@ksl101/vulnreaper 0.0.0-stage → 0.1.0-beta.1

package/LICENSE

@@ -0,0 +1,107 @@
+VulnReaper — CONTRAT DE LICENCE UTILISATEUR FINAL (EULA)
+Version du contrat : 0.1.0-beta.0
+Copyright (c) 2026 KSL101. Tous droits réservés.
+
+En installant, en activant ou en utilisant le logiciel VulnReaper (le « Logiciel »),
+vous (l'« Utilisateur ») acceptez les termes du présent contrat. Si vous n'acceptez
+pas ces termes, n'installez pas, n'activez pas et n'utilisez pas le Logiciel.
+
+1. DÉFINITIONS
+   1.1 « Logiciel » : le cœur d'analyse, la CLI, le lanceur npm `@ksl101/vulnreaper`
+       (commandes `vulnreaper` et `vr`), les binaires, les règles et la documentation
+       associés, distribués sous quelque forme que ce soit.
+   1.2 « Clé de licence » : le jeton nominatif fourni par l'Éditeur permettant
+       d'activer le Logiciel.
+   1.3 « Serveur de licence » : le service d'authentification et d'autorisation
+       utilisé pour l'activation et le contrôle des permissions.
+   1.4 « Éditeur » : KSL101, titulaire des droits sur le Logiciel.
+
+2. OCTROI DE LICENCE
+   2.1 Sous réserve du paiement éventuel et du respect du présent contrat, l'Éditeur
+       accorde à l'Utilisateur une licence nominative, non exclusive, non cessible et
+       non transférable d'utiliser le Logiciel, dans la limite du nombre d'appareils
+       autorisés pour sa Clé de licence.
+   2.2 La Clé de licence est stricto personnelle. Elle ne peut être partagée,
+       revendue, louée, prêtée ni publiée.
+   2.3 Le Logiciel est concédé sous licence, non vendu. L'Éditeur conserve tous les
+       droits, titres et intérêts non expressément accordés.
+
+3. ACTIVATION, APPAREIL ET SESSION
+   3.1 L'activation associe la Clé de licence à un ou plusieurs appareils. Un
+       identifiant d'appareil technique peut être généré et transmis au Serveur de
+       licence aux seules fins d'activation, de contrôle des permissions et de
+       sécurité.
+   3.2 Les jetons de session sont stockés localement et uniquement pour maintenir
+       l'authentification. La Clé de licence en clair n'est pas conservée par le
+       Logiciel après échange contre des jetons.
+   3.3 L'Utilisateur s'engage à ne pas dissimuler, falsifier ni manipuler
+       l'identité d'appareil afin de contourner la limite d'appareils.
+
+4. RESTRICTIONS
+   Sauf autorisation écrite préalable de l'Éditeur, l'Utilisateur ne peut pas :
+   4.1 copier, distribuer, publier, mettre à disposition ou revendre le Logiciel ou
+       une partie de celui-ci, y compris sous forme compilée ou reconditionnée ;
+   4.2 contourner, désactiver, neutraliser ou altérer le mécanisme de licence,
+       d'activation, d'authentification ou de contrôle des permissions, ni retirer
+       les mentions de copyright ou de propriété ;
+   4.3 rétro-concevoir, décompiler ou désassembler le Logiciel, sauf dans la mesure
+       strictement permise par une disposition légale impérative ;
+   4.4 modifier, traduire ou créer des œuvres dérivées du Logiciel ;
+   4.5 utiliser le Logiciel pour développer un produit concurrent.
+
+5. UTILISATION AUTORISÉE — OBLIGATION LÉGALE
+   5.1 Le Logiciel est un outil d'audit de sécurité destiné aux professionnels.
+       L'Utilisateur s'engage à ne l'utiliser que sur des cibles (applications,
+       paquets, systèmes) pour lesquelles il dispose d'une autorisation explicite,
+       ou dans le cadre d'un programme de bug-bounty l'y habilitant.
+   5.2 Toute utilisation contre des systèmes tiers sans autorisation est
+       strictement interdite et relève de la seule responsabilité de l'Utilisateur.
+   5.3 L'Utilisateur demeure seul responsable du respect des lois et règlements
+       applicables dans sa juridiction.
+
+6. STATUT BÊTA — ABSENCE DE GARANTIE
+   6.1 Le Logiciel est fourni « EN L'ÉTAT » et « SELON DISPONIBILITÉ », en version
+       bêta, sans garantie d'aucune sorte, expresse ou implicite, y compris, sans
+       limitation, les garanties de qualité marchande, d'adéquation à un usage
+       particulier et d'absence de contrefaçon.
+   6.2 L'Éditeur ne garantit pas que le Logiciel sera exempt d'erreurs, ni que son
+       fonctionnement sera ininterrompu, ni qu'il détectera l'intégralité des
+       vulnérabilités d'une cible donnée.
+
+7. LIMITATION DE RESPONSABILITÉ
+   7.1 Dans toute la mesure permise par la loi, l'Éditeur ne saurait être tenu
+       responsable de tout dommage indirect, accessoire, spécial, consécutif ou
+       punitif, ni de toute perte de données, de revenus ou d'exploitation,
+       résultant de l'utilisation ou de l'impossibilité d'utiliser le Logiciel.
+   7.2 La responsabilité globale de l'Éditeur, toutes causes confondues, est
+       limitée au montant effectivement payé par l'Utilisateur pour la licence au
+       cours des douze (12) mois précédant le fait générateur.
+
+8. DONNÉES TECHNIQUES
+   8.1 Le Logiciel peut transmettre au Serveur de licence des données strictement
+       nécessaires à l'activation, au contrôle des permissions, à la sécurité et à
+       l'audit des accès. Aucune cible analysée, aucun code d'application et aucun
+       résultat de scan ne sont transmis automatiquement.
+   8.2 Les données techniques sont traitées conformément à la réglementation
+       applicable en matière de protection des données personnelles.
+
+9. DURÉE ET RÉSILIATION
+   9.1 Le présent contrat prend effet à la première utilisation et demeure en
+       vigueur jusqu'à résiliation.
+   9.2 L'Éditeur peut suspendre ou révoquer la Clé de licence, ainsi que l'accès au
+       Serveur de licence, en cas de violation du présent contrat.
+   9.3 En cas de résiliation, l'Utilisateur doit cesser toute utilisation et
+       supprimer les copies du Logiciel en sa possession.
+
+10. DROIT APPLICABLE
+   10.1 Le présent contrat est régi par le droit applicable au siège de l'Éditeur,
+       sans préjudice des règles impératives protégeant les consommateurs.
+   10.2 Tout litige relève de la compétence exclusive des tribunaux de ce ressort.
+
+11. CONTACT
+   Pour toute question relative aux licences, à l'activation ou au présent contrat,
+   contactez l'Éditeur via les canaux officiels du projet.
+
+---
+Le présent document constitue l'intégralité de l'accord entre les parties
+relativement à son objet et prévaut sur tout accord antérieur.

package/README.md

@@ -1,3 +1,200 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# VulnReaper — Plateforme d'analyse statique pour la sécurité Android
+
+**VulnReaper** est une plateforme d'analyse statique **offline-first** destinée au
+bug-bounty et à la recherche sécurité sur les **jeux Android** (APK natifs,
+Unity et IL2CPP). Elle tourne en **pur Python** (bibliothèque standard
+uniquement), sans dépendance runtime, et est **conçue pour Windows en priorité**,
+tout en restant compatible POSIX.
+
+Elle transforme un APK en un rapport exploitable : surface d'attaque
+(manifest), chaînes et secrets, endpoints/hosts, bibliothèques natives et
+métadonnées IL2CPP — le tout corrélé par un moteur de règles JSON.
+
+---
+
+## Points clés
+
+- **Aucune dépendance runtime** : uniquement la bibliothèque standard.
+- **Jamais de résultats fabriqués** : un outil externe absent est marqué
+  `missing` et l'étape correspondante est `skipped`, jamais simulée.
+- **Windows-first** : encodage UTF-8, couleurs ANSI (VT), gestion des chemins et
+  des sous-processus adaptée à Windows.
+- **Analyses natives sans décompilateur** : parseurs intégrés DEX, AXML
+  (manifest compilé), ELF et `global-metadata.dat` (IL2CPP v24–v31).
+- **Rapports** JSON, Markdown et HTML prêts à joindre à un rapport de bug bounty.
+
+---
+
+## Installation
+
+### Bêta publique (npm)
+
+```sh
+npm install -g @ksl101/vulnreaper@beta
+vr version
+```
+
+Prérequis : Node.js ≥ 18 et Python ≥ 3.10 (le paquet embarque le cœur Python
+complet, exécuté par le lanceur `vr` / `vulnreaper`).
+
+VulnReaper est sous licence nominative : activez votre clé avec
+`vr login --key VR-...`, puis consultez `vr whoami`. Les commandes `scan` et
+`report` exigent une permission (`scan.run`, `report.export`) ; les permissions
+`recon.run` et `audit.run` sont réservées aux futures commandes `recon`/`audit`.
+Voir **[docs/BETA_TESTERS.md](docs/BETA_TESTERS.md)** pour le guide complet des
+testeurs.
+
+### Depuis les sources
+
+Aucune installation n'est requise pour utiliser VulnReaper depuis les sources.
+
+```bat
+:: Windows (invité de commandes)
+vulnreaper.bat doctor
+vulnreaper.bat scan C:\path\to\game.apk --profile apk-static
+```
+
+```sh
+# Git Bash / Linux / macOS
+./vulnreaper.sh doctor
+./vulnreaper.sh scan /path/to/game.apk --profile apk-static
+```
+
+Ou directement via Python (à la racine du dépôt) :
+
+```bat
+python -m vulnreaper doctor
+python -m vulnreaper scan C:\path\to\game.apk
+```
+
+Installation optionnelle comme commande globale :
+
+```sh
+pip install -e .
+vulnreaper --version
+```
+
+---
+
+## Commandes
+
+| Commande | Description |
+| --- | --- |
+| `vulnreaper doctor` | Diagnostic de l'environnement et des outils externes |
+| `vulnreaper version` | Affiche la version |
+| `vulnreaper profiles` | Liste les profils de scan |
+| `vulnreaper rules [--json]` | Liste les règles chargées |
+| `vulnreaper tools [--missing\|--available] [--json]` | Inspecte les outils externes |
+| `vulnreaper project create\|list\|show\|delete <nom>` | Gère les projets/workspaces |
+| `vulnreaper scan <apk> [--profile P] [--project N] [--json]` | Lance un scan |
+| `vulnreaper runs [--project N]` | Liste les runs |
+| `vulnreaper findings [--run ID] [--severity S]` | Affiche les findings |
+| `vulnreaper report --run ID` | Chemin des rapports générés |
+| `vulnreaper config show\|init` | Affiche / initialise la configuration |
+| `vulnreaper login --key <VR-…> [--base-url URL]` | Active une licence et ouvre une session |
+| `vulnreaper logout` | Ferme la session locale |
+| `vulnreaper whoami [--json]` | Affiche licence, rôle, statut, permissions |
+| `vulnreaper admin license\|device\|audit …` | Administration des licences/appareils (rôle `admin`) |
+| `vulnreaper ui` | Shell interactif (REPL conversationnel) |
+
+Sans commande, `vulnreaper` ouvre le shell interactif (`ui`).
+
+---
+
+## Profils de scan
+
+| Profil | Usage |
+| --- | --- |
+| `apk-static` *(défaut)* | Analyse statique complète : import, extraction, manifest, dex, natif, Unity, IL2CPP, assets, endpoints, scanners, rapport |
+| `quick` | Version rapide sans extraction ni décompilation |
+| `android-full` | Ajoute apktool, Il2CppDumper et jadx quand ils sont présents |
+| `il2cpp` | Orienté Unity/IL2CPP |
+| `recon` | Reconnaissance endpoints/hosts uniquement |
+| `device` | Énumération des appareils adb |
+| `report-only` | Régénère un rapport à partir de données existantes |
+
+Lister les profils : `vulnreaper profiles`.
+
+---
+
+## Outils externes (optionnels)
+
+VulnReaper fonctionne sans eux ; s'ils sont présents, il en tire parti :
+
+| Outil | Rôle |
+| --- | --- |
+| `adb` | Énumération d'appareils / interaction device |
+| `apktool` | Décodage des ressources |
+| `jadx` | Décompilation Java |
+| `apksigner` | Vérification de signature |
+| `aapt` | Inspection d'APK |
+| `frida` | Instrumentation dynamique |
+| `il2cppdumper` | Dump IL2CPP (`.cs` reconstruits) |
+| `cpp2il` | Reconstruction IL2CPP alternative |
+| `ghidra` | Analyse native avancée |
+
+Statut : `vulnreaper tools`. Chemins explicites et répertoires de recherche se
+définissent dans la configuration (`vulnreaper config show`).
+
+---
+
+## Structure du dépôt
+
+```
+vulnreaper/                 paquet principal
+  cli/                  point d'entrée, shell interactif (REPL), thème + composants
+  formats/              parseurs strings, AXML, DEX, ELF, métadonnées IL2CPP
+  android/              import APK, modèle manifest, analyse dex/natif, adb
+  unity/ il2cpp/        détection moteur + adaptateurs de dump
+  web/                  découverte et classification d'endpoints
+  scanners/             moteur de règles + scanners (secrets, crypto, réseau, natif)
+  findings/             modèle Finding + rapports JSON/MD/HTML
+  rules/                packs de règles JSON
+  config.py workspace.py database.py project.py pipeline.py engine.py tools.py
+tests/                  suite pytest + fixtures synthétiques + smoke end-to-end
+docs/                   architecture, règles, utilisation
+```
+
+---
+
+## Tests
+
+```bat
+python -m pytest tests/ -q      :: cœur Python + UI (164 tests)
+python tests/smoke.py           :: scan end-to-end d'un APK synthétique
+cd server && npm test           :: API de licence (11 tests, store mémoire)
+cd server && VULNREAPER_E2E=1 npm test   :: + E2E CLI ↔ API
+```
+
+Le smoke construit un APK structurellement valide (manifest AXML compilé, DEX,
+`.so` natif, `global-metadata.dat`) dans un dossier temporaire, exécute le profil
+`quick` et vérifie que le run se termine, écrit les 3 formats de rapport et
+produit findings et endpoints.
+
+Le test E2E inter-stack pilote réellement la CLI contre l'API de licence
+(activation, `whoami`, gating, révocation). Détail de la couverture et
+prérequis : **[docs/TESTING.md](docs/TESTING.md)**.
+
+---
+
+## Documentation
+
+- [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) — conception et flux de données
+- [`docs/USAGE.md`](docs/USAGE.md) — prise en main et workflow bug-bounty
+- [`docs/UI.md`](docs/UI.md) — interface CLI/REPL (thème, composants, raccourcis)
+- [`docs/RULES.md`](docs/RULES.md) — packs de règles et écriture de règles
+- [`docs/BETA_TESTERS.md`](docs/BETA_TESTERS.md) — guide des testeurs bêta (npm, licence, gating)
+- [`docs/TESTING.md`](docs/TESTING.md) — stratégie et couverture des tests
+
+---
+
+## Licence et usage
+
+> Distribution sous licence nominative propriétaire. L'utilisation du logiciel
+> vaut acceptation du [contrat de licence utilisateur final (EULA)](LICENSE).
+> Le guide d'activation et le détail des permissions se trouvent dans
+> [docs/BETA_TESTERS.md](docs/BETA_TESTERS.md).
+
+Outil destiné aux professionnels autorisés. Ne scannez que des applications que
+vous êtes autorisé à tester (vos propres cibles, programmes de bug bounty, ou
+cibles explicitement autorisées).

package/bin/vulnreaper.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * VulnReaper launcher shim.
+ *
+ * This thin, auditable entry point only forwards arguments to the VulnReaper
+ * core (native binary or Python).  It intentionally performs NO security
+ * decision: all authorisation lives server-side.
+ */
+require('../lib/cli.js').run(process.argv.slice(2));

package/lib/cli.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { spawn } = require('node:child_process');
+const { resolveCore } = require('./resolve-core.js');
+
+function run(argv) {
+  let core;
+  try {
+    core = resolveCore();
+  } catch (err) {
+    process.stderr.write(String((err && err.message) || err) + '\n');
+    process.exitCode = 127;
+    return;
+  }
+
+  const child = spawn(core.command, core.args.concat(argv), {
+    stdio: 'inherit',
+    env: core.env,
+    windowsHide: false,
+  });
+
+  child.on('error', (err) => {
+    process.stderr.write('Failed to start the VulnReaper core: ' + err.message + '\n');
+    process.exitCode = 127;
+  });
+
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exitCode = code === null ? 1 : code;
+  });
+}
+
+module.exports = { run };

package/lib/resolve-core.js

@@ -0,0 +1,109 @@
+'use strict';
+
+/*
+ * Resolve the VulnReaper core executable/runner.
+ *
+ * Resolution order:
+ *   1. VULNREAPER_CORE override (explicit path).
+ *   2. Vendored native binary  (vendor/bin/<platform>-<arch>/VulnReaper[.exe]).
+ *   3. Platform optional-dependency package (@ksl101/vulnreaper-<tag>).
+ *   4. Bundled Python source run through a system Python (vendor/ or repo dev).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const ROOT = path.join(__dirname, '..');
+const DEP_SCOPE = '@ksl101/vulnreaper';
+
+function platformTag() {
+  const arch = process.arch === 'ia32' ? 'x86' : process.arch;
+  return `${process.platform}-${arch}`;
+}
+
+function binaryName() {
+  return process.platform === 'win32' ? 'VulnReaper.exe' : 'VulnReaper';
+}
+
+function isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function findPython() {
+  const candidates = process.platform === 'win32'
+    ? ['python', 'py', 'python3']
+    : ['python3', 'python'];
+  for (const exe of candidates) {
+    const probe = spawnSync(exe, ['--version'], { stdio: 'ignore' });
+    if (probe.status === 0) return exe;
+  }
+  return null;
+}
+
+function pythonCore(pkgDir) {
+  const env = Object.assign({}, process.env);
+  env.PYTHONPATH = pkgDir + (env.PYTHONPATH ? path.delimiter + env.PYTHONPATH : '');
+  env.PYTHONUTF8 = '1';
+  env.PYTHONIOENCODING = 'utf-8';
+  env.PYTHONDONTWRITEBYTECODE = '1';
+  const py = findPython();
+  if (!py) return null;
+  return { command: py, args: ['-m', 'vulnreaper'], env };
+}
+
+function resolveCore() {
+  const override = process.env.VULNREAPER_CORE;
+  if (override) {
+    return { command: override, args: [], env: Object.assign({}, process.env) };
+  }
+
+  const tag = platformTag();
+
+  // 2. Vendored native binary.
+  const vendored = path.join(ROOT, 'vendor', 'bin', tag, binaryName());
+  if (isFile(vendored)) {
+    return { command: vendored, args: [], env: Object.assign({}, process.env) };
+  }
+
+  // 3. Platform package.
+  const depName = `${DEP_SCOPE}-${tag}`;
+  try {
+    const pkgJsonPath = require.resolve(`${depName}/package.json`);
+    const pkg = require(pkgJsonPath);
+    if (pkg && pkg.core && pkg.core.path) {
+      const p = path.resolve(path.dirname(pkgJsonPath), pkg.core.path);
+      if (isFile(p)) {
+        return { command: p, args: [], env: Object.assign({}, process.env) };
+      }
+    }
+  } catch {
+    /* platform package not installed - fall through */
+  }
+
+  // 4a. Bundled Python source.
+  const bundledPkg = path.join(ROOT, 'vendor');
+  if (fs.existsSync(path.join(bundledPkg, 'vulnreaper'))) {
+    const core = pythonCore(bundledPkg);
+    if (core) return core;
+  }
+
+  // 4b. Repository development checkout.
+  if (fs.existsSync(path.join(ROOT, 'vulnreaper'))) {
+    const core = pythonCore(ROOT);
+    if (core) return core;
+  }
+
+  throw new Error(
+    'VulnReaper core not found for ' + tag + '.\n' +
+    '  - Install a supported platform package, or\n' +
+    '  - install Python 3.10+, or\n' +
+    '  - set VULNREAPER_CORE to the core executable path.'
+  );
+}
+
+module.exports = { resolveCore, platformTag, binaryName, findPython };

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "@ksl101/vulnreaper",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-beta.1",
+  "description": "VulnReaper - authorised security auditing & bug-bounty CLI for Android/Unity/IL2CPP game packages",
+  "keywords": [
+    "security",
+    "bug-bounty",
+    "pentest",
+    "android",
+    "apk",
+    "unity",
+    "il2cpp",
+    "static-analysis",
+    "cli"
+  ],
+  "homepage": "https://github.com/ksl101/vulnreaper",
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "KSL101",
+  "bin": {
+    "vulnreaper": "bin/vulnreaper.js",
+    "vr": "bin/vulnreaper.js"
+  },
+  "main": "lib/cli.js",
+  "files": [
+    "bin/",
+    "lib/",
+    "vendor/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "prepack": "node scripts/npm/pack-core.js"
+  },
+  "optionalDependencies": {},
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/vendor/vulnreaper/__init__.py

@@ -0,0 +1,23 @@
+"""VulnReaper — Android game security research & bug-bounty automation platform.
+
+A modular, offline-first toolkit for analysing Android/Unity/IL2CPP game
+packages: APK/DEX/native/IL2CPP parsing, secret and misconfiguration scanning,
+endpoint discovery, and JSON/Markdown/HTML reporting.
+
+Design invariants
+-----------------
+* Standard library only (no third-party runtime dependencies).
+* Never fabricate results: a missing external tool is reported as ``missing``
+  and its pipeline stage is ``skipped`` — never simulated.
+* Windows-first, POSIX-compatible.
+"""
+from __future__ import annotations
+
+__all__ = ["__version__", "PRODUCT"]
+
+__version__ = "0.1.0-beta.1"
+PRODUCT = "VulnReaper"
+
+
+def version_string() -> str:
+    return f"{PRODUCT} {__version__} — Security Research Platform"

package/vendor/vulnreaper/__main__.py

@@ -0,0 +1,7 @@
+"""Allow ``python -m vulnreaper``."""
+from __future__ import annotations
+
+from .cli.app import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/vendor/vulnreaper/_platform.py

@@ -0,0 +1,101 @@
+"""Platform compatibility helpers.
+
+VulnReaper targets Windows first, but keeps POSIX working.  This module is the ONLY
+place that should contain platform branching for stdio, console colour, process
+creation flags and default home directories.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+
+IS_WINDOWS = os.name == "nt"
+
+
+def configure_stdio() -> None:
+    """Force UTF-8 on stdin/stdout/stderr.
+
+    Windows consoles often default to cp1252/cp850 which breaks on Unicode
+    findings.  ``reconfigure`` is available on Python 3.7+ TextIOWrapper.
+    """
+    for name in ("stdout", "stderr", "stdin"):
+        stream = getattr(sys, name, None)
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is None:
+            continue
+        try:
+            reconfigure(encoding="utf-8", errors="replace")
+        except (ValueError, OSError):
+            pass
+
+
+def enable_virtual_terminal() -> bool:
+    """Enable ANSI escape processing on Windows consoles (Windows 10+).
+
+    Returns True when colours can be used.  On POSIX this is a no-op.
+    """
+    if not IS_WINDOWS:
+        return True
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]
+        enable_vt = 0x0004  # ENABLE_VIRTUAL_TERMINAL_PROCESSING
+        ok = False
+        for std_handle in (-11, -12):  # STD_OUTPUT_HANDLE, STD_ERROR_HANDLE
+            handle = kernel32.GetStdHandle(std_handle)
+            if handle in (0, -1):
+                continue
+            mode = ctypes.c_uint32()
+            if kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
+                if kernel32.SetConsoleMode(handle, mode.value | enable_vt):
+                    ok = True
+        return ok
+    except Exception:
+        return False
+
+
+def supports_colour() -> bool:
+    """Best-effort decision on whether to emit ANSI colour."""
+    if os.environ.get("NO_COLOR"):
+        return False
+    if os.environ.get("VULNREAPER_FORCE_COLOR"):
+        return True
+    if not sys.stdout.isatty():
+        return False
+    return enable_virtual_terminal()
+
+
+def creation_flags() -> int:
+    """subprocess creation flags: hide console windows on Windows."""
+    if IS_WINDOWS:
+        return getattr(subprocess, "CREATE_NO_WINDOW", 0)
+    return 0
+
+
+def default_home() -> str:
+    """Default VulnReaper home directory (config + workspaces)."""
+    env = os.environ.get("VULNREAPER_HOME")
+    if env:
+        return os.path.abspath(os.path.expanduser(env))
+    if IS_WINDOWS:
+        base = os.environ.get("LOCALAPPDATA") or os.path.expanduser("~")
+        return os.path.join(base, "vulnreaper")
+    base = os.environ.get("XDG_DATA_HOME") or os.path.join(os.path.expanduser("~"), ".local", "share")
+    return os.path.join(base, "vulnreaper")
+
+
+def executable_names(name: str) -> list[str]:
+    """Candidate executable filenames for a tool on this platform."""
+    if IS_WINDOWS:
+        return [name + ".exe", name + ".bat", name + ".cmd", name]
+    return [name]
+
+
+def subprocess_env() -> dict:
+    """Environment for child processes: force UTF-8 and unbuffered."""
+    env = dict(os.environ)
+    env.setdefault("PYTHONIOENCODING", "utf-8")
+    env.setdefault("PYTHONUTF8", "1")
+    return env

package/vendor/vulnreaper/android/__init__.py

@@ -0,0 +1,4 @@
+"""Android APK analysis: import, manifest, DEX, native, adb."""
+from __future__ import annotations
+
+__all__ = ["apk", "manifest", "dex_analysis", "native", "adb"]