Aller au contenu

02. Spécification du Routage des Binaires : Trampolines Universels

Navigation : Documentation > 02. Routage des Binaires & Trampolines

Sommaire

  1. Architecture de Routage
  2. Spécification Technique du Modèle Trampoline
  3. Couplage Binaire / Fichier Pointeur (.target)
  4. Propriétés Opérationnelles
  5. Sécurité Intégrée au Trampoline Rust
  6. Protection contre le Détournement de Cible (.target Tampering)
  7. Mitigation du DLL Hijacking / Binary Planting (CVE-2020-11738)
  8. Implémentations Système
  9. Implémentation sous Windows (Binaire Rust Win32)
  10. Implémentation sous Linux et macOS (Appel Système POSIX exec)

1. Architecture de Routage

erable utilise un mécanisme de routage haute performance nommé Trampoline Universel.
Le répertoire ~/.erable/bin (enregistré dans le $PATH) contient exclusivement des trampolines associés à des fichiers pointeurs légers. Aucun lien symbolique n'est utilisé dans bin/.

flowchart TD
    subgraph UserSpace ["1. Commande Utilisateur"]
        CMD["$ npm install express (ou rg, node, git...)"]
    end

    subgraph BinDirectory ["2. Répertoire PATH (~/.erable/bin)"]
        EXE["Trampoline Binaire : ~/.erable/bin/npm.exe (Rust 25-30 Ko)"]
        TARGET_FILE["Pointeur : ~/.erable/bin/npm.target"]
    end

    subgraph AppStore ["3. Store Immuable de l'Application"]
        REAL_DIR["packages/nodejs/20.10.0/"]
        REAL_BIN["npm.cmd (avec node_modules/npm/...)"]
    end

    CMD --> EXE
    EXE -->|1. Lit & Valide confinement .target| TARGET_FILE
    TARGET_FILE -.->|'../packages/nodejs/20.10.0/npm.cmd'| EXE
    EXE -->|2. SetDllDirectoryW('') & cd REAL_DIR| REAL_DIR
    EXE -->|3. Transmet la ligne de commande brute| REAL_BIN
    REAL_BIN -->|4. Renvoie le code de sortie exact| CMD

2. Spécification Technique du Modèle Trampoline

2.1 Couplage Binaire / Fichier Pointeur (.target)

Pour chaque exécutable exposé dans ~/.erable/bin/ :

  • Un binaire trampoline natif autonome : ~/.erable/bin/<alias>.exe (ou binaire ELF/Mach-O sur Unix).
  • Un fichier texte frère : ~/.erable/bin/<alias>.target.

Le fichier .target contient une seule ligne indiquant le chemin relatif vers le binaire actif : 

../packages/ripgrep/14.1.0/rg.exe

2.2 Propriétés Opérationnelles

  1. Mises à jour et rollbacks instantanés en $\mathcal{O}(1)$ et atomiques :
    Pour changer de version ou exécuter un rollback (erable rollback), le moteur remplace le contenu de <alias>.target de manière strictement atomique (écriture sur fichier temporaire puis ReplaceFileW sous Windows / rename() sous POSIX). L'exécutable <alias>.exe reste intact sur le disque, éliminant tout verrouillage de fichier (ERROR_SHARING_VIOLATION) et empêchant toute course critique de lecture à vide.

  2. Indépendance vis-à-vis des privilèges administrateur :
    Sous Windows, le système fonctionne sur n'importe quel système de fichiers (NTFS, ReFS, FAT32) sans nécessiter l'activation du Mode Développeur ni d'élévation UAC.

  3. Résolution native des scripts compagnons (npm, pip, cargo) :
    Avant de lancer l'application, le trampoline positionne le répertoire de travail courant sur le dossier réel du binaire cible. Les scripts batch ou shell utilisant %~dp0 ou dirname $0 résolvent leurs dépendances locales sans aucune anomalie de chemin.

  4. Sécurisation des cibles batch Windows (.cmd / .bat) et scripts PowerShell (.ps1) :

  5. Si la cible est un script batch (.cmd / .bat), le trampoline applique un échappement strict des métacaractères (%, &, |, ^, <, >) et invoque de manière étanche cmd.exe /d /e:off /c pour neutraliser tout vecteur d'injection de commande (type CVE-2024-24576).
  6. Si la cible est un script PowerShell (.ps1), le trampoline invoque l'interpréteur avec le commutateur -File (et non -Command) pour forcer l'interprétation des arguments comme chaînes littérales pures (neutralisant l'injection de commandes PowerShell, l'expansion de variables et l'évaluation d'accents graves) : powershell.exe -NoProfile -NonInteractive -ExecutionPolicy Bypass -File <script.ps1> [arguments]

3. Sécurité Intégrée au Trampoline Rust

Le trampoline intègre des protections natives contre les vulnérabilités d'exécution locale :

3.1 Protection contre le Détournement de Cible (.target Tampering)

Pour empêcher qu'un fichier .target corrompu ou modifié par un logiciel tiers ne pointe vers un exécutable malveillant hors du store :

  • Le trampoline résout le chemin absolu canonique de la cible via canonicalize().
  • Il valide obligatoirement que la cible commence strictement par le répertoire du store officiel ~/.erable/packages/.
  • Si la cible pointe en dehors du store autorisé, le trampoline refuse immédiatement l'exécution : "[FATAL SECURITY] Le fichier .target pointe hors du store autorisé. Exécution bloquée."

3.2 Mitigation du DLL Hijacking / Binary Planting (CVE-2020-11738 & Hardening Win32)

Sous Windows, pour empêcher le chargement de DLLs malveillantes placées dans le répertoire courant ou dans bin/ :

  • Le trampoline appelle l'API Win32 SetDllDirectoryW(L"") avant de lancer le sous-processus, ce qui retire immédiatement le dossier courant de l'ordre de recherche des DLLs de Windows.
  • Il configure SetDefaultDllDirectories(LOAD_LIBRARY_SEARCH_SYSTEM32) (drapeau 0x00000800), restreignant strictement le chargement des bibliothèques système au seul répertoire %SystemRoot%\System32 et aux chemins déclarés de confiance.
  • Il active de manière permanente le Safe Search Mode pour le processus via SetSearchPathMode(BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE | BASE_SEARCH_PATH_PERMANENT).
  • Il positionne lpCurrentDirectory sur le dossier officiel packages/<pkg>/<version>/, garantissant le chargement exclusif des DLLs légitimes de l'application.

3.3 Optimisation Zéro-Allocation Mémoire sur le Chemin Chaud

Pour garantir une latence d'exécution imperceptible (< 1 ms) :

  • Le parseur de fichier pointeur .target (read_target_str) utilise un buffer statique alloué sur la pile (stack buffer de 4096 octets).
  • La validation UTF-8, le dépouillement du BOM (\u{feff}) et le filtrage des commentaires se font par découpage de tranches (zero-copy string slicing) directement dans la mémoire de pile, évitant toute allocation dynamique sur le heap lors de l'exécution normale du trampoline.
  • Un repli gracieux sur le tas n'est opéré que dans le cas marginal où le chemin dépasserait 4096 octets.

4. Implémentations Système

4.1 Implémentation sous Windows (Binaire Rust Win32)

Le trampoline est compilé avec une empreinte minimale (opt-level = "z", lto = true, panic = "abort", strip = true) :

  • Toolchain et Compatibilité Antivirus : La compilation officielle Windows cible stable-x86_64-pc-windows-msvc. L'utilisation de l'éditeur de liens Microsoft (link.exe) avec la CRT standard évite les faux positifs heuristiques d'antivirus (ex: VHO:Backdoor.Win32.Agent.gen) fréquemment observés avec les binaires dépouillés issus de MinGW/GNU (x86_64-pc-windows-gnu).
  • Poids binaire : 200 à 300 Ko optimisé.
  • Transmission de la ligne de commande : Utilisation directe de GetCommandLineW() passée brute à CreateProcessW, préservant l'intégrité exacte des guillemets et caractères d'échappement.
  • Support des applications graphiques : Pour les outils du bucket gui (category = "gui"), le trampoline est compilé avec #![windows_subsystem = "windows"] pour éviter toute apparition de console noire.
  • Latence mesurée : ~1 milliseconde.

4.2 Implémentation sous Linux et macOS (Appel Système POSIX exec)

Sur les systèmes POSIX, le trampoline utilise la primitive noyau execve :

  • Le noyau remplace directement l'image mémoire du trampoline par celle du binaire cible.
  • Latence mesurée : 0 milliseconde, même PID, zéro consommation de mémoire additionnelle et transfert immédiat des signaux Unix (SIGINT, SIGTERM).