Sebuah request HTTP janggal masuk ke endpoint API aplikasi: GET /api/v1/profile?api_token[]=0. Parameter autentikasi yang seharusnya berupa string token acak dikirim sebagai array satu elemen bernilai nol.

Guard autentikasi membaca input tersebut dan meneruskannya ke query builder. Beberapa milidetik kemudian, server mengembalikan kode status 200 OK beserta seluruh data profil milik akun administrator dengan ID 1.

Penyerang tidak perlu mengetahui password maupun token rahasia milik admin. Namun sistem meloloskan sesi mereka secara penuh.

Akar masalah insiden ini adalah kombinasi antara parameter confusion dan implicit type conversion pada database engine, yang tercatat resmi pada penasihat keamanan CVE-2026-114509 (GHSA-f9x3-7vq9-cph6). Di artikel ini saya membedah bagaimana query builder di Laravel dan ORM Node.js memproses parameter array menjadi klausa pencarian yang cacat. Kita juga akan melihat mengapa konfigurasi STRICT_TRANS_TABLES di MySQL gagal mencegah celah ini, korelasi integritas data pada celah JSON:API CVE-2026-114508, serta mitigasi defensifnya. Seluruh skenario pengujian di sini diambil dari repo referensi publik.

Anatomi CVE-2026-114509: dari array input ke klausa WHERE IN

Banyak pengembang berasumsi bahwa framework modern otomatis menolak tipe data yang tidak sesuai. Kenyataannya, komponen autentikasi bawaan Illuminate\Auth\TokenGuard pada Laravel versi sebelum 12.68.0 dan 13.29.0 menyimpan asumsi implisit mengenai bentuk input request.

Mari kita telusuri alur eksekusi saat request masuk ke TokenGuard::user():

// Illuminate\Auth\TokenGuard (sebelum patch)
public function getTokenForRequest()
{
    $token = $this->request->query($this->inputKey);

    if (empty($token)) {
        $token = $this->request->input($this->inputKey);
    }

    return $token;
}

Ketika penyerang mengirimkan query string berformat array seperti api_token[]=0, PHP membaca nilai $token sebagai array [0].

Masalah muncul pada blok validasi awal di method user() dan validate():

if (! empty($token)) {
    $user = $this->provider->retrieveByCredentials([$this->storageKey => $token]);
}

Fungsi empty() di PHP mengembalikan nilai false untuk array yang memiliki elemen, meskipun elemen tersebut bernilai 0. Akibatnya, array [0] dianggap sebagai kredensial valid dan diteruskan ke EloquentUserProvider::retrieveByCredentials().

Di dalam EloquentUserProvider, kredensial diproses untuk menyusun kriteria query database:

// Illuminate\Auth\EloquentUserProvider
foreach ($credentials as $key => $value) {
    if (is_array($value) || $value instanceof Arrayable) {
        $query->whereIn($key, $value);
    } else {
        $query->where($key, $value);
    }
}

Karena $token bernilai array, Eloquent tidak membuat klausa WHERE api_token = ?, melainkan mengeksekusi whereIn('api_token', [0]). Query SQL mentah yang dikirimkan ke koneksi PDO menjadi:

SELECT * FROM `users` WHERE `api_token` IN (0) LIMIT 1;

Pola kerentanan serupa ditemukan pada ekosistem Node.js. Ketika aplikasi Express menggunakan parser query qs (default pada express.urlencoded({ extended: true })), payload api_token[]=0 menghasilkan objek { api_token: ['0'] }.

Jika controller langsung meneruskan properti tersebut ke ORM seperti Sequelize tanpa validasi skema:

// Pola rentan di Node.js / Sequelize
const user = await User.findOne({
  where: {
    api_token: req.query.api_token
  }
});

Sequelize secara otomatis menerjemahkan nilai bertipe array menjadi operator Op.in. Database MySQL pun menerima klausa pencarian numerik yang identik.

Mengapa MySQL menganggap string token sama dengan 0

Mengapa klausa WHERE api_token IN (0) bisa mencocokkan baris data pada tabel pengguna? Bukankah nilai token yang tersimpan di kolom api_token adalah string acak seperti adm_sec_9f82ab73c41094e1d5289?

Jawabannya terletak pada aturan konversi tipe data implisit (type coercion) di engine MySQL dan MariaDB.

Berdasarkan dokumentasi resmi MySQL 8.0 Reference Manual Bagian 14.3 (Type Conversion in Expression Evaluation), aturan perbandingan tipe data menyatakan:

Jika salah satu argumen adalah angka dan argumen lainnya adalah string, MySQL otomatis mengonversi string tersebut menjadi angka sebelum menjalankan perbandingan.

Saat MySQL mengeksekusi ekspresi api_token IN (0), engine mengevaluasi setiap baris dengan aturan:

CAST(`api_token` AS DOUBLE) = 0

Dalam fungsi konversi string ke angka pada bahasa C (my_strntod di engine MySQL), parser membaca karakter dari kiri ke kanan. Jika karakter pertama bukan digit angka (misalnya huruf a sampai z), parser langsung berhenti dan mengembalikan angka 0.

Perhatikan evaluasi perbandingan baris tabel berikut:

  1. Token adm_sec_9f82ab73c41094e1d5289 diawali huruf a, sehingga dikonversi menjadi angka 0.
  2. Hasil evaluasi perbandingan menjadi 0 = 0, yang bernilai TRUE.
  3. Token usr_tok_849204128401928401294 juga diawali huruf u, sehingga dikonversi menjadi 0 dan bernilai TRUE.
  4. Token 7829104819204819204819204 diawali angka, sehingga dikonversi menjadi 7.8291e24 dan bernilai FALSE.

Karena method autentikasi memanggil ->first() pada query builder, database mengembalikan baris pertama yang memenuhi kondisi TRUE. Pada hampir semua instalasi sistem, baris pertama di tabel users adalah akun administrator yang dibuat saat inisialisasi aplikasi.

Mitos perlindungan STRICT_TRANS_TABLES

Banyak insinyur merasa sistem mereka aman karena sudah mengaktifkan STRICT_TRANS_TABLES pada konfigurasi sql_mode. Ini adalah pemahaman yang keliru.

Dokumentasi server MySQL menegaskan bahwa STRICT_TRANS_TABLES hanya mengontrol penanganan nilai tidak valid pada operasi penulisan data (INSERT dan UPDATE). Pada operasi baca data (SELECT), MySQL tidak membatalkan eksekusi statement.

Ketika ekspresi CAST('adm_sec_...' AS DOUBLE) dievaluasi pada query SELECT, MySQL hanya mengeluarkan peringatan:

Warning 1292: Truncated incorrect DOUBLE value: 'adm_sec_9f82ab73c41094e1d5289'

Peringatan ini tidak melempar eksepsi ke driver PDO PHP. Hasil query tetap dikembalikan ke framework, dan proses login administrator berjalan sukses.

Sebaliknya, database dengan sistem pengetikan ketat seperti PostgreSQL kebal terhadap skenario ini. PostgreSQL langsung membatalkan query dan melempar error SQLSTATE 42883 (operator does not exist: character varying = integer).

Diagram alur: evaluasi type casting antar engine database

Perbedaan fundamental dalam penanganan tipe data antara MySQL dan PostgreSQL dapat dilihat pada diagram alur berikut:

Diagram alur yang membandingkan evaluasi query autentikasi berparameter array pada engine MySQL dan PostgreSQL. Input api_token array dipipihkan query builder menjadi WHERE api_token IN 0. Di kolom MySQL, implicit type conversion mengubah string token berawalan huruf menjadi integer 0 sehingga evaluasi 0 sama dengan 0 bernilai benar dan meloloskan akun admin ID 1. Di kolom PostgreSQL, strict static typing memicu error 42883 dan membatalkan query.

Dari diagram di atas terlihat jelas:

  • Di layer aplikasi: Query builder memipihkan array menjadi klausa IN (0) tanpa memeriksa apakah tipe kolom tujuan kompatibel dengan tipe numerik.
  • Di layer database MySQL: Konversi implisit mengubah perbandingan keamanan kredensial menjadi perbandingan matematika nol yang cocok untuk token berawalan huruf.

Ancaman relasi include JSON:API pada CVE-2026-114508

Kerentanan type confusion pada query builder tidak berdiri sendiri. Pada jendela rilis yang sama, tim pengembang Laravel juga menutup celah keamanan tingkat menengah CVE-2026-114508 (GHSA-5wcm-3v2w-8362).

Celah ini menyerang fitur relasi include pada komponen JSON:API resource (ResolvesJsonApiElements) yang diperkenalkan di Laravel 12.45.0.

Pada endpoint API yang bersifat read-only (misalnya GET /api/v1/articles?include=...), pengguna tanpa hak akses modifikasi data dapat mengirimkan parameter nama relasi yang dimanipulasi. Kompiler relasi internal secara tidak aman mengevaluasi method pada model Eloquent melalui refleksi dinamis.

Vektor ini memungkinkan pengguna dengan hak baca semata untuk memicu pemanggilan method destruktif seperti penghapusan data relasional tabel anak. Data pada tabel terkait bisa terhapus bersih tanpa melewati otorisasi penulisan.

Pola antara CVE-2026-114509 dan CVE-2026-114508 memiliki benang merah yang sama: mempercayai struktur input pengguna untuk menentukan alur kompilasi internal framework.

Reproduksi: membuktikan query bypass di Laravel

Kita buktikan anomali evaluasi ini secara langsung menggunakan alat uji pada repo referensi publik.

Uji forensik ini menyimulasikan pembacaan parameter request array, kompilasi query Eloquent, serta evaluasi type casting pada tabel pengguna:

php tests/test-cve-2026-114509-type-juggling.php

Berikut output asli yang dihasilkan dari pengujian terminal:

============================================================
  AUDIT DEFENSIVE: SIMULASI CVE-2026-114509 & TYPE JUGGLING
============================================================

[1] Ekstraksi Input Request (TokenGuard::getTokenForRequest):
    Tipe Data Parameter : array
    Struktur Input      : [0]
    Evaluasi !empty()   : TRUE (Lolos guard awal)

------------------------------------------------------------
[2] Kompilasi Query EloquentUserProvider (Unpatched):
    SQL Dihasilkan      : SELECT * FROM `users` WHERE `api_token` IN (0) LIMIT 1;
    Mekanisme Query     : Klausa WHERE `api_token` IN (0)

------------------------------------------------------------
[3] Evaluasi Engine Database terhadap Tipe Data:

    A. MySQL / MariaDB (Type Coercion Rule Section 14.3):
       - Kolom `api_token` bertipe VARCHAR dibandingkan dengan INTEGER 0.
       - Engine melakukan konversi implisit: CAST(`api_token` AS DOUBLE/INT).
       - String dengan awalan huruf (non-numerik) dievaluasi menjadi nilai 0.
       - Evaluasi ekspresi: (0 == 0) => TRUE.
       * User #1 (Super Administrator):
         Token Asli    : 'adm_sec_9f82ab73c41094e1d5289'
         MySQL Coerce  : 0
         Hasil Match   : MATCH (TRUE) ๐Ÿšจ
       * User #2 (Regular Member):
         Token Asli    : 'usr_tok_849204128401928401294'
         MySQL Coerce  : 0
         Hasil Match   : MATCH (TRUE) ๐Ÿšจ
       * User #3 (Numeric Token User):
         Token Asli    : '7829104819204819204819204'
         MySQL Coerce  : 7.8291048192048E+24
         Hasil Match   : NO MATCH (FALSE)

    ๐Ÿ”ด HASIL LOGIN (UNPATCHED): BERHASIL BYPASS!
       User Terautentikasi : ID 1 (Super Administrator)
       Role Diberikan      : admin
       Status Autentikasi  : BYPASS TANPA TOKEN VALID!

    B. PostgreSQL (Strict Static Typing):
       - Query: WHERE api_token IN (0)
       - Engine Error: ERROR: operator does not exist: character varying = integer
       - SQLSTATE 42883: Query otomatis dibatalkan, sistem kebal type juggling.

------------------------------------------------------------
[4] Verifikasi TokenGuard Pasca-Patch (is_string Check):
    Guard Check         : is_string($token) => FALSE
    Aksi Engine         : Input non-string ditolak sebelum query DB.
    ๐ŸŸข HASIL LOGIN (PATCHED): DITOLAK (HTTP 401 UNAUTHORIZED) โœ…
============================================================

Output di atas membuktikan bahwa akun administrator dengan token berawalan huruf langsung terautentikasi saat nilai integer 0 dimasukkan ke dalam query.

Mitigasi: strict type guard, skema validasi, dan audit defensif

Untuk mengamankan aplikasi dari serangan manipulasi tipe data pada query autentikasi, terapkan langkah mitigasi berlapis berikut:

1. Perbarui Dependency Framework

Langkah utama adalah memperbarui dependensi framework ke versi patch resmi yang telah menambal CVE-2026-114509 dan CVE-2026-114508:

composer update laravel/framework

Pastikan versimu berada di Laravel 12.68.0 atau Laravel 13.29.0 ke atas. Patch resmi menambahkan pengecekan ketat pada TokenGuard.php:

// Illuminate\Auth\TokenGuard (patched)
if (is_string($token) && ! empty($token)) {
    $user = $this->provider->retrieveByCredentials([$this->storageKey => $token]);
}

Pemeriksaan is_string($token) memastikan input berupa array langsung dibatalkan sebelum query database disusun.

2. Terapkan Validasi Skema Ketat

Jangan biarkan controller atau guard membaca input mentah dari request tanpa validasi. Gunakan Laravel Form Request untuk memastikan tipe data kredensial berupa string tunggal:

public function rules(): array
{
    return [
        'api_token' => ['required', 'string', 'max:80'],
    ];
}

Pada backend Node.js, gunakan library skema seperti Zod untuk memvalidasi query parameter secara ketat:

import { z } from 'zod';

const AuthQuerySchema = z.object({
  api_token: z.string().min(20).max(80),
});

const query = AuthQuerySchema.parse(req.query);

3. Gunakan Token Hashing di Database

Menyimpan token API dalam bentuk teks mentah pada kolom VARCHAR adalah praktik yang berisiko. Jika token disimpan dalam bentuk hash SHA-256, aplikasi wajib melakukan komputasi hash sebelum menjalankan query:

$hashed = hash('sha256', $token);
$user = User::where('api_token_hash', $hashed)->first();

Jika penyerang mengirimkan array [0], fungsi hash() di PHP melempar error TypeError karena menolak tipe data non-string. Query pencarian ke database bahkan tidak akan pernah dieksekusi.

Audit integrasi autentikasi secara menyeluruh sangat penting, terutama jika aplikasimu berinteraksi dengan payment gateway atau API pihak ketiga yang dibahas pada artikel celah runtime integrasi API. Jika kamu membutuhkan audit mendalam terhadap integritas arsitektur backend, Nextmend menyediakan layanan audit dan perbaikan API.

Sumber

Daftar penasihat keamanan dan dokumentasi primer berikut dicek pada 1 November 2026:

Kode contoh lengkap di GitHub โ†’