5 Best Ways to Encrypt and Decrypt Data in Python

Rate this post

πŸ’‘ Problem Formulation: Secure data management is crucial for protecting sensitive information within modern applications. This article provides solutions for Python developers seeking methods to encrypt sensitive data before storing or transmitting, and subsequently decrypt it for authorized use. For instance, one may need to protect user passwords or confidential messages, requiring the data to be transformed into a secure format (encrypted) and then, when needed, reversed back to its original form (decrypted).

Method 1: Using the Fernet symmetric encryption from the cryptography library

The Fernet class from the cryptography library provides easy-to-use symmetric encryption for secure data handling. It relies on strong encryption that is difficult to break, making it suitable for many security-reliant applications.

Here’s an example:

from cryptography.fernet import Fernet

# Generation of a key
key = Fernet.generate_key()
cipher_suite = Fernet(key)

# Encryption
data = "Secret Message".encode()
cipher_text = cipher_suite.encrypt(data)

# Decryption
plain_text = cipher_suite.decrypt(cipher_text)



b'gAAAAABh6...==' # Encrypted text (will vary every time)
Secret Message        # Decrypted text

This code snippet starts by generating an encryption key. That key is then used to create a cipher_suite object which is capable of encrypting and decrypting data. The secret message is first converted to bytes, encrypted, and then decrypted back to its original form, showcasing the straightforward workflow of data encryption and decryption with Fernet.

Method 2: Utilizing PyCryptoDome’s AES for Advanced Encryption Standard process

PyCryptoDome is a self-contained Python package that brings cryptographic services to your Python application. It includes a comprehensive collection of cryptographic modules, including the Advanced Encryption Standard (AES), which is widely recognized for its strength and efficiency.

Here’s an example:

from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad

# Key and initialization vector generation
key = get_random_bytes(16)
cipher = AES.new(key, AES.MODE_CBC)
iv = cipher.iv

# Encryption
data = "Secret AES Message".encode()
cipher_text = cipher.encrypt(pad(data, AES.block_size))

# Decryption
cipher_dec = AES.new(key, AES.MODE_CBC, iv=iv)
plain_text = unpad(cipher_dec.decrypt(cipher_text), AES.block_size)



b'...' # Encrypted text (will vary every time)
Secret AES Message     # Decrypted text

This code illustrates the use of PyCryptoDome’s AES encryption. It starts by generating a random key, sets up the cipher mode, and then encrypts the padded data to ensure it fits the block size requirements of AES. Afterwards, a decryption process recovers the original message. The use of padding is an important aspect of block cipher encryption schemes for maintaining data integrity.

Method 3: Using pycryptodome’s RSA for Asymmetric Encryption

Asymmetric encryption, like RSA offered by the PyCryptoDome library, uses a pair of keys; a public key to encrypt data and a private key to decrypt it. This method is particularly useful when secure data needs to be exchanged between parties that have not pre-shared secret keys.

Here’s an example:

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Random import get_random_bytes

# Key generation
key = RSA.generate(2048)
private_key = key.export_key()
public_key = key.publickey().export_key()

cipher_pub = PKCS1_OAEP.new(RSA.import_key(public_key))

# Encryption
data = "RSA Encrypted Message".encode()
cipher_text = cipher_pub.encrypt(data)

# Decryption
cipher_priv = PKCS1_OAEP.new(RSA.import_key(private_key))
plain_text = cipher_priv.decrypt(cipher_text)



b'...' # Encrypted text (will vary every time)
RSA Encrypted Message  # Decrypted text

This example highlights how to use RSA encryption with PyCryptoDome. It demonstrates key pair generation, where the public key is used for encryption and the private key for decryption. The PKCS#1 OAEP is an optimal asymmetric encryption padding method, which enhances the security of the RSA encryption by preventing various attacks.

Method 4: Utilizing PyNaCl for Public-key Encryption

PyNaCl is a Python binding to the Networking and Cryptography (NaCl) library and provides high-level cryptographic operations. Its public-key encryption schemes are designed to be highly secure yet very user-friendly.

Here’s an example:

import nacl.utils
from nacl.public import PrivateKey, PublicKey, Box

# Key generation
sk = PrivateKey.generate()
pk = sk.public_key

receiver_sk = PrivateKey.generate()
receiver_pk = receiver_sk.public_key

# Sender encrypts message
box = Box(sk, receiver_pk)
encrypted = box.encrypt(b"NaCl Message")

# Receiver decrypts message
receiver_box = Box(receiver_sk, pk)
plaintext = receiver_box.decrypt(encrypted)



b'...' # Encrypted text (will vary everytime)
NaCl Message           # Decrypted text

This code snippet demonstrates how to use PyNaCl for public-key encryption. It includes key generation, creating a Box for each party, one for encrypting and one for decrypting messages. Known for its simplicity in API, PyNaCl makes powerful cryptography accessible to developers without extensive cryptographic knowledge.

Bonus One-Liner Method 5: Using base64 for Simple Encoding/Decoding

Although base64 is not encryption and should not be considered secure for sensitive data, it can obfuscate text and meet basic encoding needs for non-critical use-cases where security is not a concern.

Here’s an example:

import base64

# Encode
encoded_data = base64.b64encode(b'Simple base64 encode')
# Decode
decoded_data = base64.b64decode(encoded_data)



Simple base64 encode

In this snippet, Python’s built-in base64 module is used to encode and decode data. The given bytestring data is first base64 encoded then decoded back to its original state. This showcases the ease of performing basic encoding and decoding operations with base64, allowing some level of obfuscation.


  • Method 1: Using the cryptography library’s Fernet. It’s a secure and easy-to-use method, but requires the management of symmetric keys.
  • Method 2: Utilizing PyCryptoDome’s AES. It’s a robust and widely accepted standard but requires padding the data to a certain block size.
  • Method 3: Using PyCryptoDome’s RSA. It provides secure data exchange between two parties without sharing a secret key, though it can be computationally more intensive than symmetric methods.
  • Method 4: Utilizing PyNaCl for public-key encryption. It offers high security and ease-of-use, albeit with fewer options for customization.
  • Bonus Method 5: Using base64. It’s simple and quick for encoding/decoding, but should not be considered secure for any sensitive data.