
Documentazione e strumenti ottenuti tramite reverse engineering per i metodi di crittografia del firmware 8BitDo
Documentazione e strumenti di reverse engineering per i metodi di cifratura del firmware utilizzati da 8BitDo per diversi prodotti.
Vedi cryptdo8.py per uno strumento di decifratura e ricifratura che applica gli
algoritmi descritti in questo documento.
Lo strumento consente potenzialmente di creare firmware personalizzati. Tuttavia, questo repository non include alcuno dei dati ufficiali del firmware. Uno script per scaricare i file firmware più recenti è disponibile nel repository fwupd/8bitdo-firmware, con alcuni binari firmware più vecchi archiviati.
Osservando superficialmente un file firmware .dat, è presente un header in
plaintext di 28 byte.
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
Il resto dell'header è zero. Dopo aver cercato la lunghezza del payload all'interno del file, possono essere presenti un altro header e ulteriori dati del firmware. Possiamo riferirci a questi come "sezioni" del firmware. Per ora, ci concentreremo solo sulla prima sezione.
Su alcuni file di firmware, emerge un pattern: c'è un livello che mescola ogni parola nella successiva.
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))
Questa concatenazione si azzera a ogni confine di blocco di 128 parole. La prima parola di un blocco
(pos = 0) non ha un termine predecessore, e pos = 1..127 si concatenano dalla parola
precedente.
Uno strato senza chiave non aggiunge sicurezza. Rimuovendolo si rivela un intermedio più pulito
(dechained), dove l'unica cosa che resta a nascondere il testo in chiaro è il keystream.
P[i] = dechained[i] ^ keystream[i]
Il repository fwupd/8bitdo-firmware contiene un catalogo di firmware più vecchi. Questi firmware sembravano avere tutti il layer di concatenamento.
Eseguendo lo XOR di alcuni di essi dopo aver rimosso il layer di concatenamento si rivelano lunghe sequenze di zeri e una struttura leggibile.
plaintext_diff = [a ^ b for a, b in zip(dechained_a, dechained_b)]
Se lo stesso keystream viene utilizzato in entrambi...
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
il keystream si annulla.
Questo è un classico many-time pad. Un tale keystream è sicuro solo se usato una volta sola. Per qualche motivo, 8BitDo ha deciso di utilizzare non solo un keystream per prodotto, ma un singolo keystream condiviso tra diversi prodotti. Questo ha indebolito significativamente la sicurezza del loro cifrario e ha reso possibile il resto dell'analisi qui presentata.
Una volta che sai che due testi in chiaro sono stati combinati con XOR, puoi indovinare una parte di uno e applicare lo XOR alla tua ipotesi per leggere l'altro. Questo recupera il keystream in quel punto.
keystream[i] = dechained[i] ^ P[i]
for fw in all_fw:
P[fw][i] = dechained[fw][i] ^ keystream[i]
La cosa sarebbe più semplice con le stringhe, ma il trucco più produttivo qui è stato la rilocazione cross-version delle istruzioni ARM. Una funzione può comparire in due versioni del firmware in posizioni spostate. Dove il keystream è noto in una versione, puoi allineare il codice condiviso in un'altra e raccogliere nuovi valori di keystream.
Sfruttando questo, le parole di keystream note sono passate da ~1.500 a diverse migliaia, rendendo leggibile circa il 18% del firmware.
Con un campione più ampio del keystream, sono emersi dei pattern: posizioni distanti 16 parole che avanzavano di una quantità quasi costante, e byte che si spostavano di una dimensione prevedibile.
Attraverso tentativi ed errori, si è scoperto che ogni parola del keystream in un blocco segue una formula:
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
L'intero blocco di 128 parole è determinato da un unico numero a 32 bit: la sua "chiave di blocco".
All'interno di un blocco, si percorre un semplice contatore (block_base(block) + pos * STEP) e
lo si combina in XOR con una maschera che parte dalla chiave di blocco e ruota di 18 bit a ogni passo.
Pertanto, una sola parola nota sblocca un intero blocco. Riorganizzando la formula si ottiene la chiave di blocco a partire da qualsiasi parola nota del keystream:
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)
Da dove proviene la chiave di ciascun blocco? Essa si scompone in due metà da 16 bit estratte da una tabella di seed con 256 voci:
def block_key_of(block, seed_table):
hi = seed_table[block]
lo = seed_table[block ^ 0xF9]
return (hi << 16) | lo
La tabella seed stessa sembra non avere una formula specifica; probabilmente sono 512 byte costanti memorizzati da qualche parte nel bootloader di ciascun dispositivo. Tuttavia, lo XOR con 0xF9 fornisce un bellissimo effetto collaterale: una legge speculare. Un blocco e il suo partner block ^ 0xF9 sono costruiti dalle stesse due voci della tabella scambiate.
mirror = block_key_of(block ^ 0xF9, seed_table)
assert mirror == rotr(block_key_of(block, seed_table), 16)
Questo ha permesso di decifrare regioni precedentemente sconosciute. Invece di indovinare a tentativi una chiave di blocco completa, è possibile indovinare due metà da 16 bit e valutare quale scelta trasformi entrambi i blocchi in stringhe credibili o istruzioni ARM.
Con questo si è ottenuta una copertura del 100% di tutti i dati del firmware che utilizzano questo specifico cifrario.
Il cifrario sopra descritto sembra essere presente sulla maggior parte dei dispositivi GD32 di 8BitDo, perciò l'ho ribattezzato "cifrario GD32".
Esiste un cifrario più recente utilizzato in modo coerente da 8BitDo. I prodotti che usano questo cifrario includono gran parte della linea Ultimate/Pro, l'M30 e lo Zero 2, tanto per citarne alcuni. Questi ultimi due sembrano avere più sezioni nei loro file di firmware: la prima codificata con il vecchio cifrario GD32, e la seconda con questo nuovo cifrario.
Dopo molti esperimenti, ho scoperto che questo cifrario non è del tutto nuovo. È in realtà una variante del cifrario GD32 esistente con parametri modificati:
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
Notably, la chiave del blocco è ancora costruita a partire da un indice e dal suo partner 0xF9, ma ciascuno viene prima trasformato in un indice della tabella dei seed tramite XOR con un valore proveniente da una piccola tabella. Qui, e è la posizione del blocco in una key schedule di 256 voci: