Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
8cryptdo — Documentazione e strumenti ottenuti tramite reverse engineering per i metodi di crittografia del firmware 8BitDo | Kitploit
Strumenti/GitHubGitHub/aeromodes/8cryptdo
Sicurezza Sistemi EmbeddedStrumenti di Crittografia/DecrittografiaSicurezza IoTReverse EngineeringCrittografiaSicurezza Hardware e IoTAnalisi di BinariPaper e RicercaAnalisi del Firmware
GitHubaeromodes/8cryptdo

8cryptdo

5151361 mese faRevisionato da Kitploit
Condividi

Documentazione e strumenti ottenuti tramite reverse engineering per i metodi di crittografia del firmware 8BitDo

Vedi Repository

8CryptDo

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.

Header

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.

Livello di concatenamento senza chiave

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]

Fattorizzazione del keystream

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.

Leggere il keystream

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.

Regola del keystream

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)

Tabella dei seed

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.

Cifrario Yichip

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:

Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    755
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    510
  • 3

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    415
  • 4

    redforge

    cybersecurity91/redforge

    Toolkit red team lato browser con 102 strumenti offline per ricognizione, generazione di payload, attacchi alle credenziali, crittografia, codifica e reportistica dell'engagement.

    343
  • 5

    antifox

    antifox-ai/antifox

    Piattaforma multi-agente di penetration testing autonoma basata sull'IA che esegue ricognizione, scoperta della superficie d'attacco, validazione dello sfruttamento e consegna di report supportati da evidenze.

    259
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Il sistema d'azione per la cybersecurity nativa AI—dove l'intento diventa esecuzione governata, le evidenze diventano memoria operativa, e ogni operazione migliora la successiva.

    258

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →