Pular para o conteúdo
🛠️ToolsShed

Gerador de Par de Chaves RSA

Gera pares de chaves RSA-2048 ou RSA-4096 no formato PEM.

As chaves são geradas inteiramente no seu navegador usando a API Web Crypto e nunca são enviadas a nenhum servidor.

Sobre esta ferramenta

Um gerador de pares de chaves RSA cria duas chaves criptográficas matematicamente vinculadas—uma chave pública para criptografia e uma chave privada para descriptografia—baseadas no algoritmo RSA (Rivest-Shamir-Adleman). Essas chaves são essenciais para comunicação segura, assinaturas digitais e autenticação em toda a internet. Seja construindo uma API segura, implementando autenticação baseada em certificados ou configurando mensagens criptografadas, um gerador de chaves RSA confiável é uma ferramenta fundamental para a infraestrutura de segurança moderna.

Para usar esta ferramenta, simplesmente selecione o tamanho de chave desejado (RSA-2048 ou RSA-4096), clique em gerar, e a ferramenta produzirá ambas as chaves em formato PEM padrão, prontas para uso imediato. RSA-2048 é adequado para a maioria das aplicações e fornece segurança robusta para o futuro previsível, enquanto RSA-4096 oferece uma margem de segurança adicional ao custo de operações ligeiramente mais lentas. Após a geração, você pode copiar cada chave separadamente para usar em seu aplicativo, arquivos de configuração ou sistemas criptográficos.

Perguntas Frequentes

Implementação de Código

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.backends import default_backend

# Generate RSA key pair
def generate_rsa_key_pair(
    key_size: int = 2048,
    public_exponent: int = 65537,
) -> tuple[rsa.RSAPrivateKey, rsa.RSAPublicKey]:
    private_key = rsa.generate_private_key(
        public_exponent=public_exponent,
        key_size=key_size,
        backend=default_backend(),
    )
    return private_key, private_key.public_key()

# Serialize to PEM
def private_key_to_pem(key: rsa.RSAPrivateKey, password: bytes | None = None) -> str:
    encryption = (
        serialization.BestAvailableEncryption(password)
        if password else serialization.NoEncryption()
    )
    return key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=encryption,
    ).decode()

def public_key_to_pem(key: rsa.RSAPublicKey) -> str:
    return key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo,
    ).decode()

# Sign and verify
def sign(message: bytes, private_key: rsa.RSAPrivateKey) -> bytes:
    return private_key.sign(message, padding.PKCS1v15(), hashes.SHA256())

def verify(message: bytes, signature: bytes, public_key: rsa.RSAPublicKey) -> bool:
    try:
        public_key.verify(signature, message, padding.PKCS1v15(), hashes.SHA256())
        return True
    except Exception:
        return False


if __name__ == "__main__":
    priv, pub = generate_rsa_key_pair(2048)
    print(private_key_to_pem(priv))
    print(public_key_to_pem(pub))

    msg = b"Hello, RSA!"
    sig = sign(msg, priv)
    print("Signature valid:", verify(msg, sig, pub))

Comments & Feedback

Comments are powered by Giscus. Sign in with GitHub to leave a comment.