👻 spectrIDA

बाइनरी में भूत की तरह।

एक स्थानीय, AI-संचालित रिवर्स इंजीनियरिंग सहायक: समानांतर IDA Pro विश्लेषण, AI फ़ंक्शन नामकरण, एक टर्मिनल जो बेकार नहीं है, एक Neo4j ज्ञान ग्राफ जो कुछ भी इसने कभी समझा है, और एक MCP सर्वर ताकि Claude सीधे उस ग्राफ पर खोज और श्रृंखला बना सके।

और अब — phantomrt के साथ — यह सिर्फ दीवारों को नहीं पढ़ता। यह उनके बीच से चलता है: उन फ़ंक्शन को एमुलेट, हुक और फ़ज़ करता है जिनका इसने नाम रखा, और वास्तव में क्या होता है वापस ग्राफ पर लिखता है।

``` spectrida analyze GameAssembly.dll --workers 16 ``` फ्रेंच में भाषा के मुद्दे सहित: [“अनुरोधित URL /blueteam0ps.html इस सर्वर पर नहीं मिला।”](https://github.com/blueteam0ps/Kitploit-Content-Translator/issues/9)``` ◈ spectrIDA ▸ GameAssembly.dll

✓ 00 ✓ 01 ✓ 02 ✓ 03 ▸ 04 · 05 · 06 · 07 ✓ 08 ✓ 09 ✓ 10 ✓ 11 ✓ 12 ✓ 13 ▸ 14 · 15

14/16 shards │ 141,203 functions found ████████████████████████████░░░░ 89% ~4s remaining

---

## यह क्या है

IDA Pro का ऑटो-विश्लेषण सिंगल-थ्रेडेड है। एक 34 MB il2cpp DLL पर वह *मिनटों* का होता है। spectrIDA बाइनरी को N शार्ड्स में विभाजित करता है, उन्हें idalib के माध्यम से समानांतर में चलाता है, एक `.i64` में विलय करता है, फिर एक फाइन-ट्यून किए गए 8B मॉडल को **हर फंक्शन का नाम** देने देता है — यह सब एक टर्मिनल UI से साइबरपंक थीम और बिल्कुल सही मात्रा में व्यंग्य के साथ।

यह अध्याय 1 है, और यह अपने आप में पूर्ण है: शुद्ध गति, यदि आप नहीं चाहते तो कोई AI आवश्यक नहीं।

अध्याय 2 आउटपुट को ऐसी चीज़ में बदल देता है जो सत्र से अधिक जीवित रहती है — एक Neo4j ग्राफ़ जिसमें एक MCP क्लाइंट (Claude, [pi](https://pi.dev), जो भी MCP बोलता है) वास्तव में रह सकता है, इसके बजाय कि आप डीकंपाइलर आउटपुट को एक बार में एक फंक्शन करके चैट विंडो में कॉपी-पेस्ट करें:```
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)

अध्याय 3 (phantomrt) वह आधा जोड़ता है जो स्थिर उपकरणों में कभी नहीं होता: यह कोड को चलाता है। बिना OS के किसी फ़ंक्शन का अनुकरण करता है (उन बाइनरी पर काम करता है जिन्हें आप लॉन्च भी नहीं कर सकते, जैसे Switch .nso), या लाइव प्रक्रिया को हुक करता है, या इसे फ़ज़ करता है — और परिणाम (crashes / needs live state / clean) को उसी ग्राफ़ नोड पर नाम के साथ टिकट लगाता है।

पूरी विस्तृत जानकारी, जिसमें अभी भी क्या बाकी है, अध्याय 2 और अध्याय 3 में दी गई है।

यह Ghidra नहीं है। यह एक कष्टप्रद काम (धीमी विश्लेषण + नामकरण) को तेज़ी से करता है, और इसका उपयोग करना वास्तव में मज़ेदार है। 199 डाउनलोड अपने आप में बोलते हैं।

कोई क्लाउड नहीं। कोई टेलीमेट्री नहीं। पूरी तरह से आपकी मशीन पर चलता है।

आंकड़े

कार्य	समय
Among Us DLL — एकल-थ्रेडेड IDA	~4 hours
Among Us DLL — spectrIDA (16 कार्यकर्ता)	67 seconds
153,649 फ़ंक्शन वाली बाइनरी — पूर्ण नामकरण पास	overnight
बाइनरी अवलोकन (यह चीज़ क्या करती है?)	~30 seconds

ये माप किस हार्डवेयर पर लिए गए: AMD Ryzen 7 5800X3D (8C/16T), 32 GB RAM, RTX 4070 12 GB. अलग हार्डवेयर समानांतर-विश्लेषण संख्याओं को बदल देता है (अधिक कोर, अधिक शार्ड, तेज़); नामकरण संख्याएं अधिकतर GPU-बाउंड होती हैं। 4-घंटे/67-सेकंड के Among Us आंकड़े अध्याय 2 से पहले के हैं और हर रिलीज़ में स्वतंत्र रूप से पुनः सत्यापित नहीं किए जाते — अपनी मशीन और बाइनरी के लिए संख्या चाहिए तो स्वयं spectrida analyze चलाएँ, परिणाम शार्ड घनत्व और बाइनरी आकार के साथ भिन्न होते हैं।

अध्याय 2 के विकास के दौरान वास्तव में पुनः सत्यापित संख्याएँ, समान हार्डवेयर:

वह NSO पंक्ति पुराने Among Us के '4 घंटे → 67 सेकंड' के दावे का वास्तविक समकक्ष है, इस रिलीज़ में 74,790-फ़ंक्शन वाली Switch बाइनरी पर ताज़ा मापा गया, कोई AI नामकरण शामिल नहीं (केवल demangling — populate=False). समानांतर चरण (16 कोर, ~55s) प्रारंभिक शार्डेड खोज करता है; मर्ज चरण (~143s) डिज़ाइन द्वारा एकल-थ्रेडेड है — एक IDA डेटाबेस, एक लेखक — इसलिए यदि आप उस भाग के दौरान Task Manager देखते हैं और 15 कोर को सोते हुए पाते हैं, तो यह बग रिपोर्ट नहीं है, यह भौतिकी है।

यहाँ एक ईमानदार संख्या प्राप्त करना अपने आप में एक छोटी डरावनी कहानी थी। NSO समर्थन का पहला संस्करण साफ चला, 0 से बाहर निकला, और गर्व से 727 फ़ंक्शन लौटाया एक बाइनरी के लिए जिसमें लगभग 75,000 हैं — यह क्रैश नहीं था, बस शानदार ढंग से, आत्मविश्वास से गलत था, जो किसी तरह से बदतर है। पता चला कि IDA के पास मूल NSO लोडर नहीं है, इसलिए फ़ाइल चुपचाप सादे x86 ("metapc") के रूप में लोड हो गई, भले ही Switch लॉन्च होने के बाद से ARM64 है। हर शार्ड ने शुद्ध AArch64 निर्देशों के खिलाफ x86 प्रोलॉग स्कैनर चलाया और जो कुछ भी गलती से एक "फ़ंक्शन" से मेल खाता था, उसे कॉल किया। आर्किटेक्चर को ठीक करने से अपने आप कुछ ठीक नहीं हुआ, क्योंकि बाइनरी मेमोरी में अभी भी LZ4-संपीड़ित थी — तो जो स्कैन किया गया उसका आधा, उदारता से, शोर था। और एक बार जब यह ठीक से डीकंप्रेस हो गया और AArch64 के रूप में चिह्नित हो गया, तब भी प्रत्येक शार्ड केवल बाइनरी के अपने छोटे टुकड़े के अंदर कॉल लक्ष्यों की खोज कर रहा था, हर उस कॉल को छोड़ रहा था जो शार्ड सीमा पार करती थी — और इस आकार की बाइनरी में यह उनमें से अधिकांश हैं। तीन बग, एक संख्या, और उनमें से किसी में भी अपवाद फेंकने की शालीनता नहीं थी। (हमने IDA के स्टैक-फ्रेम विश्लेषण को छोड़कर मर्ज चरण को कम करने का भी प्रयास किया — एक सुंदर गति वृद्धि और एक डेटाबेस मिला जहाँ Hex-Rays ने विनम्रता से इसके आधे को डीकंपाइल करने से इनकार कर दिया। इसे जल्दी वापस ले लिया गया। इसके बजाय बहुत छोटा, बहुत सुरक्षित FLIRT-signature स्किप रखा, जो लगभग ~3% का एक उचित लाभ देता है और कुछ भी नहीं तोड़ता, जो इस बिंदु तक एक व्यक्तित्व विशेषता की तरह लगा जो रखने लायक है।)

नामकरण सटीकता पर: यह Ghidra-ग्रेड का ग्राउंड ट्रुथ नहीं है, यह एक 8B मॉडल है जो स्यूडोकोड से अनुमान लगाता है। सामान्य हेल्पर्स/गेटर्स अच्छे से काम करते हैं; गहराई से गेम-विशिष्ट तर्क अधिक सिक्का उछालने जैसा है। जो कुछ भी यह गलत करता है उसका नाम बदलें — इसीलिए rename_function सीधे ग्राफ़ में वापस बनी रहती है।

विशेषताएं

समानांतर शार्डेड विश्लेषण — एड्रेस-स्पेस शार्ड्स में विभाजित करता है, N idalib इंस्टेंस चलाता है, एक .i64 में मर्ज करता है। कार्यकर्ता फ़्लैग, कॉन्फ़िग या env var के माध्यम से कॉन्फ़िगरेबल हैं।
प्लग करने योग्य प्रारूप समर्थन — PE, NSO (Switch), और ELF (.so/Linux) बिल्ट-इन शिप करते हैं; नया जोड़ना एक एकल फ़ाइल है, कोई कोर परिवर्तन नहीं। spectrida formats पंजीकृत प्रारूपों को सूचीबद्ध करता है। देखें नया बाइनरी प्रारूप जोड़ना।
AI फ़ंक्शन नामकरण — फाइन-ट्यून किया गया Qwen3-8B स्थानीय रूप से Ollama के माध्यम से चलता है, नामों को टोकन-दर-टोकन स्ट्रीम करता है। N दबाएँ। इसे सोचते हुए देखें। नाम प्रकट होता है।
बैच नामकरण — B सूची में हर sub_* फ़ंक्शन का नाम रखने के लिए। चले जाएँ। वापस आएँ।
बाइनरी अवलोकन — O दबाएँ या spectrida overview file.i64 चलाएँ। मॉडल 120 नमूना फ़ंक्शन नाम पढ़ता है और आपको बताता है कि बाइनरी क्या करती है, इसके उपतंत्र क्या हैं, और कोई भी सुरक्षा-प्रासंगिक बात। 30 सेकंड में 153k-फ़ंक्शन IL2CPP रनटाइम की सही पहचान की।
कॉल चेन एक्सप्लोरर — C कॉलर्स और कैलीज़ दिखाता है। मॉडल नामकरण करते समय इन्हें संदर्भ के रूप में उपयोग करता है — Player$$TakeDamage द्वारा कॉल किया गया फ़ंक्शन एक अलग फ़ंक्शन से बेहतर नाम पाता है।

स्थापना```bash

pip install spectrida

आवश्यकताएँ: **IDA Pro 9.x** के साथ 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

कमांड्स```bash

analyze a binary from scratch

spectrida analyze GameAssembly.dll spectrida analyze GameAssembly.dll --workers 8 # custom worker count

open an existing .i64 in the browser

spectrida open file.i64

ask the AI what this binary is

spectrida overview file.i64 spectrida overview file.i64 --addr 0x10001000 --addr 0x10353fd0 # include specific functions

export function names

spectrida export file.i64 -f idc # IDA script — apply names to any install spectrida export file.i64 -f json # full dump with addresses + sizes spectrida export file.i64 -f csv # spreadsheet spectrida export file.i64 -f symbols # addr name pairs spectrida export file.i64 --named-only # skip sub_* functions

check Ollama + model status

spectrida serve

re-run the setup wizard

spectrida onboard

---

## TUI कुंजियाँ

| कुंजी | कार्य |
|-------|-------|
| `N` | चयनित फ़ंक्शन का नाम — AI परिणाम लाइव स्ट्रीम करता है |
| `R` | नाम बदलें — AI सुझाव से पूर्व-भरा हुआ |
| `D` | डीकम्पाइल्ड स्यूडोकोड (Hex-Rays) टॉगल करें |
| `C` | कॉल श्रृंखला — कॉल करने वाले और कॉल किए जाने वाले |
| `B` | वर्तमान सूची में सभी `sub_*` फ़ंक्शन को बैच-नाम दें |
| `O` | अवलोकन — पूरे बाइनरी का AI सारांश |
| `/` | फ़ज़ी खोज |
| `?` | सहायता |
| `Q` | बाहर निकलें |

---

## प्रोग्रामेटिक API

कोई TUI आवश्यक नहीं — स्क्रिप्ट, Claude Code, नोटबुक, या किसी भी चीज़ से spectrIDA चलाएं:```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())

मॉडल

hf.co/gdfhhjk/spectrida-re-gguf — Qwen3-8B reverse engineering के लिए फाइन-ट्यून किया गया।

प्रशिक्षित किया गया:

x86/x64 असेंबली → कॉल-चेन संदर्भ के साथ फ़ंक्शन नाम जोड़े
jtsylve/ida-mcp से टूल कॉल ट्रेसेस — हेडलेस IDA जिसमें idalib है
कोडबेस कॉन्टेक्स्ट सर्वर से विस्तारित संदर्भ तर्क ट्रेसेस

प्रशिक्षण दृष्टिकोण: न्यूरॉन-लक्षित SFT + GRPO। केवल RE-प्रासंगिक न्यूरॉन्स को ट्यून किया जाता है — आधार Qwen3 ज्ञान बरकरार रहता है, आपने बस ऊपर एक बहुत विशिष्ट कौशल जोड़ा है।

Ollama के माध्यम से स्थानीय रूप से चलता है। GGUF — CPU, GPU, या दोनों पर काम करता है।

यह किसके लिए है

आप किसी चीज़ को रिवर्स कर रहे हैं। आपके पास 150,000 फ़ंक्शन वाला एक बाइनरी है। शायद 2,000 के पास मेटाडेटा से नाम हैं। बाकी 148,000 sub_XXXXXXXX हैं। आप नेटवर्क कोड ढूंढना चाहते हैं। आप इसे grep नहीं कर सकते क्योंकि किसी के पास अभी तक नाम नहीं है।

एक मानव RE प्रति घंटे ~50-100 फ़ंक्शन नाम दे सकता है यदि वे तेज़ हों। उस दर पर, 150k फ़ंक्शन = 3 साल।

spectrIDA उन्हें रातों-रात नाम देता है। पूरी तरह से नहीं — सामान्य फ़ंक्शन पर शायद 70% सटीकता, मॉडल द्वारा पहचाने जाने वाले पैटर्न पर बहुत अधिक। लेकिन अब 148k sub_ फ़ंक्शन के बजाय आपके पास network_send_packet, serialize_player_state, validate_checksum हैं — और आप जानते हैं कि कहाँ देखना है।

यह एक कुशल रिवर्स इंजीनियर को प्रतिस्थापित नहीं करता है। यह उबाऊ 80% करता है ताकि आप दिलचस्प 20% पर ध्यान केंद्रित कर सकें। यह ओरिएंटेशन लेयर है।

वास्तविक उपयोग के मामले:

गेम मॉडिंग — 150k-फ़ंक्शन बाइनरी में भौतिकी प्रणाली मिनटों में खोजें, दिनों में नहीं
सुरक्षा अनुसंधान — मैलवेयर ट्राइएज, बाइनरी की वास्तुकला को जल्दी से समझें
CTF — समय का दबाव, आप जो देख रहे हैं उसे तुरंत जानने की आवश्यकता
कोई भी जिसने sub_140001234 को 20 मिनट तक घूरते हुए सोचा हो इससे बेहतर तरीका होना चाहिए

कॉन्फ़िगरेशन

~/.spectrida/config.toml:```toml [ida] idalib = "C:/Program Files/IDA Professional 9.1" output_dir = "~/.spectrida/output"

[ollama] base_url = "http://localhost:11434" model = "spectrida-re" # any ollama model name works

[pipeline] workers = 16

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

---

## नया बाइनरी फॉर्मेट जोड़ना

फॉर्मेट समर्थन एक प्लगइन सिस्टम है, न कि if/elif शाखाओं का ढेर — PE, NSO, और ELF सभी `spectrida/analysis/formats/` के अंतर्गत फ़ाइलें हैं, स्वचालित रूप से खोजी जाती हैं। वर्तमान में क्या पंजीकृत है, यह देखने के लिए `spectrida formats` चलाएँ।```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

एक फ़ॉर्मैट हैंडलर का कार्य संकीर्ण है — एक फ़ाइल देखें और कहें कि क्या आप उसके मालिक हैं, फिर उसके कोड लेआउट का वर्णन करें। बाकी सब कुछ (शार्डिंग रणनीति, GPU प्रस्तावना स्कैनिंग, शार्ड्स को एक .i64 में मर्ज करना) एक बार, सामान्य रूप से, फ़ॉर्मैट पैकेज के बाहर संभाला जाता है। NSO पूर्ण उदाहरण है: इसका LZ4 डीकंप्रेस + idaapi mem2base/add_segm लॉजिक पहले से ही nso_loader.py में रहता था (अध्याय 2 के इतिहास से गलत-आर्क/अभी भी संपीड़ित/स्थानीय रूप से अंध प्रवेश बिंदु बगों के लिए फिक्स) — formats/nso.py एक पतला एडाप्टर है जो उस मौजूदा, मान्य मॉड्यूल को FormatHandler अनुबंध के माध्यम से उजागर करता है, पुनर्लेखन नहीं।

एक फ़ॉर्मैट जोड़ने के लिए, spectrida/analysis/formats/ में एक नई फ़ाइल डालें और कुछ नहीं। parallel_analyze.py, shard_worker.py, या रजिस्ट्री में कोई संपादन नहीं — यह निर्देशिका को स्कैन करके किसी भी मॉड्यूल को ढूंढ लिया जाता है जो एक HANDLER इंस्टेंस को एक्सपोज़ करता है।```python

spectrida/analysis/formats/myformat.py

from spectrida.analysis.formats.base import FormatHandler, PreparedImage, Section

class MyFormatHandler(FormatHandler): name = "MYFMT"

@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: ...

HANDLER = MyFormatHandler()

| Method | आवश्यक? | यह क्या करता है |
|---|---|---|---|
| `sniff(header, path)` | हाँ | मैजिक-बाइट/एक्सटेंशन जाँच — क्या यह हैंडलर फ़ाइल का स्वामी है? |
| `prepare(path, workdir)` | हाँ | एक `PreparedImage` लौटाएँ: idalib द्वारा खोली जाने वाली फ़ाइल + इसकी सेक्शन तालिका |
| `post_open()` | नहीं (डिफ़ॉल्ट no-op) | उन फ़ॉर्मेटों के लिए मैन्युअल सेगमेंट सेटअप जिनमें कोई मूल IDA लोडर नहीं है (`nso.py` देखें) |
| `make_shard_binary(image, dst, va_start, va_end)` | नहीं (डिफ़ॉल्ट काम करता है) | केवल तभी ओवरराइड करें जब शार्ड के बाहर के सेक्शन बाइट्स को शून्य करना आपके फ़ॉर्मेट के लिए गलत हो (`nso.py` देखें — संपीड़ित फ़ाइल को कभी शून्य न करें) |
| `code_range(image)` | नहीं (डिफ़ॉल्ट काम करता है) | केवल तभी ओवरराइड करें जब "`is_code` सेक्शनों का न्यूनतम/अधिकतम" सही उत्तर न हो |
| `read_bytes(image, va_start, va_end)` | नहीं (डिफ़ॉल्ट काम करता है) | तब ओवरराइड करें यदि `prepare()` पहले से ही प्रासंगिक बाइट्स को डिस्क के बजाय मेमोरी (NSO) में रखता है |
| `global_entry_points(image, text_start, text_end)` | नहीं (डिफ़ॉल्ट: None) | केवल तभी ओवरराइड करें जब प्रति-शार्ड स्थानीय स्कैन वास्तविक एंट्री पॉइंट्स को पकड़ न पाए — NSO को इसकी आवश्यकता है क्योंकि AArch64 लीफ फ़ंक्शन केवल बाइनरी में कहीं और देखे गए BL लक्ष्यों के माध्यम से खोजे जा सकते हैं, स्थानीय प्रोलॉग स्कैन से नहीं |

सबसे सरल संभव हैंडलर (शुद्ध हेडर पार्सिंग, कोई ओवरराइड नहीं) के लिए `formats/pe.py` देखें, और पूर्ण मामले (डीकंप्रेसन + मैन्युअल सेगमेंट सेटअप + प्रत्येक ओवरराइड को शामिल करता है) के लिए `formats/nso.py` देखें।

`spectrida.formats` एंट्री-पॉइंट समूह के माध्यम से, तृतीय-पक्ष पैकेज spectrIDA के स्रोत को बिल्कुल छुए बिना भी एक हैंडलर पंजीकृत कर सकते हैं:```toml
# in a separate package's pyproject.toml
[project.entry-points."spectrida.formats"]
myformat = "spectrida_myformat_plugin:HANDLER"

फ़ॉर्मैट सिस्टम के लिए परीक्षण कवरेज tests/test_formats.py में है — शुद्ध Python, IDA/idalib की आवश्यकता नहीं, इसलिए यह CI में चलता है।

अध्याय 2 — भूत बात करना सीखता है

अध्याय 1 एक तेज़, मज़ेदार IDA था। अध्याय 2 एक टीममेट के रूप में spectrIDA है: एक स्थायी, क्वेरी करने योग्य ज्ञान ग्राफ जो इसके द्वारा नामित प्रत्येक फ़ंक्शन का है, और एक MCP सर्वर ताकि Claude (या कोई भी MCP क्लाइंट — pi भी काम करता है) सीधे उसमें खोज और तर्क कर सके, बजाय इसके कि आप डीकंपाइलर आउटपुट को चैट विंडो में कॉपी-पेस्ट करें।```bash spectrida install mcp

बस इतना ही। यह क्लॉड कोड और पाई के साथ सर्वर को स्वचालित रूप से पंजीकृत करता है (यदि बेयर `pip install spectrida` ने उन्हें छोड़ दिया तो `mcp` + `neo4j` को खींचते हुए), उनका कॉन्फिग लिखता है, और आपको बताता है कि आपको कौन सा रीस्टार्ट चुकाना है।

**जब Neo4j चल रहा होता है (`spectrida` कॉन्फिग का `[graph]` सेक्शन, या बस इसे स्थानीय इंस्टेंस पर पॉइंट करें), तो क्लॉड को वास्तव में यह मिलता है:**

- `search_functions` / `get_function` / `get_callees` / `get_callers` / `trace_chain` — तेज़, कैश्ड ग्राफ रीड्स। `get_function` स्यूडोकोड **और** डिसअसेंबली लौटाता है (सटीक इंस्ट्रक्शन बाउंड्रीज़ और ऑपरेंड — जो स्यूडोकोड लेयर आपको नहीं दे सकता, जो उस समय महत्वपूर्ण हो जाता है जब आप "यह क्या करता है" से "मैं इसे वास्तव में कहां पैच करूंगा" पर जाते हैं) प्लस इनलाइन कॉलर्स/कॉलिज़, ताकि क्लॉड यह देखकर गहराई में जाने का निर्णय ले कि क्या कोई कॉली अभी भी `sub_*` है ठीक उसी प्रतिक्रिया में — बिना किसी अतिरिक्त राउंड ट्रिप के यह पता लगाने के लिए कि देखने के लिए और कुछ नहीं है।
- `get_full_pseudocode` / `rename_function` — लाइव, आधिकारिक रीड्स/राइट्स सीधे `.i64` पर जब कैश्ड स्निपेट पर्याप्त नहीं है या कोई नाम आखिरकार पता चल गया है।
- `analyze_binary` — इसे एक बाइनरी दें जो इसने कभी नहीं देखी (PE या NSO, दोनों तरह से समानांतर-शार्डेड) और यह पूरी पाइपलाइन चलाता है — विश्लेषण → डिमैंगल (Itanium *और* MSVC) → वास्तव में स्ट्रिप किए गए बचे हुए का AI-नामकरण → यह सब ग्राफ में डालना — एक बैकग्राउंड जॉब के रूप में जिसे आप पोल करते हैं, ताकि कई मिनट का रन कभी बातचीत को अवरुद्ध न करे।
- `doctor` / `start_all` — चैट छोड़े बिना llama-server + Neo4j की जाँच करें या बूट करें। यदि llama-server स्वयं कहीं स्थापित नहीं है, तो `start_all` पहले winget (Windows) या brew (macOS) के माध्यम से इसे प्राप्त करता है — कोई अलग llama.cpp डाउनलोड/सेटअप की आवश्यकता नहीं।

यह जादू नहीं है — एक फंक्शन जो अभी भी `sub_140001234` है क्योंकि किसी ने इसे अभी तक नहीं देखा है, वह अभी भी `sub_140001234` है। लेकिन ग्राफ वह सब कुछ याद रखता है जो मॉडल ने *समझ लिया* है, हमेशा के लिए, सत्रों के पार, और क्लॉड इसे एक सहकर्मी की तरह चल सकता है जिसने पहले ही कोडबेस पढ़ लिया है, बजाय एक बार में एक फंक्शन को घूरने के।

**अभी आने वाला है:**

- **डीप कॉन्टेक्स्ट नेमिंग** — कॉल ट्री को N स्तर गहरा फॉलो करें, मॉडल को पूरी चेन फीड करें। एक फंक्शन जो `encrypt_block` से 3 हॉप दूर है, उसे पता होना चाहिए कि वह क्रिप्टो पथ में है।
- **डिऑबफस्केशन** — TigressVM पैटर्न डिटेक्शन और हैंडलर ट्रेसिंग
- **वास्तविक पैचिंग** — डिसअसेंबली अब ग्राफ में है ताकि एक एजेंट बाइट-स्तरीय पैच की योजना बना सके; "यहाँ बदलने के लिए सटीक इंस्ट्रक्शन है" को "और यहाँ राइट है" में बदलना अगला कदम है।

---

## अध्याय 3 — भूत दीवारों के पार चलता है

अध्याय 1 और 2 बाइनरी को पढ़ते हैं और इसे याद रखते हैं। लेकिन एक फंक्शन को पढ़ना आपको बताता है कि वह *क्या है*, कभी नहीं कि वह *क्या करता है* जब आप ट्रिगर दबाते हैं। अध्याय 3 — [**phantomrt**](https://pypi.org/project/phantomrt/) — ट्रिगर दबाता है।```bash
pip install "spectrida[atlas]"

यह पहले से नामित एक फंक्शन spectrIDA लेता है और उसके साथ तीन भयावह चीजों में से एक करता है:

एमुलेट करें (Unicorn, कोई OS नहीं, कोई भी आर्क) — यह एकमात्र दरवाजा है जो उन बाइनरी पर काम करता है जिन्हें आप लॉन्च नहीं कर सकते, जैसे कि Switch .nso या Android .so।
लाइव-इंस्ट्रूमेंट करें (Frida) — चल रही प्रक्रिया से जुड़ें और वास्तविक आर्ग्स और रिटर्न वैल्यू देखें, क्योंकि फंक्शन्स का इमुलेशन केवल हाथ खड़े कर सकता है जिन्हें वास्तविक स्थिति की आवश्यकता होती है।
फज़ करें — उत्परिवर्तित इनपुट (आपके द्वारा लाए गए बीज, या वे जो यह बाइनरी से ही निकालता है), क्रैश को पकड़ें, पुनरुत्पादन करने वाले इनपुट को रखें।

फिर यह फैसले को उसी Neo4j नोड पर dyn_* प्रॉपर्टीज के रूप में स्टैंप करता है, ताकि ग्राफ पर चलने वाला एजेंट एक ही स्थान पर नाम और व्यवहार देखे। छह नए MCP टूल — emulate_function, hunt_crashes, live_trace, dynamic_overview, risk_functions, learn_vm — सभी एक ही ग्राफ का समर्थन करते हैं। रीज़निंग कॉर्नर जो भी LLM चला रहा है; phantomrt यह सुनिश्चित करता है कि उसके पास वाइब्स के बजाय वास्तविक रनटाइम तथ्य हों।``` spectrIDA (names it) ─▶ phantomrt (runs it) ─▶ graph (dyn_status / crash / live args) ─▶ the agent reasons

**और, ऊपर बताई गई NSO डरावनी कहानी की भावना में:** पहली वास्तविक बग-शिकार ने ईमानदारी से *कुछ नहीं* पाया — और इसका कारण किसी क्रैश से भी अधिक दिलचस्प था। एक वास्तव में पुराने, वास्तव में कमज़ोर FreeType पर लक्षित करने पर, ब्लाइंड फ़ज़िंग को शून्य मिला। कवरेज-निर्देशित फ़ज़िंग ने तब विजयी रूप से **64,000 edges** कवर होने की सूचना दी — जो झूठ था, क्योंकि बाइनरी PIE थी और ASLR चुपचाप हर रन पर पतों को फिर से रैंडमाइज़ कर रहा था, इसलिए "नया कवरेज" ज़्यादातर लोडर द्वारा पत्तों को फेरबदल करना था। ASLR अक्षम करें, ईमानदार संख्या घटकर एक *वास्तविक* 727 edges पर आ जाती है, और वहीं रुक जाती है — क्योंकि हर सीड TrueType फ़ॉन्ट था, इसलिए फ़ज़र एक पार्सर के अंदर फँस गया था और संरचनात्मक रूप से उस CFF/Type1/BDF कोड में नहीं जा सकता था जहाँ बग वास्तव में रहते हैं। सुधार एक होशियार म्यूटेटर नहीं था, बल्कि बेहतर सीड थे: एजेंट ने वास्तविक OpenType/Type1/BDF नमूने लाए, कवरेज एक भी फ़ज़ इटरेशन से पहले 727 → 4,013 पर पहुँच गया, और इसने ठीक से एक्सप्लोर किया। बजट में अभी भी कोई क्रैश नहीं — जो एक कोर पर 3 मिनट के रन की ईमानदार स्थिति है, जबकि आमतौर पर यह कार्य घंटों लगता है। मशीनरी असली है। इसने अपने *खुद के* नकली नंबर को पकड़ा, उसे रिपोर्ट करने के बजाय। यही पूरी बात है।

**ईमानदार भूत अस्वीकरण:** phantomrt `0.1.0` है। अल्फ़ा। यह एक ठोस डायनामिक लेयर है, कोई जादुई बग ऑरेकल नहीं — इसने एक खिलौना लक्ष्य में लगाए गए बग्स को तुरंत ढूँढ लिया, और वास्तविक लक्ष्यों पर यह ईमानदारी से बताता है कि यह कब अटका है (`needs_state`), कब कोई क्रैश केवल एक *उम्मीदवार* है (जाएँ और सत्यापित करें कि पॉइंटर वास्तव में इनपुट-नियंत्रित है), और कब इसे बस अधिक समय और बेहतर सीड की आवश्यकता है। स्विच बाइनरीज़ लाइव नहीं चलती — Frida को कुछ ऐसा चाहिए जिसे वह लॉन्च कर सके — तो वहाँ, एमुलेशन ही एकमात्र दरवाजा है और यह अक्सर `needs_state` कहेगा। यह ईमानदार है, टूटा हुआ नहीं।

यह जानबूझकर भारी अतिरिक्त है (`torch`, `unicorn`, `frida`) — बेस `pip install spectrida` इनमें से कुछ भी नहीं खींचता। स्रोत [`phantomrt/`](https://github.com/ggfuchsi-oss/spectrida-reverse_engineering_stack/blob/HEAD/phantomrt/) में रहता है; इसका अपना भूत-स्वाद वाला README [यहाँ](https://github.com/ggfuchsi-oss/spectrida-reverse_engineering_stack/blob/HEAD/phantomrt/README.md) है।

*स्थिर भूत आपके फ़ंक्शन के नाम बताता है। यह उनसे कबूल करवाता है।* 👻

---

## लाइसेंस

MIT। इसके साथ जो चाहे करें। अगर यह काम करता है, तो अच्छा।
अगर नहीं करता, तो GGUF क्वांटाइज़ेशन को दोष दें।

नफरत, कॉफ़ी और एक RTX 4070 के साथ बनाया गया।
मॉडल के शून्य मार्केटिंग के साथ 199 डाउनलोड हैं। प्रत्येक डाउनलोड विकास गति में 0.01% जोड़ता है।
(यह सच नहीं है। लेकिन इसके करीब है।) 👻

test_small.dll (PE)	189	समानांतर विश्लेषण, 4 कार्यकर्ता, CLI	6.4s
test_small.dll (PE)	164	पूर्ण MCP पाइपलाइन (analyze + demangle + ग्राफ़ लेखन)	9.8s
main.nso — Mario Odyssey (NSO), 16 कार्यकर्ता	28,038 seed functions	समानांतर शार्डेड स्कैन चरण	54.5s
main.nso — Mario Odyssey (NSO), 16 कार्यकर्ता	74,790 कुल फ़ंक्शन	+ मर्ज/पूर्ण-विश्लेषण चरण	143.1s
main.nso — Mario Odyssey (NSO), 16 कार्यकर्ता	74,790 कुल फ़ंक्शन	एंड-टू-एंड वॉल टाइम	197.6s
main.nso — Mario Odyssey (NSO)	74,790	केवल demangling के माध्यम से हल किया (Itanium ABI, मुफ्त, कोई AI नहीं)	67,300 (90.0%)

सबसे लोकप्रिय

spectrIDA-Reverse_Engineering_Stack