Saltar al contenido
🛠️ToolsShed

Generador de Par de Claves RSA

Genera pares de claves RSA-2048 o RSA-4096 en formato PEM.

Las claves se generan completamente en tu navegador usando Web Crypto API y nunca se envían a ningún servidor.

Acerca de esta herramienta

Un generador de pares de claves RSA crea dos claves criptográficas matemáticamente vinculadas—una clave pública para cifrado y una clave privada para descifrado—basadas en el algoritmo RSA (Rivest-Shamir-Adleman). Estas claves son esenciales para la comunicación segura, firmas digitales y autenticación en toda la red. Ya sea que estés construyendo una API segura, implementando autenticación basada en certificados o configurando mensajería cifrada, un generador de claves RSA confiable es una herramienta fundamental para la infraestructura de seguridad moderna.

Para usar esta herramienta, simplemente selecciona el tamaño de clave deseado (RSA-2048 o RSA-4096), haz clic en generar, y la herramienta producirá ambas claves en formato PEM estándar, listas para usar inmediatamente. RSA-2048 es adecuado para la mayoría de aplicaciones y proporciona una seguridad sólida para un futuro previsible, mientras que RSA-4096 ofrece un margen de seguridad adicional al costo de operaciones ligeramente más lentas. Después de la generación, puedes copiar cada clave por separado para usar en tu aplicación, archivos de configuración o sistemas criptográficos.

Preguntas Frecuentes

Implementación 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.