0Pricing
Cryptology Academy · Aula

Armadilhas comuns de criptografia em Python e padrões seguros

Evite chaves codificadas diretamente, o modo ECB, comparações cujo tempo não é constante e outros problemas.

Armadilhas comuns de criptografia em Python e padrões seguros é uma aula grátis de Cryptology Academy no CoddyKit. Esta é a aula 4 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.

Os erros criptográficos mais perigosos

É fácil usar a criptografia de forma incorreta. As armadilhas mais comuns do Python são: chaves codificadas diretamente, modo ECB, comparações que não têm tempo constante, aleatoriedade fraca, reutilização de chaves/nonces e criação da própria criptografia.

Armadilha 1: chaves codificadas diretamente

Nunca inclua chaves no código-fonte. Elas acabam no histórico do git, nos registros e nas mensagens de erro. Use variáveis de ambiente ou um KMS:

# WRONG
SECRET_KEY = b"my_secret_key_12"  # visible in git!

# RIGHT
import os
SECRET_KEY = os.environb.get(b"SECRET_KEY") or os.urandom(32)
# Or load from KMS at startup

Armadilha 2: modo ECB

O AES-ECB criptografa cada bloco de forma independente — blocos de texto simples idênticos produzem blocos de texto cifrado idênticos. O ataque do "pinguim ECB" revela padrões em imagens e dados estruturados. Use sempre GCM ou CBC com um IV aleatório.

# WRONG — never use ECB
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
cipher = Cipher(algorithms.AES(key), modes.ECB())  # insecure!

# RIGHT
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
aesgcm = AESGCM(key)  # authenticated encryption

Armadilha 3: comparação de MAC sem tempo constante

Usar == para comparar MACs vaza informações de temporização. Use sempre hmac.compare_digest:

import hmac

# WRONG — leaks timing
if received_mac == expected_mac:
    pass

# RIGHT — constant-time
if hmac.compare_digest(received_mac, expected_mac):
    pass

Armadilha 4: geração fraca de números aleatórios

Nunca use o módulo random para fins criptográficos — ele não é um CSPRNG. Use secrets ou os.urandom:

import random, secrets, os

# WRONG
key = bytes([random.randint(0, 255) for _ in range(32)])  # predictable!

# RIGHT
key = os.urandom(32)          # OS CSPRNG
token = secrets.token_bytes(32)  # secrets module wrapper

Armadilha 5: reutilização de IV/nonces

Reutilizar um IV com CBC ou um nonce com GCM compromete a segurança. Gere um IV/nonce aleatório novo para cada criptografia e armazene-o junto com o texto cifrado:

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

key = AESGCM.generate_key(bit_length=256)
aesgcm = AESGCM(key)

# WRONG — fixed nonce
nonce = b"\x00" * 12  # reuse breaks GCM!

# RIGHT — fresh nonce every time
nonce = os.urandom(12)
ciphertext = aesgcm.encrypt(nonce, b"data", None)

Armadilha 6: uso de MD5 ou SHA-1 para segurança

MD5 e SHA-1 estão criptograficamente comprometidos quanto à resistência a colisões. Nunca os use para assinaturas digitais, impressões digitais de certificados ou HMAC. Use SHA-256 ou SHA-3-256.

Armadilha 7: criação da própria criptografia

Implementar primitivas criptográficas do zero quase sempre introduz erros sutis. Use os pacotes cryptography, PyNaCl ou PyCA. Nunca implemente AES, RSA ou ECDSA por conta própria.

Padrão seguro: PyNaCl para criptografia de alto nível

PyNaCl encapsula a biblioteca NaCl/libsodium — uma API opinativa e difícil de usar incorretamente:

# pip install PyNaCl
import nacl.secret
import nacl.utils

key = nacl.utils.random(nacl.secret.SecretBox.KEY_SIZE)
box = nacl.secret.SecretBox(key)

encrypted = box.encrypt(b"my secret message")
decrypted = box.decrypt(encrypted)
print("Decrypted:", decrypted)  # Uses XSalsa20-Poly1305

Padrão seguro: hash de senhas com Argon2

Use argon2-cffi para gerar hashes de senhas — nunca SHA-256 ou bcrypt diretamente:

# pip install argon2-cffi
from argon2 import PasswordHasher

ph = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=4)
hash_val = ph.hash("user_password")
print("Hash:", hash_val[:40], "...")

# Verify
try:
    ph.verify(hash_val, "user_password")
    print("Password correct")
except Exception:
    print("Wrong password")

Zeragem de chaves

Depois de usar uma chave na memória, zere-a para reduzir a janela de exposição a ataques de despejo de memória. O coletor de lixo do Python dificulta isso — use ctypes ou PyNaCl, que faz isso automaticamente.

Verificação de conhecimento

Qual função Python deve ser usada no lugar de == ao comparar MACs criptográficos?

Recapitulação da lição

Evite chaves codificadas diretamente, o modo ECB, == para comparar MACs, o módulo random e a reutilização de nonces. Use os.urandom/secrets para aleatoriedade, AESGCM para criptografia e hmac.compare_digest para verificação. PyNaCl e argon2-cffi fornecem APIs seguras de alto nível para criptografia simétrica e senhas.

Perguntas Frequentes

A aula “Armadilhas comuns de criptografia em Python e padrões seguros” é grátis?

Sim — o texto completo de “Armadilhas comuns de criptografia em Python e padrões seguros” é 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 “Armadilhas comuns de criptografia em Python e padrões seguros”?

Evite chaves codificadas diretamente, o modo ECB, comparações cujo tempo não é constante e outros problemas. 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 4 de 4.

Quanto tempo leva a aula “Armadilhas comuns de criptografia em Python e padrões seguros”?

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

  1. Visão geral da biblioteca de criptografia do Python
  2. Encriptação e desencriptação AES-GCM em Python
  3. Pares de chaves RSA e ECDSA em Python
  4. Armadilhas comuns de criptografia em Python e padrões seguros
← Voltar para Cryptology Academy