python पीईक्रिप्टो एईएस 256 का उपयोग करके एन्क्रिप्ट और डिक्रिप्ट करें




encryption padding (8)

आप क्रिप्टोग्राफिक हैश फ़ंक्शन (पायथन के बिल्टिन hash ) जैसे SHA-1 या SHA-256 का उपयोग करके मनमाने ढंग से पासवर्ड से पासफ्रेज प्राप्त कर सकते हैं। पायथन में मानक पुस्तकालय दोनों के लिए समर्थन शामिल है:

import hashlib

hashlib.sha1("this is my awesome password").digest() # => a 20 byte string
hashlib.sha256("another awesome password").digest() # => a 32 byte string

आप केवल [:16] या [:24] का उपयोग कर क्रिप्टोग्राफ़िक हैश मान को छोटा कर सकते हैं और यह आपके द्वारा निर्दिष्ट लंबाई तक इसकी सुरक्षा बनाए रखेगा।

मैं PyCrypto का उपयोग करके दो फ़ंक्शंस बनाने की कोशिश कर रहा हूं जो दो पैरामीटर स्वीकार करते हैं: संदेश और कुंजी, और फिर संदेश को एन्क्रिप्ट / डिक्रिप्ट करें।

मुझे मदद करने के लिए वेब पर कई लिंक मिले, लेकिन उनमें से प्रत्येक में त्रुटियां हैं:

कोडेकोला में यह एक os.urandom का उपयोग करता है, जो PyCrypto द्वारा निराश है।

इसके अलावा, मैं जिस कुंजी को फ़ंक्शन को देता हूं उसे सटीक लंबाई की अपेक्षा रखने की गारंटी नहीं है। ऐसा करने के लिए मैं क्या कर सकता हूं?

इसके अलावा, कई तरीके हैं, जिनकी सिफारिश की जाती है? मुझे नहीं पता कि क्या उपयोग करना है: /

अंत में, चतुर्थ क्या है? क्या मैं एन्क्रिप्टिंग और डिक्रिप्टिंग के लिए एक अलग IV प्रदान कर सकता हूं, या यह एक अलग परिणाम में वापस आ जाएगा?

यहां तक ​​कि मैंने अभी तक क्या किया है:

from Crypto import Random
from Crypto.Cipher import AES
import base64

BLOCK_SIZE=32

def encrypt(message, passphrase):
    # passphrase MUST be 16, 24 or 32 bytes long, how can I do that ?
    IV = Random.new().read(BLOCK_SIZE)
    aes = AES.new(passphrase, AES.MODE_CFB, IV)
    return base64.b64encode(aes.encrypt(message))

def decrypt(encrypted, passphrase):
    IV = Random.new().read(BLOCK_SIZE)
    aes = AES.new(passphrase, AES.MODE_CFB, IV)
    return aes.decrypt(base64.b64decode(encrypted))

यह बहुत देर हो चुकी है लेकिन मुझे लगता है कि यह बहुत उपयोगी होगा। पीकेसीएस # 7 पैडिंग जैसी उपयोग योजना के बारे में कोई भी उल्लेख नहीं करता है। आप इसके बजाय पिछले कार्यों को पैड (जब एन्क्रिप्शन करते हैं) और अनपैड (डिक्रिप्शन करते समय) का उपयोग कर सकते हैं। मैं नीचे पूर्ण स्रोत कोड प्रदान करूंगा।

import base64
import hashlib
from Crypto import Random
from Crypto.Cipher import AES
import pkcs7
class Encryption:

    def __init__(self):
        pass

    def Encrypt(self, PlainText, SecurePassword):
        pw_encode = SecurePassword.encode('utf-8')
        text_encode = PlainText.encode('utf-8')

        key = hashlib.sha256(pw_encode).digest()
        iv = Random.new().read(AES.block_size)

        cipher = AES.new(key, AES.MODE_CBC, iv)
        pad_text = pkcs7.encode(text_encode)
        msg = iv + cipher.encrypt(pad_text)

        EncodeMsg = base64.b64encode(msg)
        return EncodeMsg

    def Decrypt(self, Encrypted, SecurePassword):
        decodbase64 = base64.b64decode(Encrypted.decode("utf-8"))
        pw_encode = SecurePassword.decode('utf-8')

        iv = decodbase64[:AES.block_size]
        key = hashlib.sha256(pw_encode).digest()

        cipher = AES.new(key, AES.MODE_CBC, iv)
        msg = cipher.decrypt(decodbase64[AES.block_size:])
        pad_text = pkcs7.decode(msg)

        decryptedString = pad_text.decode('utf-8')
        return decryptedString

import StringIO
import binascii


def decode(text, k=16):
    nl = len(text)
    val = int(binascii.hexlify(text[-1]), 16)
    if val > k:
        raise ValueError('Input is not padded or padding is corrupt')

    l = nl - val
    return text[:l]


def encode(text, k=16):
    l = len(text)
    output = StringIO.StringIO()
    val = k - (l % k)
    for _ in xrange(val):
        output.write('%02x' % val)
    return text + binascii.unhexlify(output.getvalue())


एक और इस पर ले लो (भारी उपरोक्त समाधान से व्युत्पन्न) लेकिन

  • पैडिंग के लिए शून्य का उपयोग करता है
  • लैम्ब्डा का उपयोग नहीं करता (कभी प्रशंसक नहीं रहा)

    #!/usr/bin/env python
    
    import base64, re
    from Crypto.Cipher import AES
    from Crypto import Random
    from django.conf import settings
    
    class AESCipher:
        """
          Usage:
          aes = AESCipher( settings.SECRET_KEY[:16], 32)
          encryp_msg = aes.encrypt( 'ppppppppppppppppppppppppppppppppppppppppppppppppppppppp' )
          msg = aes.decrypt( encryp_msg )
          print("'{}'".format(msg))
        """
        def __init__(self, key, blk_sz):
            self.key = key
            self.blk_sz = blk_sz
    
        def encrypt( self, raw ):
            if raw is None or len(raw) == 0:
                raise NameError("No value given to encrypt")
            raw = raw + '\0' * (self.blk_sz - len(raw) % self.blk_sz)
            iv = Random.new().read( AES.block_size )
            cipher = AES.new( self.key, AES.MODE_CBC, iv )
            return base64.b64encode( iv + cipher.encrypt( raw ) ).decode('utf-8')
    
        def decrypt( self, enc ):
            if enc is None or len(enc) == 0:
                raise NameError("No value given to decrypt")
            enc = base64.b64decode(enc)
            iv = enc[:16]
            cipher = AES.new(self.key, AES.MODE_CBC, iv )
            return re.sub(b'\x00*$', b'', cipher.decrypt( enc[16:])).decode('utf-8')
    

दूसरों के लाभ के लिए, यहां मेरा डिक्रिप्शन कार्यान्वयन है जो मुझे @ कैरिल और @ मर्कस के उत्तरों के संयोजन से मिला है। यह मानता है कि यह HTTP अनुरोध के माध्यम से एन्क्रिप्टेड टेक्स्ट उद्धृत और बेस 64 एन्कोडेड के साथ आ रहा है।

import base64
import urllib2
from Crypto.Cipher import AES


def decrypt(quotedEncodedEncrypted):
    key = 'SecretKey'

    encodedEncrypted = urllib2.unquote(quotedEncodedEncrypted)

    cipher = AES.new(key)
    decrypted = cipher.decrypt(base64.b64decode(encodedEncrypted))[:16]

    for i in range(1, len(base64.b64decode(encodedEncrypted))/16):
        cipher = AES.new(key, AES.MODE_CBC, base64.b64decode(encodedEncrypted)[(i-1)*16:i*16])
        decrypted += cipher.decrypt(base64.b64decode(encodedEncrypted)[i*16:])[:16]

    return decrypted.strip()

किसी ऐसे व्यक्ति के लिए जो urlsafe_b64encode और urlsafe_b64decode का उपयोग करना चाहेगा, यहां वह संस्करण है जो मेरे लिए काम कर रहा है (यूनिकोड समस्या के साथ कुछ समय बिताने के बाद)

BS = 16
key = hashlib.md5(settings.SECRET_KEY).hexdigest()[:BS]
pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS)
unpad = lambda s : s[:-ord(s[len(s)-1:])]

class AESCipher:
    def __init__(self, key):
        self.key = key

    def encrypt(self, raw):
        raw = pad(raw)
        iv = Random.new().read(AES.block_size)
        cipher = AES.new(self.key, AES.MODE_CBC, iv)
        return base64.urlsafe_b64encode(iv + cipher.encrypt(raw)) 

    def decrypt(self, enc):
        enc = base64.urlsafe_b64decode(enc.encode('utf-8'))
        iv = enc[:BS]
        cipher = AES.new(self.key, AES.MODE_CBC, iv)
        return unpad(cipher.decrypt(enc[BS:]))

मुझे अपने प्रश्नों को "मोड" के बारे में बताएं। एईएस 256 एक प्रकार का ब्लॉक सिफर है । यह 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)

इसे अक्सर एईएस-सीटीआर के रूप में जाना जाता है। मैं पीईक्रिप्टो के साथ एईएस-सीबीसी का उपयोग करने में सावधानी बरतता हूं । इसका कारण यह है कि आपको पैडिंग योजना निर्दिष्ट करने की आवश्यकता है, जैसा कि दिए गए अन्य समाधानों के उदाहरण के रूप में है। आम तौर पर, यदि आप पैडिंग के बारे में बहुत सावधान नहीं हैं, तो ऐसे attacks जो पूरी तरह से एन्क्रिप्शन तोड़ते हैं!

अब, यह ध्यान रखना महत्वपूर्ण है कि कुंजी एक यादृच्छिक, 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 का उपयोग करने का सुझाव देते हैं, लेकिन इसे आम तौर पर खराब क्रिप्टोग्राफिक अभ्यास माना जाता है। ऑपरेशन के तरीके पर अधिक के लिए wikipedia देखें।


इनपुट की लंबाई BLOCK_SIZE के एकाधिक नहीं होने पर आपको पैड के लिए निम्न दो फ़ंक्शंस (एन्क्रिप्शन कब करें) और अनपैड (डिक्रिप्शन करते समय) की आवश्यकता हो सकती है।

BS = 16
pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS) 
unpad = lambda s : s[:-ord(s[len(s)-1:])]

तो आप कुंजी की लंबाई पूछ रहे हैं? आप सीधे इसका उपयोग करने के बजाय कुंजी के md5sum का उपयोग कर सकते हैं।

अधिक, PyCrypto का उपयोग करने के अपने छोटे अनुभव के अनुसार, IV का उपयोग इनपुट के समान होने पर एन्क्रिप्शन के आउटपुट को मिश्रित करने के लिए किया जाता है, इसलिए IV को यादृच्छिक स्ट्रिंग के रूप में चुना जाता है, और फिर इसे एन्क्रिप्शन आउटपुट के हिस्से के रूप में उपयोग किया जाता है, और फिर संदेश को डिक्रिप्ट करने के लिए इसका इस्तेमाल करें।

और यहां मेरा कार्यान्वयन है, उम्मीद है कि यह आपके लिए उपयोगी होगा:

import base64
from Crypto.Cipher import AES
from Crypto import Random

class AESCipher:
    def __init__( self, key ):
        self.key = key

    def encrypt( self, raw ):
        raw = pad(raw)
        iv = Random.new().read( AES.block_size )
        cipher = AES.new( self.key, AES.MODE_CBC, iv )
        return base64.b64encode( iv + cipher.encrypt( raw ) ) 

    def decrypt( self, enc ):
        enc = base64.b64decode(enc)
        iv = enc[:16]
        cipher = AES.new(self.key, AES.MODE_CBC, iv )
        return unpad(cipher.decrypt( enc[16:] ))

from Crypto import Random
from Crypto.Cipher import AES
import base64

BLOCK_SIZE=16
def trans(key):
     return md5.new(key).digest()

def encrypt(message, passphrase):
    passphrase = trans(passphrase)
    IV = Random.new().read(BLOCK_SIZE)
    aes = AES.new(passphrase, AES.MODE_CFB, IV)
    return base64.b64encode(IV + aes.encrypt(message))

def decrypt(encrypted, passphrase):
    passphrase = trans(passphrase)
    encrypted = base64.b64decode(encrypted)
    IV = encrypted[:BLOCK_SIZE]
    aes = AES.new(passphrase, AES.MODE_CFB, IV)
    return aes.decrypt(encrypted[BLOCK_SIZE:])




initialization-vector