OGhidra, Ollama के माध्यम से Large Language Models (LLMs) को Ghidra रिवर्स इंजीनियरिंग प्लेटफ़ॉर्म से जोड़ता है, जो प्राकृतिक भाषा के माध्यम से AI-संचालित बाइनरी विश्लेषण को सक्षम बनाता है। वार्तालापीय प्रश्नों का उपयोग करके Ghidra के साथ बातचीत करें और जटिल रिवर्स इंजीनियरिंग वर्कफ़्लो को स्वचालित करें।
# OGhidra 3 - Ghidra के साथ AI-संचालित रिवर्स इंजीनियरिंग
क्लॉड-प्रेरित ऑर्केस्ट्रेटर का उपयोग करने वाले संस्करण के लिए, देखें https://github.com/llnl/OGhidra/tree/orchestrator
**OGhidra** बड़े भाषा मॉडलों को Ghidra के रिवर्स इंजीनियरिंग प्लेटफॉर्म से जोड़ता है, जिससे प्राकृतिक भाषा के माध्यम से AI-संचालित बाइनरी विश्लेषण संभव होता है। बातचीत के माध्यम से बाइनरी का विश्लेषण करें, जटिल वर्कफ़्लो को स्वचालित करें, और स्थानीय AI मॉडलों के साथ पूर्ण गोपनीयता बनाए रखें।
YouTube सेटअप ट्यूटोरियल
[](https://www.youtube.com/watch?v=hBD92FUgR0Y)
---
## OGhidra क्या है?
OGhidra Ghidra को AI क्षमताओं के साथ बढ़ाता है, जिससे आप यह कर सकते हैं:
- **प्राकृतिक भाषा विश्लेषण** - सादी अंग्रेज़ी में फ़ंक्शन, स्ट्रिंग, आयातों के बारे में प्रश्न पूछें
- **स्वचालित वर्कफ़्लो** - फ़ंक्शनों का नाम बदलें, पैटर्न का पता लगाएं, व्यापक रिपोर्ट तैयार करें
- **स्थानीय AI मॉडल** - अपने हार्डवेयर (Ollama) पर चलने वाले मॉडलों के साथ पूर्ण गोपनीयता
- **क्लाउड AI समर्थन** - बाहरी API (OpenAI, Google Gemini, Anthropic Claude) से कनेक्ट करें
- **मैलवेयर पहचान** - 12+ चोरी और इंजेक्शन तकनीकों के लिए स्वचालित पैटर्न मिलान
- **स्मार्ट गणना** - बाइनरी विश्लेषण से पूछताछ योग्य ज्ञान ग्राफ़ बनाएं
- **मल्टी-इंस्टेंस विश्लेषण** - समानांतर विश्लेषण के लिए कई Ghidra इंस्टेंस चलाएं
### यह कैसे काम करता है
```mermaid
graph TD
A[User Query] --> B[Planning Phase]
B --> C{Execution Phase}
C -- Tool Calls --> D[Ghidra/LLM]
D --> C
C --> E[Review Phase]
E -- Agentic Loop --> B
E --> F[Final Response]
style E fill:#f9f,stroke:#333,stroke-width:2px
style B fill:#bbf,stroke:#333,stroke-width:2px
```
**एजेंटिक लूप**: OGhidra एक अनुकूली योजना प्रणाली का उपयोग करता है। प्रत्येक निष्पादन चक्र के बाद, परिणामों की समीक्षा की जाती है और AI अंतिम प्रतिक्रिया देने से पहले अधिक जानकारी एकत्र करने या अपने विश्लेषण को परिष्कृत करने का निर्णय ले सकता है।
---
## त्वरित आरंभ
### पूर्वापेक्षाएँ
1. **Python 3.12+** - संस्करण जांचें: `python --version`
2. **Ghidra 12.0.3** (अनुशंसित) - [Ghidra रिलीज़](https://github.com/NationalSecurityAgency/ghidra/releases) से डाउनलोड करें
- प्लगइन बिल्ड/इंस्टॉल पथ Ghidra 12.0.3 के लिए प्रलेखित है
- परीक्षण किया गया: Ghidra 11.0.3, 11.3.2, 12.0.2, 12.0.3
3. **Java 21** - Ghidra 12.0.3 एक्सटेंशन बनाने के लिए आवश्यक: `java -version`
4. **Ollama** (वैकल्पिक, स्थानीय मॉडलों के लिए) - [ollama.com](https://ollama.com/) से इंस्टॉल करें
### इंस्टॉलेशन
```bash
# रिपॉजिटरी क्लोन करें
git clone https://github.com/LLNL/OGhidra.git
cd OGhidra
# निर्भरताएँ स्थापित करें (एक चुनें)
uv sync # UV का उपयोग करके (अनुशंसित)
pip install -r requirements.txt # pip का उपयोग करके
# वातावरण कॉन्फ़िगर करें
cp .env.example .env
# अपनी सेटिंग्स के साथ .env संपादित करें
```
### Ghidra प्लगइन सेटअप करें
नीचे दिए गए OGhidraMCP प्लगइन बिल्ड चरण Ghidra 12.0.3 (अनुशंसित) को लक्षित करते हैं।
YouTube वीडियो ट्यूटोरियल भी है: https://www.youtube.com/watch?v=hBD92FUgR0Y
#### GhidraMCP एक्सटेंशन बनाना
एक डेवलपर के रूप में, आपको इसे Ghidra में स्थापित करने से पहले GhidraMCP एक्सटेंशन बनाना होगा:
1. **पूर्वापेक्षाएँ**:
- Ghidra 12.0.3 स्थापित
- Java 21
2. **विकल्प 1: स्वचालित बिल्ड स्क्रिप्ट का उपयोग करके**:
- विंडोज़:
```bat
# अपने Ghidra इंस्टॉलेशन का पथ सेट करें (यदि सेट नहीं किया गया है तो Ghidra की अंतिम चलाई गई प्रतिलिपि खोजने का प्रयास करेगा)
set GHIDRA_INSTALL_DIR=C:\path\to\ghidra_12.0.3_PUBLIC
# बिल्ड स्क्रिप्ट चलाएं
build_ghidra_plugin.bat
```
- Unix/Linux/Mac:
```bash
# अपने Ghidra इंस्टॉलेशन का पथ सेट करें (यदि सेट नहीं किया गया है तो Ghidra की अंतिम चलाई गई प्रतिलिपि खोजने का प्रयास करेगा)
export GHIDRA_INSTALL_DIR=/path/to/ghidra_12.0.3_PUBLIC
# बिल्ड स्क्रिप्ट चलाएं (यदि आवश्यक हो तो पहले इसे निष्पादन योग्य बनाएं)
chmod +x build_ghidra_plugin.sh
./build_ghidra_plugin.sh
```
3. **विकल्प 2: मैन्युअल बिल्ड प्रक्रिया**:
- अपने Ghidra इंस्टॉल पथ के साथ `OGhidraMCP/gradle.properties` बनाएं/अपडेट करें:
```properties
GHIDRA_INSTALL_DIR=/absolute/path/to/ghidra_12.0.3_PUBLIC
```
- Unix/Linux/macOS पर:
```bash
cd OGhidraMCP
$GHIDRA_INSTALL_DIR/support/gradle/gradlew buildExtension --info
```
- विंडोज़ पर:
```bat
cd OGhidraMCP
"%GHIDRA_INSTALL_DIR%\support\gradle\gradlew.bat" buildExtension --info
```
4. **बनाए गए एक्सटेंशन का पता लगाएं**:
- एक्सटेंशन zip फ़ाइल `OGhidraMCP/dist/` में बनाई गई है
- फ़ाइल का नाम कुछ इस प्रकार होगा `ghidra_12.0.3_PUBLIC_YYYYMMDD_OGhidraMCP.zip`
#### GhidraMCP एक्सटेंशन स्थापित करना
एक बार जब आप सफलतापूर्वक एक्सटेंशन बना लें:
1. **Ghidra में स्थापित करें**:
- Ghidra खोलें -> **File** -> **Install Extensions**
- **Add Extension** (हरा प्लस आइकन) पर क्लिक करें
- अपनी `OGhidraMCP/dist/` निर्देशिका पर ब्राउज़ करें
- नवनिर्मित एक्सटेंशन zip फ़ाइल चुनें (जैसे, `ghidra_12.0.3_PUBLIC_YYYYMMDD_OGhidraMCP.zip`)
- Ghidra को पुनरारंभ करें
2. **प्लगइन सक्षम करें**:
- एक Ghidra प्रोजेक्ट खोलें
- **File** → **Configure** → **Enable Developer**
- `OGhidraMCP` प्लगइन सक्षम करें
- सर्वर `http://localhost:8080/methods` पर प्रारंभ होगा
> **आपके पास कोड ब्राउज़र खुला होना चाहिए**
### AI मॉडल खींचें
```bash
# Ollama के लिए (स्थानीय मॉडल)
ollama pull gemma3:27b # अच्छा संतुलन (20GB RAM)
ollama pull nomic-embed-text # RAG के लिए एम्बेडिंग मॉडल
# वैकल्पिक मॉडल
ollama pull gpt-oss:120b # उच्च गुणवत्ता (80GB RAM)
ollama pull devstral-2:123b # उच्च गुणवत्ता (80GB RAM)
ollama pull devstral-2:123b-cloud # क्लाउड मॉडल
```
### OGhidra लॉन्च करें
```bash
# GUI मोड (अनुशंसित)
uv run main.py --ui
# इंटरैक्टिव CLI
uv run main.py --interactive
# इंटरैक्टिव CLI में, कनेक्शन का परीक्षण करें
health
```
यदि आपने GUI मोड लॉन्च किया है, तो इसका उपयोग करें:
```bash
curl http://localhost:8080/methods
```
---
## कॉन्फ़िगरेशन
अपने AI प्रदाता को कॉन्फ़िगर करने के लिए `.env` संपादित करें:
### विकल्प 1: स्थानीय मॉडल (Ollama)
```env
LLM_PROVIDER=ollama
OLLAMA_BASE_URL=http://localhost:11434/
OLLAMA_MODEL=gemma3:27b
OLLAMA_EMBEDDING_MODEL=nomic-embed-text
```
### विकल्प 2: बाहरी APIs
```env
LLM_PROVIDER=external
EXTERNAL_PROVIDER=google
EXTERNAL_API_KEY=your-api-key-here
EXTERNAL_MODEL=gemini-3.1-flash-lite-preview
EXTERNAL_EMBEDDING_MODEL=gemini-embedding-001
```
### विकल्प 3: कस्टम OpenAI-संगत API
```env
LLM_PROVIDER=custom_api
CUSTOM_API_URL=https://api.example.com/v1/chat/completions
CUSTOM_API_KEY=your-api-key-here
CUSTOM_API_MODEL=your-model-name
CUSTOM_API_EMBEDDING_MODEL=your-embedding-model
```
### संदर्भ प्रबंधन सेटिंग्स
अपने मॉडल के संदर्भ विंडो के अनुसार समायोजित करें:
```env
# टोकन में संदर्भ बजट (अपने मॉडल की सीमा के अनुसार समायोजित करें)
CONTEXT_BUDGET=100000 # मध्यम आकार के मॉडलों के लिए 100K टोकन
# फ्रंटियर मॉडलों के लिए 200K+
# निष्पादन सेटिंग्स
MAX_EXECUTION_STEPS=5 # प्रति योजना चक्र कदम
MAX_AGENTIC_CYCLES=3 # कितने योजना-निष्पादन-समीक्षा लूप
AGENTIC_LOOP_ENABLED=true # अनुकूली पुनर्नियोजन सक्षम करें
```
---
## मुख्य विशेषताएं
### 1. स्मार्ट टूल बटन (GUI)
एक क्लिक से सामान्य रिवर्स इंजीनियरिंग कार्यों तक पहुंच:
| उपकरण | विवरण |
| ---------------------------- | ----------------------------------------------- |
| **वर्तमान फ़ंक्शन का विश्लेषण करें** | चयनित फ़ंक्शन के व्यवहार में गहराई से जाएं |
| **वर्तमान फ़ंक्शन का नाम बदलें** | AI विश्लेषण के आधार पर सार्थक नाम सुझाता है |
| **सभी फ़ंक्शनों का नाम बदलें** | स्मार्ट/पूर्ण/केवल-नाम-बदलें विकल्पों के साथ बल्क नाम बदलें |
| **आयातों का विश्लेषण करें** | लाइब्रेरी और बाहरी निर्भरताओं की पहचान करें |
| **स्ट्रिंग्स का विश्लेषण करें** | URL, क्रेडेंशियल, कॉन्फ़िगरेशन डेटा खोजें |
| **रिपोर्ट तैयार करें** | व्यापक सुरक्षा मूल्यांकन |
### 2. कार्य मोड
विशेष विश्लेषण लक्ष्य सेट करें:
```python
# GUI में: "Task Mode" ड्रॉपडाउन का उपयोग करें
# CLI में: set task_mode <mode>
task_mode malware # पैटर्न पहचान के साथ मैलवेयर विश्लेषण
task_mode vuln # कमज़ोरी अनुसंधान फोकस
task_mode general # सामान्य रिवर्स इंजीनियरिंग
```
### 3. मैलवेयर पैटर्न पहचान
12+ मैलवेयर पैटर्न का स्वचालित पता लगाना:
- **चोरी**: PEB वॉकिंग, डायनामिक API रिज़ॉल्यूशन, एंटी-डीबग, एंटी-VM
- **इंजेक्शन**: प्रोसेस इंजेक्शन (स्थानीय/रिमोट)
- **स्थिरता**: रजिस्ट्री, फ़ाइल सिस्टम हुक
- **अस्पष्टीकरण**: स्ट्रिंग एन्कोडिंग, API हैशिंग
- **विशेषाधिकार वृद्धि**: टोकन हेरफेर, UAC बाईपास
पैटर्न MITRE ATT&CK मैपिंग के साथ AI के संदर्भ में स्वचालित अलर्ट ट्रिगर करते हैं।
### 4. स्मार्ट गणना
बाइनरी विश्लेषण से समृद्ध, पूछताछ योग्य ज्ञान बनाएं:
```
# AI सारांश के साथ सभी फ़ंक्शनों को गिनें
# इनमें से चुनें:
- केवल नाम बदलें: केवल सामान्य फ़ंक्शन नामों को संसाधित करें
- स्मार्ट गणना: सुरक्षा-प्रासंगिक फ़ंक्शनों पर ध्यान दें
- पूर्ण गणना: बाइनरी में प्रत्येक फ़ंक्शन का विश्लेषण करें
```
विशेषताएं:
- संरचित मेटाडेटा निष्कर्षण (LOC, जटिलता, संचालन)
- सिमैंटिक खोज अनुकूलन
- इरादा-आधारित संदर्भ संयोजन
- सटीक पुनर्प्राप्ति के लिए मल्टी-वेक्टर समर्थन
### 5. सत्र प्रबंधन
विश्लेषण सत्रों को सहेजें और पुनर्स्थापित करें:
```python
# प्रगति सहेजें
File → Save Session
# पिछला कार्य लोड करें
File → Load Session
# बल्क संचालन के बाद ऑटो-सेव
# सत्र में शामिल हैं:
- सारांश के साथ विश्लेषित फ़ंक्शन
- सिमैंटिक खोज के लिए RAG वेक्टर
- प्रदर्शन आँकड़े
- UI स्थिति
```
---
## बैकएंड सेटअप
OGhidra दो बैकएंड प्रकारों का समर्थन करता है:
- **MCP** — GhidraMCP सर्वर के साथ एकीकृत होता है और विश्लेषण के दौरान Ghidra क्लाइंट को चालू रखना आवश्यक होता है
- **PyGhidra** — Ghidra क्लाइंट के बिना हेडलेस विश्लेषण का समर्थन करता है और MCP द्वारा आवश्यक सर्वर घटक को हटा देता है
### बैकएंड चुनना
बैकएंड चुनने के लिए निम्नलिखित कमांड-लाइन विकल्प का उपयोग करें:
```bash
--ghidra-backend={http,pyghidra}
```
| बैकएंड विकल्प | विवरण |
|----------------|-------------|
| `http` | GhidraMCP बैकएंड का उपयोग करता है |
| `pyghidra` | PyGhidra बैकएंड का उपयोग करता है |
---
## PyGhidra कॉन्फ़िगरेशन
### मौजूदा Ghidra प्रोजेक्ट का उपयोग करना
OGhidra लॉन्च करते समय एक Ghidra प्रोजेक्ट फ़ाइल (`.gpr`) निर्दिष्ट करें:
```bash
--pyghidra-project=/path/to/project.gpr
```
OGhidra लॉन्च करने के लिए PyGhidra को एक मान्य Ghidra प्रोजेक्ट की आवश्यकता होती है।
---
### प्रोग्राम चुनना
निर्दिष्ट करें कि Ghidra प्रोजेक्ट के अंदर किस बाइनरी का विश्लेषण किया जाना चाहिए:
```bash
--pyghidra-program=<program_name>
```
Ghidra प्रोजेक्ट में प्रोग्राम चुनने के लिए उदाहरण कॉल:
```bash
uv run main.py --ui --ghidra-backend=pyghidra --pyghidra-project=/path/to/project.gpr --pyghidra-program=<program_name>
```
आवश्यकताएँ:
- प्रोग्राम का नाम Ghidra प्रोजेक्ट GUI में दिखाए गए नाम से बिल्कुल मेल खाना चाहिए
- मौजूदा प्रोजेक्ट का उपयोग करते समय यह विकल्प आवश्यक है
- प्रोग्राम निर्दिष्ट करने में विफलता OGhidra को लॉन्च होने से रोकेगी
---
### सीधे बाइनरी लॉन्च करना
आप सीधे बाइनरी पथ भी प्रदान कर सकते हैं:
```bash
--pyghidra-binary=/path/to/binary
```
जब इस विकल्प का उपयोग किया जाता है, तो PyGhidra स्वचालित रूप से:
1. एक नया Ghidra प्रोजेक्ट (`.gpr`) बनाता है
2. बाइनरी आयात करता है
3. विश्लेषण के लिए बाइनरी को OGhidra में लॉन्च करता है
सीधे बाइनरी लॉन्च करने के लिए उदाहरण कॉल:
uv run main.py --ui --ghidra-backend=pyghidra --pyghidra-binary=/path/to/binary
---
## सामान्य वर्कफ़्लो
### एक संदिग्ध बाइनरी का विश्लेषण करें
1. **Ghidra में बाइनरी लोड करें** और CodeBrowser में खोलें
2. **OGhidraMCP प्लगइन सक्षम करें** (File → Configure)
3. **OGhidra लॉन्च करें**: `uv run main.py --ui`
4. **कार्य मोड सेट करें**: ड्रॉपडाउन से "malware" चुनें
5. **स्मार्ट गणना चलाएं**: "Rename All Functions" → "Smart Enumeration" पर क्लिक करें
6. **प्रश्न पूछें**: "उच्च-जोखिम वाले फ़ंक्शन कौन से हैं?" या "मुझे नेटवर्क संचार दिखाएं"
### सुरक्षा रिपोर्ट तैयार करें
```bash
# GUI में: "Generate Report" बटन पर क्लिक करें
# रिपोर्ट में शामिल हैं:
- कार्यकारी सारांश
- फ़ंक्शन इन्वेंटरी (व्यवहार के साथ नामित फ़ंक्शन)
- सुरक्षा विश्लेषण (उच्च-जोखिम फ़ंक्शन, पैटर्न)
- आयात विश्लेषण
- स्ट्रिंग विश्लेषण
- अनुशंसाएँ
```
### विशिष्ट फ़ंक्शन की जांच करें
1. **Ghidra में फ़ंक्शन पर नेविगेट करें**
2. **"Analyze Current Function" पर क्लिक करें**
3. **अनुवर्ती प्रश्न पूछें**:
- "यह फ़ंक्शन क्या करता है?"
- "क्या यह बफर ओवरफ़्लो के लिए कमज़ोर है?"
- "कौन से अन्य फ़ंक्शन इसे कॉल करते हैं?"
---
## उन्नत सुविधाएँ
### RAG (पुनर्प्राप्ति-वर्धित पीढ़ी)
OGhidra विश्लेषित फ़ंक्शनों पर सिमैंटिक खोज के लिए वेक्टर एम्बेडिंग का उपयोग करता है:
```env
# .env में सक्षम करें
RESULT_CACHE_ENABLED=true
TIERED_CONTEXT_ENABLED=true
```
लाभ:
- सत्रों में पिछले विश्लेषण को याद रखें
- सिमैंटिक रूप से समान फ़ंक्शन खोजें
- अनावश्यक LLM कॉल कम करें
### संदर्भ अनुकूलन
स्तरीय संदर्भ संपीड़न प्रासंगिक जानकारी रखता है:
```env
CURRENT_LOOP_MAX_CHARS=2000 # हालिया: पूर्ण विवरण
PREV_LOOP_MAX_CHARS=400 # पिछला: सारांश
OLDER_LOOP_MAX_CHARS=100 # पुराना: केवल संदर्भ
```
### LLM लॉगिंग
डिबगिंग के लिए सभी AI इंटरैक्शन को ट्रैक करें:
```env
LLM_LOGGING_ENABLED=true
LLM_LOG_FILE=logs/llm_interactions.log
LLM_LOG_FORMAT=json
```
---
## समस्या निवारण
### Ghidra कनेक्शन समस्याएं
```bash
# सत्यापित करें कि प्लगइन लोड है
# codebrowser खोलें!
# जांचें कि सर्वर चल रहा है
curl http://localhost:8080/methods
```
### Ollama कनेक्शन समस्याएं
```bash
# सत्यापित करें कि Ollama चल रहा है
ollama list
# कनेक्टिविटी जांचें
curl http://localhost:11434/api/tags
# Ollama सेवा पुनरारंभ करें
ollama serve
```
### खाली प्रतिक्रियाएं / संदर्भ ओवरफ़्लो
```env
# संदर्भ बजट कम करें
CONTEXT_BUDGET=50000
# संघनन सक्षम करें
COMPACTION_ENABLED=true
COMPACTION_THRESHOLD=0.75
```
### धीमा प्रदर्शन
1. **छोटे मॉडल का उपयोग करें**: `gemma3:9b` पर स्विच करें
2. **समानांतर कर्मचारी कम करें**: बल्क संचालन में `max_workers=2` सेट करें
3. **वेक्टर एम्बेडिंग अक्षम करें**: `RESULT_CACHE_ENABLED=false`
4. **अनुरोध विलंब बढ़ाएं**: `CUSTOM_API_REQUEST_DELAY=2.0`
---
## आर्किटेक्चर अवलोकन
```
┌─────────────────────────────────────────────────────────────┐
│ OGhidra UI │
│ (GUI / Interactive CLI) │
└────────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ Bridge (src/bridge.py) │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ • Agentic Loop: Plan → Execute → Review → Replan │ │
│ │ • Tool Router: Ghidra client, LLM client, CAG manager │ │
│ │ • Context Manager: Budget allocation, compression │ │
│ └────────────────────────────────────────────────────────┘ │
└───────────┬────────────────────────┬────────────────────────┘
│ │
▼ ▼
┌───────────────────────┐ ┌─────────────────────────┐
│ Ghidra Client │ │ LLM Clients │
│ • GhidraMCP Plugin │ │ • Ollama (local) │
│ • Binary operations │ │ • External APIs │
│ • Decompilation │ │ • Custom endpoints │
└───────────────────────┘ └─────────────────────────┘
│ │
└────────────┬───────────┘
▼
┌─────────────────────────────────────────────────────────────┐
│ CAG Manager (Knowledge System) │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ • Vector Store: Semantic search over functions │ │
│ │ • Pattern Detector: 12+ malware techniques │ │
│ │ • Metadata Extractor: Structured function analysis │ │
│ │ • Session Store: Persistent analysis state │ │
│ └────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
```
---
## योगदान
हम योगदान का स्वागत करते हैं! रुचि के क्षेत्र:
- पहचान के लिए **नए मैलवेयर पैटर्न**
- **LLM प्रदाता एकीकरण**
- **UI/UX सुधार**
- **प्रदर्शन अनुकूलन**
- **प्रलेखन** और उदाहरण
सामुदायिक दिशानिर्देशों के लिए [CODE_OF_CONDUCT.md](https://github.com/llnl/oghidra/blob/main/CODE_OF_CONDUCT.md) देखें।
---
## उद्धरण
यदि आप अपने शोध में OGhidra का उपयोग करते हैं, तो कृपया उद्धृत करें:
```bibtex
@software{oghidra2025,
title = {OGhidra: AI-Powered Reverse Engineering with Ghidra},
author = {Enoch Wang},
year = {2025},
url = {https://github.com/LLNL/OGhidra}
}
```
---
## आभार
OGhidra उत्कृष्ट ओपन-सोर्स परियोजनाओं पर आधारित है:
- **[Ghidra](https://github.com/NationalSecurityAgency/ghidra)** - NSA का रिवर्स इंजीनियरिंग प्लेटफॉर्म
- **[Ollama](https://ollama.com/)** - स्थानीय LLM रनटाइम
- **[LaurieWired/GhidraMCP](https://github.com/LaurieWired/GhidraMCP)** - मूल Ghidra MCP प्लगइन
- **[starsong/GhydraMCP](https://github.com/starsong/GhydraMCP)** - उन्नत MCP कार्यान्वयन
---
## लाइसेंस
OGhidra वाणिज्यिक लाइसेंस विकल्प के साथ BSD 3-क्लॉज़ लाइसेंस की शर्तों के तहत वितरित किया जाता है।
विवरण के लिए [LICENSE](https://github.com/llnl/oghidra/blob/main/LICENSE) और [NOTICE.md](https://github.com/llnl/oghidra/blob/main/NOTICE.md) देखें।
**LLNL-CODE-2013290**
---
## सहायता
- **मुद्दे**: [GitHub Issues](https://github.com/LLNL/OGhidra/issues)
- **चर्चाएं**: [GitHub Discussions](https://github.com/LLNL/OGhidra/discussions)
- **मुझे सीधे ईमेल करें**: [email protected]