@nekzus/liop 1.2.0 → 2.0.0-alpha.1

package/dist/server/pii.js

@@ -159,14 +159,136 @@ export const PII_PRESETS = {
 export class PiiScanner {
     patterns;
     forbiddenKeysSet;
-    constructor(patterns = [], forbiddenKeys = []) {
+    nerScanner;
+    /**
+     * Safelist of keys that contain forbidden substrings but are NOT PII.
+     * Prevents false positives from fuzzy matching (e.g., "grid" contains "id").
+     */
+    static KEY_SAFELIST = new Set([
+        // Common words containing "id" substring
+        "grid",
+        "video",
+        "android",
+        "identity",
+        "provide",
+        "override",
+        "validate",
+        "hidden",
+        "widget",
+        "guidelines",
+        "beside",
+        "guideline",
+        "outside",
+        "inside",
+        "collide",
+        "decide",
+        "divide",
+        "aside",
+        "ride",
+        "side",
+        "wide",
+        "hide",
+        "tide",
+        "pride",
+        "bride",
+        "slide",
+        "guide",
+        "stride",
+        "oxide",
+        "dioxide",
+        "suicide",
+        "homicide",
+        "pesticide",
+        "valid",
+        "invalid",
+        "void",
+        "avoid",
+        // Common words containing "name" substring
+        "diagnosis",
+        "medication",
+        "namespace",
+        "namesake",
+        "rename",
+        "filename",
+        "hostname",
+        "typename",
+        "unnamed",
+        "renamed",
+        // Common words containing "phone" substring
+        "phonetic",
+        "phoneme",
+        "microphone",
+        "headphone",
+        "telephone",
+        "saxophone",
+        "smartphone",
+        // Common words containing "address" substring
+        "streetview",
+        "addressable",
+        "addressing",
+        // Common words containing "city" substring
+        "cityscape",
+        "electricity",
+        "capacity",
+        "velocity",
+        "opacity",
+        // Common technical terms
+        "timestamp",
+        "timezone",
+        // LIOP Protocol Internal Keys (must never be blocked)
+        "image_id",
+        "computation_result",
+        "zk_receipt",
+        "testid",
+        "toolid",
+        "sessionid",
+        "peerid",
+        "nodeid",
+        "requestid",
+        "correlationid",
+        "traceid",
+        "spanid",
+    ]);
+    /**
+     * Short forbidden tokens (< 4 chars) that require boundary-aware matching.
+     * Uses regex boundary detection to avoid false positives.
+     */
+    shortTokenBoundaryPatterns;
+    /**
+     * Long forbidden tokens (>= 4 chars) that use substring containment.
+     */
+    longForbiddenTokens;
+    constructor(patterns = [], forbiddenKeys = [], nerScanner) {
         this.patterns = patterns;
-        // Optimizes large recursive evaluations using O(1) continuous key lookup
         this.forbiddenKeysSet = new Set(forbiddenKeys.map((k) => k.toLowerCase()));
+        this.nerScanner = nerScanner ?? null;
+        // Pre-compute fuzzy matching structures for performance
+        this.shortTokenBoundaryPatterns = new Map();
+        this.longForbiddenTokens = [];
+        for (const token of this.forbiddenKeysSet) {
+            if (token.length < 4) {
+                // Short tokens: require word boundary (camelCase, snake_case, kebab-case, or exact)
+                // "id" matches: "patientId", "record_id", "user-id", "id"
+                // "id" does NOT match: "grid", "video", "android"
+                this.shortTokenBoundaryPatterns.set(token, new RegExp(`(?:^|[_-])${token}(?:$|[_-])|` + // snake/kebab boundary
+                    `(?:^|[a-z])${token.charAt(0).toUpperCase()}${token.slice(1)}|` + // camelCase boundary (e.g., patientId)
+                    `^${token}$`, // exact match
+                "i"));
+            }
+            else {
+                this.longForbiddenTokens.push(token);
+            }
+        }
     }
     /**
      * Scans any input (string, object, array) for PII violations.
      * Returns the pattern/rule name that triggered the violation, or null if safe.
+     *
+     * Detection pipeline (fail-fast):
+     *   1. Exact key match (O(1) Set lookup)
+     *   2. Fuzzy key match (boundary detection for short tokens, substring for long)
+     *   3. Regex/algorithmic pattern match on string values
+     *   4. NER content scan on string values (if enabled)
      */
     scan(input, seen = new WeakSet()) {
         if (input === null || input === undefined)
@@ -189,8 +311,21 @@ export class PiiScanner {
                     // Silent fallback: It looked like JSON but wasn't valid. Proceed with raw string check.
                 }
             }
-            // Fallback: Check the raw string
-            return this.checkString(input);
+            // Check string value against regex patterns
+            const patternViolation = this.checkString(input);
+            if (patternViolation)
+                return patternViolation;
+            // Layer 3: NER Content Scan — detect person names in free-text values
+            if (this.nerScanner) {
+                const nerResult = this.nerScanner.scan(input);
+                if (nerResult.detected) {
+                    const personEntity = nerResult.entities.find((e) => e.type === "person");
+                    if (personEntity) {
+                        return `PII Entity Detected: person name "${personEntity.text}"`;
+                    }
+                }
+            }
+            return null;
         }
         // 2. Recursive Objects/Arrays Scan
         if (typeof input === "object") {
@@ -207,10 +342,14 @@ export class PiiScanner {
             }
             else {
                 for (const [key, value] of Object.entries(input)) {
-                    // Check Keys using O(1) Constant Time Memory Evaluation
+                    // Layer 1: Exact key match — O(1) constant time
                     if (this.forbiddenKeysSet.has(key.toLowerCase())) {
                         return `Forbidden Key: ${key}`;
                     }
+                    // Layer 2: Fuzzy key match — catches aliases and variations
+                    const fuzzyViolation = this.checkKeyFuzzy(key);
+                    if (fuzzyViolation)
+                        return fuzzyViolation;
                     // Recurse into values
                     const violation = this.scan(value, seen);
                     if (violation)
@@ -220,6 +359,29 @@ export class PiiScanner {
         }
         return null;
     }
+    /**
+     * Checks a key against fuzzy matching rules.
+     * Short tokens use boundary-aware regex; long tokens use substring containment.
+     */
+    checkKeyFuzzy(key) {
+        const normalized = key.toLowerCase();
+        // Skip safelisted keys entirely
+        if (PiiScanner.KEY_SAFELIST.has(normalized))
+            return null;
+        // Short token boundary matching (e.g., "id" in "patientId" but not "grid")
+        for (const [token, pattern] of this.shortTokenBoundaryPatterns) {
+            if (pattern.test(key)) {
+                return `Forbidden Key (fuzzy): ${key} matches boundary pattern "${token}"`;
+            }
+        }
+        // Long token substring matching (e.g., "name" in "firstName", "names")
+        for (const token of this.longForbiddenTokens) {
+            if (normalized.includes(token)) {
+                return `Forbidden Key (fuzzy): ${key} contains restricted token "${token}"`;
+            }
+        }
+        return null;
+    }
     checkString(text) {
         for (const rule of this.patterns) {
             if (typeof rule === "string") {

package/dist/workers/logic-execution.js

@@ -30,9 +30,11 @@ export default async function processLogicExecution(data) {
         // 3. Decrypt Inputs
         for (const [key, encValue] of Object.entries(inputs || {})) {
             const valBuffer = Buffer.from(encValue);
+            // Extract 12-byte prepended nonce, ciphertext, and 16-byte AuthTag
+            const inputNonce = valBuffer.subarray(0, 12);
             const valTag = valBuffer.subarray(-16);
-            const valData = valBuffer.subarray(0, -16);
-            const valDecipher = crypto.createDecipheriv("aes-256-gcm", aesKey, Buffer.from(aesNonce || new Uint8Array(12)));
+            const valData = valBuffer.subarray(12, -16);
+            const valDecipher = crypto.createDecipheriv("aes-256-gcm", aesKey, inputNonce);
             valDecipher.setAuthTag(valTag);
             let valDecrypted = valDecipher.update(valData);
             valDecrypted = Buffer.concat([valDecrypted, valDecipher.final()]);

package/dist/workers/zk-verifier.d.ts

@@ -10,6 +10,8 @@ export interface ZkVerificationPayload {
     remoteImageIdHex: string;
     /** Cbor-encoded or raw buffer containing the execution Receipt (Journal + Seal) */
     zkReceipt: Uint8Array;
+    /** Kyber-derived session secret to verify HMAC signature */
+    sessionSecret?: Uint8Array;
 }
 /**
  * Main worker entry point for Piscina.

package/dist/workers/zk-verifier.js

@@ -1,3 +1,4 @@
+import crypto from "node:crypto";
 import { parentPort } from "node:worker_threads";
 import { deriveLogicImageDigest } from "../crypto/logic-image-id.js";
 // Ensure this worker is used via Piscina pool
@@ -12,7 +13,7 @@ function deriveImageId(logicPayload) {
  * In a real environment, this delegates to @risc0/verifier or SP1 FFI bindings.
  */
 async function verifyZkReceipt(payload) {
-    const { logicPayload, remoteImageIdHex, zkReceipt } = payload;
+    const { logicPayload, remoteImageIdHex, zkReceipt, sessionSecret } = payload;
     // 1. Calculate local ImageID (Integrity Check)
     const localImageId = deriveImageId(logicPayload);
     const localImageIdHex = localImageId.toString("hex");
@@ -60,6 +61,19 @@ async function verifyZkReceipt(payload) {
     catch (_e) {
         return { verified: false, message: "Failed to parse journal data." };
     }
+    // 4. Mathematical Verification (HMAC-SHA256)
+    if (sessionSecret && sessionSecret.length > 0) {
+        const expectedSeal = crypto
+            .createHmac("sha256", sessionSecret)
+            .update(journal)
+            .digest();
+        if (!crypto.timingSafeEqual(seal, expectedSeal)) {
+            return {
+                verified: false,
+                message: "Invalid seal: HMAC verification failed.",
+            };
+        }
+    }
     return {
         verified: true,
         message: "HMAC Commitment Verified: Integrity intact.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nekzus/liop",
-  "version": "1.2.0",
+  "version": "2.0.0-alpha.1",
   "description": "Official SDK for Logic-Injection-on-Origin Protocol (LIOP). Deploy Logic-on-Origin with WebAssembly at gRPC speed and bidirectional MCP compatibility.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -88,10 +88,10 @@
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Nekzus/Neural-Mesh-Protocol.git"
+    "url": "git+https://github.com/Nekzus/LIOP.git"
   },
   "bugs": {
-    "url": "https://github.com/Nekzus/Neural-Mesh-Protocol/issues"
+    "url": "https://github.com/Nekzus/LIOP/issues"
   },
   "homepage": "https://nekzus-32.mintlify.app/",
   "publishConfig": {
@@ -131,6 +131,7 @@
     "@modelcontextprotocol/sdk": "^1.28.0",
     "@multiformats/multiaddr": "^13.0.1",
     "@opentelemetry/api": "^1.9.1",
+    "compromise": "14.15.0",
     "gpt-tokenizer": "^3.4.0",
     "hono": "^4.12.5",
     "it-pipe": "^3.0.1",