Java4Shell: Bug Base64 OpenJDK Ubah 65 Byte Jadi RCE
Java4Shell: cacat korupsi memori di decoder Base64 AVX-512 OpenJDK. Begini 65 byte memicu korupsi heap dan RCE, serta cara mitigasinya sekarang.

Enam puluh empat huruf A dan satu tanda sama dengan. Hanya itu input yang dibutuhkan untuk merusak heap server OpenJDK yang belum di-patch, yaitu string Base64 sepanjang 65 karakter yang melewati mekanisme keamanan memori Java yang terkenal dan menulis 62 byte melewati akhir sebuah array. Kerentanan ini, yang diungkap firma keamanan Calif dengan nama Java4Shell (CVE-2026-114938, CVSS 9.2), tidak ada di kode aplikasi melainkan di assembly buatan tangan yang tersembunyi dalam decoder Base64 milik JVM. Eksekusi kode jarak jauh tanpa autentikasi berhasil didemonstrasikan terhadap Keycloak, Jenkins, Jira, Confluence, Artifactory, dan PingFederate. Kalau organisasimu menjalankan Java di server x86-64, dan secara statistik memang begitu, ini masalahmu.
Saya meneliti kerentanan untuk nafkah, dan sebagian besar kasus mulai terasa mirip: bug deserialisasi lagi, bypass autentikasi lagi, path traversal lagi. Java4Shell beda, dan bukan karena skornya. Bedanya ada di lokasinya. Bug ini berada di sebuah optimisasi, yaitu percepatan decoding Base64 memakai instruksi vektor AVX-512, yang hampir tidak dibutuhkan aplikasi mana pun. Cerita tentang bagaimana bug ini ditemukan, dieksploitasi, dan mengapa proxy-mu mungkin sudah menyelamatkanmu, menunjukkan banyak hal tentang arah keamanan perangkat lunak ke depan.
Masalahnya: Intrinsic JIT dengan Mask yang Rusak
Untuk memahami bug ini, kamu perlu tahu bagaimana OpenJDK membuat Base64 jadi cepat. HotSpot JVM memantau method mana yang sering dijalankan, lalu membiarkan kompilator C2-nya mengubahnya menjadi kode native. Untuk operasi tertentu, JVM bahkan melangkah lebih jauh dengan mengganti kode dengan rutin assembly hasil tuning tangan yang disebut intrinsic, yang memakai instruksi khusus CPU. Pada chip x86-64 dengan dukungan AVX-512 VBMI, decoding Base64 mendapat perlakuan ini: intrinsic memproses input dalam blok 256 atau 64 byte, memakai instruksi VMOVDQU8 dengan mask 64-bit yang menentukan byte mana yang ditulis ke buffer tujuan.
Cacatnya ada pada cara mask itu dihitung untuk bagian ekor input yang di-padding. Base64 memberi padding pada output dengan karakter =, dan assembly mengurangi panjang output untuk setiap byte padding yang ditemui. Untuk input malformed tertentu, misalnya satu = sendirian di akhir blok, panjang output yang dihitung underflow menjadi -1 atau -2. Nilai negatif itu masuk ke instruksi manipulasi bit (bzhiq) yang, untuk input berukuran 64 atau lebih, membiarkan mask tidak berubah: semua 64 bit terset. Semua bit terset berarti setiap byte ikut ditulis.
Mari lihat pemicunya secara konkret. Kamu mengirim 64 huruf A diikuti =, total 65 karakter. JVM menghitung panjang hasil decoding sebagai 50 byte dan mengalokasikan array 50 byte. Intrinsic men-decode 64 karakter pertama dengan benar, lalu bertemu tanda sama dengan yang nyasar, panjangnya underflow, mask terisi penuh, dan penulisan vektor 64 byte dimulai dekat akhir buffer 50 byte. Sebanyak 62 byte dari objek heap di sebelahnya tertimpa data konstan yang dipengaruhi penyerang. Kode validasi Java akhirnya menyadari input itu tidak valid dan melempar IllegalArgumentException, tapi saat itu kerusakannya sudah terjadi. Exception handler sibuk mengepel lantai padahal rumahnya sudah terbakar.
// Pseudocode of the mask calculation (after Calif's write-up)
input_mask := bzhiq(-1, input_length)
output_len := (input_length / 4) * 3
// handle padding
if input[input_length - 1] == '=':
output_len -= 1
input_mask >>= 1
if input[input_length - 2] == '=':
output_len -= 1
input_mask >>= 1
// For a lone '=' tail, output_len was already 0
// -> now it's -1, and bzhiq(-1, 255) leaves all bits set
output_mask := bzhiq(-1, output_len) // == -1u64, all 64 bits 1
// evmovdqub then writes all 64 bytes where ~50 were allocated
Satu detail penting untuk triage-mu: ini hanya dieksekusi di host x86-64 yang CPU-nya mendukung AVX-512 VBMI. Server ARM seperti AWS Graviton tidak pernah menjalankan stub yang bermasalah, begitu pula Xeon generasi lama. Jalur kode rentan ini juga hanya muncul di JVM berbasis HotSpot: OpenJDK, Oracle JDK, GraalVM. OpenJ9 dan Azul Prime, yang memakai arsitektur JIT berbeda, tidak terdampak. Di OpenJDK 17, pemicunya ternyata 128 huruf A plus =, bukan 64, karena ambang masuk ke jalur cepat lebih tinggi. Perbedaannya kecil, tapi penting kalau kamu menulis aturan deteksi.
Percobaan Gagal Pertama: “Java Itu Aman dari Memori”
Reaksi pertama di channel Slack tim engineering saat kabar ini keluar adalah tidak percaya. Korupsi memori di Java? Bukankah keamanan memori justru inti dari Java? Insting ini, bahwa runtime itu benteng dan hanya kode aplikasi yang bisa mengkhianatimu, adalah model pertama yang gagal. Model ini layak dibahas karena memengaruhi cara tim mengaudit stack mereka sendiri.
Java sebagai bahasa memang memeriksa setiap akses array dan mengelola setiap alokasi. Tapi Java sebagai runtime adalah tubuh besar berisi C, C++, dan assembly. Kompilator JIT, garbage collector, intrinsic, kode native image: semuanya berjalan dengan kekuatan penuh dan tanpa mediasi di dalam proses, dan tak satu pun menikmati jaminan yang diberikan kepada bytecode-mu. Setiap intrinsic adalah lubang kecil yang dibuat di dinding keamanan demi kecepatan, dan lubang-lubang itu dijaga oleh segelintir engineer VM. Ini pelajaran struktural yang sama dengan bug asterisk SSH di Alpine Linux yang sudah berumur satu dekade: cacat paling menakutkan bersembunyi di kode yang semua orang andalkan, tapi hampir tak seorang pun membacanya.
Ada titik buta audit keamanan yang sering saya lihat. Tim akan melakukan fuzzing terhadap parser JSON mereka sendiri, pen-test handler REST, dan menjalankan static analysis di setiap baris yang mereka tulis, lalu memperlakukan JDK sebagai kotak hitam karena sudah matang, luas dipakai, dan dikelola orang-orang pintar. Kematangan bukan pertahanan. Seringnya justru sebaliknya: puluhan tahun optimisasi menumpuk, masing-masing masuk akal pada masanya, masing-masing menambah permukaan serangan yang dikirim ke semua orang, entah mereka mendapat manfaatnya atau tidak. Intrinsic AVX-512 Base64 ada untuk mempercepat aplikasi yang men-decode data dalam jumlah sangat besar. API REST-mu yang men-decode header autentikasi 200 byte mewarisi risikonya tapi hampir tidak mendapat manfaatnya. Calif menyebutnya tragedi milik bersama, dan mereka benar: semua yang butuh fitur itu mendapat manfaatnya, semua yang lain hanya kebagian bug-nya.
Percobaan Gagal Kedua: “Penulisannya Terlalu Terbatas untuk Dieksploitasi”
Model kedua yang gagal datang dari orang-orang yang membaca detail teknisnya lalu jadi santai. Penimpaan nilai konstan di offset tetap, tanpa kendali atas byte yang ditulis? Banyak bug seperti itu langsung dicap “hanya crash” dan diturunkan prioritasnya. Anggapan itu bisa dimengerti, tapi keliru, dan alasan kekeliruannya adalah bagian paling mendidik dari seluruh episode ini.
Eksploitasi modern bukan soal apa yang bisa dilakukan satu primitif, melainkan apa yang bisa dibujuk untuk diatur di sekitarnya oleh sistem. Teknik Calif adalah heap grooming: membentuk perilaku allocator dari jarak jauh agar objek yang dapat diprediksi dan berguna mendarat tepat di belakang buffer yang meluap. Mereka melakukannya lewat jaringan, dengan memanfaatkan waktu request untuk mengatur kapan alokasi dan pembebasan memori terjadi di target. Penulisannya mungkin bernilai konstan, tapi kalau kamu bisa mengendalikan objek mana yang berada di zona ledakan, kamu mengendalikan apa yang rusak. Dari situ mereka membangun pengungkapan memori bergaya Heartbleed, membocorkan cukup data untuk mengalahkan ASLR, lalu merangkainya menjadi eksekusi kode jarak jauh penuh.

Ada detail yang cukup pragmatis tapi memuaskan, tersembunyi di tulisan mereka tentang cara membuat ini berjalan di internet sungguhan. Heap grooming jarak jauh sensitif terhadap round-trip time dan jitter, sehingga request harus tiba dengan ritme tertentu agar allocator berada dalam kondisi yang diinginkan. Alih-alih merekayasa balik TCP stack, para peneliti menyewa VM di region cloud yang sama dengan target. Mereka menyelesaikan masalah fisika dengan uang. Saya sudah melihat exploit developer kelas atas melakukan versi ini selama bertahun-tahun, dan ini pengingat bahwa batasan penyerang sama ekonominya dengan teknisnya. Penyerang yang punya sumber daya memperlakukan jitter jaringan sebagai pos anggaran.
Perlu dicatat juga: tidak ada exploit universal. Setiap aplikasi, seperti Jira, Jenkins, dan Keycloak, memakai Base64 dengan cara berbeda, mengalokasikan memori secara berbeda, dan menyediakan permukaan grooming yang berbeda. Itu kabar baiknya. Kabar buruknya adalah luasnya titik masuk. Header autentikasi, field unggah file, penanganan sertifikat klien, payload pesan: di mana pun teks Base64 masuk ke JVM, itu potensi pemicu. Seorang kontributor bahkan mendemonstrasikan varian sisi klien: aplikasi Java yang membuka koneksi TLS ke server berbahaya bisa dikompromikan tanpa perlu membuka layanan apa pun. Batch job dan tooling internal-mu juga termasuk dalam cakupan, bukan hanya gateway yang menghadap internet.
Sang Centaur di Ruangan: AI Menemukannya dalam Sejam
Sekarang bagian yang seharusnya mengkalibrasi ulang threat model setiap tim keamanan. Peneliti Quang Luong menemukan kerentanan ini sekitar satu jam, dan punya exploit yang berjalan sekitar dua jam setelahnya. Total biaya token AI: di bawah $200. Caranya adalah mengarahkan AI coding agent ke area HotSpot tempat kompleksitas melintasi batas, yaitu JIT, intrinsic, API yang mudah dijangkau, dan kripto, lalu menyaring kebisingannya. Sebagian besar temuan agent itu adalah sampah yang tak bisa dijangkau. Dia terus memberi prompt, dan setelah dua puluh menit tekun, temuan Base64 pun muncul.
Calif membingkai ini sebagai “hacker centaur”: manusia memberi intuisi tentang tempat sistem kompleks biasanya salah, AI memberi stamina. Menurut saya itu akurat, dan implikasinya berlaku dua arah. Loop yang sama yang menemukan Java4Shell tersedia bagi siapa pun yang punya API key, dan fase pengembangan exploit, yaitu membangun pipeline grooming yang bisa dipakai ulang lalu membiarkan agent menggarap rantai khusus per aplikasi, makin mudah diotomatisasi. Ekonomi mencari bug di C dan assembly yang matang dan luas dipakai baru saja runtuh. Defender sebaiknya berasumsi bahwa selusin bug kelas Java4Shell berikutnya sudah sedang dicari, oleh orang-orang yang tidak pernah mengajukan disclosure. Inilah tekanan di balik perdebatan seperti tenggat disclosure Project Zero yang makin pendek: ketika penemuan jadi murah, jendela patch adalah seluruh permainannya.
Usulan balasan Calif itu provokatif dan saya sebagian besar setuju: gunakan leverage AI yang sama untuk menghapus kode, bukan menambahkannya. Mereka menyebutnya “vibe-uncoding”, yaitu mengaudit codebase untuk mencari fitur mati, dukungan protokol kuno, dan optimisasi yang tidak perlu, lalu membuangnya untuk memperkecil permukaan serangan. Keberatan jujurnya adalah menghapus itu berisiko: fitur yang kelihatannya tidak dipakai bisa punya dependensi tersembunyi, dan penghapusan butuh pengujian yang sering kurang didanai tim. Tapi arahnya benar. Kalau JDK-mu membawa jalur cepat assembly buatan tangan untuk beban kerja yang tidak akan pernah kamu jalankan, postur keamanan optimal adalah tidak mengirimkan jalur itu sama sekali. Kalau tidak bisa, JVM setidaknya memberimu saklar untuk mematikannya. Yang membawa kita ke hal yang benar-benar berhasil.
Yang Benar-Benar Berhasil: Patch, Flag, Proxy
Ini bagian yang diperhatikan tim on-call-mu. Perbaikannya terbagi menjadi tiga tingkat, dan saya berpendapat kamu sebaiknya melakukan setidaknya dua di antaranya hari ini, bukan menunggu jendela perubahan berikutnya.
- Patch ke build OpenJDK yang sudah diperbaiki. Perbaikan upstream (commit JDK 5177a70) mengoreksi perhitungan mask. Ini satu-satunya perbaikan yang lengkap. Versi terdampak dimulai dari 17.0.6 di jalur 17 dan berlanjut sampai rilis terkini di 21 dan setelahnya. Periksa daftar fixed-in untuk jalur spesifikmu dan anggap setiap JVM HotSpot (OpenJDK, Oracle JDK, GraalVM) masuk cakupan sampai terbukti sebaliknya.
- Nonaktifkan intrinsic sebagai kontrol sementara. Jalankan JVM dengan
-XX:-UseBASE64Intrinsicsuntuk mematikan Base64 yang dipercepat perangkat keras sepenuhnya. Biaya performanya kecil kecuali kamu men-decode gigabyte Base64, dan hampir tidak ada yang melakukannya. Alternatifnya,-XX:UseAVX=2menonaktifkan AVX-512 di x86-64, tapi jangan pasang flag itu di ARM karena JVM akan menolak untuk berjalan. Ini filosofi yang sama dengan playbook CVE PHP: ketika komponen yang rentan adalah jalur cepat yang sempit dan bisa diganti, mematikan jalur cepat lebih baik daripada menunggu. - Gunakan proxy-mu untuk memutus waktu eksploitasi. Bagian keterbatasan dari tulisan Calif sendiri mencatat bahwa profil grooming jarak jauh saat ini bergantung pada body request parsial yang sampai ke aplikasi dengan timing yang presisi. Reverse proxy yang membuffer seluruh body request, yang dilakukan nginx secara default, menghancurkan timing itu. Ini jelas bukan perbaikan, tapi secara berarti memperlambat jalur serangan paling praktis selagi kamu melakukan patch.
Deteksi juga layak disinggung. Semgrep merilis skrip gratis yang memeriksa kombinasi kondisi yang membuat host bisa dieksploitasi: VM berkeluarga HotSpot, hardware x86-64 dengan dukungan instruksi yang relevan, dan versi yang masuk rentang terdampak. Jalankan itu di seluruh armada sebelum kamu menganggap dirimu rentan. Container berbasis ARM dan sisa-sisa OpenJ9 aman, dan mengetahui itu dengan cepat bisa menyelamatkan satu akhir pekan. Saat memindai, ingat bahwa jalur versi itu penting: perbaikannya masuk di rilis patch tertentu per jalur, jadi “kami pakai 21” bukan jawaban.

Pelajaran yang Lebih Besar: Optimisasi Adalah Liabilitas yang Tidak Pernah Kamu Audit
Lepas dari respons insiden, Java4Shell meninggalkan residu yang tidak nyaman. Bug ini tidak berada di sudut fitur yang samar. Ia ada di Base64, mungkin operasi paling membosankan, paling ada di mana-mana, dan paling “pasti sudah aman sekarang” dalam komputasi. Kerentanan itu ada justru karena seseorang membuat hal yang membosankan itu jadi cepat, memakai instruksi vektor terbaru, dalam assembly, dengan kasus tepi penanganan ekor yang lolos dari code review. Setiap runtime yang matang penuh dengan hal seperti ini. Dan semuanya kini sedang diburu oleh agent tak kenal lelah yang biayanya lebih murah dari makan malam yang enak.
Semua orang bertanya apa yang bisa dibangun AI. Pertanyaan keamanan yang lebih baik mungkin adalah apa yang bisa dibantu AI untuk kita hapus.
Pendapat saya: industri akan segera belajar perbedaan antara kode yang diaudit dan kode yang dianggap aman, dan biaya belajarnya akan mahal. Library standar, intrinsic VM, codec kompresi, decoder gambar: lapisan fondasi yang tak pernah kita pertanyakan justru tempat perhatian manusia paling langka dan tempat perburuan berbantuan AI membayar bounty tertinggi. Model centaur bukan hanya menemukan bug lebih cepat; ia menemukan bug di tempat-tempat yang dilewati peneliti manusia karena nilai harapan mengaudit kode yang “sudah beres” terasa terlalu rendah.
Jadi, patch JVM-mu, nyalakan flag intrinsic di tempat yang tidak bisa kamu patch, dan biarkan nginx membelikanmu waktu. Tapi juga periksa dependency tree-mu sendiri dan tanyakan pertanyaan uncoding: fitur mana dari ini yang kita warisi, bukan kita pilih? String 65 karakter yang akan membakar akhir pekanmu kemungkinan sudah ditulis. Pertanyaannya hanya apakah orang yang memegangnya mengajukan disclosure atau tidak.


