
Documentación y herramientas de ingeniería inversa para los métodos de cifrado del firmware de 8BitDo
Documentación y herramientas de ingeniería inversa para los métodos de cifrado de firmware utilizados por 8BitDo en varios productos.
Consulte cryptdo8.py para obtener una herramienta de descifrado y recifrado que aplica los
algoritmos descritos en este documento.
La herramienta permite potencialmente crear firmware personalizado. Sin embargo, este repositorio no incluye ninguno de los datos oficiales de firmware. Se puede encontrar un script para descargar los archivos de firmware más recientes en el repositorio fwupd/8bitdo-firmware, con algunos binarios de firmware más antiguos archivados.
Al observar superficialmente un archivo de firmware .dat, se
presenta un encabezado en texto plano de 28 bytes.
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
El resto de la cabecera es cero. Tras buscar la longitud del payload dentro del archivo, puede haber otra cabecera y más datos de firmware. Podemos referirnos a estos como "secciones" del firmware. Por ahora, nos centraremos únicamente en la primera sección.
En ciertos archivos de firmware, aparece un patrón: hay una capa que mezcla cada palabra en la siguiente.
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))
Este encadenamiento se reinicia en cada límite de bloque de 128 palabras. La primera palabra de un bloque
(pos = 0) no tiene término predecesor, y pos = 1..127 se encadenan desde la palabra
anterior.
Una capa sin clave no añade seguridad. Al despojarla se revela un intermedio más limpio
(dechained), donde lo único que queda ocultando el texto plano es el flujo de claves.
P[i] = dechained[i] ^ keystream[i]
El repositorio fwupd/8bitdo-firmware tiene un catálogo de firmware más antiguo. Todos estos firmwares parecían tener la capa de encadenamiento.
Aplicar XOR entre algunos de ellos tras eliminar la capa de encadenamiento revela largas secuencias de ceros y una estructura legible.
plaintext_diff = [a ^ b for a, b in zip(dechained_a, dechained_b)]
Si se utiliza el mismo keystream tanto en...
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
el flujo de claves se cancela.
Este es un clásico many-time pad. Dicho flujo de claves solo es seguro si se usa una vez. Por alguna razón, 8BitDo decidió usar no solo un flujo de claves por producto, sino un único flujo de claves en varios productos. Esto debilitó significativamente la seguridad de su cifrado e hizo posible el resto del análisis aquí presentado.
Una vez que sabes que dos textos planos están combinados con XOR, puedes adivinar parte de uno y aplicar XOR con tu conjetura para leer el otro. Esto recupera el flujo de claves en ese punto.
keystream[i] = dechained[i] ^ P[i]
for fw in all_fw:
P[fw][i] = dechained[fw][i] ^ keystream[i]
Esto sería más fácil con cadenas, pero el truco más productivo aquí fue la reubicación entre versiones de instrucciones ARM. Una función puede aparecer en dos versiones de firmware en posiciones desplazadas. Donde el keystream es conocido en una versión, puedes alinear el código compartido en otra y recolectar nuevos valores de keystream.
Explotar esto llevó las palabras de keystream conocidas de ~1.500 a varios miles, haciendo legible aproximadamente el 18% del firmware.
Con una muestra más grande del keystream, los patrones se hicieron visibles: posiciones separadas por 16 palabras que avanzaban en una cantidad casi constante, y bytes que se desplazaban en un tamaño predecible.
Mediante prueba y error, se descubrió que cada palabra de keystream en un bloque sigue una fórmula:
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
El bloque completo de 128 palabras está determinado por un único número de 32 bits: su "clave de bloque".
Dentro de un bloque, se recorre un contador simple (block_base(block) + pos * STEP), y
se aplica XOR con una máscara que comienza en la clave de bloque y rota 18 bits en cada paso.
Por lo tanto, una palabra conocida desbloquea un bloque entero. Reordenando la fórmula se obtiene la clave de bloque a partir de cualquier palabra conocida 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)
¿De dónde provino la clave de cada bloque? Se factoriza en dos mitades de 16 bits extraídas de una tabla de semillas de 256 entradas:
def block_key_of(block, seed_table):
hi = seed_table[block]
lo = seed_table[block ^ 0xF9]
return (hi << 16) | lo
La tabla semilla en sí parece no tener una fórmula específica; probablemente sean 512 bytes constantes almacenados en algún lugar del bootloader de cada dispositivo. Sin embargo, el XOR con 0xF9 proporciona un bonito efecto secundario: una ley espejo. Un bloque y su compañero block ^ 0xF9 se construyen a partir de las mismas dos entradas de la tabla intercambiadas.
mirror = block_key_of(block ^ 0xF9, seed_table)
assert mirror == rotr(block_key_of(block, seed_table), 16)
Esto descifró regiones previamente desconocidas. En lugar de adivinar a ciegas una clave de bloque completa, puedes adivinar dos mitades de 16 bits y puntuar qué elección convierte ambos bloques en cadenas creíbles o instrucciones ARM.
Con eso, se obtuvo una cobertura del 100% de todos los datos del firmware usando este cifrado específico.
El cifrado anterior parece estar presente en la mayoría de los dispositivos GD32 de 8BitDo, por lo que lo he denominado el "cifrado GD32".
Hay un cifrado más reciente usado de forma consistente por 8BitDo. Los productos que usan este cifrado incluyen la mayor parte de la línea Ultimate/Pro, el M30 y el Zero 2, por nombrar algunos. Los dos últimos parecen tener múltiples secciones en sus archivos de firmware: la primera codificada con el cifrado GD32 más antiguo, y la segunda con este nuevo cifrado.
Tras mucha experimentación, descubrí que este cifrado no es totalmente nuevo. En realidad es una variante del cifrado GD32 existente con parámetros modificados:
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
Notablemente, la clave de bloque todavía se construye a partir de un índice y su socio 0xF9, pero cada uno se convierte primero en un índice de tabla semilla mediante XOR con un valor de una tabla pequeña. Aquí, e es la posición del bloque en una programación de claves de 256 entradas: