Zero-Knowledge Proofs (ZKP) son protocolos criptográficos que permiten a una parte (prover) demostrar a otra (verifier) que conoce un secreto sin revelar información sobre el secreto.

¿Qué son Zero-Knowledge Proofs?

Un zero-knowledge proof es un método criptográfico que permite probar la posesión de información sin revelar la información misma, manteniendo la privacidad total.

Propiedades Fundamentales

Completitud (Completeness)

  • Definición: Si el prover conoce el secreto, puede convencer al verifier
  • Probabilidad: Alta probabilidad de éxito
  • Condición: P(verifier acepta | prover honesto) ≈ 1

Solidez (Soundness)

  • Definición: Si el prover no conoce el secreto, no puede convencer al verifier
  • Probabilidad: Baja probabilidad de éxito
  • Condición: P(verifier acepta | prover deshonesto) ≈ 0

Zero-Knowledge

  • Definición: El verifier no aprende nada sobre el secreto
  • Simulación: El verifier puede simular la conversación sin el secreto
  • Privacidad: Información cero sobre el secreto

Tipos de Zero-Knowledge Proofs

Interactive ZKPs

  • Múltiples rondas: Prover y verifier interactúan
  • Desafío-respuesta: Patrón de desafío-respuesta
  • Ejemplo: Protocolo de Fiat-Shamir
  • Aplicación: Autenticación

Non-Interactive ZKPs

  • Una sola ronda: Prover genera prueba sin interacción
  • Verificación independiente: Verifier puede verificar solo
  • Ejemplo: zk-SNARKs, zk-STARKs
  • Aplicación: Blockchain

Succinct ZKPs

  • Pruebas cortas: Tamaño constante independiente del input
  • Verificación rápida: Verificación en tiempo polinomial
  • Ejemplo: zk-SNARKs
  • Aplicación: Escalabilidad

Protocolos Clásicos

Protocolo de Fiat-Shamir

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

import hashlib
import random

class FiatShamir:
    def __init__(self, n, s):
        self.n = n  # Módulo RSA
        self.s = s  # Secreto
        self.v = (s * s) % n  # Valor público
    
    def prove(self):
        # Paso 1: Prover elige r aleatorio
        r = random.randint(1, self.n - 1)
        x = (r * r) % self.n
        
        # Paso 2: Verifier elige desafío aleatorio
        c = random.randint(0, 1)
        
        # Paso 3: Prover responde
        if c == 0:
            y = r
        else:
            y = (r * self.s) % self.n
        
        return x, c, y
    
    def verify(self, x, c, y):
        # Verificar respuesta
        if c == 0:
            return (y * y) % self.n == x
        else:
            return (y * y) % self.n == (x * self.v) % self.n

# Ejemplo de uso
n = 77  # 7 * 11
s = 4   # Secreto
protocol = FiatShamir(n, s)

# Prover demuestra conocimiento
x, c, y = protocol.prove()
is_valid = protocol.verify(x, c, y)
print(f"Proof valid: {is_valid}")

Protocolo de Schnorr

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes
import secrets

class SchnorrProof:
    def __init__(self, private_key, public_key):
        self.private_key = private_key
        self.public_key = public_key
        self.curve = ec.SECP256R1()
    
    def prove(self, message):
        # Generar nonce aleatorio
        k = secrets.randbelow(self.curve.key_size)
        
        # Calcular R = k * G
        R = self.curve.generator * k
        
        # Calcular hash
        h = hashlib.sha256(message.encode()).digest()
        c = int.from_bytes(h, 'big') % self.curve.order
        
        # Calcular s = k + c * private_key
        s = (k + c * self.private_key) % self.curve.order
        
        return R, s
    
    def verify(self, message, R, s):
        # Calcular hash
        h = hashlib.sha256(message.encode()).digest()
        c = int.from_bytes(h, 'big') % self.curve.order
        
        # Verificar s * G = R + c * public_key
        left = self.curve.generator * s
        right = R + self.public_key * c
        
        return left == right

zk-SNARKs

¿Qué son zk-SNARKs?

  • Zero-Knowledge: No revela información
  • Succinct: Pruebas cortas
  • Non-Interactive: Sin interacción
  • Arguments: Argumentos de conocimiento
  • of Knowledge: De conocimiento

Componentes

  • Setup: Configuración inicial
  • Proving: Generación de pruebas
  • Verification: Verificación de pruebas
  • Trusted Setup: Configuración de confianza

Aplicaciones

  • Blockchain: Privacidad en transacciones
  • Voting: Votación privada
  • Identity: Identidad sin revelar datos
  • Compliance: Cumplimiento privado

zk-STARKs

¿Qué son zk-STARKs?

  • Zero-Knowledge: No revela información
  • Scalable: Escalable
  • Transparent: Transparente
  • Arguments: Argumentos de conocimiento
  • of Knowledge: De conocimiento

Ventajas sobre zk-SNARKs

  • No trusted setup: Sin configuración de confianza
  • Quantum resistant: Resistente a computación cuántica
  • Transparent: Configuración transparente
  • Scalable: Mejor escalabilidad

Aplicaciones Prácticas

Blockchain y Criptomonedas

  • Zcash: Privacidad en transacciones
  • Monero: Privacidad mejorada
  • Ethereum: L2 solutions (zkSync, Polygon)
  • Bitcoin: Lightning Network

Identidad Digital

  • Self-Sovereign Identity: Identidad soberana
  • Age Verification: Verificación de edad
  • Credential Verification: Verificación de credenciales
  • Privacy-Preserving: Preservación de privacidad

Votación Electrónica

  • Secret Ballot: Voto secreto
  • Verifiable: Votación verificable
  • Anonymous: Anónima
  • Transparent: Transparente

Machine Learning

  • Model Privacy: Privacidad del modelo
  • Data Privacy: Privacidad de datos
  • Inference Privacy: Privacidad de inferencia
  • Training Privacy: Privacidad de entrenamiento

Implementación Práctica

Circom (Circuit Compiler)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// Ejemplo de circuito Circom
template Main() {
    signal private input secret;
    signal public input hash;
    signal output out;
    
    // Verificar que hash = SHA256(secret)
    component hasher = SHA256(1);
    hasher.in[0] <== secret;
    hash === hasher.out;
    
    out <== 1;
}

component main = Main();

SnarkJS

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

const snarkjs = require("snarkjs");

async function generateProof(input) {
    // Generar prueba
    const { proof, publicSignals } = await snarkjs.groth16.fullProve(
        input,
        "circuit.wasm",
        "circuit_final.zkey"
    );
    
    return { proof, publicSignals };
}

async function verifyProof(proof, publicSignals) {
    // Verificar prueba
    const vKey = await snarkjs.zKey.exportVerificationKey("circuit_final.zkey");
    const res = await snarkjs.groth16.verify(vKey, publicSignals, proof);
    
    return res;
}

Ventajas y Desventajas

Ventajas

  • Privacidad: Privacidad total
  • Verificabilidad: Verificación independiente
  • Escalabilidad: Pruebas cortas
  • Flexibilidad: Múltiples aplicaciones

Desventajas

  • Complejidad: Implementación compleja
  • Overhead: Costo computacional
  • Trusted Setup: Algunos requieren configuración de confianza
  • Quantum Vulnerability: Vulnerabilidad cuántica (algunos)

Casos de Uso Específicos

Finanzas Descentralizadas (DeFi)

  • Private Transactions: Transacciones privadas
  • Liquidity Proofs: Pruebas de liquidez
  • Credit Scoring: Puntuación crediticia privada
  • Risk Assessment: Evaluación de riesgo privada

Supply Chain

  • Product Authentication: Autenticación de productos
  • Quality Proofs: Pruebas de calidad
  • Origin Verification: Verificación de origen
  • Compliance Proofs: Pruebas de cumplimiento

Healthcare

  • Medical Records: Registros médicos privados
  • Drug Authentication: Autenticación de medicamentos
  • Clinical Trials: Ensayos clínicos privados
  • Patient Privacy: Privacidad del paciente

Herramientas y Frameworks

Desarrollo

  • Circom: Compilador de circuitos
  • SnarkJS: Librería JavaScript
  • libsnark: Librería C++
  • Arkworks: Framework Rust

Verificación

  • Verification Tools: Herramientas de verificación
  • Testing Frameworks: Frameworks de prueba
  • Security Audits: Auditorías de seguridad
  • Performance Tools: Herramientas de rendimiento

Conceptos Relacionados

  • ECC - Algoritmo usado en zero-knowledge proofs
  • RSA - Algoritmo usado en zero-knowledge proofs
  • Funciones Hash - Algoritmos usados en zero-knowledge proofs
  • Criptoanálisis - Análisis de zero-knowledge proofs
  • CISO - Rol que supervisa zero-knowledge proofs
  • Ciberseguridad General - Disciplina que incluye zero-knowledge proofs
  • Brechas de seguridad - Incidentes que afectan zero-knowledge proofs
  • Vectores de ataque - Ataques contra zero-knowledge proofs
  • Incident Response - Proceso que incluye zero-knowledge proofs
  • SIEM - Sistema que monitorea zero-knowledge proofs
  • SOAR - Automatización que gestiona zero-knowledge proofs
  • EDR - Herramienta que protege zero-knowledge proofs
  • Firewall - Dispositivo que puede inspeccionar zero-knowledge proofs
  • VPN - Conexión que puede usar zero-knowledge proofs
  • Dashboards - Visualización de métricas zero-knowledge proofs
  • Registros - Logs de operaciones zero-knowledge proofs

Referencias