Skip to content
KitploitKITPLOIT
उपकरणएक्सप्लॉइटब्लॉग
Log in
जमा करें
उपकरणएक्सप्लॉइटब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

फ़ीडसंपर्कगोपनीयता© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
aotopsy — Flutter/Dart AOT स्नैपशॉट के लिए स्थैतिक विश्लेषक — Dart VM को एम्बेड या निष्पादित किए बिना libapp.so से फ़ंक्शन नाम, क्लास पदानुक्रम, कॉल ग्राफ़ और व्यवहारिक संकेत पुनर्प्राप्त करता है। ARM64 और x86_64, Dart 2.10–3.12 का समर्थन करता है। | Kitploit
उपकरण/GitHubGitHub/bronils/aotopsy
स्थैतिक विश्लेषणमोबाइल ऐप पेंटेस्टिंगरिवर्स इंजीनियरिंगमोबाइल सुरक्षाबाइनरी विश्लेषण
GitHubbronils/aotopsy

aotopsy

Flutter/Dart AOT स्नैपशॉट के लिए स्थैतिक विश्लेषक — Dart VM को एम्बेड या निष्पादित किए बिना libapp.so से फ़ंक्शन नाम, क्लास पदानुक्रम, कॉल ग्राफ़ और व्यवहारिक संकेत पुनर्प्राप्त करता है। ARM64 और x86_64, Dart 2.10–3.12 का समर्थन करता है।

रिपॉजिटरी देखें
48111112 महीने पहलेKitploit द्वारा समीक्षित
साझा करें
# AOTopsy

[![CI](https://github.com/BroNils/aotopsy/actions/workflows/ci.yml/badge.svg)](https://github.com/BroNils/aotopsy/actions/workflows/ci.yml)
[![Release](https://img.shields.io/github/v/release/BroNils/aotopsy?sort=semver)](https://github.com/BroNils/aotopsy/releases)
[![License](https://img.shields.io/badge/license-BSD--3--Clause-blue.svg)](LICENSE)

एक Dart AOT स्नैपशॉट विश्लेषक। `libapp.so` — Flutter रिलीज़ APK के अंदर संकलित Dart कोड — को फ़ंक्शन नामों, क्लास लेआउट, कॉल ग्राफ़, व्यवहारिक संकेतों और पठनीय स्यूडोकोड में बदलता है। कोई Dart VM नहीं, कोई SDK संकलन नहीं, कोई रनटाइम फ़ॉलबैक नहीं।

> **फ़ोर्क सूचना:** AOTopsy, **unflutter** का एक फ़ोर्क है, जिसे मूल रूप से **Anthony Zboralski** ने बनाया था। मूल `zboralski/unflutter` रिपॉज़िटरी अब उपलब्ध नहीं है (लेखक द्वारा हटा दी गई); एक सामुदायिक निरंतरता [`KristijanZic/unflutter`](https://github.com/KristijanZic/unflutter) पर मौजूद है। मूल स्नैपशॉट पार्सर, क्लस्टर डीसीरियलाइज़र, ARM64 डिसअसेम्बली पाइपलाइन और Ghidra/IDA एकीकरण का सारा श्रेय मूल लेखक को जाता है। AOTopsy इसे x86_64 समर्थन, एक नेटिव डीकंपाइलर, संपूर्ण-प्रोग्राम टाइप अनुमान, Frida स्क्रिप्ट जनरेशन और व्यापक दस्तावेज़ीकरण के साथ विस्तारित करता है।

## यह क्या पुनर्प्राप्त करता है

| आउटपुट | यह क्या है |
|--------|-----------|
| फ़ंक्शन नाम | प्रत्येक संकलित फ़ंक्शन के लिए मूल Dart नाम |
| क्लास संरचनाएँ | फ़ील्ड नाम, बाइट ऑफ़सेट, विरासत श्रृंखलाएँ |
| कॉल ग्राफ़ | प्रोवेनेंस के साथ प्रत्यक्ष (BL) और अप्रत्यक्ष (BLR/dispatch) कॉल किनारे |
| स्ट्रिंग संदर्भ | कौन से फ़ंक्शन ऑब्जेक्ट पूल से कौन से स्ट्रिंग लिटरल लोड करते हैं |
| व्यवहारिक संकेत | क्रिप्टो, नेटवर्क, जुआ, SIM, स्थान, WebView, ब्लॉकचेन कीवर्ड वर्गीकरण |
| स्यूडोकोड | ARM64 या x86_64 मशीन कोड से आर्किटेक्चर-न्यूट्रल डीकंपाइल्ड आउटपुट |
| Dart स्रोत निर्यात | क्लास, फ़ील्ड और मेथड्स के साथ पुनर्निर्मित संपूर्ण-प्रोजेक्ट मॉड्यूलर `.dart` फ़ाइलें |

**ARM64** और **x86_64** का समर्थन करता है। **Dart 2.10 से 3.13** तक कवर करता है (3.13.2 वर्तमान स्थिर सीमा है) — प्रत्येक मॉडल किया गया संस्करण दोनों आर्किटेक्चर पर साफ़ तरीके से पार्स होता है, देखें [COVERAGE.md](https://github.com/bronils/aotopsy/blob/main/COVERAGE.md) (93 नमूना बिल्ड, 0 विफलताएँ)।

## सटीकता और ईमानदारी

AOTopsy को ग्राउंड ट्रुथ के विरुद्ध मापा जाता है, दावा नहीं किया जाता। प्रत्येक परिवर्तन पर
टेस्ट सूट द्वारा दो गुण लागू किए जाते हैं:

| मीट्रिक | मान | इसका क्या अर्थ है |
|--------|-------|---------------|
| **नाम-पुनर्प्राप्ति सहमति** | 44 ग्राउंड-ट्रुथ बिल्ड्स में समग्र रूप से **90.2%** (81.3% सबसे खराब बैंड, ≥ 0.81 गेट फ़्लोर) | पुनर्प्राप्त फ़ंक्शन नामों की तुलना प्रत्येक बिल्ड के अपने ELF `.symtab` से की गई, जो बाहरी ग्राउंड ट्रुथ है — `TestSymtabDifferential`। प्रति-बिल्ड पूरा स्कोरबोर्ड: [BENCHMARK.md](https://github.com/bronils/aotopsy/blob/main/BENCHMARK.md) (`make bench`)। |
| **डीकंपाइलर सिंटैक्स वैधता** | **100%** वैध Dart | प्रत्येक उत्सर्जित स्यूडोकोड फ़ंक्शन Dart के रूप में पार्स होता है — `TestDecompileQualityCorpus`। |
| **निर्माण दर** | **0%** | §2 नियम: किसी अनुमानित नाम, प्रकार या कॉल लक्ष्य को कभी तथ्य के रूप में उत्सर्जित न करें। अज्ञात चीज़ें ईमानदारी से प्रस्तुत होती हैं (`indirectCall`, `<unknown>`, `dynamic`)। |

ग्राउंड-ट्रुथ ट्विन्स वास्तविक प्रोडक्शन बिल्ड हैं जिन्हें हम पुनर्वितरित नहीं कर सकते, इसलिए वे
डिफ़रेंशियल गेट्स **स्थानीय रूप से** चलते हैं; सार्वजनिक CI बिल्ड, vet, `gofmt`,
`staticcheck`, यूनिट टेस्ट (शफ़ल किए गए) और प्लेटफ़ॉर्म मैट्रिक्स में कवरेज फ़्लोर को मान्य करता है।
`samples/` पुनर्वितरित करने योग्य नहीं है और gitignored है, इसलिए नमूना-निर्भर
टेस्ट वहाँ छोड़ दिए जाते हैं — लेकिन केवल तब जब कॉर्पस पूरी तरह अनुपस्थित हो; एक कॉर्पस जो
मौजूद है और एक पंजीकृत नमूना गुम है, विफल हो जाता है, क्योंकि इनका अर्थ विपरीत है।
यहाँ प्रत्येक संख्या कैसे मापी जाती है (ग्राउंड ट्रुथ, मीट्रिक परिभाषाएँ, पुनरुत्पादन): [METHODOLOGY.md](https://github.com/bronils/aotopsy/blob/main/METHODOLOGY.md)। रिलीज़-बाइनरी सत्यापन और नीचे दिए गए ईमानदार दायरे के लिए
[SECURITY.md](https://github.com/bronils/aotopsy/blob/main/SECURITY.md) देखें।

## त्वरित शुरुआत

```bash
make build
./aotopsy libapp.so                    # full pipeline
./aotopsy doctor libapp.so             # quick diagnostic
./aotopsy export-dart --lib libapp.so --out ./lib  # reconstruct entire Dart source project
./aotopsy _debug decompile-native --lib libapp.so --find MyClass  # find and decompile a function
```

वास्तविक स्नैपशॉट पर पाँच मिनट के वॉकथ्रू के लिए [DEMO.md](https://github.com/bronils/aotopsy/blob/main/DEMO.md) देखें, या जब आपके पास एक कच्चा APK हो और आपको पता न हो कि कहाँ से शुरू करें, तो चरण-दर-चरण कार्यप्रणाली के लिए `WORKFLOW.md` देखें।

## यह कैसे काम करता है

AOTopsy, Dart AOT स्नैपशॉट को एक नियतात्मक बाइनरी व्याकरण के रूप में मानता है। सही बाधाओं (ELF संरचना, स्नैपशॉट मैजिक, वर्ज़न हैश, CID तालिका, क्लस्टर एन्कोडिंग) दिए जाने पर प्रत्येक बाइट का ठीक एक सही अर्थ होता है। पार्सर बाधाओं को तब तक लागू करता है जब तक केवल एक ही व्याख्या शेष न रहे — कोई अनुमानी तरीका नहीं, कोई अंदाज़ा नहीं।

पाइपलाइन चरणों में चलती है, प्रत्येक चरण बाइट्स से संरचित डेटा तक एक शुद्ध फ़ंक्शन है:

```mermaid
flowchart TD
    A[libapp.so] --> B[ELF parse]
    B --> C[snapshot region extraction]
    C --> D[version detection]
    D --> E[cluster alloc<br/>object census]
    E --> F[cluster fill<br/>field values, names, strings]
    F --> G[instructions table<br/>code ranges, stub boundaries]
    G --> H{architecture?}
    H -->|ARM64| I[ARM64 disassembly]
    H -->|x86_64| J[x86_64 disassembly]
    I --> K[CFG + call edges<br/>register provenance]
    J --> K
    K --> L[type inference<br/>BLR receiver type resolution]
    L --> M[signal classification<br/>behavioral keyword matching]
    M --> N[JSONL + HTML + DOT<br/>pseudocode output]
```

दो स्वतंत्र बैकएंड एक ही फ्रंट हाफ (ELF से क्लस्टर फिल तक) साझा करते हैं, फिर आर्किटेक्चर के आधार पर विभाजित होते हैं: ARM64 के लिए `internal/disasm`, x86_64 के लिए `internal/disasm/x86.go`। डीकंपाइलर (`internal/decompiler`) एकीकृत IR के माध्यम से दोनों आर्किटेक्चर को संभालता है।

```mermaid
flowchart LR
    subgraph "Shared front half"
        A[elfx] --> B[snapshot]
        B --> C[cluster]
    end
    subgraph "ARM64 backend"
        C --> D1[disasm ARM64]
        D1 --> E1[callgraph]
        E1 --> F1[signal]
    end
    subgraph "x86_64 backend"
        C --> D2[disasm x86_64]
        D2 --> E2[callgraph]
        E2 --> F2[signal]
    end
    subgraph "Decompiler (both archs)"
        C --> G[decompiler IR]
        G --> H[pseudocode]
    end
```

## Blutter के साथ तुलना

```mermaid
flowchart LR
    subgraph Blutter
        direction TB
        B1[libapp.so] --> B2[Compile matching<br/>Dart SDK]
        B2 --> B3[Embed Dart VM]
        B3 --> B4[Deserialize via<br/>VM internal APIs]
        B4 --> B5[Perfect fidelity]
    end
    subgraph AOTopsy
        direction TB
        A1[libapp.so] --> A2[Parse binary format<br/>directly]
        A2 --> A3[No VM, no SDK]
        A3 --> A4[Version-specific<br/>format modeling]
        A4 --> A5[Portability + speed]
    end
```

[Blutter](https://github.com/worawit/blutter) स्नैपशॉट को अपने स्वयं के कोड पथों के माध्यम से डीसेरियलाइज़ करने के लिए Dart VM को एम्बेड करता है। पूर्ण निष्ठा, लेकिन हर लक्ष्य संस्करण के लिए एक मेल खाता Dart SDK संकलित करना आवश्यक है — और यह केवल ARM64 के लिए है, स्थिर x86_64 समर्थन के बिना। AOTopsy एकमात्र स्थिर, संस्करण-स्वतंत्र विश्लेषक है जिसमें एक मूल स्यूडोकोड डीकंपाइलर और प्रकाशित ग्राउंड-ट्रुथ सटीकता है।

AOTopsy बाइनरी प्रारूप को सीधे पार्स करता है। कोई VM नहीं, कोई SDK नहीं। समझौता: Dart संस्करणों में हर प्रारूप परिवर्तन को स्पष्ट रूप से मॉडल किया जाना चाहिए। इसे स्वचालित रूप से संभालने के लिए कोई रनटाइम नहीं है।

## कमांड

### पूर्ण पाइपलाइन

```bash
aotopsy libapp.so              # disasm + call edges + signal + metadata (ARM64: + Ghidra/IDA)
aotopsy signal libapp.so       # same, skip metadata
aotopsy libapp.so --graph      # also build call graph DOT files
```

फ़्लैग: `--out <dir>` (डिफ़ॉल्ट: `<basename>.aotopsy/`), `--quiet`, `--strict`, `--max-steps <n>`, `--k <n>` (सिग्नल संदर्भ गहराई, डिफ़ॉल्ट 2), `--decompile`।

`--decompile` प्रत्येक फ़ंक्शन के लिए Dart स्यूडोकोड को `<out>/dart/` में लिखता है। यह डिफ़ॉल्ट रूप से बंद है क्योंकि यह आउटपुट निर्देशिका के आकार को लगभग तीन गुना कर देता है; इसके बिना हर रन यह बताता है, इसलिए यह क्षमता केवल मौजूद नहीं बल्कि खोजी जा सकने योग्य है।

### निदान

```bash
aotopsy doctor libapp.so       # Dart version, pointer size, support status, build features
aotopsy find-libapp --apk app.apk  # locate libapp.so inside an APK
```

### संपूर्ण-प्रोजेक्ट Dart स्रोत निर्यात

सभी क्लासेस, फ़ील्ड्स, मेथड्स, गेटर्स, सेटर्स और कंस्ट्रक्टर्स को मूल लाइब्रेरी URIs द्वारा मैप किए गए मॉड्यूलर `.dart` फ़ाइलों में पुनर्निर्मित करता है:

```bash
aotopsy export-dart --lib libapp.so --out ./reconstructed_lib/   # full project export
aotopsy export-dart --lib libapp.so --out ./lib/ --app-only      # filter out core/flutter framework
aotopsy export-dart --lib libapp.so --out ./lib/ --filter Auth   # targeted export by name
```

### उच्च-स्तरीय नेटिव डीकंपाइलर (ARM64 + x86_64)

बाइनरी मशीन निर्देशों से सीधे स्वच्छ, मुहावरेदार Dart कोड उत्पन्न करता है:
- **संरचनात्मक नियंत्रण प्रवाह**: सटीक PC बाउंडिंग के साथ `for-in` इटरेटर, `while`, `for`, `try-catch-finally`।
- **Async/Await रैखिककरण**: `_SuspendState` स्टेट मशीनों को रैखिक `await future` और `await for` में खोलता है।
- **लैम्ब्डा इनलाइनिंग**: कॉल साइटों पर सीधे एरो कॉलबैक `(item) => process(item)` को संश्लेषित करता है।
- **टाइप लैटिस**: लाइव VM चलाए बिना SSA मानों में ठोस Dart प्रकार (`String`, `int`, `UserModel`) का प्रसार करता है।
- **Dart मुहावरे**: Null-aware (`?.`, `??`, `??=`), कैस्केड (`..`), Set/List/Map लिटरल, स्ट्रिंग इंटरपोलेशन (`"${a}${b}"`)।

```bash
aotopsy _debug decompile-native --lib libapp.so --find MyClass         # locate by name
aotopsy _debug decompile-native --lib libapp.so --func 0x1a92728       # one function at a VA
aotopsy _debug decompile-native --lib libapp.so --from-main --out out/ # reachability from app entry
aotopsy _debug decompile-native --lib libapp.so --all --filter MyClass # bulk, filtered
```

चेतावनी: `--all` को छोटे `--max` के बिना उपयोग करने पर वास्तविक ऐप पर लगभग 64GB RAM की आवश्यकता हो सकती है। `--find`/`--func`/`--from-main` को प्राथमिकता दें।

### Ghidra / IDA (केवल ARM64)

```bash
aotopsy ghidra libapp.so        # headless Ghidra with metadata injection
aotopsy ida libapp.so           # headless IDA via idalib
```

दोनों x86_64 इनपुट को अस्वीकार करते हैं। x86_64 स्यूडोकोड के लिए `decompile-native` का उपयोग करें।

### Frida स्क्रिप्ट जनरेशन

```bash
aotopsy _debug decompile-native --lib libapp.so --func 0x1a92728 --gen-frida --gen-frida-out hooks.js
frida -U -f com.example.app -l hooks.js --no-pause
```

पूर्ण गाइड के लिए `FRIDA.md` देखें।

### क्रॉस-रेफ़रेंसिंग और ट्रेसिंग

```bash
aotopsy _debug strings --lib libapp.so --find "X-Signature" --xref   # which function loads this string?
aotopsy _debug ffi-trace --lib libapp.so --filter MyClass            # dart:ffi call sites
aotopsy _debug dispatch-table --lib libapp.so --filter MyClass       # dispatch table entries
aotopsy _debug fingerprint --lib libapp.so                           # build-id and version markers
aotopsy _debug funcdiff --old old.so --new new.so                    # function set diff
aotopsy _debug symbolmap --stripped lib.so --unstripped debug.so     # resolve stripped targets
```

### कॉर्पस टूल्स

```bash
aotopsy inventory --dir samples/                    # catalog APKs
aotopsy parity --samples samples/ --out out/        # cross-version parse report
aotopsy _debug thr-audit -lib libapp.so -out thr.jsonl  # THR access scan
```

## आउटपुट आर्टिफैक्ट्स

| फ़ाइल | सामग्री |
|------|----------|
| `functions.jsonl` | प्रति फ़ंक्शन नाम, पता, आकार, स्वामी, पैरामीटर संख्या |
| `call_edges.jsonl` | हल किए गए लक्ष्यों और प्रोवेनेंस के साथ BL/BLR एज |
| `classes.jsonl` | प्रति क्लास फ़ील्ड नाम, ऑफ़सेट, इंस्टेंस आकार |
| `string_refs.jsonl` | ऑब्जेक्ट पूल लोड से स्ट्रिंग संदर्भ |
| `dispatch_table.jsonl`| अनुमानित डिस्पैच टेबल रिसीवर प्रकार और लक्ष्य मैपिंग |
| `signal.html` | संदर्भ ग्राफ़ के साथ व्यवहारिक सिग्नल रिपोर्ट |
| `dart_meta.json` | स्नैपशॉट मेटाडेटा, कंप्रेस्ड पॉइंटर्स फ़्लैग, THR लेआउट |
| `flutter_meta.json` | Ghidra/IDA के लिए एकीकृत मेटाडेटा (केवल ARM64) |
| `aotopsy.sarif` | SARIF 2.1.0 सुरक्षा निष्कर्ष रिपोर्ट (GitHub Code Scanning के लिए) |
| `evidence.jsonl` | प्रति कॉल साइट विश्वास और प्रोवेनेंस के साथ एकीकृत साक्ष्य मॉडल |
| `asm/*.txt` | प्रति फ़ंक्शन एनोटेटेड डिसअसेम्बली |
| `asm/*.bin` | प्रति फ़ंक्शन कच्चे निर्देश बाइट्स (दोनों आर्किटेक्चर) |
| `dart/*.dart` | प्रति-फ़ंक्शन डीकंपाइल किया गया स्यूडोकोड (`--decompile` के साथ) |
| `cfg/*.dot` | प्रति-फ़ंक्शन CFG (`--graph` के साथ) |

## पैकेज लेआउट

```
cmd/aotopsy/          CLI entry point and command handlers
internal/
  analysis/           Pipeline orchestration, snapshot loader, and analysis engines
  sdk/                Dart VM ground-truth facts, register mappings, and predicates
  vmtables/           Versioned THR field offsets, stub names, and stub orders
  thraudit/           Thread-relative memory access audit and classification
  arch/arm64/         Centralized ARM64 bitmask instruction decoders
  arch/x86/           Centralized x86_64 decode primitives and register helpers
  naming/             Central pool lookups, name resolution, and stub builders
  elfx/               ELF validation and symbol extraction
  snapshot/           Snapshot region extraction, version profiles
  dartfmt/            Dart VM variable-length integer encoding
  cluster/            Two-phase snapshot deserialization (alloc + fill)
  disasm/             ARM64 + x86_64 decode, CFG, call-edge provenance
  callgraph/          Call graph construction and DOT rendering
  signal/             Behavioral string and malware signal classification
  render/             HTML/DOT/SVG visualization
  output/             JSONL and SARIF 2.1.0 serialization
  decompiler/         Dart-AOT pseudocode decompiler (both architectures)
  typetrack/          Whole-program type inference and receiver recovery
  fingerprint/        Build-id and version marker identification
  funcdiff/           Function-set diffing between builds
  symbolmap/          Stripped-vs-unstripped symbol resolution
  ffitrace/           Static dart:ffi call-site tracing
  strxref/            String-to-function cross-referencing
  strutil/            Dart syntax sanitization and metadata serialization
  jsonutil/           Generic JSONL stream readers and writers
  evidence/           Unified evidence model with confidence and provenance
  frida/              Frida runtime hook and probe generation
  cli/                ANSI color helpers for CLI output
tools/                Standalone utilities (THR table extractor and validator)
ghidra_scripts/       Ghidra integration (Python)
ida_scripts/          IDA integration (Python)
```

विस्तृत जानकारी के लिए प्रत्येक पैकेज के बारे में `ARCHITECTURE.md` देखें।

## बिल्ड

Go 1.25+ आवश्यक है।

```bash
make build      # build ./aotopsy
make install    # install to ~/.aotopsy/bin, plus the Ghidra/IDA integration
                # assets into ~/.aotopsy/ghidra_scripts and ~/.aotopsy/ida_scripts
make test       # run tests
make bench      # regenerate BENCHMARK.md (needs local ground-truth twins)
make coverage   # regenerate COVERAGE.md (needs local corpus samples)
make analyze    # cross-check export-dart output against `dart analyze`
```

इंटीग्रेशन टेस्ट अपना इनपुट `internal/samplecorpus` से प्राप्त करते हैं, जो एक `samples/` डायरेक्टरी खोजता है; सेट करने के लिए कुछ भी नहीं है। `samples/` gitignored है, इसलिए बिना इसके किया गया चेकआउट उन टेस्ट को छोड़ देता है — लेकिन जिस चेकआउट में कॉर्पस *है* और कोई पंजीकृत सैंपल गायब है, वह विफल होता है, क्योंकि बदला हुआ कॉर्पस और अनुपस्थित कॉर्पस का अर्थ अलग-अलग होता है।

सार्वजनिक CI linux/amd64, darwin/arm64 और windows/amd64 पर `gofmt`, `staticcheck`, build, vet और शफल किए गए यूनिट टेस्ट चलाता है, साथ ही कवरेज फ्लोर वाला एक race+coverage जॉब भी।

## रिलीज़ और ब्रांच

AOTopsy दो-ब्रांच मॉडल का उपयोग करता है:

| ब्रांच | भूमिका |
|--------|------|
| `main` | **स्थिर।** प्रत्येक कमिट एक squash-merged, गेट-सत्यापित रिलीज़ कैंडिडेट है। टैग किए गए रिलीज़ (प्रीबिल्ट क्रॉस-प्लेटफ़ॉर्म बाइनरीज़ के साथ) यहीं से काटे जाते हैं। |
| `develop` | **रोलिंग / नाइटली।** जहाँ दैनिक छोटे कमिट, फ़ीचर और रिसर्च पहले आते हैं। मर्ज के बीच अस्थिर हो सकता है। गेट्स हरे होने पर squash-merge PR के माध्यम से `main` में बैच किया जाता है। |

`develop` के विरुद्ध योगदान करें; `main` में PR केवल तब खोलें जब काम का एक बैच गेट-सत्यापित हो।

Linux, macOS और Windows (amd64/arm64) के लिए प्रीबिल्ट बाइनरीज़ प्रत्येक
[GitHub रिलीज़](../../releases) के साथ संलग्न हैं। AOTopsy शुद्ध Go है, इसलिए `make build` किसी भी लक्ष्य के लिए साफ़ तौर पर क्रॉस-कंपाइल करता है।
प्रत्येक रिलीज़ आर्काइव में बाइनरी के बगल में `ghidra_scripts/` और `ida_scripts/` भी होते हैं,
जो वही लेआउट है जिसे `aotopsy ghidra` और `aotopsy ida` खोजते हैं — इसलिए वे
कमांड सीधे अनपैक किए गए डाउनलोड से काम करते हैं, बिना किसी चेकआउट की आवश्यकता के।

## सीमाएँ और दायरा

AOTopsy स्पष्ट रूप से बताता है कि वह क्या पुनर्प्राप्त करता है और क्या नहीं। कुछ सीमाएँ
इंजीनियरिंग दायरे की हैं; अन्य **कठोर AOT-फ़ॉर्मेट फ्लोर** हैं — वह जानकारी जिसे Dart कंपाइलर
रिलीज़ (PRODUCT) बिल्ड में हटा देता है, जिसे SDK स्रोत के विरुद्ध सत्यापित किया गया है। हम फ्लोर का दस्तावेज़ीकरण करते हैं
बजाय उन पर कुछ गढ़ने के।

**कठोर AOT फ्लोर (सत्यापित — इनके सुधरने की अपेक्षा न करें):**
- **इंस्टेंस फ़ील्ड नाम ~97–99% अनुपस्थित हैं।** `Precompiler::DropFields` फ़ील्ड
  नाम केवल `#if !defined(PRODUCT)` के अंतर्गत रखता है; एक वास्तविक ऐप में ~233 नामित `Field` ऑब्जेक्ट बनाम
  ~16k सिंथेटिक होते हैं। एक्सेसर-आधारित रिकवरी (`get:`/`set:` अभी भी नाम रखते हैं) इसे
  आंशिक रूप से भेदती है (−11–22%, नियतात्मक, कभी अनुमान नहीं लगाया गया); बाकी वास्तव में चला गया है।
- **लोकल और कैप्चर किए गए वेरिएबल नाम चले गए हैं।** `local_*` / `tN` के रूप में प्रस्तुत।
- **वास्तव में बहुरूपी डिस्पैच लक्ष्य स्थिर रूप से हल करने योग्य नहीं हैं।** डिस्पैच टेबल / डायनामिक `Closure` ऑब्जेक्ट के माध्यम से BLR एक AOT सीमा है, विश्लेषण अंतराल नहीं; ये
  ईमानदारी से `indirectCall` / `dynamicCall` के रूप में प्रस्तुत होते हैं। देखें [METHODOLOGY.md](https://github.com/bronils/aotopsy/blob/main/METHODOLOGY.md#limits-of-this-method-honestly)।

**इंजीनियरिंग दायरा:**
- **केवल AOT।** कोई JIT समर्थन नहीं।
- **Ghidra/IDA डीकंपाइलेशन केवल ARM64 है।** x86_64 को स्पष्ट त्रुटि के साथ अस्वीकार किया जाता है — इसके बजाय `decompile-native` का उपयोग करें (एकमात्र स्टैटिक x86_64 Flutter डीकंपाइलर)।
- **`--all` डीकंपाइलेशन होस्ट को क्रैश कर सकता है।** एक वास्तविक पूर्ण-आकार के ऐप को असीमित `--all` के लिए ~64GB RAM चाहिए। लक्षित मोड (`--find`, `--func`, `--from-main`) का उपयोग करें या `--max` से सीमित करें।
- **वर्चुअल डिस्पैच `--from-main` रीचेबिलिटी के लिए अदृश्य है।** विजेट लाइफ़साइकल कॉलबैक Flutter के फ़्रेमवर्क डिस्पैच से गुज़रते हैं, सीधे कॉल निर्देशों से नहीं। एक क्लास-टच ह्यूरिस्टिक कुछ पुनर्प्राप्त करता है, लेकिन यह एक ओवर-अप्रॉक्सिमेशन है। बाकी के लिए Frida का उपयोग करें।

---

[Read more](https://github.com/bronils/aotopsy)
टूल डाउनलोड करें

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

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 अंतिम OSINT टूलकिट: जाँच ग्राफ़, विश्वास स्कोरिंग, उपनाम परिवार, मानचित्र, टाइमलाइन और रिपोर्ट। 49 मॉड्यूल, 400+ साइटें, किसी API कुंजी की आवश्यकता नहीं।

    891
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # घोस्टलॉक वन-टैप निष्पादन ऐप (CVE-2026-43499)

    547
  • 3

    ARTEX

    baarai/artex

    प्लानर/वर्कर एजेंट, एसेट और एक्सप्लोरेशन ग्राफ़, MITM ट्रैफ़िक रिकॉर्डिंग, और भेद्यता पुनःपरीक्षण के साथ LLM मल्टी-एजेंट स्वायत्त पेनेट्रेशन टेस्टिंग प्लेटफ़ॉर्म।

    369
  • 4

    redforge

    cybersecurity91/redforge

    ब्राउज़र-साइड रेड टीम टूलकिट, जिसमें रेकॉन, पेलोड जनरेशन, क्रेडेंशियल हमलों, क्रिप्टो, एन्कोडिंग और एंगेजमेंट रिपोर्टिंग के लिए 102 ऑफ़लाइन टूल्स हैं।

    366
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT प्लेटफ़ॉर्म जो Shadowserver रिपोर्ट्स को MongoDB में इनजेस्ट करता है और उन्हें इंटरैक्टिव मैप्स, विश्लेषण, निष्कर्षों, सलाहों और कार्यकारी डैशबोर्ड के रूप में पुनः प्रस्तुत करता है।

    309
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    AI-मूल साइबरसुरक्षा के लिए कार्रवाई की प्रणाली—जहाँ इरादा नियंत्रित निष्पादन बन जाता है, साक्ष्य परिचालन स्मृति बन जाता है, और हर ऑपरेशन अगले को बेहतर बनाता है।

    282

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →