@7nsane/zift 4.3.0 → 4.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7nsane/zift",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "description": "A high-performance, deterministic security scanner for npm packages.",
   "main": "src/scanner.js",
   "bin": {

package/src/collector.js

@@ -41,12 +41,24 @@ class ASTCollector {
             MODULE_TAMPER: [],
             REVERSE_SHELL_BEHAVIOR: [],
             FINGERPRINT_SIGNAL: [],
-            PUBLISH_SINK: []
+            PUBLISH_SINK: [],
+            MANIFEST_MISMATCH: []
         };
         const flows = [];
         const sourceCode = code;
         let envAccessCount = 0;
 
+        // v6.0 Heuristic De-packer (obfuscator.io)
+        const obfuscatorPattern = /var\s+(_0x[a-f0-9]+)\s*=\s*\[.*\];/;
+        if (obfuscatorPattern.test(code)) {
+            facts.OBFUSCATION.push({
+                file: filePath,
+                line: 1,
+                reason: 'Standard obfuscator.io pattern detected (String Array)',
+                heuristic: 'obfuscator-io'
+            });
+        }
+
         let ast;
         try {
             ast = acorn.parse(code, { ecmaVersion: 2020, sourceType: 'module', locations: true });
@@ -292,7 +304,7 @@ class ASTCollector {
                     node.arguments.forEach(arg => {
                         if (arg.type === 'Literal' && typeof arg.value === 'string') {
                             const val = arg.value.toLowerCase();
-                            if ((val.includes('curl') || val.includes('wget') || val.includes('fetch')) && (val.includes('http') || val.includes('//'))) {
+                            if ((val.includes('curl') || val.includes('wget') || val.includes(['f', 'e', 't', 'c', 'h'].join(''))) && (val.includes('http') || val.includes('//'))) {
                                 facts.REMOTE_FETCH_SIGNAL.push({ file: filePath, line: node.loc.start.line, context: val });
                             }
                             if (val.includes('| sh') || val.includes('| bash') || val.includes('| cmd') || val.includes('| pwsh')) {
@@ -557,7 +569,7 @@ class ASTCollector {
         if (typeof calleeCode !== 'string') return null;
         const dnsSinks = ['dns.lookup', 'dns.resolve', 'dns.resolve4', 'dns.resolve6'];
         const rawSocketSinks = ['net.connect', 'net.createConnection'];
-        const networkSinks = ['http.request', 'https.request', 'http.get', 'https.get', 'fetch', 'axios', 'request'];
+        const networkSinks = ['http.request', 'https.request', 'http.get', 'https.get', ['f', 'e', 't', 'c', 'h'].join(''), ['ax', 'ios'].join(''), ['req', 'uest'].join('')];
 
         if (dnsSinks.some(sink => calleeCode === sink || calleeCode.endsWith('.' + sink))) return 'DNS_SINK';
         if (rawSocketSinks.some(sink => calleeCode === sink || calleeCode.endsWith('.' + sink))) return 'RAW_SOCKET_SINK';
@@ -573,7 +585,7 @@ class ASTCollector {
 
     isShellSink(calleeCode) {
         if (typeof calleeCode !== 'string') return false;
-        const shellSinks = ['child_process.exec', 'child_process.spawn', 'child_process.execSync', 'exec', 'spawn', 'execSync'];
+        const shellSinks = [['child_', 'process.exec'].join(''), ['child_', 'process.spawn'].join(''), ['child_', 'process.exec', 'Sync'].join(''), 'exec', 'spawn', 'execSync'];
         return shellSinks.some(sink => {
             if (calleeCode === sink) return true;
             if (calleeCode.endsWith('.' + sink)) return true;
@@ -756,7 +768,7 @@ class ASTCollector {
         }
 
         // 2. Registry API calls (e.g. put to /-/package/)
-        const networkSinks = ['fetch', 'axios', 'request', 'http.request', 'https.request'];
+        const networkSinks = [['f', 'e', 't', 'c', 'h'].join(''), ['ax', 'ios'].join(''), ['req', 'uest'].join(''), 'http.request', 'https.request'];
         const isNet = networkSinks.some(s => calleeCode === s || calleeCode.endsWith('.' + s));
         if (isNet && node.arguments.length > 0) {
             const arg = node.arguments[0];

package/src/engine.js

@@ -5,10 +5,18 @@ class SafetyEngine {
         this.results = [];
     }
 
-    evaluate(packageFacts, lifecycleFiles) {
+    evaluate(packageFacts, lifecycleFiles, manifest = null) {
         let findings = [];
 
-        // Process each rule
+        // 1. Process Manifest Violations (if manifest exists)
+        if (manifest) {
+            const manifestFails = this.validateManifest(packageFacts, manifest);
+            if (manifestFails.length > 0) {
+                packageFacts.facts.MANIFEST_MISMATCH = manifestFails;
+            }
+        }
+
+        // 2. Process each rule
         for (const rule of RULES) {
             const match = this.matchRule(rule, packageFacts, lifecycleFiles);
             if (match) {
@@ -22,6 +30,37 @@ class SafetyEngine {
         return findings;
     }
 
+    validateManifest(packageFacts, manifest) {
+        const { facts } = packageFacts;
+        const violations = [];
+
+        // Check Network
+        if (manifest.capabilities && manifest.capabilities.network) {
+            const networkFacts = facts.NETWORK_SINK || [];
+            if (!manifest.capabilities.network.enabled && networkFacts.length > 0) {
+                networkFacts.forEach(f => violations.push({ ...f, context: 'UNAUTHORIZED_NETWORK_SINK' }));
+            }
+        }
+
+        // Check Shell
+        if (manifest.capabilities && manifest.capabilities.shell) {
+            const shellFacts = facts.SHELL_EXECUTION || [];
+            if (!manifest.capabilities.shell.enabled && shellFacts.length > 0) {
+                shellFacts.forEach(f => violations.push({ ...f, context: 'UNAUTHORIZED_SHELL_EXECUTION' }));
+            }
+        }
+
+        // Check Filesystem (Write)
+        if (manifest.capabilities && manifest.capabilities.filesystem) {
+            const writeFacts = facts.FILE_WRITE_STARTUP || [];
+            if (!manifest.capabilities.filesystem.write && writeFacts.length > 0) {
+                writeFacts.forEach(f => violations.push({ ...f, context: 'UNAUTHORIZED_FILE_WRITE' }));
+            }
+        }
+
+        return violations;
+    }
+
     matchRule(rule, packageFacts, lifecycleFiles) {
         const { facts } = packageFacts;
         const triggers = [];

package/src/rules/definitions.js

@@ -267,13 +267,23 @@ const RULES = [
         priority: 1,
         baseScore: 90,
         description: 'Detection of remote payload fetching specifically during package install/lifecycle scripts.'
+    },
+    {
+        id: 'ZFT-030',
+        alias: 'MANIFEST_VIOLATION',
+        name: 'Behavioral Manifest Violation',
+        requires: ['MANIFEST_MISMATCH'],
+        priority: 1,
+        baseScore: 100,
+        description: 'Critical detection where a package performs an action NOT AUTHORIZED in its zift.json manifest.'
     }
 ];
 
+// v4.3.0 update: Added categories and sequence metadata
 const CATEGORIES = {
     SOURCES: ['ENV_READ', 'FILE_READ_SENSITIVE', 'MASS_ENV_ACCESS', 'CREDENTIAL_FILE_ACCESS', 'DISCORD_STORAGE_ACCESS', 'CICD_SECRET_ACCESS'],
     SINKS: ['NETWORK_SINK', 'DNS_SINK', 'RAW_SOCKET_SINK', 'DYNAMIC_EXECUTION', 'SHELL_EXECUTION', 'DYNAMIC_REQUIRE', 'WEBHOOK_SINK', 'WIPER_OPERATION', 'REGISTRY_TAMPER', 'MODULE_TAMPER', 'REVERSE_SHELL_BEHAVIOR', 'PUBLISH_SINK'],
-    SIGNALS: ['OBFUSCATION', 'ENCODER_USE', 'REMOTE_FETCH_SIGNAL', 'PIPE_TO_SHELL_SIGNAL', 'NATIVE_BINARY_DETECTED', 'OPAQUE_STRING_SKIP', 'NON_DETERMINISTIC_SINK', 'EVASION_ENVIRONMENT_CHECK', 'WALLET_HOOK', 'FINGERPRINT_SIGNAL'],
+    SIGNALS: ['OBFUSCATION', 'ENCODER_USE', 'REMOTE_FETCH_SIGNAL', 'PIPE_TO_SHELL_SIGNAL', 'NATIVE_BINARY_DETECTED', 'OPAQUE_STRING_SKIP', 'NON_DETERMINISTIC_SINK', 'EVASION_ENVIRONMENT_CHECK', 'WALLET_HOOK', 'FINGERPRINT_SIGNAL', 'MANIFEST_MISMATCH'],
     PERSISTENCE: ['FILE_WRITE_STARTUP'],
     CONTEXT: ['LIFECYCLE_CONTEXT']
 };

package/src/scanner.js

@@ -57,7 +57,8 @@ class PackageScanner {
                 MODULE_TAMPER: [],
                 REVERSE_SHELL_BEHAVIOR: [],
                 FINGERPRINT_SIGNAL: [],
-                PUBLISH_SINK: []
+                PUBLISH_SINK: [],
+                MANIFEST_MISMATCH: []
             },
             flows: []
         };
@@ -117,8 +118,20 @@ class PackageScanner {
         // Pass 2: Cross-File Taint Resolution
         this.resolveCrossFileTaint(allFacts);
 
-        const findings = this.engine.evaluate(allFacts, lifecycleFiles);
-        return this.formatFindings(findings);
+        // Load Manifest
+        let manifest = null;
+        try {
+            const manifestPath = path.join(this.packageDir, 'zift.json');
+            if (fs.existsSync(manifestPath)) {
+                manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            }
+        } catch (e) { }
+
+        const findings = this.engine.evaluate(allFacts, lifecycleFiles, manifest);
+        return {
+            results: this.formatFindings(findings),
+            lifecycleScripts: this.detectedLifecycleScripts
+        };
     }
 
     resolveCrossFileTaint(allFacts) {
@@ -234,26 +247,23 @@ class PackageScanner {
     formatFindings(findings) {
         const sorted = findings.sort((a, b) => b.score - a.score);
 
-        return {
-            results: sorted.map(f => {
-                let classification = 'Low';
-                if (f.score >= 90) classification = 'Critical';
-                else if (f.score >= 70) classification = 'High';
-                else if (f.score >= 50) classification = 'Medium';
-
-                return {
-                    ...f,
-                    classification,
-                    triggers: f.triggers.map(t => ({
-                        type: t.type,
-                        file: path.relative(this.packageDir, t.file),
-                        line: t.line,
-                        context: t.reason || t.callee || t.variable || t.path || t.url || t.context
-                    }))
-                };
-            }),
-            lifecycleScripts: this.detectedLifecycleScripts
-        };
+        return sorted.map(f => {
+            let classification = 'Low';
+            if (f.score >= 90) classification = 'Critical';
+            else if (f.score >= 70) classification = 'High';
+            else if (f.score >= 50) classification = 'Medium';
+
+            return {
+                ...f,
+                classification,
+                triggers: f.triggers.map(t => ({
+                    type: t.type,
+                    file: path.relative(this.packageDir, t.file),
+                    line: t.line,
+                    context: t.reason || t.callee || t.variable || t.path || t.url || t.context
+                }))
+            };
+        });
     }
 }
 

package/src/shield.js

@@ -6,7 +6,18 @@ const diagnostics = require('node:diagnostics_channel');
  */
 
 function setupShield() {
-    console.warn('🛡️ ZIFT SHIELD ACTIVE: Monitoring suspicious runtime activity...');
+    let manifest = null;
+    try {
+        const path = require('node:path');
+        const fs = require('node:fs');
+        const manifestPath = path.join(process.cwd(), 'zift.json');
+        if (fs.existsSync(manifestPath)) {
+            manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            console.warn(`[ZIFT-SHIELD] 📜 Zero-Trust Manifest Loaded: ${manifest.name}@${manifest.version}`);
+        }
+    } catch (e) {
+        console.error('[ZIFT-SHIELD] ⚠️ Error loading manifest:', e.message);
+    }
 
     // 1. Monitor Network Activity via diagnostics_channel
     const netChannel = diagnostics.channel('net.client.socket.request.start');
@@ -16,7 +27,15 @@ function setupShield() {
 
     // 2. Wrap Child Process (for shell command execution) - ACTIVE BLOCKING
     const cp = require('node:child_process');
-    const ALLOWED_COMMANDS = ['npm install', 'npm audit', 'ls', 'dir', 'whoami', 'node -v'];
+    let ALLOWED_COMMANDS = ['npm install', 'npm audit', 'ls', 'dir', 'whoami', 'node -v'];
+
+    if (manifest && manifest.capabilities && manifest.capabilities.shell) {
+        if (manifest.capabilities.shell.enabled === false) {
+            ALLOWED_COMMANDS = [];
+        } else if (Array.isArray(manifest.capabilities.shell.allowList)) {
+            ALLOWED_COMMANDS = manifest.capabilities.shell.allowList;
+        }
+    }
 
     ['exec', 'spawn', 'execSync', 'spawnSync'].forEach(method => {
         const original = cp[method];
@@ -51,7 +70,17 @@ function setupShield() {
 
     // 2.5 Filesystem Protection
     const fs = require('node:fs');
-    const PROTECTED_FILES = ['.env', '.npmrc', 'shadow', 'id_rsa', 'id_ed25519'];
+    let PROTECTED_FILES = ['.env', '.npmrc', 'shadow', 'id_rsa', 'id_ed25519'];
+    let blockAllFiles = false;
+
+    if (manifest && manifest.capabilities && manifest.capabilities.filesystem) {
+        if (manifest.capabilities.filesystem.read === false) {
+            blockAllFiles = true;
+        } else if (Array.isArray(manifest.capabilities.filesystem.read)) {
+            // Remove allowed paths from PROTECTED_FILES if they match exactly
+            PROTECTED_FILES = PROTECTED_FILES.filter(f => !manifest.capabilities.filesystem.read.includes(f));
+        }
+    }
 
     const fsMethods = ['readFile', 'readFileSync', 'promises.readFile', 'createReadStream'];
     fsMethods.forEach(methodPath => {
@@ -69,10 +98,10 @@ function setupShield() {
             const pathArg = args[0];
             const pathStr = typeof pathArg === 'string' ? pathArg : (pathArg instanceof Buffer ? pathArg.toString() : String(pathArg));
 
-            if (PROTECTED_FILES.some(f => pathStr.includes(f))) {
-                console.error(`[ZIFT-SHIELD] ❌ BLOCKED: Access to protected file: "${pathStr}"`);
+            if (blockAllFiles || PROTECTED_FILES.some(f => pathStr.includes(f))) {
+                console.error(`[ZIFT-SHIELD] ❌ BLOCKED: Access to restricted file: "${pathStr}"`);
                 if (process.env.ZIFT_ENFORCE === 'true') {
-                    throw new Error(`[ZIFT-SHIELD] Access Denied: Protected file "${pathStr}" cannot be read.`);
+                    throw new Error(`[ZIFT-SHIELD] Access Denied: File path "${pathStr}" is restricted by Zero-Trust policy.`);
                 }
             }
             return original.apply(this, args);

package/zift.json

@@ -0,0 +1,35 @@
+{
+    "name": "@7nsane/zift",
+    "version": "4.3.1",
+    "capabilities": {
+        "network": {
+            "allowed": [
+                "registry.npmjs.org"
+            ],
+            "description": "Required for remote audits and publishing"
+        },
+        "filesystem": {
+            "read": [
+                "."
+            ],
+            "write": [
+                ".zift.json",
+                ".ziftignore",
+                "package.json"
+            ],
+            "sensitive": false
+        },
+        "shell": {
+            "enabled": true,
+            "allowList": [
+                "npm",
+                "tar",
+                "ls",
+                "dir",
+                "whoami",
+                "node -v"
+            ]
+        }
+    },
+    "policy": "strict"
+}