Satu JSON, Dua Putusan: Perbedaan Parser dan Batas Kepercayaan Validasi
Intinya: Ketika validator menerima dokumen tetapi layanan berikutnya crash, biasanya dua parser berbeda pendapat tentang teks yang sama. Artikel ini membandingkan kunci duplikat, byte NUL, UTF-8 tidak valid, NaN, dan nol di awal pada runtime nyata, menjelaskan bagaimana CVE-2026-33948 mengubah perbedaan menjadi permukaan serangan, dan menunjukkan cara menetapkan satu arbiter untuk setiap batas.

Lolos validasi hanya membuktikan satu hal: teks diterima oleh parser itu, di bawah kebijakan itu. Ganti parser, dan putusan bisa berbalik.
Gejala: alat A lolos, alat B menolak
Inilah adegan yang pernah dijumpai semua orang. Respons API ditempel ke formatter daring dan mendapat centang hijau. Payload yang sama tiba di layanan berikutnya dan melempar exception. Saat kedua parser disandingkan dan dibandingkan karakter demi karakter, biasanya tidak ada pihak yang "salah" — data mendarat tepat di titik di mana dua implementasi berbeda pendapat.
Titik seperti itu tidak banyak, tetapi masing-masing umum. Tabel di bawah mencatat perilaku nyata untuk input berfrekuensi tinggi (diuji terhadap Node 22 JSON.parse, json bawaan Python 3.11, jq 1.8, dan validator daring populer):
| Input | Node JSON.parse | Python json.loads | jq | Catatan |
|---|---|---|---|---|
{"a":1,"a":2} kunci duplikat |
diterima, yang terakhir bertahan | diterima, yang terakhir bertahan | diterima, yang terakhir bertahan | RFC 8259 hanya menyatakan SHOULD; keempatnya membiarkannya |
{"n":NaN} |
error | diterima | error | Library standar Python menerimanya secara default — jebakan senyap terbesar |
{"n":01} nol di awal |
error | error | error | Ditolak seragam, tetapi posisi error berbeda |
"中文" disimpan sebagai byte GBK |
error atau mojibake | bergantung pada encoding | error | RFC mewajibkan UTF-8, tetapi decoding adalah urusan lapisan IO |
{"a":1} dengan BOM |
error | diterima (utf-8-sig) | error | Yang melepas BOM yang menentukan |
| komentar, kutip tunggal, koma penutup | error | error | error | Hanya parser JSON5/JSONC yang menerimanya |
Lihat baris kedua: json.loads('{"cpu":NaN}') legal di Python. Library standar sengaja menerima NaN/Infinity demi kompatibilitas ke belakang, dan banyak pipeline menghitung baris sampah ini sebagai record normal tanpa menyadari kontaminasinya. Memblokirnya butuh argumen parse_constant yang eksplisit — kode di bawah.
Dari mana perbedaan itu berasal: celah spesifikasi dan keputusan implementasi
RFC 8259 tidak kabur; spesifikasi sengaja membiarkan tiga area "terserah implementasi", dan setiap implementasi mengisinya dengan caranya sendiri.
Pertama, keunikan nama objek. Bagian 4 menyatakan nama SEBAIKNYA (SHOULD) unik — rekomendasi, bukan aturan. Kunci duplikat bukan error sintaks, dan parser di mana-mana memilih "yang terakhir menang". Validator bisnis kemudian hanya melihat nilai yang bertahan; nilai yang dikirim pengirim lebih dulu lenyap tanpa error atau baris log.
Kedua, angka. Tata bahasa hanya menetapkan bentuk int frac exp; besaran diserahkan ke implementasi. JavaScript memaksa semuanya melalui double IEEE 754, sehingga 9007199254740993 menjadi ...992. jq menyimpan literal desimal secara setia sejak 1.8, tetapi aritmetika apa pun kembali ke double. Dokumen yang sama bisa menampilkan tiga nilai berbeda saat dibandingkan, disimpan, dan dikirim.
Ketiga, UTF-8 dan karakter tak terlihat. Spesifikasi mensyaratkan JSON yang dipertukarkan dalam UTF-8, tetapi bagaimana file dibuka, apakah BOM dilepas, dan bagaimana byte tidak valid diperlakukan adalah keputusan lapisan IO. Aliran byte yang sama memberi putusan berbeda bergantung Python membukanya sebagai utf-8 atau utf-8-sig.
Sumber keempat adalah dialek yang longgar. JSON5 memperbolehkan komentar, kutip tunggal, dan koma penutup; JSONC melonggarkan aturan yang sama di ekosistem VS Code. Konfigurasi yang diurai parser toleran dan API yang diurai parser ketat adalah penyimpangan paling umum di dalam satu tim.
CVE-2026-33948: ketika perbedaan menjadi permukaan serangan
Perbedaan parser biasanya sekadar gangguan UX. Begitu "validasi" dan "parsing" berjalan pada dua implementasi berbeda, keduanya menjadi permukaan serangan. CVE-2026-33948, diumumkan tahun 2026, adalah kasus buku teks: jq sebelum 1.8.2 menerima byte NUL tertanam (\0) saat membaca JSON dari file, sehingga input yang sama menghasilkan dua putusan — tahap validasi menganggap konten berakhir di situ, sementara pemrosesan sesungguhnya membaca lebih jauh. Bypass-nya lengkap. Security advisory GitHub mengonfirmasi perbaikannya: upgrade ke 1.8.2.
Abstrakkan pelajarannya: dalam rantai "validasi dulu, parsing kemudian" mana pun, jika kedua langkah memakai implementasi atau konfigurasi berbeda, penyerang bisa merancang input yang validator tolak dan parser terima, menyelundupkan payload melewati pemeriksaan. Struktur yang sama berulang di gateway — argumen API7 untuk menuliskan parsing ketat ke kontrak API adalah semantik parsing bagian dari kontrak, bukan perilaku privat sebuah implementasi. Ketika gateway menolak permintaan dengan satu aturan dan layanan backend menerima body yang sama dengan parser lain, kontrak sudah rusak.
Pemeriksaan mandiri muat dalam satu perintah — pastikan setiap tahap menjalankan versi jq yang sama, termasuk perbaikan ini:
jq --version
# jq-1.7.1 ← rentan, upgrade
# jq-1.8.2 ← sudah diperbaiki
Kunci duplikat: nilai terakhir menelan yang pertama secara diam-diam
Kunci duplikat pantas mendapat bagian tersendiri karena menjadi satu-satunya batas yang semua parser mainstream terima padahal hampir setiap developer menganggapnya error.
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 menghidupkan pemeriksaan tanda tangan atau keputusan izin, penyerang bisa menambahkan satu field bernama sama untuk menimpa hak akses, dan kode validasi Anda hanya melihat nilai akhir. JSON.parse milik Node berperilaku identik. Untuk mendeteksi alih-alih menimpa diam-diam, 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']
Bagian 4 RFC 8259 menyatakannya lugas: demi interoperabilitas, nama SEBAIKNYA unik. Menaikkan SHOULD itu menjadi aturan validasi hanya menelan biaya satu kali iterasi dan menghapus sumber paling umum dari "dua alat, dua putusan".
Solusinya: satu arbiter untuk setiap batas
Perbaikannya bukan "pindah ke parser yang lebih ketat". Melainkan memberi setiap titik batas kebijakan yang eksplisit dan tertulis — dan membuat validasi serta eksekusi memakai kebijakan yang sama. Tabel berikut berfungsi sebagai checklist review:
| Batas | Perilaku default toleran | Putusan yang disarankan | Konfigurasi representatif |
|---|---|---|---|
| kunci duplikat | yang terakhir menang | tolak | object_pairs_hook Python; json/v2 Go menolak secara default |
| NaN / Infinity | Python menerima | tolak | parse_constant Python yang melempar exception |
| anggota tak dikenal | diabaikan diam-diam | putuskan sesuai kontrak | RejectUnknownMembers(true) json/v2 Go |
| UTF-8 tidak valid | beragam antar implementasi | tolak | validasi aliran byte eksplisit di lapisan decoding |
| BOM | yang melepas yang menentukan | lepas sekali di pintu masuk | utf-8-sig tetap atau lepas sebelum parsing |
| validasi dan eksekusi terpisah | masing-masing berjalan sendiri | satu implementasi, satu konfigurasi | validator memakai ulang parser produksi |
Di sisi Python, mematikan dua default paling berbahaya hanya satu panggilan:
import json
def _reject(value):
raise ValueError(f"non-standard constant: {value}")
data = json.loads(
raw,
parse_constant=_reject, # blokir NaN / Infinity
object_pairs_hook=reject_dup, # blokir kunci duplikat
)
encoding/json/v2 di Go (beralias jsonv2) membuat seluruh kebijakan eksplisit: RejectUnknownMembers(true) menolak field tak dikenal, dan nama duplikat bersama UTF-8 tidak valid ditolak secara default. Halaman praktik GopherForge presisi soal urutannya: batasi byte input, decode di bawah kebijakan eksplisit, validasi domain dan otorisasi, baru izinkan efek samping — dan setiap jalur kegagalan harus dilatih dengan fixture, bukan dinilai dari pesan error yang berubah.
Bawa kebijakan parsing ke kontrak dan korpus
Kebijakan perlu perlindungan dari penyimpangan. Dua langkah cukup.
Pertama, tulis "apa yang kita terima, apa yang kita tolak" ke dokumentasi antarmuka di samping definisi field. API7 merekomendasikan kode error yang stabil agar klien dapat membedakan error kontrak permanen dari kegagalan infrastruktur sementara — kunci duplikat yang ditolak tidak boleh tampak seperti timeout gateway, kalau tidak Anda mengundang badai retry. Jangan curahkan seluruh body permintaan ke log: payload mentah bisa berisi kredensial, dan beberapa urutan byte tidak valid tidak aman ditampilkan.
Kedua, bangun korpus ambiguitas. Ubah setiap baris tabel di atas menjadi fixture pengujian: kunci duplikat, kunci dengan kapitalisasi berbeda, anggota tak dikenal, UTF-8 tidak valid, BOM, nilai kedua di akhir, input kosong. Tegaskan dua hal di CI: input tidak valid gagal tanpa menghasilkan nilai parsial yang bisa dipakai, dan input yang diterima selamat melewati putaran encode/decode tanpa berubah. Ketika parser di-upgrade, putar ulang sampel berbentuk produksi di lingkungan terlindung dalam mode perbandingan, dan tinjau perubahan pada himpunan penerimaan sebagai perubahan kontrak sungguhan alih-alih berasumsi fixture lama menutup semuanya.
Langkah-langkah ini melengkapi Validasi JSON di CI: pipeline jsonlint, ajv dan jq, yang membahas bagaimana validasi sintaks dan skema menempatkan diri dalam pipeline; artikel ini membahas apa yang ada sebelum simpul pertama — parser itu sendiri. Risiko injeksi seperti prototype pollution dan XSS dibahas di daftar periksa risiko keamanan JSON; masalah rantai kepercayaan level parser — kunci duplikat dan byte NUL — tepat merupakan lapisan nol dari daftar itu. Untuk menemukan error sintaks sederhana, lihat Batas tata bahasa JSON dari RFC 8259.
Checklist pra-rilis
- Samakan versi parser di seluruh rantai: jq, runtime, gateway, validator offline — perbaikan kelas CVE-2026-33948 harus sampai ke mana-mana;
- Tolak secara eksplisit kunci duplikat dan NaN: masukkan
object_pairs_hookdanparse_constantke wrapper bersama, jangan pernah memanggiljson.loadstelanjang di kode bisnis; - Putuskan anggota tak dikenal per route: konsumen yang kompatibel ke depan boleh mengabaikannya, endpoint perintah wajib menyetel
RejectUnknownMembers; - Korpus ambiguitas di CI: minimal 8 fixture, plus satu putaran perbandingan lama-lawan-baru sebelum setiap upgrade parser;
- Error yang dapat diklasifikasi: kode terpisah untuk error kontrak dan infrastruktur, coba ulang hanya yang kedua.
Kembali ke kalimat pembuka: lolos validasi berarti "diterima oleh suatu parser di bawah suatu kebijakan". Jadikan kebijakan itu eksplisit — ke kontrak, ke korpus, ke penguncian versi — dan "satu JSON, dua putusan" akhirnya lenyap.
FAQ
Apakah kunci duplikat benar-benar error menurut spesifikasi JSON?
Bukan error sintaks. Bagian 4 RFC 8259 merumuskannya sebagai nama SEBAIKNYA (SHOULD) unik — rekomendasi, bukan keharusan — sehingga parser utama menerima duplikat dan menyimpan nilai terakhir secara default. Spesifikasi tetap menyarankan keunikan demi interoperabilitas. Menaikkannya menjadi error validasi adalah keputusan kontrak; mendeteksinya hanya menelan biaya satu iterasi.
Mengapa library json Python menerima NaN sementara JavaScript melempar error?
Library standar Python sengaja menerima NaN dan Infinity agar bisa membaca ulang data yang secara historis ia hasilkan dengan kehilangan. JSON.parse milik ECMAScript mengimplementasikan tata bahasa secara ketat dan melempar SyntaxError. Berikan parse_constant di Python agar ditolak, dan satu baris konfigurasi menyelaraskan kedua runtime.
Versi mana yang terdampak CVE-2026-33948 dan bagaimana perbaikannya?
jq sebelum 1.8.2, saat membaca JSON dari file, menerima byte NUL tertanam yang membuat tahap validasi dan parser sebenarnya berbeda pendapat pada input yang sama, memungkinkan bypass validasi. Perbaikan menurut advisory GitHub adalah upgrade ke 1.8.2 atau build yang memuat commit 6374ae0. Kunci versi di skrip dan CI, dan jalankan korpus ambiguitas sebelum upgrade.
Saya validasi sekali di pintu masuk dan pakai ulang hasilnya — apakah saya tetap terpapar risiko?
Ya, tetapi risikonya terkonsentrasi di satu-satunya titik masuk itu. Jika parser pintu masuk, konfigurasi, dan versinya dikunci, serta korpus ambiguitas mencakup kunci duplikat, byte NUL, dan UTF-8, tidak ada arbiter kedua di dalam rantai. Topologi berbahaya adalah gateway pada satu implementasi dan layanan pada implementasi lain, atau validasi pada satu parser dan eksekusi pada parser lain — saat itu putusan diserahkan kepada perbedaan pendapat itu sendiri.