icarus-cmd 0.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Icarus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,57 @@
+# Icarus
+
+Plateforme de pentest tout-en-un. Regroupe les meilleurs outils (nmap, nuclei,
+sqlmap, ZAP, ffuf, katana, nikto, dalfox, httpx…) derrière une seule CLI + TUI,
+avec une base de résultats commune, des rapports HTML/JSON, une interface web
+locale et un analyseur de code statique (SAST).
+
+> ⚠️ **Usage strictement autorisé** : uniquement sur tes propres systèmes ou
+> avec un mandat écrit signé. Scanner un tiers sans autorisation est illégal.
+
+## Installation
+
+Pré-requis : **Node.js ≥ 20**.
+
+```bash
+npm install -g icarus-cmd
+icarus setup      # télécharge les binaires Go (nuclei, httpx, ffuf, katana…)
+icarus doctor     # affiche ce qu'il reste à installer (nmap, ZAP, sqlmap…)
+```
+
+`icarus setup` récupère les binaires précompilés depuis les releases GitHub
+(Windows / Linux / macOS, amd64 & arm64). Les outils à runtime (nmap, OWASP ZAP,
+nikto, sqlmap, wafw00f, wpscan, Metasploit) s'installent à part — `icarus doctor`
+donne la commande pour chacun.
+
+## Utilisation
+
+```bash
+icarus                         # TUI interactive
+icarus scan example.com --profile full --timeout 300
+icarus scan http://site/p?id=1 --tools sqlmap,nuclei
+icarus code ./mon-projet       # analyse statique du code (SAST)
+icarus web                     # interface web locale (http://localhost:7373)
+icarus report                  # rapport HTML + JSON
+icarus doctor                  # état des outils
+```
+
+### Options de scan
+
+| Option | Effet |
+|--------|-------|
+| `--profile recon\|web\|vuln\|full` | enchaîne un profil d'outils |
+| `--tools nmap,nuclei,sqlmap` | choisit des outils précis |
+| `--parallel` | lance tous les outils en même temps |
+| `--fast` | mode rapide (sévérités hautes, options légères) |
+| `--timeout 300` | délai max par outil (s) — mets large pour nuclei |
+
+### Analyse de code (SAST)
+
+`icarus code <fichier|dossier>` cherche des motifs de vulnérabilités dans le
+source : secrets en dur, injections (SQL/commande/code), XSS, désérialisation
+non sûre, TLS désactivé, crypto faible… Multi-langage (JS/TS, Python, PHP, Java,
+Go, Ruby…).
+
+## Licence
+
+MIT.

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "icarus-cmd",
+  "version": "0.3.1",
+  "description": "Icarus — plateforme de pentest tout-en-un : nmap, nuclei, sqlmap, ZAP, ffuf, katana & co regroupés. CLI + TUI + interface web locale, analyse de code (SAST), base de résultats commune et rapports.",
+  "type": "module",
+  "bin": {
+    "icarus": "src/index.js"
+  },
+  "files": [
+    "src",
+    "wordlists",
+    "tools/resolvers.txt",
+    "scripts/postinstall.mjs",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node src/index.js",
+    "setup": "node src/index.js setup",
+    "web": "node src/index.js web",
+    "doctor": "node src/index.js doctor",
+    "postinstall": "node scripts/postinstall.mjs || true"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "pentest", "security", "sast", "nuclei", "nmap", "sqlmap",
+    "ffuf", "recon", "vulnerability-scanner", "cli", "infosec"
+  ],
+  "author": "Icarus",
+  "license": "MIT",
+  "dependencies": {
+    "@inquirer/prompts": "^7.2.1",
+    "chalk": "^5.4.1",
+    "cli-table3": "^0.6.5"
+  },
+  "devDependencies": {
+    "pngjs": "^7.0.0"
+  }
+}

package/scripts/postinstall.mjs

@@ -0,0 +1,9 @@
+// Message d'après-installation. AUCUN téléchargement ici (mauvaise pratique +
+// certains outils demandent l'admin) : on guide juste l'utilisateur.
+const c = (s, n) => `\x1b[${n}m${s}\x1b[0m`;
+console.log('');
+console.log('  ' + c('Icarus installé.', '1') + ' Étape suivante :');
+console.log('    ' + c('icarus setup', '33') + '     télécharge nuclei, httpx, ffuf, katana… (binaires)');
+console.log('    ' + c('icarus doctor', '33') + '    voir ce qui reste (nmap, ZAP, sqlmap…)');
+console.log('    ' + c('icarus', '33') + '           lance l\'interface');
+console.log('');

package/src/core/codescan.js

@@ -0,0 +1,121 @@
+// Analyse statique (SAST) légère : parcourt un fichier ou un dossier et applique
+// des règles regex par langage pour repérer des motifs de vulnérabilités
+// classiques (injection, secrets en dur, crypto faible, désérialisation…).
+// Zéro dépendance : chaque règle = { id, severity, exts, re, title }.
+import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { join, extname, basename, relative } from 'node:path';
+
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', 'dist', 'build', 'out', 'vendor', '.next', 'coverage',
+  '__pycache__', '.venv', 'venv', 'target', 'bin', 'obj', '.idea', '.vscode',
+]);
+const TEXT_EXTS = new Set([
+  '.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.py', '.php', '.rb', '.java',
+  '.go', '.cs', '.c', '.cpp', '.h', '.sh', '.bash', '.ps1', '.sql', '.html',
+  '.env', '.yml', '.yaml', '.json', '.xml', '.ini', '.conf', '.cfg', '.txt',
+]);
+const MAX_FILE = 1.5 * 1024 * 1024; // 1.5 Mo
+
+const ANY = null; // règle valable pour toutes extensions
+
+// exts = liste d'extensions ('.js') ou ANY ; re testée ligne par ligne.
+const RULES = [
+  // ---- Secrets / credentials (tous fichiers) ----
+  { id: 'secret-aws-key', severity: 'critical', exts: ANY, title: 'Cle AWS Access Key en dur', re: /\bAKIA[0-9A-Z]{16}\b/ },
+  { id: 'secret-private-key', severity: 'critical', exts: ANY, title: 'Cle privee en dur', re: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----/ },
+  { id: 'secret-generic', severity: 'high', exts: ANY, title: 'Secret/mot de passe en dur', re: /\b(?:api[_-]?key|secret|passwd|password|token|access[_-]?key|client[_-]?secret)\b\s*[:=]\s*['"][^'"\s]{8,}['"]/i },
+  { id: 'secret-bearer', severity: 'high', exts: ANY, title: 'Token Bearer en dur', re: /bearer\s+[a-z0-9._\-]{20,}/i },
+  { id: 'secret-slack', severity: 'high', exts: ANY, title: 'Token Slack en dur', re: /xox[baprs]-[0-9A-Za-z-]{10,}/ },
+
+  // ---- Injection de commande / code ----
+  { id: 'js-eval', severity: 'high', exts: ['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx'], title: 'eval() — execution de code', re: /\beval\s*\(/ },
+  { id: 'js-new-function', severity: 'high', exts: ['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx'], title: 'new Function() — execution dynamique', re: /\bnew\s+Function\s*\(/ },
+  { id: 'js-child-exec', severity: 'high', exts: ['.js', '.mjs', '.cjs', '.ts'], title: 'child_process.exec avec variable — injection cmd', re: /\bexec(?:Sync)?\s*\(\s*[`'"][^`'"]*\$\{|\bexec(?:Sync)?\s*\([^)]*\+/ },
+  { id: 'py-eval-exec', severity: 'high', exts: ['.py'], title: 'eval()/exec() — execution de code', re: /\b(?:eval|exec)\s*\(/ },
+  { id: 'py-os-system', severity: 'high', exts: ['.py'], title: 'os.system() — injection commande', re: /\bos\.system\s*\(/ },
+  { id: 'py-subprocess-shell', severity: 'high', exts: ['.py'], title: 'subprocess shell=True — injection commande', re: /subprocess\.[a-z]+\([^)]*shell\s*=\s*True/ },
+  { id: 'php-cmd', severity: 'high', exts: ['.php'], title: 'system/exec/shell_exec/passthru — injection commande', re: /\b(?:system|exec|shell_exec|passthru|popen|proc_open)\s*\(/ },
+
+  // ---- Injection SQL ----
+  { id: 'sql-concat', severity: 'high', exts: ['.js', '.mjs', '.cjs', '.ts', '.py', '.php', '.java', '.rb', '.cs'], title: 'Requete SQL concatenee — risque SQLi', re: /(?:select|insert|update|delete)\b[^;'"]*['"`]\s*(?:\+|\.|%|\$\{|f")/i },
+  { id: 'php-sql-super', severity: 'high', exts: ['.php'], title: 'Variable $_GET/$_POST dans requete SQL', re: /(?:query|mysqli?_query|->query)\s*\([^)]*\$_(?:GET|POST|REQUEST|COOKIE)/i },
+
+  // ---- XSS ----
+  { id: 'js-innerhtml', severity: 'medium', exts: ['.js', '.ts', '.tsx', '.jsx', '.html'], title: 'innerHTML/outerHTML — risque XSS', re: /\.(?:inner|outer)HTML\s*=/ },
+  { id: 'react-dangerously', severity: 'medium', exts: ['.jsx', '.tsx', '.js', '.ts'], title: 'dangerouslySetInnerHTML — risque XSS', re: /dangerouslySetInnerHTML/ },
+  { id: 'js-doc-write', severity: 'medium', exts: ['.js', '.ts', '.html'], title: 'document.write — risque XSS', re: /document\.write\s*\(/ },
+  { id: 'php-echo-super', severity: 'medium', exts: ['.php'], title: 'echo direct de $_GET/$_POST — XSS', re: /echo\s+[^;]*\$_(?:GET|POST|REQUEST)/i },
+
+  // ---- Deserialisation / parsing dangereux ----
+  { id: 'py-pickle', severity: 'high', exts: ['.py'], title: 'pickle.loads — deserialisation non sure', re: /pickle\.loads?\s*\(/ },
+  { id: 'py-yaml-load', severity: 'high', exts: ['.py'], title: 'yaml.load sans SafeLoader', re: /yaml\.load\s*\((?![^)]*Safe)/ },
+  { id: 'php-unserialize', severity: 'high', exts: ['.php'], title: 'unserialize() — deserialisation non sure', re: /\bunserialize\s*\(/ },
+
+  // ---- TLS / crypto ----
+  { id: 'tls-node-reject', severity: 'high', exts: ['.js', '.mjs', '.cjs', '.ts'], title: 'rejectUnauthorized:false — TLS non verifie', re: /rejectUnauthorized\s*:\s*false/ },
+  { id: 'tls-py-verify', severity: 'high', exts: ['.py'], title: 'verify=False — TLS non verifie', re: /verify\s*=\s*False/ },
+  { id: 'tls-curl-insecure', severity: 'medium', exts: ANY, title: 'curl -k / --insecure — TLS non verifie', re: /curl\s+[^\n]*(?:\s-k\b|--insecure)/ },
+  { id: 'crypto-weak', severity: 'medium', exts: ANY, title: 'Hash faible (MD5/SHA1)', re: /\b(?:md5|sha1)\s*\(/i },
+  { id: 'js-math-random', severity: 'low', exts: ['.js', '.ts'], title: 'Math.random() — non cryptographique', re: /Math\.random\s*\(\)/ },
+
+  // ---- Divers ----
+  { id: 'flask-debug', severity: 'medium', exts: ['.py'], title: 'Flask debug=True — execution de code', re: /\.run\s*\([^)]*debug\s*=\s*True/ },
+  { id: 'cors-wildcard', severity: 'low', exts: ANY, title: 'CORS Access-Control-Allow-Origin: *', re: /Access-Control-Allow-Origin['"\s:]+\*/ },
+];
+
+function listFiles(root) {
+  const out = [];
+  const walk = (p) => {
+    let st;
+    try { st = statSync(p); } catch { return; }
+    if (st.isDirectory()) {
+      if (SKIP_DIRS.has(basename(p))) return;
+      let entries = [];
+      try { entries = readdirSync(p); } catch { return; }
+      for (const e of entries) walk(join(p, e));
+    } else if (st.isFile() && st.size <= MAX_FILE) {
+      const ext = extname(p).toLowerCase();
+      if (TEXT_EXTS.has(ext) || basename(p).startsWith('.env')) out.push(p);
+    }
+  };
+  walk(root);
+  return out;
+}
+
+function scanFile(file, root) {
+  const findings = [];
+  let text;
+  try { text = readFileSync(file, 'utf8'); } catch { return findings; }
+  const ext = extname(file).toLowerCase();
+  const rel = relative(root, file) || basename(file);
+  const lines = text.split(/\r?\n/);
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.length > 1000) continue;
+    for (const rule of RULES) {
+      if (rule.exts !== ANY && !rule.exts.includes(ext)) continue;
+      if (rule.re.test(line)) {
+        findings.push({
+          type: 'code',
+          severity: rule.severity,
+          title: rule.title,
+          detail: `${rel}:${i + 1}  ${line.trim().slice(0, 120)}`,
+          ref: rule.id,
+        });
+      }
+    }
+  }
+  return findings;
+}
+
+// Analyse un fichier ou un dossier. Renvoie { findings, files, root }.
+export function analyzeCode(target) {
+  if (!existsSync(target)) return { error: `Chemin introuvable : ${target}`, findings: [], files: 0 };
+  const st = statSync(target);
+  const files = st.isDirectory() ? listFiles(target) : [target];
+  const root = st.isDirectory() ? target : join(target, '..');
+  const findings = [];
+  for (const f of files) findings.push(...scanFile(f, root));
+  return { findings, files: files.length, root: target };
+}

package/src/core/detect.js

@@ -0,0 +1,64 @@
+// Détection d'un outil : on le cherche dans le PATH (via `where`/`which`),
+// puis dans une liste de chemins d'installation connus (utile sous Windows où
+// nmap/ZAP n'ajoutent pas toujours leur dossier au PATH).
+
+import { existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const cache = new Map();
+
+// Dossier où Icarus installe les binaires précompilés (install-tools.ps1).
+const BUNDLED_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'tools', 'bin');
+
+function whichBin(name) {
+  const finder = process.platform === 'win32' ? 'where' : 'which';
+  try {
+    const out = execFileSync(finder, [name], { stdio: ['ignore', 'pipe', 'ignore'] })
+      .toString()
+      .trim()
+      .split(/\r?\n/)[0];
+    return out && existsSync(out) ? out : (out || null);
+  } catch {
+    return null;
+  }
+}
+
+// Renvoie le chemin résolu du binaire d'un outil, ou null si introuvable.
+export function resolveBin(tool, { fresh = false } = {}) {
+  if (!fresh && cache.has(tool.id)) return cache.get(tool.id);
+
+  const candidates = [];
+  // 1) binaires installés localement par Icarus (tools/bin)
+  for (const b of tool.bins || []) {
+    const local = join(BUNDLED_DIR, b.endsWith('.exe') ? b : `${b}.exe`);
+    if (existsSync(local)) candidates.push(local);
+  }
+  // 2) chemins d'installation Windows connus
+  for (const p of tool.winPaths || []) {
+    if (existsSync(p)) candidates.push(p);
+  }
+  // 3) PATH
+  for (const b of tool.bins || []) {
+    const r = whichBin(b);
+    if (r) candidates.push(r);
+  }
+
+  // Certains outils partagent un nom de binaire avec un autre logiciel
+  // (ex: le scanner httpx de ProjectDiscovery vs la lib Python httpx).
+  // tool.verify(bin) permet d'écarter le mauvais.
+  let found = null;
+  for (const c of candidates) {
+    if (typeof tool.verify === 'function' && !tool.verify(c)) continue;
+    found = c;
+    break;
+  }
+
+  cache.set(tool.id, found);
+  return found;
+}
+
+export function clearCache() {
+  cache.clear();
+}

package/src/core/registry.js

@@ -0,0 +1,52 @@
+// Registre central des outils. Pour ajouter un outil : créer src/tools/xxx.js,
+// l'importer ici et l'ajouter à TOOLS. Tout le reste (TUI, scans, rapports,
+// profils) le prend en compte automatiquement.
+
+import { resolveBin } from './detect.js';
+
+import nmap from '../tools/nmap.js';
+import naabu from '../tools/naabu.js';
+import subfinder from '../tools/subfinder.js';
+import httpx from '../tools/httpx.js';
+import katana from '../tools/katana.js';
+import whatweb from '../tools/whatweb.js';
+import wafw00f from '../tools/wafw00f.js';
+import nuclei from '../tools/nuclei.js';
+import ffuf from '../tools/ffuf.js';
+import gobuster from '../tools/gobuster.js';
+import nikto from '../tools/nikto.js';
+import sqlmap from '../tools/sqlmap.js';
+import dalfox from '../tools/dalfox.js';
+import wpscan from '../tools/wpscan.js';
+import zap from '../tools/zap.js';
+import metasploit from '../tools/metasploit.js';
+
+export const TOOLS = [
+  nmap, naabu, subfinder, httpx, katana, whatweb, wafw00f,  // recon
+  nuclei, metasploit,                                       // vuln
+  ffuf, gobuster, nikto, sqlmap, dalfox, wpscan, zap,       // web
+];
+
+// Profils = enchaînements d'outils par objectif. Le profil ne lance que les
+// outils réellement installés (les autres sont ignorés silencieusement).
+export const PROFILES = {
+  recon: { label: 'Reconnaissance', tools: ['nmap', 'naabu', 'subfinder', 'httpx', 'katana', 'whatweb', 'wafw00f'] },
+  web: { label: 'Application web', tools: ['httpx', 'whatweb', 'katana', 'ffuf', 'gobuster', 'nikto', 'sqlmap', 'dalfox', 'wpscan', 'zap'] },
+  vuln: { label: 'Vulnérabilités', tools: ['nuclei', 'nikto', 'sqlmap', 'dalfox', 'metasploit'] },
+  full: { label: 'Complet (tout)', tools: TOOLS.map((t) => t.id) },
+};
+
+export function getTool(id) {
+  return TOOLS.find((t) => t.id === id) || null;
+}
+
+export function toolStatus({ fresh = false } = {}) {
+  return TOOLS.map((t) => {
+    const bin = resolveBin(t, { fresh });
+    return { tool: t, bin, available: Boolean(bin) };
+  });
+}
+
+export function availableIds() {
+  return toolStatus().filter((s) => s.available).map((s) => s.tool.id);
+}

package/src/core/resolvers.js

@@ -0,0 +1,53 @@
+// Résolveurs DNS imposés aux outils ProjectDiscovery (nuclei, httpx, katana,
+// subfinder). Leur résolveur Go interne échoue souvent ("no address found for
+// host"), surtout sous VPN (Mullvad force son propre DNS et bloque les autres) :
+// du coup l'appli trouve 0 vuln alors que tout marche par ailleurs.
+//
+// On génère donc un fichier -resolvers à partir du DNS SYSTÈME ACTIF
+// (dns.getServers() — le primaire en tête, c'est celui que l'OS utilise et qui
+// marche). Deux pièges Windows gérés ici :
+//   1) nuclie ne lit le fichier qu'en fins de ligne CRLF ;
+//   2) son chemin ne doit pas contenir d'espaces (le projet vit dans
+//      "…/pentest tool/…") -> on écrit dans tmp/home.
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir, homedir } from 'node:os';
+import { getServers } from 'node:dns';
+
+const BUNDLED = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'tools', 'resolvers.txt');
+
+function pickPath() {
+  for (const base of [tmpdir(), homedir()]) {
+    if (base && !/\s/.test(base)) return join(base, '.icarus-resolvers.txt');
+  }
+  return '';
+}
+
+function buildList() {
+  const out = [];
+  try {
+    for (const s of getServers()) {
+      const ip = String(s).replace(/%.*$/, '').replace(/^\[|\]$/g, '');
+      if (/^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) out.push(ip); // IPv4 seulement
+    }
+  } catch { /* ignore */ }
+  // Le primaire SEUL : c'est le DNS que l'OS utilise (donc joignable même sous
+  // VPN), et ça évite que nuclei pioche un DNS secondaire bloqué par le VPN.
+  if (out.length) return out.slice(0, 1);
+  // Secours : liste statique fournie avec le projet.
+  try { return readFileSync(BUNDLED, 'utf8').split(/\r?\n/).map((l) => l.trim()).filter(Boolean); }
+  catch { return []; }
+}
+
+let resolved = '';
+try {
+  const dst = pickPath();
+  const list = buildList();
+  if (dst && list.length) {
+    writeFileSync(dst, list.join('\r\n') + '\r\n'); // CRLF obligatoire pour nuclei
+    resolved = dst;
+  }
+} catch { resolved = ''; }
+
+export const RESOLVERS_FILE = resolved;

package/src/core/runner.js

@@ -0,0 +1,94 @@
+// Lance un outil, streame sa sortie en direct dans le terminal, capture tout,
+// puis délègue au parser de l'outil pour produire des findings normalisés.
+
+import { spawn } from 'node:child_process';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { resolveBin } from './detect.js';
+import { recordScan, addFindings } from './store.js';
+
+// Exécute un binaire et renvoie { code, stdout, stderr, timedOut }.
+// timeoutMs > 0 : tue le process s'il dépasse le délai.
+export function runProcess(cmd, args, { onData, cwd, env, timeoutMs = 0, shell = false } = {}) {
+  return new Promise((resolve) => {
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    let timer;
+    let child;
+    try {
+      child = spawn(cmd, args, { cwd, env: { ...process.env, ...env }, shell });
+    } catch (err) {
+      resolve({ code: -1, stdout, stderr: err.message, error: err });
+      return;
+    }
+    if (timeoutMs > 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        onData?.(`\n[icarus] ⏱ timeout ${Math.round(timeoutMs / 1000)}s — process arrêté\n`, 'err');
+        child.kill('SIGKILL');
+      }, timeoutMs);
+    }
+    child.stdout.on('data', (d) => { const s = d.toString(); stdout += s; onData?.(s, 'out'); });
+    child.stderr.on('data', (d) => { const s = d.toString(); stderr += s; onData?.(s, 'err'); });
+    child.on('error', (err) => { clearTimeout(timer); resolve({ code: -1, stdout, stderr: `${stderr}\n${err.message}`, error: err, timedOut }); });
+    child.on('close', (code) => { clearTimeout(timer); resolve({ code, stdout, stderr, timedOut }); });
+  });
+}
+
+// Orchestration d'un outil de bout en bout : détection -> commande -> run ->
+// parse -> stockage. Renvoie { ok, findings, code, error }.
+export async function runTool(tool, target, { opts = {}, onData, onLog } = {}) {
+  const log = onLog || (() => {});
+  const bin = resolveBin(tool);
+  if (!bin) {
+    return { ok: false, findings: [], code: -1, error: `${tool.name} introuvable. Installe-le : ${tool.install}` };
+  }
+
+  let workdir;
+  if (tool.needsWorkdir) workdir = mkdtempSync(join(tmpdir(), `pentesthub-${tool.id}-`));
+
+  const built = tool.command(target, { ...opts, bin, workdir });
+  let cmd = built.cmd || bin;
+  let args = built.args || [];
+  let shell = false;
+
+  // Sous Windows, Node ≥20 refuse de spawn directement un .bat/.cmd
+  // (EINVAL, correctif CVE-2024-27980). On reconstruit une ligne de commande
+  // correctement quotée et on laisse cmd.exe l'exécuter via shell:true.
+  // Les outils qui définissent déjà built.cmd (ex. metasploit via `cmd /c`)
+  // gèrent leur propre invocation et ne sont pas touchés.
+  if (process.platform === 'win32' && !built.cmd && /\.(bat|cmd)$/i.test(cmd)) {
+    const q = (s) => (/[\s"&()[\]{}^=;!'+,`~%<>|]/.test(String(s))
+      ? `"${String(s).replace(/"/g, '""')}"`
+      : String(s));
+    cmd = [cmd, ...args].map(q).join(' ');
+    args = [];
+    shell = true;
+  }
+
+  // Certains lanceurs (ZAP zap.bat) chargent leurs fichiers via des chemins
+  // relatifs et doivent donc s'exécuter depuis leur dossier d'installation.
+  // Un outil peut imposer son répertoire de travail via built.cwd.
+  const runCwd = built.cwd || workdir;
+
+  const timeoutMs = Number(opts.timeout) > 0 ? Number(opts.timeout) * 1000 : 0;
+  log(`$ ${cmd} ${args.join(' ')}${timeoutMs ? `   (timeout ${opts.timeout}s)` : ''}`);
+  const result = await runProcess(cmd, args, { onData, cwd: runCwd, timeoutMs, shell });
+
+  const scanId = recordScan({ tool: tool.id, target, code: result.code, command: `${cmd} ${args.join(' ')}` });
+
+  let parsed = [];
+  try {
+    parsed = (await tool.parse({ ...result, target, workdir, opts })) || [];
+  } catch (err) {
+    log(`(parser ${tool.id} a échoué: ${err.message})`);
+  }
+
+  const findings = addFindings(
+    parsed.map((f) => ({ scanId, tool: tool.id, target, ...f }))
+  );
+
+  return { ok: result.code === 0 || findings.length > 0, findings, code: result.code, error: result.error };
+}

package/src/core/setup.js

@@ -0,0 +1,102 @@
+// `icarus setup` — télécharge les binaires précompilés (releases GitHub) des
+// outils Go et les place dans tools/bin. Cross-platform (Windows/Linux/macOS) :
+// détecte OS+arch, choisit le bon asset, extrait via `tar` (présent par défaut
+// sur Win10+, Linux, macOS). Les outils à runtime (nmap, ZAP, Metasploit,
+// nikto, wpscan…) ne sont pas gérés ici : `icarus doctor` indique comment.
+import { mkdtempSync, mkdirSync, existsSync, copyFileSync, readdirSync, createWriteStream, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execFileSync } from 'node:child_process';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+
+const BIN_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'tools', 'bin');
+
+const TOOLS = [
+  { id: 'nuclei', repo: 'projectdiscovery/nuclei' },
+  { id: 'httpx', repo: 'projectdiscovery/httpx' },
+  { id: 'naabu', repo: 'projectdiscovery/naabu' },
+  { id: 'katana', repo: 'projectdiscovery/katana' },
+  { id: 'subfinder', repo: 'projectdiscovery/subfinder' },
+  { id: 'ffuf', repo: 'ffuf/ffuf' },
+  { id: 'gobuster', repo: 'OJ/gobuster' },
+  { id: 'dalfox', repo: 'hahwul/dalfox' },
+];
+
+function osKeys() {
+  const p = process.platform;
+  const a = process.arch;
+  const os = p === 'win32' ? /(?:windows|win)/i : p === 'darwin' ? /(?:darwin|macos|mac|apple)/i : /linux/i;
+  const arch = a === 'arm64' ? /(?:arm64|aarch64)/i : /(?:amd64|x86_64|x64)/i;
+  const ext = p === 'win32' ? '.exe' : '';
+  return { os, arch, ext, notArm: a !== 'arm64' };
+}
+
+async function ghJson(url) {
+  const res = await fetch(url, { headers: { 'User-Agent': 'IcarusSetup', Accept: 'application/vnd.github+json' } });
+  if (!res.ok) throw new Error(`GitHub API ${res.status}`);
+  return res.json();
+}
+
+async function download(url, dest) {
+  const res = await fetch(url, { headers: { 'User-Agent': 'IcarusSetup' } });
+  if (!res.ok || !res.body) throw new Error(`HTTP ${res.status}`);
+  await pipeline(Readable.fromWeb(res.body), createWriteStream(dest));
+}
+
+// Installe un outil. Renvoie true/false. log(msg) pour le suivi.
+async function installTool(t, keys, tmp, log) {
+  const rel = await ghJson(`https://api.github.com/repos/${t.repo}/releases/latest`);
+  const asset = (rel.assets || []).find((x) =>
+    keys.os.test(x.name) && keys.arch.test(x.name) &&
+    !(keys.notArm && /arm/i.test(x.name) && !/x86_64|amd64|x64/i.test(x.name)) &&
+    /\.(zip|tar\.gz|tgz)$/i.test(x.name));
+  if (!asset) throw new Error('aucun binaire pour cet OS/arch');
+
+  const archive = join(tmp, asset.name);
+  await download(asset.browser_download_url, archive);
+  const ex = join(tmp, t.id);
+  mkdirSync(ex, { recursive: true });
+  execFileSync('tar', ['-xf', archive, '-C', ex], { stdio: 'ignore' });
+
+  const exeName = t.id + keys.ext;
+  const found = (function find(dir) {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      const p = join(dir, e.name);
+      if (e.isDirectory()) { const r = find(p); if (r) return r; }
+      else if (e.name.toLowerCase() === exeName.toLowerCase()) return p;
+    }
+    return null;
+  })(ex);
+  if (!found) throw new Error(`${exeName} introuvable dans l'archive`);
+  copyFileSync(found, join(BIN_DIR, exeName));
+  return asset.name;
+}
+
+export async function setupTools({ log = console.log } = {}) {
+  mkdirSync(BIN_DIR, { recursive: true });
+  const keys = osKeys();
+  const tmp = mkdtempSync(join(tmpdir(), 'icarus-setup-'));
+  const ok = [];
+  const fail = [];
+
+  log(`\n  Icarus setup — ${process.platform}/${process.arch}  →  ${BIN_DIR}\n`);
+  for (const t of TOOLS) {
+    try {
+      const name = await installTool(t, keys, tmp, log);
+      log(`  ✓ ${t.id.padEnd(10)} ${name}`);
+      ok.push(t.id);
+    } catch (e) {
+      log(`  ✗ ${t.id.padEnd(10)} ${e.message}`);
+      fail.push(t.id);
+    }
+  }
+  try { rmSync(tmp, { recursive: true, force: true }); } catch { /* ignore */ }
+
+  log(`\n  Installés (${ok.length}) : ${ok.join(', ') || '-'}`);
+  if (fail.length) log(`  Échecs    (${fail.length}) : ${fail.join(', ')}`);
+  log(`\n  Reste à installer manuellement (voir « icarus doctor ») :`);
+  log(`   nmap, OWASP ZAP, nikto, sqlmap, wafw00f, wpscan, Metasploit.\n`);
+  return { ok, fail };
+}

package/src/core/severity.js

@@ -0,0 +1,35 @@
+// Modèle de sévérité partagé par tous les outils, pour normaliser des sorties
+// très hétérogènes (nuclei dit "high", ZAP dit "3", etc.) en une seule échelle.
+
+export const SEVERITIES = ['critical', 'high', 'medium', 'low', 'info', 'unknown'];
+
+// Plus le rang est petit, plus c'est grave (utile pour trier).
+export function rank(sev) {
+  const i = SEVERITIES.indexOf(String(sev || 'unknown').toLowerCase());
+  return i < 0 ? SEVERITIES.length : i;
+}
+
+// Normalise n'importe quelle étiquette de sévérité vers notre échelle.
+export function normalize(sev) {
+  const s = String(sev || '').toLowerCase().trim();
+  if (['critical', 'crit', '4'].includes(s)) return 'critical';
+  if (['high', 'haute', '3'].includes(s)) return 'high';
+  if (['medium', 'moyenne', 'moderate', '2'].includes(s)) return 'medium';
+  if (['low', 'basse', 'minor', '1'].includes(s)) return 'low';
+  if (['info', 'informational', 'information', '0'].includes(s)) return 'info';
+  return 'unknown';
+}
+
+const COLORS = {
+  critical: (c, t) => c.bgRed.white.bold(` ${t} `),
+  high: (c, t) => c.red.bold(t),
+  medium: (c, t) => c.yellow(t),
+  low: (c, t) => c.cyan(t),
+  info: (c, t) => c.gray(t),
+  unknown: (c, t) => c.gray(t),
+};
+
+export function paint(chalk, sev, text = sev) {
+  const fn = COLORS[normalize(sev)] || COLORS.unknown;
+  return fn(chalk, text);
+}