Satu JSON, Dua Keputusan: Perbezaan Parser dan Sempadan Kepercayaan Pengesahan
Inti pati: Apabila pengesah menerima dokumen tetapi perkhidmatan seterusnya runtuh, biasanya dua parser tidak bersetuju tentang teks yang sama. Artikel ini membandingkan kunci pendua, bait NUL, UTF-8 tidak sah, NaN dan sifar pendahuluan pada runtime sebenar, menerangkan bagaimana CVE-2026-33948 mengubah percanggahan kepada permukaan serangan, dan menunjukkan cara menetapkan satu timbang tara bagi setiap sempadan.

Lulus pengesahan membuktikan tepat satu perkara: teks telah diterima oleh parser itu, di bawah polisi itu. Tukar parser dan keputusan boleh berubah.
Gejala: alat A lulus, alat B menolak
Inilah situasi yang semua orang pernah temui. Respons API ditampal ke pemformat dalam talian dan mendapat tanda semak hijau. Payload yang sama tiba di perkhidmatan seterusnya dan membaling pengecualian. Apabila anda letakkan kedua-dua parser bersebelahan dan bandingkan aksara demi aksara, biasanya tiada pihak yang "bersalah" — data mendarat tepat pada titik di mana dua pelaksanaan berpecah.
Titik sedemikian tidak banyak, tetapi setiap satu lazim. Jadual di bawah merekodkan gelagat sebenar bagi input berfrekuensi tinggi (diuji terhadap Node 22 JSON.parse, json standard Python 3.11, jq 1.8 dan pengesah dalam talian yang popular):
| Input | Node JSON.parse | Python json.loads | jq | Nota |
|---|---|---|---|---|
{"a":1,"a":2} kunci pendua |
terima, yang akhir kekal | terima, yang akhir kekal | terima, yang akhir kekal | RFC 8259 hanya kata SHOULD; keempat-empat membiarkannya |
{"n":NaN} |
ralat | terima | ralat | Pustaka standard Python terimanya secara lalai — perangkap senyap terbesar |
{"n":01} sifar pendahuluan |
ralat | ralat | ralat | Ditolak seragam, tetapi kedudukan ralat berbeza |
"中文" disimpan sebagai bait GBK |
ralat atau aksara rosak | bergantung pada pengekodan | ralat | RFC menuntut UTF-8, tetapi pendekodan adalah tugas lapisan IO |
{"a":1} dengan BOM |
ralat | terima (utf-8-sig) | ralat | Yang menanggalkan BOM yang menentukan |
| komen, petikan tunggal, koma penutup | ralat | ralat | ralat | Hanya parser JSON5/JSONC menerimanya |
Lihat baris kedua: json.loads('{"cpu":NaN}') adalah sah dalam Python. Pustaka standard sengaja menerima NaN/Infinity demi keserasian ke belakang, dan banyak talian paip mengira baris sampah ini sebagai rekod biasa tanpa menyedari pencemarannya. Menahannya memerlukan hujah parse_constant yang jelas — kod di bawah.
Dari mana perbezaan datang: jurang spesifikasi dan pilihan pelaksanaan
RFC 8259 tidak kabur; spesifikasi itu sengaja meninggalkan tiga kawasan "kepada pelaksana", dan setiap pelaksanaan mengisinya dengan cara tersendiri.
Pertama, keunikan nama objek. Seksyen 4 menyatakan nama SHOULD unik — cadangan, bukan peraturan. Maka kunci pendua bukan ralat sintaks, dan parser di mana-mana memilih "yang akhir menang". Pengesah perniagaan kemudian hanya melihat nilai yang terselamat; nilai yang penghantar hantar dahulu lenyap tanpa ralat mahupun baris log.
Kedua, nombor. Tatabahasa hanya menetapkan bentuk int frac exp; magnitud diserahkan kepada pelaksanaan. JavaScript memaksa semuanya melalui double IEEE 754, jadi 9007199254740993 menjadi ...992. jq mengekalkan literal perpuluhan dengan setia sejak 1.8, tetapi sebarang aritmetik kembali kepada double. Dokumen yang sama boleh memaparkan tiga nilai berbeza merentas perbandingan, penyimpanan dan penghantaran.
Ketiga, UTF-8 dan aksara halimunan. Spesifikasi menuntut JSON yang dipertukarkan dalam UTF-8, tetapi bagaimana fail dibuka, sama ada BOM ditanggalkan dan bagaimana bait tidak sah dilayan adalah keputusan lapisan IO. Aliran bait yang sama memberi keputusan berbeza bergantung sama ada Python membukanya sebagai utf-8 atau utf-8-sig.
Sumber keempat ialah dialek longgar. JSON5 membenarkan komen, petikan tunggal dan koma penutup; JSONC melonggarkan peraturan sama dalam ekosistem VS Code. Konfigurasi yang dihurai oleh parser longgar dan API yang dihurai oleh parser ketat ialah percanggahan paling biasa dalam satu pasukan.
CVE-2026-33948: apabila percanggahan menjadi permukaan serangan
Perbezaan parser biasanya sekadar gangguan pengalaman pengguna. Begitu sahaja "pengesahan" dan "penghuraian" berjalan atas dua pelaksanaan berbeza, ia menjadi permukaan serangan. CVE-2026-33948, didedahkan pada 2026, adalah kes buku teks: jq sebelum 1.8.2 membenarkan bait NUL terbenam (\0) semasa membaca JSON daripada fail, lalu input yang sama menghasilkan dua keputusan — fasa pengesahan menganggap kandungan tamat di situ, manakala pemprosesan sebenar terus membaca melepasinya. Pintasan itu lengkap. Penasihat keselamatan GitHub mengesahkan pembetulan: naik taraf ke 1.8.2.
Abstrakkan pengajarannya: dalam sebarang rantaian "sahkan dahulu, hurai kemudian", jika kedua-dua langkah memakai pelaksanaan atau konfigurasi berbeza, penyerang boleh reka input yang pengesah menolak tetapi parser terima, menyeludup payload melepasi pemeriksaan. Struktur sama berulang di gerbang — hujah API7 menulis penghuraian ketat dalam kontrak API ialah semantik penghuraian sebahagian daripada kontrak, bukan gelagat peribadi sesuatu pelaksanaan. Bila gerbang menolak permintaan di bawah satu set peraturan dan perkhidmatan backend menerima badan sama di bawah parser lain, kontrak sudah pecah.
Pemeriksaan diri muat dalam satu arahan — pastikan setiap fasa menjalankan versi jq yang sama, termasuk pembetulan ini:
jq --version
# jq-1.7.1 ← terjejas, naik taraf
# jq-1.8.2 ← telah dibaiki
Kunci pendua: nilai terakhir menelan yang pertama secara senyap
Kunci pendua berhak mendapat seksyen tersendiri kerana itulah satu-satunya sempadan yang semua parser arus utama terima sedangkan hampir setiap pembangun menganggapnya ralat.
import json
text = '{"role": "guest", "role": "admin"}'
data = json.loads(text)
print(data) # {'role': 'admin'}
print("guest" in data.values()) # False: nilai pertama sudah hilang
Jika teks itu menyalakan semakan tandatangan atau keputusan kebenaran, penyerang boleh tambah satu medan bernama sama untuk menulis ganti keistimewaan, dan kod pengesahan anda hanya melihat nilai akhir. JSON.parse Node berkelakuan sama. Untuk mengesan alih-alih menulis ganti senyap, Python menerima 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']
Seksyen 4 RFC 8259 menyatakannya terus: demi kebolehsalingoperasian, nama SHOULD unik. Menaikkan SHOULD itu kepada peraturan pengesahan menelan kos satu laluan sahaja dan membuang punca paling biasa "dua alat, dua keputusan".
Penyelesaian: satu timbang tara bagi setiap sempadan
Pembaikannya bukan "bertukar kepada parser lebih ketat". Ia ialah memberi setiap titik sempadan satu polisi jelas yang ditulis — dan memastikan pengesahan dan pelaksanaan memakai polisi yang sama. Jadual berikut berfungsi sebagai senarai semak semakan:
| Sempadan | Gelagat longgar lalai | Keputusan disyorkan | Konfigurasi wakil |
|---|---|---|---|
| kunci pendua | yang akhir menang | tolak | object_pairs_hook Python; json/v2 Go menolak secara lalai |
| NaN / Infinity | Python terima | tolak | parse_constant Python yang membaling pengecualian |
| ahli tidak dikenali | diabaikan senyap | putuskan mengikut kontrak | RejectUnknownMembers(true) json/v2 Go |
| UTF-8 tidak sah | berbeza ikut pelaksanaan | tolak | semakan strim bait jelas di lapisan pendekodan |
| BOM | yang menanggalkan yang menentukan | tanggalkan sekali di pintu masuk | utf-8-sig tetap atau tanggalkan sebelum huraian |
| pengesahan dan pelaksanaan terpisah | setiap satu berasingan | satu pelaksanaan, satu konfigurasi | pengesah guna semula parser pengeluaran |
Di pihak Python, mematikan dua lalai paling berbahaya hanya satu panggilan:
import json
def _reject(value):
raise ValueError(f"non-standard constant: {value}")
data = json.loads(
raw,
parse_constant=_reject, # halang NaN / Infinity
object_pairs_hook=reject_dup, # halang kunci pendua
)
encoding/json/v2 dalam Go (dengan alias jsonv2) menjadikan seluruh polisi jelas: RejectUnknownMembers(true) menolak medan tidak dikenali, dan nama pendua bersama UTF-8 tidak sah ditolak secara lalai. Halaman amalan GopherForge tepat tentang urutan: hadkan bait input, dekod di bawah polisi jelas, sahkan domain dan sahkan kebenaran, barulah benarkan kesan sampingan — dan setiap laluan kegagalan perlu diuji dengan fixture, bukan dinilai daripada rentetan ralat yang berubah.
Bawa polisi penghuraian ke dalam kontrak dan korpus
Polisi perlu perlindungan daripada hanyutan. Dua tindakan sudah memadai.
Pertama, tulis "apa yang kami terima, apa yang kami tolak" dalam dokumentasi antara muka di samping definisi medan. API7 mengesyorkan kod ralat stabil supaya klien dapat membezakan ralat kontrak kekal daripada kegagalan infrastruktur sementara — kunci pendua yang ditolak tidak boleh kelihatan seperti tamat masa gerbang, jika tidak anda menjemput ribuan cubaan semula. Jangan tuang seluruh badan permintaan ke dalam log: payload mentah mungkin mengandungi kelayakan, dan beberapa jujukan bait tidak sah tidak selamat dipaparkan.
Kedua, bina korpus kekaburan. Jadikan setiap baris jadual di atas sebagai fixture ujian: kunci pendua, kunci dengan huruf besar-kecil berbeza, ahli tidak dikenali, UTF-8 tidak sah, BOM, nilai kedua di hujung, input kosong. Tegaskan dua perkara dalam CI: input tidak sah gagal tanpa menghasilkan nilai separa yang boleh diguna, dan input diterima menamatkan pusingan pengekodan/pendekodan tanpa berubah. Apabila naik taraf parser, mainkan semula sampel berbentuk pengeluaran dalam persekitaran terlindung dalam mod perbandingan, dan semak perubahan dalam set penerimaan sebagai perubahan kontrak sebenar alih-alih menganggap fixture lama menutup segalanya.
Tindakan ini melengkapi Pengesahan JSON dalam CI: talian paip jsonlint, ajv dan jq, yang menerangkan bagaimana pengesahan sintaks dan skema menempatkan diri dalam talian paip; artikel ini meliputi apa yang sebelum nod pertama — parser itu sendiri. Risiko suntikan seperti pencemaran prototaip dan XSS dibincangkan dalam senarai semak risiko keselamatan JSON; isu rantaian kepercayaan peringkat parser — kunci pendua dan bait NUL — tepat merupakan lapisan sifar senarai itu. Untuk mengesan ralat sintaks biasa, lihat Sempadan tatabahasa JSON daripada RFC 8259.
Senarai semak pra-pelancaran
- Selaraskan versi parser merentas seluruh rantaian: jq, runtime, gerbang, pengesah luar talian — pembetulan kelas CVE-2026-33948 mesti sampai ke mana-mana;
- Tolak secara jelas kunci pendua dan NaN: letakkan
object_pairs_hookdanparse_constantdalam pembalut bersama, jangan sesekali panggiljson.loadskosong dalam kod perniagaan; - Putuskan ahli tidak dikenali mengikut laluan: pengguna serasi ke hadapan boleh abaikan, endpoint arahan wajib menetapkan
RejectUnknownMembers; - Korpus kekaburan dalam CI: sekurang-kurangnya 8 fixture, plus satu larian perbandingan lama-menentang-baharu sebelum setiap naik taraf parser;
- Ralat berkelas: kod berasingan untuk ralat kontrak dan infrastruktur, hanya yang kedua dicuba semula.
Kembali kepada ayat pembukaan: lulus pengesahan bermaksud "diterima oleh sesuatu parser di bawah sesuatu polisi". Jadikan polisi itu jelas — ke dalam kontrak, ke dalam korpus, ke dalam pinning versi — dan "satu JSON, dua keputusan" akhirnya lenyap.
FAQ
Adakah kunci pendua sebenarnya ralat menurut spesifikasi JSON?
Bukan ralat sintaks. Seksyen 4 RFC 8259 merumuskannya sebagai nama SHOULD unik — cadangan, bukan keperluan — maka parser utama menerima pendua dan menyimpan nilai terakhir secara lalai. Spesifikasi tetap menyarankan keunikan demi kebolehsalingoperasian. Menaiknya menjadi ralat pengesahan adalah keputusan kontrak; pengesanan menelan kos satu laluan.
Mengapa pustaka json Python menerima NaN sedangkan JavaScript membaling ralat?
Pustaka standard Python sengaja menerima NaN dan Infinity supaya boleh membaca semula data yang secara sejarahnya dikeluarkan dengan kehilangan. JSON.parse ECMAScript melaksanakan tatabahasa dengan ketat dan membaling SyntaxError. Hantar parse_constant dalam Python untuk menolaknya, dan satu baris konfigurasi menyelaraskan kedua-dua runtime.
Versi mana yang terjejas oleh CVE-2026-33948 dan bagaimana ia dibaiki?
jq sebelum 1.8.2, semasa membaca JSON daripada fail, menerima bait NUL terbenam yang menyebabkan fasa pengesahan dan parser sebenar bercanggah atas input yang sama, membolehkan pintasan pengesahan. Pembetulan mengikut penasihat GitHub ialah naik taraf ke 1.8.2 atau binaan yang mengandungi commit 6374ae0. Pin versi dalam skrip dan CI, dan jalankan korpus kekaburan sebelum naik taraf.
Saya mengesahkan sekali di pintu masuk dan guna semula hasilnya — adakah saya masih terdedah?
Ya, tetapi risiko tertumpu di satu-satunya pintu masuk itu. Jika parser pintu masuk, konfigurasi dan versinya dipin, dan korpus kekaburan meliputi kunci pendua, bait NUL dan UTF-8, tiada timbang tara kedua dalam rantaian. Topologi berbahaya ialah gerbang atas satu pelaksanaan dan perkhidmatan atas pelaksanaan lain, atau pengesahan atas satu parser dan pelaksanaan atas parser lain — ketika itu keputusan diserahkan kepada percanggahan itu sendiri.