# jwt हुक: बिना तय एल्गोरिदम वाला JWT वेरिफ़िकेशन पकड़ें

> कमांड लाइन से कोडबेस को स्कैन करके बिना तय एल्गोरिदम वाला JWT वेरिफ़िकेशन खोजें, या किसी एक कॉल को स्कोर दें।

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

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

## चलाएँ

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

```bash
npx lagune read jwt                # scans the whole project
npx lagune read jwt --dir src      # scans a directory
npx lagune read jwt --file auth.ts # scans a single file
```

**एक कॉल जाँचें**

```bash
npx lagune read jwt --lang javascript --pattern 'jwt.verify(token, secret)'                         # => unpinned
npx lagune read jwt --lang python --pattern 'jwt.decode(t, k, options={"verify_signature": False})' # => unpinned
npx lagune read jwt --lang python --pattern 'jwt.decode(t, k, algorithms=["HS256"])'                # => safe
```

**Unpinned JWT verification found** के नीचे की हर लाइन एक ऐसी वेरिफ़ाई कॉल है जो या तो कोई `algorithms` अनुमति सूची तय नहीं करती (जहाँ लाइब्रेरी को इसकी ज़रूरत है), या असुरक्षित सूची स्वीकार करती है (`none`, या HMAC के साथ मिला कोई एसिमेट्रिक एल्गोरिदम), या सिग्नेचर की जाँच ही पूरी तरह बंद कर देती है, और इस तरह टोकन के अपने `alg` पर भरोसा कर लेती है। यह पुष्ट जोखिम है, इसलिए हुक नॉन-ज़ीरो कोड के साथ बाहर निकलता है। कुछ न मिलने पर यह `no unpinned JWT verification found` प्रिंट करता है।

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

| फ़ैसला     | मतलब                                                                                                                 |
| ---------- | -------------------------------------------------------------------------------------------------------------------- |
| `unpinned` | ऐसी वेरिफ़ाई कॉल जिसमें एल्गोरिदम की अनुमति सूची नहीं है (जहाँ ज़रूरी है), सूची असुरक्षित है, या वेरिफ़िकेशन बंद है। |
| `safe`     | ऐसी वेरिफ़ाई कॉल जो एल्गोरिदम की सुरक्षित अनुमति सूची तय करती है, या जिसकी लाइब्रेरी इसे अपने आप तय कर देती है।      |
| `invalid`  | कोड के इस टुकड़े में जाँचने लायक कोई पहचानी जा सकने वाली वेरिफ़ाई कॉल नहीं है।                                       |

### CLI विकल्प

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

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

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

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

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

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

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

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

स्कैन इन लाइब्रेरी को फ़ाइल एक्सटेंशन से पहचानकर पढ़ता है। कुछ लाइब्रेरी एल्गोरिदम को अपने आप तय कर देती हैं (वहाँ अलग से सूची न होना सुरक्षित है), इसलिए "अनुमति सूची नहीं ⇒ unpinned" वाला नियम सिर्फ़ वहीं लागू होता है जहाँ लाइब्रेरी अलग से सूची की उम्मीद करती है। इस तरह सही ढंग से कॉन्फ़िगर की गई कॉल कभी नहीं पकड़ी जाती।

| भाषा                        | लाइब्रेरी               | अनुमति सूची न होने पर unpinned मानता है?                                   | हमेशा पकड़ता है                                  |
| --------------------------- | ----------------------- | -------------------------------------------------------------------------- | ------------------------------------------------ |
| **JavaScript / TypeScript** | jsonwebtoken, jose      | हाँ                                                                        | `none`, एसिमेट्रिक और HMAC का मेल                |
| **Python**                  | PyJWT, python-jose      | हाँ (PyJWT में यह ज़रूरी है, python-jose का डिफ़ॉल्ट `algorithms=None` है) | `none`, `verify_signature: False`                |
| **Go**                      | golang-jwt              | हाँ (`WithValidMethods` न होने पर)                                         | `none`, `ParseUnverified`                        |
| **Ruby**                    | ruby-jwt                | हाँ                                                                        | `none`, `verify = false`                         |
| **Java / Kotlin**           | jjwt, nimbus            | नहीं (एल्गोरिदम कुंजी से तय होता है)                                       | `none`, बिना सिग्नेचर वाला या `unsecured` पार्सर |
| **PHP**                     | firebase/php-jwt        | नहीं (`Key` में एल्गोरिदम शामिल रहता है)                                   | `none`                                           |
| **Rust**                    | jsonwebtoken            | नहीं (`Validation` में एल्गोरिदम बताना ज़रूरी है)                          | `none`, `insecure_disable_signature_validation`  |
| **C#**                      | Microsoft.IdentityModel | नहीं (पैरामीटर कई लाइनों में फैले होते हैं)                                | `none`, `RequireSignedTokens = false`            |

**टिप**

हुक सिर्फ़ एल्गोरिदम तय होने का फ़ैसला करता है: क्लेम, कुंजी और फ़्लो की जाँच ऐसे आकलन हैं जो अब भी [`federation` विशेषज्ञता](https://lagune.ai/hi-IN/docs/catalog) के दायरे में आते हैं।

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

### JWT एल्गोरिदम कन्फ़्यूज़न क्या है?

अगर वेरिफ़ाई करने वाला कोड टोकन के हेडर से एल्गोरिदम पढ़ता है, तो हमलावर RS256 की जगह HS256 रखकर पब्लिक कुंजी से साइन कर सकता है। कोड में एल्गोरिदम की सुरक्षित अनुमति सूची तय करने से यह रुकता है, और jwt हुक ऐसी वेरिफ़ाई कॉल पकड़ता है जो कोई सूची तय नहीं करती या असुरक्षित सूची तय करती है।