muaddib-scanner 2.10.30 → 2.10.31

package/README.md

@@ -30,7 +30,7 @@
 
 npm and PyPI supply-chain attacks are exploding. Shai-Hulud compromised 25K+ repos in 2025. Existing tools detect threats but don't help you respond.
 
-MUAD'DIB combines **14 parallel scanners** (176 detection rules), a **deobfuscation engine**, **inter-module dataflow analysis**, **compound scoring**, **ML classifiers** (XGBoost), and Docker sandbox to detect known threats and suspicious behavioral patterns in npm and PyPI packages.
+MUAD'DIB combines **14 parallel scanners** (195 detection rules), a **deobfuscation engine**, **inter-module dataflow analysis**, **compound scoring**, **ML classifiers** (XGBoost), and Docker sandbox to detect known threats and suspicious behavioral patterns in npm and PyPI packages.
 
 ---
 
@@ -195,7 +195,7 @@ muaddib replay                     # Ground truth validation (46/49 TPR)
 | GitHub Actions | Shai-Hulud backdoor detection |
 | Hash Scanner | Known malicious file hashes |
 
-### 176 detection rules
+### 195 detection rules
 
 All rules are mapped to MITRE ATT&CK techniques. See [SECURITY.md](SECURITY.md#detection-rules-v21021) for the complete rules reference.
 
@@ -271,7 +271,7 @@ With pre-commit framework:
 ```yaml
 repos:
   - repo: https://github.com/DNSZLSK/muad-dib
-    rev: v2.10.21
+    rev: v2.10.31
     hooks:
       - id: muaddib-scan
 ```
@@ -288,7 +288,7 @@ repos:
 | **FPR** (Benign random) | **7.5%** (15/200) | 200 random npm packages, stratified sampling |
 | **ADR** (Adversarial + Holdout) | **94.0%** (101/107) | 67 adversarial + 40 holdout (107 available on disk), global threshold=20 |
 
-**2793 tests** across 57 files. **176 rules** (171 RULES + 5 PARANOID).
+**2868 tests** across 62 files. **195 rules** (190 RULES + 5 PARANOID).
 
 > **Methodology caveats:**
 > - TPR measured on 49 Node.js attack samples (3 browser-only excluded from 51 total)
@@ -329,7 +329,7 @@ npm test
 
 ### Testing
 
-- **2793 tests** across 57 modular test files
+- **2868 tests** across 62 modular test files
 - **56 fuzz tests** - Malformed inputs, ReDoS, unicode, binary
 - **Datadog 17K benchmark** - 14,587 confirmed malware samples (in-scope)
 - **Ground truth validation** - 51 real-world attacks (93.9% TPR)
@@ -351,7 +351,7 @@ npm test
 - [Evaluation Methodology](docs/EVALUATION_METHODOLOGY.md) - Experimental protocol, holdout scores
 - [Threat Model](docs/threat-model.md) - What MUAD'DIB detects and doesn't detect
 - [Adversarial Evaluation](ADVERSARIAL.md) - Red team samples and ADR results
-- [Security Policy](SECURITY.md) - Detection rules reference (176 rules)
+- [Security Policy](SECURITY.md) - Detection rules reference (195 rules)
 - [Security Audit](docs/SECURITY_AUDIT.md) - Bypass validation report
 - [FP Analysis](docs/EVALUATION.md) - Historical false positive analysis
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muaddib-scanner",
-  "version": "2.10.30",
+  "version": "2.10.31",
   "description": "Supply-chain threat detection & response for npm & PyPI/Python",
   "main": "src/index.js",
   "bin": {

package/src/response/playbooks.js

@@ -511,6 +511,13 @@ const PLAYBOOKS = {
     'CRITIQUE: Un Proxy JavaScript avec trap set/get/apply est combine avec un appel reseau. ' +
     'Technique d\'interception: le Proxy capture toutes les ecritures de proprietes (credentials, tokens, config) ' +
     'et les exfiltre via HTTPS/fetch/dgram. Supprimer le package. Auditer tous les modules qui importent ce package.',
+  proxy_globalthis_intercept:
+    'CRITIQUE: new Proxy(globalThis/global) intercepte tous les acces au scope global. ' +
+    'L\'attaquant peut hooker eval, Function, require de maniere transparente via le handler Proxy. ' +
+    'Supprimer le package immediatement.',
+  reflect_bind_code_execution:
+    'CRITIQUE: Reflect.apply() avec methode prototype (bind/call/apply) et thisArg=Function/eval. ' +
+    'Evasion de 2nd niveau contournant la detection Reflect.apply(eval). Supprimer le package.',
   detached_credential_exfil:
     'CRITIQUE: Process detache avec acces aux credentials et exfiltration reseau. ' +
     'Technique DPRK/Lazarus: le process fils survit au parent (detached:true, unref()) et exfiltre des secrets en arriere-plan. ' +

package/src/rules/index.js

@@ -2142,6 +2142,24 @@ const RULES = {
     ],
     mitre: 'T1082'
   },
+  proxy_globalthis_intercept: {
+    id: 'MUADDIB-AST-083',
+    name: 'Proxy GlobalThis Interception',
+    severity: 'CRITICAL',
+    confidence: 'high',
+    description: 'new Proxy(globalThis/global/window/self) — intercepts all global scope access, enabling transparent hooking of eval/Function/require.',
+    references: ['https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy'],
+    mitre: 'T1574'
+  },
+  reflect_bind_code_execution: {
+    id: 'MUADDIB-AST-084',
+    name: 'Reflect.apply Prototype Method Code Execution',
+    severity: 'CRITICAL',
+    confidence: 'high',
+    description: 'Reflect.apply(Function.prototype.bind/call/apply, Function, [...]) — indirect code execution via Reflect with prototype method as target.',
+    references: ['https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/apply'],
+    mitre: 'T1059'
+  },
   lifecycle_missing_script: {
     id: 'MUADDIB-PKG-017',
     name: 'Phantom Lifecycle Script',

package/src/scanner/ast-detectors/handle-call-expression.js

@@ -1496,6 +1496,26 @@ function handleCallExpression(node, ctx) {
           file: ctx.relFile
         });
       }
+      // Bypass fix: Reflect.apply(Function.prototype.bind/call/apply, Function, [...])
+      if (target.type === 'MemberExpression') {
+        const methodProp = target.property;
+        const methodName = methodProp?.type === 'Identifier' ? methodProp.name :
+                           (methodProp?.type === 'Literal' ? String(methodProp.value) : null);
+        if (methodName === 'bind' || methodName === 'call' || methodName === 'apply') {
+          const thisArg = node.arguments[1];
+          if (thisArg?.type === 'Identifier' &&
+              (thisArg.name === 'Function' || thisArg.name === 'eval' ||
+               ctx.evalAliases?.has(thisArg.name))) {
+            ctx.hasDynamicExec = true;
+            ctx.threats.push({
+              type: 'reflect_bind_code_execution',
+              severity: 'CRITICAL',
+              message: `Reflect.apply(*.${methodName}, ${thisArg.name}, [...]) — indirect ${thisArg.name} invocation via prototype method, bypasses Reflect.apply(${thisArg.name}) detection.`,
+              file: ctx.relFile
+            });
+          }
+        }
+      }
       // B1: Reflect.apply(require, null, ['child_process']) — bypasses require() call detection
       if (target.type === 'Identifier' && target.name === 'require') {
         const argsArray = node.arguments[2];

package/src/scanner/ast-detectors/handle-new-expression.js

@@ -58,6 +58,18 @@ function handleNewExpression(node, ctx) {
         file: ctx.relFile
       });
     }
+    // Detect new Proxy(globalThis/global/window/self, handler) — intercepts all global access
+    if (target.type === 'Identifier' &&
+        (target.name === 'globalThis' || target.name === 'global' ||
+         target.name === 'window' || target.name === 'self' ||
+         ctx.globalThisAliases.has(target.name))) {
+      ctx.threats.push({
+        type: 'proxy_globalthis_intercept',
+        severity: 'CRITICAL',
+        message: `new Proxy(${target.name}, handler) — intercepts all global object access. Attacker can hook eval/Function/require transparently.`,
+        file: ctx.relFile
+      });
+    }
     // Detect new Proxy(obj, handler) where handler has set/get traps — data interception
     // Real-world technique: export a Proxy that intercepts all property sets/gets to exfiltrate
     // data flowing through the module. Combined with network (hasNetworkInFile) → credential theft.

package/src/scanner/ast-detectors/handle-variable-declarator.js

@@ -58,6 +58,19 @@ function handleVariableDeclarator(node, ctx) {
       ctx.globalThisAliases.add(node.id.name);
     }
 
+    // Track Proxy(globalThis) as globalThis alias for downstream detection
+    if (node.init?.type === 'NewExpression' &&
+        node.init.callee?.type === 'Identifier' && node.init.callee.name === 'Proxy' &&
+        node.init.arguments?.length >= 2) {
+      const proxyTarget = node.init.arguments[0];
+      if (proxyTarget?.type === 'Identifier' &&
+          (proxyTarget.name === 'globalThis' || proxyTarget.name === 'global' ||
+           proxyTarget.name === 'window' || proxyTarget.name === 'self' ||
+           ctx.globalThisAliases.has(proxyTarget.name))) {
+        ctx.globalThisAliases.add(node.id.name);
+      }
+    }
+
     // B1: const E = eval; const F = Function;
     if (node.init?.type === 'Identifier' &&
         (node.init.name === 'eval' || node.init.name === 'Function')) {