# regex हुक: ReDoS पैटर्न पकड़ें

> कमांड लाइन से कोडबेस को स्कैन करके ReDoS के खतरे वाले रेगेक्स खोजें, या किसी एक पैटर्न को स्कोर दें।

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

`regex` हुक वह नियतात्मक रेगेक्स-सुरक्षा इंजन है जिसे [`regex` विशेषज्ञता](https://lagune.ai/hi-IN/docs/catalog) चलाती है, और आप इसे खुद भी चला सकते हैं। एक ही कमांड से यह दो मोड में काम करता है: **scan**, जो कोडबेस में **ReDoS** के खतरे वाले और रनटाइम पर बनने वाले पैटर्न खोजता है, और **check**, जो आपके दिए गए किसी एक पैटर्न को स्कोर देता है।

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

कोई फ़्लैग न देने पर यह पूरे प्रोजेक्ट को स्कैन करता है। `--dir` स्कैन को एक डायरेक्टरी तक और `--file` एक फ़ाइल तक सीमित करता है। दोनों को दोहराया जा सकता है और वे मिलकर एक ही रिपोर्ट बनाते हैं, जिसमें हर फ़ाइल एक ही बार आती है, चाहे वह एक से ज़्यादा टारगेट के दायरे में हो।

**पूरा प्रोजेक्ट**

```bash
npx lagune read regex
```

**एक डायरेक्टरी**

```bash
npx lagune read regex --dir src/services
```

**एक फ़ाइल**

```bash
npx lagune read regex --file bin/import.pl
```

**कई टारगेट**

```bash
npx lagune read regex --dir core --dir workers --file Sources/App/Router.swift
```

**सीमा के साथ**

`--limit` स्कैन के लिए ReDoS की सीमा तय करता है (डिफ़ॉल्ट 25), जो check मोड वाली सीमा ही है। सीमा जितनी कम, जाँच उतनी सख़्त।

```bash
npx lagune read regex --dir src/services --limit 15
```

आउटपुट सादा टेक्स्ट है, और हर सेक्शन का हेडर बताता है कि उसे कैसे पढ़ें। कोई सेक्शन तभी दिखता है जब उसमें कोई निष्कर्ष हो।

```text
Vulnerable regular expressions found:

cmd/server/main.go
  ([a-z]+)+$ (exponential, search)

Dynamically built regular expressions (review manually by simulating a constructed regex):

app/payments.php
crates/parser/lexer.rs
lib/validate.py

Static regex wrapped in a constructor (use a literal instead):

config/token.rb
```

कुछ न मिलने पर यह एक ही लाइन प्रिंट करता है।

```bash
npx lagune read regex --dir src/clean
# => no unsafe patterns found
```

### सेक्शन कैसे पढ़ें

| सेक्शन                                                                                      | मतलब                                                                                                                                                                                                                                                  |
| ------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Vulnerable regular expressions found`                                                      | ReDoS के खतरे वाले पैटर्न, फ़ाइल के हिसाब से समूह में, हर पैटर्न उसके नीचे इंडेंट करके। उसके बाद कोष्ठक में बताया जाता है कि वह असुरक्षित क्यों है, और अगर हों तो उसका स्कोप और उसके फ़्लैग भी। हर लाइन असुरक्षित है, इसलिए फ़ैसला दोहराया नहीं जाता। |
| `Regular expressions the analysis could not settle (review manually)`                       | वे पैटर्न जिन पर विश्लेषण अपनी काम की सीमा के अंदर किसी नतीजे पर नहीं पहुँच सका, उसी तरह सूचीबद्ध।                                                                                                                                                    |
| `Dynamically built regular expressions (review manually by simulating a constructed regex)` | वे फ़ाइलें जो किसी वेरिएबल से, स्ट्रिंगें जोड़कर या इंटरपोलेशन से रेगेक्स बनाती हैं।                                                                                                                                                                  |
| `Static regex wrapped in a constructor (use a literal instead)`                             | वे फ़ाइलें जो रेगेक्स कंस्ट्रक्टर को सादा स्ट्रिंग लिटरल देती हैं, जबकि रेगेक्स लिटरल ज़्यादा आसान है और रनटाइम कंपाइल से भी बचाता है।                                                                                                                |

पहला सेक्शन सुरक्षा से जुड़ा निष्कर्ष है। दूसरा और तीसरा अपने आप में निष्कर्ष नहीं हैं: वे ऐसे कोड की ओर इशारा करते हैं जिस पर कोई स्टैटिक जाँच फ़ैसला नहीं कर सकती, इसलिए उन्हें किसी इंसान को पढ़ना होगा। चौथा कोड को साफ़ बनाने का सुझाव है, सुरक्षा से जुड़ा निष्कर्ष नहीं।

### CLI विकल्प

| विकल्प      | मान                       | विवरण                                                                                                         |
| ----------- | ------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `--pattern` | रेगेक्स का सोर्स          | एक पैटर्न जाँचें। कई पैटर्न जाँचने के लिए इसे दोहराएँ, हर पैटर्न के लिए एक फ़ैसला, उसी क्रम में।              |
| `--flags`   | रेगेक्स फ़्लैग            | हर `--pattern` को इन फ़्लैग के साथ जाँचें, जैसे `im`। यह सिर्फ़ check मोड पर लागू होता है।                    |
| `--dir`     | एक डायरेक्टरी             | स्कैन को एक डायरेक्टरी तक सीमित करें। इसे दोहराया जा सकता है और `--file` के साथ जोड़ा जा सकता है।             |
| `--file`    | एक फ़ाइल                  | स्कैन को एक फ़ाइल तक सीमित करें। इसे दोहराया जा सकता है और `--dir` के साथ जोड़ा जा सकता है।                   |
| `--limit`   | शून्य या धनात्मक पूर्णांक | ReDoS में दोहराव की सीमा तय करें (डिफ़ॉल्ट 25)। यह दोनों मोड पर लागू होता है। सीमा जितनी कम, जाँच उतनी सख़्त। |

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

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

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

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

```json
{
  "checkers": {
    "regex": { "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` |
| 2   | **Python**                  | `.py`, `.pyi`                                                                                                |
| 3   | **Ruby**                    | `.rb`                                                                                                        |
| 4   | **Go**                      | `.go`                                                                                                        |
| 5   | **PHP**                     | `.php`                                                                                                       |
| 6   | **Rust**                    | `.rs`                                                                                                        |
| 7   | **Java**                    | `.java`                                                                                                      |
| 8   | **C#**                      | `.cs`                                                                                                        |
| 9   | **C**                       | `.c`, `.h`                                                                                                   |
| 10  | **C++**                     | `.cc`, `.cpp`, `.cxx`, `.hpp`, `.hh`, `.hxx`                                                                 |
| 11  | **Kotlin**                  | `.kt`, `.kts`                                                                                                |
| 12  | **Swift**                   | `.swift`                                                                                                     |
| 13  | **Scala**                   | `.scala`, `.sc`                                                                                              |
| 14  | **Dart**                    | `.dart`                                                                                                      |
| 15  | **PowerShell**              | `.ps1`, `.psm1`, `.psd1`                                                                                     |
| 16  | **Elixir**                  | `.ex`, `.exs`                                                                                                |
| 17  | **Objective-C**             | `.m`, `.mm`                                                                                                  |
| 18  | **R**                       | `.r`                                                                                                         |
| 19  | **Julia**                   | `.jl`                                                                                                        |
| 20  | **Clojure**                 | `.clj`, `.cljs`, `.cljc`, `.edn`                                                                             |
| 21  | **Crystal**                 | `.cr`                                                                                                        |
| 22  | **Nim**                     | `.nim`, `.nims`                                                                                              |
| 23  | **V**                       | `.v`                                                                                                         |
| 24  | **D**                       | `.d`                                                                                                         |
| 25  | **Perl**                    | `.pl`, `.pm`                                                                                                 |

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

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

## एक पैटर्न जाँचें

किसी पैटर्न को स्कोर देने के लिए उसका सोर्स `--pattern` के साथ दें। हुक एक शब्द प्रिंट करता है: `safe`, `unsafe`, `undetermined` (जब विश्लेषण पैटर्न पर नतीजे तक पहुँचने से पहले अपनी काम की सीमा तक पहुँच जाए), या `invalid regex`। कई पैटर्न एक साथ स्कोर करने के लिए `--pattern` दोहराएँ, हर पैटर्न के लिए एक फ़ैसला, उसी क्रम में।

**एक पैटर्न**

```bash
npx lagune read regex --pattern '(a+)+$'
# => unsafe

npx lagune read regex --pattern '^[a-z0-9_]{3,20}$'
# => safe
```

**कई पैटर्न**

```bash
npx lagune read regex --pattern '(a+)+$' --pattern '^[a-z]+$'
# => unsafe
# => safe
```

**फ़्लैग के साथ**

`--flags` कॉल के हर `--pattern` को उन्हीं फ़्लैग के साथ जाँचता है जिनके साथ वह चलता है, क्योंकि फ़्लैग से बदल जाता है कि पैटर्न किन कैरेक्टर से मैच करता है।

```bash
npx lagune read regex --pattern '^(?:a|A)+$'
# => safe

npx lagune read regex --pattern '^(?:a|A)+$' --flags 'i'
# => unsafe
```

**सीमा के साथ**

`--limit` दोहराव की सीमा तय करता है (डिफ़ॉल्ट 25) और कॉल के हर `--pattern` पर लागू होता है। सीमा जितनी कम, जाँच उतनी सख़्त।

```bash
npx lagune read regex --pattern 'a?a?a?' --limit 2
# => unsafe
```

**आर्ग्युमेंट कोट में क्यों**

हर पैटर्न फ़्लैग के मान के रूप में दिया जाता है, उसे कमांड के अंदर कभी जोड़ा नहीं जाता। कोट या बैकटिक वाला मान भी बेअसर रहता है और शेल में इंजेक्ट नहीं हो सकता। पैटर्न को हमेशा सिंगल कोट में रखें, ताकि आपका शेल पहले ही उसे एक्सपैंड न कर दे।

**टिप**

यह वही इंजन है जिसे [`regex` विशेषज्ञता](https://lagune.ai/hi-IN/docs/catalog) चलाती है: scan से ReDoS की जाँच शुरू होती है, और check उस जाँच में सामने आए पैटर्न की पुष्टि करता है।

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

### CLI से किसी रेगेक्स में ReDoS की जाँच कैसे करूँ?

npx lagune read regex --pattern '<pattern>' चलाएँ। यह safe, unsafe, undetermined या invalid regex लौटाता है।

### पूरे प्रोजेक्ट में असुरक्षित रेगेक्स कैसे स्कैन करूँ?

कोडबेस पर regex हुक को scan मोड में चलाएँ। यह 25 समर्थित भाषाओं में ReDoS के खतरे वाले पैटर्न की रिपोर्ट देता है।