मुझे आपके प्रश्नों को "मोड" के बारे में बताएं। AES256 एक प्रकार का ब्लॉक सिफर है । यह एक 32-बाइट कुंजी और 16-बाइट स्ट्रिंग के रूप में इनपुट लेता है , जिसे ब्लॉक कहा जाता है और ब्लॉक को आउटपुट करता है। एन्क्रिप्ट करने के लिए हम एईएस का उपयोग एक मोड में करते हैं । उपरोक्त समाधान सीबीसी का उपयोग करने का सुझाव देते हैं, जो एक उदाहरण है। दूसरे को सीटीआर कहा जाता है, और इसका उपयोग करना कुछ आसान है:
from Crypto.Cipher import AES
from Crypto.Util import Counter
from Crypto import Random
# AES supports multiple key sizes: 16 (AES128), 24 (AES192), or 32 (AES256).
key_bytes = 32
# Takes as input a 32-byte key and an arbitrary-length plaintext and returns a
# pair (iv, ciphtertext). "iv" stands for initialization vector.
def encrypt(key, plaintext):
assert len(key) == key_bytes
# Choose a random, 16-byte IV.
iv = Random.new().read(AES.block_size)
# Convert the IV to a Python integer.
iv_int = int(binascii.hexlify(iv), 16)
# Create a new Counter object with IV = iv_int.
ctr = Counter.new(AES.block_size * 8, initial_value=iv_int)
# Create AES-CTR cipher.
aes = AES.new(key, AES.MODE_CTR, counter=ctr)
# Encrypt and return IV and ciphertext.
ciphertext = aes.encrypt(plaintext)
return (iv, ciphertext)
# Takes as input a 32-byte key, a 16-byte IV, and a ciphertext, and outputs the
# corresponding plaintext.
def decrypt(key, iv, ciphertext):
assert len(key) == key_bytes
# Initialize counter for decryption. iv should be the same as the output of
# encrypt().
iv_int = int(iv.encode('hex'), 16)
ctr = Counter.new(AES.block_size * 8, initial_value=iv_int)
# Create AES-CTR cipher.
aes = AES.new(key, AES.MODE_CTR, counter=ctr)
# Decrypt and return the plaintext.
plaintext = aes.decrypt(ciphertext)
return plaintext
(iv, ciphertext) = encrypt(key, 'hella')
print decrypt(key, iv, ciphertext)
इसे अक्सर एईएस-सीटीआर के रूप में जाना जाता है। मैं PyCrypto के साथ AES-CBC का उपयोग करने में सावधानी बरतने की सलाह दूंगा । कारण यह है कि आपको पेडिंग स्कीम को निर्दिष्ट करने की आवश्यकता है , जैसा कि अन्य समाधानों के अनुसार दिया गया है। सामान्य तौर पर, यदि आप पैडिंग के बारे में बहुत सावधान नहीं हैं , तो ऐसे हमले हैं जो एन्क्रिप्शन को पूरी तरह से तोड़ देते हैं!
अब, यह नोट करना महत्वपूर्ण है कि कुंजी एक यादृच्छिक, 32-बाइट स्ट्रिंग होनी चाहिए ; एक पासवर्ड पर्याप्त नहीं है। आम तौर पर, कुंजी इस तरह उत्पन्न होती है:
# Nominal way to generate a fresh key. This calls the system's random number
# generator (RNG).
key1 = Random.new().read(key_bytes)
एक कुंजी पासवर्ड से भी निकाली जा सकती है :
# It's also possible to derive a key from a password, but it's important that
# the password have high entropy, meaning difficult to predict.
password = "This is a rather weak password."
# For added # security, we add a "salt", which increases the entropy.
#
# In this example, we use the same RNG to produce the salt that we used to
# produce key1.
salt_bytes = 8
salt = Random.new().read(salt_bytes)
# Stands for "Password-based key derivation function 2"
key2 = PBKDF2(password, salt, key_bytes)
ऊपर दिए गए कुछ समाधान SHA256 को कुंजी को प्राप्त करने के लिए उपयोग करने का सुझाव देते हैं, लेकिन इसे आमतौर पर बुरा क्रिप्टोग्राफिक अभ्यास माना जाता है । ऑपरेशन के तरीकों पर अधिक जानकारी के लिए विकिपीडिया देखें ।