soulprint-network 0.2.2 → 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

@@ -2,9 +2,11 @@ import { createServer } from "node:http";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { generateKeypair, keypairFromPrivateKey, decodeToken, sign, verifyAttestation, computeReputation, defaultReputation, PROTOCOL, checkFarming, recordApprovedGain, recordFarmingStrike, loadAuditStore, exportAuditStore, } from "soulprint-core";
+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,13 +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) ─────────────────────
-    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" },
-            body: JSON.stringify({ attestation: att }),
+            headers: {
+                "Content-Type": "application/json",
+                "X-Gossip": "1",
+                "X-Protocol-Hash": PROTOCOL_HASH,
+                "X-Encrypted": "aes-256-gcm-v1", // señal al receptor
+            },
+            body: JSON.stringify(encrypted),
             signal: AbortSignal.timeout(GOSSIP_TIMEOUT_MS),
         }).catch(() => { });
     }
@@ -248,11 +263,12 @@ function handleInfo(res, nodeKeypair) {
         node_did: nodeKeypair.did,
         version: VERSION,
         protocol: PROTOCOL.VERSION,
+        protocol_hash: PROTOCOL_HASH, // ← cualquier modificación cambia este hash
         total_verified: Object.keys(nullifiers).length,
         total_reputation: Object.keys(repStore).length,
         known_peers: peers.length,
         supported_countries: ["CO"],
-        capabilities: ["zk-verify", "anti-sybil", "co-sign", "bot-reputation", "p2p-gossipsub"],
+        capabilities: ["zk-verify", "anti-sybil", "co-sign", "bot-reputation", "p2p-gossipsub", "credential-validators", "anti-farming"],
         rate_limit: `${PROTOCOL.RATE_LIMIT_MAX} req/min per IP`,
         // P2P stats (Phase 5)
         p2p: p2pStats ? {
@@ -275,6 +291,11 @@ function handleInfo(res, nodeKeypair) {
 function handleProtocol(res) {
     json(res, 200, {
         protocol_version: PROTOCOL.VERSION,
+        // ── Protocol Hash — IDENTIDAD DE LA RED ────────────────────────────────
+        // Cualquier nodo con un hash diferente es rechazado automáticamente.
+        // Si PROTOCOL fue modificado (aunque sea un valor), este hash cambia.
+        protocol_hash: PROTOCOL_HASH,
+        // ── Score limits ────────────────────────────────────────────────────────
         score_floor: PROTOCOL.SCORE_FLOOR,
         verified_score_floor: PROTOCOL.VERIFIED_SCORE_FLOOR,
         min_attester_score: PROTOCOL.MIN_ATTESTER_SCORE,
@@ -282,11 +303,20 @@ function handleProtocol(res) {
         reputation_max: PROTOCOL.REPUTATION_MAX,
         max_score: PROTOCOL.MAX_SCORE,
         default_reputation: PROTOCOL.DEFAULT_REPUTATION,
+        // ── Biometric thresholds ────────────────────────────────────────────────
+        face_sim_doc_selfie: PROTOCOL.FACE_SIM_DOC_SELFIE,
+        face_sim_selfie_selfie: PROTOCOL.FACE_SIM_SELFIE_SELFIE,
+        face_key_dims: PROTOCOL.FACE_KEY_DIMS,
+        face_key_precision: PROTOCOL.FACE_KEY_PRECISION,
+        // ── Retry / timing ──────────────────────────────────────────────────────
         verify_retry_max: PROTOCOL.VERIFY_RETRY_MAX,
         verify_retry_base_ms: PROTOCOL.VERIFY_RETRY_BASE_MS,
         verify_retry_max_ms: PROTOCOL.VERIFY_RETRY_MAX_MS,
         att_max_age_seconds: PROTOCOL.ATT_MAX_AGE_SECONDS,
-        immutable: true, // todas estas constantes son inamovibles por diseño
+        // ── Enforcement notice ──────────────────────────────────────────────────
+        immutable: true,
+        enforcement: "p2p-hash", // ← la red rechaza nodos con hash diferente
+        note: "Nodes with a different protocol_hash are rejected by the network. Modifying any constant changes the hash and isolates the node.",
     });
 }
 // ── GET /reputation/:did ──────────────────────────────────────────────────────
@@ -317,16 +347,45 @@ 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) ────────────────────────
+    if (from_peer) {
+        const peerHash = req.headers["x-protocol-hash"];
+        if (peerHash && !isProtocolHashCompatible(peerHash)) {
+            console.warn(`[protocol] Gossip rechazado de ${ip} — hash incompatible: ${peerHash?.slice(0, 16)}...`);
+            return json(res, 409, {
+                error: "Protocol mismatch — gossip rejected",
+                our_hash: PROTOCOL_HASH,
+                their_hash: peerHash,
+            });
+        }
+    }
     const att = attestation;
     // ── Validaciones básicas de la attestation ────────────────────────────────
     if (typeof att.issuer_did !== "string")
@@ -422,16 +481,30 @@ async function handlePeerRegister(req, res) {
     catch (e) {
         return json(res, 400, { error: e.message });
     }
-    const { url } = body ?? {};
+    const { url, protocol_hash } = body ?? {};
     if (!url || typeof url !== "string")
         return json(res, 400, { error: "Missing field: url" });
     if (!/^https?:\/\//.test(url))
         return json(res, 400, { error: "url must start with http:// or https://" });
+    // ── Protocol Hash Enforcement — INAMOVIBLE POR LA RED ────────────────────
+    // Si el peer envía un hash, DEBE coincidir con el nuestro.
+    // Si no envía hash → se acepta (nodos legacy / primeras versiones).
+    // En versiones futuras, el hash será OBLIGATORIO.
+    if (protocol_hash && !isProtocolHashCompatible(protocol_hash)) {
+        return json(res, 409, {
+            error: "Protocol mismatch — node rejected",
+            reason: "The peer is running with different protocol constants. This breaks network consensus.",
+            our_hash: PROTOCOL_HASH,
+            their_hash: protocol_hash,
+            our_version: PROTOCOL.VERSION,
+            resolution: "Update soulprint-network to the latest version, or join a compatible network.",
+        });
+    }
     if (peers.includes(url))
         return json(res, 200, { ok: true, peers: peers.length, msg: "Already registered" });
     peers.push(url);
     savePeers();
-    json(res, 200, { ok: true, peers: peers.length });
+    json(res, 200, { ok: true, peers: peers.length, protocol_hash: PROTOCOL_HASH });
 }
 // ── GET /peers ─────────────────────────────────────────────────────────────────
 function handleGetPeers(res) {
@@ -579,6 +652,8 @@ export function startValidatorNode(port = PORT) {
         console.log(`\n🌐 Soulprint Validator Node v${VERSION}`);
         console.log(`   Node DID:     ${nodeKeypair.did}`);
         console.log(`   Listening:    http://0.0.0.0:${port}`);
+        console.log(`   Protocol:     ${PROTOCOL.VERSION} | hash: ${PROTOCOL_HASH.slice(0, 16)}...`);
+        console.log(`   ⚠️  Hash mismatch with peers → connection rejected (P2P enforcement)`);
         console.log(`   Nullifiers:   ${Object.keys(nullifiers).length}`);
         console.log(`   Reputations:  ${Object.keys(repStore).length}`);
         console.log(`   Known peers:  ${peers.length}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soulprint-network",
-  "version": "0.2.2",
+  "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",
@@ -44,8 +44,8 @@
     "otpauth": "^9.5.0",
     "otplib": "^13.3.0",
     "uint8arrays": "5.1.0",
-    "soulprint-core": "0.1.5",
-    "soulprint-zkp": "0.1.3"
+    "soulprint-core": "0.1.7",
+    "soulprint-zkp": "0.1.4"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",