# cors हुक: CORS ऑरिजिन का ऑडिट करें

> कमांड लाइन से सोर्स कोड में ऐसी CORS ऑरिजिन अनुमति सूची खोजें जिसे बायपास किया जा सके, या किसी एक ऑरिजिन वैल्यू को स्कोर देकर देखें कि वह ज़रूरत से ज़्यादा एक्सेस तो नहीं देती।

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

`cors` हुक [`http-request` विशेषज्ञता](https://lagune.ai/hi-IN/docs/catalog) के पीछे का नियतात्मक इंजन है, और आप इसे खुद चला सकते हैं। एक ही कमांड से यह दो मोड में काम करता है: **scan**, जो सोर्स कोड में **बायपास की जा सकने वाली ऑरिजिन अनुमति सूची** खोजता है (होस्ट जाँचने वाला ऐसा regex जिससे हमलावर का होस्ट बचकर निकल जाता है), और **score**, जो किसी एक **CORS ऑरिजिन** वैल्यू को `wildcard`, `null` या `safe` के रूप में आँकता है।

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

कोई फ़्लैग न देने पर यह पूरा प्रोजेक्ट स्कैन करता है।

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

```bash
npx lagune read cors
```

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

```bash
npx lagune read cors --dir src/server
```

**एक फ़ाइल**

```bash
npx lagune read cors --file internal/auth/origin.go
```

यह बायपास की जा सकने वाली हर अनुमति सूची को एक ही हेडर के नीचे, फ़ाइल के हिसाब से समूहों में दिखाता है। अगर होस्ट जाँचने वाले regex में `.+`/`.*` भरोसेमंद होस्ट वाले सफ़िक्स से पहले authority हिस्से में हो (`^https?://.+\.trusted\.com`), तो `your-site.com.attacker.com` जैसा हमलावर होस्ट बचकर निकल जाता है।

```text
Origin-allowlist patterns with a greedy wildcard (bypassable, review):

internal/auth/origin.go
  ^https?://.+\.trusted\.com
```

यह समीक्षा के लिए एक सुराग है, पक्का निष्कर्ष नहीं: regex किसी असली भरोसे वाले फ़ैसले को नियंत्रित करता है या नहीं, यह सिर्फ़ टेक्स्ट से तय नहीं हो सकता, इसलिए स्कैन कभी एग्ज़िट कोड नहीं बदलता। हर एक को पढ़ें और पक्का करें कि अनुमति सूची पूरी वैल्यू का हूबहू मिलान करती है। कुछ न मिलने पर यह सिर्फ़ एक लाइन छापता है।

```bash
npx lagune read cors --dir src/clean
# => no bypassable origin allowlist found
```

## ऑरिजिन को स्कोर दें

हर ऑरिजिन `--origin` के साथ दें। हुक हर ऑरिजिन के लिए एक शब्द छापता है, और कोई भी `wildcard` या `null` मिलने पर नॉन-ज़ीरो एग्ज़िट कोड देता है।

**एक ऑरिजिन**

```bash
npx lagune read cors --origin '*'                       # => wildcard
npx lagune read cors --origin 'null'                    # => null
npx lagune read cors --origin 'https://app.example.com' # => safe
```

**कई ऑरिजिन**

पूरी अनुमति सूची को एक ही कॉल में स्कोर देने के लिए `--origin` दोहराएँ। हर लाइन में एक फ़ैसला आता है, उसी क्रम में।

```bash
npx lagune read cors \
  --origin 'https://app.example.com' \
  --origin '*' \
  --origin 'null'
# => safe
# => wildcard
# => null
```

| फ़ैसला     | मतलब                                                                                             |
| ---------- | ------------------------------------------------------------------------------------------------ |
| `safe`     | न `*`, न `null`, न ही कोई `*`-glob। इससे यह गारंटी नहीं मिलती कि ऑरिजिन सही ढंग से लिखा गया है।  |
| `wildcard` | `*`, या कोई सबडोमेन, होस्ट या पोर्ट glob: कोई भी साइट (या साइटों का बड़ा समूह) जवाब पढ़ सकती है। |
| `null`     | `null` ऑरिजिन, जिसे सैंडबॉक्स किए गए iframe और रीडायरेक्ट जाली बना सकते हैं।                     |

सिर्फ़ `safe` का मतलब अनुमति है, और `--origin` एक वैल्यू ऑरेकल है: यह वैल्यू को आँकता है, हैंडलर को नहीं, इसलिए हैंडलर की पुष्टि `http-request` विशेषज्ञता से करें।

### CLI विकल्प

| विकल्प     | वैल्यू        | विवरण                                                                                             |
| ---------- | ------------- | ------------------------------------------------------------------------------------------------- |
| `--origin` | एक ऑरिजिन     | एक ऑरिजिन वैल्यू को स्कोर दें। कई को स्कोर देने के लिए इसे दोहराएँ, हर लाइन में एक।               |
| `--dir`    | एक डायरेक्टरी | स्कैन को एक डायरेक्टरी तक सीमित करें। इसे दोहराया जा सकता है और `--file` के साथ जोड़ा जा सकता है। |
| `--file`   | एक फ़ाइल      | स्कैन को एक फ़ाइल तक सीमित करें। इसे दोहराया जा सकता है और `--dir` के साथ जोड़ा जा सकता है।       |

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

### चुनें कि यह क्या स्कैन करे

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

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

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

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

**यह क्या कवर नहीं करता**

स्कैन **बायपास किए जा सकने वाले regex** का पैटर्न पढ़ता है, और `--origin` ऑरिजिन की **वैल्यू** को स्कोर देता है। सोर्स कोड के दो पैटर्न इसकी पहुँच से बाहर रहते हैं: रिक्वेस्ट के `Origin` को लौटाना (सर्वर आए हुए `Origin` को ही वापस भेज देता है, या उसे क्रेडेंशियल के साथ जोड़ देता है), और `endsWith` या सबस्ट्रिंग पर आधारित ढीली अनुमति सूची। इन्हें कोड में पहचानें और उसी तरह संभालें जैसा [`http-request` विशेषज्ञता](https://lagune.ai/hi-IN/docs/catalog) बताती है।

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

### null CORS ऑरिजिन ख़तरनाक क्यों है?

सैंडबॉक्स किए गए iframe और कुछ रीडायरेक्ट Origin: null भेजते हैं, इसलिए जो अनुमति सूची null पर भरोसा करती है, वह इन संदर्भों को जवाब पढ़ने का एक्सेस दे देती है। cors हुक इसे वाइल्डकार्ड के साथ-साथ पकड़ता है।

### बायपास की जा सकने वाली CORS ऑरिजिन अनुमति सूची कैसे पकड़ूँ?

कोडबेस पर npx lagune read cors चलाएँ। यह होस्ट जाँचने वाले ऐसे regex को पकड़ता है जिसका ग्रीडी वाइल्डकार्ड भरोसेमंद सफ़िक्स से पहले आता है, जिससे your-site.com.attacker.com जैसा हमलावर होस्ट बचकर निकल जाता है।