Encriptação e desencriptação AES-GCM em Python
Implemente encriptação autenticada com gerenciamento adequado de nonces.
Encriptação e desencriptação AES-GCM em Python é uma aula grátis de Cryptology Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Cryptology Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Cryptology Academy inclui 4 aulas no total.
Por que AES-GCM?
AES-GCM é um esquema de Criptografia autenticada com dados associados (AEAD). Ele fornece confidencialidade (AES-CTR) e integridade/autenticidade (MAC GHASH) em uma única passagem — o padrão da criptografia moderna.
Componentes do GCM: CTR + GHASH
AES-GCM = AES no modo Contador (criptografia) + MAC polinomial GHASH (autenticação). A tag de autenticação de 128 bits abrange tanto o texto cifrado quanto os Dados Adicionais Autenticados (AAD) opcionais.
Requisitos dos nonces
O nonce de 96 bits nunca deve ser reutilizado com a mesma chave. A reutilização do nonce compromete completamente o GCM — um invasor recupera a chave de autenticação e pode forjar textos cifrados. Use nonces aleatórios ou um contador com rotação de chaves.
Criptografia com AES-GCM em Python
Usando a camada hazmat:
import os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
# Generate a 256-bit key
key = AESGCM.generate_key(bit_length=256)
aesgcm = AESGCM(key)
# Fresh 96-bit nonce per encryption
nonce = os.urandom(12)
plaintext = b"sensitive payload"
aad = b"user_id=42" # authenticated but not encrypted
ciphertext = aesgcm.encrypt(nonce, plaintext, aad)
print("Nonce:", nonce.hex())
print("Ciphertext+tag:", ciphertext.hex())Descriptografia com AES-GCM em Python
A descriptografia verifica a tag automaticamente; gera InvalidTag em caso de falha:
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.exceptions import InvalidTag
# key, nonce, ciphertext, aad from previous step
try:
recovered = aesgcm.decrypt(nonce, ciphertext, aad)
print("Decrypted:", recovered)
except InvalidTag:
print("Authentication failed — ciphertext tampered!")Armazenamento de nonce + texto cifrado
Prependa o nonce ao texto cifrado antes do armazenamento. Durante a descriptografia, divida no byte 12:
def encrypt_blob(key: bytes, data: bytes, aad: bytes = b"") -> bytes:
aesgcm = AESGCM(key)
nonce = os.urandom(12)
ct = aesgcm.encrypt(nonce, data, aad or None)
return nonce + ct # prepend nonce
def decrypt_blob(key: bytes, blob: bytes, aad: bytes = b"") -> bytes:
aesgcm = AESGCM(key)
nonce, ct = blob[:12], blob[12:]
return aesgcm.decrypt(nonce, ct, aad or None)Dados Adicionais Autenticados (AAD)
Os AAD são autenticados, mas não são criptografados. Use-os para vincular o texto cifrado ao contexto: ID do usuário, ID do registro, versão da API. Isso impede que um invasor mova um texto cifrado válido para um contexto diferente.
Uso da API de cifra de baixo nível
Para criptografia em fluxo ou no próprio local, use a API de cifra diretamente com o modo GCM:
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
key = os.urandom(32)
nonce = os.urandom(12)
cipher = Cipher(algorithms.AES(key), modes.GCM(nonce))
encryptor = cipher.encryptor()
encryptor.authenticate_additional_data(b"aad-value")
ct = encryptor.update(b"hello world") + encryptor.finalize()
tag = encryptor.tag
print("Tag:", tag.hex())Resistência ao uso indevido de nonces: AES-GCM-SIV
AES-GCM-SIV (RFC 8452) é resistente ao uso indevido de nonces: a reutilização do nonce revela que dois textos simples são idênticos, mas NÃO compromete a autenticidade. Prefira-o quando for difícil garantir a exclusividade dos nonces.
Derivação de chaves antes da criptografia
Nunca use uma senha bruta como chave AES. Derive uma chave com Argon2 ou HKDF:
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives import hashes
import os
master_secret = b"shared_secret_from_ECDH"
salt = os.urandom(16)
kdf = HKDF(algorithm=hashes.SHA256(), length=32, salt=salt, info=b"aes-gcm-key")
aes_key = kdf.derive(master_secret)
print("Derived AES key:", aes_key.hex())Considerações de desempenho
A aceleração de hardware AES-NI torna o AES-GCM extremamente rápido (~1–4 GB/s em CPUs modernas). A biblioteca cryptography do Python usa o OpenSSL, que aproveita o AES-NI. Para arquivos com mais de 100 MB, use processamento em fluxo por blocos com a API de cifra de baixo nível.
Verificação de conhecimento
O que acontece se o mesmo nonce for usado duas vezes com AES-GCM sob a mesma chave?
Recapitulação da lição
O AES-GCM fornece criptografia autenticada em uma única passagem. Use um nonce aleatório novo de 96 bits para cada criptografia. Prependa o nonce ao texto cifrado para armazenamento. Os AAD vinculam o texto cifrado ao contexto. O AES-GCM-SIV resiste ao uso indevido de nonces. Derive as chaves com HKDF; nunca use senhas brutas.
Perguntas Frequentes
A aula “Encriptação e desencriptação AES-GCM em Python” é grátis?
Sim — o texto completo de “Encriptação e desencriptação AES-GCM em Python” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Cryptology Academy, atualize para CoddyKit PRO. O curso de Cryptology Academy inclui 4 aulas no total.
O que vou aprender em “Encriptação e desencriptação AES-GCM em Python”?
Implemente encriptação autenticada com gerenciamento adequado de nonces. Você pratica Cryptology Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Cryptology Academy?
Nenhuma experiência prévia é necessária. Cryptology Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Encriptação e desencriptação AES-GCM em Python”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Cryptology Academy?
Sim. Cada aula de Cryptology Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Visão geral da biblioteca de criptografia do Python
- Encriptação e desencriptação AES-GCM em Python
- Pares de chaves RSA e ECDSA em Python
- Armadilhas comuns de criptografia em Python e padrões seguros