# कैटलॉग: ज़रूरत पड़ने पर ही लोड होने वाली सुरक्षा विशेषज्ञताएँ

> आपके प्रोजेक्ट के कैटलॉग की विशेषज्ञताएँ कैसे लोड होती हैं, ज़रूरत पड़ने पर किसी चरण के ज़रिए और सीधे आपके ज़रिए।

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

🧠 **Lagune** की विशेषज्ञताएँ सुरक्षा ज्ञान के केंद्रित मॉड्यूल हैं, जो किसी एक प्रोग्रामिंग भाषा से बंधे नहीं हैं और डिफ़ॉल्ट रूप से कभी लोड नहीं होते, सिर्फ़ ज़रूरत पड़ने पर ही लोड होते हैं। ये कमांड नहीं हैं। आपके प्रोजेक्ट का कैटलॉग वह सेट है जिसका प्रोजेक्ट इस्तेमाल करता है: उसकी [श्रेणियों](https://lagune.ai/hi-IN/docs/categories) की बिल्ट-इन विशेषज्ञताएँ और उसकी अपनी विशेषज्ञताएँ। detect और verify चरण चलते समय इनका सहारा लेते हैं, और आप भी किसी भी समय कोई विशेषज्ञता सीधे लोड कर सकते हैं।

**परिचय**

*इंटरैक्टिव कैटलॉग ओवरव्यू वेब पेज पर है। हर बिल्ट-इन विशेषज्ञता नीचे दी गई टेबल में है।*

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

## ख़ुद चलाएँ

किसी विशेषज्ञता का सीधे इस्तेमाल करने के लिए, अपने एजेंट से उसे `read catalog <name>` से लोड करने को कहें और उसी प्रॉम्प्ट में अपना काम भी लिखें। फिर वह ज्ञान आपके माँगे गए काम पर लागू होता है। यह किसी भी प्रॉम्प्ट में काम करता है, उसमें भी जिसका **Lagune** फ़्लो से कोई लेना-देना नहीं है।

उदाहरण के लिए, **Python** में सुरक्षित **RegExp** का संग्रह बनाने के लिए एक सीधा, अपने शब्दों में लिखा प्रॉम्प्ट:

```prompt
`npx lagune read catalog regex` से regex विशेषज्ञता लोड करो, फिर @src/utils/regex.py में ईमेल और यूज़रनेम जाँचने के लिए रेगुलर एक्सप्रेशन का एक संग्रह बनाओ।
```

इसमें एक नियतात्मक हुक हर **RegExp** को **ReDoS** के ख़िलाफ़ टेस्ट करता है, सुरक्षित पैटर्न रखता है, और कुछ ऐसा नतीजा देता है:

```python
import re

EMAIL = re.compile(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")
USERNAME = re.compile(r"^[a-zA-Z0-9_]{3,20}$")

def is_email(value: str) -> bool:
    return EMAIL.match(value) is not None

def is_username(value: str) -> bool:
    return USERNAME.match(value) is not None
```

**ReDoS चेकर आज़माएँ**

किसी पैटर्न को [**devina.io/redos-checker**](https://devina.io/redos-checker) पर ख़ुद टेस्ट करें।

## बिल्ट-इन विशेषज्ञताएँ

बिल्ट-इन विशेषज्ञताएँ [**श्रेणियों**](https://lagune.ai/hi-IN/docs/categories) में बँटी हुई हैं। **Lagune** के साथ आने वाला सेट यह है:

| विशेषज्ञता            | श्रेणी                      | मुख्य विषय                                                                                      |
| --------------------- | --------------------------- | ----------------------------------------------------------------------------------------------- |
| `regex`               | `owasp`                     | **ReDoS**: ऐसे पैटर्न जो जान-बूझकर गढ़े गए इनपुट पर बेक़ाबू हो जाते हैं।                        |
| `network`             | `owasp`                     | **SSRF और रीडायरेक्ट**: यूज़र के दिए फ़ेच या रीडायरेक्ट के गंतव्य।                              |
| `interpreter`         | `owasp`, `lovable`          | **कोड इंजेक्शन**: `eval`, डायनैमिक include, नाम के आधार पर डिस्पैच।                             |
| `sql`                 | `owasp`                     | **रिलेशनल डेटाबेस**: इंजेक्शन, रॉ ORM कॉल, अधिकार, इंजन की पहुँच।                               |
| `path`                | `owasp`                     | **फ़ाइल सिस्टम पाथ**: पाथ ट्रैवर्सल, null byte, NTFS स्ट्रीम, फ़ाइल प्लांटिंग।                  |
| `upload`              | `owasp`                     | **फ़ाइल अपलोड**: टाइप और सिग्नेचर, नुक़सानदेह कंटेंट, स्टोरेज, सीमाएँ।                          |
| `access-control`      | `owasp`, `lovable`          | **ऑथेंटिकेशन, ऑथराइज़ेशन, सेशन**: IDOR, मास असाइनमेंट, टेनेंट, सेशन।                            |
| `credential-endpoint` | `owasp`, `lovable`          | **अंदाज़े वाले हमले और बॉट**: ब्रूट फ़ोर्स, पासवर्ड स्प्रेइंग, क्रेडेंशियल स्टफ़िंग, थ्रॉटलिंग। |
| `federation`          | `owasp`                     | **टोकन पर भरोसा**: OAuth/OIDC, SAML, JWT वैलिडेशन, QR लॉगिन।                                    |
| `http-request`        | `owasp`                     | **रिक्वेस्ट का स्रोत**: CSRF, CORS की ग़लत कॉन्फ़िगरेशन, नक़ली क्लाइंट IP।                      |
| `transport`           | `owasp`                     | **चैनल सुरक्षा**: TLS कॉन्फ़िगरेशन, HTTPS और प्लेनटेक्स्ट, HSTS, पिनिंग।                        |
| `crypto`              | `owasp`, `lovable`          | **स्टोर किए गए डेटा की क्रिप्टोग्राफ़ी**: कमज़ोर या ख़ुद बनाए एल्गोरिदम, CSPRNG, कुंजी प्रबंधन। |
| `secrets`             | `owasp`, `lovable`          | **हार्डकोड किए गए क्रेडेंशियल**: सोर्स कोड में सीधे लिखी कुंजियाँ, टोकन, पासवर्ड।               |
| `api-endpoint`        | `owasp`                     | **REST के अलावा दूसरे सरफ़ेस**: GraphQL, gRPC, WebSocket ऑथराइज़ेशन, DoS, स्कीमा।               |
| `payment`             | `owasp`, `lovable`          | **चेकआउट फ़्लो**: सर्वर-साइड पर गेटवे की पुष्टि, साइन किए गए कॉलबैक, आइडेम्पोटेंसी।             |
| `xml`                 | `owasp`                     | **XML पार्सिंग**: XXE, एक्सटर्नल एंटिटी, billion laughs एक्सपैंशन।                              |
| `csv`                 | `owasp`                     | **फ़ॉर्मूला इंजेक्शन**: `=`/`+`/`-`/`@` से शुरू होने वाले स्प्रेडशीट सेल।                       |
| `container`           | `owasp`, `infra`            | **कंटेनर कॉन्फ़िगरेशन**: root यूज़र, कैपेबिलिटीज़, सॉकेट माउंट, इमेज हार्डनिंग।                 |
| `infra`               | `infra`                     | **इन्फ़्रास्ट्रक्चर ऐज़ कोड**: Terraform, Dockerfile, GitHub Actions।                           |
| `serverless`          | `owasp`, `infra`, `lovable` | **FaaS फ़ंक्शन**: कम से कम अधिकार वाला IAM, इवेंट इनपुट, कॉन्टेक्स्ट, सीक्रेट।                  |
| `llm`                 | `ai`, `lovable`             | **AI और LLM जोखिम**: प्रॉम्प्ट इंजेक्शन, ज़रूरत से ज़्यादा अधिकार (agency), RAG, MCP, आउटपुट।   |
| `supabase`            | `lovable`                   | **Supabase बैकएंड**: डिफ़ॉल्ट रूप से बंद RLS, AI की ग़लत बनाई पॉलिसियाँ, कुंजी मॉडल।            |
| `browser`             | `javascript`, `lovable`     | **क्लाइंट-साइड जोखिम**: XSS, CSP, फ़्रेमिंग, स्टोरेज आदि।                                       |
| `javascript`          | `javascript`                | **भाषा के स्तर के जोखिम**: RCE, प्रोटोटाइप पॉल्यूशन आदि।                                        |
| `python`              | `python`                    | **भाषा के स्तर के जोखिम**: `pickle` RCE, क्लास पॉल्यूशन, `-O` आदि।                              |
| `rust`                | `rust`                      | **`unsafe` की साउंडनेस**: safe कॉलर से पैदा होने वाला UB, `transmute`, ओवरफ़्लो।                |
| `java`                | `java`                      | **डीसीरियलाइज़ेशन और मोबाइल कोड**: `readObject` चेन, ऑब्जेक्ट हाइजैक।                           |
| `ruby`                | `ruby`                      | **डीसीरियलाइज़ेशन और `open`**: `Marshal`/YAML से ऑब्जेक्ट रिवाइवल, पाइप से जुड़ा अनोखा व्यवहार। |
| `php`                 | `php`                       | **टाइप जगलिंग और `unserialize`**: मैजिक हैश, POP चेन।                                           |
| `go`                  | `go`                        | **typed nil और डेटा रेस**: `nil != nil`, मेमोरी साझा करने वाले गोरूटीन।                         |
| `c-cpp`               | `c-cpp`                     | **फ़ॉर्मैट स्ट्रिंग**: `printf(user_input)`, `%n` से write-what-where।                          |
| `dotnet`              | `dotnet`                    | **प्लैटफ़ॉर्म के स्तर के जोखिम**: `BinaryFormatter` RCE, `@Html.Raw`, enum की कमियाँ।           |

ज़्यादातर बिल्ट-इन ज्ञान OWASP से सार निकालकर बना है। हर विशेषज्ञता का उसके मूल OWASP अटैक और Cheat Sheet पेजों से पूरा मिलान [**OWASP स्रोत**](https://lagune.ai/hi-IN/docs/references/owasp-sources) में देखें। कुछ स्टैक-विशेष मॉड्यूल इसके बजाय वेंडर के अपने दिशानिर्देशों से बने हैं: उदाहरण के लिए, `supabase` Supabase के डॉक्स और CVE-2025-48757 से लिया गया है।

## आपकी अपनी विशेषज्ञताएँ

बिल्ट-इन विशेषज्ञताएँ एक ज्ञान फ़ाइल और इंडेक्स की एक पंक्ति जोड़कर बढ़ती हैं, नई कमांड जोड़कर कभी नहीं। आप अपनी विशेषज्ञताएँ भी इसी तरह [`/lagune-specialize`](https://lagune.ai/hi-IN/docs/commands/specialize) कमांड से जोड़ते हैं: इसे कोई लेख या विषय दें, और यह उसका सार निकालकर आपके प्रोजेक्ट में एक नई विशेषज्ञता बना देती है, यानी `.lagune/catalog/` में फ़ाइल और `.lagune/configs.json` में उसकी एंट्री। आपकी अपनी विशेषज्ञताएँ कैटलॉग में हमेशा रहती हैं, उसकी श्रेणियाँ चाहे जो हों, और आपकी कोई विशेषज्ञता उसी नाम की बिल्ट-इन विशेषज्ञता की जगह ले लेती है।

**Lagune अंदर ही अंदर, ज़रूरत पड़ने पर विशेषज्ञताएँ अपने-आप लोड करता है**

जब detect या verify चरण किसी ऐसे संदर्भ पर पहुँचता है जिसे कोई विशेषज्ञता कवर करती है, तो वह चरण ख़ुद `read catalog <name>` से उस विशेषज्ञता को लोड करता है। यह चरण के हिस्से के रूप में अपने-आप होता है। इसके काम करने के लिए आपको कुछ भी हाथ से नहीं करना पड़ता।

## देखें कि क्या उपलब्ध है

टर्मिनल में अपने प्रोजेक्ट का कैटलॉग देखें, हर पंक्ति में एक विशेषज्ञता और उसके टैग के साथ:

```bash
npx lagune read catalog
# regex: Regular Expression [required]
# network: Requests, Webhook, URL Fetch, Socket, IMDS, Redirect
# interpreter: Evaluator, Sink, Shell, Dynamic Execution
# ...
```

`[required]` वाली विशेषज्ञता हमेशा लागू होती है, काम चाहे जो हो। सूची में कौन-सी बिल्ट-इन विशेषज्ञताएँ होंगी, यह आपके प्रोजेक्ट की [**श्रेणियों**](https://lagune.ai/hi-IN/docs/categories) पर निर्भर करता है।

**विशेषज्ञताएँ डिफ़ॉल्ट रूप से लोड नहीं होतीं**

हर जाँच डिफ़ॉल्ट रूप से चलाने के बजाय, प्रोजेक्ट असल में जैसा है, उसी के हिसाब से ज़रूरी ज्ञान लोड होता है।

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

### Lagune की विशेषज्ञता क्या है?

सुरक्षा ज्ञान का एक केंद्रित मॉड्यूल, जो किसी एक प्रोग्रामिंग भाषा से बंधा नहीं है और डिफ़ॉल्ट रूप से कभी नहीं, सिर्फ़ ज़रूरत पड़ने पर ही लोड होता है। यह एजेंट स्किल्स की तरह कमांड नहीं है।

### प्रोजेक्ट का कैटलॉग क्या है?

वे विशेषज्ञताएँ जिनका प्रोजेक्ट इस्तेमाल करता है: उसकी श्रेणियों की बिल्ट-इन विशेषज्ञताएँ और उसकी अपनी विशेषज्ञताएँ। जब तक कोई श्रेणी दर्ज नहीं होती, प्रोजेक्ट सिर्फ़ OWASP का इस्तेमाल करता है।

### क्या विशेषज्ञताएँ डिफ़ॉल्ट रूप से लोड होती हैं?

नहीं। ये सिर्फ़ ज़रूरत पड़ने पर ही लोड होती हैं, प्रोजेक्ट असल में जैसा है उसके हिसाब से।

### मैं किसी विशेषज्ञता को सीधे कैसे लोड करूँ?

अपने काम वाले उसी प्रॉम्प्ट में एजेंट से npx lagune read catalog <name> चलाने को कहें।