JSON Toolkit

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.

Advanced±6 menit bacaDiterbitkan 2026-11-11Diperbarui 2026-11-11
Sampul menampilkan dua alat yang memberikan putusan berlawanan atas dokumen JSON yang sama

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

  1. Samakan versi parser di seluruh rantai: jq, runtime, gateway, validator offline — perbaikan kelas CVE-2026-33948 harus sampai ke mana-mana;
  2. Tolak secara eksplisit kunci duplikat dan NaN: masukkan object_pairs_hook dan parse_constant ke wrapper bersama, jangan pernah memanggil json.loads telanjang di kode bisnis;
  3. Putuskan anggota tak dikenal per route: konsumen yang kompatibel ke depan boleh mengabaikannya, endpoint perintah wajib menyetel RejectUnknownMembers;
  4. Korpus ambiguitas di CI: minimal 8 fixture, plus satu putaran perbandingan lama-lawan-baru sebelum setiap upgrade parser;
  5. 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.

Referensi

Alat yang sesuai

Artikel terkait

Validasi JSON di CI: Pipeline dengan jsonlint, ajv, dan jq

Validasi sintaks membuktikan file dapat di-parse; validasi schema membuktikan field mengikuti kontrak. Di CI, yang penting adalah exit code yang tidak ambigu, lokasi error, dan jalur perbaikan.

Menengah±10 menit bacaDiperbarui 2026-10-31

Checklist Risiko Keamanan untuk Pemrosesan JSON

JSON.parse sendiri aman; bahayanya ada pada apa yang terjadi setelahnya: deep merge, assignment berdasarkan path, inline ke HTML, kedalaman dan ukuran tanpa batas.

Menengah±12 menit bacaDiperbarui 2026-10-30

Membaca batas tata bahasa JSON dari RFC 8259

Menerjemahkan produksi tata bahasa RFC 8259 ke bahasa sederhana: karakter mana yang boleh muncul langsung, mana yang harus di-escape, dan di mana spesifikasi sengaja memberi ruang.

Pemula±11 menit bacaDiperbarui 2026-10-30