# interpreter हुक: डायनैमिक कोड एक्ज़ीक्यूशन सिंक पकड़ें

> कमांड लाइन से कोडबेस को स्कैन करके कई भाषाओं में डायनैमिक कोड एक्ज़ीक्यूशन सिंक पकड़ें, या कोड के एक टुकड़े को स्कोर दें।

कैनोनिकल: https://lagune.ai/hi-IN/docs/hooks/interpreter
भाषा: hi-IN
मूल: https://lagune.ai/docs/hooks/interpreter
आख़िरी अपडेट: 2026-11-06

`interpreter` हुक **डायनैमिक कोड एक्ज़ीक्यूशन सिंक** पकड़ता है: ऐसी बनावटें जो डेटा को चलने वाले कोड में बदल देती हैं या उसे शेल को सौंप देती हैं, `eval` से लेकर नेटिव डीसीरियलाइज़ेशन तक। यह भाषा को समझता है और हर फ़ाइल को उसकी अपनी भाषा के नियमों से पढ़ता है। यही [`interpreter` विशेषज्ञता](https://lagune.ai/hi-IN/docs/catalog) के पीछे का नियतात्मक इंजन है, जिसे आप खुद **scan** या **check** मोड में चला सकते हैं।

## चलाएँ

**कोडबेस स्कैन करें**

```bash
npx lagune read interpreter               # scans the whole project
npx lagune read interpreter --dir src     # scans a directory
npx lagune read interpreter --file app.py # scans a single file
```

**कोड का टुकड़ा जाँचें**

```bash
npx lagune read interpreter --lang javascript --pattern 'eval(x)'   # => careful
npx lagune read interpreter --lang python --pattern 'json.loads(x)' # => safe
```

ये सिंक दोहरे इस्तेमाल वाले हैं: हमलावर के असर वाला इनपुट किसी सिंक तक पहुँचता है या नहीं, यह कोई स्टैटिक स्कैन तय नहीं कर सकता, इसलिए हर मैच **समीक्षा के लिए एक चेतावनी** है, पक्का निष्कर्ष कभी नहीं। स्कैन फ़ाइल के हिसाब से समूह बनाकर एक ही **Dynamic-execution sinks to review** सेक्शन प्रिंट करता है। कुछ न मिलने पर यह `no dynamic-execution sinks found` प्रिंट करता है।

**पकड़ा गया कोड पढ़ें, उसे कभी न चलाएँ!**

हर सिंक को **स्टैटिक** तरीके से परखें, यह खोजते हुए कि अविश्वसनीय इनपुट उस तक पहुँचता है या नहीं। पकड़ा गया कोड क्या करता है, यह "टेस्ट" करने के लिए उसे कभी न चलाएँ, न ही `eval` करें। यही बात उस रिमोट कोड या रनटाइम पर लाए गए कोड पर भी लागू होती है, जिसे वह अपने साथ खींच लाता है।

## फ़ैसला कैसे पढ़ें

| फ़ैसला    | मतलब                                                                                              |
| --------- | ------------------------------------------------------------------------------------------------- |
| `careful` | कोड के इस टुकड़े में उसकी भाषा का एक डायनैमिक एक्ज़ीक्यूशन सिंक है। इसे चलाकर नहीं, पढ़कर जाँचें। |
| `safe`    | दी गई भाषा के लिए कोई डायनैमिक एक्ज़ीक्यूशन सिंक नहीं मिला।                                       |

### CLI विकल्प

| विकल्प      | मान              | विवरण                                                                                                       |
| ----------- | ---------------- | ----------------------------------------------------------------------------------------------------------- |
| `--pattern` | कोड का एक टुकड़ा | कोड का एक टुकड़ा जाँचें। कई टुकड़े जाँचने के लिए इसे दोहराएँ, हर लाइन पर एक फ़ैसला मिलेगा।                  |
| `--lang`    | एक भाषा          | `--pattern` के साथ ज़रूरी: javascript, python, php, ruby, java, kotlin, go, rust, c, cpp, csharp में से एक। |
| `--dir`     | एक डायरेक्टरी    | स्कैन को एक डायरेक्टरी तक सीमित करें। इसे दोहराया जा सकता है और `--file` के साथ जोड़ा जा सकता है।           |
| `--file`    | एक फ़ाइल         | स्कैन को एक फ़ाइल तक सीमित करें। इसे दोहराया जा सकता है और `--dir` के साथ जोड़ा जा सकता है।                 |

कोई विकल्प न देने पर यह पूरे प्रोजेक्ट को स्कैन करता है। `--pattern` के लिए `--lang` ज़रूरी है, और इसे `--dir` या `--file` के साथ नहीं जोड़ा जा सकता।

### क्या स्कैन हो, यह चुनें

**Git** जिन चीज़ों को अनदेखा करता है, यह उन्हें छोड़ देता है। और चीज़ें छोड़ने के लिए, या **Git** की अनदेखी की गई चीज़ों को भी स्कैन करने के लिए, `interpreter` को उसकी अपनी सेटिंग दें:

```bash
npx lagune write add --ignore test/fixtures --checker interpreter
```

```json
{
  "checkers": {
    "interpreter": { "gitignore": false, "ignore": ["test/fixtures"] }
  }
}
```

[हुक कॉन्फ़िगर करें](https://lagune.ai/hi-IN/docs/hooks/configure) पेज पर हर सेटिंग की जानकारी है।

### समर्थित भाषाएँ

स्कैन इन भाषाओं को फ़ाइल एक्सटेंशन से पहचानकर पढ़ता है, और हर भाषा को उसके अपने डायनैमिक एक्ज़ीक्यूशन सिंक की सूची से जाँचता है।

| #   | भाषा                        | एक्सटेंशन                                                                                                    | यह कौन-से सिंक पकड़ता है                                                                                                                                                                                      |
| --- | --------------------------- | ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1   | **JavaScript / TypeScript** | `.js`, `.jsx`, `.mjs`, `.cjs`, `.ts`, `.tsx`, `.mts`, `.cts`, `.astro`, `.vue`, `.svelte`, `.marko`, `.riot` | `eval()`, Function कंस्ट्रक्टर, स्ट्रिंग बॉडी वाला `setTimeout`/`setInterval`, `vm` मॉड्यूल, `child_process` exec, डायनैमिक `require()`, डायनैमिक `import()`                                                  |
| 2   | **Python**                  | `.py`, `.pyi`                                                                                                | `eval`/`exec`, `__import__()`, `os.system`/`os.popen`, `subprocess` `shell=True`, `pickle.load`/`loads`, `yaml.load` (असुरक्षित)                                                                              |
| 3   | **Ruby**                    | `.rb`                                                                                                        | eval परिवार (`instance_eval`/`class_eval`/`module_eval`/`eval`), `system`/`exec`, बैकटिक या `%x`, `Kernel#open` / `IO.popen`/`read`/`binread` / `Open3`, `Process.spawn`, `Marshal.load`                      |
| 4   | **Go**                      | `.go`                                                                                                        | `exec.Command`/`exec.CommandContext`, `plugin.Open`                                                                                                                                                           |
| 5   | **PHP**                     | `.php`                                                                                                       | `eval()`, स्ट्रिंग पर `assert()`, `create_function()`, शेल exec (`system`/`exec`/`shell_exec`/`passthru`/`popen`/`proc_open`), `call_user_func`/`call_user_func_array`, रनटाइम पाथ के साथ `include`/`require` |
| 6   | **Rust**                    | `.rs`                                                                                                        | `Command::new`, `process::Command`                                                                                                                                                                            |
| 7   | **Java**                    | `.java`                                                                                                      | `Runtime.exec`, `ProcessBuilder`, `ScriptEngine`, `ObjectInputStream.readObject`                                                                                                                              |
| 8   | **Kotlin**                  | `.kt`, `.kts`                                                                                                | JVM वाले सिंक: `Runtime.exec`, `ProcessBuilder`, `ScriptEngine`, `ObjectInputStream.readObject`                                                                                                               |
| 9   | **C#**                      | `.cs`                                                                                                        | `Process.Start` / `new Process`, `BinaryFormatter`, `Assembly.Load`                                                                                                                                           |
| 10  | **C**                       | `.c`, `.h`                                                                                                   | `system()`, `popen()`, `exec*` परिवार (`execl`, `execve`, `execvp`, …)                                                                                                                                        |
| 11  | **C++**                     | `.cc`, `.cpp`, `.cxx`, `.hpp`, `.hh`, `.hxx`                                                                 | `system()`, `popen()`, `exec*` परिवार (`execl`, `execve`, `execvp`, …)                                                                                                                                        |

**पूरी कोशिश, पर हर मामला नहीं**

यह सोर्स कोड को टेक्स्ट की तरह पढ़ता है, इसलिए रनटाइम पर जोड़ा गया, किसी एलियास के पीछे छिपा, या ऐसे रूप में लिखा गया सिंक जिसे यह नहीं पहचानता, इसकी पकड़ से छूट सकता है। इस टेबल को पूरी सूची नहीं, बल्कि एक मज़बूत शुरुआती आधार मानें।

**टिप**

हुक न्यूनतम आधार की गारंटी देता है (ये सिंक मौजूद हैं, और कहाँ हैं): कोई अविश्वसनीय मान सच में किसी सिंक तक पहुँचता है या नहीं, यह आकलन [`interpreter` विशेषज्ञता](https://lagune.ai/hi-IN/docs/catalog) के दायरे में आता है।

## अक्सर पूछे जाने वाले सवाल

### क्या interpreter हुक किसी कमज़ोरी की पुष्टि करता है?

नहीं। यह डायनैमिक एक्ज़ीक्यूशन सिंक को समीक्षा के लिए एक चेतावनी के रूप में पकड़ता है, पक्के निष्कर्ष के रूप में कभी नहीं, क्योंकि हमलावर के असर वाला इनपुट सिंक तक पहुँचता है या नहीं, यह कोई स्टैटिक स्कैन तय नहीं कर सकता।

### interpreter हुक किन भाषाओं को सपोर्ट करता है?

यह "समर्थित भाषाएँ" टेबल की भाषाओं को फ़ाइल एक्सटेंशन से पहचानकर पढ़ता है, और हर भाषा को उसके अपने सिंक की सूची से जाँचता है। दूसरी भाषाओं में यह कोई सिंक नहीं बताता।