यह `seclab-taskflow-agent` और `seclab-taskflows` (parent) को
संक्रमणीय रूप से शामिल करता है, इसलिए
`seclab_taskflows.taskflows.audit.*`,
`seclab_taskflows.toolboxes.local_file_viewer`,
`seclab_taskflows.toolboxes.gh_file_viewer`, और
`seclab_taskflows.configs.model_config` के रूप में प्रत्येक डॉटेड संदर्भ
रनटाइम पर parent वितरण से हल हो जाता है।

---

## विषय-सूची

1. [यह क्या है](#what-this-is)
2. [त्वरित शुरुआत](#quick-start)
3. [आर्किटेक्चर](#architecture)
4. [पाइपलाइन, चरण दर चरण](#the-pipeline-stage-by-stage)
5. [कवरेज-फीडबैक लूप](#the-coverage-feedback-loop)
6. [संरचना-जागरूक फ़ज़िंग](#structure-aware-fuzzing)
7. [पुनरावृत्तियों और अभियानों में स्थायी कॉर्पस](#persistent-corpus-across-iterations-and-campaigns)
8. [ट्राइएज और भेद्यता रिपोर्ट](#triage-and-vulnerability-reports)
9. [लाइव डैशबोर्ड](#live-dashboard)
10. [आउटपुट फ़ाइलें](#output-files)
11. [डेटाबेस स्कीमा](#database-schema)
12. [MCP टूल्स (एजेंट की शब्दावली)](#mcp-tools-the-agents-vocabulary)
13. [समायोज्य नॉब्स (पर्यावरण चर)](#tunable-knobs-environment-variables)
14. [पाइपलाइन का विस्तार](#extending-the-pipeline)
15. [बेंचमार्क प्रोजेक्ट्स और परिणाम](#benchmark-projects-and-results)
16. [सीमाएँ और सावधानियाँ](#limitations-and-gotchas)
17. [सुरक्षा चेतावनी](#security-warning)
18. [विकास: परीक्षण, लिंटिंग, योगदान](#development-testing-linting-contributing)
19. [शब्दावली](#glossary)

---

## यह क्या है

यह टास्कफ़्लो एक पूर्णतः स्वायत्त फ़ज़िंग पाइपलाइन है। एक नेटिव C/C++ प्रोजेक्ट के GitHub रेपो को देखते हुए, यह:

1. यदि अनुपस्थित हों तो AFL++ + clang/llvm/lcov + ctags/cscope/graphviz इंस्टॉल करेगा,
2. स्रोत प्राप्त करेगा,
3. संभावित फ़ज़ लक्ष्यों (पार्सर, डिकोडर, वैलिडेटर, …) की पहचान करेगा,
4. बिल्ड सिस्टम का विश्लेषण करेगा,
5. प्रति लक्ष्य एक या अधिक हार्नेस उम्मीदवार लिखेगा, प्रत्येक को AFL-इंस्ट्रुमेंटेड `.afl` बाइनरी और कवरेज-इंस्ट्रुमेंटेड `.cov` बाइनरी दोनों के रूप में बनाएगा,
6. (वैकल्पिक रूप से) 60-सेकंड कवरेज द्वारा उम्मीदवारों को योग्य ठहराएगा और सर्वश्रेष्ठ रखेगा,
7. दोगुने समय बजट के साथ फ़ज़/कवरेज/सुधार लूप चलाएगा,
8. प्रत्येक क्रैश का ट्राइएज करेगा, पुष्टि करेगा कि पहले से ज्ञात क्रैश अभी भी पुनरुत्पादित होते हैं, और प्रति-क्रैश मार्कडाउन भेद्यता रिपोर्ट लिखेगा जिसमें निर्णय, शोषणीयता, सुझाए गए पैच, और रिग्रेशन-टेस्ट स्केच शामिल होंगे,
9. अगले अभियान के लिए Fuzz-Introspector-शैली का कॉल ग्राफ़ + अछूते-API रिपोर्ट बनाएगा,
10. सब कुछ एक लाइव HTML डैशबोर्ड पर प्रकाशित करेगा।

पाइपलाइन भावना में **OSS-Fuzz-शैली** की है: यह कई समान तकनीकों का उपयोग करती है (प्रति-फ़ॉर्मेट म्यूटेटर और डिक्शनरी, संरचना-जागरूक टोकन स्प्लिसिंग, कवरेज-चालित हार्नेस सुधार, मशीन-पठनीय रिपोर्ट, डीडुप्ड स्टैक-हैश्ड क्रैश) लेकिन यह बहुत छोटी और स्व-निहित है।

---

## त्वरित शुरुआत```bash
# Inside the codespace (or a host with python + git available):
./scripts/fuzzing/run_fuzzing.sh tukaani-project/xz

---

## आर्किटेक्चर

तीन परतें, ऊपर से नीचे:```
┌────────────────────────────────────────────────────────────────────┐
│  scripts/fuzzing/run_fuzzing.sh                                    │
│      shell driver; chains the taskflow stages with `set +e`        │
└────────────────────┬───────────────────────────────────────────────┘
                     │
                     ▼
┌────────────────────────────────────────────────────────────────────┐
│  src/seclab_taskflows/taskflows/fuzzing/*.yaml                     │
│      LLM agent prompts; one YAML per pipeline stage                │
└────────────────────┬───────────────────────────────────────────────┘
                     │  (calls MCP tools)
                     ▼
┌────────────────────────────────────────────────────────────────────┐
│  src/seclab_taskflows/mcp_servers/                                 │
│   ├ fuzz_context.py    persistence (SQLite via SQLAlchemy)         │
│   └ fuzz_runner.py     subprocess wrappers (AFL, clang, lcov, ...) │
│                                                                    │
│  scripts/fuzzing/dashboard.py                                      │
│   read-only HTML view of fuzz_context.db                           │
└────────────────────────────────────────────────────────────────────┘

प्रति पुनरावृत्ति, प्रति हार्नेस, एजेंट:

1. इस हार्नेस की स्थिर कॉर्पस डायरेक्टरी के लिए `get_persistent_corpus_dir(harness_id)` को कॉल करता है।
2. `run_afl_for(afl_binary_path, seed_dir=<persistent corpus>, output_dir=<run dir>, seconds=<budget>, dictionary=<auto.dict>)` को कॉल करता है।
3. LCOV ट्रेसफ़ाइल और HTML रिपोर्ट उत्पन्न करने के लिए `run_coverage(cov_binary_path, inputs_dir=<run>/default/queue, output_dir=<run>/coverage)` को कॉल करता है।
4. एक `coverage_report` पंक्ति + प्रति-अनकवर आइटम `coverage_gap` पंक्तियों को स्थायी बनाने के लिए `store_coverage_from_lcov(run_id, lcov_path, html_path)` को कॉल करता है।
5. AFL की पुनरावृत्ति कतार को स्थायी कॉर्पस में मर्ज करने और आकार को सीमित रखने के लिए `cmin` चलाने हेतु `fold_queue_into_persistent_corpus(...)` को कॉल करता है।
6. `get_coverage_summary` + `get_coverage_gaps` को पढ़ता है, फिर या तो:
   - एक अनकवर ब्रांच तक पहुँचने के लिए एक नया सीड जोड़ता है (जिसे `coverage_feedback` टैग किया जाता है),
   - एक अतिरिक्त API को कॉल करने के लिए हार्नेस स्रोत को संपादित करता है,
   - एक गार्ड को संतुष्ट करने के लिए AFL को आवश्यक मैजिक कॉन्स्टेंट के लिए डिक्शनरी प्रविष्टियों को स्वतः जोड़ने हेतु `enrich_dictionary_from_uncovered(...)` को कॉल करता है, या
   - अंतराल को छोड़ देता है (कोल्ड एरर पथ / विक्रेता कोड)।
7. `store_iteration_note(repo, iteration_number, harness_id, note=<one line summary>)` को कॉल करता है ताकि डैशबोर्ड की पुनरावृत्ति टाइमलाइन ट्रैक कर सके कि क्या बदला।

**पठार का पता लगाना।** लूप जल्दी समाप्त हो जाता है जब दो लगातार पुनरावृत्तियों ने लाइन कवरेज के `<FUZZ_PLATEAU_THRESHOLD_PCT` (डिफ़ॉल्ट `1.0`) पूर्ण प्रतिशत अंक से कम लाभ प्राप्त किया हो।

---

## संरचना-जागरूक फ़ज़िंग

तीन पूरक तंत्र कच्चे बाइट म्यूटेशन की तुलना में मजबूत इनपुट उत्पन्न करते हैं।

### 1. प्रति-प्रारूप डिक्शनरी + कस्टम म्यूटेटर

उन लक्ष्यों के लिए जिनका `input_kind` किसी ज्ञात प्रारूप से मेल खाता है, टास्कफ़्लो पूर्व-निर्मित डिक्शनरी और `LLVMFuzzerCustomMutator` C स्रोत फ़ाइलें भेजता है:

| प्रारूप | डिक्शनरी | म्यूटेटर | नोट्स |
|--------|------------|---------|-------|
| `json` | `json.dict` | `json_mutator.c` | टोकन स्प्लाइस, संतुलित ब्रैकेट डुप/ड्रॉप, टाइप फ्लिप |
| `xml` | `xml.dict` | `xml_mutator.c` | टैग, एंटिटीज़, DTDs, बिलियन-लाफ्स टोकन |
| `regex` | `regex.dict` | `regex_mutator.c` | एंकर, क्लासेस, क्वांटिफायर, वास्तविक ReDoS पैटर्न |
| `binary_tlv` | _(कोई नहीं)_ | `binary_tlv_mutator.c` | लंबाई-प्रीफ़िक्स्ड रिकॉर्ड: लंबाई-ओवरफ़्लो / डुप / ड्रॉप |
| `png` | `png.dict` | _(binary_tlv का पुन: उपयोग)_ | PNG डिक्शनरी + binary_tlv म्यूटेटर |

इन्हें `write_initial_harnesses` (डिक्शनरी सीड्स के बगल में कॉपी की जाती है) और `build_harnesses` (म्यूटेटर AFL बाइनरी में लिंक किया जाता है) द्वारा स्वचालित रूप से उठाया जाता है। प्रत्येक म्यूटेटर 50% म्यूटेशन AFL के डिफ़ॉल्ट बाइट म्यूटेटर को सौंपता है ताकि हम इंजन की रैंडमाइज़ेशन न खोएँ।

एक नया प्रारूप जोड़ने के लिए: `src/seclab_taskflows/dictionaries/` में एक `<name>.dict` और/या एक `<name>_mutator.c` डालें, फिर इसे `fuzz_runner.py` के निचले भाग में `_FORMAT_ASSETS` मैप में पंजीकृत करें।

### 2. स्रोत-जागरूक (प्रोजेक्ट-विशिष्ट) स्मार्ट म्यूटेटर

अपरिचित प्रारूपों के लिए, या जब भी आप मजबूत प्रोजेक्ट-विशिष्ट टोकन चाहते हैं, `generate_smart_mutator` लक्ष्य रेपो की अपनी `.c`/`.h` फ़ाइलों को स्कैन करता है और एक `LLVMFuzzerCustomMutator` C फ़ाइल उत्सर्जित करता है जिसकी स्प्लाइस डिक्शनरी निम्न से निकाली जाती हैं:

- ≥3 वर्णमाला वर्णों वाले स्ट्रिंग लिटरल (कंपाइलर/लाइसेंस शोर, पथ, हेडर, asm कंस्ट्रेंट, प्रारूप स्पेसिफायर को फ़िल्टर करने के बाद),
- `#define`, `case`, और `enum` से 32-बिट संख्यात्मक कॉन्स्टेंट (0, 1, 256, 0xff… जैसे सामान्य छोटे-इंट शोर को फ़िल्टर करने के बाद)।

तीन फोकस उपलब्ध हैं:

| फोकस | क्या स्प्लाइस करता है | कब उपयोग करें |
|-------|-----------------|-------------|
| `strings` | केवल प्रोजेक्ट स्ट्रिंग लिटरल | टेक्स्ट प्रारूप (JSON, XML, YAML, CSV) |
| `constants` | केवल 32-बिट संख्यात्मक मैजिक मान | बाइनरी प्रोटोकॉल, मैजिक नंबर वाले हेडर |
| `combined` | दोनों | डिफ़ॉल्ट; आमतौर पर सर्वोत्तम |

`generate_smart_mutators(...)` (बहुवचन) को `HARNESS_CANDIDATES >= 3` के साथ जोड़ें ताकि प्रत्येक फोकस क्वालिफायर राउंड में एक उम्मीदवार हार्नेस बन जाए।

### 3. प्रोजेक्ट-जागरूक AFL डिक्शनरी + कवरेज-चालित संवर्धन

दो पूरक उपकरण अभियान के दौरान एक AFL `-x` डिक्शनरी बनाते और बढ़ाते हैं:

- **`generate_project_dictionary(source_root, output_path)`** — पुनरावृत्ति 1 से पहले एक बार चलता है, स्मार्ट म्यूटेटर द्वारा उपयोग किए जाने वाले समान स्रोत-टोकन सेट को स्थिर रूप से निकालता है और इसे AFL डिक्शनरी के रूप में लिखता है। संख्यात्मक कॉन्स्टेंट दोनों एंडियननेस में उत्सर्जित होते हैं ताकि फ़ज़र होस्ट बाइट ऑर्डर की परवाह किए बिना `memcmp(x, &magic, 4)` को संतुष्ट कर सके।

- **`enrich_dictionary_from_uncovered(source_root, dictionary_path, uncovered_locations)`** — प्रत्येक पुनरावृत्ति के कवरेज चरण के बाद चलता है, अनकवर लाइनों के पास सशर्त गार्ड (`strncmp/memcmp/strstr`, `case 0xN:`, `== 0xN`, `== 'X'`) के लिए आसपास के स्रोत को स्कैन करता है, और किसी भी नए टोकन को डिक्शनरी में जोड़ता है। इडेम्पोटेंट: पहले से मौजूद प्रविष्टि को कभी दोबारा नहीं जोड़ता।

### 4. कॉर्पस-स्प्लाइस ऑप

जब `corpus_dir` को `generate_smart_mutator` में पास किया जाता है, तो उत्पन्न C को एक कॉर्पस-स्प्लाइस ऑपरेटर भी मिलता है: पहली कॉल पर यह उस डायरेक्टरी से 64 फ़ाइलों तक लोड करता है (प्रत्येक 4 KiB तक सीमित), और उसके बाद उन फ़ाइलों के यादृच्छिक उप-क्षेत्रों को म्यूटेटेड इनपुट में स्प्लाइस कर सकता है। यह म्यूटेटर को एक रीकॉम्बिनेशन-शैली ऑपरेटर देता है जो AFL का स्टॉक हेवोक अच्छी तरह नहीं करता। `get_persistent_corpus_dir(...)` के साथ जोड़ें ताकि स्प्लाइस लाइब्रेरी "जो AFL ने पहले ही खोज लिया है उसे रीमिक्स करे"।

---

## पुनरावृत्तियों और अभियानों में स्थायी कॉर्पस

प्रत्येक हार्नेस की एक स्थिर कॉर्पस डायरेक्टरी होती है:```
<workspace>/corpus/harness_<id>/

---

## आउटपुट फ़ाइलें

सभी `~/.local/share/seclab-taskflow-agent/seclab-taskflows/` के अंतर्गत।

| पथ | सामग्री |
|------|----------|
| `fuzz_context/fuzz_context.db` | SQLite — लक्ष्य, हार्नेस, रन, कवरेज, क्रैश, निर्णय, कॉल ग्राफ़, हार्नेस सुझाव, पुनरावृत्ति नोट्स |
| `fuzz_runner/builds/` | निर्मित `.afl` और `.cov` बाइनरी |
| `fuzz_runner/runs/` | AFL आउटपुट डायरेक्टरी + LCOV फ़ाइलें + HTML कवरेज रिपोर्ट |
| `fuzz_runner/corpus/harness_<id>/` | प्रति हार्नेस स्थायी कॉर्पस (पुनरावृत्तियों और अभियानों में बना रहता है) |
| `fuzz_runner/repo/<owner>__<repo>/REPORT.md` | Markdown अभियान सारांश, निर्णय के अनुसार समूहीकृत क्रैश |
| `fuzz_runner/repo/<owner>__<repo>/vuln_<crash_id>.md` | प्रति-क्रैश markdown भेद्यता रिपोर्ट |
| `fuzz_runner/repo/<owner>__<repo>/call_graph.{dot,svg,md}` | स्थिर कॉल ग्राफ़ + पहुँचे/अपहुँचे ओवरले |

---

## डेटाबेस स्कीमा

`fuzz_context.db` में तालिकाएँ (SQLAlchemy के माध्यम से SQLite):

| तालिका | रुचि के कॉलम |
|-------|--------------------|
| `fuzz_target` | `repo, file, function, signature, input_kind` |
| `harness` | `target_id, repo, harness_path, afl_binary_path, cov_binary_path, build_status, version, sanitizers` |
| `seed_corpus` | `target_id, source, path, bytes_count, added_in_iteration` |
| `fuzz_run` | `harness_id, iteration_number, exec_per_sec, paths_total, crashes_count, status, output_dir, started_at, ended_at` |
| `coverage_report` | `run_id, lines_total, lines_hit, line_pct, fns_*, branches_*, lcov_path, html_path` |
| `coverage_gap` | `report_id, file, function, line, kind, reason_hint` |
| `crash` | `run_id, input_blob_path, minimized_path, stack_top_hash, sanitizer_output, verdict, bug_class, cwe, severity, vuln_report_path, reproducer_path, classification, notes` |
| `call_graph` | `repo, target_id, dot_path, svg_path, functions_total, functions_in_graph, functions_reached, functions_unreached, untouched_surface_json` |
| `harness_suggestion` | `repo, function_name, file, rationale, input_kind, priority` |
| `iteration_note` | `repo, harness_id, iteration_number, note, created_at` |

स्कीमा माइग्रेशन `fuzz_context.py` में `_migrate()` में स्थित हैं। नई TABLES
`Base.metadata.create_all()` द्वारा स्वतः-निर्मित होती हैं; केवल नए COLUMNS के लिए
PRAGMA-आधारित `ALTER TABLE` की आवश्यकता होती है।

---

## MCP टूल्स (एजेंट की शब्दावली)

एजेंट कभी सीधे AFL या clang को कॉल नहीं करता — यह MCP टूल्स को कॉल करके
पाइपलाइन को संयोजित करता है। पूरा सेट, उद्देश्य के अनुसार समूहीकृत:

### दृढ़ता (`fuzz_context.py`)

- `store_fuzz_target`, `get_fuzz_targets`
- `store_harness`, `update_harness_build`, `get_harnesses`
- `store_seed`, `start_fuzz_run`, `finish_fuzz_run`, `get_fuzz_runs`
- `store_coverage_from_lcov`, `get_coverage_summary`, `get_coverage_gaps`,
  `coverage_plateau_reached`
- `store_crash`, `update_crash_verdict`, `get_crashes`,
  `get_crashes_grouped`, `suggest_severity`
- `store_call_graph`, `get_call_graphs`, `get_repo_reached_functions`
- `store_harness_suggestion`, `get_harness_suggestions`
- `store_iteration_note`, `get_iteration_notes`

### बिल्ड / फ़ज़ / कवरेज (`fuzz_runner.py`)

- `check_tooling`, `workspace_paths`
- `compile_harness` — `.afl` और `.cov` बाइनरी बनाता है
- `run_afl_for`, `cmin`, `tmin`, `replay_under_asan`, `reproduce_crash`
- `run_coverage` — `.cov` बाइनरी के विरुद्ध AFL कतार को रीप्ले करता है, LCOV निर्यात करता है
- `extract_dictionary` — बाइनरी से प्रिंटेबल स्ट्रिंग्स निकालता है
- `package_reproducer` — एकल-क्रैश `.tgz` को बंडल करता है

### स्थायी कॉर्पस (v8)

- `get_persistent_corpus_dir`, `fold_queue_into_persistent_corpus`

### फ़ॉर्मेट एसेट्स (C5)

- `list_format_assets`, `get_format_dictionary`, `write_format_mutator`

### स्मार्ट म्यूटेटर + प्रोजेक्ट-जागरूक डिक्शनरी

- `generate_smart_mutator`, `generate_smart_mutators`
- `generate_project_dictionary`, `enrich_dictionary_from_uncovered`

टूल फ़ंक्शन `@mcp.tool()` (FastMCP) से सज्जित हैं। परीक्षणों के अंदर,
उन्हें `.fn` एट्रिब्यूट के माध्यम से आमंत्रित करें, जैसे
`fr.run_afl_for.fn(afl_binary_path=..., ...)`।

---

## ट्यूनेबल नॉब्स (पर्यावरण चर)

| चर | डिफ़ॉल्ट | उद्देश्य |
|----------|---------|---------|
| `HARNESS_CANDIDATES` | `1` | प्रति लक्ष्य लिखे गए उम्मीदवार हार्नेस की संख्या। OSS-Fuzz-Gen-शैली प्रतिस्पर्धा के लिए 2 या 3 पर सेट करें। क्वालिफायर चरण प्रत्येक को `QUALIFIER_SECONDS` तक चलाता है और लाइन % के आधार पर सर्वश्रेष्ठ रखता है। |
| `QUALIFIER_SECONDS` | `60` | क्वालिफायर चरण में प्रति-उम्मीदवार वॉल-क्लॉक बजट। |
| `FUZZ_PLATEAU_THRESHOLD_PCT` | `1.0` | लाइन-कवरेज लाभ (पूर्ण pp में) जिसके नीचे दो क्रमागत पुनरावृत्तियों को पठार माना जाता है और लूप जल्दी रुक जाता है। |
| `FUZZ_DASHBOARD_PORT` | `8765` | लाइव डैशबोर्ड के लिए पोर्ट। |
| `FUZZ_NO_DASHBOARD` | (अनसेट) | डैशबोर्ड शुरू करना छोड़ने के लिए `1` पर सेट करें। |
| `FUZZ_RUNNER_TIMEOUT` | `1200` | `fuzz_runner` में प्रति-टूल सबप्रोसेस टाइमआउट (सेकंड)। |
| `LOCAL_SHELL_TIMEOUT` | `180` | `local_shell` में प्रति-कमांड टाइमआउट (सेकंड)। |

साथ ही मानक एजेंट चर (`COPILOT_TOKEN`, `LOG_DIR`,
`FUZZ_CONTEXT_DIR`, …)। पूरी सूची के लिए प्रोजेक्ट रूट README देखें।

---

## पाइपलाइन का विस्तार

### नया फ़ॉर्मेट जोड़ना (म्यूटेटर + डिक्शनरी)

1. `dictionaries/<name>.dict` (AFL `-x` फ़ॉर्मेट) और/या
   `dictionaries/<name>_mutator.c` (libFuzzer कस्टम म्यूटेटर) छोड़ें।
2. `fuzz_runner.py` के निचले भाग में `_FORMAT_ASSETS` में पंजीकृत करें:   ```python
   "<name>": {
       "dictionary": "<name>.dict",
       "mutator": "<name>_mutator.c",
       "description": "Short one-liner about the format",
   },

कोडबेस परंपराएँ (इनका कैंपेन-इतिहास संस्करण भी `benchmark/improvements.md` में देखें):

- `os.environ.get(NAME, "default")` के बजाय
  `os.environ.get(NAME) or "default"` का उपयोग करें। अन्यथा YAML टेम्पलेट
  प्रतिस्थापन से आने वाली खाली स्ट्रिंग्स लौटा दी जाएँगी।
- नए एनोटेशन में `Optional[X]` के बजाय `X | None` (PEP 604) का उपयोग करें।
- टेस्ट MCP टूल्स को सीधे डेकोरेटेड नाम से नहीं, बल्कि `.fn(...)` के माध्यम से
  आमंत्रित करते हैं।
- टेस्ट में `/tmp/...` लिटरल्स से बचें — `tmp_path` pytest फिक्स्चर का उपयोग
  करें (लिंट नियम `S108`)।
- टेस्ट मेथड्स के अंदर सभी इनलाइन इम्पोर्ट्स के लिए `# noqa: PLC0415` आवश्यक है
  यदि आप उन्हें फ़ाइल के शीर्ष पर नहीं ले जा सकते (जैसे कि `pytest.skip` के बाद
  सशर्त रूप से इम्पोर्ट किए जाने पर)।
- कंपाउंड ट्रुथ टेस्ट के लिए प्रति-पंक्ति एक-असेर्शन (लिंट नियम `PT018`)।

सुधार ट्रैकर (`benchmark/improvements.md`) संस्करणों के आर-पार पाइपलाइन में जोड़े गए
बदलावों का स्थायी लॉग है। जब आप कोई महत्वपूर्ण फ़ीचर जोड़ें, तो वहाँ एक अनुभाग
जोड़ें जिसमें वर्णित हो कि क्या बदला, वह कहाँ स्थित है, और कौन-से टेस्ट उसकी रक्षा
करते हैं।

---

## शब्दावली

- **AFL++** — कवरेज-निर्देशित ग्रेबॉक्स फ़ज़र; यहाँ निष्पादन इंजन।
- **libAFLDriver** — स्टैटिक लाइब्रेरी जो AFL++ हार्नेस को libFuzzer
  एंट्री-पॉइंट परंपरा (`LLVMFuzzerTestOneInput`) का उपयोग करने देती है।
- **LCOV** — उद्योग-मानक कवरेज ट्रेसफ़ाइल प्रारूप। हम `llvm-cov export -format=lcov`
  के माध्यम से इसमें निर्यात करते हैं और इसे स्वयं पार्स करते हैं।
- **`stack_top_hash`** — ASan/UBSan स्टैक ट्रेस के शीर्ष N सामान्यीकृत फ़्रेम्स का
  16-अक्षर का हैश। क्रैश डिडुप्लीकेशन के लिए उपयोग किया जाता है।
- **स्थायी कॉर्पस** — `<workspace>/corpus/harness_<id>/` पर प्रति-हार्नेस
  डायरेक्टरी जो एक ही कैंपेन के पुनरावृत्तियों और पुनः-रन के आर-पार AFL के
  रोचक इनपुट्स को बनाए रखती है।
- **स्मार्ट म्यूटेटर** — एक `LLVMFuzzerCustomMutator` जिसके स्प्लाइस टोकन लक्ष्य के
  स्वयं के सोर्स कोड से निकाले जाते हैं (`generate_smart_mutator`)।
- **कस्टम म्यूटेटर (libFuzzer)** — उपयोगकर्ता-प्रदत्त C फ़ंक्शन जिसे इंजन द्वारा
  बफ़र को कैसे म्यूटेट करना है, इस पर पूर्ण स्वतंत्रता के साथ कॉल किया जाता है;
  AFL++ समान ABI का समर्थन करता है।
- **MCP टूल** — एक FastMCP-डेकोरेटेड फ़ंक्शन जिसे LLM एजेंट कॉल कर सकता है।
- **OSS-Fuzz / Fuzz-Introspector** — Google का ओपन-सोर्स-फ़ज़िंग
  इंफ्रास्ट्रक्चर और उसका सहयोगी कॉल-ग्राफ़/कवरेज विश्लेषण टूल।
  इस टास्कफ़्लो की कई सुविधाएँ (प्रति-प्रारूप म्यूटेटर, डिडुप-बाय-स्टैक,
  कॉल-ग्राफ़ + अनटच्ड API रिपोर्ट, मल्टी-कैंडिडेट हार्नेस) इनसे प्रेरित हैं।

---

## लाइसेंस

यह प्रोजेक्ट MIT ओपन सोर्स लाइसेंस की शर्तों के अंतर्गत लाइसेंस प्राप्त है। पूर्ण शर्तों के लिए कृपया [LICENSE](https://github.com/githubsecuritylab/seclab-taskflows-fuzzing/blob/main/LICENSE.txt) फ़ाइल देखें।

## मेंटेनर्स

[CODEOWNERS](https://github.com/githubsecuritylab/seclab-taskflows-fuzzing/blob/main/CODEOWNERS) देखें या GitHub Security Lab टीम से संपर्क करें।

## सहायता

इस प्रोजेक्ट के साथ सहायता प्राप्त करने के तरीके के बारे में विवरण के लिए [SUPPORT.md](https://github.com/githubsecuritylab/seclab-taskflows-fuzzing/blob/main/SUPPORT.md) देखें।

## आभार

यह प्रोजेक्ट [AFL++](https://github.com/AFLplusplus/AFLplusplus), [OSS-Fuzz](https://github.com/google/oss-fuzz), और [Fuzz-Introspector](https://github.com/ossf/fuzz-introspector) की अवधारणाओं और तकनीकों पर आधारित है।