
Documentation et outils rétro-ingénierés pour les méthodes de chiffrement des firmwares 8BitDo
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 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.
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]
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.
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.
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)
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.
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