RSA Cracker

TAG -> Artículos

La Importancia de Crear Claves Públicas Robusta en el Mundo de la Ciberseguridad

En el mundo del hacking ofensivo y la ciberseguridad, las llaves públicas juegan un papel crucial en la protección de la información y la verificación de la autenticidad de los mensajes. Ya sea que estés realizando un análisis forense o una prueba de penetración, entender cómo generar, usar y proteger adecuadamente estas llaves es esencial para un trabajo exitoso.

A lo largo de este artículo, exploraremos la importancia de generar llaves públicas robustas, cómo puedes cifrar archivos de manera segura usando OpenSSL y qué sucede cuando intentas decifrar la información cifrada.

🔐 1. ¿Qué es una clave pública?

Una clave pública es un componente esencial en los algoritmos de cifrado como RSA. Se utiliza para cifrar datos que solo podrán ser descifrados con la clave privada correspondiente. Aunque la clave pública es accesible para todos, su fortaleza depende de la robustez de su longitud y de los factores matemáticos que la componen.

¿Por qué es importante crear una clave pública robusta?

• La seguridad de la clave pública depende directamente de la complejidad y tamaño de su módulo n (producto de dos números primos grandes).

• Una clave débil (es decir, con un módulo pequeño o con factores conocidos) puede ser fácilmente comprometida, lo que facilita el acceso a la información cifrada y permite ataques de tipo factorización.

🛠️ 2. ¿Cómo se crean claves RSA con ssh-keygen? ¿Y por qué son tan seguras?

Una de las formas más comunes y prácticas de generar claves RSA en sistemas UNIX/Linux es con el comando ssh-keygen. Este comando se usa ampliamente tanto para autenticación SSH como para otras tareas criptográficas.

🧬 ¿Qué pasa "detrás de cámaras"?

Cuando ejecutamos ssh-keygen, se genera:

• Dos números primos grandes p y q.

• Se calcula su producto n = p * q, que se convierte en el módulo RSA.

• Se escoge un exponente público e, generalmente 65537.

• Luego se calcula el exponente privado d, que es la clave privada, usando la inversa modular.

🔐 Generar una clave RSA con ssh-keygen

ssh-keygen -t rsa -b 4096 -f rsa_key

Resultado

📌 Esto creará:

• rsa_key → clave privada

• rsa_key.pub → clave pública

La opción -b 4096 genera una clave de 4096 bits, lo que significa que el valor n tiene 4096 bits (¡más de 1200 dígitos decimales!).

🔍 ¿Por qué es segura una clave RSA?

👉 Porque factorizar n es muy difícil:

• n se forma multiplicando dos primos enormes.

• Si alguien quiere obtener la clave privada, tendría que factorizar n (es decir, hallar p y q), lo cual es computacionalmente inviable si n es lo suficientemente grande.

⏱️ Incluso con supercomputadoras modernas, factorizar un número de 2048 o 4096 bits llevaría siglos usando fuerza bruta.

🧪 Script: Visualizando los valores de una clave RSA

Aquí te dejo un script en Python que usa pycryptodome para leer una clave pública y mostrar:

• El módulo n (base de seguridad RSA)

• El exponente público e

• El número de bits de n

visualizar_clave_rsa.py

from Crypto.PublicKey import RSA

# Cargar clave pública
with open("rsa_key.pub", "r") as f:
    key_data = f.read()

# A veces OpenSSH añade texto, debemos limpiarlo
key = RSA.import_key(key_data)

# Mostrar los valores clave
n = key.n
e = key.e

print("\n🔐 COMPONENTES DE LA CLAVE PÚBLICA RSA")
print("="*60)
print(f"🧮 Módulo (n):\n{n}")
print(f"\n📏 Longitud de n: {n.bit_length()} bits")
print(f"\n📌 Exponente público (e): {e}")
print("="*60)

if n.bit_length() >= 2048:
    print("✅ Esta clave es robusta. Factorizar n sería prácticamente imposible.\n")
else:
    print("⚠️ Esta clave es débil. Considera usar al menos 2048 bits.\n")

Resultado

📌 ¿Qué debes notar?

🔍 El módulo n se ve así (extracto real de una clave de 4096 bits):

n = 68020964613496584619... [más de 1200 dígitos decimales] ...

¡Un solo número! Pero tan grande que si lo intentaras factorizar con fuerza bruta, necesitarías más años de los que tiene el universo conocido. 🤯

✅ Usar ssh-keygen con al menos 2048 o 4096 bits es una de las formas más sencillas y confiables de generar claves RSA seguras. ⚔️ En pruebas de hacking ofensivo, si encuentras una clave débil con menos de 2048 bits, podrías extraer la clave privada y comprometer el sistema.

Ejemplo

🔨 3. Usando OpenSSL para Cifrar y Descifrar Archivos 🖥️

En el siguiente ejemplo, utilizamos OpenSSL para generar una clave pública robusta, cifrar un archivo y luego descifrarlo usando la clave privada. A continuación, verás cómo puedes realizar estos procesos y cómo entender cada paso.

🔑 Generando las Claves con OpenSSL

Para empezar, necesitamos generar un par de claves públicas y privadas con OpenSSL:

# Generar clave privada
openssl genpkey -algorithm RSA -out private.key -aes256

# Extraer clave pública de la clave privada
openssl rsa -pubout -in private.key -out public.key

Resultado

Aquí generamos una clave privada (private.key) usando el algoritmo RSA y luego extraemos la clave pública (public.key) de esa clave privada.

Paso 1: Crea un archivo de texto

Imagina que tienes un archivo de texto llamado archivo.txt que quieres cifrar. Este archivo podría contener cualquier información, como:

Este es un mensaje secreto.

Crear

echo 'Este es un mensaje secreto.' > archivo.txt

Paso 2: Cifrado con la llave pública

Para cifrar el archivo usando una clave pública, primero necesitas tener la clave pública en un archivo. Suponiendo que ya tienes la clave pública (por ejemplo, public.key), puedes usar el siguiente comando en OpenSSL para cifrar el archivo:

openssl pkeyutl -encrypt -inkey public.key -pubin -in archivo.txt -out archivo_cifrado.bin

Explicación:

• pkeyutl: Es el comando de OpenSSL para operaciones de RSA (cifrado/descifrado).

• -encrypt: Indica que la operación es un cifrado.

• -inkey public.key: Especifica el archivo que contiene la clave pública.

• -pubin: Le indica a OpenSSL que la clave es una clave pública.

• -in archivo.txt: Especifica el archivo de entrada que contiene el mensaje.

• -out archivo_cifrado.bin: Especifica el archivo de salida que contendrá el texto cifrado.

Resultado

Como podemos ver, el contenido cifrado es imposible de entender al menos que se usa la clave privada para descifrarlo, borremos el archivo original y sigamos:

rm archivo.txt

Paso 3: Descifrar el archivo con la llave privada

Para descifrar el archivo que cifraste previamente (archivo_cifrado.bin), puedes usar el siguiente comando en OpenSSL:

openssl pkeyutl -decrypt -inkey private.key -in archivo_cifrado.bin -out archivo_descifrado.txt

Explicación:

• pkeyutl: Es el comando de OpenSSL para operaciones de RSA (cifrado/descifrado).

• -decrypt: Indica que la operación es un descifrado.

• -inkey private.key: Especifica el archivo que contiene la clave privada.

• -in archivo_cifrado.bin: Especifica el archivo de entrada que contiene el texto cifrado.

• -out archivo_descifrado.txt: Especifica el archivo de salida que contendrá el mensaje descifrado.

Paso 4: Ver el archivo descifrado

Después de ejecutar el comando anterior, tendrás el archivo archivo_descifrado.txt con el contenido original, por ejemplo:

Este es un mensaje secreto.

Resultado

Resumen de los comandos

1. Cifrado (usando la clave pública):

openssl pkeyutl -encrypt -inkey public.key -pubin -in archivo.txt -out archivo_cifrado.bin

1. Descifrado (usando la clave privada):

openssl pkeyutl -decrypt -inkey private.key -in archivo_cifrado.bin -out archivo_descifrado.txt

Consideraciones

• RSA en OpenSSL es adecuado para cifrar pequeños bloques de datos, ya que el tamaño máximo de datos que puedes cifrar depende del tamaño de la clave. Si los datos a cifrar son demasiado grandes, normalmente se utiliza un enfoque híbrido (combinando RSA con AES para cifrar grandes cantidades de datos).

• Si el archivo es grande, es recomendable cifrar solo una clave simétrica (como AES) con RSA, y luego usar esa clave para cifrar el archivo completo con AES. Sin embargo, para archivos pequeños o sencillos, RSA es suficiente.

🔓 Qué pasa si usas una clave débil? ⚠️

Si alguna de las claves que generas es débil (por ejemplo, si eliges números primos pequeños), el proceso de cifrado y descifrado puede ser fácilmente vulnerado por un atacante. Un atacante podría factorizar el módulo n para obtener los valores p y q, lo que le permitiría calcular la clave privada d y descifrar el contenido cifrado.

🛠️ 4. Crypto Challenge - HackTheBox - Brevi Moduli

Código del challenge server.py:

from Crypto.PublicKey import RSA
from Crypto.Util.number import bytes_to_long, getPrime, isPrime

rounds = 5
e = 65537

for i in range(rounds):
    print("*" * 10, f"Round {i+1}/{rounds}", "*" * 10)

    pumpkin1 = getPrime(110)
    pumpkin2 = getPrime(110)
    n = pumpkin1 * pumpkin2
    large_pumpkin = RSA.construct((n, e)).exportKey()
    print(f"\n@ Can you crack this pumpkin? @\n{large_pumpkin.decode()}\n")

    assert isPrime(_pmp1 := int(input("enter your first pumkin = "))), exit()
    assert isPrime(_pmp2 := int(input("enter your second pumkin = "))), exit()

    if n != _pmp1 * _pmp2:
        print("wrong! bye...")
        exit()

    print()

print(open("flag.txt").read())

La debilidad clave es:

1. El tamaño de los primos (getPrime(110)):

   • Primos de 110 bits → módulo RSA n de ~220 bits.

   • Este tamaño es ridículamente pequeño para los estándares modernos (se recomienda mínimo 2048 bits para seguridad).

   • Esto hace que n = p * q pueda factorizarse fácilmente con Sage o incluso con sympy.factorint() en segundos.

2. Llave pública completa se revela:

   • Se muestra en cada ronda: n y e.

   • Si puedes factorizar n, puedes calcular φ(n) = (p-1)(q-1) y la clave privada.

3. Validación directa del reto:

   • El servidor te pide que envíes p y q directamente.

   • Solo necesitas factorizar n para superarlo.

🧠 ¿Qué necesitas hacer?

• Extraer n del contenido de la llave pública.

• Factorizar n usando Sage.

• Enviar p y q de vuelta al servidor.

Crear una llave privada en base a una llave pública insegura.

Vamos a tomar este challenge para repasar lo aprendido, primero veamos que pasa si ejecutamos el script server.py:

python server.py

Resultado

Inspeccionando el código y ya viendo el resultado de ejecutar el archivo server.py, podemos notar que el script nos da una llave pública y luego nos pide los valores de p y q, entonces en este primer paso, vamos a copiar esa llave publica insegura y guardarla en public.key, para trabajar sobre esa llave, luego usando openssl cifraremos el contenido de archivo.txt con esa llave insegura y veremos como construir paso a paso una llave privada en base a una llave publica insegura:

El siguiente paso es cifrar el archivo con openssl y borrar el original:

Ahora, ¿Cómo logramos descifrar ese archivo_cifrado.bin si solo tenemos la llave publica?, pues primero veamos un poco de teoría sobre el significado y el papel de cada uno de los valores que usaremos para construir la llave privada.

Significado y el papel de cada uno de los valores que usaremos y cómo se obtienen

Estos valores están relacionados con el funcionamiento del sistema de cifrado RSA.

1. Valor de n:

• Significado: n es el módulo de la clave RSA. Es el producto de dos números primos grandes, p y q.

• Obtención: El valor de n se obtiene directamente de la clave pública. Es parte de la información que viene incluida en la clave pública y se utiliza tanto para cifrar como para verificar la autenticidad de un mensaje.

• Uso: n es usado en las operaciones matemáticas RSA (cifrado, descifrado, firma, verificación) y es la base del sistema de seguridad de RSA. Es un número muy grande, que asegura que el sistema sea seguro, ya que factorizarlo para encontrar p y q es computacionalmente difícil.

2. Valor de e:

• Significado: e es el exponente público. Es un número utilizado en el proceso de cifrado. A menudo, se elige un valor pequeño y bien conocido para e, típicamente 65537.

• Obtención: El valor de e se obtiene directamente de la clave pública.

• Uso: e se utiliza en el proceso de cifrado RSA. Para cifrar un mensaje, se eleva el mensaje a la potencia e y luego se toma el residuo cuando se divide entre n. Es un número público y no se debe mantener en secreto.

3. Valor de p:

• Significado: p es uno de los dos números primos utilizados en la generación de la clave RSA. Junto con q, se utiliza para calcular n y phi(n).

• Obtención: p es obtenido al factorizar el valor de n. Dado que n es el producto de p y q, al factorizar n, se pueden obtener ambos valores.

• Uso: p es privado y se mantiene en secreto. Junto con q, se utiliza para calcular phi(n) y la clave privada.

4. Valor de q:

• Significado: q es el otro número primo utilizado en la generación de la clave RSA. Junto con p, es utilizado para calcular n y phi(n).

• Obtención: q también se obtiene al factorizar el valor de n. Después de factorizar n, se obtiene p y q.

• Uso: Al igual que p, q es privado y se utiliza para calcular phi(n) y la clave privada.

5. Valor de phi(n) o φ(n):

• Significado: phi(n) es la función totiente de Euler de n. Representa la cantidad de enteros positivos menores que n que son coprimos con n. Se calcula como:

ϕ(n)=(p−1)×(q−1)\phi(n) = (p - 1) \times (q - 1)

• Obtención: Se obtiene al calcular el producto de (p - 1) y (q - 1), donde p y q son los factores primos de n.

• Uso: phi(n) es utilizado para calcular la clave privada d. Este valor es fundamental para el algoritmo RSA, ya que la clave privada d se calcula usando phi(n).

6. Valor de d:

• Significado: d es el exponente privado de la clave RSA. Es el valor que se utiliza en el proceso de descifrado, y su cálculo es un paso esencial en la generación de la clave privada.

• Obtención: d se obtiene como el inverso multiplicativo de e módulo phi(n). Es decir, d es el valor tal que:

e×d≡1 (mod ϕ(n))e \times d \equiv 1 \ (\text{mod} \ \phi(n))

Esto se puede calcular utilizando el algoritmo de Euclides extendido (lo que se logra con la función inverse_mod).

• Uso: d se utiliza en el proceso de descifrado. Cuando se recibe un mensaje cifrado, se descifra usando la clave privada d junto con n (el módulo).

7. Llave privada completa:

• Significado: La clave privada es el conjunto de valores que incluye n, e, y d (junto con p y q si es necesario para la optimización). La clave privada se utiliza para descifrar los mensajes que fueron cifrados con la clave pública.

• Obtención: La clave privada se construye a partir de los valores n, e, d, p, y q, usando la función RSA_Crypto.construct.

• Uso: La clave privada es necesaria para descifrar mensajes y firmar datos. Es crucial que esta clave se mantenga en secreto para garantizar la seguridad del sistema RSA.

📜 Script para factorizar una llave pública (archivo .key) con Sage y mostrar sus valores.

Ahora que ya hemos visto toda la teoría e creado el siguiente código en este caso llamado solver_1.py el cual puede extraer los valores necesarios de una llave publica para crear su llave privada, siempre y cuando la llave publica sea vulnerable, el contenido del código seria el siguiente:

#!/usr/bin/env sage

import signal
import sys
from base64 import b64decode
from Crypto.PublicKey import RSA
from Crypto.PublicKey import RSA as RSA_Crypto
from sage.all import Integer, inverse_mod

# === Colores ANSI ===
RED = "\033[91m"
GREEN = "\033[92m"
YELLOW = "\033[93m"
BLUE = "\033[94m"
MAGENTA = "\033[95m"
CYAN = "\033[96m"
RESET = "\033[0m"

def handler(sig, frame):
    print(f"\n\n{RED}[!] Saliendo...\n{RESET}")
    sys.exit(1)
# Ctrl + C
signal.signal(signal.SIGINT, handler)

def imprimir_banner():
    banner = rf"""{YELLOW}
 ___  ___   _      ___             _
| _ \/ __| /_\    / __|_ _ __ _ __| |_____ _ _
|   /\__ \/ _ \  | (__| '_/ _` / _| / / -_) '_|
|_|_\|___/_/ \_\  \___|_| \__,_\__|_\_\___|_|
                                   {CYAN}Anonymous17{YELLOW}
{RESET}"""
    print(banner)

def leer_llave_publica(ruta="public.key"):
    print(f"{BLUE}[*] Leyendo la llave pública desde {RED}{ruta}...{RESET}")
    with open(ruta, "r") as f:
        key_data = f.read()
    # Limpiar la clave PEM y decodificar en binario
    pem_lines = key_data.strip().splitlines()
    b64_data = "".join(pem_lines[1:-1])
    der_key = b64decode(b64_data)
    return RSA.importKey(der_key)

def obtener_parametros_rsa(pubkey):
    n = Integer(pubkey.n)
    e = Integer(pubkey.e)
    print(f"{BLUE}[*] Obteniendo valores de la llave pública{RESET}")
    print(f"{GREEN}[+] Valor de e {RED}-> {YELLOW}{e}{RESET}")
    print(f"{GREEN}[+] Valor de n {RED}-> {YELLOW}{n}{RESET}")
    return n, e

def factorizar_modulo(n):
    print(f"{BLUE}[*] Factorizando n...{RESET}")
    factors = n.factor()
    if len(factors) != 2:
        print(f"{RED}[-] Error: El módulo n no tiene exactamente dos factores primos.{RESET}")
        exit(1)
    p, q = [int(f[0]) for f in factors]
    print(f"{GREEN}[+] Valor de p {RED}-> {YELLOW}{p}{RESET}")
    print(f"{GREEN}[+] Valor de q {RED}-> {YELLOW}{q}{RESET}")
    return p, q

def calcular_clave_privada(e, p, q):
    phi = (p - 1) * (q - 1)
    d = inverse_mod(e, phi)
    print(f"{GREEN}[+] Valor de d {RED}-> {YELLOW}{d}{RESET}")
    return d

def construir_llave_privada(n, e, d, p, q):
    private_key = RSA_Crypto.construct((int(n), int(e), int(d), int(p), int(q)))
    print(f"\n{RED}[+] Llave privada completa:{RESET}\n")
    print(f"{RESET}{private_key.export_key().decode()}{RESET}\n")
    return private_key

# === Punto de entrada principal ===
def main():
    imprimir_banner()
    pubkey = leer_llave_publica()
    n, e = obtener_parametros_rsa(pubkey)
    p, q = factorizar_modulo(n)
    d = calcular_clave_privada(e, p, q)
    construir_llave_privada(n, e, d, p, q)

if __name__ == "__main__":
    main()

Cabe resaltar que usaremos SageMath (o simplemente Sage) que es un sistema de matemáticas computacionales de código abierto que combina herramientas como Python, álgebra, teoría de números, criptografía, cálculo simbólico y más. Es muy usado en matemáticas puras, criptografía y álgebra computacional.

🔧 Instalación rápida:

✅ En Debian/Ubuntu/Parrot:

sudo apt update
sudo apt install sagemath

✅ En Arch/Manjaro:

sudo pacman -S sagemath

También puedes usarlo online en: https://sagecell.sagemath.org o instalarlo vía conda.

Ahora si veamos como nuestro código resuelve este primer reto por decirlo así:

chmod 755 solver_1.py
./solver_1.py

Resultado

Perfecto, nuestro código pudo construir la llave privada correspondiente a la llave publica que nos genero el script server.py, ahora veamos si podemos descifrar el archivo que tenemos:

Y efectivamente hemos logrado descifrar el mensaje que previamente habíamos cifrado con una clave publica insegura, logrando así crear su correspondiente llave privada con nuestro script usando SageMath.

✅ Versión de solver_2.py que ejecuta y resuelve server.py automáticamente:

Este script:

• Ejecuta server.py como un subproceso.

• Detecta el bloque con la clave pública.

• Extrae n, lo factoriza con Sage.

• Envia los primos p y q como respuestas.

#!/usr/bin/env sage

import re
import pexpect
from Crypto.PublicKey import RSA
from sage.all import Integer, factor

def extract_rsa_key(output):
    """
    Extrae la clave RSA del texto de salida y devuelve n y e.
    """
    pattern = r"-----BEGIN PUBLIC KEY-----.*?-----END PUBLIC KEY-----"
    match = re.search(pattern, output, re.DOTALL)
    if not match:
        raise ValueError("No se encontró la clave pública")

    pub_key = RSA.import_key(match.group(0))
    return Integer(pub_key.n), Integer(pub_key.e)

def solve_server():
    # Ejecutamos server.py como un subproceso interactivo
    child = pexpect.spawn("python3 server.py", encoding='utf-8')

    rounds = 5
    for i in range(rounds):
        print(f"\n[+] Resolviendo ronda {i+1}/{rounds}...")

        # Esperamos hasta que aparezca la clave pública completa
        child.expect(r'-----END PUBLIC KEY-----')
        output = child.before + child.after  # Capturamos toda la salida hasta ese punto

        # Extraemos n y e
        n, e = extract_rsa_key(output)
        print(f"[+] n extraído: {n}")
        print(f"[+] e: {e} (típico valor común)")

        # Factorizamos n usando Sage
        print("[*] Factorizando n con Sage...")
        factors = factor(n)

        if len(factors) != 2:
            print("[-] Error: la factorización no tiene dos factores primos.")
            exit(1)

        p = int(factors[0][0])
        q = int(factors[1][0])

        print(f"[+] p encontrado: {p}")
        print(f"[+] q encontrado: {q}")

        # Enviamos las respuestas
        child.expect("enter your first pumkin = ")
        child.sendline(str(p))
        child.expect("enter your second pumkin = ")
        child.sendline(str(q))

    # Esperamos la flag
    child.expect(pexpect.EOF)
    print("\n[+] Flag capturada:")
    print(child.before)

if __name__ == "__main__":
    solve_server()

🔧 Requisitos

Asegúrate de tener instalado pexpect:

pip install pexpect

Y que el script server.py esté en el mismo directorio y sea ejecutable por python3.

🧪 ¿Cómo ejecutarlo?

sage solver_2.py # o ./solver_2.py

El script automáticamente:

• Lanza server.py

• Detecta cada ronda

• Extrae n

• Factoriza

• Envía p y q

• Al final, imprime la flag.

Resultado

Challenge resuelto.

🧩 5. La Importancia de Usar Claves Fuertes en el Hacking Ofensivo 💡

Cuando realizas pruebas de penetración o ataques de hacking ético, una de tus primeras metas es garantizar que los sistemas que estás probando utilizan claves públicas lo suficientemente robustas para proteger la información sensible.

Consejos para fortalecer tus claves públicas:

1. Tamaño de la clave: Asegúrate de que la clave RSA tenga al menos 2048 bits. No uses claves de 1024 bits, ya que son vulnerables a ataques de factorizar el módulo n en un tiempo razonable.

2. Utiliza generadores de números primos seguros: Elige generadores de números primos robustos y verifica que no existan vulnerabilidades en el algoritmo que utilices para generarlos.

3. Cambiar regularmente las claves: Asegúrate de cambiar las claves periódicamente y revocar aquellas que ya no sean necesarias o que puedan haber sido comprometidas.