## Ce que c'est

L'analyse automatique d'IDA Pro est monothread. Sur une DLL il2cpp de 34 Mo, cela prend *des minutes*. spectrIDA divise le binaire en N fragments, les exécute en parallèle via idalib, les fusionne en un seul `.i64`, puis laisse un modèle 8B finement ajusté **nommer chaque fonction** — le tout depuis une interface terminal avec un thème cyberpunk et exactement la bonne dose de sarcasme.

Voilà le chapitre 1, et il se suffit à lui-même : pure vitesse, aucune IA nécessaire si on n'en veut pas.

Le chapitre 2 transforme la sortie en quelque chose qui survit à la session — un graphe Neo4j dans lequel un client MCP (Claude, [pi](https://pi.dev), ou tout ce qui parle MCP) peut réellement vivre, au lieu que vous copiiez-colliez la sortie du décompilateur dans une fenêtre de chat une fonction à la fois :```
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)

Prérequis: **IDA Pro 9.x** avec 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

---

## Touches de l'interface TUI

| Touche | Action |
|--------|--------|
| `N` | Nommer la fonction sélectionnée — l'IA diffuse le résultat en direct |
| `R` | Renommer — pré-rempli avec la suggestion de l'IA |
| `D` | Basculer le pseudo-code décompilé (Hex-Rays) |
| `C` | Chaîne d'appels — appelants et appelés |
| `B` | Nommer par lots toutes les fonctions `sub_*` de la liste actuelle |
| `O` | Vue d'ensemble — résumé IA de l'intégralité du binaire |
| `/` | Recherche floue |
| `?` | Aide |
| `Q` | Quitter |

---

## API programmatique

Pas besoin d'interface TUI — pilotez spectrIDA depuis des scripts, Claude Code, notebooks, peu importe :```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())

Env var overrides: `SPECTRIDA_IDALIB` · `SPECTRIDA_MODEL` · `SPECTRIDA_WORKERS` · `SPECTRIDA_OLLAMA_URL`

---

## Ajout d'un nouveau format binaire

La prise en charge des formats est un système de plugins, pas un tas de branches if/elif — PE, NSO et ELF sont simplement des fichiers sous `spectrida/analysis/formats/`, découverts automatiquement. Exécutez `spectrida formats` pour voir ce qui est actuellement enregistré.```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: ...

Voici l'intégralité du contrat :

| Méthode | Requis ? | Ce qu'il fait |
|---|---|---|
| `sniff(header, path)` | oui | Vérification par magic-byte/extension — ce gestionnaire possède-t-il le fichier ? |
| `prepare(path, workdir)` | oui | Renvoie un `PreparedImage` : le fichier que idalib doit ouvrir + sa table de sections |
| `post_open()` | non (par défaut, aucune opération) | Configuration manuelle des segments pour les formats sans chargeur IDA natif (voir `nso.py`) |
| `make_shard_binary(image, dst, va_start, va_end)` | non (fonctionne par défaut) | Redéfinir uniquement si la mise à zéro des octets de section hors fragment est incorrecte pour votre format (voir `nso.py` — ne jamais mettre à zéro un fichier compressé) |
| `code_range(image)` | non (fonctionne par défaut) | Redéfinir uniquement si « min/max des sections `is_code` » n'est pas la bonne réponse |
| `read_bytes(image, va_start, va_end)` | non (fonctionne par défaut) | Redéfinir si `prepare()` contient déjà les octets pertinents en mémoire (NSO) au lieu du disque |
| `global_entry_points(image, text_start, text_end)` | non (par défaut : None) | Redéfinir uniquement si un scan local par fragment manquerait les véritables points d'entrée — NSO en a besoin car les fonctions feuilles AArch64 ne sont découvrables que via les cibles BL vues ailleurs dans le binaire, pas par un scan local du prologue |

Regardez `formats/pe.py` pour le gestionnaire le plus simple possible (analyse pure des en-têtes, sans redéfinitions) et
`formats/nso.py` pour le cas complet (intègre la décompression + configuration manuelle des segments + chaque redéfinition).

Les paquets tiers peuvent également enregistrer un gestionnaire, sans toucher du tout au source de spectrIDA, via
le groupe de points d'entrée `spectrida.formats` :```toml
# in a separate package's pyproject.toml
[project.entry-points."spectrida.formats"]
myformat = "spectrida_myformat_plugin:HANDLER"

C'est tout. Il enregistre le serveur avec Claude Code et pi automatiquement (en incluant `mcp` +
`neo4j` si un simple `pip install spectrida` les a ignorés), écrit leur configuration, et vous indique
quel redémarrage vous lui devez.

**Ce que Claude obtient réellement, une fois Neo4j en cours d'exécution (section `[graph]` de la configuration `spectrida`,
ou pointez-le simplement vers une instance locale) :**

- `search_functions` / `get_function` / `get_callees` / `get_callers` / `trace_chain` — rapides,
  lectures en cache du graphe. `get_function` renvoie le pseudocode **et** le désassemblage (limites exactes des instructions
  et opérandes — que la couche de pseudocode ne peut pas vous donner, ce qui compte dès que vous
  passez de « qu'est-ce que cela fait » à « où exactement devrais-je patcher cela ») ainsi que les
  appelants/appelés en ligne, afin que Claude décide s'il doit creuser plus profondément en vérifiant si un appelé
  est toujours `sub_*` directement dans la réponse — pas d'aller-retour supplémentaire juste pour découvrir qu'il n'y a
  rien de plus à voir.
- `get_full_pseudocode` / `rename_function` — lectures/écritures en direct et autoritaires directement vers le
  `.i64` lorsque l'extrait en cache ne suffit pas ou qu'un nom est enfin trouvé.
- `analyze_binary` — donnez-lui un binaire qu'il n'a jamais vu (PE ou NSO, parallélisé par sharding dans les deux cas)
  et il exécute tout le pipeline — analyser → démasquer (Itanium *et* MSVC) → nommer par IA les
  vestiges réellement strippés → tout pousser dans le graphe — comme une tâche d'arrière-plan que vous interrogez,
  de sorte qu'une exécution de plusieurs minutes ne bloque jamais la conversation.
- `doctor` / `start_all` — vérifiez ou démarrez llama-server + Neo4j sans quitter le chat.
  Si llama-server lui-même n'est installé nulle part, `start_all` le récupère via winget (Windows) ou
  brew (macOS) d'abord — pas besoin de téléchargement/configuration séparé de llama.cpp.

Ce n'est pas magique — une fonction qui est toujours `sub_140001234` parce que personne ne l'a encore regardée est
toujours `sub_140001234`. Mais le graphe se souvient de tout ce que le modèle *a* découvert, pour toujours,
entre les sessions, et Claude peut le parcourir comme un collègue qui a déjà lu la base de code au lieu
de regarder une fonction à la fois.

**À venir :**

- **Nommage contextuel profond** — suivre les arbres d'appels sur N niveaux de profondeur, fournir la chaîne complète au modèle.
  Une fonction à 3 sauts de `encrypt_block` devrait savoir qu'elle est dans le chemin crypto.
- **Désobfuscation** — détection de motifs TigressVM et traçage des handlers
- **Patching réel** — le désassemblage est maintenant dans le graphe, donc un agent *peut* planifier un patch
  au niveau des octets ; transformer « voici l'instruction exacte à modifier » en « et voici l'écriture » est la prochaine étape.

---

## Chapitre 3 — le fantôme traverse les murs

Les chapitres 1 et 2 lisent le binaire et s'en souviennent. Mais lire une fonction vous dit ce qu'elle *est*,
jamais ce qu'elle *fait* quand vous appuyez sur la gâchette. Le chapitre 3 — [**phantomrt**](https://pypi.org/project/phantomrt/) —
appuie sur la gâchette.```bash
pip install "spectrida[atlas]"

**Et, dans l'esprit de l'histoire d'horreur NSO ci-dessus :** la première vraie chasse aux bugs a honnêtement trouvé
*rien* — et la raison était plus intéressante qu'un crash ne l'aurait été. Pointée vers un
FreeType vraiment vieux, vraiment vulnérable, le fuzzing aveugle n'a rien donné. Le fuzzing guidé par couverture a ensuite
signalé un triomphant **64 000 arêtes** couvertes — ce qui était un mensonge, car le binaire était PIE et
ASLR rerandomisait silencieusement les adresses à chaque exécution, donc la "nouvelle couverture" était surtout le chargeur
qui mélangeait les cartes. Désactivez ASLR, le nombre honnête tombe à *réellement* 727 arêtes, et ça plafonne
là — car chaque graine était une police TrueType, donc le fuzzer était piégé dans un analyseur et
ne pouvait pas muter structurellement pour atteindre le code CFF/Type1/BDF où vivent réellement les bugs. La
solution n'était pas un mutateur plus intelligent, c'étaient de meilleures graines : l'agent a récupéré de vrais échantillons
OpenType/Type1/BDF, la couverture a bondi de 727 → 4 013 avant une seule itération de fuzz, et il a exploré correctement.
Toujours pas de crash dans le budget — ce qui est l'état honnête d'une exécution de 3 minutes sur un cœur par rapport à un
travail qui prend normalement des heures. La mécanique est réelle. Elle a attrapé son *propre* faux nombre au lieu de
le signaler. C'est tout l'intérêt.

**Avertissement honnête sur les fantômes :** phantomrt est `0.1.0`. Alpha. C'est une couche dynamique solide, pas un oracle
magique à bugs — il a trouvé instantanément des bugs plantés dans une cible jouet, et sur des cibles réelles, il vous dit
honnêtement quand il est bloqué (`needs_state`), quand un crash n'est qu'un *candidat* (allez vérifier que le pointeur
est réellement contrôlé par l'entrée), et quand il a juste besoin de plus de temps et de meilleures graines. Les binaires
Switch ne tournent pas en direct — Frida a besoin de quelque chose qu'il peut lancer — donc là, l'émulation est la seule
porte et il dira `needs_state` souvent. C'est honnête, pas cassé.

C'est le lourd supplément intentionnellement (`torch`, `unicorn`, `frida`) — le `pip install spectrida`
de base n'en tire rien. La source vit dans [`phantomrt/`](https://github.com/ggfuchsi-oss/spectrida-reverse_engineering_stack/blob/HEAD/phantomrt/) ; son propre README teinté de fantôme est
[juste là](https://github.com/ggfuchsi-oss/spectrida-reverse_engineering_stack/blob/HEAD/phantomrt/README.md).

*Le fantôme statique nomme vos fonctions. Celui-ci les fait avouer.* 👻

---

## Licence

MIT. Faites-en ce que vous voulez. Si ça marche, cool.
Sinon, blâmez la quantification GGUF.

Construit avec dépit, café et une RTX 4070.
Le modèle a 199 téléchargements sans marketing. Chacun ajoute 0,01 % à la vitesse de développement.
(Ce n'est pas vrai. Mais c'est proche.) 👻