{"id":2019,"date":"2020-05-09T22:35:09","date_gmt":"2020-05-09T14:35:09","guid":{"rendered":"https:\/\/www.techcoil.com\/blog\/?p=2019"},"modified":"2020-05-12T14:21:53","modified_gmt":"2020-05-12T06:21:53","slug":"how-to-encrypt-and-decrypt-data-in-python-3-using-pycrypto","status":"publish","type":"post","link":"https:\/\/www.techcoil.com\/blog\/how-to-encrypt-and-decrypt-data-in-python-3-using-pycrypto\/","title":{"rendered":"How to encrypt and decrypt data in Python 3 using pycrypto"},"content":{"rendered":"

When you wish to encrypt and decrypt data in your Python 3 application, you can take a look at pycrypto<\/a>. <\/p>\n

Given that, let us look at how we can encrypt and decrypt data in Python 3 using pycrpto.<\/p>\n

Installing pycrypto into your Python 3 environment<\/h2>\n

In order to use pycrypto, we need to install it. <\/p>\n

Therefore, run the following command to install pycrypto into your Python 3 environment:<\/p>\n

\r\npip pycrypto\r\n<\/pre>\n
Getting an instance of the AES to encrypt and decrypt data with the AES encryption algorithm<\/h2>\n
After you had installed pycrypto in your Python 3 environment, you can then choose an encryption algorithm to encrypt and decrypt your data.<\/p>\n
For example, you can write the following Python 3 codes to get an object to encrypt \/ decrypt data with the AES encryption algorithm:<\/p>\n
\r\nfrom Crypto.Cipher import AES\r\n\r\n# AES key must be either 16, 24, or 32 bytes long\r\nCOMMON_ENCRYPTION_KEY='asdjk@15r32r1234asdsaeqwe314SEFT'\r\n# Make sure the initialization vector is 16 bytes\r\nCOMMON_16_BYTE_IV_FOR_AES='IVIVIVIVIVIVIVIV'\r\n\r\ndef get_common_cipher():\r\n    return AES.new(COMMON_ENCRYPTION_KEY,\r\n                   AES.MODE_CBC,\r\n                   COMMON_16_BYTE_IV_FOR_AES)\r\n<\/pre>\n
As shown above, we first import the AES module<\/a>. After we had done so, we define an encryption key that is 32 bytes long. In case you are wondering, this key must be either 16, 24 or 32 bytes long. <\/p>\n
After that, we define an initialization vector that must be 16 bytes long.<\/p>\n
Once we have defined the key and initialization vector, we then define a function to get an AES cipher instance. <\/p>\n
Whenever we need to perform encryption or decryption, we can use the get_common_cipher<\/code> function. <\/p>\n
Since the cipher object is stateful, we should create a new AES cipher instance whenever we wish to encrypt or decrypt data<\/strong>. <\/p>\n
How to encrypt string in Python 3 using pycrypto<\/h2>\n
When we represent our data as string or text, we can transfer our data easily with HTTP<\/a>.<\/p>\n
Given that, let's look at how we can define a function to encrypt string:<\/p>\n
\r\nimport base64\r\nimport math\r\ndef encrypt_with_common_cipher(cleartext):\r\n    common_cipher = get_common_cipher()\r\n    cleartext_length = len(cleartext)\r\n    next_multiple_of_16 = 16 * math.ceil(cleartext_length\/16)\r\n    padded_cleartext = cleartext.rjust(next_multiple_of_16)\r\n    raw_ciphertext = common_cipher.encrypt(padded_cleartext)\r\n    return base64.b64encode(raw_ciphertext).decode('utf-8')\r\n<\/pre>\n
As shown above, we first import the base64<\/code><\/a> and math<\/code><\/a> modules.<\/p>\n
Once we have done so, we define a function encrypt_with_common_cipher<\/code> that takes a string as an input.<\/p>\n
When the function is called, we first get an instance of the AES cipher to perform the encryption.<\/p>\n
Since the cipher does not pad our data, we need to do that on our own. Therefore, we first get the length of the text data to compute the next multiple of 16. Once we get the next multiple of 16, we use the rjust<\/code><\/a> method to pad the cleartext<\/code> with spaces. <\/p>\n
Once we had padded our string data to make its size a multiple of 16, we then encrypt it with the AES cipher. When we do so, raw_ciphertext<\/strong> will contain the corresponding cipher text in bytes. <\/p>\n
In order to convert the raw_ciphertext<\/code> to a string, we call base64.b64encode<\/code><\/a> on raw_ciphertext<\/code>, followed by decode<\/code><\/a> before returning the result to the caller.<\/p>\n
How to decrypt string in Python 3 using pycrypto <\/h2>\n
Whenever we encrypt our string data, there will be a point in time when we want to decrypt it.<\/p>\n
Given that, we can define a function to decrypt the cipher text that was created by encrypt_with_common_cipher<\/code>:<\/p>\n
\r\ndef decrypt_with_common_cipher(ciphertext):\r\n    common_cipher = get_common_cipher()\r\n    raw_ciphertext = base64.b64decode(ciphertext)\r\n    decrypted_message_with_padding = common_cipher.decrypt(raw_ciphertext)\r\n    return decrypted_message_with_padding.decode('utf-8').strip()\r\n<\/pre>\n
Similar to encrypt_with_common_cipher<\/code>, we first get an instance of the AES cipher with the same key and initialization vector.<\/p>\n
Next, we take the ciphertext<\/code>, convert it back to bytes and kept it as raw_ciphertext<\/code>.<\/p>\n
Once we get back the cipher text in bytes, we use our AES cipher to decrypt it. <\/p>\n
When we do so, we will get the decrypted message with padding.<\/p>\n
Finally, we decode decrypted_message_with_padding<\/code> as a string, call strip<\/code><\/a> to remove the spaces and return the result to the caller.<\/p>\n
How to encrypt JSON data in Python 3 using pycrypto<\/h2>\n
At this point in time, encrypting JSON data will be straightforward:<\/p>\n
\r\nimport json\r\ndef encrypt_json_with_common_cipher(json_obj):\r\n    json_string = json.dumps(json_obj)\r\n    return encrypt_with_common_cipher(json_string)\r\n<\/pre>\n
As shown above, we can define a encrypt_json_with_common_cipher<\/code> function that takes a JSON object as input.<\/p>\n
When the function is called, we use json.dumps<\/code><\/a> to convert the JSON object into a JSON string.<\/p>\n
Once we have the JSON string, we pass it to the encrypt_with_common_cipher<\/code> function and return the result back to the caller.<\/p>\n
How to decrypt JSON data in Python 3 using pycrypto<\/h2>\n
When we want to get back the JSON data that we had encrypted, we can define the following function:<\/p>\n
\r\nimport json\r\ndef decrypt_json_with_common_cipher(json_ciphertext):\r\n    json_string = decrypt_with_common_cipher(json_ciphertext)\r\n    return json.loads(json_string)\r\n<\/pre>\n
As shown above, the decrypt_json_with_common_cipher<\/code> function takes in a JSON cipher text as an input.<\/p>\n
When the function is called, we call the decrypt_with_common_cipher function to get back the JSON string.<\/p>\n
Once we have the JSON string, we use json.loads<\/code><\/a> to get back the JSON object and return it back to the caller.<\/p>\n
Putting everything together<\/h2>\n
In case you want a running example of what was discussed, you can run the following script:<\/p>\n
\r\nfrom Crypto.Cipher import AES\r\n\r\nimport base64, json, math\r\n\r\n# AES key must be either 16, 24, or 32 bytes long\r\nCOMMON_ENCRYPTION_KEY='asdjk@15r32r1234asdsaeqwe314SEFT'\r\n# Make sure the initialization vector is 16 bytes\r\nCOMMON_16_BYTE_IV_FOR_AES='IVIVIVIVIVIVIVIV'\r\n\r\ndef get_common_cipher():\r\n    return AES.new(COMMON_ENCRYPTION_KEY,\r\n                   AES.MODE_CBC,\r\n                   COMMON_16_BYTE_IV_FOR_AES)\r\n\r\ndef encrypt_with_common_cipher(cleartext):\r\n    common_cipher = get_common_cipher()\r\n    cleartext_length = len(cleartext)\r\n    nearest_multiple_of_16 = 16 * math.ceil(cleartext_length\/16)\r\n    padded_cleartext = cleartext.rjust(nearest_multiple_of_16)\r\n    raw_ciphertext = common_cipher.encrypt(padded_cleartext)\r\n    return base64.b64encode(raw_ciphertext).decode('utf-8')\r\n\r\n\r\ndef decrypt_with_common_cipher(ciphertext):\r\n    common_cipher = get_common_cipher()\r\n    raw_ciphertext = base64.b64decode(ciphertext)\r\n    decrypted_message_with_padding = common_cipher.decrypt(raw_ciphertext)\r\n    return decrypted_message_with_padding.decode('utf-8').strip()\r\n\r\n\r\ndef encrypt_json_with_common_cipher(json_obj):\r\n    json_string = json.dumps(json_obj)\r\n    return encrypt_with_common_cipher(json_string)\r\n\r\n\r\ndef decrypt_json_with_common_cipher(json_ciphertext):\r\n    json_string = decrypt_with_common_cipher(json_ciphertext)\r\n    return json.loads(json_string)\r\n\r\nmessage = 'This is obviously a secret message.'\r\n\r\nciphertext = encrypt_with_common_cipher(message)\r\nprint('Cipher text: %s' % ciphertext)\r\n\r\ndecrypted_message = decrypt_with_common_cipher(ciphertext)\r\nprint('Decrypted message: %s' % decrypted_message)\r\n\r\njson_obj = {\r\n    'fruits': ['apple', 'pear', 'orange']\r\n}\r\n\r\njson_ciphertext = encrypt_json_with_common_cipher(json_obj)\r\nprint('JSON cipher text: ')\r\nprint(json_ciphertext)\r\n\r\ndecryped_json_obj = decrypt_json_with_common_cipher(json_ciphertext)\r\nprint('Decrypted JSON object: ')\r\nprint(decryped_json_obj)\r\n<\/pre>\n
After the function definition for decrypt_json_with_common_cipher<\/code>, we proceeded to encrypt and decrypt a string and a JSON object.<\/p>\n
When you run the script, you should get the following output:<\/p>\n
\r\nCipher text: Qq3sD\/JX0M2Uo5anotgnBhZvyM\/KHGWc\/Eaoin1ocnoTrPNSZpKUUKtTuzW+ocJs\r\nDecrypted message: This is obviously a secret message.\r\nJSON cipher text: \r\nTj\/KLrTiFQfUJtQOe9FuUkHoMI4BKxjQAtrPyAYxGpDrlOvtcLIUKhVmRhloqNdm\r\nDecrypted JSON object: \r\n{'fruits': ['apple', 'pear', 'orange']}\r\n<\/pre>\n\n