JSON Toolkit

JSON ชุดเดียว คำตัดสินสองแบบ: ความต่างของพาร์เซอร์และเส้นแบ่งความเชื่อมั่นของการตรวจสอบ

สรุปสำคัญ: เมื่อตัวตรวจสอบยอมรับเอกสารแต่บริการถัดไปล้ม มักเกิดจากพาร์เซอร์สองตัวเห็นต่างกันกับข้อความชุดเดียวกัน บทความนี้เปรียบเทียบคีย์ซ้ำ ไบต์ NUL, UTF-8 ที่ไม่ถูกต้อง, NaN และเลขศูนย์นำหน้าบนรันไทม์จริง อธิบายว่า CVE-2026-33948 เปลี่ยนความเห็นต่างให้กลายเป็นพื้นที่โจมตีอย่างไร และแสดงวิธีกำหนดผู้ตัดสินเพียงหนึ่งเดียวให้ทุกเส้นแบ่ง

Advancedอ่านประมาณ 6 นาทีเผยแพร่ 2026-11-11อัปเดต 2026-11-11
ภาพปกแสดงเครื่องมือสองตัวตัดสินต่างกันกับเอกสาร JSON ชุดเดียวกัน

การผ่านการตรวจสอบพิสูจน์เพียงสิ่งเดียว: ข้อความถูกยอมรับโดยพาร์เซอร์ตัวนั้น ภายใต้นโยบายนั้น เปลี่ยนพาร์เซอร์แล้วคำตัดสินอาจกลับด้าน

อาการ: เครื่องมือ A ผ่าน เครื่องมือ B ตีตก

ฉากที่ทุกคนเคยเจอ การตอบกลับจาก API ถูกวางลงในเครื่องมือจัดรูปแบบออนไลน์แล้วได้เครื่องหมายถูกสีเขียว เพย์โหลดชุดเดียวกันไปถึงบริการถัดไปแล้วโยน exception เมื่อวางพาร์เซอร์สองตัวไว้เคียงกันแล้วเทียบทีละอักขระ มักไม่มีฝ่ายใด "ผิด" — ข้อมูลตกลงพอดีจุดที่การนำไปใช้สองแบบเห็นต่างกัน

จุดแบบนี้ไม่มีมาก แต่ละจุดพบบ่อย ตารางด้านล่างบันทึกพฤติกรรมจริงกับอินพุตที่พบบ่อย (ทดสอบกับ Node 22 JSON.parse, json มาตรฐานของ Python 3.11, jq 1.8 และตัวตรวจสอบออนไลน์ยอดนิยม):

อินพุต Node JSON.parse Python json.loads jq หมายเหตุ
{"a":1,"a":2} คีย์ซ้ำ ยอมรับ เหลือค่าสุดท้าย ยอมรับ เหลือค่าสุดท้าย ยอมรับ เหลือค่าสุดท้าย RFC 8259 พูดเพียง SHOULD; ทั้งสี่ปล่อยผ่าน
{"n":NaN} ผิดพลาด ยอมรับ ผิดพลาด ไลบรารีมาตรฐาน Python ยอมรับเป็นค่าเริ่มต้น — กับดักเงียบที่ใหญ่ที่สุด
{"n":01} เลขศูนย์นำหน้า ผิดพลาด ผิดพลาด ผิดพลาด ถูกปฏิเสธทุกที่ แต่ตำแหน่งข้อผิดพลาดต่างกัน
"中文" เก็บเป็นไบต์ GBK ผิดพลาดหรือตัวอักษรเพี้ยน ขึ้นกับ encoding ผิดพลาด 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) ไม่ซ้ำกัน — เป็นคำแนะนำ ไม่ใช่กฎ คีย์ซ้ำจึงไม่ใช่ข้อผิดพลาดทางไวยากรณ์ และพาร์เซอร์ทุกที่เลือก "ตัวสุดท้ายชนะ" ตัวตรวจสอบฝั่งธุรกิจจะเห็นเฉพาะค่าที่รอดมา ส่วนค่าที่ผู้ส่งส่งมาก่อนหายไปเงียบ ๆ โดยไม่มีข้อผิดพลาดหรือบรรทัด log

สอง ตัวเลข ไวยากรณ์กำหนดเพียงรูปแบบ int frac exp ขนาดค่าปล่อยให้ผู้นำไปใช้ตัดสิน JavaScript ผลักทุกอย่างผ่าน double IEEE 754 เลยทำให้ 9007199254740993 กลายเป็น ...992 jq ตั้งแต่ 1.8 เก็บลิเทอรัลทศนิยมได้ตรง แต่การคำนวณใด ๆ กลับไปเป็น double อีกครั้ง เอกสารชุดเดียวกันอาจแสดงค่าสามแบบต่างกันขณะเทียบ จัดเก็บ และส่งต่อ

สาม UTF-8 และอักขระที่มองไม่เห็น สเปกกำหนดว่า JSON ที่แลกเปลี่ยนต้องเป็น UTF-8 แต่ไฟล์เปิดอย่างไร BOM ถูกถอดหรือไม่ ไบต์ไม่ถูกต้องถูกจัดการแบบไหน เป็นการตัดสินของชั้น IO สตรีมไบต์ชุดเดียวกันให้คำตัดสินต่างกันขึ้นกับว่า Python เปิดด้วย utf-8 หรือ utf-8-sig

สี่ ไดอะเล็กต์ที่ผ่อนปรน JSON5 อนุญาตคอมเมนต์ อัญประกาศเดี่ยว และคอมมาท้าย JSONC คลายกฎเดียวกันในระบบนิเวศ VS Code คอนฟิกที่แยกวิเคราะห์ด้วยพาร์เซอร์เชิงยอมรับ กับ API ที่แยกวิเคราะห์ด้วยพาร์เซอร์เข้มงวด เป็นความเบี่ยงเบนที่พบมากที่สุดแม้ในทีมเดียว

CVE-2026-33948: เมื่อความเห็นต่างกลายเป็นพื้นที่โจมตี

ความต่างของพาร์เซอร์ปกติแค่รำคาญผู้ใช้ พอ "การตรวจสอบ" กับ "การแยกวิเคราะห์" ทำงานบนการนำไปใช้สองแบบต่างกัน มันกลายเป็นพื้นที่โจมตี CVE-2026-33948 ที่เปิดเผยปี 2026 เป็นกรณีตัวอย่างจากตำรา: jq เวอร์ชันก่อน 1.8.2 ยอมรับไบต์ NUL ฝังอยู่ (\0) เมื่ออ่าน JSON จากไฟล์ ทำให้อินพุตชุดเดียวกันให้คำตัดสินสองแบบ — ขั้นตรวจสอบถือว่าเนื้อหาจบตรงนั้น ขณะที่การประมวลผลจริงอ่านต่อข้ามไป การหลบเลี่ยงครบถ้วน คำแนะนำด้านความปลอดภัยของ GitHub ยืนยันการแก้ไข: อัปเกรดเป็น 1.8.2

ถอดบทเรียน: ในห่วงโซ่ "ตรวจก่อน แยกวิเคราะห์ทีหลัง" หากสองขั้นใช้การนำไปใช้หรือคอนฟิกต่างกัน ผู้โจมตีสร้างอินพุตที่ตัวตรวจตีตกแต่พาร์เซอร์ยอมรับได้ แล้วลักเพย์โหลดผ่านด่านไป โครงสร้างเดียวกันซ้ำที่เกตเวย์ — เหตุผลของ API7 ที่ให้เขียนการแยกวิเคราะห์แบบเข้มงวดลงในสัญญา API คือความหมายของการแยกวิเคราะห์เป็นส่วนหนึ่งของสัญญา ไม่ใช่พฤติกรรมส่วนตัวของการนำไปใช้ใด ๆ เมื่อเกตเวย์ปฏิเสธคำขอด้วยชุดกฎหนึ่ง แต่บริการแบ็กเอนด์ยอมรับเนื้อความเดิมด้วยพาร์เซอร์อื่น สัญญาก็แตกไปแล้ว

การตรวจตัวเองใช้คำสั่งเดียว — ยืนยันว่าทุกขั้นใช้ 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: ค่าแรกหายไปแล้ว

ถ้าข้อความนี้เลี้ยงการตรวจลายเซ็นหรือการตัดสินสิทธิ์ ผู้โจมตีเติมฟิลด์ชื่อเดียวกันเข้าไปเพื่อเขียนทับสิทธิ์ได้ และโค้ดตรวจสอบของคุณเห็นแค่ค่าสุดท้าย JSON.parse ของ Node ทำเหมือนกันทุกประการ เพื่อตรวจจับแทนการเขียนทับเงียบ ๆ 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']

มาตรา 4 ของ RFC 8259 พูดตรง ๆ: เพื่อความสามารถในการทำงานร่วมกัน ชื่อควรไม่ซ้ำ การยกระดับ SHOULD นี้เป็นกฎการตรวจสอบใช้เวลาสแกนรอบเดียว และตัดแหล่งที่พบบ่อยที่สุดของ "สองเครื่องมือ สองคำตัดสิน" ทิ้งไป

ทางแก้: หนึ่งผู้ตัดสินต่อหนึ่งเส้นแบ่ง

การซ่อมไม่ใช่ "เปลี่ยนไปใช้พาร์เซอร์เข้มงวดขึ้น" แต่คือการมอบนโยบายที่ชัดเจนและเขียนไว้ให้ทุกจุดเส้นแบ่ง — และบังคับให้การตรวจสอบกับการประมวลผลใช้นโยบายเดียวกัน ตารางต่อไปนี้ใช้เป็นเช็กลิสต์ทบทวนได้:

เส้นแบ่ง พฤติกรรมเริ่มต้นแบบผ่อนปรน คำตัดสินที่แนะนำ คอนฟิกตัวอย่าง
คีย์ซ้ำ ตัวสุดท้ายชนะ ปฏิเสธ object_pairs_hook ใน Python; json/v2 ของ Go ปฏิเสธเป็นค่าเริ่มต้น
NaN / Infinity Python ยอมรับ ปฏิเสธ parse_constant ใน Python ที่โยน exception
ฟิลด์ไม่รู้จัก ถูกมองข้ามเงียบ ๆ ตัดสินตามสัญญา RejectUnknownMembers(true) ใน json/v2 ของ Go
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,    # บล็อกคีย์ซ้ำ
)

encoding/json/v2 ของ Go (นามแฝง jsonv2) ทำนโยบายทั้งหมดชัดเจน: RejectUnknownMembers(true) ปฏิเสธฟิลด์ไม่รู้จัก และชื่อซ้ำพร้อม UTF-8 ไม่ถูกต้องถูกปฏิเสธเป็นค่าเริ่มต้น หน้าแนวปฏิบัติของ GopherForge เป๊ะเรื่องลำดับ: จำกัดไบต์อินพุต ถอดรหัสภายใต้นโยบายชัดเจน ตรวจโดเมนและให้สิทธิ์ แล้วจึงอนุญาตผลข้างเคียง — และทุกเส้นทางความล้มเหลวต้องซ้อมด้วยฟิกซ์เจอร์ ห้ามตัดสินจากข้อความเออเรอร์ที่เปลี่ยนไป

นำนโยบายการแยกวิเคราะห์เข้าสัญญาและคลังทดสอบ

นโยบายต้องมีเกราะกันการเลื่อนไหล สองการกระทำก็พอ

หนึ่ง เขียน "เรายอมรับอะไร ปฏิเสธอะไร" ลงในเอกสารอินเทอร์เฟซถัดจากนิยามฟิลด์ API7 แนะนำโค้ดข้อผิดพลาดแบบนิ่ง เพื่อให้ไคลเอนต์แยกข้อผิดพลาดสัญญาถาวรออกจากความล้มเหลวชั่วคราวของโครงสร้างพื้นฐาน — คีย์ซ้ำที่ถูกปฏิเสธห้ามดูเหมือน timeout ของเกตเวย์ ไม่เช่นนั้นคุณเชิญพายุ retry อย่าเทเนื้อความคำขอทั้งหมดลง log: เพย์โหลดดิบอาจมีข้อมูลยืนยันตัวตน และลำดับไบต์ไม่ถูกต้องบางแบบไม่ปลอดภัยเมื่อแสดงผล

สอง สร้างคลังความกำกวม เปลี่ยนทุกแถวในตารางข้างบนเป็นฟิกซ์เจอร์ทดสอบ: คีย์ซ้ำ คีย์ต่างตัวพิมพ์ ฟิลด์ไม่รู้จัก UTF-8 ไม่ถูกต้อง BOM ค่าที่สองท้ายสตรีม อินพุตว่าง ยืนยันสองเรื่องใน CI: อินพุตไม่ถูกต้องต้องล้มโดยไม่ผลิตค่าบางส่วนที่ใช้ได้ และอินพุตที่ยอมรับต้องรอดรอบ encode/decode โดยไม่เปลี่ยน เมื่ออัปเกรดพาร์เซอร์ เล่นซ้ำตัวอย่างรูปแบบโปรดักชันในสภาพแวดล้อมที่ได้รับการป้องกันด้วยโหมดเทียบ แล้วทบทวนการเปลี่ยนแปลงในชุดยอมรับว่าเป็นการเปลี่ยนสัญญาจริง แทนการสมมติว่าฟิกซ์เจอร์เก่าครอบคลุมหมด

การกระทำเหล่านี้เสริม การตรวจสอบ JSON ใน CI: ไปป์ไลน์ jsonlint, ajv และ jq ที่อธิบายการตรวจไวยากรณ์และสคีมาวางในไปป์ไลน์อย่างไร ส่วนบทความนี้ครอบคลุมสิ่งที่อยู่ก่อนโหนดแรก — ตัวพาร์เซอร์เอง ความเสี่ยงด้านการฉีด เช่น prototype pollution และ XSS อยู่ใน เช็กลิสต์ความเสี่ยงด้านความปลอดภัย JSON ปัญหาห่วงโซ่ความเชื่อมั่นระดับพาร์เซอร์ — คีย์ซ้ำและไบต์ NUL — คือชั้นศูนย์ของรายการนั้นพอดี หากต้องหาข้อผิดพลาดไวยากรณ์ธรรมดา ดู เขตแดนไวยากรณ์ JSON จาก RFC 8259

เช็กลิสต์ก่อนเปิดใช้งาน

  1. จัดเวอร์ชันพาร์เซอร์ให้ตรงกันทั้งห่วงโซ่: jq, รันไทม์, เกตเวย์, ตัวตรวจออฟไลน์ — แพตช์ระดับ CVE-2026-33948 ต้องถึงทุกที่;
  2. ปฏิเสธคีย์ซ้ำและ NaN อย่างชัดเจน: ใส่ object_pairs_hook และ parse_constant ไว้ใน wrapper ใช้ร่วม ห้ามเรียก json.loads เปล่า ๆ ในโค้ดธุรกิจ;
  3. ตัดสินฟิลด์ไม่รู้จักเป็นรายเส้นทาง: ผู้บริโภคที่เข้ากันได้ล่วงหน้ามองข้ามได้ ส่วนเอนด์พอยต์คำสั่งต้องตั้ง RejectUnknownMembers;
  4. คลังความกำกวมใน CI: อย่างน้อย 8 ฟิกซ์เจอร์ บวกรอบเทียบเก่า-กับ-ใหม่ก่อนอัปเกรดพาร์เซอร์ทุกครั้ง;
  5. ข้อผิดพลาดจำแนกได้: โค้ดแยกข้อผิดพลาดสัญญากับโครงสร้างพื้นฐาน ทำซ้ำเฉพาะแบบหลัง

กลับไปที่ประโยคเปิด: ผ่านการตรวจสอบหมายความว่า "ถูกยอมรับโดยพาร์เซอร์บางตัวภายใต้นโยบายบางแบบ" ทำให้นโยบายนั้นชัดเจน — ลงสัญญา ลงคลังทดสอบ ลงการล็อกเวอร์ชัน — แล้ว "JSON ชุดเดียว คำตัดสินสองแบบ" จะหายไปในที่สุด

FAQ

คีย์ซ้ำจริง ๆ เป็นข้อผิดพลาดตามสเปก JSON หรือไม่

ไม่ใช่ข้อผิดพลาดทางไวยากรณ์ มาตรา 4 ของ RFC 8259 ระบุว่าชื่อควร (SHOULD) ไม่ซ้ำ — เป็นคำแนะนำ ไม่ใช่ข้อบังคับ — พาร์เซอร์หลักจึงยอมรับคีย์ซ้ำและเก็บค่าสุดท้ายเป็นค่าเริ่มต้น สเปกยังแนะนำความไม่ซ้ำเพื่อการทำงานร่วมกันอยู่ การยกระดับเป็นข้อผิดพลาดการตรวจสอบเป็นการตัดสินใจเชิงสัญญา การตรวจจับใช้เวลาสแกนรอบเดียว

ทำไมไลบรารี json ของ Python ยอมรับ NaN แต่ JavaScript โยน error

ไลบรารีมาตรฐานของ Python ตั้งใจยอมรับ NaN และ Infinity เพื่ออ่านซ้ำข้อมูลที่ตนเคยส่งออกแบบสูญเสียในอดีต JSON.parse ของ ECMAScript นำไวยากรณ์ไปใช้อย่างเข้มงวดและโยน SyntaxError ส่ง parse_constant ใน Python แล้วค่าเหล่านี้จะถูกปฏิเสธ และหนึ่งบรรทัดคอนฟิกจัดรันไทม์สองฝั่งให้ตรงกัน

CVE-2026-33948 กระทบเวอร์ชันใด และแก้อย่างไร

jq ก่อน 1.8.2 เมื่ออ่าน JSON จากไฟล์ยอมรับไบต์ NUL ฝังอยู่ ทำให้ขั้นตรวจสอบกับพาร์เซอร์จริงเห็นต่างกันบนอินพุตเดียวกัน เกิดการหลบเลี่ยงการตรวจสอบได้ การแก้ไขตามคำแนะนำของ GitHub คืออัปเกรดเป็น 1.8.2 หรือบิลด์ที่มี commit 6374ae0 ล็อกเวอร์ชันในสคริปต์และ CI แล้วรันคลังความกำกวมก่อนอัปเกรด

ผมตรวจสอบครั้งเดียวที่ทางเข้าแล้วใช้ผลซ้ำ — ยังเสี่ยงอยู่ไหม

เสี่ยง แต่ความเสี่ยงกระจุกอยู่ที่จุดเข้านั้นจุดเดียว ถ้าพาร์เซอร์ที่ทางเข้า คอนฟิก และเวอร์ชันถูกล็อกไว้ และคลังความกำกวมครอบคลุมคีย์ซ้ำ ไบต์ NUL และ UTF-8 ก็ไม่มีผู้ตัดสินที่สองภายในห่วงโซ่ โทโพโลยีที่อันตรายคือเกตเวย์บนการนำไปใช้หนึ่งแต่บริการบนอีกแบบ หรือการตรวจสอบบนพาร์เซอร์หนึ่งแต่การประมวลผลบนอีกตัว — เมื่อนั้นคำตัดสินถูกส่งต่อให้ความเห็นต่างเอง