Encrypt Decrypt using PyCrypto AES 256

Question

I m trying to build two functions using PyCrypto that accept two parameters  the message and the key  and then encrypt decrypt the message   I found several links on the web to help me out  but each one of them has flaws   This one at codekoala uses os urandom  which is discouraged by PyCrypto   Moreover  the key I give to the function is not guaranteed to have the exact length expected  What can I do to make that happen    Also  there are several modes  which one is recommended  I don t know what to use     Finally  what exactly is the IV  Can I provide a different IV for encrypting and decrypting  or will this return in a different result   Edit  Removed the code part since it was not secure

User · Answer

You may need the following two functions: pad- to pad(when doing encryption) and unpad- to unpad (when doing decryption) when the length of input is not a multiple of 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:])]

So you're asking the length of key? You can use the md5sum of the key rather than use it directly.

More, according to my little experience of using PyCrypto, the IV is used to mix up the output of a encryption when input is same, so the IV is chosen as a random string, and use it as part of the encryption output, and then use it to decrypt the message.

And here's my implementation, hope it will be useful for you:

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

User · Answer

Here is my implementation and works for me with some fixes and enhances the alignment of the key and secret phrase with 32 bytes and iv to 16 bytes   import base64 import hashlib from Crypto import Random from Crypto Cipher import AES  class AESCipher object        def   init   self  key            self bs   AES block size         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 encode          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

User · Answer

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

User · Answer

I have used both Crypto and PyCryptodomex library and it is blazing fast     import base64 import hashlib from Cryptodome Cipher import AES as domeAES from Cryptodome Random import get random bytes from Crypto import Random from Crypto Cipher import AES as cryptoAES  BLOCK SIZE   AES block size  key    my secret key  encode     key     hashlib sha256 key  digest   print   key     def encrypt raw       BS   cryptoAES block size     pad   lambda s  s    BS - len s    BS    chr BS - len s    BS      raw   base64 b64encode pad raw  encode  utf8        iv   get random bytes cryptoAES block size      cipher   cryptoAES new key    key    mode  cryptoAES MODE CFB iv  iv      a  base64 b64encode iv   cipher encrypt raw       IV   Random new   read BLOCK SIZE      aes   domeAES new   key    domeAES MODE CFB  IV      b   base64 b64encode IV   aes encrypt a       return b  def decrypt enc       passphrase     key       encrypted   base64 b64decode enc      IV   encrypted  BLOCK SIZE      aes   domeAES new passphrase  domeAES MODE CFB  IV      enc   aes decrypt encrypted BLOCK SIZE        unpad   lambda s  s  -ord s -1         enc   base64 b64decode enc      iv   enc  cryptoAES block size      cipher   cryptoAES new   key    cryptoAES MODE CFB  iv      b   unpad base64 b64decode cipher decrypt enc cryptoAES block size     decode  utf8        return b  encrypted data  encrypt  Hi Steven        print encrypted data  print            decrypted data   decrypt encrypted data  print decrypted data

User · Answer

Let me address your question about  modes   AES256 is a kind of block cipher  It takes as input a 32-byte key and a 16-byte string  called the block and outputs a block  We use AES in a mode of operation in order to encrypt  The solutions above suggest using CBC  which is one example  Another is called CTR  and it s somewhat easier to use   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    This is often referred to as AES-CTR  I would advise caution in using AES-CBC with PyCrypto  The reason is that it requires you to specify the padding scheme  as exemplified by the other solutions given  In general  if you re not very careful about the padding  there are attacks that completely break encryption    Now  it s important to note that the key must be a random  32-byte string  a password does not suffice  Normally  the key is generated like so     Nominal way to generate a fresh key  This calls the system s random number   generator  RNG   key1   Random new   read key bytes    A key may be derived from a password  too     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    Some solutions above suggest using SHA256 for deriving the key  but this is generally considered bad cryptographic practice  Check out wikipedia for more on modes of operation

User · Answer

Grateful for the other answers which inspired but didn t work for me   After spending hours trying to figure out how it works  I came up with the implementation below with the newest PyCryptodomex library  it is another story how I managed to set it up behind proxy  on Windows  in a virtualenv   phew   Working on your implementation  remember to write down padding  encoding  encrypting steps  and vice versa   You have to pack and unpack keeping in mind the order    import base64 import hashlib from Cryptodome Cipher import AES from Cryptodome Random import get random bytes    key     hashlib sha256 b 16-character key   digest    def encrypt raw       BS   AES block size     pad   lambda s  s    BS - len s    BS    chr BS - len s    BS       raw   base64 b64encode pad raw  encode  utf8        iv   get random bytes AES block size      cipher   AES new key    key    mode  AES MODE CFB iv  iv      return base64 b64encode iv   cipher encrypt raw    def decrypt enc       unpad   lambda s  s  -ord s -1          enc   base64 b64decode enc      iv   enc  AES block size      cipher   AES new   key    AES MODE CFB  iv      return unpad base64 b64decode cipher decrypt enc AES block size     decode  utf8

User · Answer

You can get a passphrase out of an arbitrary password by using a cryptographic hash function  NOT Python s builtin hash  like SHA-1 or SHA-256  Python includes support for both in its standard library   import hashlib  hashlib sha1  this is my awesome password   digest       gt  a 20 byte string hashlib sha256  another awesome password   digest       gt  a 32 byte string   You can truncate a cryptographic hash value just by using   16  or   24  and it will retain its security up to the length you specify

User · Answer

For someone who would like to use urlsafe b64encode and urlsafe b64decode  here are the version that re working for me  after spending some time with the unicode issue   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

User · Answer

Another take on this  heavily derived from solutions above  but   uses null for padding  does not use lambda  never been a fan  tested with python 2 7 and 3 6 5     usr bin python2 7   you ll have to adjust for your setup  e g      usr bin python3   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          raw   raw encode  utf-8           iv   Random new   read  AES block size           cipher   AES new  self key encode  utf-8    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 encode  utf-8    AES MODE CBC  iv           return re sub b  x00     b    cipher decrypt  enc 16     decode  utf-8

User · Answer

It s little late but i think this will be very helpful  No one mention about use  scheme like PKCS 7 padding  You can use it instead the previous functions to pad when do encryption  and unpad when do decryption  i will provide the full Source Code below   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  gt  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

User · Answer

For the benefit of others  here is my decryption implementation which I got to by combining the answers of  Cyril and  Marcus   This assumes that this coming in via HTTP Request with the encryptedText quoted and base64 encoded   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

User · Answer

https   stackoverflow com a 21928790 11402877   compatible utf-8 encoding  def  pad self  s       s   s encode       res   s    self bs - len s    self bs    chr self bs - len s    self bs  encode       return res

[python] Encrypt & Decrypt using PyCrypto AES 256

Examples related to python

Examples related to encryption

Examples related to padding

Examples related to pycrypto

Examples related to initialization-vector