Criptografía Aplicada

const crypto = require('crypto');

// Función para cifrar datos con AES-256-GCM
function encryptData(plaintext, key) {
  // Generar un IV aleatorio
  const iv = crypto.randomBytes(12);
  
  // Crear cipher con AES-256-GCM
  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
  
  // Cifrar los datos
  let encrypted = cipher.update(plaintext, 'utf8', 'base64');
  encrypted += cipher.final('base64');
  
  // Obtener el tag de autenticación
  const authTag = cipher.getAuthTag();
  
  // Devolver IV, datos cifrados y tag de autenticación
  return {
    iv: iv.toString('base64'),
    encryptedData: encrypted,
    authTag: authTag.toString('base64')
  };
}

// Función para descifrar datos con AES-256-GCM
function decryptData(encryptedObj, key) {
  // Convertir IV y authTag de base64 a Buffer
  const iv = Buffer.from(encryptedObj.iv, 'base64');
  const authTag = Buffer.from(encryptedObj.authTag, 'base64');
  
  // Crear decipher
  const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
  
  // Establecer el tag de autenticación
  decipher.setAuthTag(authTag);
  
  // Descifrar los datos
  let decrypted = decipher.update(encryptedObj.encryptedData, 'base64', 'utf8');
  decrypted += decipher.final('utf8');
  
  return decrypted;
}

// Ejemplo de uso
const key = crypto.randomBytes(32); // Clave de 256 bits
const plaintext = 'Información confidencial que necesita protección';

const encrypted = encryptData(plaintext, key);
console.log('Datos cifrados:', encrypted);

const decrypted = decryptData(encrypted, key);
console.log('Datos descifrados:', decrypted);

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

# Generar par de claves RSA
def generate_rsa_keys():
    # Generar clave privada
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048
    )
    
    # Derivar clave pública
    public_key = private_key.public_key()
    
    # Serializar clave privada en formato PEM
    private_pem = private_key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption()
    )
    
    # Serializar clave pública en formato PEM
    public_pem = public_key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    )
    
    return private_pem, public_pem, private_key, public_key

# Cifrar datos con clave pública
def encrypt_with_rsa(public_key, plaintext):
    ciphertext = public_key.encrypt(
        plaintext.encode('utf-8'),
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    return ciphertext

# Descifrar datos con clave privada
def decrypt_with_rsa(private_key, ciphertext):
    plaintext = private_key.decrypt(
        ciphertext,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    return plaintext.decode('utf-8')

# Ejemplo de uso
private_pem, public_pem, private_key, public_key = generate_rsa_keys()

# Mensaje a cifrar
message = "Mensaje confidencial para cifrado asimétrico"

# Cifrar con clave pública
encrypted = encrypt_with_rsa(public_key, message)
print(f"Mensaje cifrado: {encrypted.hex()}")

# Descifrar con clave privada
decrypted = decrypt_with_rsa(private_key, encrypted)
print(f"Mensaje descifrado: {decrypted}")

const argon2 = require('argon2');

// Función para hashear una contraseña con Argon2id
async function hashPassword(password) {
  try {
    // Configuración recomendada para Argon2id
    const hash = await argon2.hash(password, {
      type: argon2.argon2id,      // Variante más segura
      memoryCost: 65536,          // 64 MiB en KB
      timeCost: 3,                // Número de iteraciones
      parallelism: 4,             // Grado de paralelismo
      hashLength: 32,             // Longitud del hash en bytes
    });
    
    return hash;
  } catch (error) {
    console.error('Error al hashear la contraseña:', error);
    throw error;
  }
}

// Función para verificar una contraseña contra un hash almacenado
async function verifyPassword(hash, password) {
  try {
    return await argon2.verify(hash, password);
  } catch (error) {
    console.error('Error al verificar la contraseña:', error);
    return false;
  }
}

// Ejemplo de uso
async function main() {
  const password = 'Contraseña.Segura.123';
  
  // Hashear la contraseña para almacenarla
  const hash = await hashPassword(password);
  console.log('Hash generado:', hash);
  
  // Verificar contraseña correcta
  const isValid = await verifyPassword(hash, password);
  console.log('¿Contraseña válida?', isValid); // true
  
  // Verificar contraseña incorrecta
  const isInvalid = await verifyPassword(hash, 'ContraseñaIncorrecta');
  console.log('¿Contraseña incorrecta válida?', isInvalid); // false
}

main();

const https = require('https');
const fs = require('fs');
const express = require('express');

const app = express();

// Middleware y rutas
app.get('/', (req, res) => {
  res.send('¡Servidor HTTPS seguro funcionando!');
});

// Opciones de TLS con configuración segura
const options = {
  key: fs.readFileSync('ruta/a/clave-privada.key'),
  cert: fs.readFileSync('ruta/a/certificado.crt'),
  // Configuración moderna y segura de TLS
  minVersion: 'TLSv1.2',
  // Cifrados recomendados (orden de preferencia)
  ciphers: [
    'TLS_AES_256_GCM_SHA384',
    'TLS_CHACHA20_POLY1305_SHA256',
    'TLS_AES_128_GCM_SHA256',
    'ECDHE-RSA-AES256-GCM-SHA384',
    'ECDHE-RSA-AES128-GCM-SHA256',
    'ECDHE-RSA-CHACHA20-POLY1305'
  ].join(':'),
  // Habilitar Perfect Forward Secrecy
  honorCipherOrder: true,
  // Opciones HSTS
  maxAge: 31536000, // 1 año en segundos
  includeSubDomains: true,
  preload: true
};

// Crear servidor HTTPS
const server = https.createServer(options, app);

// Iniciar servidor
server.listen(443, () => {
  console.log('Servidor HTTPS ejecutándose en el puerto 443');
});

// Redirigir HTTP a HTTPS
const http = require('http');
http.createServer((req, res) => {
  res.writeHead(301, { 'Location': 'https://' + req.headers.host + req.url });
  res.end();
}).listen(80);

const jwt = require('jsonwebtoken');
const crypto = require('crypto');

// Generar una clave secreta segura (en producción, almacenar de forma segura)
const generateSecretKey = () => {
  return crypto.randomBytes(64).toString('hex');
};

// Clave secreta para firmar y verificar tokens
const secretKey = generateSecretKey();

// Función para crear un token JWT
function createToken(payload, options = {}) {
  // Configuración predeterminada segura
  const defaultOptions = {
    expiresIn: '1h',        // Tiempo de expiración corto
    algorithm: 'HS256',     // Algoritmo de firma
    issuer: 'mi-aplicacion', // Emisor del token
    audience: 'mi-api',     // Audiencia del token
    jwtid: crypto.randomBytes(16).toString('hex') // ID único para prevenir reutilización
  };
  
  // Combinar opciones predeterminadas con las proporcionadas
  const tokenOptions = { ...defaultOptions, ...options };
  
  // Crear y firmar el token
  return jwt.sign(payload, secretKey, tokenOptions);
}

// Función para verificar un token JWT
function verifyToken(token) {
  try {
    // Verificar y decodificar el token
    const decoded = jwt.verify(token, secretKey, {
      algorithms: ['HS256'],      // Limitar a algoritmos seguros
      issuer: 'mi-aplicacion',    // Verificar emisor
      audience: 'mi-api',         // Verificar audiencia
      clockTolerance: 30          // Tolerancia de 30 segundos para diferencias de reloj
    });
    
    return { valid: true, payload: decoded };
  } catch (error) {
    return { 
      valid: false, 
      error: error.name, 
      message: error.message 
    };
  }
}

// Ejemplo de uso
const userData = {
  id: '12345',
  username: 'usuario_ejemplo',
  role: 'user'
};

// Crear token
const token = createToken(userData);
console.log('Token JWT:', token);

// Verificar token válido
const verification = verifyToken(token);
console.log('Verificación:', verification);

// Verificar token manipulado
const tampered = token.slice(0, -5) + 'xxxxx';
const tamperedVerification = verifyToken(tampered);
console.log('Verificación de token manipulado:', tamperedVerification);

const crypto = require('crypto');

// Función que aplica SHA-256 a un string
function sha256(data) {
  return crypto.createHash('sha256').update(data).digest('hex');
}

// Simulamos un conjunto de transacciones dentro de un bloque
const transactions = ["Tx1", "Tx2", "Tx3", "Tx4"];

// Ciframos cada transacción con SHA-256
const hashedTxs = transactions.map(sha256);

// Función recursiva para construir la raíz de Merkle
function buildMerkleRoot(hashes) {
  // Caso base: si solo queda un hash, es la raíz
  if (hashes.length === 1) return hashes[0];

  const newLevel = [];
  for (let i = 0; i < hashes.length; i += 2) {
    // Tomamos pares de hashes y los concatenamos
    const left = hashes[i];
    const right = hashes[i + 1] || left; // Duplicamos si hay número impar

    // Hasheamos el resultado y lo agregamos al nuevo nivel
    newLevel.push(sha256(left + right));
  }

  // Repetimos hasta obtener una sola raíz
  return buildMerkleRoot(newLevel);
}

const merkleRoot = buildMerkleRoot(hashedTxs);
console.log("Merkle Root:", merkleRoot);

pragma solidity ^0.8.0;

contract SecureWallet {
    // Dirección del propietario de la wallet
    address public owner;

    // Eventos para registrar depósitos y transferencias
    event Deposited(address indexed from, uint amount);
    event Transferred(address indexed to, uint amount);

    // Constructor: se guarda el creador como dueño
    constructor() {
        owner = msg.sender;
    }

    // Modificador para restringir acceso solo al dueño
    modifier onlyOwner() {
        require(msg.sender == owner, "No autorizado");
        _;
    }

    // Función para recibir fondos
    function deposit() external payable {
        emit Deposited(msg.sender, msg.value);
    }

    // Función que transfiere fondos solo si es el dueño
    function transferFunds(address payable to, uint amount) external onlyOwner {
        require(address(this).balance >= amount, "Fondos insuficientes");
        to.transfer(amount);
        emit Transferred(to, amount);
    }

    // Obtener el balance actual del contrato
    function getBalance() public view returns (uint) {
        return address(this).balance;
    }
}

//Ejemplo: Firma digital con Ed25519

const nacl = require('tweetnacl');
const util = require('tweetnacl-util');

// Convertir string a Uint8Array y viceversa
const { encodeUTF8, decodeUTF8, encodeBase64, decodeBase64 } = util;

// Función para generar par de claves Ed25519
function generateKeyPair() {
  const keyPair = nacl.sign.keyPair();
  return {
    publicKey: encodeBase64(keyPair.publicKey),
    secretKey: encodeBase64(keyPair.secretKey)
  };
}

// Función para firmar un mensaje
function signMessage(message, secretKeyBase64) {
  const messageUint8 = decodeUTF8(message);
  const secretKey = decodeBase64(secretKeyBase64);
  const signature = nacl.sign.detached(messageUint8, secretKey);
  return encodeBase64(signature);
}

// Función para verificar una firma
function verifySignature(message, signature, publicKeyBase64) {
  const messageUint8 = decodeUTF8(message);
  const signatureUint8 = decodeBase64(signature);
  const publicKey = decodeBase64(publicKeyBase64);
  
  return nacl.sign.detached.verify(messageUint8, signatureUint8, publicKey);
}

// Ejemplo de uso
const message = 'Mensaje importante que necesita ser firmado';

// Generar par de claves
const keyPair = generateKeyPair();
console.log('Clave pública:', keyPair.publicKey);
console.log('Clave privada:', keyPair.secretKey);

// Firmar mensaje
const signature = signMessage(message, keyPair.secretKey);
console.log('Firma:', signature);

// Verificar firma (debería ser true)
const isValid = verifySignature(message, signature, keyPair.publicKey);
console.log('¿Firma válida?', isValid);

// Verificar firma con mensaje modificado (debería ser false)
const isValidModified = verifySignature(message + ' modificado', signature, keyPair.publicKey);
console.log('¿Firma válida con mensaje modificado?', isValidModified);

from phe import paillier

# Generamos un par de claves públicas/privadas
public_key, private_key = paillier.generate_paillier_keypair()

# Simulamos salarios confidenciales
salaries = [3500, 4200, 3900]

# Ciframos cada salario con la clave pública
encrypted_salaries = [public_key.encrypt(s) for s in salaries]

# Sumamos los salarios cifrados (sin descifrar)
total_encrypted = sum(encrypted_salaries)

# Desciframos el total para obtener la suma real
total_decrypted = private_key.decrypt(total_encrypted)

# Calculamos el promedio (de forma local)
average_salary = total_decrypted / len(salaries)

print("Total descifrado:", total_decrypted)
print("Promedio salarial:", average_salary)

from mpyc.runtime import mpc

# Inicializamos un tipo seguro entero (32 bits por defecto)
secint = mpc.SecInt()

# Arrancamos el entorno seguro
await mpc.start()

# Votos individuales simulados (1 = sí, 0 = no), ocultos en forma cifrada
votes = [secint(1), secint(0), secint(1), secint(1)]

# Suma segura de los votos (sin conocer su valor individual)
total_votes = sum(votes)

# Obtenemos el resultado de la suma revelando solo el total
result = await mpc.output(total_votes)

print("Votos a favor:", result, "de", len(votes))

# Cerramos el entorno seguro
await mpc.shutdown()

// Nota: Este es un ejemplo conceptual, ya que las implementaciones
// de criptografía post-cuántica aún están en desarrollo y estandarización

const kyber = require('kyber-crystals');

// Generar par de claves Kyber
function generateKyberKeys() {
  // Kyber-768 ofrece seguridad de nivel 3 (equivalente a AES-192)
  const keyPair = kyber.keyPair(768);
  return {
    publicKey: keyPair.publicKey,
    secretKey: keyPair.secretKey
  };
}

// Encapsular una clave compartida usando la clave pública
function encapsulate(publicKey) {
  const result = kyber.encapsulate(publicKey);
  return {
    sharedSecret: result.sharedSecret, // Clave simétrica para cifrado
    ciphertext: result.ciphertext      // Datos para que el receptor derive la misma clave
  };
}

// Desencapsular para obtener la misma clave compartida
function decapsulate(ciphertext, secretKey) {
  const sharedSecret = kyber.decapsulate(ciphertext, secretKey);
  return sharedSecret;
}

// Ejemplo de uso
async function secureExchange() {
  // Generar claves para el receptor
  const receiverKeys = generateKyberKeys();
  
  // Remitente encapsula una clave compartida
  const { sharedSecret: senderSharedSecret, ciphertext } = encapsulate(receiverKeys.publicKey);
  
  // Receptor desencapsula para obtener la misma clave compartida
  const receiverSharedSecret = decapsulate(ciphertext, receiverKeys.secretKey);
  
  // Ambas partes ahora tienen la misma clave secreta
  console.log('¿Claves iguales?', Buffer.compare(senderSharedSecret, receiverSharedSecret) === 0);
  
  // Esta clave compartida puede usarse para cifrado simétrico (AES)
  // const aesKey = sharedSecret.slice(0, 32); // 256 bits para AES-256
}

secureExchange();

import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.*;
import java.util.Base64;

public class DigitalSignatureExample {

    // Generar par de claves RSA
    public static KeyPair generateKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(2048); // Tamaño de clave recomendado
        return keyPairGenerator.generateKeyPair();
    }

    // Firmar datos con clave privada
    public static byte[] sign(byte[] data, PrivateKey privateKey) throws Exception {
        Signature signature = Signature.getInstance("SHA256withRSA");
        signature.initSign(privateKey);
        signature.update(data);
        return signature.sign();
    }

    // Verificar firma con clave pública
    public static boolean verify(byte[] data, byte[] signatureBytes, PublicKey publicKey) throws Exception {
        Signature signature = Signature.getInstance("SHA256withRSA");
        signature.initVerify(publicKey);
        signature.update(data);
        return signature.verify(signatureBytes);
    }

    public static void main(String[] args) {
        try {
            // Generar par de claves
            KeyPair keyPair = generateKeyPair();
            PublicKey publicKey = keyPair.getPublic();
            PrivateKey privateKey = keyPair.getPrivate();

            // Datos a firmar (podría ser un archivo)
            String message = "Este es un documento importante que necesita ser firmado digitalmente";
            byte[] data = message.getBytes();

            // Firmar los datos
            byte[] signatureBytes = sign(data, privateKey);
            String signatureBase64 = Base64.getEncoder().encodeToString(signatureBytes);
            System.out.println("Firma digital: " + signatureBase64);

            // Verificar la firma (simulando recepción)
            boolean isValid = verify(data, signatureBytes, publicKey);
            System.out.println("¿Firma válida? " + isValid);

            // Verificar con datos modificados (debe fallar)
            String modifiedMessage = message + " con modificación no autorizada";
            byte[] modifiedData = modifiedMessage.getBytes();
            boolean isValidModified = verify(modifiedData, signatureBytes, publicKey);
            System.out.println("¿Firma válida con datos modificados? " + isValidModified);

        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

import paramiko
import os
import socket
import sys

class SecureShellClient:
    def __init__(self, hostname, port=22, username=None, key_filename=None, password=None):
        self.hostname = hostname
        self.port = port
        self.username = username
        self.key_filename = key_filename
        self.password = password
        self.client = None
        self.session_log = []
    
    def connect(self):
        """Establece una conexión SSH segura con el servidor"""
        try:
            # Inicializar cliente SSH
            self.client = paramiko.SSHClient()
            
            # Configuración de seguridad para host keys
            # En producción, usar 'system' o implementar verificación personalizada
            self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
            
            # Registrar intento de conexión
            self.log_action(f"Conectando a {self.hostname}:{self.port} como {self.username}")
            
            # Conectar usando autenticación por clave o contraseña
            if self.key_filename:
                self.client.connect(
                    hostname=self.hostname,
                    port=self.port,
                    username=self.username,
                    key_filename=self.key_filename,
                    timeout=10
                )
                self.log_action("Autenticado con clave privada")
            elif self.password:
                self.client.connect(
                    hostname=self.hostname,
                    port=self.port,
                    username=self.username,
                    password=self.password,
                    timeout=10
                )
                self.log_action("Autenticado con contraseña")
            else:
                raise ValueError("Se requiere clave privada o contraseña para la autenticación")
                
            return True
            
        except paramiko.AuthenticationException:
            self.log_action("Error: Falló la autenticación")
            return False
        except paramiko.SSHException as e:
            self.log_action(f"Error SSH: {str(e)}")
            return False
        except socket.error as e:
            self.log_action(f"Error de conexión: {str(e)}")
            return False
    
    def execute_command(self, command):
        """Ejecuta un comando en el servidor remoto"""
        if not self.client:
            raise RuntimeError("No hay conexión SSH establecida")
        
        self.log_action(f"Ejecutando comando: {command}")
        
        # Crear canal para el comando
        stdin, stdout, stderr = self.client.exec_command(command)
        
        # Obtener resultados
        output = stdout.read().decode('utf-8')
        error = stderr.read().decode('utf-8')
        
        if error:
            self.log_action(f"Error en comando: {error}")
        
        return output
    
    def upload_file(self, local_path, remote_path):
        """Sube un archivo al servidor remoto usando SFTP"""
        if not self.client:
            raise RuntimeError("No hay conexión SSH establecida")
        
        self.log_action(f"Subiendo archivo: {local_path} -> {remote_path}")
        
        try:
            # Abrir sesión SFTP
            sftp = self.client.open_sftp()
            
            # Subir archivo
            sftp.put(local_path, remote_path)
            
            # Cerrar sesión SFTP
            sftp.close()
            
            return True
        except Exception as e:
            self.log_action(f"Error al subir archivo: {str(e)}")
            return False
    
    def download_file(self, remote_path, local_path):
        """Descarga un archivo del servidor remoto usando SFTP"""
        if not self.client:
            raise RuntimeError("No hay conexión SSH establecida")
        
        self.log_action(f"Descargando archivo: {remote_path} -> {local_path}")
        
        try:
            # Abrir sesión SFTP
            sftp = self.client.open_sftp()
            
            # Descargar archivo
            sftp.get(remote_path, local_path)
            
            # Cerrar sesión SFTP
            sftp.close()
            
            return True
        except Exception as e:
            self.log_action(f"Error al descargar archivo: {str(e)}")
            return False
    
    def close(self):
        """Cierra la conexión SSH"""
        if self.client:
            self.client.close()
            self.log_action("Conexión SSH cerrada")
            self.client = None
    
    def log_action(self, message):
        """Registra acciones para auditoría"""
        self.session_log.append(message)
        print(message)

# Ejemplo de uso
if __name__ == "__main__":
    # Conexión con clave privada (más seguro)
    ssh = SecureShellClient(
        hostname="ejemplo.servidor.com",
        username="usuario",
        key_filename="~/.ssh/id_rsa"
    )
    
    # Alternativa: conexión con contraseña (menos seguro)
    # ssh = SecureShellClient(
    #     hostname="ejemplo.servidor.com",
    #     username="usuario",
    #     password="contraseña_segura"
    # )
    
    if ssh.connect():
        # Ejecutar comandos
        output = ssh.execute_command("ls -la")
        print(f"Resultado del comando:\n{output}")
        
        # Transferir archivos
        ssh.upload_file("archivo_local.txt", "/ruta/remota/archivo.txt")
        ssh.download_file("/ruta/remota/datos.csv", "datos_locales.csv")
        
        # Cerrar conexión
        ssh.close()

const crypto = require('crypto');

/**
 * Implementación simplificada de una prueba de conocimiento cero para verificar
 * que un usuario conoce una contraseña sin revelarla.
 * 
 * Este es un ejemplo educativo que ilustra el concepto de ZKP.
 * Para aplicaciones reales, use bibliotecas criptográficas especializadas.
 */
class PasswordZKP {
  /**
   * Configuración inicial para el protocolo
   * @param {string} password - La contraseña que el probador conoce
   */
  constructor(password) {
    // Generar un salt aleatorio para el hash
    this.salt = crypto.randomBytes(16).toString('hex');
    
    // Calcular el hash de la contraseña (esto se almacenaría en el servidor)
    this.passwordHash = this.hashPassword(password);
    
    // Número de rondas para la verificación
    this.rounds = 10;
  }
  
  /**
   * Función para hashear la contraseña con el salt
   * @param {string} password - La contraseña a hashear
   * @returns {string} - El hash resultante en formato hex
   */
  hashPassword(password) {
    return crypto.createHash('sha256')
      .update(password + this.salt)
      .digest('hex');
  }
  
  /**
   * Genera un desafío aleatorio para una ronda de verificación
   * @returns {string} - Un desafío aleatorio
   */
  generateChallenge() {
    return crypto.randomBytes(32).toString('hex');
  }
  
  /**
   * El probador genera un compromiso basado en la contraseña y un valor aleatorio
   * @param {string} password - La contraseña del usuario
   * @returns {Object} - El compromiso y el valor aleatorio usado
   */
  generateCommitment(password) {
    // Generar un valor aleatorio (nonce) para esta ronda
    const nonce = crypto.randomBytes(32).toString('hex');
    
    // Crear un compromiso combinando la contraseña con el nonce
    const commitment = crypto.createHash('sha256')
      .update(password + nonce)
      .digest('hex');
    
    return { commitment, nonce };
  }
  
  /**
   * El probador genera una respuesta al desafío
   * @param {string} password - La contraseña del usuario
   * @param {string} challenge - El desafío recibido
   * @param {string} nonce - El nonce usado en el compromiso
   * @returns {string} - La respuesta al desafío
   */
  generateResponse(password, challenge, nonce) {
    // Combinar la contraseña, el nonce y el desafío
    return crypto.createHash('sha256')
      .update(password + nonce + challenge)
      .digest('hex');
  }
  
  /**
   * El verificador comprueba si la respuesta es correcta
   * @param {string} commitment - El compromiso inicial
   * @param {string} challenge - El desafío enviado
   * @param {string} response - La respuesta recibida
   * @returns {boolean} - True si la verificación es exitosa
   */
  verifyResponse(commitment, challenge, response) {
    // En una implementación real, el verificador reconstruiría la respuesta
    // usando el hash almacenado de la contraseña, el desafío y el compromiso
    
    // Para simplificar, aquí solo verificamos que la respuesta sea consistente
    // con el compromiso y el desafío
    
    // Nota: Esta es una simplificación y no es una verdadera ZKP criptográficamente segura
    const expectedPattern = commitment.substring(0, 8) + challenge.substring(0, 8);
    return response.startsWith(expectedPattern);
  }
  
  /**
   * Ejecuta el protocolo completo de verificación
   * @param {string} password - La contraseña que el probador afirma conocer
   * @returns {boolean} - True si la verificación es exitosa
   */
  verify(password) {
    // Verificar primero si el hash de la contraseña coincide
    // Esto simula la verificación tradicional (no ZKP)
    const providedHash = this.hashPassword(password);
    if (providedHash !== this.passwordHash) {
      console.log("❌ Verificación tradicional fallida: Hash incorrecto");
      return false;
    }
    
    console.log("✅ Verificación tradicional exitosa: Hash correcto");
    console.log("Iniciando protocolo de conocimiento cero...");
    
    // Ejecutar múltiples rondas de verificación ZKP
    let allRoundsSuccessful = true;
    
    for (let round = 1; round <= this.rounds; round++) {
      console.log(`
Ronda ${round}/${this.rounds}:`);
      
      // Paso 1: El probador genera un compromiso
      const { commitment, nonce } = this.generateCommitment(password);
      console.log(`- Probador envía compromiso: ${commitment.substring(0, 16)}...`);
      
      // Paso 2: El verificador envía un desafío
      const challenge = this.generateChallenge();
      console.log(`- Verificador envía desafío: ${challenge.substring(0, 16)}...`);
      
      // Paso 3: El probador genera una respuesta al desafío
      const response = this.generateResponse(password, challenge, nonce);
      console.log(`- Probador envía respuesta: ${response.substring(0, 16)}...`);
      
      // Paso 4: El verificador comprueba la respuesta
      const isValid = this.verifyResponse(commitment, challenge, response);
      
      if (isValid) {
        console.log(`✅ Ronda ${round}: Verificación exitosa`);
      } else {
        console.log(`❌ Ronda ${round}: Verificación fallida`);
        allRoundsSuccessful = false;
        break;
      }
    }
    
    return allRoundsSuccessful;
  }
}

// Ejemplo de uso
const secretPassword = "mi_contraseña_secreta";

// Configurar el protocolo
const zkp = new PasswordZKP(secretPassword);

// Verificar con la contraseña correcta
console.log("Verificando con contraseña correcta:");
const isValidCorrect = zkp.verify(secretPassword);
console.log(`
Resultado final: ${isValidCorrect ? "✅ Verificación exitosa" : "❌ Verificación fallida"}`);

// Verificar con una contraseña incorrecta
console.log("
-----------------------------------
");
console.log("Verificando con contraseña incorrecta:");
const isValidIncorrect = zkp.verify("contraseña_incorrecta");
console.log(`
Resultado final: ${isValidIncorrect ? "✅ Verificación exitosa" : "❌ Verificación fallida"}`);