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

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