OpenSSL EVP_EncodeBlock Overflow: 5 Mitos yang Kami Uji
Buffer overflow EVP_EncodeBlock di OpenSSL (CVSS 9.8) menunjukkan API encoder base64 sering luput dari pengawasan. Lima mitos keamanan encoder, kami uji.

Fungsi yang cuma mengubah byte menjadi teks base64 baru saja mendapat skor CVSS 9.8. Buffer overflow pada EVP_EncodeBlock di OpenSSL — dilacak sebagai CVE-2026-121481 — memang kedengarannya membosankan, sampai kamu sadar bahwa encoding base64 ada di bawah penanganan sertifikat, klien HTTP, autentikasi proxy, dan separuh kode perekat di infrastruktur kamu. Perbaikannya sendiri butuh empat commit dan perdebatan panas di antara maintainer soal seperti apa seharusnya nilai return error itu.
Diskusi seputar CVE ini adalah hadiah bagi siapa pun yang peduli pada desain API, karena memperlihatkan tumpukan asumsi yang dibuat engineer tentang fungsi encoding — asumsi yang terus memunculkan kelas bug yang sama selama puluhan tahun dan lintas library. Mari ambil lima keyakinan paling umum dan uji dengan apa yang benar-benar terjadi.
Cara Kerja Buffer Overflow EVP_EncodeBlock yang Sebenarnya
Encoding base64 membengkakkan data: setiap tiga byte input menjadi empat karakter output. Jadi ukuran output adalah 4 * ((n + 2) / 3), ditambah satu untuk terminator NUL jika kamu ingin string C. EVP_EncodeBlock() dari OpenSSL membuat pemanggil yang menghitung ukuran itu dan mengalokasikan buffer tujuan. Fungsinya sendiri menerima pointer input, pointer output, dan panjang input — sebagai int. Ia tidak pernah tahu seberapa besar buffer output, jadi ia tidak bisa memvalidasi apa pun. Ia hanya menulis.
Sekarang hitung-hitungannya. int terbesar adalah 2.147.483.647. Ketika panjang input melebihi (INT_MAX / 4) * 3 — yaitu 1.610.612.733 byte, sekitar 1,6 GB — perhitungan ukuran internal meluap dari integer 32-bit bertanda. Matematika panjang itu berputar, perkiraan fungsi tentang di mana output berakhir tidak lagi sesuai kenyataan, dan kamu mendapat penulisan melewati ujung buffer apa pun yang dialokasikan pemanggil. Pemanggil, yang mengikuti rumus dokumentasi, juga melakukan perhitungan yang meluap itu, sehingga kedua sisi bisa sangat tidak sepakat tentang berapa banyak ruang yang ada.
Perbaikan di hulu menambahkan penjaga: tolak input saat dlen > (INT_MAX / 4) * 3, bersama buffer NULL dan panjang negatif. Jika kamu membungkus API ini — dan kamu memang sebaiknya membungkusnya — pemeriksaan itu juga harus ada di batas aplikasimu:
#include <limits.h>
#include <stddef.h>
#include <openssl/evp.h>
/*
* Mirrors the upstream guard: refuse inputs whose encoded size
* cannot be represented in an int, and verify the destination
* capacity ourselves since the API never sees it.
*/
int b64_encode_checked(const unsigned char *in, size_t n,
unsigned char *out, size_t out_cap)
{
size_t need;
if (in == NULL || n > ((size_t)INT_MAX / 4) * 3)
return -1;
need = ((n + 2) / 3) * 4 + 1; /* +1 for the NUL terminator */
if (out == NULL || out_cap < need)
return -1;
if (EVP_EncodeBlock(out, in, (int)n) < 0)
return -1;
return 0;
}
Perhatikan apa yang dipaksakan API ini: menulis ulang rumus ukuran internal library di sisi pemanggil, dengan benar, selamanya. Kontrak itu sendiri adalah kerentanan sebenarnya. Overflow hanyalah tempat di mana kontrak itu akhirnya patah.
Mitos 1: "Decoder Adalah Permukaan Serangan, Encoder Membosankan"
Budaya review keamanan punya bias kuat: parsing itu berbahaya, serialisasi cuma pembukuan. Decoder mengonsumsi byte berbahaya, jadi mereka di-fuzz, diaudit, dan ditulis ulang dalam bahasa yang aman dari memori. Encoder menghasilkan output, dan output terasa aman. Keyakinan ini keliru dengan cara yang spesifik dan berulang: bug encoder hidup di perhitungan ukuran output, dan matematika itu dipercaya oleh kedua sisi pemanggilan.
Polanya terus berulang. Thread PR sendiri mencatat bahwa CVE-2026-121481 mirip dengan CVE-2021-23840, overflow OpenSSL sebelumnya di fungsi update EVP di mana perhitungan panjang meluap pada input besar. Dan base64 secara khusus punya sejarah di sini — ketika decoder Base64 OpenJDK mengubah 65 byte menjadi remote code execution, kami sudah membahas bagaimana codec yang "sepele" menjadi primitif RCE. Decoder mendapat CVE karena menerima input buruk; encoder mendapat CVE karena salah menghitung input yang baik. Keduanya satu spesies: aritmetika pada panjang yang dipengaruhi penyerang.
Vonis: terbantahkan. Kalau threat model kamu berhenti di parser, kamu sudah membiarkan pintu belakang terbuka sambil menjaga pintu depan.
Mitos 2: "CVSS 9.8 Berarti Tinggalkan Semua Kerjaan Malam Ini"
Di sini saya akan sedikit membela para skeptis. Skor 9.8 untuk encoder yang butuh input 1,6 GB bukanlah Heartbleed. Tidak ada encoding base64 untuk data besar di mana pun dalam handshake TLS — sertifikat dikirim sebagai DER di dalam TLS, bukan PEM. Agar ini menyakitimu, data tidak tepercaya harus sampai ke EVP_EncodeBlock() (atau pemanggil internal seperti base64encode() di klien HTTP OpenSSL) dengan skala di atas 1,6 GB. Field protokol dengan prefix panjang 16-bit tidak akan pernah sampai ke sana.
Tapi menyebutnya "sintetis" juga meremehkan. Pelapor mendemonstrasikan jalur command-line yang nyata: memberikan nilai -proxy_pass yang sangat besar ke openssl s_client, dikirim lewat environment variable untuk menghindari batas argumen shell, dan konfigurasi tertentu — engine GOST menerima password berukuran besar secara default — dengan senang hati akan meng-encode-nya base64 untuk request CONNECT proxy. Itu bukan kuriositas laboratorium; itu tool standar yang melakukan autentikasi proxy standar dengan environment variable standar.
Posisi saya: anggap CVSS sebagai ukuran fungsinya, dan call graph kamu sebagai ukuran eksposurmu. Sebelum menjadwalkan jendela patch darurat, grep codebase dan dependensi kamu untuk melihat siapa yang sebenarnya meng-encode apa, dan seberapa besar input bisa menjadi. Lalu tetap patch — hanya saja dengan urutan yang tepat. Vonis: setengah benar. Skornya memang nyata, tetapi kepanikan harus proporsional dengan keterjangkauan, dan keterjangkauan adalah pertanyaan yang hanya bisa dijawab oleh kodemu.
Mitos 3: "Perbaikannya Mudah — Tinggal Kembalikan Kode Error"
Ini bagian favorit saya dari keseluruhan cerita, karena overflow-nya adalah bagian yang sederhana. Bagian sulitnya adalah memutuskan apa yang harus dilakukan EVP_EncodeBlock() soal itu — dan para maintainer tidak bisa sepakat.
Patch awal mengembalikan -1 untuk input tidak valid, sesuai dengan lapisan kompatibilitas wolfSSL dan jalur kegagalan yang sudah ada di EVP_DecodeBlock(). Penolakan datang segera. Seorang maintainer khawatir pemanggil pihak ketiga melakukan cast nilai return ke size_t tanpa memeriksa — dan -1 menjadi SIZE_MAX dengan cast itu, yang bisa dibilang lebih buruk dari overflow yang dicegahnya. Jadi kembalikan 0 saja? Masalahnya 0 sudah menjadi hasil sukses yang sah: meng-encode nol byte mengembalikan nol. Seperti kata seorang maintainer, dia pernah kena getahnya karena memunculkan error pada kasus sukses. Pakai OPENSSL_assert() saja, kata yang lain — crash saat kontrak dilanggar dan dokumentasikan prasyaratnya. Lalu seorang maintainer senior menjawab dengan datar: assert di dalam library adalah "DoS yang menunggu terjadi."
Setiap opsi buruk, dan masing-masing buruk karena alasan berbeda: -1 merusak cast unsigned, 0 bertabrakan dengan sukses, assert mengubah kesalahan logika menjadi crash yang bisa dipicu penyerang. Begini jadinya kalau semantik error sebuah API tidak pernah dirancang, hanya diwarisi. Ini adalah kesenjangan spesifikasi-implementasi dalam bentuk paling murninya — dokumentasinya menulis "mengembalikan jumlah byte yang di-encode", dan tidak ada yang pernah menuliskan apa yang terjadi saat encoding tidak mungkin dilakukan.
Ada dua detail lagi dari thread yang layak diperhatikan. Pertama, seorang reviewer menemukan bahwa patch awal menolak f == NULL tanpa syarat — padahal meng-encode buffer kosong dengan pointer input NULL dan dlen == 0 selalu berhasil, dan aplikasi nyata bergantung padanya. Bahkan validasi yang "jelas benar" pun merusak kasus tepi yang sah. Kedua, seorang reviewer men-grep pemanggil yang tidak memeriksa nilai return dan menemukannya di dalam OpenSSL sendiri: PEM_SignFinal() dan NETSCAPE_SPKI_b64_encode(). Membuat sebuah fungsi tiba-tiba bisa gagal tidak berguna jika pemanggilnya ditulis saat fungsi itu tidak mungkin gagal. Vonis: terbantahkan, sepenuhnya. Semantik error adalah bagian dari desain API, dan memperbaikinya belakangan itu operasi bedah, bukan patch.

Mitos 4: "Tidak Ada yang Memasukkan Satu Gigabyte ke Encoder Base64"
Intuisinya adalah base64 untuk hal kecil: sertifikat, kunci, token pendek. Dan sebagian besar memang benar. Tapi sistem modern diam-diam makin sering meng-encode blob raksasa — dokumen attestation, respons SAML, manifest container image, kredensial proxy, payload webhook yang di-encode ulang oleh middlebox tertentu. Reproducer CVE ini tidak eksotis: itu sebuah password, dikirim lewat environment variable, pada jalur kode yang meng-encode kredensial untuk proxy HTTP. Tidak ada yang dalam pipeline itu dirancang dengan batas 1,6 GB dalam pikiran, karena tidak ada yang menuliskan batas itu di mana pun.
Ada juga kebiasaan arsitektur yang memperburuk ini: API encoding sekali-jalan mendorong pembacaan seluruh payload ke memori sebelum diubah. OpenSSL punya alternatif streaming — EVP_EncodeInit(), EVP_EncodeUpdate(), EVP_EncodeFinal() — yang memproses data per potongan dan menghindari masalah "hitung total ukuran output di awal". Streaming memang memakan objek konteks dan sebuah loop. Yang didapat: tidak ada satu panjang pun yang harus sekaligus dipengaruhi penyerang dan dipercaya. Vonis: terbantahkan. Input terus bertambah sampai menyentuh batas, dan jika batasnya adalah overflow integer bertanda, batas itu yang akan menemukanmu.
Mitos 5: "Fuzzer Kami Pasti Sudah Menangkap Ini"
Tidak akan, dan ada gunanya memahami alasannya. Fuzzer berbasis coverage seperti libFuzzer secara default membatasi panjang input maksimum dalam kilobyte — 4096 byte bawaan. Bug yang butuh 1,6 miliar byte input bukan sekadar tidak mungkin ditemukan; ia berada di luar ruang pencarian sepenuhnya. Kamu bisa men-fuzz EVP_EncodeBlock() selama seabad dan tidak pernah menyentuh overflow itu, karena perilaku menariknya hanya ada pada skala yang tidak akan pernah dikunjungi fuzzer.
Solusinya bukan memperbesar input fuzz — tidak ada yang mau mengalokasikan 1,6 GB per iterasi fuzz. Solusinya adalah menguji aritmetika secara terpisah dari encoding. Ekstrak perhitungan ukuran dan hantam batasnya dengan unit test biasa:
#include <assert.h>
#include <limits.h>
/* Mirrors the upstream guard, computed in a wide type. */
static int encoded_len_fits_int(long long dlen)
{
return dlen >= 0 && dlen <= ((long long)INT_MAX / 4) * 3;
}
int main(void)
{
long long limit = ((long long)INT_MAX / 4) * 3; /* 1,610,612,733 */
assert(encoded_len_fits_int(0));
assert(encoded_len_fits_int(limit));
assert(!encoded_len_fits_int(limit + 1));
assert(!encoded_len_fits_int(-1));
/* The encoded size at the limit must itself fit in an int. */
assert(4 * ((limit + 2) / 3) <= INT_MAX);
return 0;
}
Lalu tambahkan pengecekan diferensial pada ukuran menengah: hitung panjang output yang diharapkan dengan rumus di sisi pemanggil, encode, dan pastikan fungsi menulis tepat sejumlah byte itu dan tidak lebih. Jalankan semuanya di bawah AddressSanitizer dengan beberapa input ratusan megabyte di CI — cukup besar untuk mengeksekusi loop lebar, cukup kecil untuk selesai sebelum makan siang. Fuzzing tetap alat yang tepat untuk logika byte-level codec; hanya saja ia tidak pernah tepat untuk overflow integer pada skala besar, dan mencampuradukkan kedua pekerjaan ini adalah cara bug seperti ini bertahan selama satu dekade fuzzing berkelanjutan. Vonis: terbantahkan.
Cara Mengaudit API Encoder Sebelum Ia Mengaudit Kamu
Baik kamu sedang meninjau penggunaan OpenSSL di kodemu sendiri atau mengevaluasi jalur encode library mana pun, beberapa pertanyaan berikut sudah cukup untuk menangkap seluruh kelas bug ini:
- Siapa yang menghitung ukuran output? Jika pemanggil melakukannya dengan rumus yang tidak sepele, kedua sisi bisa menyimpang. Utamakan API yang menerima kapasitas output sebagai parameter dan gagal dengan bersih saat kapasitasnya tidak cukup.
- Tipe integer apa yang membawa panjang? Parameter panjang
intadalah batas 2 GB dengan bit tanda terpasang.size_ttidak membuat overflow mustahil, tetapi ia memindahkan batas melewati tepi buffer mana pun yang benar-benar bisa kamu alokasikan di mesin 64-bit. - Apa yang terjadi di nol, di batas, dan satu melewatinya? Input kosong, tepat
(INT_MAX/4)*3, dan nilai itu ditambah satu adalah tiga kasus uji yang penting. - Apakah fungsi itu baru-baru ini menjadi bisa gagal? Jika patch menambahkan return error pada sesuatu yang sebelumnya tidak mungkin gagal, grep setiap call site. Return yang tidak diperiksa mengubah bug yang sudah diperbaiki menjadi bug diam-diam.
- Apakah ada varian streaming? API chunked encode/update/final menghilangkan kebutuhan akan satu panjang total yang dipercaya.
Saya akan lebih jauh soal poin pertama: API apa pun yang memaksa pemanggil mereplikasi rumus ukuran internal library adalah pabrik bug, dan industri harus berhenti membuatnya. Callee tahu faktor ekspansi, aturan padding, dan konvensi terminator. Memaksa setiap pemanggil menurunkan ulang 4 * ((n + 2) / 3) + 1 menjamin ada yang salah menghitungnya — atau benar tetapi di tipe yang terlalu kecil.

Kesimpulan untuk Base64 dan Seterusnya
CVE-2026-121481 akan memudar dari feed dalam seminggu, tetapi kelas bugnya tidak. Fungsi encoding berada di titik buta review keamanan: dipercaya dengan panjang, dibebaskan dari fuzzing skala besar, dan dibungkus dalam API yang perilaku errornya tidak pernah ditentukan. Maintainer OpenSSL menghabiskan lebih banyak kata untuk memperdebatkan apakah harus mengembalikan -1, 0, atau crash daripada untuk overflow itu sendiri — dan mereka benar melakukannya, karena itulah bagian yang akan dijalani setiap pemanggil hilir selama bertahun-tahun.
Jadi: patch, ya, tetapi juga grep. Temukan call site encode kamu, periksa siapa yang menghitung ukuran buffer, pastikan return-nya benar-benar diperiksa, dan pindahkan apa pun yang menangani data besar tidak tepercaya ke API streaming. 9.8 berikutnya di encoder sudah duduk di rumus ukuran seseorang, menunggu input cukup besar untuk menemukannya.


