Cryptology Academy · Aula

Pares de chaves RSA e ECDSA em Python

Gere, serialize e use chaves RSA e EC para assinaturas e encriptação.

Aula 3 de 413 etapas

Pares de chaves RSA e ECDSA em Python é uma aula grátis de Cryptology Academy no CoddyKit. Esta é a aula 3 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.

Visão geral das operações com pares de chaves

A biblioteca cryptography do Python oferece suporte a RSA e ECDSA para gerar chaves, assinar, verificar, serializar e carregar. Esses são os elementos básicos de certificados TLS, assinatura de código e JWTs.

Geração de um par de chaves RSA

Mínimo recomendado: 2048 bits para compatibilidade, 4096 bits para chaves de longa duração:

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.backends import default_backend

private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
    backend=default_backend()
)
public_key = private_key.public_key()
print("RSA key generated, size:", private_key.key_size, "bits")

Assinatura RSA com PSS

Use sempre preenchimento PSS para assinaturas (não PKCS#1 v1.5):

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding

message = b"document to sign"
signature = private_key.sign(
    message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)
print("RSA-PSS signature:", signature.hex()[:32], "...")

Verificação de assinatura RSA

A verificação gera InvalidSignature em caso de falha:

from cryptography.exceptions import InvalidSignature

try:
    public_key.verify(
        signature,
        message,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("Signature valid!")
except InvalidSignature:
    print("Signature INVALID")

Geração de um par de chaves ECDSA

O ECDSA com NIST P-256 (secp256r1) oferece segurança de 128 bits com chaves muito menores que as do RSA-3072:

from cryptography.hazmat.primitives.asymmetric import ec

private_key = ec.generate_private_key(ec.SECP256R1())
public_key = private_key.public_key()
print("EC private key generated on curve:", private_key.curve.name)

Assinatura e verificação ECDSA

O ECDSA usa assinaturas codificadas em DER por padrão:

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes
from cryptography.exceptions import InvalidSignature

# Sign
sig = private_key.sign(b"my data", ec.ECDSA(hashes.SHA256()))
print("ECDSA signature bytes:", len(sig))

# Verify
try:
    public_key.verify(sig, b"my data", ec.ECDSA(hashes.SHA256()))
    print("ECDSA signature valid")
except InvalidSignature:
    print("Invalid")

Serialização de chaves em PEM

Salve as chaves em arquivos PEM para armazenamento ou distribuição:

from cryptography.hazmat.primitives import serialization

# Private key — encrypted with passphrase
private_pem = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.BestAvailableEncryption(b"strong-passphrase")
)

# Public key — no encryption
public_pem = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)
print(public_pem.decode()[:64])

Carregamento de chaves a partir de PEM

Carregue as chaves persistidas novamente em objetos:

from cryptography.hazmat.primitives.serialization import (
    load_pem_private_key, load_pem_public_key
)

with open("ec_private.pem", "rb") as f:
    priv = load_pem_private_key(f.read(), password=b"strong-passphrase")

with open("ec_public.pem", "rb") as f:
    pub = load_pem_public_key(f.read())

print("Loaded EC key curve:", priv.curve.name)

Acordo de chaves ECDH

Use ECDH para derivar um segredo compartilhado para a criptografia simétrica:

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.hkdf import HKDF

alice_priv = ec.generate_private_key(ec.SECP256R1())
bob_priv = ec.generate_private_key(ec.SECP256R1())

# Alice computes shared secret
shared = alice_priv.exchange(ec.ECDH(), bob_priv.public_key())
aes_key = HKDF(hashes.SHA256(), 32, None, b"app-context").derive(shared)
print("Derived AES key:", aes_key.hex())

Criptografia RSA com OAEP

Para criptografar pequenas cargas úteis (por exemplo, uma DEK) com RSA — use sempre OAEP:

from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes

# Encrypt with public key
ciphertext = public_key.encrypt(
    b"small secret",
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# Decrypt with private key
plaintext = private_key.decrypt(ciphertext, padding.OAEP(
    mgf=padding.MGF1(algorithm=hashes.SHA256()),
    algorithm=hashes.SHA256(), label=None
))
print("Decrypted:", plaintext)

Escolha entre RSA e ECDSA

ECDSA: assinaturas menores (~71 bytes para P-256 contra ~256 bytes para RSA-2048), assinatura mais rápida e o mesmo nível de segurança. RSA: suporte legado mais amplo e modelo mental mais simples. Use ECDSA P-256 ou Ed25519 em sistemas novos.

Verificação de conhecimento

Por que RSA-PSS deve ser preferido a PKCS#1 v1.5 para assinaturas digitais?

Responda na aula interativa

Recapitulação da lição

Use rsa.generate_private_key para RSA e ec.generate_private_key para ECDSA. Assine com PSS (RSA) ou ECDSA + SHA-256. Serialize em PEM com o formato PKCS8 e criptografia por senha. Use ECDH para acordo de chaves. Prefira ECDSA P-256 ou Ed25519 em sistemas novos.

Grátis para começar

Aprenda Cryptology Academy com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 67
Aulas: 261

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Pares de chaves RSA e ECDSA em Python” é grátis?

Sim — o texto completo de “Pares de chaves RSA e ECDSA 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 “Pares de chaves RSA e ECDSA em Python”?

Gere, serialize e use chaves RSA e EC para assinaturas e encriptação. 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 3 de 4.

Quanto tempo leva a aula “Pares de chaves RSA e ECDSA 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

← Voltar para Cryptology Academy