Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Einreichen
ToolsExploitsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

FeedsKontaktDatenschutz© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
8cryptdo — Reverse-engineerte Dokumentation und Tools für die Firmware-Verschlüsselungsmethoden von 8BitDo | Kitploit
Tools/GitHubGitHub/aeromodes/8cryptdo
Embedded-System-SicherheitVerschlüsselungs-/EntschlüsselungstoolsIoT-SicherheitReverse EngineeringKryptographieHardware- & IoT-SicherheitBinäranalysePapers & ForschungFirmware-Analyse
GitHubaeromodes/8cryptdo

8cryptdo

515136vor 1 MonatVon Kitploit geprüft
Teilen

Reverse-engineerte Dokumentation und Tools für die Firmware-Verschlüsselungsmethoden von 8BitDo

Repository anzeigen

8CryptDo

Reverse-engineering-Dokumentation und Werkzeuge für die Firmware-Verschlüsselungsmethoden, die von 8BitDo für mehrere Produkte verwendet werden.

Siehe cryptdo8.py für ein Entschlüsselungs- und Wiederverschlüsselungswerkzeug, das die in diesem Dokument beschriebenen Algorithmen anwendet.

Das Werkzeug ermöglicht potenziell die Erstellung angepasster Firmware. Dieses Repository enthält jedoch keine der offiziellen Firmware-Daten. Ein Skript zum Herunterladen der neuesten Firmware-Dateien ist im fwupd/8bitdo-firmware-Repository zu finden, wobei einige ältere Firmware-Binärdateien archiviert sind.

Header

Betrachtet man eine Firmware-.dat-Datei oberflächlich, so ist ein 28-Byte-Klartext-Header vorhanden.

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

Der Rest des Headers ist null. Nach dem Anspringen der Payload-Länge innerhalb der Datei können ein weiterer Header und weitere Firmware-Daten vorhanden sein. Wir können diese als Firmware-„Sections" bezeichnen. Vorerst konzentrieren wir uns nur auf den ersten Abschnitt.

Keyless-Chaining-Schicht

Bei bestimmten Firmware-Dateien zeigt sich ein Muster: Es gibt eine Schicht, die jedes Wort in das nächste einmischt.

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))

Diese Verkettung wird an jeder 128-Wort-Blockgrenze zurückgesetzt. Das erste Wort eines Blocks (pos = 0) hat keinen Vorgängerterm, und pos = 1..127 verketten sich mit dem Wort davor.

Eine schlüssellose Schicht fügt keine Sicherheit hinzu. Ihr Abziehen legt ein saubereres Zwischenergebnis (dechained) offen, bei dem das Einzige, was den Klartext noch verbirgt, der Keystream ist.

P[i] = dechained[i] ^ keystream[i]

Keystream-Faktorisierung

Das Repository fwupd/8bitdo-firmware enthält einen Katalog älterer Firmware. Diese Firmwares schienen alle die Verkettungsschicht zu besitzen.

XOR-Verknüpfung einiger von ihnen nach Entfernen der Verkettungsschicht offenbart lange Nullfolgen und lesbare Struktur.

plaintext_diff = [a ^ b for a, b in zip(dechained_a, dechained_b)]

Wenn derselbe Keystream in beiden verwendet wird...

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

Der Keystream hebt sich auf.

Dies ist ein klassisches Many-Time-Pad. Ein solcher Keystream ist nur sicher, wenn er einmalig verwendet wird. Aus irgendeinem Grund entschied sich 8BitDo, nicht nur einen produktbezogenen Keystream zu verwenden, sondern einen einzigen Keystream über mehrere Produkte hinweg. Dies schwächte die Sicherheit ihrer Verschlüsselung erheblich und ermöglichte den Rest der hier vorliegenden Analyse.

Den Keystream auslesen

Sobald man weiß, dass zwei Klartexte miteinander XOR-verknüpft sind, kann man einen Teil des einen erraten und durch XOR mit der eigenen Vermutung den anderen lesen. Dadurch wird der Keystream an dieser Stelle wiederhergestellt.

keystream[i] = dechained[i] ^ P[i]
for fw in all_fw:
    P[fw][i] = dechained[fw][i] ^ keystream[i]

Am einfachsten wäre das mit Strings, aber der produktivste Trick hier war die versionsübergreifende Relokation von ARM-Instruktionen. Eine Funktion kann in zwei Firmware-Versionen an verschobenen Positionen auftauchen. Wo der Keystream in einer Version bekannt ist, kann man den gemeinsamen Code in einer anderen ausrichten und neue Keystream- Werte ernten.

Die Ausnutzung dessen erhöhte die bekannten Keystream-Wörter von ~1.500 auf mehrere Tausend, wodurch etwa 18 % der Firmware lesbar wurden.

Keystream-Regel

Mit einer größeren Stichprobe des Keystreams wurden Muster sichtbar: Positionen, die 16 Wörter auseinanderliegen und um einen nahezu konstanten Betrag fortschreiten, und Bytes, die sich um eine vorhersagbare Größe verschieben.

Durch Ausprobieren wurde entdeckt, dass jedes Keystream-Wort in einem Block einer Formel folgt:

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

Der gesamte 128-Wort-Block wird durch eine einzige 32-Bit-Zahl bestimmt: seinen „Block Key". Innerhalb eines Blocks läuft ein einfacher Zähler (block_base(block) + pos * STEP) und wird mit einer Maske XOR-verknüpft, die beim Block Key beginnt und sich bei jedem Schritt um 18 Bit dreht.

Daher entsperrt ein bekanntes Wort einen ganzen Block. Durch Umstellen der Formel ergibt sich der Block Key aus jedem bekannten Keystream-Wort:

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)

Seed-Tabelle

Woher kam der Schlüssel jedes Blocks? Er setzt sich aus zwei 16-Bit-Hälften zusammen, die aus einer Seed-Tabelle mit 256 Einträgen stammen:

def block_key_of(block, seed_table):
    hi = seed_table[block]
    lo = seed_table[block ^ 0xF9]
    return (hi << 16) | lo

Die Seed-Tabelle selbst scheint keine spezifische Formel zu haben; es sind wahrscheinlich 512 konstante Bytes, die irgendwo im Bootloader jedes Geräts gespeichert sind. Die XOR-Verknüpfung mit 0xF9 hat jedoch einen schönen Nebeneffekt: ein Spiegelgesetz. Ein Block und sein Partner block ^ 0xF9 werden aus denselben zwei vertauschten Tabelleneinträgen gebildet.

mirror = block_key_of(block ^ 0xF9, seed_table)
assert mirror == rotr(block_key_of(block, seed_table), 16)

Das knackte zuvor unbekannte Regionen. Anstatt einen vollständigen Block-Schlüssel blind zu raten, kann man zwei 16-Bit-Hälften raten und bewerten, welche Wahl beide Blöcke in glaubwürdige Zeichenketten oder ARM-Instruktionen verwandelt.

Damit wurde eine 100%ige Abdeckung aller Firmware-Daten mit dieser spezifischen Chiffre erreicht.

Yichip-Chiffre

Die obige Chiffre scheint auf den meisten GD32-Geräten von 8BitDo vorhanden zu sein, daher habe ich sie die „GD32-Chiffre" getauft.

Es gibt eine neuere Chiffre, die von 8BitDo konsistent verwendet wird. Produkte, die diese Chiffre verwenden, umfassen den Großteil der Ultimate/Pro-Reihe, den M30 und den Zero 2, um nur einige zu nennen. Bei den letzten beiden scheint es mehrere Abschnitte in ihren Firmware-Dateien zu geben: Der erste ist mit der älteren GD32-Chiffre kodiert, und der zweite mit dieser neuen Chiffre.

Nach vielen Experimenten entdeckte ich, dass diese Chiffre nicht völlig neu ist. Sie ist tatsächlich eine Variante der bestehenden GD32-Chiffre mit modifizierten Parametern:

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
Tool herunterladen

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Das ultimative OSINT-Toolkit: Untersuchungsgraph, Konfidenzbewertung, Alias-Familien, Karte, Zeitleiste und Berichte. 49 Module, 400+ Websites, keine API-Schlüssel erforderlich.

    786
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    506
  • 3

    ARTEX

    baarai/artex

    LLM-basierte Multi-Agenten-Plattform für autonome Penetrationstests mit Planer-/Worker-Agenten, Asset- und Explorationsgraphen, MITM-Verkehrsaufzeichnung und Schwachstellen-Retesting.

    429
  • 4

    redforge

    cybersecurity91/redforge

    Browser-seitiges Red-Team-Toolkit mit 102 Offline-Tools für Recon, Payload-Generierung, Credential-Angriffe, Krypto, Encoding und Engagement-Reporting.

    345
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Das System der Handlung für KI-native Cybersicherheit – wo Absicht zu gesteuerter Ausführung wird, Beweise zu operativem Gedächtnis werden und jeder Einsatz den nächsten verbessert.

    262
  • 6

    looking-glass

    anonghosty/looking-glass

    CSIRT-Plattform, die Shadowserver-Berichte in MongoDB einliest und sie als interaktive Karten, Analysen, Findings, Advisories und Executive-Dashboards wiedergibt.

    256

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →