
Reverse-engineerte Dokumentation und Tools für die Firmware-Verschlüsselungsmethoden von 8BitDo
Reverse-engineering-Dokumentation und Werkzeuge für die Firmware-Verschlüsselungsmethoden, die von 8BitDo für mehrere Produkte verwendet werden.
Siehe cryptdo8.py für ein Entschlüsselungs- und Wiederverschlüsselungswerkzeug, das die
in diesem Dokument beschriebenen Algorithmen anwendet.
Das Werkzeug ermöglicht potenziell die Erstellung angepasster Firmware. Dieses Repository enthält jedoch keine der offiziellen Firmware-Daten. Ein Skript zum Herunterladen der neuesten Firmware-Dateien ist im fwupd/8bitdo-firmware-Repository zu finden, wobei einige ältere Firmware-Binärdateien archiviert sind.
Betrachtet man eine Firmware-.dat-Datei oberflächlich, so ist ein 28-Byte-Klartext-Header
vorhanden.
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
Der Rest des Headers ist null. Nach dem Anspringen der Payload-Länge innerhalb der Datei können ein weiterer Header und weitere Firmware-Daten vorhanden sein. Wir können diese als Firmware-„Sections" bezeichnen. Vorerst konzentrieren wir uns nur auf den ersten Abschnitt.
Bei bestimmten Firmware-Dateien zeigt sich ein Muster: Es gibt eine Schicht, die jedes Wort in das nächste einmischt.
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))
Diese Verkettung wird an jeder 128-Wort-Blockgrenze zurückgesetzt. Das erste Wort eines Blocks
(pos = 0) hat keinen Vorgängerterm, und pos = 1..127 verketten sich mit dem Wort
davor.
Eine schlüssellose Schicht fügt keine Sicherheit hinzu. Ihr Abziehen legt ein saubereres Zwischenergebnis
(dechained) offen, bei dem das Einzige, was den Klartext noch verbirgt, der Keystream ist.
P[i] = dechained[i] ^ keystream[i]
Das Repository fwupd/8bitdo-firmware enthält einen Katalog älterer Firmware. Diese Firmwares schienen alle die Verkettungsschicht zu besitzen.
XOR-Verknüpfung einiger von ihnen nach Entfernen der Verkettungsschicht offenbart lange Nullfolgen und lesbare Struktur.
plaintext_diff = [a ^ b for a, b in zip(dechained_a, dechained_b)]
Wenn derselbe Keystream in beiden verwendet wird...
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
Der Keystream hebt sich auf.
Dies ist ein klassisches Many-Time-Pad. Ein solcher Keystream ist nur sicher, wenn er einmalig verwendet wird. Aus irgendeinem Grund entschied sich 8BitDo, nicht nur einen produktbezogenen Keystream zu verwenden, sondern einen einzigen Keystream über mehrere Produkte hinweg. Dies schwächte die Sicherheit ihrer Verschlüsselung erheblich und ermöglichte den Rest der hier vorliegenden Analyse.
Sobald man weiß, dass zwei Klartexte miteinander XOR-verknüpft sind, kann man einen Teil des einen erraten und durch XOR mit der eigenen Vermutung den anderen lesen. Dadurch wird der Keystream an dieser Stelle wiederhergestellt.
keystream[i] = dechained[i] ^ P[i]
for fw in all_fw:
P[fw][i] = dechained[fw][i] ^ keystream[i]
Am einfachsten wäre das mit Strings, aber der produktivste Trick hier war die versionsübergreifende Relokation von ARM-Instruktionen. Eine Funktion kann in zwei Firmware-Versionen an verschobenen Positionen auftauchen. Wo der Keystream in einer Version bekannt ist, kann man den gemeinsamen Code in einer anderen ausrichten und neue Keystream- Werte ernten.
Die Ausnutzung dessen erhöhte die bekannten Keystream-Wörter von ~1.500 auf mehrere Tausend, wodurch etwa 18 % der Firmware lesbar wurden.
Mit einer größeren Stichprobe des Keystreams wurden Muster sichtbar: Positionen, die 16 Wörter auseinanderliegen und um einen nahezu konstanten Betrag fortschreiten, und Bytes, die sich um eine vorhersagbare Größe verschieben.
Durch Ausprobieren wurde entdeckt, dass jedes Keystream-Wort in einem Block einer Formel folgt:
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
Der gesamte 128-Wort-Block wird durch eine einzige 32-Bit-Zahl bestimmt: seinen „Block Key".
Innerhalb eines Blocks läuft ein einfacher Zähler (block_base(block) + pos * STEP) und
wird mit einer Maske XOR-verknüpft, die beim Block Key beginnt und sich bei jedem Schritt um 18 Bit dreht.
Daher entsperrt ein bekanntes Wort einen ganzen Block. Durch Umstellen der Formel ergibt sich der Block Key aus jedem bekannten Keystream-Wort:
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)
Woher kam der Schlüssel jedes Blocks? Er setzt sich aus zwei 16-Bit-Hälften zusammen, die aus einer Seed-Tabelle mit 256 Einträgen stammen:
def block_key_of(block, seed_table):
hi = seed_table[block]
lo = seed_table[block ^ 0xF9]
return (hi << 16) | lo
Die Seed-Tabelle selbst scheint keine spezifische Formel zu haben; es sind wahrscheinlich 512 konstante Bytes, die irgendwo im Bootloader jedes Geräts gespeichert sind. Die XOR-Verknüpfung mit 0xF9 hat jedoch einen schönen Nebeneffekt: ein Spiegelgesetz. Ein Block und sein Partner block ^ 0xF9 werden aus denselben zwei vertauschten Tabelleneinträgen gebildet.
mirror = block_key_of(block ^ 0xF9, seed_table)
assert mirror == rotr(block_key_of(block, seed_table), 16)
Das knackte zuvor unbekannte Regionen. Anstatt einen vollständigen Block-Schlüssel blind zu raten, kann man zwei 16-Bit-Hälften raten und bewerten, welche Wahl beide Blöcke in glaubwürdige Zeichenketten oder ARM-Instruktionen verwandelt.
Damit wurde eine 100%ige Abdeckung aller Firmware-Daten mit dieser spezifischen Chiffre erreicht.
Die obige Chiffre scheint auf den meisten GD32-Geräten von 8BitDo vorhanden zu sein, daher habe ich sie die „GD32-Chiffre" getauft.
Es gibt eine neuere Chiffre, die von 8BitDo konsistent verwendet wird. Produkte, die diese Chiffre verwenden, umfassen den Großteil der Ultimate/Pro-Reihe, den M30 und den Zero 2, um nur einige zu nennen. Bei den letzten beiden scheint es mehrere Abschnitte in ihren Firmware-Dateien zu geben: Der erste ist mit der älteren GD32-Chiffre kodiert, und der zweite mit dieser neuen Chiffre.
Nach vielen Experimenten entdeckte ich, dass diese Chiffre nicht völlig neu ist. Sie ist tatsächlich eine Variante der bestehenden GD32-Chiffre mit modifizierten Parametern:
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