
Documentação e ferramentas de engenharia reversa para os métodos de criptografia de firmware da 8BitDo
Documentação e ferramentas de engenharia reversa para os métodos de criptografia de firmware usados pela 8BitDo em vários produtos.
Consulte cryptdo8.py para obter uma ferramenta de descriptografia e recriptografia que aplica os
algoritmos descritos neste documento.
A ferramenta possibilita potencialmente a criação de firmware personalizado. No entanto, este repositório não inclui nenhum dos dados oficiais de firmware. Um script para baixar os arquivos de firmware mais recentes pode ser encontrado no repositório fwupd/8bitdo-firmware, com alguns binários de firmware mais antigos arquivados.
Observando superficialmente um arquivo de firmware .dat, há um cabeçalho de texto simples de 28 bytes
presente.
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
O restante do cabeçalho é zero. Após buscar o comprimento do payload dentro do arquivo, outro cabeçalho e mais dados de firmware podem estar presentes. Podemos nos referir a estes como "seções" do firmware. Por enquanto, vamos nos concentrar apenas na primeira seção.
Em certos arquivos de firmware, um padrão aparece: há uma camada que mistura cada palavra na seguinte.
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))
Esse encadeamento é reiniciado a cada limite de bloco de 128 palavras. A primeira palavra de um bloco
(pos = 0) não tem termo predecessor, e pos = 1..127 encadeiam a partir da palavra
anterior.
Uma camada sem chave não adiciona segurança. Removê-la revela um intermediário mais limpo
(dechained), onde a única coisa que resta escondendo o texto simples é o keystream.
P[i] = dechained[i] ^ keystream[i]
O repositório fwupd/8bitdo-firmware possui um catálogo de firmwares mais antigos. Todos esses firmwares pareciam ter a camada de encadeamento.
Aplicar XOR entre alguns deles após remover a camada de encadeamento revela longas sequências de zeros e estrutura legível.
plaintext_diff = [a ^ b for a, b in zip(dechained_a, dechained_b)]
Se o mesmo keystream for usado em ambos...
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
o keystream se anula.
Este é um clássico many-time pad. Tal keystream só é seguro se usado uma única vez. Por alguma razão, a 8BitDo decidiu usar não apenas uma keystream por produto, mas uma única keystream entre vários produtos. Isso enfraqueceu significativamente a segurança da sua cifra e tornou possível o restante da análise aqui apresentada.
Uma vez que você sabe que dois textos simples foram combinados com XOR, você pode adivinhar parte de um e aplicar XOR na sua suposição para ler o outro. Isso recupera a keystream naquele ponto.
keystream[i] = dechained[i] ^ P[i]
for fw in all_fw:
P[fw][i] = dechained[fw][i] ^ keystream[i]
Isso seria mais fácil com strings, mas o truque mais produtivo aqui foi a realocação entre versões de instruções ARM. Uma função pode aparecer em duas versões de firmware em posições deslocadas. Onde o keystream é conhecido numa versão, é possível alinhar o código partilhado noutra e recolher novos valores de keystream.
Explorar isto fez com que as palavras de keystream conhecidas passassem de ~1.500 para vários milhares, tornando aproximadamente 18% do firmware legível.
Com uma amostra maior do keystream, os padrões tornaram-se visíveis: posições separadas por 16 palavras que avançavam por uma quantidade quase constante, e bytes que se moviam por um tamanho previsível.
Através de tentativa e erro, descobriu-se que cada palavra de keystream num bloco segue uma 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
O bloco inteiro de 128 palavras é determinado por um único número de 32 bits: sua "chave de bloco".
Dentro de um bloco, percorre-se um contador simples (block_base(block) + pos * STEP) e
aplica-se XOR com uma máscara que começa na chave do bloco e gira 18 bits a cada passo.
Portanto, uma palavra conhecida desbloqueia um bloco inteiro. Reorganizando a fórmula, obtém-se a chave do bloco a partir de qualquer palavra conhecida do 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 onde veio a chave de cada bloco? Ela se decompõe em duas metades de 16 bits extraídas de uma tabela de sementes com 256 entradas:
def block_key_of(block, seed_table):
hi = seed_table[block]
lo = seed_table[block ^ 0xF9]
return (hi << 16) | lo
A tabela de seed em si parece não ter uma fórmula específica; provavelmente são 512 bytes constantes armazenados em algum lugar no bootloader de cada dispositivo. No entanto, o XOR com 0xF9 proporciona um belo efeito colateral: uma lei de espelhamento. Um bloco e seu parceiro block ^ 0xF9 são construídos a partir das mesmas duas entradas da tabela trocadas.
mirror = block_key_of(block ^ 0xF9, seed_table)
assert mirror == rotr(block_key_of(block, seed_table), 16)
Isso quebrou regiões anteriormente desconhecidas. Em vez de adivinhar uma chave de bloco completa às cegas, você pode adivinhar duas metades de 16 bits e pontuar qual escolha transforma ambos os blocos em strings verossímeis ou instruções ARM.
Com isso, obteve-se 100% de cobertura de todos os dados de firmware usando essa cifra específica.
A cifra acima parece estar presente na maioria dos dispositivos GD32 da 8BitDo, então eu a apelidei de "cifra GD32".
Há uma cifra mais recente usada consistentemente pela 8BitDo. Produtos que usam essa cifra incluem a maior parte da linha Ultimate/Pro, o M30 e o Zero 2, para citar alguns. Os dois últimos parecem ter múltiplas seções em seus arquivos de firmware: a primeira codificada com a cifra GD32 mais antiga, e a segunda com esta nova cifra.
Após muita experimentação, descobri que essa cifra não é totalmente nova. Na verdade, é uma variante da cifra GD32 existente com 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
Notavelmente, a chave de bloco ainda é construída a partir de um índice e do seu parceiro 0xF9, mas cada um é primeiro convertido num índice de tabela de sementes através de XOR com um valor de uma pequena tabela. Aqui, e é a posição do bloco numa tabela de chaves de 256 entradas:
INDEX_XOR = ((0x00, 0x82, 0x83, 0x81, 0x03, 0x81, 0x83, 0x81),
(0x86, 0x83, 0x81, 0x82, 0x03, 0x05, 0x82, 0x82))
def seed_index(e):
return e ^ INDEX_XOR[e >> 7][e & 7]