# RSA desde cero con los parámetros del ejemplo
# Puedes ejecutar esto en cualquier Python 3

## PASO 1: Definir los primos
p, q = 61, 53

## PASO 2: Calcular n y phi(n)
n = p * q          # 3233
phi = (p-1) * (q-1)# 3120

## PASO 3: Clave pública (e coprimo con phi)
e = 17
from math import gcd
assert gcd(e, phi) == 1, "e no es coprimo con phi"

## PASO 4: Clave privada (d inverso modular de e)
d = pow(e, -1, phi)  # Python 3.8+ calcula el inverso modular directamente
print(f"Clave pública:  (n={n}, e={e})")
print(f"Clave privada:  (n={n}, d={d})")
Clave pública:  (n=3233, e=17)
Clave privada:  (n=3233, d=2753)

## CIFRAR: C = M^e mod n
M = 65               # mensaje
C = pow(M, e, n)     # pow(base, exp, mod) es eficiente para números grandes
print(f"Mensaje original:  {M}")
print(f"Mensaje cifrado:   {C}")
Mensaje original:  65
Mensaje cifrado:   2790

## DESCIFRAR: M = C^d mod n
M_dec = pow(C, d, n)
print(f"Mensaje descifrado: {M_dec}")
assert M_dec == M, "¡Error de descifrado!"
Mensaje descifrado: 65  ← ¡correcto!

## VERIFICAR que sin d no se puede descifrar
# Sin conocer p y q, encontrar d requiere factorizar n
# Para n=3233 es fácil, pero para RSA-2048 es computacionalmente imposible

## PASO 1: Generar la clave privada RSA-2048
openssl genrsa -out clave_privada.pem 2048
Generating RSA private key, 2048 bit long modulus (2 primes)
.........+++++
.....+++++
e is 65537 (0x10001)

## PASO 2: Extraer la clave pública de la privada
openssl rsa -in clave_privada.pem -pubout -out clave_publica.pem
writing RSA key

## Ver la clave pública generada
cat clave_publica.pem
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2a2rwplBQLzskS6ACJM5
...
-----END PUBLIC KEY-----

## Ver los componentes matemáticos de la clave
openssl rsa -in clave_privada.pem -text -noout | head -20
Private-Key: (2048 bit, 2 primes)
modulus:
    00:d9:ad:ab:c2:99:41:40:bc:...   ← n (2048 bits)
publicExponent: 65537 (0x10001)      ← e = 65537
privateExponent:                     ← d (secreto)
    ...
prime1:                              ← p
prime2:                              ← q

## PASO 3: Cifrar un mensaje con la clave pública
echo "Hola GhostAcademy, esto es un secreto!" > mensaje.txt
openssl rsautl -encrypt -inkey clave_publica.pem -pubin \
  -in mensaje.txt -out mensaje_cifrado.bin

## Ver el contenido cifrado (binario ilegible)
xxd mensaje_cifrado.bin | head -5
00000000: 3a8f d291 4c7a 2b88 e931 f450 a2b3 ...   ← ilegible sin la clave privada

## PASO 4: Descifrar con la clave privada
openssl rsautl -decrypt -inkey clave_privada.pem \
  -in mensaje_cifrado.bin -out mensaje_descifrado.txt
cat mensaje_descifrado.txt
Hola GhostAcademy, esto es un secreto!

## CIFRADO HÍBRIDO PRÁCTICO — RSA + AES (lo que se usa en producción)
# Cifrar un archivo grande (RSA tiene límite de tamaño)

# 1. Generar clave AES aleatoria
openssl rand -base64 32 > clave_aes.key

# 2. Cifrar el archivo grande con AES
openssl enc -aes-256-cbc -salt -in archivo_grande.txt \
  -out archivo_cifrado.enc -pass file:clave_aes.key

# 3. Cifrar la clave AES con RSA (esto es lo que se envía al destinatario)
openssl rsautl -encrypt -inkey clave_publica.pem -pubin \
  -in clave_aes.key -out clave_aes_cifrada.bin

# Enviar al destinatario: archivo_cifrado.enc + clave_aes_cifrada.bin
# El destinatario descifra la clave AES con su RSA privada, luego descifra el archivo

# Instalar: pip install cryptography
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes, serialization

## GENERAR PAR DE CLAVES RSA-2048
clave_privada = rsa.generate_private_key(
    public_exponent=65537,   # e estándar
    key_size=2048,           # tamaño de n en bits
)
clave_publica = clave_privada.public_key()

## CIFRAR con la clave pública (OAEP es el padding recomendado)
mensaje = b"Hola GhostAcademy, esto es secreto!"

cifrado = clave_publica.encrypt(
    mensaje,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print(f"Mensaje cifrado: {cifrado.hex()[:60]}...")
Mensaje cifrado: 3a8fd2914c7a2b88e931f450a2b3c8d1e4f6a7b8c9d0e1f2...

## DESCIFRAR con la clave privada
descifrado = clave_privada.decrypt(
    cifrado,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print(f"Mensaje descifrado: {descifrado.decode()}")
Mensaje descifrado: Hola GhostAcademy, esto es secreto!

## EXPORTAR CLAVES en formato PEM
pem_privada = clave_privada.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.BestAvailableEncryption(b"mi_passphrase")
)

pem_publica = clave_publica.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)

with open("privada.pem", "wb") as f: f.write(pem_privada)
with open("publica.pem", "wb") as f: f.write(pem_publica)
print("Claves guardadas en privada.pem y publica.pem")

## PREPARAR: reutilizamos las claves generadas antes
echo "Este contrato es vinculante. Fecha: $(date)" > contrato.txt
cat contrato.txt
Este contrato es vinculante. Fecha: Mon Jan 15 14:32:00 UTC 2024

## FIRMAR el documento con la clave privada
openssl dgst -sha256 -sign clave_privada.pem \
  -out contrato.sig contrato.txt

## Ver la firma (binario codificado en hex)
xxd contrato.sig | head -3
00000000: 7a3b c891 2e45 f7d8 9a12 ...   ← firma de 256 bytes (RSA-2048)

## VERIFICAR la firma con la clave pública
openssl dgst -sha256 -verify clave_publica.pem \
  -signature contrato.sig contrato.txt
Verified OK   ← firma válida

## QUÉ PASA si el documento es modificado después de firmar
echo "clausula_maliciosa" >> contrato.txt
openssl dgst -sha256 -verify clave_publica.pem \
  -signature contrato.sig contrato.txt
Verification Failure   ← ¡el documento fue alterado! la firma no coincide

## FIRMAR CON ECDSA (más eficiente que RSA para firmas)
openssl ecparam -name prime256v1 -genkey -noout -out ec_privada.pem
openssl ec -in ec_privada.pem -pubout -out ec_publica.pem
openssl dgst -sha256 -sign ec_privada.pem -out contrato_ec.sig contrato.txt
openssl dgst -sha256 -verify ec_publica.pem -signature contrato_ec.sig contrato.txt
Verified OK

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

## Generar par de claves
clave_privada = rsa.generate_private_key(public_exponent=65537, key_size=2048)
clave_publica = clave_privada.public_key()

## Documento a firmar
documento = b"Este contrato tiene validez legal. Firmado por: Alice"

## FIRMAR con la clave privada (PSS es el padding recomendado para firmas)
firma = clave_privada.sign(
    documento,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)
print(f"Firma generada: {firma.hex()[:60]}...")

## VERIFICAR con la clave pública
try:
    clave_publica.verify(
        firma,
        documento,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("✓ Firma válida — el documento es auténtico e íntegro")
except Exception as e:
    print(f"✗ Firma inválida: {e}")

## Qué ocurre con documento alterado
documento_alterado = b"Este contrato tiene validez legal. Firmado por: Bob"
try:
    clave_publica.verify(firma, documento_alterado,
        padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH),
        hashes.SHA256())
except Exception:
    print("✗ Firma inválida — el documento fue modificado")
Firma generada: 7a3bc8912e45f7d89a12...
✓ Firma válida — el documento es auténtico e íntegro
✗ Firma inválida — el documento fue modificado

## OPENSSL — Generar clave ECC (Ed25519 — la más moderna)
openssl genpkey -algorithm Ed25519 -out ed25519_privada.pem
openssl pkey -in ed25519_privada.pem -pubout -out ed25519_publica.pem

## Comparar tamaños con RSA
wc -c ed25519_privada.pem rsa_privada.pem
 119 ed25519_privada.pem    ← Ed25519: 119 bytes
1704 rsa_privada.pem        ← RSA-2048: 1704 bytes  ← 14x más grande

## PYTHON — ECC con Ed25519
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey

privada = Ed25519PrivateKey.generate()
publica = privada.public_key()

mensaje = b"Firmado con curva elíptica Ed25519"
firma = privada.sign(mensaje)

# Verificar
publica.verify(firma, mensaje)
print("✓ Firma Ed25519 válida")

# Ed25519 es más rápido que RSA y más seguro a igual tamaño de clave
✓ Firma Ed25519 válida

# Ver el certificado completo de un servidor
echo | openssl s_client -connect google.com:443 2>/dev/null | openssl x509 -noout -text | grep -E "Subject|Issuer|Algorithm|Public Key|Not|SANs"
Subject: CN=*.google.com
Issuer: C=US, O=Google Trust Services, CN=WR2
Signature Algorithm: ecdsa-with-SHA384
Public Key Algorithm: id-ecPublicKey (P-256)
Not Before: Jan 10 00:00:00 2024 GMT
Not After : Apr  3 23:59:59 2024 GMT

# Ver qué cipher suite se negoció
echo | openssl s_client -connect google.com:443 2>/dev/null | grep "Cipher"
New, TLSv1.3, Cipher is TLS_AES_256_GCM_SHA384
← TLS 1.3 + AES-256-GCM para datos + SHA-384 para integridad

# Ver la clave pública del certificado
echo | openssl s_client -connect github.com:443 2>/dev/null | openssl x509 -noout -pubkey
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE...   ← clave pública ECDSA P-256 de GitHub
-----END PUBLIC KEY-----

## GENERAR PAR DE CLAVES SSH

# Ed25519 — recomendado (ECC moderno, clave pequeña y segura)
ssh-keygen -t ed25519 -C "tu_email@ejemplo.com" -f ~/.ssh/id_ed25519
Generating public/private ed25519 key pair.
Enter passphrase: ****   ← proteger la clave privada con passphrase
Your identification has been saved in /home/user/.ssh/id_ed25519
Your public key has been saved in /home/user/.ssh/id_ed25519.pub

# RSA-4096 — alternativa compatible con sistemas más antiguos
ssh-keygen -t rsa -b 4096 -C "tu_email@ejemplo.com" -f ~/.ssh/id_rsa

## VER LAS CLAVES
cat ~/.ssh/id_ed25519.pub
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAA... tu_email@ejemplo.com
← esta es la clave PÚBLICA — puedes copiarla a cualquier servidor

## COPIAR LA CLAVE PÚBLICA AL SERVIDOR
ssh-copy-id -i ~/.ssh/id_ed25519.pub usuario@servidor.com
# Esto añade tu clave pública al ~/.ssh/authorized_keys del servidor

## CONECTAR SIN CONTRASEÑA (usando la clave privada)
ssh -i ~/.ssh/id_ed25519 usuario@servidor.com

## QUÉ OCURRE DURANTE LA AUTENTICACIÓN SSH
1. El servidor genera un número aleatorio y lo cifra con tu clave pública
2. Te lo envía cifrado — solo tu clave privada puede descifrarlo
3. Tu cliente descifra el desafío y envía la respuesta
4. El servidor verifica que la respuesta es correcta → autenticado ✓
(nunca se envía la clave privada ni la contraseña por la red)

## FIRMAR COMMITS DE GIT CON SSH (GitHub, GitLab)
git config --global gpg.format ssh
git config --global user.signingkey ~/.ssh/id_ed25519.pub
git commit -S -m "commit firmado con mi clave SSH"

## GENERAR PAR DE CLAVES GPG
gpg --full-generate-key
# Seleccionar: RSA and RSA, 4096 bits, sin expiración (o con)
# Introducir nombre y email, proteger con passphrase

## VER LAS CLAVES GENERADAS
gpg --list-keys
pub   rsa4096 2024-01-15 [SC]
      A1B2C3D4E5F67890A1B2C3D4E5F67890A1B2C3D4
uid           [ultimate] Tu Nombre <tu@email.com>
sub   rsa4096 2024-01-15 [E]

## EXPORTAR LA CLAVE PÚBLICA (para compartir)
gpg --armor --export tu@email.com > mi_clave_publica.asc
cat mi_clave_publica.asc
-----BEGIN PGP PUBLIC KEY BLOCK-----
mQINBGb...
-----END PGP PUBLIC KEY BLOCK-----

## IMPORTAR LA CLAVE PÚBLICA DE OTRA PERSONA
gpg --import clave_publica_bob.asc

## CIFRAR un archivo para Bob (solo Bob puede descifrarlo)
echo "Mensaje secreto para Bob" > secreto.txt
gpg --encrypt --recipient bob@email.com --armor -o secreto.gpg secreto.txt

## DESCIFRAR (Bob lo ejecuta con su clave privada)
gpg --decrypt secreto.gpg
gpg: encrypted with RSA key, ID ...
Mensaje secreto para Bob

## FIRMAR un archivo (demostrar autoría)
gpg --sign --armor -o contrato.sig contrato.txt

## VERIFICAR la firma
gpg --verify contrato.sig contrato.txt
gpg: Good signature from "Tu Nombre <tu@email.com>" [ultimate]

## CIFRAR Y FIRMAR a la vez (lo más común)
gpg --encrypt --sign --recipient bob@email.com --armor -o mensaje.gpg mensaje.txt

## FIRMAR COMMITS DE GIT CON GPG
git config --global user.signingkey TU_ID_GPG
git config --global commit.gpgsign true
git commit -m "commit con firma GPG automática"

# Un JWT tiene 3 partes separadas por puntos, cada una en Base64URL:
eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiJ1c2VyMTIzIiwiZXhwIjoxNzAwMDAwMDAwfQ.FIRMA_AQUI
#  ↑ Header                ↑ Payload                                    ↑ Signature

# HEADER (decodificado):
{"alg": "RS256", "typ": "JWT"}
← RS256 = RSA + SHA-256 para la firma

# PAYLOAD (decodificado):
{"sub": "user123", "exp": 1700000000, "role": "admin"}
← claims: quién es el usuario y qué puede hacer

# SIGNATURE:
RSA_SIGN(SHA256(base64(header) + "." + base64(payload)), clave_privada_servidor)
← el servidor firma el header+payload — nadie puede falsificar el token sin la clave privada

# pip install pyjwt cryptography
import jwt
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization

## Generar par de claves RSA para el servidor de autenticación
clave_privada = rsa.generate_private_key(public_exponent=65537, key_size=2048)
clave_publica = clave_privada.public_key()

## SERVIDOR — Emitir token al hacer login
payload = {
    "sub": "user123",
    "name": "Juan García",
    "role": "admin",
    "exp": 9999999999  # expiración
}

token = jwt.encode(payload, clave_privada, algorithm="RS256")
print(f"Token JWT: {token[:80]}...")

## CUALQUIER MICROSERVICIO — Verificar el token con la clave pública
try:
    datos = jwt.decode(token, clave_publica, algorithms=["RS256"])
    print(f"✓ Token válido. Usuario: {datos['name']}, Rol: {datos['role']}")
except jwt.InvalidTokenError as e:
    print(f"✗ Token inválido: {e}")

## Intentar falsificar el token (modificar el payload)
import base64, json
partes = token.split('.')
payload_falso = base64.urlsafe_b64encode(
    json.dumps({"sub": "hacker", "role": "superadmin"}).encode()
).rstrip(b'=').decode()
token_falso = f"{partes[0]}.{payload_falso}.{partes[2]}"

try:
    jwt.decode(token_falso, clave_publica, algorithms=["RS256"])
except jwt.InvalidTokenError:
    print("✗ Token falsificado rechazado — la firma no coincide")
Token JWT: eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...
✓ Token válido. Usuario: Juan García, Rol: admin
✗ Token falsificado rechazado — la firma no coincide