soulprint-network 0.2.3 → 0.2.4

package/dist/crypto/gossip-cipher.d.ts

@@ -0,0 +1,69 @@
+/**
+ * gossip-cipher.ts — Cifrado end-to-end para el tráfico P2P de Soulprint
+ *
+ * DISEÑO:
+ * ─────────────────────────────────────────────────────────────────────────
+ * • Algoritmo: AES-256-GCM (AEAD — autenticado + cifrado)
+ * • Clave derivada de: HMAC-SHA256(PROTOCOL_HASH + epoch)
+ *   → Solo nodos con PROTOCOL_HASH correcto pueden cifrar/descifrar
+ *   → Refuerza el hash enforcement: no basta con conocer el hash,
+ *     el hash correcto ES la clave de acceso a la red
+ * • Rotación: epoch de 5 minutos → forward secrecy básica
+ * • Nonce: 96 bits aleatorios por mensaje (GCM requirement)
+ * • AuthTag: 128 bits — detecta cualquier tampering en tránsito
+ *
+ * FLUJO:
+ *   Emisor:  payload → encryptGossip() → { ciphertext, nonce, epoch, tag }
+ *   Receptor: → decryptGossip() → payload original  ← solo si tiene hash correcto
+ *
+ * VENTAJAS SOBRE PLAINTEXT:
+ * 1. Un nodo modificado (hash diferente) no puede leer el tráfico de la red
+ * 2. Un atacante MitM no puede modificar attestations (AuthTag falla)
+ * 3. Replay protection: epoch cambia cada 5 min, aceptamos ±1 epoch
+ * 4. Doble enforcement: hash = identidad de red + llave de cifrado
+ */
+/**
+ * Deriva la clave AES-256 para el epoch dado.
+ * PROTOCOL_HASH es el secreto compartido — solo nodos honestos lo tienen.
+ *
+ * @param epochMs Timestamp del epoch (default: now)
+ */
+export declare function deriveGossipKey(epochMs?: number): Buffer;
+/**
+ * Retorna el epoch actual y el anterior (para ventana de tolerancia).
+ */
+export declare function currentEpochs(): number[];
+export interface EncryptedGossip {
+    /** Payload cifrado + AuthTag (base64). */
+    ct: string;
+    /** Nonce aleatorio de 96 bits (base64). */
+    iv: string;
+    /** Epoch en que fue cifrado (para seleccionar la clave correcta). */
+    ep: number;
+    /** Versión del esquema de cifrado. */
+    v: 1;
+}
+/**
+ * Cifra un payload de gossip con AES-256-GCM.
+ * Solo nodos con el PROTOCOL_HASH correcto pueden descifrar.
+ *
+ * @param payload Objeto JSON a cifrar
+ * @returns EncryptedGossip listo para transmitir
+ */
+export declare function encryptGossip(payload: object): EncryptedGossip;
+export interface DecryptResult {
+    ok: boolean;
+    payload?: object;
+    error?: string;
+}
+/**
+ * Descifra un payload de gossip recibido de un peer.
+ *
+ * Valida:
+ * 1. Epoch dentro de la ventana aceptada (±EPOCH_TOLERANCE epochs)
+ * 2. AuthTag GCM — rechaza cualquier mensaje tampered
+ * 3. JSON válido
+ *
+ * @param enc EncryptedGossip recibido del peer
+ */
+export declare function decryptGossip(enc: EncryptedGossip): DecryptResult;

package/dist/crypto/gossip-cipher.js

@@ -0,0 +1,123 @@
+/**
+ * gossip-cipher.ts — Cifrado end-to-end para el tráfico P2P de Soulprint
+ *
+ * DISEÑO:
+ * ─────────────────────────────────────────────────────────────────────────
+ * • Algoritmo: AES-256-GCM (AEAD — autenticado + cifrado)
+ * • Clave derivada de: HMAC-SHA256(PROTOCOL_HASH + epoch)
+ *   → Solo nodos con PROTOCOL_HASH correcto pueden cifrar/descifrar
+ *   → Refuerza el hash enforcement: no basta con conocer el hash,
+ *     el hash correcto ES la clave de acceso a la red
+ * • Rotación: epoch de 5 minutos → forward secrecy básica
+ * • Nonce: 96 bits aleatorios por mensaje (GCM requirement)
+ * • AuthTag: 128 bits — detecta cualquier tampering en tránsito
+ *
+ * FLUJO:
+ *   Emisor:  payload → encryptGossip() → { ciphertext, nonce, epoch, tag }
+ *   Receptor: → decryptGossip() → payload original  ← solo si tiene hash correcto
+ *
+ * VENTAJAS SOBRE PLAINTEXT:
+ * 1. Un nodo modificado (hash diferente) no puede leer el tráfico de la red
+ * 2. Un atacante MitM no puede modificar attestations (AuthTag falla)
+ * 3. Replay protection: epoch cambia cada 5 min, aceptamos ±1 epoch
+ * 4. Doble enforcement: hash = identidad de red + llave de cifrado
+ */
+import { createCipheriv, createDecipheriv, createHmac, randomBytes, } from "node:crypto";
+import { PROTOCOL_HASH } from "soulprint-core";
+// ── Constantes ────────────────────────────────────────────────────────────────
+/** Duración de cada epoch de cifrado (5 minutos). */
+const EPOCH_MS = 5 * 60 * 1000;
+/** Epochs aceptados en recepción: actual ± EPOCH_TOLERANCE. */
+const EPOCH_TOLERANCE = 1;
+/** Tamaño del nonce GCM (96 bits — recomendación NIST). */
+const NONCE_BYTES = 12;
+/** Tamaño del AuthTag GCM (128 bits — máximo, más seguro). */
+const AUTH_TAG_BYTES = 16;
+// ── Key derivation ────────────────────────────────────────────────────────────
+/**
+ * Deriva la clave AES-256 para el epoch dado.
+ * PROTOCOL_HASH es el secreto compartido — solo nodos honestos lo tienen.
+ *
+ * @param epochMs Timestamp del epoch (default: now)
+ */
+export function deriveGossipKey(epochMs = Date.now()) {
+    const epoch = Math.floor(epochMs / EPOCH_MS);
+    const material = `soulprint-gossip-v1:${PROTOCOL_HASH}:epoch:${epoch}`;
+    return createHmac("sha256", PROTOCOL_HASH).update(material).digest();
+}
+/**
+ * Retorna el epoch actual y el anterior (para ventana de tolerancia).
+ */
+export function currentEpochs() {
+    const now = Date.now();
+    const epoch = Math.floor(now / EPOCH_MS);
+    return Array.from({ length: EPOCH_TOLERANCE * 2 + 1 }, (_, i) => epoch - EPOCH_TOLERANCE + i);
+}
+/**
+ * Cifra un payload de gossip con AES-256-GCM.
+ * Solo nodos con el PROTOCOL_HASH correcto pueden descifrar.
+ *
+ * @param payload Objeto JSON a cifrar
+ * @returns EncryptedGossip listo para transmitir
+ */
+export function encryptGossip(payload) {
+    const epoch = Math.floor(Date.now() / EPOCH_MS);
+    const key = deriveGossipKey(Date.now());
+    const nonce = randomBytes(NONCE_BYTES);
+    const cipher = createCipheriv("aes-256-gcm", key, nonce);
+    cipher.setAAD(Buffer.from(`epoch:${epoch}`)); // Additional data autenticada
+    const plaintext = Buffer.from(JSON.stringify(payload), "utf8");
+    const encrypted = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+    const authTag = cipher.getAuthTag(); // 16 bytes
+    // ciphertext = encrypted || authTag (concatenados)
+    return {
+        ct: Buffer.concat([encrypted, authTag]).toString("base64"),
+        iv: nonce.toString("base64"),
+        ep: epoch,
+        v: 1,
+    };
+}
+/**
+ * Descifra un payload de gossip recibido de un peer.
+ *
+ * Valida:
+ * 1. Epoch dentro de la ventana aceptada (±EPOCH_TOLERANCE epochs)
+ * 2. AuthTag GCM — rechaza cualquier mensaje tampered
+ * 3. JSON válido
+ *
+ * @param enc EncryptedGossip recibido del peer
+ */
+export function decryptGossip(enc) {
+    if (enc.v !== 1)
+        return { ok: false, error: "Unknown cipher version" };
+    // Validar epoch
+    const validEpochs = currentEpochs();
+    if (!validEpochs.includes(enc.ep)) {
+        return {
+            ok: false,
+            error: `Epoch ${enc.ep} fuera de ventana aceptada [${validEpochs[0]}–${validEpochs[validEpochs.length - 1]}]`,
+        };
+    }
+    try {
+        const key = deriveGossipKey(enc.ep * EPOCH_MS);
+        const nonce = Buffer.from(enc.iv, "base64");
+        const ctAndTag = Buffer.from(enc.ct, "base64");
+        // Separar ciphertext del authTag
+        const ciphertext = ctAndTag.subarray(0, ctAndTag.length - AUTH_TAG_BYTES);
+        const authTag = ctAndTag.subarray(ctAndTag.length - AUTH_TAG_BYTES);
+        const decipher = createDecipheriv("aes-256-gcm", key, nonce);
+        decipher.setAuthTag(authTag);
+        decipher.setAAD(Buffer.from(`epoch:${enc.ep}`));
+        const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+        const payload = JSON.parse(decrypted.toString("utf8"));
+        return { ok: true, payload };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: err.message?.includes("Unsupported state")
+                ? "AuthTag inválido — mensaje tampered o clave incorrecta"
+                : `Decrypt error: ${err.message?.slice(0, 80)}`,
+        };
+    }
+}

package/dist/crypto/peer-router.d.ts

@@ -0,0 +1,59 @@
+/**
+ * peer-router.ts — Routing XOR para búsqueda de peers eficiente
+ *
+ * PROBLEMA CON BROADCAST TOTAL:
+ * ─────────────────────────────────────────────────────────────────────────
+ * Gossip actual: envía attestation a TODOS los peers → O(n)
+ * Con 100 nodos: 100 requests por attestation
+ * Con 1000 nodos: 1000 requests — no escala
+ *
+ * SOLUCIÓN: Kademlia-style XOR routing
+ * ─────────────────────────────────────────────────────────────────────────
+ * • Cada nodo tiene un ID de 32 bytes (SHA-256 de su URL)
+ * • Distancia entre dos nodos = XOR de sus IDs (métrica Kademlia)
+ * • Para gossip de una attestation sobre DID X:
+ *   → Seleccionar K peers más cercanos a SHA-256(X)
+ *   → En redes grandes: O(log n) en lugar de O(n)
+ * • Bucket table: 256 buckets por bit position
+ *
+ * CONFIGURACIÓN:
+ * • K_FACTOR = 6: enviar a los 6 peers más cercanos al target
+ * • ALPHA = 3: paralelismo de búsqueda (como Kademlia estándar)
+ * • FULL_BROADCAST_THRESHOLD = 10: con ≤10 peers, broadcast total
+ *   (no vale la pena routing con pocos nodos)
+ */
+/** Peers más cercanos a seleccionar para gossip dirigido. */
+export declare const K_FACTOR = 6;
+/** Umbral de peers bajo el cual se hace broadcast total (más simple). */
+export declare const FULL_BROADCAST_THRESHOLD = 10;
+/**
+ * Deriva un ID de 32 bytes para una URL o DID.
+ * Determinístico: misma entrada → mismo ID.
+ */
+export declare function nodeId(input: string): Buffer;
+/**
+ * Calcula la distancia XOR entre dos IDs (Buffer de 32 bytes).
+ * Menor distancia = más cercano en el espacio Kademlia.
+ */
+export declare function xorDistance(a: Buffer, b: Buffer): Buffer;
+/**
+ * Compara dos distancias XOR.
+ * @returns negativo si a < b, 0 si iguales, positivo si a > b
+ */
+export declare function compareDistance(a: Buffer, b: Buffer): number;
+/**
+ * Selecciona los K peers más cercanos al target para gossip dirigido.
+ *
+ * Con ≤ FULL_BROADCAST_THRESHOLD peers: retorna todos (broadcast).
+ * Con más peers: retorna los K más cercanos al targetId (XOR routing).
+ *
+ * @param peers      Lista de URLs de peers conocidos
+ * @param targetDid  DID del bot sobre el que se gossipea (target del routing)
+ * @param exclude    URLs a excluir (ej: el peer que nos envió el mensaje)
+ * @returns          Subconjunto de peers seleccionados para gossip
+ */
+export declare function selectGossipPeers(peers: string[], targetDid: string, exclude?: string): string[];
+/**
+ * Calcula estadísticas del routing para logging.
+ */
+export declare function routingStats(totalPeers: number, selectedPeers: number, targetDid: string): string;

package/dist/crypto/peer-router.js

@@ -0,0 +1,98 @@
+/**
+ * peer-router.ts — Routing XOR para búsqueda de peers eficiente
+ *
+ * PROBLEMA CON BROADCAST TOTAL:
+ * ─────────────────────────────────────────────────────────────────────────
+ * Gossip actual: envía attestation a TODOS los peers → O(n)
+ * Con 100 nodos: 100 requests por attestation
+ * Con 1000 nodos: 1000 requests — no escala
+ *
+ * SOLUCIÓN: Kademlia-style XOR routing
+ * ─────────────────────────────────────────────────────────────────────────
+ * • Cada nodo tiene un ID de 32 bytes (SHA-256 de su URL)
+ * • Distancia entre dos nodos = XOR de sus IDs (métrica Kademlia)
+ * • Para gossip de una attestation sobre DID X:
+ *   → Seleccionar K peers más cercanos a SHA-256(X)
+ *   → En redes grandes: O(log n) en lugar de O(n)
+ * • Bucket table: 256 buckets por bit position
+ *
+ * CONFIGURACIÓN:
+ * • K_FACTOR = 6: enviar a los 6 peers más cercanos al target
+ * • ALPHA = 3: paralelismo de búsqueda (como Kademlia estándar)
+ * • FULL_BROADCAST_THRESHOLD = 10: con ≤10 peers, broadcast total
+ *   (no vale la pena routing con pocos nodos)
+ */
+import { createHash } from "node:crypto";
+// ── Constantes ────────────────────────────────────────────────────────────────
+/** Peers más cercanos a seleccionar para gossip dirigido. */
+export const K_FACTOR = 6;
+/** Umbral de peers bajo el cual se hace broadcast total (más simple). */
+export const FULL_BROADCAST_THRESHOLD = 10;
+// ── Node ID ───────────────────────────────────────────────────────────────────
+/**
+ * Deriva un ID de 32 bytes para una URL o DID.
+ * Determinístico: misma entrada → mismo ID.
+ */
+export function nodeId(input) {
+    return createHash("sha256").update(input).digest();
+}
+/**
+ * Calcula la distancia XOR entre dos IDs (Buffer de 32 bytes).
+ * Menor distancia = más cercano en el espacio Kademlia.
+ */
+export function xorDistance(a, b) {
+    const result = Buffer.allocUnsafe(32);
+    for (let i = 0; i < 32; i++) {
+        result[i] = a[i] ^ b[i];
+    }
+    return result;
+}
+/**
+ * Compara dos distancias XOR.
+ * @returns negativo si a < b, 0 si iguales, positivo si a > b
+ */
+export function compareDistance(a, b) {
+    for (let i = 0; i < 32; i++) {
+        if (a[i] !== b[i])
+            return a[i] - b[i];
+    }
+    return 0;
+}
+// ── Peer selection ────────────────────────────────────────────────────────────
+/**
+ * Selecciona los K peers más cercanos al target para gossip dirigido.
+ *
+ * Con ≤ FULL_BROADCAST_THRESHOLD peers: retorna todos (broadcast).
+ * Con más peers: retorna los K más cercanos al targetId (XOR routing).
+ *
+ * @param peers      Lista de URLs de peers conocidos
+ * @param targetDid  DID del bot sobre el que se gossipea (target del routing)
+ * @param exclude    URLs a excluir (ej: el peer que nos envió el mensaje)
+ * @returns          Subconjunto de peers seleccionados para gossip
+ */
+export function selectGossipPeers(peers, targetDid, exclude) {
+    const candidates = exclude ? peers.filter(p => p !== exclude) : [...peers];
+    // Con pocos peers, broadcast total (más robusto)
+    if (candidates.length <= FULL_BROADCAST_THRESHOLD) {
+        return candidates;
+    }
+    // XOR routing: ordenar por distancia al target
+    const targetBuf = nodeId(targetDid);
+    const sorted = candidates
+        .map(url => ({
+        url,
+        dist: xorDistance(nodeId(url), targetBuf),
+    }))
+        .sort((a, b) => compareDistance(a.dist, b.dist))
+        .slice(0, K_FACTOR)
+        .map(({ url }) => url);
+    return sorted;
+}
+/**
+ * Calcula estadísticas del routing para logging.
+ */
+export function routingStats(totalPeers, selectedPeers, targetDid) {
+    const ratio = ((selectedPeers / totalPeers) * 100).toFixed(0);
+    const mode = totalPeers <= FULL_BROADCAST_THRESHOLD ? "broadcast" : `xor-routing(k=${K_FACTOR})`;
+    return `[routing] ${selectedPeers}/${totalPeers} peers (${ratio}%) via ${mode} → ${targetDid.slice(0, 16)}...`;
+}

package/dist/validator.js

@@ -5,6 +5,8 @@ import { homedir } from "node:os";
 import { generateKeypair, keypairFromPrivateKey, decodeToken, sign, verifyAttestation, computeReputation, defaultReputation, PROTOCOL, PROTOCOL_HASH, isProtocolHashCompatible, checkFarming, recordApprovedGain, recordFarmingStrike, loadAuditStore, exportAuditStore, } from "soulprint-core";
 import { verifyProof, deserializeProof } from "soulprint-zkp";
 import { handleCredentialRoute } from "./credentials/index.js";
+import { encryptGossip, decryptGossip } from "./crypto/gossip-cipher.js";
+import { selectGossipPeers, routingStats } from "./crypto/peer-router.js";
 import { publishAttestationP2P, onAttestationReceived, getP2PStats, } from "./p2p.js";
 // ── Config ────────────────────────────────────────────────────────────────────
 const PORT = parseInt(process.env.SOULPRINT_PORT ?? String(PROTOCOL.DEFAULT_HTTP_PORT));
@@ -183,18 +185,26 @@ async function gossipAttestation(att, excludeUrl) {
             console.log(`[p2p] Attestation publicada → ${recipients} peer(s) via GossipSub`);
         }
     }
-    // ── Canal 2: HTTP gossip (fallback para nodos legacy) ─────────────────────
-    // Incluye X-Protocol-Hash para que el peer receptor valide compatibilidad.
-    const targets = peers.filter(p => p !== excludeUrl);
+    // ── Canal 2: HTTP gossip con cifrado AES-256-GCM + XOR routing ────────────
+    // Selección de peers: XOR routing hacia el DID objetivo → O(log n)
+    // Con ≤10 peers: broadcast total. Con más: solo K=6 más cercanos.
+    const targets = selectGossipPeers(peers, att.target_did, excludeUrl);
+    if (targets.length < peers.length - (excludeUrl ? 1 : 0)) {
+        console.log(routingStats(peers.length, targets.length, att.target_did));
+    }
+    // Cifrar el payload con AES-256-GCM antes de enviar
+    // Solo nodos con PROTOCOL_HASH correcto pueden descifrar
+    const encrypted = encryptGossip({ attestation: att, from_peer: true });
     for (const peerUrl of targets) {
         fetch(`${peerUrl}/reputation/attest`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
                 "X-Gossip": "1",
-                "X-Protocol-Hash": PROTOCOL_HASH, // ← el receptor valida esto
+                "X-Protocol-Hash": PROTOCOL_HASH,
+                "X-Encrypted": "aes-256-gcm-v1", // señal al receptor
             },
-            body: JSON.stringify({ attestation: att, from_peer: true }),
+            body: JSON.stringify(encrypted),
             signal: AbortSignal.timeout(GOSSIP_TIMEOUT_MS),
         }).catch(() => { });
     }
@@ -337,20 +347,34 @@ function handleGetReputation(res, did) {
 async function handleAttest(req, res, ip) {
     if (!checkRateLimit(ip))
         return json(res, 429, { error: "Rate limit exceeded" });
-    let body;
+    let rawBody;
     try {
-        body = await readBody(req);
+        rawBody = await readBody(req);
     }
     catch (e) {
         return json(res, 400, { error: e.message });
     }
+    // ── Descifrado AES-256-GCM (gossip cifrado desde peers) ──────────────────
+    // Si el header X-Encrypted está presente, descifrar antes de procesar.
+    // Un nodo con PROTOCOL_HASH diferente no puede descifrar → falla aquí.
+    let body = rawBody;
+    const isEncrypted = req.headers["x-encrypted"] === "aes-256-gcm-v1";
+    if (isEncrypted) {
+        const result = decryptGossip(rawBody);
+        if (!result.ok) {
+            console.warn(`[crypto] Gossip descifrado fallido desde ${ip}: ${result.error}`);
+            return json(res, 403, {
+                error: "Encrypted gossip could not be decrypted",
+                reason: result.error,
+                hint: "Ensure your node runs the official soulprint-network with the correct PROTOCOL_HASH",
+            });
+        }
+        body = result.payload;
+    }
     const { attestation, service_spt, from_peer } = body ?? {};
     if (!attestation)
         return json(res, 400, { error: "Missing field: attestation" });
     // ── Protocol Hash Enforcement (gossip desde peers) ────────────────────────
-    // Si la attestation viene de un peer (X-Gossip: 1), validamos que el peer
-    // opera con las mismas constantes de protocolo.
-    // Un nodo con constantes modificadas no puede inyectar attestations en la red.
     if (from_peer) {
         const peerHash = req.headers["x-protocol-hash"];
         if (peerHash && !isProtocolHashCompatible(peerHash)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soulprint-network",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Soulprint validator node — HTTP server that verifies ZK proofs, co-signs SPTs, anti-Sybil registry",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",