"""Cuánto tardaría la fuerza bruta contra una billetera SERO. Licencia MIT, Ostermann Laboratories.

Reproduce, con números reales, la tabla de https://web.sero.foundation/fuerza-bruta/

    python calculo.py                 (usa capitulos.json, que está junto a este archivo)
    python calculo.py --medir         (además mide Argon2id en tu computadora; pip install argon2-cffi)

Qué se cuenta (ver https://web.sero.foundation/llave/especificacion.txt):
  - Estándar: el libro (17), el pasaje dentro de un capítulo (cualquier inicio y fin), el avatar (17)
    y el aterrizador: cédula o matrícula (la bifurcación entre las dos ya es un dato más que adivinar).
  - Avanzada: lo mismo con dos pasajes.
  - Máxima: 12 palabras al azar (128 bits).
Cada intento obliga a calcular Argon2id con 64 MiB de memoria y 3 pasadas: no hay atajo.
"""
import json, math, pathlib, sys, time

AQUI = pathlib.Path(__file__).resolve().parent
datos = json.loads((AQUI / "capitulos.json").read_text(encoding="utf-8"))

# Pasajes posibles: en un capítulo de n palabras, un pasaje es un inicio y un fin (inicio ≤ fin): n × (n + 1) / 2.
PASAJES = sum(n * (n + 1) // 2 for libro in datos["libros"] for n in libro["palabras_por_capitulo"])
AVATARES = 17
# El aterrizador: tu cédula o una matrícula (de carro o de moto). SERO no verifica que sea venezolana ni real:
# sirve el documento de cualquier país o un número inventado. Por eso damos dos cotas:
#   piso:  solo las cédulas venezolanas plausibles (hasta 35 millones) y la bifurcación cédula/matrícula (x2);
#   techo: todo lo que la activación acepta: cédulas de hasta 10 dígitos y matrículas de hasta 12 caracteres
#          entre 37 posibles (A-Z, 0-9 y «-»), según la especificación.
ATERRIZADORES_PISO = 35_000_000 * 2
ATERRIZADORES_TECHO = 10 ** 10 + sum(37 ** k for k in range(1, 13))

ESCENARIOS = {
    "Estándar, a ciegas (piso: solo cédulas venezolanas)": PASAJES * AVATARES * ATERRIZADORES_PISO,
    "Estándar, a ciegas (techo: cualquier cédula o matrícula)": PASAJES * AVATARES * ATERRIZADORES_TECHO,
    "Estándar, si ya saben tu cédula o matrícula": PASAJES * AVATARES,
    "Estándar, si ya saben tu cédula o matrícula y tu avatar": PASAJES,
    "Avanzada, a ciegas (piso: solo cédulas venezolanas)": PASAJES ** 2 * AVATARES * ATERRIZADORES_PISO,
    "Avanzada, a ciegas (techo: cualquier cédula o matrícula)": PASAJES ** 2 * AVATARES * ATERRIZADORES_TECHO,
    "Avanzada, si ya saben tu cédula o matrícula": PASAJES ** 2 * AVATARES,
    "Avanzada, si ya saben tu cédula o matrícula y tu avatar": PASAJES ** 2,
    "Máxima (12 palabras)": 2 ** 128,
}
# Intentos por segundo. 50 es lo medido con Argon2id de SERO en una computadora de 12 núcleos
# (236 ms por intento y por núcleo, 8 de noviembre de 2026). Corre --medir para la tuya.
ATACANTES = {"Una computadora potente": 50, "Cien computadoras": 5_000}

AÑO = 365.25 * 24 * 3600


def años(espacio, por_segundo):
    return espacio / 2 / por_segundo / AÑO  # en promedio se acierta a mitad de camino


UNIVERSO = 13.8e9  # años de edad del universo, para tener una escala


def en_palabras(n):
    """«63 mil millones», «1,5 mil trillones», «224»."""
    for valor, nombre in [(1e21, "mil trillones"), (1e18, "trillones"), (1e15, "mil billones"), (1e12, "billones"), (1e9, "mil millones"), (1e6, "millones")]:
        if n >= valor:
            q = n / valor
            numero = f"{q:.1f}".replace(".", ",").removesuffix(",0") if q < 10 else f"{q:,.0f}".replace(",", ".")
            return f"{numero} {nombre} de"
    return f"{n:,.0f}".replace(",", ".")


def legible(a):
    """Días o años mientras se entienden; más allá de la edad del universo, cuántas veces esa edad."""
    if a < 1: return f"{a * 365.25:.0f} días"
    if a < 10: return f"{a:.1f} años".replace(".", ",")
    if a >= UNIVERSO:
        veces = a / UNIVERSO
        return "más que la edad del universo" if veces < 2 else f"{en_palabras(veces)} veces la edad del universo"
    texto = en_palabras(a)
    return f"{texto} años"


if "--medir" in sys.argv:
    import os
    from argon2.low_level import Type, hash_secret_raw
    hash_secret_raw(b"calentar", b"s" * 32, time_cost=3, memory_cost=65536, parallelism=1, hash_len=32, type=Type.ID)
    t = time.perf_counter()
    for i in range(8):
        hash_secret_raw(str(i).encode(), b"s" * 32, time_cost=3, memory_cost=65536, parallelism=1, hash_len=32, type=Type.ID)
    ms = (time.perf_counter() - t) / 8 * 1000
    nucleos = os.cpu_count() or 1
    ATACANTES = {f"Tu computadora ({nucleos} núcleos, {ms:.0f} ms por intento)": 1000 / ms * nucleos, **ATACANTES}

# Las cuentas privadas (direcciones sigilosas) salen de la misma llave electrónica de acceso: el ataque de arriba
# las cubre a todas. Adivinar directamente la llave de una sola de ellas obliga a resolver el problema matemático
# de la curva secp256k1 (el «logaritmo discreto», unas 2^128 operaciones con el método rho de Pollard).
# Suponemos mil millones de operaciones por segundo por computadora, que es generoso con el atacante.
OPERACIONES_CURVA = 2 ** 128
CURVA_POR_SEGUNDO = 1_000_000_000

print(f"Capítulos: {sum(len(l['palabras_por_capitulo']) for l in datos['libros'])}   Pasajes posibles: {PASAJES:,}".replace(",", "."))
for nombre, espacio in ESCENARIOS.items():
    print(f"\n{nombre}: {math.log2(espacio):.1f} bits")
    for atacante, v in ATACANTES.items():
        print(f"   {atacante:>45}: {legible(años(espacio, v))}")

print("\nUna cuenta privada atacada directamente (la curva secp256k1, unas 2^128 operaciones)")
for atacante, n in {"Una computadora potente": 1, "Cien computadoras": 100}.items():
    print(f"   {atacante:>45}: {legible(OPERACIONES_CURVA / 2 / (CURVA_POR_SEGUNDO * n) / AÑO)}")
