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
8cryptdo — Documentation et outils rétro-ingénierés pour les méthodes de chiffrement des firmwares 8BitDo | Kitploit
Outils/GitHubGitHub/aeromodes/8cryptdo
Sécurité des Systèmes EmbarquésOutils de Chiffrement/DéchiffrementSécurité IoTRétro-ingénierieCryptographieSécurité Matériel et IoTAnalyse de BinairesArticles et RechercheAnalyse de Micrologiciel
GitHubaeromodes/8cryptdo

8cryptdo

515136il y a 1 moisVérifié par Kitploit
Partager

Documentation et outils rétro-ingénierés pour les méthodes de chiffrement des firmwares 8BitDo

Voir le dépôt

8CryptDo

Documentation rétro-ingénierée et outils pour les méthodes de chiffrement du firmware utilisées par 8BitDo pour plusieurs produits.

Voir cryptdo8.py pour un outil de déchiffrement et de rechiffrement appliquant les algorithmes décrits dans ce document.

L'outil permet potentiellement de créer des firmwares personnalisés. Cependant, ce dépôt n'inclut aucune des données officielles de firmware. Un script pour télécharger les derniers fichiers de firmware se trouve dans le dépôt fwupd/8bitdo-firmware, avec quelques anciens binaires de firmware archivés.

En-tête

En observant un fichier de firmware .dat en surface, un en-tête en clair de 28 octets est présent.

import struct

raw = open("sn30.dat", "rb").read()
version, addr, payload_len, pid = struct.unpack("<IIII", raw[:16])
# version     = 207        -> firmware == v2.07
# addr        = 0x08003400 -> destination (probably)
# payload_len = 99328      -> section payload length in bytes
# pid         = 0x0000     -> (optional, usually 0) USB PID

Le reste de l'en-tête est à zéro. Après avoir recherché la longueur de la charge utile dans le fichier, un autre en-tête et davantage de données de firmware peuvent être présents. Nous pouvons les appeler des « sections » de firmware. Pour l'instant, nous nous concentrerons uniquement sur la première section.

Couche de chaînage sans clé

Sur certains fichiers de firmware, un motif apparaît : il existe une couche qui mélange chaque mot dans le suivant.

def rotr(x, r):
    return ((x >> r) | (x << (32 - r))) & 0xFFFFFFFF

dechained = [words[0]]
for i in range(1, len(words)):
    dechained.append(words[i] ^ rotr(words[i - 1], 3))

Cette chaîne se réinitialise à chaque limite de bloc de 128 mots. Le premier mot d'un bloc (pos = 0) n'a pas de terme prédécesseur, et pos = 1..127 s'enchaînent à partir du mot précédent.

Une couche sans clé n'ajoute aucune sécurité. La retirer révèle un intermédiaire plus propre (dechained), où la seule chose qui cache encore le texte en clair est le flux de clé.

P[i] = dechained[i] ^ keystream[i]

Factorisation du flux de clés

Le dépôt fwupd/8bitdo-firmware contient un catalogue d'anciens firmwares. Tous ces firmwares semblaient posséder la couche de chaînage.

Un XOR de certains d'entre eux après suppression de la couche de chaînage révèle de longues séquences de zéros et une structure lisible.

plaintext_diff = [a ^ b for a, b in zip(dechained_a, dechained_b)]

Si le même flux de clés est utilisé dans les deux...

a = dechained_a[i] ^ dechained_b[i]
b = (P_a[i] ^ keystream[i]) ^ (P_b[i] ^ keystream[i])
c = P_a[i] ^ P_b[i]
assert a == b == c

le flux de clé s'annule.

Il s'agit d'un many-time pad classique. Un tel flux de clé n'est sûr que s'il n'est utilisé qu'une seule fois. Pour une raison quelconque, 8BitDo a décidé de ne pas utiliser un flux de clé par produit, mais un flux de clé unique à travers plusieurs produits. Cela a considérablement affaibli la sécurité de leur chiffrement et a rendu possible le reste de l'analyse présentée ici.

Lire le flux de clé

Une fois que vous savez que deux textes en clair sont XOR-és ensemble, vous pouvez deviner une partie de l'un et XOR votre supposition pour lire l'autre. Cela permet de récupérer le flux de clé à cet endroit.

keystream[i] = dechained[i] ^ P[i]
for fw in all_fw:
    P[fw][i] = dechained[fw][i] ^ keystream[i]

Cela aurait été plus simple avec des chaînes de caractères, mais l'astuce la plus productive ici a été la relocalisation inter-versions des instructions ARM. Une fonction peut apparaître dans deux versions du firmware à des positions décalées. Là où le flux de clés est connu dans une version, vous pouvez aligner le code partagé dans une autre et récolter de nouvelles valeurs de flux de clés.

Exploiter cela a fait passer les mots de flux de clés connus d'environ 1 500 à plusieurs milliers, rendant environ 18 % du firmware lisible.

Règle du flux de clés

Avec un échantillon plus large du flux de clés, des motifs sont devenus visibles : des positions espacées de 16 mots qui progressaient d'une quantité presque constante, et des octets qui se déplaçaient d'une taille prévisible.

Par tâtonnements, il a été découvert que chaque mot du flux de clés dans un bloc suit une formule :

STEP  = 0x92A753FA
A_MUL = 0x80000301
ROT   = 18
UINT32_MAX = 0xFFFFFFFF

def rotr(x, r):
    r &= 31
    return ((x >> r) | (x << (32 - r))) & UINT32_MAX if r else x

def block_base(block):
    return (block * A_MUL + block // 2) & UINT32_MAX

def keystream(block, pos, block_key):
    counter = (block_base(block) + pos * STEP) & UINT32_MAX
    mask = rotr(block_key, ROT * pos)
    return counter ^ mask

Le bloc entier de 128 mots est déterminé par un seul nombre de 32 bits : sa « clé de bloc ». À l'intérieur d'un bloc, on parcourt un simple compteur (block_base(block) + pos * STEP), et on le combine par XOR avec un masque qui commence à la clé de bloc et tourne de 18 bits à chaque étape.

Ainsi, un seul mot connu déverrouille tout un bloc. En réarrangeant la formule, on obtient la clé de bloc à partir de n'importe quel mot de flux de clés connu :

def block_key_from_known(block, pos, known_keystream):
    counter = (block_base(block) + pos * STEP) & UINT32_MAX
    return rotr(known_keystream ^ counter, -ROT * pos & 31)

Table de graines

D'où vient la clé de chaque bloc ? Elle se factorise en deux moitiés de 16 bits tirées d'une table de graines de 256 entrées :

def block_key_of(block, seed_table):
    hi = seed_table[block]
    lo = seed_table[block ^ 0xF9]
    return (hi << 16) | lo

La table de graines elle-même ne semble pas avoir de formule spécifique ; il s'agit probablement de 512 octets constants stockés quelque part dans le bootloader de chaque appareil. Cependant, le XOR avec 0xF9 produit un effet secondaire élégant : une loi de miroir. Un bloc et son partenaire block ^ 0xF9 sont construits à partir des deux mêmes entrées de table permutées.

mirror = block_key_of(block ^ 0xF9, seed_table)
assert mirror == rotr(block_key_of(block, seed_table), 16)

Cela a permis de percer des régions auparavant inconnues. Au lieu de deviner à l'aveugle une clé de bloc complète, vous pouvez deviner deux moitiés de 16 bits et évaluer laquelle transforme les deux blocs en chaînes plausibles ou en instructions ARM.

Avec cela, une couverture à 100 % de toutes les données du firmware utilisant ce chiffrement spécifique a été obtenue.

Chiffrement Yichip

Le chiffrement ci-dessus semble être présent sur la plupart des appareils GD32 de 8BitDo, je l'ai donc baptisé le « chiffrement GD32 ».

Il existe un chiffrement plus récent utilisé de manière cohérente par 8BitDo. Les produits utilisant ce chiffrement incluent la plupart de la gamme Ultimate/Pro, le M30 et le Zero 2, pour n'en citer que quelques-uns. Ces deux derniers semblent comporter plusieurs sections dans leurs fichiers de firmware : la première étant encodée avec l'ancien chiffrement GD32, et la seconde avec ce nouveau chiffrement.

Après de nombreuses expérimentations, j'ai découvert que ce chiffrement n'est pas totalement nouveau. Il s'agit en réalité d'une variante du chiffrement GD32 existant avec des paramètres modifiés :

CHAIN_ROT = 18          # GD32: 3
STEP      = 0xEE97FAFA  # GD32: 0x92A753FA
A_MUL     = 0x01200210  # GD32: 0x80000301
ROT       = 16          # GD32: 18

def block_base(block):
    return (block * A_MUL + (block >> 8)) & UINT32_MAX
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.

    786
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    506
  • 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.

    429
  • 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.

    345
  • 5

    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.

    262
  • 6

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    256

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →