REx@Skill - बाइनरी भेद्यता खोज के लिए एजेंटिक रिवर्स इंजीनियरिंग एक्सक्यूशन स्किल
Ghidra · radare2 · rizin · qemu-user · angr · z3 · AFL++ · valgrind · capa · Unicorn · Triton · Frida · semgrep · clang · Python · Nix
सभी पिन किए गए, सभी प्रतिलिपि-सक्षम
1 · Claude Code — यदि आपके पास पहले से है तो छोड़ दें।```bash curl -fsSL https://claude.ai/install.sh | bash
**2 · REx@Skill** — 1 स्किल, 12 संदर्भ, **7 सबएजेंट**, **33 स्क्रिप्ट**।```bash
curl -fsSL https://raw.githubusercontent.com/tihanyin/REx-skill/main/install.sh | sh
3 · एक बाइनरी का विश्लेषण करें।```bash claude
/re-analyze path/to/binary # one target /re-analyze path/to/directory/ # a whole corpus, evidence gathered in parallel
<div align="center">
<sub><code>install.sh</code> केवल <code>~/.claude/</code> में लिखता है — स्किल और उसकी 33 पाइपलाइन स्क्रिप्ट्स, 7 एजेंट्स, <code>/re-analyze</code>।<br>यह आपके लिए Claude Code कभी इंस्टॉल नहीं करता; जो कुछ भी यह ओवरराइट करेगा उसका बैकअप लेता है, और <code>--uninstall</code> इसे साफ़ तौर पर हटा देता है।</sub>
</div>
<br>
<details>
<summary><b>क्लोन करना पसंद करेंगे?</b> · <i>या कहीं और इंस्टॉल करें, या इसे हटा दें</i></summary>```bash
git clone https://github.com/tihanyin/REx-skill && cd REx-skill
./install.sh # into ~/.claude
./install.sh --prefix ~/.config/claude # somewhere else
./install.sh --uninstall # take it back out
Ghidra · radare2 · rizin · qemu-user · angr · z3 · AFL++ · valgrind · capa
Unicorn · Triton · Frida · semgrep · clang · Python · Nix · Linux · Claude
REx@Skill रिवर्स-इंजीनियरिंग विशेषज्ञों द्वारा एकत्रित अत्याधुनिक टूल्स का उपयोग करता है। इनमें से प्रत्येक इस सेट में इसलिए है क्योंकि यह ज्ञात बेंचमार्क और वास्तविक बाइनरी-विश्लेषण चुनौतियों पर अपनी जगह बनाता है — न कि इसलिए कि इसे इंस्टॉल करना सुविधाजनक था। यहाँ कुछ भी पुनः कार्यान्वित नहीं किया गया है; स्किल का अपना काम यह जानना है कि सामने आए प्रश्न का उत्तर कौन-सा टूल देता है, और उसके उत्तर का मूल्य क्या है।
| टूल | यह क्या करता है |
|---|---|
| Ghidra | एक संकलित बाइनरी को वापस पठनीय C में बदलता है |
| radare2 / rizin | एक दूसरा डीकंपाइलर, पहले की क्रॉस-चेक के लिए उपयोग किया जाता है |
| qemu-user | ARM, MIPS, PowerPC और RISC-V बाइनरी को सामान्य x86 मशीन पर चलाता है |
| z3 | एक गणितीय सॉल्वर — सिद्ध करता है कि कोई इंडेक्स अपने बफ़र से बाहर जा सकता है, या कोई भाजक शून्य हो सकता है |
| angr | यह पता लगाता है कि कौन-सा इनपुट कोड की किसी दी गई पंक्ति तक पहुँचेगा |
| AFL++ | प्रोग्राम को क्रैश कराने के लिए लाखों जनरेट किए गए इनपुट फेंकता है |
| valgrind | उन मेमोरी बग्स को पकड़ता है जो अन्यथा कोई दृश्य त्रुटि नहीं देते |
| libdislocator | बफ़र से एक बाइट आगे पढ़ने पर तुरंत क्रैश करा देता है |
| capa | बताता है कि बाइनरी क्या कर सकती है: एन्क्रिप्ट करना, सॉकेट खोलना, प्रोसेस में इंजेक्ट करना |
| floss | छिपे हुए टेक्स्ट को ढूँढता है जो साधारण strings से छूट जाता है |
| Unicorn | प्रोग्राम चलाए बिना, आपके चुने हुए इनपुट पर एक ही फ़ंक्शन चलाता है |
| Triton | रन के दौरान हमलावर-नियंत्रित डेटा कहाँ यात्रा करता है, इसका पीछा करता है |
| Frida | प्रोग्राम के चलते समय उसे देखता और बदलता है |
| semgrep / cppcheck | डीकंपाइल किए गए C को ज्ञात खराब पैटर्न के लिए स्कैन करते हैं |
| pwntools | ऑफ़सेट, ELF पार्सिंग और एक्सप्लॉइट कार्य के लिए हेल्पर लाइब्रेरी |
ये वे सटीक वर्शन हैं जिनके साथ इसे बनाया और मापा गया था:
Ghidra 12.1.2 · radare2 6.2.0 · rizin 0.9.1 · qemu-user 11.1.0 + 9 cross-sysroots · angr 9.2.154 · z3 4.16.0 · AFL++ 5.00c · valgrind 3.27.1 · capa 9.4.0 · Unicorn 2.1.4 · Triton 3.7.0 · Frida 17.17.0 · clang 21.1.8 · semgrep 1.172.0 · floss 3.1.1 · yara 4.5.7 · binwalk 3.1.0 · pwntools 4.15.0 · cppcheck 2.21.1
इनमें से प्रत्येक वैकल्पिक है। scripts/capabilities.sh बताता है कि इस मशीन में क्या है,
प्रत्येक स्क्रिप्ट उस टूल का नाम बताती है जो उसे नहीं मिला, और अनुपस्थित टूल विश्लेषण को
limitations में सीमित कर देता है, बजाय चुपचाप विफल होने के।
तीन कमांड और ऊपर दिए गए हर टूल आपके PATH पर हैं, ठीक इन्हीं वर्शन पर —
कुछ ढूँढना नहीं, कुछ आधा-कॉन्फ़िगर छोड़ना नहीं।```bash
git clone https://github.com/tihanyin/REx-skill 2>/dev/null || git -C REx-skill pull
cd REx-skill
curl --proto '=https' --tlsv1.2 -sSf -L https://install.determinate.systems/nix | sh -s -- install --no-confirm
nix develop ./devshell
scripts/capabilities.sh
| | |
|---|---|
| **0** | रेपो को क्लोन करता है, या यदि आपके पास पहले से है तो उसे अपडेट करता है — ऊपर दिया गया one-line skill installer क्लोन पीछे **नहीं** छोड़ता, यह एक अस्थायी checkout से काम करता है और उसे हटा देता है, इसलिए toolchain और scripts को अपना अलग क्लोन चाहिए |
| **1** | Nix इंस्टॉल करता है, वह package manager जो pinning करता है — फिर **एक नया terminal खोलें**। *पहले से Nix है? इसे छोड़ दें।* मौजूदा install पर installer दोबारा चलाने पर `Found existing plan in /nix/receipt.json` के साथ विफल होता है, जो यह दर्शाता है कि यह आपके पास पहले से मौजूद चीज़ को छूने से इनकार कर रहा है, यह ठीक करने लायक कोई error नहीं है |
| **2** | shell में प्रवेश करता है, repo root से ताकि `scripts/` हाथ में रहे। पहली बार बहुत कुछ डाउनलोड होता है; हर बार उसके बाद कुछ सेकंड |
| **3** | इसकी पुष्टि करता है: `ghidra pyghidra r2 rizin`, `qemu-user architectures: 7`, `angr`, `z3`, `afl` — एक साधारण मशीन जो `MISS` लाइनें देती है, उसके बजाय |
`exit` आपके `PATH` को बिल्कुल वैसा ही वापस कर देता है जैसा वह था। *Ubuntu 22.04.5 LTS
(x86-64), Determinate Nix 3.22.4 पर परीक्षित।*
<details>
<summary><b>आखिर toolchain को pin क्यों करें?</b></summary>
- **तुलनीय runs।** decompiler का output *ही* analyst का input है। दो लोग
दो अलग Ghidra versions पर एक ही प्रयोग नहीं कर रहे होते, और न ही कोई दूसरे का
परिणाम जाँच सकता है।
- **आपकी मशीन पर कुछ भी इंस्टॉल नहीं।** Nix हर package को उस hash के अंदर रखता है
जिसने उसे बनाया, इसलिए shell में प्रवेश करने से `PATH` बदलता है और कुछ नहीं। shell
छोड़ें और आपका सिस्टम बिल्कुल वैसा ही रहता है जैसा वह था।
- **यह पाँच साल बाद भी काम करता है।** तीन pinned revisions पूरे
toolchain को फिर से बनाते हैं, यही चीज़ किसी प्रकाशित संख्या को बाद में फिर से
जाँचने योग्य बनाती है।
तीन revisions पूरे toolchain को किसी भी मशीन पर, भविष्य में किसी भी समय, फिर से बनाते हैं:```
nixpkgs ffb3c9b700e759be2ef13237c9d8f953b32a1e46
nixpkgs-angr ac62194c3917d5f474c1a844b6fd6da2db95077d
capa-rules v9.4.0
devshell/flake.lock ही प्रमाण है; devshell/DEVSHELL.md
हर टूल को उसके संस्करण और उसके उद्देश्य के साथ सूचीबद्ध करता है।
REx@Skill यह तय करने की एक विधि है कि किसी बाइनरी में कोई दोष है या नहीं — और उसे सिद्ध करना। सात सबएजेंट इसे चलाते हैं, एक ही साक्ष्य निर्देशिका साझा करते हुए।
एक एजेंट बाइनरी को साक्ष्य में बदलता है: डीकंपाइल किया गया C, डिसअसेम्बली, स्ट्रिंग्स, यह मैप कि कौन-सा कोड कहाँ पहुँचता है, और जब आप वास्तव में इसे चलाते हैं तो क्या होता है। फिर पाँच एजेंट उस साक्ष्य को एक ही समय में पढ़ते हैं, प्रत्येक एक अलग प्रकार के दोष की खोज करता है, और उनमें से कोई भी यह नहीं देख सकता कि दूसरों ने क्या पाया — एक ही डीकंपाइलर साझा करने वाले पाँच पाठक वही गलतियाँ करते हैं, इसलिए उन्हें अलग रखना एक राय को पाँच बार दोहराने के बजाय पाँच स्वतंत्र पठन प्रदान करता है। एक सातवाँ पहले कोड पढ़ता है, फिर उनके निष्कर्ष, और तय करता है कि कौन-से टिकते हैं।
किसी चीज़ को बग के रूप में तब तक रिपोर्ट नहीं किया जाता जब तक चार चीज़ें बाइनरी में नामित और स्थित न हों: हमलावर-नियंत्रित डेटा कहाँ प्रवेश करता है (source), वह ऑपरेशन जिसे यह तोड़ सकता है (sink), वह जाँच जिसे इसे रोकना चाहिए था (broken guard), और किसे नुकसान होता है (affected principal)। एक भी छूट गया तो यह एक अप्रमाणित लीड के रूप में जाता है, निष्कर्ष के रूप में नहीं।
हर रन वही तीन चीज़ें देता है: निष्कर्ष, क्या बाहर रखा गया और क्यों, और होस्ट क्या चला नहीं सका।
इस स्किलसेट का दस आर्किटेक्चर पर परीक्षण किया गया है — x86-64, i686, ARM, AArch64, MIPS और MIPS64 दोनों एंडियननेस में, 32-बिट PowerPC, RISC-V और Apple arm64 — ELF, PE और Mach-O, फर्मवेयर और रॉ ब्लॉब्स पर। यहीं कोई सीमा नहीं है: कोई भी आर्किटेक्चर जिसे आपका डीकंपाइलर लिफ्ट कर सकता है, दायरे में है।
| एजेंट | कब चलता है | एक पंक्ति में | |
|---|---|---|---|
| 01 | re-recon | पहले, अकेले | साक्ष्य निकालता है। बग नहीं खोजता — यहाँ कोई आत्मविश्वासी निष्कर्ष ही विफलता का तरीका है। |
| 02 | re-bughunt | हमेशा | इस बात का सबसे मज़बूत ईमानदार केस बनाता है कि कोई दोष मौजूद है। हर sink की गणना करता है। |
| 03 | re-safety | हमेशा | इसे सुदृढ़ सिद्ध करने का प्रयास करता है, और हर उस बाध्यता की रिपोर्ट करता है जिसे वह नहीं निभा सकता। |
| 04 | re-arithmetic | यदि यह इंडेक्स या साइज़ करता है | कॉल सीमाओं के आर-पार साइज़, इंडेक्स, चौड़ाई और साइन्डनेस — किसी के दिमाग में नहीं, बल्कि एक सॉल्वर द्वारा निपटाया गया। |
| 05 | re-lifecycle | यदि यह एलोकेट करता है | एलोकेशन, फ्री, स्वामित्व, इनिट और एरर पाथ। एरर पाथ वह है जिसे किसी ने टेस्ट नहीं किया। |
| 06 | re-logic | यदि यह प्रमाणित करता है | ऑथराइज़ेशन, स्टेट मशीन, क्रिप्टो, validate-here-use-there। grep करने के लिए कोई सिग्नेचर नहीं। |
| 07 | re-reconcile | अंत में, अकेले | किसी के भी निष्कर्ष पढ़ने से पहले कोड पढ़ता है, फिर निर्णय करता है और रिपोर्ट करता है। |
प्रति बाइनरी एक निर्देशिका, जिसका नाम <filename>-<first 8 hex of its SHA-256> है:```
results/
├── index.json every sha256 analysed -> its directory
└── httpd-4f2a9c1e/ <- "httpd", sha256 4f2a9c1e...
├── decomp/ decompiled C ├── reach/ source -> sink paths
├── disasm/ disassembly, real VAs ├── bounds/ arithmetic to discharge
├── meta/ function map + base ├── sanitize/ hostile-allocator runs
├── strings/ inventory, by family ├── fuzz/ coverage-guided search
├── dynamic/ crafted-input battery ├── quarantine/ text aimed at YOU
└── notes/ the threat model └── pipeline.json what ran, what did not
**नाम में हैश क्यों है।** किसी प्रोग्राम के दो बिल्ड एक ही फ़ाइलनाम साझा करते हैं लेकिन
SHA-256 नहीं, इसलिए साक्ष्य और बाइनरी चुपचाप अलग नहीं हो सकते: लक्ष्य को फिर से कंपाइल करें और
आपको एक प्रदूषित डायरेक्टरी के बजाय एक नई डायरेक्टरी मिलती है।
`pipeline_status.py` उस ट्री का ऑडिट करता है और रिपोर्ट करता है कि कौन से चरण कभी नहीं चले — क्योंकि एक
ऐसा चरण जो कभी नहीं चला, अपने पीछे कोई त्रुटि नहीं छोड़ता, केवल एक अनुपस्थित डायरेक्टरी, जो बिल्कुल
"चला, कुछ नहीं मिला" जैसा पढ़ा जाता है।
</details>
---
## 4. टूल इन्वेंटरी — कौन सा स्क्रिप्ट किसे कॉल करता है
#### डीकंपाइल और पढ़ें
| टूल | संस्करण | द्वारा उपयोग किया गया | किसलिए |
|---|---|---|---|
| **Ghidra** | 12.1.2 | `ghidra_export.py` `batch_decompile.sh` `decompile_addr.py` | डीकंपाइलर — भार वहन करने वाला टूल |
| **pyghidra** | 3.1.0 | वही तीन | इसे हेडलेस चलाना |
| radare2 | 6.2.0 | `run_tools.sh` `strings_report.py` `brief.py` | हर कमांड से JSON आउटपुट |
| rizin | 0.9.1 | `capabilities.sh` `preflight.sh` | एक **दूसरा** डीकंपाइलर — क्रॉस-चेक |
| binutils | 2.46 | `triage.py` `inventory.py` `run_tools.sh` | readelf, objdump, nm, strings, size |
| file | 5.48 | हर एंट्री पॉइंट | पहली कमांड, हर बार |
#### ट्राइएज — यह क्या है, यह क्या कर सकता है
| टूल | संस्करण | द्वारा उपयोग किया गया | किसलिए |
|---|---|---|---|
| **capa** | 9.4.0 | `run_tools.sh` `brief.py` | नियमों से क्षमताएँ, पतों के साथ |
| **floss** | 3.1.1 | `strings_report.py` | वे स्ट्रिंग्स जो `strings` नहीं देख सकता |
| yara | 4.5.7 | `run_tools.sh` `analyze.sh` | पैकर्स, क्रिप्टो कॉन्स्टेंट, लाइब्रेरी संस्करण |
| detect-it-easy | 3.21 | `run_tools.sh` | पैकर और कंपाइलर की पहचान |
| checksec | pwntools | `triage.py` `brief.py` | NX / RELRO / canary / PIE |
#### निष्पादित करें — सबसे बड़ा एकल लीवर
| टूल | संस्करण | द्वारा उपयोग किया गया | किसलिए |
|---|---|---|---|
| **qemu-user** | 11.1.0 | `dynamic_probe.py` `quick_dynamic.sh` | विदेशी-आर्किटेक्चर बाइनरी चलाएँ |
| **9 cross-sysroots** | glibc | `setup_sysroots.sh` | इनके बिना qemu एक विदेशी डायनामिक बाइनरी को लोड भी नहीं कर सकता |
| gdb / ltrace / strace | 17.2 | `capabilities.sh` इनकी रिपोर्ट करता है | ट्रेस; `ltrace` यहाँ सबसे कम उपयोग किया जाने वाला टूल है |
> एक मापे गए तुलना पर उसी मॉडल ने निष्पादन उपलब्ध होने पर लगभग **3× रिकॉल** स्कोर किया,
> बिना के मुकाबले। यह पंक्ति ही कारण है कि sysroots flake के साथ आते हैं।
#### मौन बग्स को मुखर बनाएँ
| टूल | संस्करण | द्वारा उपयोग किया गया | किसलिए |
|---|---|---|---|
| **valgrind** | 3.27.1 | `sanitize_run.sh` | उस बाइनरी के लिए ASan के सबसे निकट की चीज़ जिसे आप फिर से बिल्ड नहीं कर सकते |
| **AFL++** | 5.00c | `fuzz_target.sh` `quick_dynamic.sh` | कवरेज-निर्देशित फ़ज़िंग, QEMU मोड |
| libdislocator | AFL++ के साथ | `sanitize_run.sh` `quick_dynamic.sh` | प्रति-आवंटन पेज — एक मौन OOB रीड को फ़ॉल्ट में बदल देता है |
| clang | 21.1.8 | `triage.py` | लिफ्टेड कोड पर `-fsanitize=...` |
#### हल करें और अनुकरण करें
| टूल | संस्करण | द्वारा उपयोग किया गया | किसलिए |
|---|---|---|---|
| **z3** | 4.16.0 | `check_bound.py` | एक बाउंड्स दावे को निर्वहन करता है — 9 मोड्स प्लस एक जेनेरिक एस्केप हैच |
| **angr** | 9.2.154 | `symfn.py` | प्रति फ़ंक्शन सिंबॉलिक हार्नेस: हाइजैक, OOB राइट, डिवाइड-बाय-ज़ीरो |
| **unicorn** | 2.1.4 | `emulate.py` | आपके चुने हुए इनपुट्स पर एक ही फ़ंक्शन को अलग से चलाएँ |
| triton | 3.7.0 | उपलब्ध | एक ठोस ट्रेस पर कॉन्कॉलिक निष्पादन और टेंट |
| pwntools | 4.15.0 | `brief.py` `run_tools.sh` | `cyclic()` ऑफ़सेट्स, ELF/GOT पार्सिंग |
#### डीकंपाइल्ड C पर स्टैटिक विश्लेषण
| टूल | संस्करण | द्वारा उपयोग किया गया | किसलिए |
|---|---|---|---|
| cppcheck | 2.21.1 | `run_tools.sh` `analyze.sh` | उस कोड को सहन करता है जो कंपाइल नहीं होता — डीकंपाइलर आउटपुट नहीं होता |
| semgrep | 1.172.0 | `run_tools.sh` `analyze.sh` | पैटर्न नियम, किसी बिल्ड की आवश्यकता नहीं |
| flawfinder | 2.0.20 | `capabilities.sh` | शाब्दिक; राय वाला एक grep |
<details>
<summary><b>शेल में भी</b> — फ़र्मवेयर, फ़ॉर्मेट, शोषणीयता</summary>
`binwalk` 3.1.0 · `unsquashfs` · `sasquatch` · `jefferson` · `ubi_reader` ·
`kaitai-struct-compiler` 0.11 · `tshark` 4.6.8 · `hexyl` · `pev` 0.81 ·
`osslsigncode` · `diffoscope` 328 · `patchelf` 0.15.2 · `ROPgadget` 7.7 ·
`one_gadget` 1.9.0 · `honggfuzz` · `radamsa` 0.7 · `bitwuzla` 0.9.1 · `rr` 5.9.0 ·
`bpftrace` 0.26.0 · `upx` 5.2.0
हर संस्करण के साथ पूरी इन्वेंटरी: [`devshell/DEVSHELL.md`](https://github.com/tihanyin/rex-skill/blob/main/devshell/DEVSHELL.md)
</details>
---
## 5. इसे Claude के अलावा किसी और के साथ उपयोग करें
`general-skill/SKILL-RE.md` **एक स्व-निहित फ़ाइल** है — 3 750 पंक्तियों का सादा
Markdown जिसमें `name`/`description` फ्रंटमैटर है। Claude बंडल में जो कुछ भी है, वह सब
एक टुकड़े में: वही साक्ष्य मानक, वही पाइपलाइन, विदेशी आर्किटेक्चर को फ़ज़ करने के बारे में वही नियम।
रेपो को क्लोन करें ताकि `scripts/` इसके बगल में बैठे, फिर:
| रनर | कैसे |
|---|---|
| **Codex** | `AGENTS.md` को इस पर इंगित करें, या इसे सिस्टम प्रॉम्प्ट के रूप में पेस्ट करें |
| **opencode** | `opencode.json` में `{"instructions": ["SKILL-RE.md"]}` |
| **Cursor / Windsurf** | इसे प्रोजेक्ट नियम के रूप में ड्रॉप करें |
| **एक सादा API लूप** | यह बस Markdown है — इसे आगे जोड़ें |
| **एक इंसान** | यह एक पाठ्यपुस्तक की तरह पढ़ा जाता है; यही मुद्दा था |
> **दो रूप क्यों?** Claude बंडल एक 16 KB कोर प्लस बारह संदर्भ फ़ाइलें है जो
> मांग पर लोड होती हैं — छोटा कॉन्टेक्स्ट जब तक किसी विशिष्ट प्रश्न को किसी विशिष्ट
> अध्याय की आवश्यकता न हो। केवल Claude Code उन पॉइंटर्स का पालन करता है, इसलिए हर अन्य रनर को
> एकल फ़ाइल मिलती है।
---
---
## 6. अंदर क्या है```
.
├── claude-skill/ the Claude Code form
│ ├── skills/reverse-engineering/
│ │ ├── SKILL.md 16 KB core, loaded on every trigger
│ │ └── references/ 12 files, pulled in on demand
│ ├── agents/ 7 subagents
│ └── commands/ /re-analyze — orchestrates all three phases
│
├── general-skill/ the portable form
│ ├── SKILL-RE.md the whole methodology, one file, 32 sections
│ └── AGENTS.md points any agent at it
│
├── scripts/ 32 tools — the pipeline and its parts
├── devshell/ flake.nix + flake.lock + DEVSHELL.md
├── images/ logo and figures
└── install.sh one command into ~/.claude
यह स्किल कहीं भी चलती है जहाँ Claude Code चलता है — Linux, macOS, WSL। यह मार्कडाउन है:
कोर, 12 संदर्भ, 7 सबएजेंट्स और /re-analyze। इसमें कुछ भी
प्लेटफ़ॉर्म-विशिष्ट नहीं है, और स्क्रिप्ट्स पोर्टेबल Python और bash हैं। जो बदलता है वह है
उनके नीचे के टूल्स।
DEVSHELL Linux पर बनाया और परीक्षण किया गया है — x86-64 (Ubuntu 22.04.5 LTS) और aarch64। macOS वह जगह है जहाँ यह पतला हो जाता है, क्योंकि ग्यारह टूल्स Darwin पर बिल्कुल मौजूद नहीं हैं:
qemu-user Linux सिसकॉल्स का अनुवाद करता है, इसलिए यह परिभाषा से Linux है, और
नौ क्रॉस-आर्किटेक्चर सिसरूट्स इसके साथ जाते हैं।
इससे Mac पर क्या बचता है। हर स्टैटिक चरण: Ghidra डीकंपाइलेशन, radare2 और rizin, angr और z3, स्टैटिक विश्लेषक, ट्राइएज, स्ट्रिंग्स और रीचेबिलिटी। जो आप खोते हैं वह है एक्ज़ीक्यूशन — डायनामिक प्रोब, सैनिटाइज़र रन, फ़ज़िंग, और कोई भी विदेशी-आर्किटेक्चर बाइनरी। यह एक वास्तविक क्षति है: एक क्रैश इस कार्यप्रणाली का सबसे मज़बूत प्रमाण है, और कोई भी स्टैटिक चीज़ इसकी भरपाई नहीं करती।
कुछ भी अन्यथा होने का दिखावा नहीं करता। scripts/capabilities.sh रिपोर्ट करता है कि होस्ट
वास्तव में क्या कर सकता है, scripts/pipeline_status.py चरण को अनुपस्थित चिह्नित करता है, और
लागत रिपोर्ट के limitations में आती है। जो चरण नहीं चला उसे कभी भी
ऐसे चरण के रूप में रिपोर्ट नहीं किया जाता जो चला और कुछ नहीं मिला — स्किल का §9.1 देखें।
संक्षेप में: Linux पर विश्लेषण करें। कहीं भी पढ़ें, योजना बनाएँ और रिपोर्ट लिखें।
Norbert Tihanyi · x.com/@TihanyiNorbert
एक निष्कर्ष = सोर्स · सिंक · टूटा गार्ड · प्रभावित प्रिंसिपल।
इससे कम कुछ भी एक परिकल्पना है।
capabilities.sh | यह होस्ट वास्तव में क्या कर सकता है — योजना बनाने से पहले जाँचें |
analyze.sh | पूरी पाइपलाइन क्रम में, चरण 0-5, फिर हैंडऑफ़ |
batch_analyze.sh | लक्ष्यों की एक निर्देशिका पर वही पाइपलाइन |
pipeline_status.py | एक एविडेंस ट्री का ऑडिट करें: कौन से चरण चले, और प्रत्येक अनुपस्थिति की क्या कीमत है |
overview.py | एक प्रोग्राम का आकार: गणनाएँ, कॉल ट्री, सिंक्स, सोर्सेज़ |
brief.py | एक लक्ष्य के लिए प्रत्येक टूल का आउटपुट, समेकित, अंतरालों के नाम के साथ |
fn.py | पूरे डीकंपाइलेशन के बजाय एक फ़ंक्शन पढ़ें |
reach.py | कॉल ग्राफ़ पर सोर्स → सिंक पथ |
bounds_worklist.py | अंकगणितीय दावे जिन्हें निपटाना है, तीन स्तरों में |
check_bound.py | z3 के साथ एक को निपटाएँ — 9 मोड्स और एक सामान्य एस्केप हैच |
symfn.py | एक फ़ंक्शन के लिए सिंबॉलिक हार्नेस |
emulate.py | आपके चुने हुए इनपुट्स पर एक फ़ंक्शन को अलग से चलाएँ |
quick_dynamic.sh | बस इसे चलाएँ: कोई इनपुट नहीं, फिर वे इनपुट्स जो अधिकांश चीज़ों को तोड़ देते हैं |
fuzz_target.sh | उस चैनल पर लक्षित फ़ज़िंग जिसे प्रोग्राम वास्तव में पढ़ता है |
sanitize_run.sh | शत्रुतापूर्ण एलोकेटर्स — एक मौन हीप बग को क्रैश कराएँ |
sanitize.py | मॉडल-निर्देशित टेक्स्ट को क्वारंटीन करें इससे पहले कि कोई इसे पढ़े |
| macOS पर अनुपस्थित | qemu-user · gdb · gef · ltrace · strace · valgrind · AFL++ · honggfuzz · frida · bpftrace · rr |
| साथ ही | capa का पिन किया गया बिल्ड Darwin पर अपना ही टेस्ट सूट पास नहीं करता |
| और | argv फ़ज़िंग __libc_start_main को इंटरपोज़ करती है, जो glibc है — macOS में इसका कोई समकक्ष नहीं है |