---

## Was es ist

Die Autoanalyse von IDA Pro ist single-threaded. Bei einer 34 MB il2cpp DLL sind das *Minuten*. spectrIDA teilt die Binärdatei in N Shards auf, führt sie parallel via idalib aus, führt sie zu einer `.i64` zusammen und lässt dann ein feinabgestimmtes 8B-Modell **jede Funktion benennen** — alles aus einem Terminal-UI mit einem Cyberpunk-Theme und genau der richtigen Menge an Sarkasmus.

Das ist Kapitel 1, und es steht für sich allein: reine Geschwindigkeit, kein KI erforderlich, wenn Sie sie nicht wollen.

Kapitel 2 verwandelt die Ausgabe in etwas, das die Sitzung überdauert — einen Neo4j-Graphen, in dem ein MCP-Client (Claude, [pi](https://pi.dev), was auch immer MCP spricht) tatsächlich leben kann, anstatt dass Sie Decompiler-Ausgabe Funktion für Funktion in ein Chat-Fenster kopieren und einfügen:```
Binary  ─▶  Parallel IDA Analysis  ─▶  Demangle  ─▶  AI Naming  ─▶  Neo4j Graph  ─▶  MCP Server  ─▶  Claude
              (N idalib shards)       (free, real)   (stripped     (persists,        (search/chain/
                                                       leftovers     forever,          rename, live)
                                                       only)         across sessions)

Anforderungen: **IDA Pro 9.x** mit idalib · **Python 3.10+** · **Ollama**```bash
# install Ollama (Windows)
winget install Ollama.Ollama

# pull the model (8.7 GB — go get coffee)
ollama pull hf.co/gdfhhjk/spectrida-re-gguf:latest

# first run — detects your IDA install and sets everything up
spectrida onboard

# or just try the demo right now
spectrida --demo

---

## TUI-Tasten

| Taste | Aktion |
|-------|--------|
| `N` | Ausgewählte Funktion benennen – KI streamt das Ergebnis live |
| `R` | Umbenennen – mit KI-Vorschlag vorausgefüllt |
| `D` | Dekompilierten Pseudocode umschalten (Hex-Rays) |
| `C` | Aufrufkette – Aufrufer und Aufgerufene |
| `B` | Alle `sub_*`-Funktionen in der aktuellen Liste stapelweise benennen |
| `O` | Übersicht – KI-Zusammenfassung der gesamten Binärdatei |
| `/` | Unscharfe Suche |
| `?` | Hilfe |
| `Q` | Beenden |

---

## Programmatische API

Kein TUI erforderlich – steuern Sie spectrIDA von Skripten, Claude Code, Notebooks, was auch immer:```python
import asyncio
from spectrida.api import open_i64

async def main():
    async with open_i64("GameAssembly.i64") as db:

        # list all 153k functions
        funcs = await db.list_functions()

        # name one function — returns name + reasoning + confidence
        result = await db.name_function(0x10001000)
        print(result["new_name"])     # init_atexit_handler
        print(result["reasoning"])    # allocates array of 3 fn ptrs, calls _atexit...

        # batch name everything (with live progress)
        async def on_progress(done, total, r):
            print(f"  {done}/{total}  {r['old_name']} -> {r['new_name']}")

        await db.batch_name(limit=500, rename=True, progress_cb=on_progress)

        # ask what the binary does
        overview = await db.overview()
        print(overview)

        # export to IDA script
        await db.export("names.idc", fmt="idc", named_only=True)

asyncio.run(main())

Überschreibungen von Umgebungsvariablen: `SPECTRIDA_IDALIB` · `SPECTRIDA_MODEL` · `SPECTRIDA_WORKERS` · `SPECTRIDA_OLLAMA_URL`

---

## Hinzufügen eines neuen Binärformats

Die Formatunterstützung ist ein Plugin-System, kein Haufen von if/elif-Zweigen — PE, NSO und ELF sind alle nur Dateien unter `spectrida/analysis/formats/`, die automatisch erkannt werden. Führen Sie `spectrida formats` aus, um zu sehen, was derzeit registriert ist.```bash
$ spectrida formats
ELF        spectrida.analysis.formats.elf.ELFHandler
NSO        spectrida.analysis.formats.nso.NSOHandler
PE         spectrida.analysis.formats.pe.PEHandler
generic    spectrida.analysis.formats.generic.GenericHandler

@staticmethod
def sniff(header: bytes, path: str) -> bool:
    return header[:4] == b"MYF0"          # however you recognize the format

def prepare(self, path: str, workdir: str) -> PreparedImage:
    # Format idalib already loads natively (ELF, PE, Mach-O)? Just parse
    # the section/segment table — return the original path unchanged.
    return PreparedImage(
        binary_path=path,
        image_base=0,
        sections=[Section(name=".text", va=0x1000, raw_off=0x400,
                           raw_size=0x2000, vsize=0x2000, is_code=True)],
        arch=None,        # set "x86_64"/"arm64" only if IDA can't detect it itself
    )

# Only needed if idalib has NO native loader for this format (NSO is the
# example): do any manual idaapi/ida_segment setup here, called right
# after idapro.open_database() succeeds, before analysis starts.
# def post_open(self) -> None: ...

Das ist der gesamte Vertrag:

| Methode | Erforderlich? | Beschreibung |
|---|---|---|
| `sniff(header, path)` | ja | Magic-Byte/Extension-Prüfung – gehört diese Datei zu diesem Handler? |
| `prepare(path, workdir)` | ja | Gibt ein `PreparedImage` zurück: die Datei, die idalib öffnen soll, plus deren Abschnittstabelle |
| `post_open()` | nein (Standard: keine Aktion) | Manuelle Segment-Einrichtung für Formate ohne nativen IDA-Loader (siehe `nso.py`) |
| `make_shard_binary(image, dst, va_start, va_end)` | nein (Standard funktioniert) | Nur überschreiben, wenn das Nullsetzen von Shard-externen Abschnittsbytes für Ihr Format falsch ist (siehe `nso.py` – niemals eine komprimierte Datei nullen) |
| `code_range(image)` | nein (Standard funktioniert) | Nur überschreiben, wenn "Min/Max der `is_code`-Abschnitte" nicht die richtige Antwort ist |
| `read_bytes(image, va_start, va_end)` | nein (Standard funktioniert) | Überschreiben, wenn `prepare()` die relevanten Bytes bereits im Speicher hält (NSO) statt auf der Festplatte |
| `global_entry_points(image, text_start, text_end)` | nein (Standard: None) | Nur überschreiben, wenn ein lokaler Scan pro Shard echte Entry Points verpassen würde – NSO benötigt dies, weil AArch64-Blattfunktionen nur über BL-Ziele, die an anderer Stelle in der Binärdatei sichtbar sind, auffindbar sind, nicht durch einen lokalen Prolog-Scan |

Schauen Sie sich `formats/pe.py` für den einfachsten möglichen Handler an (reine Header-Parsing, keine Überschreibungen) und
`formats/nso.py` für den vollständigen Fall (umfasst Dekompression + manuelle Segment-Einrichtung + jede Überschreibung).

Drittanbieterpakete können ebenfalls einen Handler registrieren, ohne den Quellcode von spectrIDA zu berühren, über die Einstiegspunktgruppe `spectrida.formats`:```toml
# in a separate package's pyproject.toml
[project.entry-points."spectrida.formats"]
myformat = "spectrida_myformat_plugin:HANDLER"

Das war's. Es registriert den Server automatisch bei Claude Code und pi (indem es `mcp` + `neo4j` nachzieht, falls eine bloße `pip install spectrida` sie ausgelassen hat), schreibt deren Konfiguration und sagt dir, welchen Neustart du ihm schuldest.

**Was Claude tatsächlich bekommt, sobald Neo4j läuft (`spectrida`-Konfigurationsabschnitt `[graph]` oder einfach auf eine lokale Instanz verweisen):**

- `search_functions` / `get_function` / `get_callees` / `get_callers` / `trace_chain` — schnelle,
  gecachte Graph-Lesevorgänge. `get_function` liefert Pseudocode **und** Disassemblierung (exakte
  Befehlsgrenzen und Operanden – die Schicht, die Pseudocode nicht liefern kann, und die in dem Moment wichtig ist,
  in dem du von „Was macht das?" zu „Wo genau würde ich das patchen?" übergehst) plus Inline-
  Caller/Callees, sodass Claude entscheiden kann, ob es tiefer ketten soll, indem es sieht, ob ein Callee immer noch
  `sub_*` direkt in der Antwort ist – kein zusätzlicher Roundtrip nur um herauszufinden, dass es nichts weiter zu sehen gibt.
- `get_full_pseudocode` / `rename_function` — Live-, autoritative Lese-/Schreibvorgänge direkt in die
  `.i64`, wenn das gecachte Snippet nicht ausreicht oder ein Name endlich gefunden ist.
- `analyze_binary` — gib ihm eine Binärdatei, die es noch nie gesehen hat (PE oder NSO, parallel-sharded auf beide Arten)
  und es führt die gesamte Pipeline aus – analysieren → demanglen (Itanium *und* MSVC) → KI-basiertes Benennen der
  tatsächlich gestrippten Überbleibsel → alles in den Graphen pushen – als einen Hintergrund-Job, den du abfragst,
  damit ein mehrminütiger Lauf das Gespräch nie blockiert.
- `doctor` / `start_all` — überprüfe oder starte llama-server + Neo4j, ohne den Chat zu verlassen.
  Falls llama-server selbst nirgendwo installiert ist, holt `start_all` es zuerst über winget (Windows) oder
  brew (macOS) – kein separater llama.cpp-Download/Setup nötig.

Es ist keine Magie – eine Funktion, die immer noch `sub_140001234` heißt, weil noch niemand hingesehen hat, ist
immer noch `sub_140001234`. Aber der Graph merkt sich alles, was das Modell *jemals* herausgefunden hat, für immer,
über Sitzungen hinweg, und Claude kann ihn durchlaufen wie einen Kollegen, der den Code schon gelesen hat, anstatt
eine Funktion nach der anderen anzustarren.

**Noch in Arbeit:**

- **Deep Context Naming** — Aufrufbäume N Ebenen tief verfolgen, die gesamte Kette dem Modell füttern.
  Eine Funktion, die 3 Hops von `encrypt_block` entfernt ist, sollte wissen, dass sie sich im Crypto-Pfad befindet.
- **Deobfuskation** — TigressVM-Mustererkennung und Handlerverfolgung
- **Echtes Patchen** — die Disassemblierung ist jetzt im Graphen, sodass ein Agent *kann* einen Patch auf Byte-Ebene
  planen; „Hier ist der genaue Befehl, der geändert werden muss" in „und hier ist der Schreibvorgang" umzuwandeln, kommt als Nächstes.

---

## Kapitel 3 — der Geist geht durch Wände

Kapitel 1 und 2 lesen die Binärdatei und merken sie sich. Aber eine Funktion zu lesen sagt dir, was sie *ist*,
nie, was sie *tut*, wenn du den Abzug betätigst. Kapitel 3 — [**phantomrt**](https://pypi.org/project/phantomrt/) —
betätigt den Abzug.```bash
pip install "spectrida[atlas]"

**Und, im Geiste der obigen NSO-Horror-Geschichte:** die erste echte Fehlersuche fand ehrlich gesagt
*nichts* — und der Grund war interessanter als ein Absturz gewesen wäre. Auf einen
wirklich alten, wirklich verwundbaren FreeType gerichtet, brachte blindes Fuzzing null. Coverage-geführtes Fuzzing meldete
dann triumphierend **64.000 Kanten** abgedeckt — was eine Lüge war, weil die Binärdatei PIE war und
ASLR leise die Adressen bei jedem Durchlauf neu randomisierte, sodass "neue Coverage" größtenteils das Mischen
des Decks durch den Lader war. ASLR deaktivieren, die ehrliche Zahl sinkt auf *echte* 727 Kanten, und sie bleibt dort
konstant — weil jeder Seed eine TrueType-Schriftart war, sodass der Fuzzer in einem Parser gefangen war
und sich nicht strukturell in den CFF/Type1/BDF-Code mutieren konnte, wo die Fehler tatsächlich leben. Der
Fix war kein klügerer Mutator, sondern bessere Seeds: der Agent holte echte OpenType/Type1/BDF-
Beispiele, die Coverage sprang von 727 auf 4.013 vor einer einzigen Fuzz-Iteration, und er erkundete richtig.
Immer noch kein Absturz im Budget — was der ehrliche Zustand eines 3-Minuten-Laufs auf einem Kern im Vergleich zu einem
Job ist, der normalerweise Stunden dauert. Die Maschinerie ist real. Sie hat ihre *eigene* gefälschte Zahl erwischt, anstatt
sie zu melden. Das ist der springende Punkt.

**Ehrlicher Geist-Haftungsausschluss:** phantomrt ist `0.1.0`. Alpha. Es ist eine solide dynamische Schicht, kein magisches
Fehler-Orakel — es fand gepflanzte Fehler in einem Spielzeugziel sofort, und bei echten Zielen sagt es dir
ehrlich, wenn es feststeckt (`needs_state`), wenn ein Absturz nur ein *Kandidat* ist (geh und überprüfe, ob der Pointer
tatsächlich eingabegesteuert ist), und wenn es einfach mehr Zeit und bessere Seeds braucht. Switch-
Binärdateien laufen nicht live — Frida braucht etwas, das es starten kann — also dort ist Emulation die einzige
Tür und es wird oft `needs_state` sagen. Das ist ehrlich, nicht kaputt.

Es ist absichtlich das schwere Extra (`torch`, `unicorn`, `frida`) — die Basis `pip install spectrida`
zieht nichts davon. Der Quellcode lebt in [`phantomrt/`](https://github.com/ggfuchsi-oss/spectrida-reverse_engineering_stack/blob/HEAD/phantomrt/); seine eigene geistgeschmackte README ist
[gleich dort](https://github.com/ggfuchsi-oss/spectrida-reverse_engineering_stack/blob/HEAD/phantomrt/README.md).

*Der statische Geist nennt deine Funktionen. Dieser bringt sie zum Geständnis.* 👻

---

## Lizenz

MIT. Mach damit, was du willst. Wenn es funktioniert, cool.
Wenn nicht, gib der GGUF-Quantisierung die Schuld.

Gebaut mit Bosheit, Kaffee und einer RTX 4070.
Das Modell hat 199 Downloads bei null Marketing. Jeder Download erhöht die Entwicklungsgeschwindigkeit um 0,01 %.
(Das stimmt nicht. Aber es ist nah dran.) 👻