---
# System prepended metadata

title: Fundamentos Criptográficos de Bitcoin - Glosario

---

# Cryptographic Foundations of Bitcoin - Glossary
###### tags: `bitcoin` `cryptography` `fundamentals` 

**Tabla de contenido**
[TOC]

## Autores
[Dulce Villarreal](https://www.linkedin.com/in/dulcevillarreal/) 
Mail para correcciones, comentarios o sugerencias: [dulce@libreriadesatoshi.com](https://twitter.com/Entreplanctony1)

El presente documentos fue elaborado para el curso de [Bitcoin Fundamentals](https://libreriadesatoshi.com/) a través de [@libreriadesatoshi](https://twitter.com/libdesatoshi).

# Fundamentos Criptográficos de Bitcoin - Glosario

*Definiciones organizadas según el orden del currículo*

---

## **Módulo 1: Fundamentos Criptográficos**

### **Criptografía**
**Definición Breve:** La ciencia de asegurar comunicaciones y datos a través de técnicas matemáticas, garantizando confidencialidad, integridad y autenticidad.

**Definición Técnica:** La criptografía es la ciencia matemática que diseña algoritmos y protocolos para asegurar sistemas de información contra ataques adversarios. Abarca cuatro objetivos principales: 
(1) **Confidencialidad** - asegurar que los datos sean accesibles solo a partes autorizadas, 
(2) **Integridad** - detectar modificaciones no autorizadas de datos, 
(3) **Autenticidad** - verificar la fuente de los datos, y 
(4) **No repudio** - prevenir la negación de acciones. La criptografía moderna se basa en la teoría de complejidad computacional, donde la seguridad se basa en la suposición de que ciertos problemas matemáticos (como la factorización de enteros o logaritmos discretos) son computacionalmente intratables para entradas grandes.

**Ejemplo:** Consideremos a Alicia enviando un mensaje a Roberto a través de un canal inseguro monitoreado por Eva (espía):
```
Texto plano:    "Transferir $100 a Roberto"
Clave:          k = 0x2A3F...
Cifrado:        E(mensaje, k) → texto cifrado
Texto cifrado:  0x8B9C2D...
Descifrado:     D(texto_cifrado, k) → "Transferir $100 a Roberto"
```

### **Confidencialidad**
**Definición Breve:** La propiedad de que la información sea accesible solo a partes autorizadas; los datos permanecen secretos de observadores no autorizados.

**Definición Técnica:** La confidencialidad en criptografía se define formalmente usando seguridad semántica o indistinguibilidad. Un esquema criptográfico proporciona confidencialidad si un adversario no puede distinguir entre cifrados de dos mensajes de su elección, incluso cuando se le da acceso a un oráculo de cifrado. Esto se formaliza a través de juegos como IND-CPA (Indistinguibilidad bajo Ataque de Texto Plano Elegido) donde la ventaja del adversario en distinguir cifrados debe ser despreciable.

**Ejemplo:** Las direcciones de Bitcoin proporcionan confidencialidad computacional a través de ECDSA:
```
Clave Privada: d = 0x18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725
Clave Pública: Q = d × G (multiplicación de punto de curva elíptica)
Dirección:     RIPEMD160(SHA256(Q)) → 1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2
```
Sin conocimiento de la clave privada `d`, es computacionalmente inviable vincular la dirección con el propietario.

### **Integridad**
**Definición Breve:** La garantía de que los datos no han sido alterados, corrompidos o manipulados durante la transmisión o almacenamiento.

**Definición Técnica:** La integridad criptográfica se logra a través de Códigos de Autenticación de Mensaje (MAC) o firmas digitales. Un esquema proporciona integridad si un adversario no puede producir una etiqueta de autenticación válida para un mensaje que no haya visto antes, formalizado a través de EUF-CMA (Falsificación Existencial bajo Ataque de Mensaje Elegido). La propiedad de integridad asegura que cualquier modificación a los datos será detectada con probabilidad abrumadora.

**Ejemplo:** Integridad de transacciones de Bitcoin usando firmas digitales:
```
Transacción: {de: Alicia, a: Roberto, cantidad: 1 BTC, nonce: 12345}
Hash: H(transacción) = SHA256(transacción) = 0x7A8B9C...
Firma: σ = ECDSA_firmar(clave_privada, H(transacción))
Verificación: ECDSA_verificar(clave_publica, H(transacción), σ) → Verdadero/Falso
```

Si alguien modifica la transacción (incluso cambiar 1 BTC a 2 BTC), la verificación de la firma fallará, detectando la manipulación.

### **Autenticidad**
**Definición Breve:** La verificación de que un mensaje, transacción o datos provienen de una fuente declarada y no han sido falsificados.

**Definición Técnica:** La autenticidad combina integridad con verificación de fuente. En criptografía de clave pública, la autenticidad se logra a través de firmas digitales que vinculan un mensaje a un poseedor específico de clave privada. La seguridad se basa en la propiedad de infalsificabilidad: dada una clave pública, es computacionalmente inviable producir una firma válida sin conocer la clave privada correspondiente. Esto se formaliza a través del modelo de seguridad EUF-CMA.

**Ejemplo:** Verificación de autenticidad de transacción Bitcoin:
```
Alicia afirma enviar 1 BTC a Roberto:

Datos de Transacción:
  Entrada: Referencia UTXO anterior
  Salida: Dirección de Roberto, 1 BTC
  Firma: σ_Alicia

Proceso de Verificación:
1. Extraer clave pública de Alicia de transacción anterior
2. Calcular hash del mensaje: h = SHA256(datos_transacción)
3. Verificar: ECDSA_verificar(pub_Alicia, h, σ_Alicia)
4. Si Verdadero → transacción es auténtica de Alicia
   Si Falso → transacción es falsa o corrupta
```

### **Criptografía Simétrica**
**Definición Breve:** Un sistema criptográfico donde la misma clave se usa tanto para cifrado como para descifrado; requiere distribución segura de claves.

**Definición Técnica:** La criptografía simétrica usa una sola clave secreta K compartida entre las partes comunicantes. La seguridad se basa en mantener K secreto y usar algoritmos como AES (Estándar de Cifrado Avanzado). El sistema proporciona seguridad semántica si el algoritmo de cifrado es indistinguible del azar bajo ataques de texto plano elegido. La gestión de claves es el desafío principal, requiriendo canales seguros para distribución de claves y rotación periódica de claves.

**Ejemplo:** Cifrado AES-256 (no usado directamente en Bitcoin, pero ilustrativo):
```
Clave: K = 0x000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F
Texto plano:  "Hola Mundo Bitcoin!"
VI:           0x101112131415161718191A1B1C1D1E1F (Vector de Inicialización)

Cifrado: C = AES-256-CBC(K, VI, texto_plano)
Texto cifrado: 0x8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B

Descifrado: AES-256-CBC-Descifrar(K, VI, C) → "Hola Mundo Bitcoin!"
```

### **Criptografía Asimétrica (Criptografía de Clave Pública)**
**Definición Breve:** Un sistema criptográfico que usa pares de claves matemáticamente relacionadas: una clave pública (compartida abiertamente) y una clave privada (mantenida en secreto).

**Definición Técnica:** La criptografía de clave pública se basa en funciones matemáticas de trampa - funciones que son fáciles de calcular en una dirección pero difíciles de revertir sin información especial (la trampa). El sistema usa pares de claves (pk, sk) donde pk es pública y sk es privada. La seguridad se basa en problemas matemáticos difíciles como factorización de enteros (RSA) o problema del logaritmo discreto (ECDSA). La propiedad fundamental es que conocer pk no proporciona una forma computacionalmente factible de determinar sk.

**Ejemplo:** Generación de claves ECDSA en Bitcoin:
```
Curva Elíptica: secp256k1: y² ≡ x³ + 7 (mod p)
Punto Generador: G = (0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D9..., 
                      0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08F...)

Generación de Claves:
1. Elegir clave privada aleatoria: d ∈ [1, n-1] donde n = orden de la curva
   d = 0x18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725

2. Calcular clave pública: Q = d × G (multiplicación escalar de curva elíptica)
   Q = (0x50863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B2352,
        0x2CD470243453A299FA9E77237716103ABC11A1DF38855ED6F2EE187E9C582BA6)

Relación Matemática: Q = d × G, pero encontrar d desde Q y G es el ECDLP (problema difícil)
```

### **Problema del Logaritmo Discreto**
**Definición Breve:** El problema computacional de encontrar el exponente x en la ecuación g^x ≡ h (mod p), considerado difícil para valores grandes.

**Definición Técnica:** Dado un grupo cíclico G de orden n con generador g, y un elemento h ∈ G, el problema del logaritmo discreto es encontrar el entero único x ∈ [0, n-1] tal que g^x = h. Los mejores algoritmos conocidos para resolver este problema (como rho de Pollard) requieren O(√n) operaciones, haciéndolo intratable para n suficientemente grande. En criptografía de curva elíptica, esto se convierte en el Problema del Logaritmo Discreto de Curva Elíptica (ECDLP).

**Ejemplo:** Logaritmo discreto en el contexto de secp256k1 de Bitcoin:
```
Dado:
- Curva elíptica secp256k1
- Punto generador G
- Punto de clave pública Q = d × G

Problema: Encontrar clave privada d dado Q y G

Formulación matemática:
Q = d × G = G + G + ... + G (d veces)

Conocido: Q = (x_Q, y_Q), G = (x_G, y_G)
Desconocido: d (el logaritmo discreto)

Seguridad: Los mejores algoritmos conocidos requieren aproximadamente 2^128 operaciones
          para las claves de 256 bits de secp256k1, haciéndolo computacionalmente inviable

Valores de ejemplo:
G = (0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
     0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)

Si d = 123456789, entonces Q = 123456789 × G
Encontrar d desde Q es el problema difícil que asegura las direcciones de Bitcoin
```

---

## **Módulo 2: Funciones Hash e Integridad de Datos**

### **Función Hash**
**Definición Breve:** Una función matemática que transforma datos de entrada de cualquier tamaño en una salida de tamaño fijo (valor hash o resumen).

**Definición Técnica:** Una función hash criptográfica H: {0,1}* → {0,1}^n es un algoritmo determinístico que mapea cadenas de bits de longitud arbitraria a cadenas de n bits de longitud fija. Debe satisfacer tres propiedades de seguridad: (1) Resistencia a preimagen: dado h, es difícil encontrar m tal que H(m) = h, (2) Resistencia a segunda preimagen: dado m₁, es difícil encontrar m₂ ≠ m₁ tal que H(m₁) = H(m₂), (3) Resistencia a colisión: es difícil encontrar cualquier m₁ ≠ m₂ tal que H(m₁) = H(m₂). La función también debe exhibir el efecto avalancha y producir salidas uniformemente distribuidas.

**Ejemplo:** Función hash SHA-256 usada en Bitcoin:
```
Mensaje de entrada: "Hola Bitcoin"
Representación binaria: 01001000 01101111 01101100 01100001 00100000 01000010 01101001 01110100 01100011 01101111 01101001 01101110

Procesamiento SHA-256:
1. Preprocesamiento: Rellenar mensaje a bloques de 512 bits
   Original: "Hola Bitcoin" (12 bytes = 96 bits)
   Rellenado: 96 bits + 1 bit + 351 bits cero + 64 bits longitud = 512 bits

2. Inicializar valores hash (primeros 32 bits de partes fraccionarias de raíces cuadradas de los primeros 8 primos):
   h₀ = 0x6a09e667, h₁ = 0xbb67ae85, h₂ = 0x3c6ef372, h₃ = 0xa54ff53a
   h₄ = 0x510e527f, h₅ = 0x9b05688c, h₆ = 0x1f83d9ab, h₇ = 0x5be0cd19

3. Procesar bloques a través de 64 rondas de operaciones
4. Hash final: 0x8A47C8B45F2E1D093E756B42A1C8F94D76E3B25A90F4C7D1E6A2B5F8C3E9D7A4

Propiedades demostradas:
- Determinístico: La misma entrada siempre produce el mismo hash
- Salida fija: Siempre 256 bits sin importar el tamaño de entrada
- Efecto avalancha: Cambiar un bit en la entrada cambia drásticamente la salida
```

### **Efecto Avalancha**
**Definición Breve:** Una propiedad donde un pequeño cambio en la entrada produce una salida dramáticamente diferente; crucial para la seguridad.

**Definición Técnica:** El efecto avalancha requiere que cambiar cualquier bit de entrada resulte en que cada bit de salida cambie con probabilidad 1/2. Matemáticamente, para una función hash H, si las entradas x y x' difieren en exactamente un bit, entonces H(x) y H(x') deberían diferir en aproximadamente n/2 bits para una salida de n bits. Esta propiedad asegura que entradas similares no produzcan salidas similares, previniendo ataques de análisis de patrones y asegurando distribución uniforme de valores hash.

**Ejemplo:** Demostrando efecto avalancha en SHA-256:
```
Mensaje original: "Bitcoin"
SHA-256: 0x6B88C087247AA2F07EE1C5956B8E1A9F4C7F892A70E324F1BB3D161E05CA107B

Mensaje cambiado: "bitcoin" (solo cambio de mayúscula)
SHA-256: 0x7FA9F77DC04BE0E0FFC5CF513DC0E4F29E0B81DEF7A5C28B9689DA9E84FF5C62

Análisis de diferencia de bits:
Original:  0110101110001000110000100111...
Cambiado:  0111111110101001110111000000...
XOR:       0001010000101101000111000111...

Distancia de Hamming: 131 bits diferentes de 256 (51.2% ≈ 50% ideal)

Esto demuestra efecto avalancha perfecto - un cambio pequeño en la entrada 
causa que aproximadamente la mitad de los bits de salida cambien.
```

### **Puntero Hash**
**Definición Breve:** Una estructura de datos que contiene tanto la ubicación de datos como un hash criptográfico de esos datos, habilitando detección de manipulación.

**Definición Técnica:** Un puntero hash es una tupla (ptr, H(datos)) donde ptr es una dirección de memoria o referencia a datos, y H(datos) es el hash criptográfico de esos datos. Esta estructura proporciona tanto capacidad de direccionamiento como verificación de integridad. Cualquier modificación a los datos referenciados causará una discordancia de hash, detectando inmediatamente la manipulación. Los punteros hash pueden encadenarse para crear estructuras de datos resistentes a manipulación como blockchains.

**Ejemplo:** Blockchain de Bitcoin usando punteros hash:
```
Estructura de Bloque:
┌─────────────────────────────────────┐
│          Encabezado de Bloque       │
│  ┌─────────────────────────────────┐ │
│  │ Hash Bloque Anterior (Ptr Hash) │ │ ← Apunta al bloque anterior
│  │ Raíz Merkle                     │ │ ← Hash de todas las transacciones
│  │ Marca de Tiempo                 │ │
│  │ Objetivo de Dificultad          │ │
│  │ Nonce                           │ │
│  └─────────────────────────────────┘ │
├─────────────────────────────────────┤
│           Transacciones             │
│  Transacción 1                      │
│  Transacción 2                      │
│  ...                               │
│  Transacción n                      │
└─────────────────────────────────────┘

Cadena de Punteros Hash:
Bloque N-1 → Bloque N → Bloque N+1
    ↑         ↑         ↑
   Hash     Hash     Hash
   Ptr      Ptr      Ptr

Ejemplo:
Hash Encabezado Bloque 100: 0x00000000000003ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506
Hash Anterior Bloque 101: 0x00000000000003ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506

Si el Bloque 100 es manipulado:
- Nuevo Hash Bloque 100: 0x00000000000003ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e999
- Hash Anterior Bloque 101: 0x00000000000003ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506
- ¡Discordancia detectada! Integridad de cadena violada.
```

### **Árbol Merkle**
**Definición Breve:** Una estructura de datos de árbol binario donde los nodos hoja contienen hashes de datos y los nodos internos contienen hashes de sus hijos.

**Definición Técnica:** Un árbol Merkle es un árbol binario completo donde cada nodo hoja contiene el hash de un bloque de datos, y cada nodo interno contiene el hash de la concatenación de los hashes de sus hijos. Para un árbol con n hojas, la raíz representa un compromiso con todos los n bloques de datos. El árbol habilita pruebas de membresía eficientes: para probar que un bloque de datos está incluido, solo se necesitan proporcionar O(log n) hashes (los hermanos a lo largo del camino desde la hoja hasta la raíz). La seguridad se basa en la resistencia a colisión de la función hash subyacente.

**Ejemplo:** Árbol Merkle de transacciones Bitcoin:
```
Consideremos 4 transacciones en un bloque:

Transacciones (hojas):
Tx1: "Alicia → Roberto: 1 BTC"     → H(Tx1) = 0xA1B2...
Tx2: "Roberto → Carlos: 0.5 BTC"   → H(Tx2) = 0xC3D4...
Tx3: "Carlos → David: 0.3 BTC"     → H(Tx3) = 0xE5F6...
Tx4: "David → Eva: 0.2 BTC"        → H(Tx4) = 0x7890...

Construcción del Árbol Merkle:
                    Raíz
                 H(H12 + H34)
                /           \
           H12               H34
        H(H1+H2)          H(H3+H4)
        /      \          /      \
    H(Tx1)   H(Tx2)   H(Tx3)   H(Tx4)
     A1B2     C3D4     E5F6     7890

Cálculo paso a paso:
Nivel 1: H12 = SHA256(A1B2 + C3D4) = 0x1234...
         H34 = SHA256(E5F6 + 7890) = 0x5678...

Nivel 0: Raíz = SHA256(1234 + 5678) = 0x9ABC...

Prueba de inclusión para Tx1:
Prueba = [H(Tx2), H34] = [C3D4, 5678]
Verificación:
1. Calcular H12' = SHA256(A1B2 + C3D4) ✓
2. Calcular Raíz' = SHA256(H12' + 5678) ✓
3. Verificar Raíz' == Raíz ✓

Eficiencia: Solo 2 hashes necesarios en lugar de las 4 transacciones completas
```

### **SPV (Verificación Simplificada de Pagos)**
**Definición Breve:** Un método para que los clientes de Bitcoin verifiquen transacciones sin descargar toda la blockchain usando pruebas Merkle.

**Definición Técnica:** SPV es un método de verificación ligero donde los clientes descargan solo encabezados de bloque (80 bytes cada uno) en lugar de bloques completos (típicamente 1-4 MB). Para verificar una transacción, el cliente solicita una prueba Merkle de nodos completos. El cliente puede verificar inclusión de transacción: (1) Calculando la raíz Merkle usando la prueba, (2) Verificando que la raíz calculada coincide con la raíz Merkle en el encabezado del bloque, (3) Verificando que el encabezado del bloque tiene suficiente prueba de trabajo. SPV proporciona seguridad probabilística: mientras más confirmaciones (bloques subsecuentes), mayor la confianza.

**Ejemplo:** Proceso de verificación SPV:
```
Cliente SPV quiere verificar: "Alicia envió 1 BTC a Roberto" en Bloque 750,000

Paso 1: Descargar solo encabezados de bloque
Encabezado Bloque 750,000 (80 bytes):
├─ Hash Anterior: 0x000000000000000000024bead8df69990852c202db0e0097c1a12ea637d7e96d
├─ Raíz Merkle:   0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b
├─ Marca Tiempo:  1659277149
├─ Dificultad:    0x1712daa9
├─ Nonce:         1914849169

Paso 2: Solicitar prueba Merkle para transacción Alicia→Roberto
Prueba recibida:
├─ Hash Transacción: 0x8b30c40183ce5c3dc6ba146da61c55c456abc955c5cd6513b8cbfb04c28c3717
├─ Camino Merkle: [0x2f37b56d4e, 0x9a45c831f2, 0x6b8e7d23a1] (hashes hermanos)
├─ Índices Camino: [0, 1, 0] (izquierda=0, derecha=1 en cada nivel)

Paso 3: Verificar inclusión
raiz_merkle_calculada = verificar_prueba_merkle(
    hash_tx=0x8b30c40183ce5c3dc6ba146da61c55c456abc955c5cd6513b8cbfb04c28c3717,
    prueba=[0x2f37b56d4e, 0x9a45c831f2, 0x6b8e7d23a1],
    indices=[0, 1, 0]
)

Nivel 2: SHA256(0x8b30c40183... + 0x2f37b56d4e) = 0x1a2b3c...
Nivel 1: SHA256(0x9a45c831f2 + 0x1a2b3c...) = 0x4d5e6f...  
Nivel 0: SHA256(0x4d5e6f... + 0x6b8e7d23a1) = 0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b

Resultado: Raíz calculada coincide con raíz Merkle del encabezado ✓
Almacenamiento: ~300 bytes vs ~2MB bloque completo (reducción 99.985%)
```

---

## **Módulo 4: Firmas Digitales**

### **ECDSA (Algoritmo de Firma Digital de Curva Elíptica)**
**Definición Breve:** El esquema de firma digital principal de Bitcoin basado en criptografía de curva elíptica y logaritmos discretos.

**Definición Técnica:** ECDSA es una variante de DSA usando aritmética de curva elíptica. Opera en la curva secp256k1: y² ≡ x³ + 7 (mod p) donde p = 2²⁵⁶ - 2³² - 977. El algoritmo consiste en tres fases: (1) Generación de claves: seleccionar clave privada aleatoria d ∈ [1, n-1] y calcular clave pública Q = d×G, (2) Firmado: para mensaje m, seleccionar k aleatorio, calcular r = (k×G).x mod n y s = k⁻¹(H(m) + d×r) mod n, salida (r,s), (3) Verificación: calcular u₁ = H(m)×s⁻¹ mod n y u₂ = r×s⁻¹ mod n, verificar si r ≡ (u₁×G + u₂×Q).x mod n.

**Ejemplo:** Proceso completo de firma ECDSA:
```
Parámetros de Curva Elíptica (secp256k1):
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
G = (0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
     0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)

Generación de Claves:
Clave privada: d = 0x18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725
Clave pública:  Q = d × G = (Qx, Qy)

Mensaje a firmar: "Transferir 1 BTC a Roberto"
Hash mensaje: z = SHA256("Transferir 1 BTC a Roberto") = 0x1D2E3F...

Generación de Firma:
1. Generar nonce aleatorio: k = 0x2A5B7C8D9E0F1A2B3C4D5E6F7A8B9C0D1E2F3A4B5C6D7E8F9A0B1C2D3E4F5A6B
2. Calcular punto: (x₁, y₁) = k × G
3. Calcular r = x₁ mod n = 0x4B5A6C7D...
4. Calcular s = k⁻¹(z + d×r) mod n = 0x8E9F0A1B...
5. Firma: (r, s) = (0x4B5A6C7D..., 0x8E9F0A1B...)

Verificación:
1. Verificar 0 < r < n y 0 < s < n ✓
2. Calcular w = s⁻¹ mod n
3. Calcular u₁ = z×w mod n y u₂ = r×w mod n
4. Calcular punto: (x₂, y₂) = u₁×G + u₂×Q
5. Verificar: r ≡ x₂ mod n ✓

Seguridad: Romper requiere resolver ECDLP (encontrar d desde Q) o romper SHA-256
```

### **Nonce**
**Definición Breve:** Un valor aleatorio usado en
