Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
DeadDialect — Un ISA RISC-V unique par session — chaque démarrage parle un dialecte différent. Les anciens binaires deviennent invalides. Les malwares ne peuvent pas persister. | Kitploit
Outils/GitHubGitHub/engrbilal992/deaddialect
Outils DéfensifsSécurité des Systèmes EmbarquésExploitationRétro-ingénierieAnalyse de MalwareCryptographieTests d'IntrusionSécurité MatérielleAnalyse de BinairesRed Teaming
GitHub
632il y a 7 moisPas encore vérifié
engrbilal992/deaddialect

DeadDialect

Un ISA RISC-V unique par session — chaque démarrage parle un dialecte différent. Les anciens binaires deviennent invalides. Les malwares ne peuvent pas persister.

Voir le dépôt
Partager

DeadDialect

Chaque démarrage parle une langue différente. Le binaire d'hier est le code mort d'aujourd'hui.

Un système de remappage ISA RISC-V unique par session. Chaque fois que le système démarre, il génère une nouvelle permutation cryptographique du jeu d'instructions. Les binaires compilés pour une session sont cryptographiquement rejetés lors de la suivante. Un logiciel malveillant qui survit à un redémarrage ne peut pas s'exécuter — il parle un dialecte mort.


L'idée

Les ISA standards sont des contrats fixes. Chaque programme, chaque bibliothèque, chaque logiciel malveillant s'accorde sur ce que signifie 0x13, ce que fait l'appel système 64, quel registre est le pointeur de pile. DeadDialect brise ce contrat à chaque session.

Boot A:  addi = 0x13,  write = syscall 64,   t0 = x5
Boot B:  addi = 0x33,  write = syscall 178,  t0 = x19
Boot C:  addi = 0x67,  write = syscall 291,  t0 = x23

Un binaire compilé pour Boot A n'a pas de sens sur Boot B. Il exécute soit les mauvaises instructions, appelle les mauvaises fonctions du noyau, ou échoue à la vérification de l'empreinte cryptographique — selon ce qui arrive en premier.


Architecture

256-bit session seed  (os.urandom)
         │
         ├─── opcode permutation   →  /etc/isa/map              12!  ≈ 2²⁹
         ├─── register permutation →  /etc/isa/register_keyring 21!  ≈ 2⁶⁵
         └─── syscall permutation  →  /etc/isa/syscall_keyring  436! ≈ 2³⁰⁰⁰⁺
                                                                 ─────────────
                                               Combined entropy: 2³⁰⁹⁴⁺

Trois couches indépendantes. Un attaquant qui en brise une fait toujours face aux deux autres.

┌──────────────────────────────────────────────────────────────┐
│                     Binary (.text)                           │
│        rewritten at compile time by isa_integrate.py         │
│        fingerprint NOPs embedded at .text+0                  │
└─────────────────────────┬────────────────────────────────────┘
                          │
                          ▼
┌──────────────────────────────────────────────────────────────┐
│                  Patched QEMU 8.2.0                          │
│                                                              │
│  translate.c  ←  register_mapping.h                         │
│  ├── verify 24-bit SHA-256 fingerprint                       │
│  │   mismatch → SIGILL before first instruction              │
│  └── remap 21 shuffleable registers                         │
│                                                              │
│  syscall.c    ←  syscall_mapping.h                          │
│  └── translate permuted syscall number → standard           │
│                                                              │
│  [Phase 1/2]  ←  isa_mapping.h                              │
│  └── remap 12 primary opcodes                               │
└──────────────────────────┬───────────────────────────────────┘
                           │
                           ▼
              Alpine Linux RISC-V (boots normally)
              OS is unaware of the remapping

Protocole d'empreinte

Chaque binaire compilé porte une empreinte cryptographique de 24 bits intégrée sous la forme de deux NOP addi x0,x0,N inoffensifs au début de .text. Ce sont de véritables NOP RISC-V — ils écrivent dans le registre zéro et n'ont aucun effet architectural — mais ils encodent la preuve de session.

QEMU sees fingerprint NOPs + matching keyring  →  RUN
QEMU sees fingerprint NOPs + wrong keyring     →  SIGILL
QEMU sees no fingerprint  + active keyring     →  SIGILL  ← standard binary blocked
QEMU sees fingerprint NOPs + empty keyring     →  SIGILL  ← remapped binary blocked

L'empreinte est dérivée de SHA-256(seed). Aucune collision trouvée dans les 100 000 premières graines testées.


Structure du dépôt

DeadDialect/
├── opcode-remapping/       Phase 1 — Mélange de 12 opcodes
├── trigger-remapping/      Phase 2 — Déclencheur en direct, pas de redémarrage nécessaire
│   └── alpine/             Démo Alpine Linux
├── syscall-remapping/      Phase 3 M1 — Mélange de 436 appels système
├── register-remapping/     Phase 3 M2 — Mélange de 21 registres + empreinte
└── integration/            Phase 3 M3 — Toutes les couches simultanément
    ├── isa_integrate.py    Réécrivain unifié
    ├── register_mapping.h
    ├── syscall_mapping.h
    ├── isa_remap_ldso.h    Correctif ld.so musl (binaires dynamiques)
    ├── trigger/
    │   └── trigger_demo.sh Un déclencheur fait pivoter les deux couches atomiquement
    ├── alpine/
    │   ├── boot_alpine.sh  Démarre Alpine sous QEMU patché
    │   ├── alpine_demo.sh  Démo ISA complète dans Alpine
    │   ├── full_alpine_test.sh
    │   └── setup_alpine.sh Configuration machine vierge
    ├── build.sh            Télécharge + patche QEMU 8.2.0
    ├── demo.sh
    └── audit.sh            51/51 vérifications

Démarrage rapide

Prérequis : Ubuntu 22.04, clang, lld, python3, wget, ninja-build, libglib2.0-dev, libpixman-1-dev, libslirp-dev

git clone https://github.com/engrbilal992/DeadDialect.git
cd DeadDialect/integration

# Build patched QEMU 8.2.0 (~10 min first run)
bash build.sh

# Security demo
bash demo.sh

# One trigger rotates both layers simultaneously
bash trigger/trigger_demo.sh

# Boot Alpine Linux under patched QEMU
cd alpine
bash setup_alpine.sh   # first time only — downloads kernel + rootfs
bash boot_alpine.sh    # boots to ~ # prompt in ~30 seconds

# Alpine ISA demos
bash alpine_demo.sh
bash full_alpine_test.sh

Résultats de la démo

Preuve de sécurité en 6 scénarios

T1: Standard binary,   empty keyrings    →  runs   ✓
T2: Integrated binary, correct keyrings  →  runs   ✓
T3: Standard binary,   active keyrings   →  SIGILL ✗
T4: Integrated binary, empty keyrings    →  SIGILL ✗
T5: Wrong-seed binary                    →  SIGILL ✗
T6: Correct seed binary                  →  runs   ✓

Démo du déclencheur

Session A  binary runs                        SUCCESS ✓
Session A  malware runs                       EXECUTED (expected — same session)
           ── trigger fires ──
Session B  old binary                         BLOCKED ✓
Session B  malware                            BLOCKED ✓
Session B  new binary compiled for B          SUCCESS ✓

Tests de résistance

100,000 seeds — zero collisions
Seed 999999999                →  BLOCKED under different session ✓
Seed 2²⁵⁶-1 (max 256-bit)    →  BLOCKED under different session ✓
Keyring corrupted mid-run     →  BLOCKED on corrupted keyring   ✓

Résultats de l'audit

MilestoneChecksStatus
Trigger remapping37/37✓
Syscall remapping40/40✓
Register remapping43/43✓
Integration51/51✓

Propriétés de sécurité

Ce qu'il stoppe

  • Persistance des logiciels malveillants — tout binaire d'une session précédente est mort au prochain démarrage
  • Exploits pré-compilés — le shellcode pour un ISA fixe échoue immédiatement
  • Attaques par rejeu — les binaires d'une session ne peuvent pas s'exécuter dans une autre
  • Exécution QEMU standard — les binaires remappés nécessitent l'exécuteur patché

Pourquoi l'entropie est importante

Guessing register permutation:  1 in 21!  ≈ 1 in 51 quintillion
Guessing syscall permutation:   1 in 436! ≈ 1 in 10^(1000+)
Guessing both simultaneously:   not a viable attack

Portée du POC

  • -march=rv64g requis (instructions compressées RVC pas encore prises en charge)
  • Binaires statiques uniquement pour les programmes de test (support dynamique via isa_remap_ldso.h)
  • Les attaques se terminant au cours d'une même session ne sont pas traitées

Comment chaque couche fonctionne

Registres (register_mapping.h)

Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    565
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    478
  • 3

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    383
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    327
  • 5

    estorides

    grisuno/estorides

    Agrège plus de 99 sources OSINT gratuites en parallèle, résout les entités dans un graphe de connaissances et exporte en STIX 2.1, MISP ou GraphML avec une analyse assistée par LLM.

    258
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    256

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →