सभी चार `JsonParser` कार्यान्वयनों में यह दोष समान रूप से मौजूद है। हमला उनमें से किसी के माध्यम से समान रूप से शोषणीय है — चाहे इनपुट `InputStream`, `Reader`, `DataInput`, या async non-blocking feeder API के माध्यम से आता हो।

**हमले के वेक्टर:**

| # | रणनीति | उदाहरण पेलोड | गहराई वृद्धि | प्रभावित पार्सर |
|---|----------|----------------|-----------------|------------------|
| 1 | ऐरे नेस्टिंग | `[[[…]]]` — 1,001 लगातार `[` टोकन | +1 per `[` | सभी चार |
| 2 | ऑब्जेक्ट नेस्टिंग | `{"k":{"k":{…}}}` — 1,001 लगातार `{` टोकन | +1 per `{` | सभी चार |
| 3 | वैकल्पिक नेस्टिंग | `[{"k":[{"k":…}]}]` — 1,001 मिश्रित `[`/`{` टोकन | +1 per `[` या `{` | सभी चार |

मुख्य अवलोकन:

- **ऐरे नेस्टिंग — न्यूनतम ओवरहेड:** केवल `[` और `]` टोकन आवश्यक हैं; कोई कुंजी, मान या व्हाइटस्पेस नहीं। 1,001 ब्रैकेट जोड़े का एक 2,002-बाइट पेलोड 1,000 की डिफ़ॉल्ट सीमा को पार करने के लिए पर्याप्त है।
- **ऑब्जेक्ट नेस्टिंग — बढ़ा हुआ हीप दबाव:** प्रत्येक `{` अतिरिक्त रूप से डेप्थ-चेन नोड के शीर्ष पर एक `JsonReadContext` कुंजी स्लॉट आवंटित करता है, जो अत्यधिक गहराई पर मेमोरी खपत को बढ़ाता है।
- **वैकल्पिक नेस्टिंग — वेब एप्लिकेशन फायरवॉल (WAF) चोरी:** दोहराए गए `[[[` या `{{{` अनुक्रमों का पता लगाने वाली पैटर्न-मिलान सुरक्षाएँ वैकल्पिक-टोकन नेस्टिंग के प्रति अंधी होती हैं; पार्सर का गहराई काउंटर टोकन प्रकार की परवाह किए बिना समान रूप से बढ़ता है।
- **नॉन-ब्लॉकिंग फीडर — समान पेलोड, अलग डिलीवरी सतह:** सभी तीन नेस्टिंग रणनीतियाँ `NonBlockingJsonParser` और `ByteArrayFeeder` API के माध्यम से समान रूप से शोषणीय हैं। दस्तावेज़ को मनमाने ढंग से छोटे टुकड़ों में वितरित किया जा सकता है; `NonBlockingJsonParserBase._startArrayScope()` / `_startObjectScope()` प्रत्येक संदर्भ-खोलने वाले टोकन पर गहराई काउंटर बढ़ाते हैं, चाहे बाइट्स कैसे भी आएँ, कई `feedInput()` कॉलों में गहराई जमा करते हैं।

सभी तीन नेस्टिंग रणनीतियाँ चार `JsonParser` कार्यान्वयनों में से किसी के माध्यम से पहुँची जा सकती हैं। 2.13.5 के साथ, पार्सिंग चुपचाप सफल होती है; इस उपचार के साथ, सभी तीन वेक्टर `StreamConstraintsException: Depth (1001) exceeds the maximum allowed nesting depth (1000)` फेंकते हैं।

---

### Sonatype-2022-6438 — असीमित संख्यात्मक टोकन लंबाई

**सुरक्षा विवरण**

| फ़ील्ड | मान |
|-------|-------|
| Sonatype ID | [sonatype-2022-6438](https://guide.sonatype.com/vulnerability/sonatype-2022-6438/security-details) |
| विवरण | jackson-core — सेवा अस्वीकार (DoS) |
| प्रकाशित | 2022-12-07 |
| स्रोत | Sonatype |
| CVSS v3.1 स्कोर | **7.5 HIGH** — `CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H` |
| CWE | [CWE-770](https://cwe.mitre.org/data/definitions/770.html) — बिना सीमा या थ्रॉटलिंग के संसाधनों का आवंटन |
| EPSS स्कोर | 0% |
| अपस्ट्रीम फिक्स PRs | [jackson-core#827](https://github.com/FasterXML/jackson-core/pull/827), [jackson-core#846](https://github.com/FasterXML/jackson-core/pull/846) |

**कमजोर विधियाँ (Sonatype द्वारा पहचाने गए)**

| विधि | नोट्स |
|--------|-------|
| `com.fasterxml.jackson.core.base.ParserBase._parseSlowInt(I)V` | कमजोर पैरामीटर: इंडेक्स 0 |
| `com.fasterxml.jackson.core.base.ParserBase.convertNumberToBigDecimal()V` | |
| `com.fasterxml.jackson.core.base.ParserMinimalBase.getValueAsDouble(D)D` | कमजोर पैरामीटर: इंडेक्स 0 |
| `com.fasterxml.jackson.core.util.TextBuffer.contentsAsDecimal()` | `BigDecimal` लौटाता है |
| `com.fasterxml.jackson.core.util.TextBuffer.contentsAsDouble(Z)D` | |
| `com.fasterxml.jackson.core.util.TextBuffer.contentsAsFloat(Z)F` | |

इनमें से प्रत्येक विधि अपनी लंबाई को पहले मान्य किए बिना कच्चे अंक बफर को संसाधित करती है। पर्याप्त रूप से लंबा संख्यात्मक टोकन पास करने पर असीमित हीप आवंटन और CPU थकावट होती है जब JVM अप्रतिबंधित बफर सामग्री से `BigInteger` या `BigDecimal` को इंस्टेंटिएट करने का प्रयास करता है।

---

**मूल कारण:** 2.15.0 से पहले, `JsonParser` ने पूर्णांक, वैज्ञानिक संकेतन, सरल फ्लोटिंग-पॉइंट, या यौगिक फ्लोटिंग-पॉइंट टोकन की बाइट लंबाई पर कोई सीमा नहीं लगाई थी। जब कोई पार्सर अपने आंतरिक `_textBuffer` को अंक एकत्र करने के लिए आवंटित करता है, तो एक हमलावर लाखों अंकों वाली एक संख्या प्रदान कर सकता है, जिससे बफर बिना सीमा के बढ़ता है और अंततः हीप मेमोरी समाप्त हो जाती है।

**कमजोर कोड पथ:**

दो संरचनात्मक रूप से भिन्न कमजोर पथ हैं — एक तीन सिंक्रोनस पार्सर्स द्वारा साझा किया गया, और दूसरा स्वतंत्र पथ async पार्सर के माध्यम से।

**पथ A — सिंक्रोनस पार्सर** (तीन कार्यान्वयन, एक साझा सिंक):```
JsonParser.nextToken()                         // common entry point
  │
  ├─ ReaderBasedJsonParser   ─┐
  ├─ UTF8StreamJsonParser     ├─→ ParserBase.resetInt() / resetFloat()
  └─ UTF8DataInputJsonParser ─┘         │
                                        ▼
                               _textBuffer.contentsAsString()
                               ⚠  no length check — buffer grows without bound

गैर-अवरोधक (async) पार्सर एक विशेष रूप से उल्लेखनीय हमले की सतह है: इसमें `_startPositiveNumber`, `_startNegativeNumber`,
`_finishNumberIntegralPart`, `_startFloat`, `_finishFloatFraction`, और `_finishFloatExponent` में अपने स्वयं के
अंक-संचय लूप हैं जो `ParserBase.resetInt()` या `resetFloat()` के माध्यम से कभी नहीं जाते हुए सीधे
`_intLength` / `_fractLength` / `_expLength` सेट करते हैं। इसका मतलब है कि अपस्ट्रीम PR #827 फिक्स (जिसने केवल
`ParserBase` में सत्यापन जोड़ा) **ने `NonBlockingJsonParser` को पूरी तरह से असुरक्षित छोड़ दिया**।
यह विस्तारित हमले-सतह विश्लेषण के दौरान खोजा गया था और इस शाखा में सुधार किया गया।

**हमले के वेक्टर:**

| # | टोकन आकार | उदाहरण पेलोड | `intLen` | `fractLen` | `expLen` | कुल | बाध्यता |
|---|------------|----------------|----------|------------|----------|-------|------------|
| 1 | पूर्णांक | `999…` — 199,999 क्रमागत अंक | 199,999 | 0 | 0 | 199,999 | `validateIntegerLength` |
| 2 | दशमलव भिन्न | `0.999…` — 1-अंकीय पूर्णांक, 1,001-अंकीय भिन्न | 1 | 1,001 | 0 | 1,002 | `validateFPLength` |
| 3 | वैज्ञानिक संकेतन | `1e999…` — 1-अंकीय सार्थकांक, 1,001-अंकीय घातांक | 1 | 0 | 1,001 | 1,002 | `validateFPLength` |
| 4 | यौगिक फ्लोटिंग-पॉइंट | `0.999…e999…` — 500-अंकीय भिन्न, 500-अंकीय घातांक | 1 | 500 | 500 | 1,001 | `validateFPLength` |

मुख्य अवलोकन:

- **पूर्णांक — चिह्न वर्ण कोई अंक नहीं है:** अग्रणी `-` को अंक संचय से बाहर रखा गया है; `-999…` और `999…` समान `intLen` मान उत्पन्न करते हैं और समान सीमा पर बाध्यता को ट्रिगर करते हैं।
- **दशमलव भिन्न — छोटा पूर्णांक, असीमित भिन्न:** पूर्णांक भाग एक एकल अंक (0) हो सकता है जबकि भिन्नात्मक भाग बिना किसी सीमा के बढ़ता है; दशमलव बिंदु स्वयं गणना से बाहर रखा गया है।
- **वैज्ञानिक संकेतन — कॉम्पैक्ट फिर भी विनाशकारी:** लगभग 1,004 बाइट्स पर यह सबसे छोटा प्रभावी पेलोड है; यह पैमाने ±10^1001 के साथ एक `BigDecimal` के इंस्टेंटिएशन को मजबूर करता है, टोकन के छोटे आकार के बावजूद असीमित मध्यवर्ती हीप आवंटन की मांग करता है।
- **यौगिक फ्लोटिंग-पॉइंट — विभाजित-सीमा चोरी:** `fractLen = 500` और `expLen = 500` के साथ, कोई भी घटक व्यक्तिगत रूप से 1,000-अंक सीमा तक नहीं पहुंचता है। एकीकृत जाँच `validateFPLength(intLen + fractLen + expLen)` ही एकमात्र बचाव है जो इस अंतर को बंद करता है।
- **गैर-अवरोधक पार्सर — स्वतंत्र बाईपास:** उपरोक्त सभी चार टोकन आकार `ByteArrayFeeder` के माध्यम से `NonBlockingJsonParser` के माध्यम से स्वतंत्र रूप से शोषण योग्य हैं। सिंक्रोनस पार्सर्स के विपरीत, `NonBlockingJsonParser` निजी लूप (`_startPositiveNumber`, `_finishNumberIntegralPart`, `_startFloat`, `_finishFloatFraction`, `_finishFloatExponent`) में अंक जमा करता है जो सीधे `_intLength` / `_fractLength` / `_expLength` लिखते हैं, `ParserBase.resetInt()` और `resetFloat()` को पूरी तरह से बायपास करते हैं। अपस्ट्रीम PR #827 — जिसने केवल `ParserBase` को संशोधित किया था — ने इसलिए इस पार्सर को पूरी तरह से असुरक्षित छोड़ दिया, इस सुधार में छह स्वतंत्र कॉल-साइट पैच की आवश्यकता है।

सभी चार टोकन आकार और गैर-अवरोधक बाईपास को टोकनीकरण समय पर अस्वीकार कर दिया जाता है — किसी भी `BigDecimal` या `BigInteger`
के निर्माण से पहले — `ParserBase` (सिंक्रोनस पार्सर्स) में `validateIntegerLength` और `validateFPLength` द्वारा 
और `NonBlockingJsonParser` (एसिंक पार्सर) में छह समर्पित कॉल साइटों पर। 2.13.5 के साथ, सभी चार टोकन आकार मौन रूप से स्वीकार किए जाते हैं; इस सुधार के साथ, प्रत्येक पार्सर फेंकता है
`StreamConstraintsException: Number length (N) exceeds the maximum length (1000)`।

> **बड़े पेलोड के साथ `UTF8DataInputJsonParser` पर ध्यान दें:** DataInput पार्सर में
> 65,536 बाइट्स की पूर्व-मौजूदा आंतरिक बफर सीमा है ([jackson-core#493](https://github.com/FasterXML/jackson-core/issues/493))।
> इस आकार से अधिक दस्तावेज़ (जैसे, 199,999-अंकीय PoC पेलोड ≈ 200 KB) लंबाई बाध्यता फायर होने से पहले
> `ArrayIndexOutOfBoundsException` ट्रिगर करते हैं। `UTF8DataInputJsonParser` के लिए संख्यात्मक लंबाई
> सुरक्षा इसलिए छोटे पेलोड (≤ 1,001 अंक) के साथ सत्यापित की जाती है जहाँ बग अभी भी प्रतिलिपि प्रस्तुत करने योग्य है।

---

### SNYK-JAVA-COMFASTERXMLJACKSONCORE-15907551 / GHSA-2m67-wjpj-xhg9 — दस्तावेज़ लंबाई बाध्यता बाईपास

**सुरक्षा विवरण**

| फ़ील्ड | मान |
|-------|-------|
| Snyk ID | [SNYK-JAVA-COMFASTERXMLJACKSONCORE-15907551](https://security.snyk.io/vuln/SNYK-JAVA-COMFASTERXMLJACKSONCORE-15907551) |
| GitHub Advisory | [GHSA-2m67-wjpj-xhg9](https://github.com/FasterXML/jackson-core/security/advisories/GHSA-2m67-wjpj-xhg9) |
| विवरण | सीमा या थ्रॉटलिंग के बिना संसाधनों का आवंटन |
| प्रकट | 2026-04-04 |
| CVSS v4.0 स्कोर | **8.7 उच्च** |
| CWE | [CWE-770](https://cwe.mitre.org/data/definitions/770.html) — सीमा या थ्रॉटलिंग के बिना संसाधनों का आवंटन |
| प्रभावित संस्करण | [2.8.0, 2.21.2) |
| अपस्ट्रीम फिक्स | jackson-core 2.18.7, 2.21.2 या उच्चतर |
| फिक्स कमिट | [74c9ee25](https://github.com/FasterXML/jackson-core/commit/74c9ee25) (3.x), [7ce3622f](https://github.com/FasterXML/jackson-core/commit/7ce3622f) (2.18.x) |

**मूल कारण:** भले ही `StreamReadConstraints.maxDocumentLength` कॉन्फ़िगर किया गया हो, 2.18.7 / 2.21.2 से पहले के संस्करण
किसी भी पार्सर पथ में दस्तावेज़ लंबाई सीमा लागू नहीं करते हैं। ब्लॉकिंग पार्सर्स
(`UTF8StreamJsonParser`, `ReaderBasedJsonParser`) कभी भी कॉन्फ़िगर की गई सीमा के विरुद्ध संचित बाइट्स पढ़े गए की जाँच नहीं करते हैं। एसिंक पार्सर (`NonBlockingJsonParser`) में भी इसी तरह
`feedInput()` में सत्यापन का अभाव है। `UTF8DataInputJsonParser` के पास खपत किए गए कुल बाइट्स को ट्रैक करने का कोई तंत्र नहीं है।

jackson-core 2.13.5 में, `maxDocumentLength` बिल्कुल भी मौजूद नहीं था, जिसका अर्थ है कि दस्तावेज़ आकार को
बाधित करने का कोई तरीका नहीं था। यह सुधार `StreamReadConstraints` में `maxDocumentLength` फ़ील्ड का परिचय देता है
और इसे सभी पार्सर पथों पर लागू करता है।

**कमजोर पार्सर पथ:**

| पार्सर | पथ | प्रवर्तन बिंदु |
|--------|------|-------------------|
| `UTF8StreamJsonParser` | `InputStream` → `_loadMore()` | प्रत्येक बफर रीफिल के बाद और EOF पर `_currInputProcessed + count` को मान्य करता है |
| `ReaderBasedJsonParser` | `Reader` → `_loadMore()` | `UTF8StreamJsonParser` के समान पैटर्न |
| `NonBlockingJsonParser` | `feedInput()` | प्रत्येक इनपुट चंक के बाद `_currInputProcessed + _origBufferLen` को मान्य करता है |
| `UTF8DataInputJsonParser` | `DataInput` | फ़ेल-फ़ास्ट: `maxDocumentLength` कॉन्फ़िगर होने पर `StreamConstraintsException` फेंकता है |

**हमले का परिदृश्य:** एक हमलावर एक वैध लेकिन अत्यधिक बड़ा JSON दस्तावेज़ (जैसे, गीगाबाइट तक फैली गहराई से
नेस्टेड या अत्यधिक दोहराव वाली संरचना) उस सेवा को भेजता है जिसने संसाधन थकावट को रोकने के लिए
`maxDocumentLength` कॉन्फ़िगर किया है। प्रवर्तन के बिना, पार्सर कॉन्फ़िगर की गई सीमा की परवाह किए बिना पूरे दस्तावेज़ को संसाधित करता है, असीमित मेमोरी और CPU की खपत करता है।

---

## सुरक्षा प्रभाव

सभी चार कमजोरियाँ बिना किसी प्रमाणीकरण की आवश्यकता के दूर से शोषण योग्य हैं:

- कोई भी सेवा जो `JsonParser` के माध्यम से (सीधे या Jackson Databind के माध्यम से, जो `jackson-core` को लपेटता है) हमलावर-नियंत्रित JSON को पार्स करती है, जोखिम में है।
- हमला तुच्छ रूप से निर्माण योग्य है — कुछ सौ बाइट्स का JSON असीमित संसाधन खपत को ट्रिगर करने के लिए पर्याप्त है।
- कोई गोपनीयता या अखंडता प्रभाव नहीं; उपलब्धता (DoS) ही एकमात्र प्रभाव वर्ग है।

---

## सुधार विवरण

### आधिकारिक उन्नयन (अनुशंसित)

**jackson-core 2.15.4** या किसी भी बाद के स्थिर रिलीज़ में अपग्रेड करें। सभी 2.15.x और 2.16+ रिलीज़ में
सुरक्षित डिफ़ॉल्ट के साथ `StreamReadConstraints` API शामिल है।```xml
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.15.4</version>
</dependency>

सत्यापन विधियाँ (प्रत्येक नए टोकन पर पार्सर द्वारा कॉल की गई):```java
void validateNestingDepth(int depth) throws StreamConstraintsException;
void validateIntegerLength(int length) throws StreamConstraintsException;
void validateFPLength(int length) throws StreamConstraintsException;
void validateStringLength(int length) throws StreamConstraintsException;
void validateBigIntegerScale(int scale) throws StreamConstraintsException;

नई हेल्पर विधियाँ `_createChildArrayContext()` और `_createChildObjectContext()` गहराई जांच के साथ संदर्भ निर्माण को लपेटती हैं:```java
protected JsonReadContext _createChildArrayContext(int line, int col) throws IOException {
    _streamReadConstraints.validateNestingDepth(_parsingContext.getNestingDepth() + 1);
    return _parsingContext.createChildArrayContext(line, col);
}

#### `json/JsonReadContext.java`

`createChildArrayContext()` और `createChildObjectContext()` के सिग्नेचर को `throws IOException` को प्रचारित करने के लिए अपडेट किया गया।

#### `json/async/NonBlockingJsonParser.java` (Sonatype-2022-6438 only)

यह अपस्ट्रीम PR #827 के दायरे से परे खोजा गया मुख्य अतिरिक्त सुधार है। छह नंबर-समाप्ति साइटें जो `ParserBase.resetInt()` को बायपास करती थीं, उन्हें व्यक्तिगत रूप से ठीक किया गया:

| Method | जोड़ा गया सत्यापन |
|--------|------------------|
| `_startPositiveNumber()` — फास्ट-पथ रिटर्न | `validateIntegerLength(_intLength)` |
| `_startNegativeNumber()` — फास्ट-पथ रिटर्न | `validateIntegerLength(_intLength)` |
| `_finishNumberIntegralPart()` — अंतिम रिटर्न | `validateIntegerLength(_intLength)` |
| `_finishToken()` case `MINOR_NUMBER_INTEGER_DIGITS` | `validateIntegerLength(_intLength)` |
| `_startFloat()` / `_finishFloatFraction()` / `_finishFloatExponent()` अंतिम रिटर्न | `validateFPLength(_intLength + _fractLength + _expLength)` |
| `_finishToken()` cases `MINOR_NUMBER_FRACTION_DIGITS` / `MINOR_NUMBER_EXPONENT_DIGITS` | `validateFPLength(...)` |

सभी साइटें पहुंच योग्य हैं: फास्ट-पथ विधियाँ उस मामले को संभालती हैं जहां पूरा नंबर एक ही `feedInput()` कॉल में उपलब्ध है; `MINOR_*` रिज्यूम-स्टेट मामले चंक्ड केस को संभालते हैं जहां नंबर अंक कई कॉलों में आते हैं। दोनों पथों को सुरक्षित रखा जाना चाहिए।

---

## परीक्षण कवरेज

### CVE-2025-52999 — नेस्टिंग गहराई परीक्षण

| परीक्षण फ़ाइल | परीक्षण विधि | पार्सर मोड | कवर करता है |
|-----------|-------------|-------------|--------|
| `read/ArrayParsingTest.java` | `testCVE_2025_52999` | stream | रिकर्सिव ट्रैवर्सल जो वास्तविक ऐप उपयोग का अनुकरण करता है; गहराई 1001 पर `StreamConstraintsException` (ठीक किया गया) और गहराई 20,000 पर `StackOverflowError` (2.13.5) की पुष्टि करता है |
| `read/ArrayParsingTest.java` | `testCustomNestingDepthConstraint` | direct API | `StreamReadConstraints.builder().maxNestingDepth(5)` — एक्सेसर, सीमा पर पास, सीमा से ऊपर थ्रो |
| `read/ArrayParsingTest.java` | `testObjectNestingDepthLimit` | stream | ऑब्जेक्ट बिल्कुल सीमा 1000 पर (पास), 1001-स्तरीय ऑब्जेक्ट थ्रो करते हैं |
| `read/ArrayParsingTest.java` | `testDataInputParserDepthLimit` | `UTF8DataInputJsonParser` | `UTF8DataInputJsonParser` 1001-स्तरीय गहराई सीमा लागू करता है |
| `read/ArrayParsingTest.java` | `testNonBlockingParserDepthLimit` | non-blocking | `NonBlockingJsonParser` 1001-स्तरीय गहराई सीमा लागू करता है |

### Sonatype-2022-6438 — संख्यात्मक लंबाई परीक्षण

| परीक्षण फ़ाइल | परीक्षण विधि | पार्सर मोड | कवर करता है |
|-----------|-------------|-------------|--------|
| `read/NumberOverflowTest.java` | `testSonatype_2022_6438` | `ALL_MODES` | पूर्णांक सीमा पर (पास), पूर्णांक सीमा से ऊपर (असफल), फ्लोट सीमा पर (पास), फ्लोट सीमा से ऊपर (असफल), वैज्ञानिक संकेतन घातांक सीमा पर (पास), घातांक सीमा से ऊपर (असफल) — सभी चार पार्सर |
| `read/NumberOverflowTest.java` | `testNonBlockingParserNumericLengthLimit` | non-blocking | `NonBlockingJsonParser` संख्यात्मक लंबाई लागू करता है |
| `read/NumberOverflowTest.java` | `testNonBlockingParserExponentLengthLimit` | non-blocking | `NonBlockingJsonParser` `validateFPLength` के माध्यम से वैज्ञानिक संकेतन घातांक लंबाई लागू करता है |
| `read/NumberOverflowTest.java` | `testCustomMaxNumberLengthConstraint` | direct API | `StreamReadConstraints.builder().maxNumberLength(5)` — एक्सेसर, सीमा पर पास, सीमा से ऊपर थ्रो `validateIntegerLength()` और `validateFPLength()` दोनों के लिए, त्रुटि संदेश प्रारूप |

> **पार्सर मोड की कुंजी:**
> - `ALL_STREAMING_MODES` = `UTF8StreamJsonParser` (स्ट्रीम), `UTF8StreamJsonParser` (थ्रॉटल), `ReaderBasedJsonParser`
> - `ALL_MODES` = उपरोक्त तीन + `UTF8DataInputJsonParser`
> - `non-blocking` = `NonBlockingJsonParser` द्वारा `ByteArrayFeeder`
> - `stream` = `UTF8StreamJsonParser` (डिफ़ॉल्ट `JsonFactory.createParser`)

### SNYK-JAVA-COMFASTERXMLJACKSONCORE-15907551 — दस्तावेज़ लंबाई परीक्षण

| परीक्षण फ़ाइल | परीक्षण विधि | पार्सर मोड | कवर करता है |
|-----------|-------------|-------------|--------|
| `constraints/LargeDocReadTest.java` | `testInputStreamExceedsLimit` | `UTF8StreamJsonParser` | InputStream पार्सर `maxDocumentLength` लागू करता है — 10K सीमा के साथ 20K दस्तावेज़ अस्वीकार |
| `constraints/LargeDocReadTest.java` | `testInputStreamUnderLimitSucceeds` | `UTF8StreamJsonParser` | InputStream पार्सर सीमा के भीतर दस्तावेज़ स्वीकार करता है |
| `constraints/LargeDocReadTest.java` | `testReaderExceedsLimit` | `ReaderBasedJsonParser` | Reader पार्सर `maxDocumentLength` लागू करता है — 10K सीमा के साथ 20K दस्तावेज़ अस्वीकार |
| `constraints/LargeDocReadTest.java` | `testReaderUnderLimitSucceeds` | `ReaderBasedJsonParser` | Reader पार्सर सीमा के भीतर दस्तावेज़ स्वीकार करता है |
| `constraints/LargeDocReadTest.java` | `testAsyncExceedsLimit` | `NonBlockingJsonParser` | Async पार्सर `maxDocumentLength` लागू करता है — `feedInput()` में 20K दस्तावेज़ अस्वीकार |
| `constraints/LargeDocReadTest.java` | `testAsyncUnderLimitSucceeds` | `NonBlockingJsonParser` | Async पार्सर सीमा के भीतर दस्तावेज़ स्वीकार करता है |
| `constraints/LargeDocReadTest.java` | `testDataInputWithDocLengthLimitFails` | `UTF8DataInputJsonParser` | DataInput पार्सर तेजी से विफल होता है जब `maxDocumentLength` कॉन्फ़िगर किया गया हो |
| `constraints/LargeDocReadTest.java` | `testDataInputWithoutDocLengthLimitWorks` | `UTF8DataInputJsonParser` | DataInput पार्सर `maxDocumentLength` कॉन्फ़िगर किए बिना सामान्य रूप से काम करता है |
| `constraints/LargeDocReadTest.java` | `testDefaultFactoryNoLimit` | `UTF8StreamJsonParser` | डिफ़ॉल्ट फैक्ट्री (कोई सीमा नहीं) बड़े दस्तावेज़ स्वीकार करती है |

---

## पूर्ण परीक्षण सूट परिणाम```
Tests run: 957, Failures: 0, Errors: 0, Skipped: 0

---

## सत्यापन परिणाम

### jackson-core 2.13.5 के विरुद्ध प्रतिगमन परीक्षण

CVE परीक्षण विधियाँ 2.13.5 कोडबेस पर **विफल** होने और सुधारित बिल्ड पर **पास** होने के लिए डिज़ाइन की गई थीं।

**`NumberOverflowTest#testSonatype_2022_6438`** 2.13.5 के विरुद्ध:```
FAIL — Sonatype-2022-6438 VULNERABILITY PRESENT: parser returned VALUE_NUMBER_INT
       for a 1001-digit integer — number length limit is not enforced

**दोनों परीक्षण सुधारित बिल्ड पर: PASS.**

---

## प्रमाण की अवधारणा

### CVE-2025-52999 — नेस्टिंग गहराई DoS```java
// Build a 1001-level nested array document (just over the limit)
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1001; i++) sb.append('[');
for (int i = 0; i < 1001; i++) sb.append(']');

JsonFactory factory = new JsonFactory();
JsonParser parser = factory.createParser(sb.toString());
try {
    while (parser.nextToken() != null) { }       // ← throws on 1001st '['
    System.err.println("VULNERABLE: no exception thrown");
} catch (StreamConstraintsException e) {
    System.out.println("REMEDIATED: " + e.getMessage());
    // Depth (1001) exceeds the maximum allowed nesting depth (1000)
} finally {
    parser.close();
}

---

## प्रवासन मार्गदर्शिका

### विकल्प 1: jackson-core 2.15.4+ में अपग्रेड करें (अनुशंसित)```xml
<!-- Maven -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.15.4</version>
</dependency>

<!-- Or with Jackson BOM -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson</groupId>
            <artifactId>jackson-bom</artifactId>
            <version>2.15.4</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

### विकल्प 2: इस सुरक्षा सुधार को लागू करें```bash
git clone https://github.com/sassoftware/jackson-core.git
cd jackson-core
git checkout 2.13.5-CVE-2025-52999-sonatype-2022-6438-GHSA-2m67-wjpj-xhg9
./mvnw install -DskipTests

---

## लाइसेंस

इसके तहत लाइसेंस प्राप्त [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0).```
Copyright 2024–2025 The Jackson Authors

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.