加密和解密使用PyCrypto AES 256

Question

我試圖建立兩個函數使用PyCrypto接受兩個參數：消息和密鑰，然後加密/解密消息。

我在網上找到了幾個環節，以幫助我，但他們每個人都有缺點：

This one at codekoala使用os.urandom，這是由PyCrypto氣餒。

此外，我給函數的關鍵不能保證具有預期的確切長度。我該怎麼做才能做到這一點？

此外，還有幾種模式，推薦哪一種？我不知道該用什麼：/

最後，到底什麼是IV？我可以提供不同的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)) 

Answer 1

這裏是我的實現，並與一些修復工作對我來說並增強了與32個字節和IV的密鑰和密碼短語的對齊方式爲16個字節：

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

class AESCipher(object): 

    def __init__(self, key): 
     self.bs = 32 
     self.key = hashlib.sha256(key.encode()).digest() 

    def encrypt(self, raw): 
     raw = self._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[:AES.block_size] 
     cipher = AES.new(self.key, AES.MODE_CBC, iv) 
     return self._unpad(cipher.decrypt(enc[AES.block_size:])).decode('utf-8') 

    def _pad(self, s): 
     return s + (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs) 

    @staticmethod 
    def _unpad(s): 
     return s[:-ord(s[len(s)-1:])] 

Answer 2

您可以通過使用密碼散列函數（不 Python的內置hash），如SHA-1或SHA得到一個密碼出任意密碼-256。 Python的包括其標準庫均支持：

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]，它會保留其安全性達到您所指定的長度。

Answer 3

當輸入的長度不是BLOCK_SIZE的倍數時，您可能需要以下兩個函數來填充（何時進行加密）和unpad（何時進行解密）。

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:])) 

Answer 4

爲他人謀取利益，這裏是我的解密實現，我結合@Cyril和@Marcus的答案得。這假定這是通過HTTP Request與加密文本引用和base64編碼進來的。

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() 

Answer 5

對於有人誰願意使用urlsafe_b64encode和urlsafe_b64decode，這裏的版本that're工作對我來說（花一些時間與Unicode的問題後）

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:])) 

Answer 6

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:]) 

Answer 7

這有點晚，但我認爲這會非常有幫助。沒有人提到像PKCS＃7填充這樣的使用方案。你可以使用它代替之前的函數來填充（何時進行加密）和unpad（何時解密）.i將在下面提供完整的源代碼。

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()) 

Answer 8

另取這個（在很大程度上借鑑的解決方案衍生以上），但

• 用於填充使用空

• 不使用拉姆達（從不一直是粉絲）

  #!/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') 
  

Answer 9

讓我解決你的問題 「的模式。」 AES256是一種分組密碼。它需要輸入一個32字節的密鑰和一個16字節的字符串，稱爲塊並輸出一個塊。爲了加密，我們在操作模式中使用AES。上面的解決方案建議使用CBC，這是一個例子。另一個稱爲CTR，它使用起來有些簡單：

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) 

這通常被稱爲AES-CTR。 我建議在使用AES-CBC和PyCrypto時慎用。原因是它要求您指定填充方案，如其他解決方案所示。一般來說，如果你不是很細心的填充，還有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推導的關鍵，但這是一般認爲是bad cryptographic practice。 查看wikipedia瞭解更多關於操作模式的信息。