muaddib-scanner 2.10.21 → 2.10.23

package/src/response/playbooks.js

@@ -698,6 +698,118 @@ const PLAYBOOKS = {
     'dans ~/.config/sysmon/ et exfiltre vers checkmarx.zone. ' +
     'Verifier: find $(python -c "import site; print(site.getsitepackages()[0])") -name "*.pth" -exec cat {} \\; ' +
     'Supprimer tout fichier .pth non standard. Rotation des credentials.',
+
+  // Audit v3 Bypass Playbooks (AST-062 to AST-069)
+  reflect_apply_require:
+    'CRITIQUE: Reflect.apply(require, null, [module]) detecte — contournement de require() via Reflect API. ' +
+    'Aucun package legitime ne charge des modules via Reflect.apply. ' +
+    'Supprimer le package. Auditer les modules charges dynamiquement.',
+
+  finalization_registry_exec:
+    'CRITIQUE: FinalizationRegistry avec callback dangereux (child_process/exec/spawn). ' +
+    'Le callback s\'execute apres le garbage collection, hors du flux synchrone — evasion sandbox. ' +
+    'Aucun usage legitime ne combine FinalizationRegistry avec des appels systeme. Supprimer le package.',
+
+  function_prototype_constructor:
+    'CRITIQUE: Acces au constructeur Function via chaine de prototypes — (function(){}).constructor(code) ' +
+    'ou [].constructor.constructor(code). Equivalent a eval() mais invisible aux detections statiques de eval/Function. ' +
+    'Supprimer le package. Aucun usage legitime.',
+
+  prototype_pollution:
+    'HAUTE: Pollution de prototype detectee (__proto__, __defineGetter__, __defineSetter__). ' +
+    'Peut detourner les proprietes heritees de tous les objets du runtime. ' +
+    'Verifier si le code modifie Object.prototype ou des prototypes de classes natives. ' +
+    'Si combine avec du code d\'execution dynamique, traiter comme CRITIQUE.',
+
+  module_wrap_override:
+    'CRITIQUE: Module.wrap remplace — la fonction wrapper du module loader est detournee. ' +
+    'Tout module charge apres cette modification execute du code injecte. ' +
+    'Aucun package legitime ne remplace Module.wrap. Supprimer immediatement.',
+
+  symbol_property_hiding:
+    'HAUTE: Module dangereux cache derriere une propriete Symbol. ' +
+    'Invisible a Object.keys(), JSON.stringify() et for...in. Technique anti-forensics. ' +
+    'Auditer toutes les proprietes Symbol du module. Supprimer si combine avec child_process/fs.',
+
+  with_body_dangerous:
+    'HAUTE: with() statement avec require/exec/spawn dans le body. ' +
+    'Le with() rend les identifiants ambigus, empechant l\'analyse statique. ' +
+    'Aucun code moderne legitime n\'utilise with(). Supprimer le package.',
+
+  require_process_mainmodule:
+    'CRITIQUE: require("process").mainModule.require() detecte — contournement de la detection ' +
+    'process.mainModule.require() via require("process") au lieu de l\'objet global. ' +
+    'Aucun package legitime n\'utilise ce pattern. Supprimer immediatement.',
+
+  // Blue Team v8 — New playbook entries
+  shared_memory_ipc:
+    'SharedArrayBuffer + Worker Thread detectes. Canal IPC memoire partagee qui contourne la surveillance. ' +
+    'Verifier si les workers manipulent des donnees sensibles. Isoler si combine avec eval/exec.',
+
+  websocket_c2:
+    'HAUTE: Connexion WebSocket vers domaine suspect ou avec execution dynamique. Canal C2 persistant bidirectionnel. ' +
+    'Analyser l\'URL de connexion. Bloquer les connexions WebSocket sortantes. Verifier les messages echanges.',
+
+  udp_exfiltration:
+    'HAUTE: Socket UDP (dgram) avec envoi de donnees. Exfiltration contournant les firewalls HTTP. ' +
+    'Verifier les destinations IP. Bloquer le trafic UDP sortant non-DNS. Auditer les donnees envoyees.',
+
+  native_addon_install:
+    'HAUTE: binding.gyp avec script lifecycle non-standard. Code natif compile a l\'installation. ' +
+    'Verifier le contenu de binding.gyp et les sources C/C++. Installer avec --ignore-scripts si suspect.',
+
+  string_mutation_obfuscation:
+    'HAUTE: Chaine de .replace() reconstruisant des noms d\'API dangereuses (leet-speak). ' +
+    'Technique d\'evasion par substitution de caracteres. Decoder la chaine finale. Supprimer si malveillant.',
+
+  crontab_systemd_write:
+    'CRITIQUE: Ecriture dans les fichiers cron/crontab. Persistence via tache planifiee. ' +
+    'Verifier /etc/cron*, /var/spool/cron. Supprimer les entrees ajoutees. Auditer crontab -l.',
+
+  isolated_suspicious_file:
+    'Un seul fichier suspect parmi de nombreux fichiers propres. Pattern de dissimulation typique ' +
+    'ou le code malveillant est cache dans un package apparemment legitime. Examiner le fichier suspect en detail.',
+
+  deep_suspicious_file:
+    'Pattern suspect dans un fichier profondement imbrique. Technique pour echapper aux analyses superficielles. ' +
+    'Verifier le contenu du fichier et son role dans l\'arborescence du package.',
+
+  // Blue Team v8b playbooks
+  module_internals_hijack:
+    'CRITIQUE: Assignation a Module._resolveFilename/_compile/_extensions. Detournement du systeme de modules Node.js. ' +
+    'Tous les require() sont interceptes. Supprimer le package immediatement. Auditer tous les modules charges apres installation.',
+
+  json_reviver_pollution:
+    'HAUTE: JSON.parse avec reviver accedant a __proto__/prototype. Pollution de prototype via JSON. ' +
+    'Ne jamais passer de JSON non fiable avec un reviver manipulant __proto__. Verifier les sources de donnees JSON.',
+
+  vm_dynamic_code:
+    'CRITIQUE: vm.runInContext/compileFunction avec code construit dynamiquement. Evasion de sandbox. ' +
+    'Verifier d\'ou provient le code execute. Bloquer l\'acces au module vm. Supprimer si non justifie.',
+
+  callback_exec_rce:
+    'CRITIQUE: exec/spawn dans callback .on(\'message\'|\'data\'). Execution de commandes depuis flux reseau. ' +
+    'Pattern C2: commandes recues par WebSocket/TCP executees via child_process. Supprimer immediatement.',
+
+  stego_binary_exec:
+    'CRITIQUE: Lecture de fichier image/binaire + eval/Function. Payload steganographique. ' +
+    'Verifier le contenu du fichier image. Scanner avec des outils stego. Supprimer le fichier et le code d\'extraction.',
+
+  asynclocal_context_exec:
+    'HAUTE: AsyncLocalStorage + execution dynamique. Code malveillant cache dans un contexte async. ' +
+    'Examiner les callbacks AsyncLocalStorage. Verifier ce qui est stocke et execute dans le store.',
+
+  prototype_chain_constructor:
+    'CRITIQUE: Object.getPrototypeOf(var).constructor stocke dans une variable. Traversee de prototype pour Function. ' +
+    'Technique d\'evasion avancee. Supprimer le code. Verifier si le constructeur est appele avec du code dynamique.',
+
+  ci_environment_probe:
+    'HAUTE: Detection de 3+ fournisseurs CI (GitHub Actions, GitLab CI, etc.) dans le meme fichier. ' +
+    'Sondage d\'environnement CI pour activation conditionnelle. Verifier la logique conditionnelle associee.',
+
+  lifecycle_missing_script:
+    'CRITIQUE: Script lifecycle reference un fichier inexistant dans le package. Script fantome. ' +
+    'Le payload peut etre injecte dynamiquement ou lors d\'une mise a jour. Installer avec --ignore-scripts. Supprimer le package.',
 };
 
 function getPlaybook(threatType) {

package/src/rules/index.js

@@ -1523,7 +1523,7 @@ const RULES = {
     id: 'MUADDIB-SHELL-019',
     name: 'Python Time Delay Execution',
     severity: 'HIGH',
-    confidence: 0.80,
+    confidence: 'medium',
     description: 'Execution Python avec delai time.sleep() >= 100s via child process. Technique d\'evasion sandbox (T1497.003) : le malware attend que la sandbox expire avant d\'executer le payload.',
     references: ['https://attack.mitre.org/techniques/T1497/003/'],
     mitre: 'T1497.003'
@@ -1850,6 +1850,310 @@ const RULES = {
     ],
     mitre: 'T1071'
   },
+
+  // Audit v3 Bypass Detections (AST-062 to AST-069)
+  reflect_apply_require: {
+    id: 'MUADDIB-AST-062',
+    name: 'Reflect.apply(require) Bypass',
+    severity: 'CRITICAL',
+    confidence: 'high',
+    description: 'Reflect.apply(require, null, [module]) detecte — contourne la detection statique de require() en passant par l\'API Reflect. Permet de charger child_process/fs/net sans appel require() direct.',
+    references: [
+      'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/apply',
+      'https://attack.mitre.org/techniques/T1059/'
+    ],
+    mitre: 'T1059'
+  },
+  finalization_registry_exec: {
+    id: 'MUADDIB-AST-063',
+    name: 'FinalizationRegistry Deferred Execution',
+    severity: 'CRITICAL',
+    confidence: 'high',
+    description: 'new FinalizationRegistry() avec callback contenant child_process/exec/spawn. Le callback s\'execute apres le garbage collection, hors du flux d\'execution normal — technique d\'evasion sandbox qui differe l\'execution malveillante.',
+    references: [
+      'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry',
+      'https://attack.mitre.org/techniques/T1497/003/'
+    ],
+    mitre: 'T1497.003'
+  },
+  function_prototype_constructor: {
+    id: 'MUADDIB-AST-064',
+    name: 'Function via Prototype Chain',
+    severity: 'CRITICAL',
+    confidence: 'high',
+    description: '(function(){}).constructor(code) ou [].constructor.constructor(code) detecte — acces au constructeur Function via la chaine de prototypes, contourne les detections de new Function() et eval().',
+    references: [
+      'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function',
+      'https://attack.mitre.org/techniques/T1059/'
+    ],
+    mitre: 'T1059'
+  },
+  prototype_pollution: {
+    id: 'MUADDIB-AST-065',
+    name: 'Prototype Pollution',
+    severity: 'HIGH',
+    confidence: 'high',
+    description: '__defineGetter__, __defineSetter__ ou assignation __proto__ detectee — pollution de prototype permettant de detourner les proprietes heritees de tous les objets. Vecteur d\'escalade pour injecter du code dans des chemins d\'execution inattendus.',
+    references: [
+      'https://portswigger.net/web-security/prototype-pollution',
+      'https://attack.mitre.org/techniques/T1574/'
+    ],
+    mitre: 'T1574'
+  },
+  module_wrap_override: {
+    id: 'MUADDIB-AST-066',
+    name: 'Module.wrap Override',
+    severity: 'CRITICAL',
+    confidence: 'high',
+    description: 'Module.wrap = ... detecte — remplacement de la fonction wrapper du module loader Node.js. Permet d\'injecter du code dans CHAQUE module charge apres le remplacement, technique de persistence systemique.',
+    references: [
+      'https://nodejs.org/api/modules.html',
+      'https://attack.mitre.org/techniques/T1574/006/'
+    ],
+    mitre: 'T1574.006'
+  },
+  symbol_property_hiding: {
+    id: 'MUADDIB-AST-067',
+    name: 'Symbol Property Hiding',
+    severity: 'HIGH',
+    confidence: 'high',
+    description: 'obj[Symbol(...)] = require(module_dangereux) detecte — dissimulation de modules dangereux derriere des proprietes Symbol, invisibles a Object.keys() et JSON.stringify(). Technique anti-forensics.',
+    references: [
+      'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol',
+      'https://attack.mitre.org/techniques/T1564/'
+    ],
+    mitre: 'T1564'
+  },
+  with_body_dangerous: {
+    id: 'MUADDIB-AST-068',
+    name: 'WithStatement Dangerous Body',
+    severity: 'HIGH',
+    confidence: 'high',
+    description: 'with() statement dont le body contient require/exec/spawn/child_process — injection de scope pour obscurcir les appels dangereux. Le with() rend tous les identifiants ambigus, empechant l\'analyse statique de tracer les appels.',
+    references: [
+      'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/with',
+      'https://attack.mitre.org/techniques/T1027/'
+    ],
+    mitre: 'T1027'
+  },
+  require_process_mainmodule: {
+    id: 'MUADDIB-AST-069',
+    name: 'require("process").mainModule Bypass',
+    severity: 'CRITICAL',
+    confidence: 'high',
+    description: 'require("process").mainModule.require() detecte — acces indirect au mainModule via require("process") au lieu de l\'objet global process. Contourne la detection de process.mainModule.require() qui ne surveille que l\'identifiant "process".',
+    references: [
+      'https://nodejs.org/api/process.html',
+      'https://attack.mitre.org/techniques/T1059/'
+    ],
+    mitre: 'T1059'
+  },
+
+  // Blue Team v8 — New detections (AST-070 to AST-077, SHELL-023, SCORE-001/002)
+  shared_memory_ipc: {
+    id: 'MUADDIB-AST-070',
+    name: 'Shared Memory IPC',
+    severity: 'MEDIUM',
+    confidence: 'medium',
+    description: 'SharedArrayBuffer + Worker Thread detectes — canal IPC memoire partagee qui contourne la surveillance des messages inter-threads.',
+    references: [
+      'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer',
+      'https://attack.mitre.org/techniques/T1559/'
+    ],
+    mitre: 'T1559'
+  },
+  websocket_c2: {
+    id: 'MUADDIB-AST-071',
+    name: 'WebSocket C2 Channel',
+    severity: 'HIGH',
+    confidence: 'high',
+    description: 'Connexion WebSocket vers un domaine suspect ou avec execution dynamique — canal C2 bidirectionnel persistant.',
+    references: [
+      'https://attack.mitre.org/techniques/T1071.001/',
+      'https://owasp.org/www-community/attacks/WebSocket_Hijacking'
+    ],
+    mitre: 'T1071.001'
+  },
+  udp_exfiltration: {
+    id: 'MUADDIB-AST-072',
+    name: 'UDP Data Exfiltration',
+    severity: 'HIGH',
+    confidence: 'high',
+    description: 'Module dgram (UDP) avec envoi de donnees — exfiltration via protocole UDP qui contourne les firewalls HTTP.',
+    references: [
+      'https://nodejs.org/api/dgram.html',
+      'https://attack.mitre.org/techniques/T1048.003/'
+    ],
+    mitre: 'T1048.003'
+  },
+  native_addon_install: {
+    id: 'MUADDIB-AST-073',
+    name: 'Native Addon Installation',
+    severity: 'HIGH',
+    confidence: 'medium',
+    description: 'binding.gyp present avec script lifecycle non-standard — compilation native potentiellement malveillante a l\'installation.',
+    references: [
+      'https://nodejs.org/api/addons.html',
+      'https://attack.mitre.org/techniques/T1195.002/'
+    ],
+    mitre: 'T1195.002'
+  },
+  string_mutation_obfuscation: {
+    id: 'MUADDIB-AST-074',
+    name: 'String Mutation Obfuscation',
+    severity: 'HIGH',
+    confidence: 'high',
+    description: 'Chaine de 3+ appels .replace() pour reconstruire des noms d\'API dangereuses — technique leet-speak/substitution pour contourner la detection statique.',
+    references: [
+      'https://attack.mitre.org/techniques/T1027/',
+      'https://attack.mitre.org/techniques/T1140/'
+    ],
+    mitre: 'T1027'
+  },
+  crontab_systemd_write: {
+    id: 'MUADDIB-SHELL-023',
+    name: 'Crontab/Cron Write',
+    severity: 'CRITICAL',
+    confidence: 'high',
+    description: 'Ecriture dans les fichiers cron (/etc/cron*, crontab, /var/spool/cron) — persistence via tache planifiee.',
+    references: [
+      'https://attack.mitre.org/techniques/T1053.003/',
+      'https://attack.mitre.org/techniques/T1543/'
+    ],
+    mitre: 'T1053.003'
+  },
+  isolated_suspicious_file: {
+    id: 'MUADDIB-SCORE-001',
+    name: 'Isolated Suspicious File',
+    severity: 'MEDIUM',
+    confidence: 'medium',
+    description: 'Un seul fichier suspect parmi 10+ fichiers propres — pattern de dissimulation ou le code malveillant est cache dans un package legitime.',
+    references: [
+      'https://attack.mitre.org/techniques/T1036/'
+    ],
+    mitre: 'T1036'
+  },
+  deep_suspicious_file: {
+    id: 'MUADDIB-SCORE-002',
+    name: 'Deeply Nested Suspicious File',
+    severity: 'LOW',
+    confidence: 'low',
+    description: 'Pattern suspect detecte dans un fichier profondement imbrique (profondeur > 3) — technique de dissimulation dans l\'arborescence du package.',
+    references: [
+      'https://attack.mitre.org/techniques/T1036.005/'
+    ],
+    mitre: 'T1036.005'
+  },
+
+  // Blue Team v8b — New detections (AST-075 to AST-082, PKG-017)
+  module_internals_hijack: {
+    id: 'MUADDIB-AST-075',
+    name: 'Module Internals Hijack',
+    severity: 'CRITICAL',
+    confidence: 'high',
+    description: 'Assignation a Module._resolveFilename, _compile ou _extensions — detournement des mecanismes internes du systeme de modules Node.js. Tous les require() subsequents peuvent etre interceptes.',
+    references: [
+      'https://nodejs.org/api/modules.html',
+      'https://attack.mitre.org/techniques/T1574.006/'
+    ],
+    mitre: 'T1574.006'
+  },
+  json_reviver_pollution: {
+    id: 'MUADDIB-AST-076',
+    name: 'JSON Reviver Prototype Pollution',
+    severity: 'HIGH',
+    confidence: 'high',
+    description: 'JSON.parse avec fonction reviver accedant a __proto__ ou prototype — pollution de prototype via donnees JSON non fiables.',
+    references: [
+      'https://portswigger.net/web-security/prototype-pollution',
+      'https://attack.mitre.org/techniques/T1059.007/'
+    ],
+    mitre: 'T1059.007'
+  },
+  vm_dynamic_code: {
+    id: 'MUADDIB-AST-077',
+    name: 'VM Dynamic Code Execution',
+    severity: 'CRITICAL',
+    confidence: 'high',
+    description: 'vm.runInContext/runInNewContext/compileFunction avec code construit dynamiquement — evasion du sandbox via code genere au runtime.',
+    references: [
+      'https://nodejs.org/api/vm.html',
+      'https://attack.mitre.org/techniques/T1059.007/'
+    ],
+    mitre: 'T1059.007'
+  },
+  callback_exec_rce: {
+    id: 'MUADDIB-AST-078',
+    name: 'Callback Remote Code Execution',
+    severity: 'CRITICAL',
+    confidence: 'high',
+    description: 'exec/spawn dans un callback .on(\'message\') ou .on(\'data\') avec child_process — execution de commandes a distance depuis un flux reseau.',
+    references: [
+      'https://attack.mitre.org/techniques/T1059/',
+      'https://attack.mitre.org/techniques/T1071/'
+    ],
+    mitre: 'T1059'
+  },
+  stego_binary_exec: {
+    id: 'MUADDIB-AST-079',
+    name: 'Steganographic Binary Execution',
+    severity: 'CRITICAL',
+    confidence: 'high',
+    description: 'Lecture de fichier binaire/image (PNG, JPG) + execution dynamique (eval/Function) — extraction et execution de payload steganographique.',
+    references: [
+      'https://attack.mitre.org/techniques/T1027.003/',
+      'https://attack.mitre.org/techniques/T1140/'
+    ],
+    mitre: 'T1027.003'
+  },
+  asynclocal_context_exec: {
+    id: 'MUADDIB-AST-080',
+    name: 'AsyncLocalStorage Context Execution',
+    severity: 'HIGH',
+    confidence: 'medium',
+    description: 'AsyncLocalStorage + execution dynamique — code malveillant cache dans un contexte asynchrone, echappe a l\'analyse de pile d\'appels synchrone.',
+    references: [
+      'https://nodejs.org/api/async_context.html',
+      'https://attack.mitre.org/techniques/T1059.007/'
+    ],
+    mitre: 'T1059.007'
+  },
+  prototype_chain_constructor: {
+    id: 'MUADDIB-AST-081',
+    name: 'Prototype Chain Constructor Access',
+    severity: 'CRITICAL',
+    confidence: 'high',
+    description: 'Object.getPrototypeOf(variable).constructor extrait dans une variable — traversee de la chaine de prototypes pour atteindre le constructeur Function et executer du code arbitraire.',
+    references: [
+      'https://attack.mitre.org/techniques/T1059.007/',
+      'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf'
+    ],
+    mitre: 'T1059.007'
+  },
+  ci_environment_probe: {
+    id: 'MUADDIB-AST-082',
+    name: 'CI Environment Fingerprinting',
+    severity: 'HIGH',
+    confidence: 'medium',
+    description: 'References a 3+ variables d\'environnement de fournisseurs CI (GITHUB_ACTIONS, GITLAB_CI, etc.) — sondage d\'environnement CI pour activation conditionnelle de payload.',
+    references: [
+      'https://attack.mitre.org/techniques/T1082/',
+      'https://attack.mitre.org/techniques/T1497/'
+    ],
+    mitre: 'T1082'
+  },
+  lifecycle_missing_script: {
+    id: 'MUADDIB-PKG-017',
+    name: 'Phantom Lifecycle Script',
+    severity: 'CRITICAL',
+    confidence: 'high',
+    description: 'Script lifecycle (preinstall/install) reference un fichier qui n\'existe pas dans le package — script fantome, le payload peut etre injecte au moment de la publication.',
+    references: [
+      'https://attack.mitre.org/techniques/T1195.002/',
+      'https://blog.npmjs.org/post/166316363605/the-lifecycle-script-vulnerability'
+    ],
+    mitre: 'T1195.002'
+  },
 };
 
 function getRule(type) {
@@ -1912,4 +2216,23 @@ for (const [, rule] of Object.entries(PARANOID_RULES)) {
   PARANOID_RULES_BY_ID[rule.id] = rule;
 }
 
+// Validate all rules at load time
+const VALID_SEVERITIES = new Set(['CRITICAL', 'HIGH', 'MEDIUM', 'LOW']);
+const VALID_CONFIDENCES = new Set(['high', 'medium', 'low']);
+
+for (const [key, rule] of Object.entries(RULES)) {
+  if (!VALID_SEVERITIES.has(rule.severity)) {
+    throw new Error(`Rule "${key}" has invalid severity: ${JSON.stringify(rule.severity)} (expected CRITICAL|HIGH|MEDIUM|LOW)`);
+  }
+  if (!VALID_CONFIDENCES.has(rule.confidence)) {
+    throw new Error(`Rule "${key}" has invalid confidence: ${JSON.stringify(rule.confidence)} (expected high|medium|low)`);
+  }
+}
+// PARANOID_RULES use a different schema (patterns/message, no confidence field)
+for (const [key, rule] of Object.entries(PARANOID_RULES)) {
+  if (!VALID_SEVERITIES.has(rule.severity)) {
+    throw new Error(`Paranoid rule "${key}" has invalid severity: ${JSON.stringify(rule.severity)} (expected CRITICAL|HIGH|MEDIUM|LOW)`);
+  }
+}
+
 module.exports = { RULES, getRule, PARANOID_RULES };