cryptography

Common errors

Warnings

Install

Install compatibility verified last tested: 2026-05-12

Imports

• Fernet

  from cryptography.fernet import Fernet

  High-level authenticated symmetric encryption; preferred over raw hazmat APIs for most use cases

• Cipher, algorithms, modes
  wrong

  from cryptography.hazmat.backends import default_backend; Cipher(..., backend=default_backend())

  correct

  from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes

  The `backend` parameter was removed in 3.x; passing `default_backend()` to Cipher() raises TypeError on modern versions

• AESGCM (AEAD shortcut)

  from cryptography.hazmat.primitives.ciphers.aead import AESGCM

  Simpler authenticated encryption API; handles IV/tag automatically compared to the Cipher+GCM mode pattern

• rsa.generate_private_key
  wrong

  rsa.generate_private_key(65537, 2048, backend=default_backend())

  correct

  from cryptography.hazmat.primitives.asymmetric import rsa

  The `backend` keyword argument was removed; call without it: rsa.generate_private_key(public_exponent=65537, key_size=2048)

• padding (asymmetric)

  from cryptography.hazmat.primitives.asymmetric import padding

  Use padding.OAEP for RSA encryption and padding.PSS for RSA signatures; PKCS1v15 is legacy only

• hashes

  from cryptography.hazmat.primitives import hashes

  Used with asymmetric sign/verify and HMAC; e.g. hashes.SHA256()

• serialization

  from cryptography.hazmat.primitives import serialization

  For loading/serializing PEM/DER keys; use serialization.load_pem_private_key(), not legacy OpenSSL backend helpers

• x509

  from cryptography import x509

  X.509 certificate parsing and building; use x509.load_pem_x509_certificate()

Quickstart verified last tested: 2026-04-23

Fernet high-level symmetric encryption (recommended starting point) plus AES-GCM via hazmat for authenticated low-level encryption.

# --- High-level: Fernet (recommended for most use cases) ---
from cryptography.fernet import Fernet

key = Fernet.generate_key()          # Must be stored securely; bytes
f = Fernet(key)
token = f.encrypt(b"secret message")  # Returns URL-safe base64 token
plaintext = f.decrypt(token)          # Raises InvalidToken if tampered
assert plaintext == b"secret message"

# --- Low-level: AES-GCM via hazmat (authenticated encryption) ---
import os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

aes_key = AESGCM.generate_key(bit_length=256)  # 32 random bytes
aesgcm = AESGCM(aes_key)
nonce = os.urandom(12)               # 96-bit nonce; NEVER reuse with same key
ciphertext = aesgcm.encrypt(nonce, b"secret data", b"optional AAD")
decrypted = aesgcm.decrypt(nonce, ciphertext, b"optional AAD")
assert decrypted == b"secret data"

# --- RSA key generation & sign/verify ---
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes

private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
public_key = private_key.public_key()
message = b"message to sign"
signature = private_key.sign(
    message,
    padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH),
    hashes.SHA256()
)
public_key.verify(
    signature, message,
    padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH),
    hashes.SHA256()
)  # Raises InvalidSignature if verification fails
print("All operations succeeded")