muaddib-scanner 2.10.8 → 2.10.10

package/package.json

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

package/src/intent-graph.js

@@ -173,25 +173,42 @@ function isSDKPattern(envVarName, fileContent) {
     if (/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(domain)) return false;
   }
 
-  // 1. Try curated allowlist first
+  // 1. Try curated allowlist first (strict: ALL domains must match)
+  // Curated allowlist is authoritative — no relaxation here to prevent
+  // attacker injecting a legitimate domain alongside their C2 domain.
   for (const mapping of SDK_ENV_DOMAIN_MAP) {
     if (mapping.envPattern.test(envVarName)) {
-      // All domains must match expected SDK domains
       return domains.every(d => domainMatchesSuffix(d, mapping.domains));
     }
   }
 
+  // R2: credential-suffixed env vars get relaxed domain matching (at least ONE match).
+  // SDKs commonly call their own API + CDN/logging/analytics domains.
+  // Safety: suspicious domains and raw IPs are already rejected above.
+  // Only applies to the heuristic fallback — curated allowlist stays strict.
+  const CREDENTIAL_SUFFIXES = ['_API_KEY', '_SECRET', '_TOKEN', '_SECRET_KEY', '_ACCESS_KEY'];
+  const upperName = envVarName.toUpperCase();
+  const hasCredentialSuffix = CREDENTIAL_SUFFIXES.some(s => upperName.endsWith(s));
+
   // 2. Heuristic fallback: extract brand keyword and check domain labels
   const brand = extractBrandFromEnvVar(envVarName);
   if (!brand || brand.length < 3) return false; // Too short for reliable matching
 
   const brandLower = brand.toLowerCase();
-  // Check if every domain has the brand as a whole label
+  // 2a. Strict check: every domain matches brand (existing behavior)
   // e.g., brand "ACME" matches "api.acme.com" (label "acme") but not "api.acmetech.com"
-  return domains.every(d => {
+  if (domains.every(d => {
+    const labels = d.split('.');
+    return labels.some(label => label === brandLower);
+  })) return true;
+
+  // 2b. R2 relaxed: credential suffix + at least one domain matches brand
+  if (hasCredentialSuffix && domains.some(d => {
     const labels = d.split('.');
     return labels.some(label => label === brandLower);
-  });
+  })) return true;
+
+  return false;
 }
 
 

package/src/scanner/dataflow.js

@@ -954,6 +954,19 @@ function analyzeFile(content, filePath, basePath) {
       }
     }
 
+    // Graduation: HIGH → MEDIUM for env/telemetry-only sources (no credential file reads,
+    // no fingerprint reads, no command output). Distant env/telemetry → network_send
+    // is the dominant FP pattern (SDK/API usage, binary wrappers, config libraries).
+    // Real credential exfiltration uses credential_read or fingerprint_read sources.
+    if (severity === 'HIGH') {
+      const hasHighRiskSource = sources.some(s =>
+        s.type === 'credential_read' || s.type === 'fingerprint_read' || s.type === 'command_output'
+      );
+      if (!hasHighRiskSource) {
+        severity = 'MEDIUM';
+      }
+    }
+
     const sourceDesc = hasCommandOutput ? 'command output' : 'credentials read';
     threats.push({
       type: 'suspicious_dataflow',

package/src/scoring.js

@@ -40,6 +40,11 @@ const MAX_RISK_SCORE = 100;
 // to limit noise while preserving some signal. CRITICAL and HIGH prototype_hook findings still score normally.
 const PROTO_HOOK_MEDIUM_CAP = 15;
 
+// R4: suspicious_dataflow(MEDIUM) is a co-occurrence signal, not a standalone detection.
+// Multiple env_read/telemetry distant flows in the same file should not inflate the score.
+// Compounds (lifecycle_dataflow) provide the real signal and score separately.
+const DATAFLOW_MEDIUM_CAP = 3;
+
 // Confidence-weighted scoring factors (v2.7.10)
 // High-confidence detections (eval, IOC, shell injection) score at full weight.
 // Medium-confidence heuristics (lifecycle_script, obfuscation, high_entropy) are discounted.
@@ -128,6 +133,7 @@ function isPackageLevelThreat(threat) {
 function computeGroupScore(threats) {
   let score = 0;
   let protoHookMediumPoints = 0;
+  let dataflowMediumPoints = 0;
 
   for (const t of threats) {
     const weight = _severityWeights[t.severity] || 0;
@@ -138,11 +144,16 @@ function computeGroupScore(threats) {
       protoHookMediumPoints += weight * factor;
       continue;
     }
+    if (t.type === 'suspicious_dataflow' && t.severity === 'MEDIUM') {
+      dataflowMediumPoints += weight * factor;
+      continue;
+    }
 
     score += weight * factor;
   }
 
   score += Math.min(protoHookMediumPoints, PROTO_HOOK_MEDIUM_CAP);
+  score += Math.min(dataflowMediumPoints, DATAFLOW_MEDIUM_CAP);
   return Math.min(MAX_RISK_SCORE, Math.round(score));
 }