Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
8cryptdo — Documentação e ferramentas de engenharia reversa para os métodos de criptografia de firmware da 8BitDo | Kitploit
Ferramentas/GitHubGitHub/aeromodes/8cryptdo
Segurança de Sistemas EmbarcadosFerramentas de Criptografia/DescriptografiaSegurança IoTEngenharia ReversaCriptografiaSegurança de Hardware e IoTAnálise de BináriosPapers e PesquisaAnálise de Firmware
GitHubaeromodes/8cryptdo

8cryptdo

515136há 1 mêsRevisado pelo Kitploit
Compartilhar

Documentação e ferramentas de engenharia reversa para os métodos de criptografia de firmware da 8BitDo

Ver Repositório

8CryptDo

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.

Cabeçalho

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.

Camada de encadeamento sem chave

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]

Fatoração de keystream

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.

Lendo a keystream

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.

Regra do keystream

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)

Tabela de sementes

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.

Cifra Yichip

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]
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    546
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    477
  • 3

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    377
  • 4

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    324
  • 5

    estorides

    grisuno/estorides

    Agrega mais de 99 fontes OSINT gratuitas em paralelo, resolve entidades em um grafo de conhecimento e exporta STIX 2.1, MISP ou GraphML com análise assistida por LLM.

    269
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    252

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →