JSON Toolkit

एक JSON, दो फ़ैसले: पार्सर के अंतर और वैलिडेशन की भरोसे की सीमा

मुख्य बात: जब वैलिडेटर दस्तावेज़ स्वीकार कर ले और नीचे की सेवा क्रैश हो जाए, तो अक्सर दो पार्सरों ने उसी टेक्स्ट पर अलग-अलग निष्कर्ष निकाले होते हैं। यह लेख डुप्लिकेट कीज़, NUL बाइट्स, अवैध UTF-8, NaN और शुरुआती शून्य को असली रनटाइम पर जाँचता है, समझाता है कि CVE-2026-33948 पार्सर के अंतर को हमले की सतह कैसे बनाता है, और हर सीमा को एकमात्र निर्णायक कैसे दें, यह दिखाता है।

मध्यम~6 मिनट पढ़ें2026-11-11 को प्रकाशित2026-11-11 को अपडेट किया गया
एक ही JSON दस्तावेज़ पर दो उपकरणों के विपरीत फ़ैसले दिखाता कवर

वैलिडेशन पास करना सिर्फ़ एक बात साबित करता है: वह टेक्स्ट उस पार्सर ने, उस नीति के तहत स्वीकार किया था। पार्सर बदलिए, और फ़ैसला पलट सकता है।

लक्षण: उपकरण A पास करता है, उपकरण B अस्वीकार करता है

वह दृश्य हर किसी ने देखा है। एक API रिस्पॉन्स ऑनलाइन फ़ॉर्मैटर में पेस्ट करने पर हरा चिह्न मिलता है। वही पेलोड नीचे की सेवा तक पहुँचते ही अपवाद फेंक देता है। दोनों पार्सरों को साथ रखकर अक्षर-दर-अक्षर तुलना करें, तो आमतौर पर कोई "ग़लत" नहीं होता — डेटा ठीक उस बिंदु पर गिरा होता है जहाँ दोनों इंप्लीमेंटेशन अलग हो जाते हैं।

ऐसे बिंदु बहुत नहीं हैं, पर हर एक आम है। नीचे की तालिका अक्सर पूछे जाने वाले इनपुट का वास्तविक व्यवहार दर्ज करती है (Node 22 के JSON.parse, Python 3.11 स्टैंडर्ड लाइब्रेरी के json, jq 1.8 और प्रचलित ऑनलाइन वैलिडेटर पर जाँचा गया):

इनपुट Node JSON.parse Python json.loads jq टिप्पणी
{"a":1,"a":2} डुप्लिकेट की स्वीकार, आख़िरी मान रखता है स्वीकार, आख़िरी मान रखता है स्वीकार, आख़िरी मान रखता है RFC 8259 केवल SHOULD कहता है; चारों छोड़ देते हैं
{"n":NaN} त्रुटि स्वीकार त्रुटि Python स्टैंडर्ड लाइब्रेरी डिफ़ॉल्ट रूप से छोड़ती है — सबसे बड़ा मौन जाल
{"n":01} शुरुआती शून्य त्रुटि त्रुटि त्रुटि सब एक साथ अस्वीकार करते हैं, पर त्रुटि की स्थिति अलग-अलग
"टेक्स्ट" GBK बाइट्स में संग्रहीत त्रुटि या कैरेक्टर ख़राब एनकोडिंग घोषणा पर निर्भर त्रुटि RFC UTF-8 माँगता है; डिकोडिंग IO परत का काम
{"a":1} से पहले BOM त्रुटि स्वीकार (utf-8-sig) त्रुटि BOM कौन हटाए, वही तय करता है
कमेंट, सिंगल कोट, ट्रेलिंग कॉमा त्रुटि त्रुटि त्रुटि केवल JSON5/JSONC पार्सर स्वीकारते हैं

दूसरी पंक्ति देखिए: json.loads('{"cpu":NaN}') Python में वैध है। स्टैंडर्ड लाइब्रेरी जानबूझकर NaN/Infinity को स्वीकार करती है, और कई पाइपलाइनों ने ये कचरा पंक्तियाँ सामान्य रिकॉर्ड गिन लीं बिना संदूषण पकड़े। रोकने के लिए parse_constant स्पष्ट रूप से पास करना ज़रूरी है — कोड नीचे।

अंतर कहाँ से आते हैं: विनिर्देश के खाली स्थान

RFC 8259 अस्पष्ट नहीं है; वह जानबूझकर तीन क्षेत्र "इंप्लीमेंटेशन के भरोसे" छोड़ता है, और हर इंप्लीमेंटेशन उन्हें अलग तरह भरता है।

पहला: नामों की अद्वितीयता। खंड 4 कहता है नाम SHOULD be unique — सिफ़ारिश, नियम नहीं। इसलिए डुप्लिकेट की सिंटैक्स त्रुटि नहीं है, और सभी पार्सर "आख़िरी जीतता है" चुनते हैं। बिज़नेस वैलिडेटर केवल बचा हुआ मान देखता है; जो पहले लिखा गया था, वह बिना त्रुटि और बिना लॉग ग़ायब हो जाता है।

दूसरा: संख्याएँ। व्याकरण केवल int frac exp रूप तय करता है; परिमाण इंप्लीमेंटेशन के भरोसे है। JavaScript सब कुछ IEEE 754 डबल से गुज़ारता है, इसलिए 9007199254740993 बन जाता है ...992। jq 1.8 से दशमलव लिटरल सही रखता है, पर कोई भी गणना डबल पर लौट आती है। वही दस्तावेज़ तुलना, भंडारण और संचरण में तीन अलग मान ले सकता है।

तीसरा: UTF-8 और अदृश्य वर्ण। विनिर्देश माँगता है कि आदान-प्रदान का JSON UTF-8 हो, पर फ़ाइल कैसे खुले, BOM हटे या न हटे, अवैध बाइट्स कैसे संभलें — यह सब IO परत के निर्णय हैं। वही बाइट स्ट्रीम Python के utf-8 या utf-8-sig में खुलने पर अलग फ़ैसले देती है।

चौथा स्रोत: शिथिल बोलियाँ। JSON5 कमेंट, सिंगल कोट और ट्रेलिंग कॉमा देता है; JSONC वही छूट VS Code पारिस्थितिकी में देता है। कॉन्फ़िग फ़ाइलों पर शिथिल पार्सर और API पर सख़्त पार्सर — एक ही टीम में यही सबसे आम विभाजन है।

CVE-2026-33948: अंतर ठीक न करें तो हमले की सतह बन जाता है

पार्सर के अंतर आमतौर पर अनुभव की परेशानी भर हैं। जैसे ही "वैलिडेशन" और "पार्सिंग" दो अलग इंप्लीमेंटेशन पर चलने लगते हैं, वे हमले की सतह बन जाते हैं। 2026 में प्रकट CVE-2026-33948 एक पाठ्यपुस्तकीय उदाहरण है: 1.8.2 से पहले का jq फ़ाइल से JSON पढ़ते समय इनपुट में NUL बाइट (\0) घुसने देता था, और वही इनपुट दो चरणों में दो फ़ैसले पाता था — वैलिडेशन चरण उसे वहीं समाप्त मानता था, असली प्रोसेसिंग उसके आगे भी पढ़ती थी। बायपास पूरा हो जाता था। GitHub का आधिकारिक सुरक्षा परामर्श सुधार बताता है: 1.8.2 में अपग्रेड।

सामान्यीकरण: किसी भी "पहले वैलिडेशन, फिर पार्सिंग" श्रृंखला में, अगर दोनों चरण अलग इंप्लीमेंटेशन या कॉन्फ़िगरेशन पर चलते हैं, हमलावर वह इनपुट बना सकता है जिसे वैलिडेटर अस्वीकार करे और पार्सर स्वीकार करे — और दुर्भावनापूर्ण पेलोड अंदर सरक जाए। वही ढाँचा गेटवे पर भी चलता है। API7 का तर्क है कि पार्सिंग की अर्थव्यवस्था अनुबंध का हिस्सा है, किसी इंप्लीमेंटेशन की निजी हरकत नहीं।

स्व-जाँच एक कमांड है — पक्का करें कि हर कड़ी वही jq संस्करण चला रही है और इस सुधार को शामिल करती है:

jq --version
# jq-1.7.1  ← भेद्य, अपग्रेड करें
# jq-1.8.2  ← ठीक किया गया

डुप्लिकेट कीज़: आख़िरी मान मौन रूप से निगल लिया जाता है

डुप्लिकेट कीज़ अलग खंड चाहती हैं, क्योंकि यह अकेली सीमा है जिसे हर प्रमुख पार्सर स्वीकार करता है जबकि लगभग हर डेवलपर सोचता है कि त्रुटि आएगी।

import json

text = '{"role": "guest", "role": "admin"}'
data = json.loads(text)
print(data)          # {'role': 'admin'}
print("guest" in data.values())  # False: पहला मान जा चुका है

अगर वह टेक्स्ट हस्ताक्षर जाँच या अनुमति निर्णय में जाता है, तो हमलावर एक समान नाम का फ़ील्ड जोड़कर अधिकार बदल सकता है, और आपका कोड केवल अंतिम मान देखता है। Node का JSON.parse वैसा ही व्यवहार करता है। मौन रूप से बदलने के बजाय पकड़ने के लिए Python में object_pairs_hook मिलता है:

from collections import Counter

def reject_dup(pairs):
    counts = Counter(k for k, _ in pairs)
    dup = [k for k, c in counts.items() if c > 1]
    if dup:
        raise ValueError(f"duplicate keys: {dup}")
    return dict(pairs)

data = json.loads('{"a":1,"a":2}', object_pairs_hook=reject_dup)
# ValueError: duplicate keys: ['a']

RFC 8259 खंड 4 साफ़ कहता है: अंतरसंचार के लिए नाम अद्वितीय होने चाहिए। उस SHOULD को वैलिडेशन नियम बनाने की कीमत एक पारी है, और लाभ "दो उपकरण, दो फ़ैसले" का सबसे आम स्रोत मिटाना है।

सुधार: हर सीमा को एकमात्र निर्णायक दें

मरम्मत "अधिक सख़्त पार्सर पर जाना" नहीं है। यह हर सीमा को एक स्पष्ट, लिखी हुई नीति देना है — और पक्का करना कि वैलिडेशन और निष्पादन वही इस्तेमाल करते हैं। नीचे की तालिका समीक्षा चेकलिस्ट बन जाती है:

सीमा शिथिल डिफ़ॉल्ट सुझाया फ़ैसला प्रतिनिधि कॉन्फ़िगरेशन
डुप्लिकेट कीज़ आख़िरी मान जीतता है अस्वीकार Python object_pairs_hook; Go json/v2 डिफ़ॉल्ट अस्वीकार
NaN / Infinity Python स्वीकार अस्वीकार Python parse_constant अपवाद फेंकता है
अज्ञात फ़ील्ड मौन अनदेखा अनुबंध से तय Go json/v2 RejectUnknownMembers(true)
अवैध UTF-8 इंप्लीमेंटेशन दर इंप्लीमेंटेशन अस्वीकार डिकोड परत में बाइट स्ट्रीम की स्पष्ट जाँच
BOM जो हटाए वही तय करे प्रवेश पर एक बार हटाएँ नियत utf-8-sig या पहले हटाना
वैलिडेशन और निष्पादन अलग दोनों अपना-अपना एक इंप्लीमेंटेशन, एक कॉन्फ़िगरेशन वैलिडेटर उत्पादन पार्सर का पुनःप्रयोग करें

Python पर सबसे ख़तरनाक दो डिफ़ॉल्ट बंद करने के लिए एक ही कॉल काफ़ी है:

import json

def _reject(value):
    raise ValueError(f"non-standard constant: {value}")

data = json.loads(
    raw,
    parse_constant=_reject,          # NaN / Infinity रोकता है
    object_pairs_hook=reject_dup,    # डुप्लिकेट कीज़ रोकता है
)

Go का encoding/json/v2 (उपनाम jsonv2) पूरी नीति स्पष्ट विकल्प बनाता है: RejectUnknownMembers(true) अज्ञात फ़ील्ड अस्वीकार करता है, और डुप्लिकेट नाम व अवैध UTF-8 डिफ़ॉल्ट अस्वीकार होते हैं। GopherForge का व्यावहारिक पृष्ठ क्रम स्पष्ट कहता है: इनपुट बाइट्स सीमित करें, स्पष्ट नीति से डिकोड करें, डोमेन जाँचें और अधिकृत करें — और तभी दुष्प्रभाव दें। हर विफलता पथ फ़िक्स्चर से जाँचा जाए, न कि बदली हुई त्रुटि संदेश से आँका जाए।

पार्सिंग नीति को अनुबंध और संग्रह में लिखें

नीति बनने के बाद भटकाव से बचाना है। दो कार्य पर्याप्त हैं।

पहला: "हम क्या स्वीकार करते हैं, क्या अस्वीकार" इंटरफ़ेस दस्तावेज़ में फ़ील्ड परिभाषाओं के पास लिखें। API7 स्थिर त्रुटि कोड सुझाता है ताकि क्लाइंट स्थायी अनुबंध त्रुटि और अस्थायी इंफ़्रा विफलता में फ़र्क़ कर सके — अस्वीकृत डुप्लिकेट की गेटवे टाइमआउट जैसी न दिखे, वरना बेतुका रिट्राई तूफ़ान आएगा। लॉग में पूरा रिक्वेस्ट बॉडी दोहराएँ नहीं: कच्चे पेलोड में क्रेडेंशियल हो सकते हैं, और कुछ अवैध बाइट क्रम छापना भी ख़तरनाक है।

दूसरा: अस्पष्टता संग्रह बनाएँ। ऊपर तालिका की हर पंक्ति एक टेस्ट केस बने: डुप्लिकेट कीज़, केस से भिन्न कीज़, अज्ञात फ़ील्ड, अवैध UTF-8, BOM, अंत में अतिरिक्त मान, खाली इनपुट। CI में दो दावे चलें: अवैध इनपुट विफल हों बिना कोई उपयोगी आंशिक मान दिए; स्वीकृत इनपुट encode/decode राउंड ट्रिप में अपरिवर्तित रहें। पार्सर अपग्रेड पर उत्पादन रूप के नमूने सुरक्षित परिवेश में तुलना मोड में चलाएँ और स्वीकृति समूह का बदलना असली अनुबंध परिवर्तन समझें।

ये क्रियाएँ CI में JSON वैलिडेशन: jsonlint, ajv और jq की पूरक हैं, जो सिंटैक्स और स्कीमा वैलिडेशन को पाइपलाइन में जोड़ती है; यह लेख पहले नोड से पहले की बात करता है — पार्सर स्वयं। प्रोटोटाइप प्रदूषण और XSS जैसे इंजेक्शन जोखिम JSON सुरक्षा जोखिम सूची में हैं; पार्सर स्तर की भरोसे की श्रृंखला की समस्याएँ ठीक उस सूची की शून्य परत हैं। सिंटैक्स त्रुटियों की जगह पकड़ने के लिए RFC 8259 से JSON व्याकरण की सीमाएँ देखें।

लॉन्च से पहले की चेकलिस्ट

  1. पूरी श्रृंखला में पार्सर संस्करण मिलाएँ: jq, रनटाइम, गेटवे, ऑफ़लाइन वैलिडेटर एक-एक कर --version से; CVE-2026-33948 जैसे सुधार हर जगह पहुँचें;
  2. डुप्लिकेट कीज़ और NaN स्पष्ट अस्वीकार करें: object_pairs_hook और parse_constant साझा रैपर में रखें, व्यापार कोड में नंगे json.loads प्रतिबिंबित करें;
  3. अज्ञात फ़ील्ड रूट से तय करें: पीछे-संगत उपभोक्ता अनदेखा कर सकते हैं, कमांड एंडपॉइंट RejectUnknownMembers रखें;
  4. अस्पष्टता संग्रह CI में: कम से कम 8 फ़िक्स्चर, हर अपग्रेड से पहले पुराना-नया तुलना;
  5. वर्गीकृत त्रुटियाँ: अनुबंध और इंफ़्रा त्रुटियों के अलग कोड, रिट्राई केवल बाद वाले के लिए।

शुरुआती पंक्ति पर लौटें: वैलिडेशन पास करने का अर्थ है "किसी पार्सर ने किसी नीति तह स्वीकारा"। उस नीति को अस्पष्ट से स्पष्ट कीजिए — अनुबंध में, संग्रह में, संस्करण पिनिंग में — और "एक JSON, दो फ़ैसले" अंततः ग़ायब होगा।

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

JSON विनिर्देश में डुप्लिकेट कीज़ वास्तव में त्रुटि नहीं हैं?

सिंटैक्स त्रुटि नहीं। RFC 8259 खंड 4 SHOULD be unique कहता है — सिफ़ारिश, अपेक्षा नहीं — इसलिए प्रमुख पार्सर डुप्लिकेट स्वीकारते हैं और डिफ़ॉल्ट रूप से आख़िरी मान रखते हैं। अंतरसंचार के लिए अद्वितीयता की सिफ़ारिश है। इसे वैलिडेशन त्रुटि बनाना अनुबंध का निर्णय है; पकड़ने की कीमत एक पारी है।

Python की json लाइब्रेरी NaN स्वीकार करती है पर JavaScript त्रुटि क्यों फेंकता है?

Python की स्टैंडर्ड लाइब्रेरी जानबूझकर NaN और Infinity स्वीकार करती है ताकि अपने पुराने नुकसानदायक आउटपुट दोबारा पढ़ सके। ECMAScript का JSON.parse व्याकरण सख़्ती से लागू करता है और NaN पर SyntaxError फेंकता है। Python में parse_constant पास कीजिए — एक पंक्ति कॉन्फ़िगरेशन दोनों रनटाइम को एक कर देती है।

CVE-2026-33948 किन संस्करणों को प्रभावित करती है, कैसे ठीक करें?

1.8.2 से पहले का jq फ़ाइल से JSON पढ़ते समय घुसाए गए NUL बाइट्स स्वीकारता था, जिनसे वैलिडेशन चरण और असली पार्सर उसी इनपुट पर अलग निष्कर्ष निकालते थे — बायपास बन जाता था। GitHub परामर्श का सुधार 1.8.2 या कमिट 6374ae0 वाले बिल्ड तक अपग्रेड है। स्क्रिप्ट और CI में संस्करण पिन करें और अपग्रेड से पहले अस्पष्टता संग्रह चलाएँ।

मैं प्रवेश पर एक बार वैलिडेट करता हूँ और परिणाम दोहराता हूँ — फिर भी जोखिम है?

हाँ, पर जोखिम उस एक बिंदु पर सिमट जाता है। यदि प्रवेश पार्सर, उसकी कॉन्फ़िगरेशन और संस्करण पिन हैं, और संग्रह डुप्लिकेट, NUL और UTF-8 को ढकता है, तो श्रृंखला में दूसरा निर्णायक नहीं है। ख़तरनाक व्यवस्था वह है जहाँ गेटवे एक इंप्लीमेंटेशन पर और सेवाएँ दूसरी पर चलें, या वैलिडेशन एक पार्सर पर और निष्पादन दूसरे पर — वह फ़ैसला उसी अंतर को सौंप देता है।