Celah Regex Ruby dan Jebakan Unicode Case Folding
Tujuh celah regex dan konversi huruf di Ruby membuktikan Unicode case folding itu ranjau keamanan memori. Begini cara mengaudit kode Anda.

Sebuah aplikasi Rails menormalisasi alamat email dengan memanggil upcase sebelum disimpan, seperti yang direkomendasikan ribuan tutorial. Seorang pengguna mendaftar dengan mueller@straße.example lewat form yang, entah di mana dalam pipeline-nya, memutuskan bahwa Windows-1252 adalah encoding yang oke. Pemanggilan upcase mengubah ß di akhir menjadi SS — dua byte di tempat yang tadinya cuma satu — dan menulis salah satu byte itu melewati ujung heap buffer. Ini bukan hipotesis. Ini rekonstruksi yang masuk akal dari salah satu dari tujuh celah konversi regex dan string case di Ruby yang baru ditambal tim inti, dan beberapa di antaranya sudah punya bukti konsep RCE yang berjalan.
Advisory ini dirilis bersamaan dengan tiga rilis darurat — Ruby 4.0.10, 3.4.13, dan 3.3.14 — dan ini studi kasus yang bagus untuk satu kebenaran yang lebih dalam: konversi case kelihatannya operasi paling sederhana di library string, padahal termasuk yang paling berbahaya. Di sinilah spesifikasi Unicode yang luas bertemu dengan kode C yang sudah berpuluh tahun, dan di sambungan inilah heap overflow tumbuh subur.
Tujuh Bug, Dua Subsistem, Satu Akar Masalah
Ketujuh advisory (dilacak lewat identifier GHSA sementara nomor CVE masih antre di proses penugasan yang menumpuk) terbagi dua keluarga. Dua ada di konversi case String: heap buffer overflow satu byte dan integer overflow yang berujung ke heap overflow. Lima ada di mesin regular expression Ruby — double free saat kompilasi pattern, integer overflow saat kompilasi, out-of-bounds read pada pencocokan case-insensitive, out-of-bounds read pada pencocokan backreference case-insensitive, dan heap buffer overflow di Regexp#to_s.
Perhatikan apa yang menyatukan semuanya. Ini bukan kecerobohan coding dalam arti biasa — core C Ruby sudah tua, teruji, dan sangat sering di-fuzz. Yang menyatukan adalah kedua subsistem menerapkan semantik case Unicode, dan semantik case Unicode itu jebakan. Pencocokan regex case-insensitive mengharuskan folding pada pattern maupun input, artinya mesin ini menjalankan tabel pemetaan yang sama berbahayanya dengan String#upcase, hanya di jalur yang lebih panas dan dengan pengaruh lebih besar dari penyerang atas input. Backreference dalam mode case-insensitive harus membandingkan substring yang sudah di-fold. Regexp#to_s harus mengeluarkan ulang teks sumber pattern beserta opsinya, dan menentukan ukuran buffer untuk rekonstruksi yang juga melibatkan logika yang sadar case. Setiap jalur kode ini harus menjawab pertanyaan yang kelihatannya sederhana tapi sulit: seberapa besar string ini setelah saya ubah case-nya?
Ruby 3.3 kebagian tambalan karena masih dalam fase security maintenance. Ruby 3.2 ke bawah sudah end of life dan tidak dapat apa-apa — kalau Anda masih di salah satu versi itu, advisory ini adalah tenggat migrasi Anda, bukan sekadar peringatan.
Sejarah Singkat Konversi Case yang Salah Kaprah
Di ASCII, mengubah case itu cuma membalik satu bit. Dua puluh enam pasang huruf, satu-ke-satu, panjang tidak berubah, tidak bergantung locale. toupper() dari C era K&R merangkum seluruh ide ini dalam satu tabel lookup. Ini model mental yang kebanyakan dari kita bawa sampai dewasa, dan model ini juga tertanam di logika penentuan ukuran buffer di kode C di seluruh dunia. Padahal model ini keliru untuk hampir semua sistem penulisan di luar Latin dasar.
Unicode mendefinisikan ribuan pemetaan case, dan sebagian besarnya tidak satu-ke-satu. Huruf s tajam Jerman (ß) di-uppercase menjadi SS. Ligatur ff menjadi FF. Ligatur Armenia juga memanjang. Yunani punya sigma yang sensitif konteks — σ versus ς di akhir kata — jadi folding yang benar bergantung pada karakter di sekitarnya. Turki dan Azerbaijan punya masalah I bertitik/tak bertitik, di mana i menjadi İ dan ı menjadi I, yang terkenal merusak segala sesuatu mulai dari aplikasi Java sampai strtoupper di PHP dengan locale Turki. Dan huruf kecil Cherokee baru ditambahkan belakangan di Unicode 8.0 tahun 2015, mengubah aksara yang tadinya tanpa case menjadi beraksara case, dan membatalkan asumsi di perangkat lunak di mana-mana.
Encoding lama memperburuk keadaan. Windows-1252 punya byte untuk ß huruf kecil (0xDF) tapi tidak punya byte untuk versi kapitalnya — karena secara historis bahasa Jerman memang tidak pernah memakainya dalam teks biasa; Anda menulis SS. Jadi ketika rutin konversi case pada string Windows-1252 menemukan ß dan dengan benar menggantinya dengan SS, string itu bertambah satu byte. Analisis tajam yang beredar setelah advisory menyarankan inilah overflow satu byte-nya: loop konversi tampaknya mengecek sisa buffer satu karakter demi satu karakter, sehingga ß yang berada di karakter terakhir dari string berukuran pas menghasilkan satu S nyasar yang ditulis melewati alokasi. Overflow heap satu byte dengan S yang dikendalikan penyerang memang primitif eksploitasi yang merepotkan dan rumit — tapi advisory memastikan PoC yang mencapai RCE memang ada, jadi seseorang sudah melakukan heap grooming.
Konversi case bukan bijeksi, tidak mempertahankan panjang, tidak independen dari locale, dan tidak selalu bisa direpresentasikan di setiap encoding. Kode yang berasumsi sebaliknya adalah celah yang menunggu fuzzer.
Mengapa Mesin Regex Justru Lebih Mengkhawatirkan
Mesin regex Ruby adalah Onigmo, fork dari Oniguruma, dan ini perangkat lunak yang benar-benar mengesankan — mendukung puluhan encoding, full Unicode case folding, lookbehind, named group, dan backreference, semuanya dalam C, dengan lapisan yang berakar sejak akhir 1990-an. Lapisan itulah masalahnya. Pencocokan case-insensitive di Onigmo berarti setiap titik perbandingan berpotensi menjalankan logika folding, dan folding mengubah panjang, jadi pembukuan antara offset pattern, offset string, dan batas match itu sangat rumit. Dua bug yang sudah ditambal adalah out-of-bounds read di mesin inilah — satu di pencocokan case-insensitive secara umum, satu secara khusus di pencocokan backreference case-insensitive, di mana mesin membandingkan substring yang sebelumnya ditangkap (dan sudah di-fold) dengan posisi saat ini.
Namun model eksploitasinya lebih penting daripada detail internalnya. Tiga dari lima bug regex terpicu saat kompilasi pattern, dan advisory-nya terus terang soal siapa yang terpapar: aplikasi yang mengompilasi pattern yang dikendalikan penyerang. Anda mungkin mengira itu jarang. Ternyata tidak. Setiap kotak pencarian yang dibungkus Regexp.new(query), setiap aturan validasi yang bisa dikonfigurasi dan dimuat dari database, setiap layer log-parsing atau routing yang membangun pattern dari file konfigurasi yang dikontrol operator (atau tenant yang sudah disusupi) — itu semua adalah jalur kompilasi yang bisa dijangkau input jahat. Sebelum advisory ini, skenario terburuk saat mengompilasi pattern jahat adalah ReDoS: pattern dengan catastrophic backtracking yang mengunci CPU. Menyebalkan, tapi masih bisa dipulihkan. Sekarang skenario terburuknya adalah korupsi memori dengan PoC RCE. Ini risiko yang kualitasnya berbeda untuk baris kode yang sama yang sudah Anda jalankan di produksi selama bertahun-tahun.
Ada pola yang layak diberi nama di sini: spesifikasi bilang satu hal, C-nya bilang hal lain, dan celah di antaranya bisa dieksploitasi. Kita sudah pernah membahas dinamika ini — celah antara spesifikasi dan implementasi itu tempat bug bersarang — dan tabel case folding Unicode adalah salah satu spesifikasi paling kaya yang bisa diminta untuk diimplementasikan oleh programmer C. Tabel-tabelnya berubah antar versi Unicode, aturan special-casing punya sub-klausul, dan orang yang menulis kode penentuan ukuran buffer di tahun 2003 bekerja dengan Unicode yang lebih kecil dan lebih sederhana dibanding Unicode tempat string Anda datang hari ini.
Integer Overflow: Empat Gigabyte Jadi Enam Byte
Bug string kedua adalah ilustrasi indah untuk mode kegagalan yang berbeda: aritmetika panjang 32-bit di dunia 64-bit. Proof of concept ini, yang beredar setelah advisory, memakai Shift_JIS dan string berukuran lebih dari empat gigabyte:
str = ("\x82\xA0" + ("A" * (2**32 + 4))).force_encoding(Encoding::Shift_JIS)
puts "str.bytesize: #{str.bytesize}" # 4294967302
new_str = str.downcase
puts new_str.bytesize # 6 on unpatched builds (!)
puts new_str.bytes # [130, 160, 97, 97, 97, 97]
String 4.294.967.302 byte masuk, dan hasil downcase-nya melaporkan ukuran 6. Di suatu tempat di jalur konversi, sebuah panjang dihitung atau dipotong lewat tipe 32-bit, 2³² + 6 terbungkus jadi 6, dan alokasi atau penyalinan berikutnya ukurannya mengikuti angka itu — pipeline klasik dari integer overflow menjadi heap overflow. Empat gigabyte kedengarannya seperti input yang absurd, tapi ingat bahwa string dalam proses yang berjalan tidak harus datang lewat jaringan sekaligus: string dibangun dari potongan-potongan, dari dekompresi, dari penggabungan dalam job impor dan parser file. Penyerang yang bisa memengaruhi seberapa banyak data menumpuk dalam sebuah string, lalu membuat downcase dipanggil padanya, menguasai kedua sisi bug ini.
Kedua bug string berbagi pelajaran arsitektur dengan bug tanda bintang di Alpine yang sudah berumur satu dekade: kode berbahaya berada di jalur yang tidak pernah dianggap sebagai permukaan serangan. Tidak ada yang melakukan threat modeling untuk upcase. Itulah sebabnya bug seperti ini bertahan bertahun-tahun — bersembunyi di jalur yang tidak diaudit manusia dan yang, sampai baru-baru ini, tidak dijangkau fuzzer dengan kecerdasan yang cukup untuk membangun string multi-byte yang valid.
Mesin yang Menemukan Bug Ini, dan Itu Mengubah Hitungannya
Lihat daftar kreditnya. Empat dari tujuh advisory berterima kasih kepada Stephan Lipp dari Ada Logics — firma di balik banyak pengembangan harness OSS-Fuzz — dan Anthropic. Itu kombinasi pakar infrastruktur fuzzing dengan model AI, dan ini bukan advisory pertama dengan tanda tangan seperti itu dalam beberapa waktu terakhir. Silsilahnya layak dihargai: fuzzing dimulai dari Barton Miller yang memberi input acak ke utilitas Unix pada 1990, menjadi lebih pintar dengan mutasi berpemandu coverage dari AFL di 2013, diindustrialisasi dengan OSS-Fuzz yang terus-menerus menguji proyek open source sejak 2016, dan kini mendapat lapisan yang bisa bernalar tentang kode — membangun string Shift_JIS 4 GiB atau buffer Windows-1252 yang berakhir dengan ß membutuhkan pemahaman tentang validitas encoding dan aritmetika panjang, bukan sekadar memutasi byte.

Implikasi strategisnya dua arah. Pihak bertahan mendapat audit yang terus-menerus dan tak kenal lelah atas basis kode yang tidak mungkin diperiksa tangan oleh tim mana pun. Tapi kemampuan yang sama tersedia bagi siapa saja yang punya model dan komputasi, dan tidak semua orang mengajukan advisory. Era nyaman ketika bug korupsi memori di jalur kode yang obscure bisa berharap hidup tenang bertahun-tahun sedang berakhir; ekonomi untuk menemukannya sudah runtuh. Saya pernah berargumen bahwa pemindai keamanan berbasis AI sedang menagih utang teknis kita, dan ini tanda terimanya: runtime bahasa yang dipakai jutaan orang ternyata bermasalah, ditemukan bukan oleh peneliti yang bosan dengan akhir pekan, melainkan oleh pipeline otomatis yang akan terus berjalan.
Posisi saya: ini memperkuat argumen untuk bahasa yang aman secara memori, tapi bukan dengan cara dangkal yang biasanya dibahas di diskursus. Menulis ulang Onigmo dalam Rust tidak akan memperbaiki logika-nya — case folding yang mengubah panjang string tetap merupakan bahaya di level spesifikasi, dan pertanyaan soal ukuran buffer tetap harus dijawab dengan benar. Yang dihapus oleh keamanan memori adalah gradien konsekuensinya. Bug logika berubah menjadi panic, hasil yang salah, request yang gagal — bukan RCE. Itu bukan hal kecil; itu perbedaan antara insiden dan pemberitahuan gangguan layanan.
Cara Mengaudit Eksposur Anda Sendiri
Mulai dari yang paling jelas lalu perluas. Upgrade ke 4.0.10, 3.4.13, atau 3.3.14 — Onigmo tertanam di build Ruby, jadi tidak ada library terpisah untuk ditambal; runtime itulah patch-nya. Lalu audit kode aplikasi Anda untuk dua bentuk berbahaya: string yang dipengaruhi penyerang yang mengalir ke operasi case, dan pattern yang dipengaruhi penyerang yang mengalir ke Regexp.new atau Regexp.compile.
- Berhenti mengompilasi input pengguna menjadi pattern. Jika pengguna memberikan kata pencarian, escape dengan
Regexp.escape. Jika mereka benar-benar butuh kekuatan regex, pasang allowlist dan timeout ketat di depannya — dan ingat bahwa timeout membantu melawan ReDoS, bukan korupsi memori. - Normalisasi encoding di batas kepercayaan. Dua bug string bergantung pada encoding eksotis (Windows-1252, Shift_JIS). Jika aplikasi Anda hanya bicara UTF-8, nyatakan itu di perbatasan: paksa atau transkode encoding saat masuk, dan tolak input yang tidak bisa dikonversi dengan bersih.
- Utamakan perbandingan case-insensitive daripada konversi case.
a.casecmp?(b)mengajukan pertanyaan;a.upcase == b.upcasemengalokasikan dua string baru dalam encoding apa pun yang diklaim input. API perbandingan punya permukaan semantik yang jauh lebih kecil. - Cari
upcase,downcase,swapcase, dancapitalizepada data yang tidak tepercaya. Setiap pemanggilan adalah tempat asumsi panjang bersarang. Hal yang sama berlaku untuk ekstensi C apa pun yang Anda tulis dan melakukan logika case sendiri — itu tidak mendapat manfaat dari tambalan tim inti. - Fuzz apa yang Anda miliki. Ruby sendiri di-fuzz oleh OSS-Fuzz, tapi ekstensi C Anda tidak. AFL++ atau libFuzzer dengan ASan akan menemukan kelas bug yang sama di kode Anda seperti yang baru ditemukan mesin di Ruby.
- Ketahui status pemeliharaan runtime Anda. Ruby 3.2 sudah end of life dan tidak menerima tambalan ini. 'Masih jalan kok' bukan postur keamanan ketika aliran patch sudah berhenti.
Berikut perbandingan before-and-after untuk pola yang paling umum — menormalisasi username atau email untuk pengecekan keunikan:
# Before: allocates a new string, trusting the input's claimed encoding
def normalize(username)
username.upcase
end
# After: pin the encoding at the boundary, fold for comparison only
def normalize(username)
utf8 = username.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
utf8.downcase(:fold)
end
# And for comparisons, skip allocation entirely:
def same_user?(a, b)
a.encode(Encoding::UTF_8).casecmp?(b.encode(Encoding::UTF_8))
end
Tidak ada satu pun dari ini membuat Anda aman di runtime yang belum ditambal — itulah gunanya upgrade. Tapi kebiasaan ini memperkecil kelas bug yang bisa diwarisi aplikasi Anda dari lapisan di bawahnya, dan membuat kode Anda jujur bahwa teks bukan byte.

Pelajaran yang Lebih Dalam untuk Runtime Bahasa
Ada godaan untuk memasukkan ini ke kategori 'C itu berbahaya, cerita lama', dan balasan dangkal terhadap advisory memang begitu. Tapi saya mau lebih jauh. Ketujuh bug ini sebenarnya bukan soal C — melainkan soal ketidakcocokan antara standar internasionalisasi yang terus berkembang dan asumsi implementasi yang sudah beku. Unicode akan terus menambah aksara dan memperhalus pemetaan. Setiap runtime bahasa di dunia punya kode konversi case yang ditulis berdasarkan versi tabel masa lalu, dengan ukuran yang ditentukan dari pemahaman masa lalu tentang seberapa besar sebuah string bisa tumbuh. Ruby kebetulan kena bulan ini; berikutnya bisa jadi mesin regex, case folder, atau rutin normalisasi milik orang lain.
Pelajaran praktisnya: perlakukan transformasi teks sebagai batas keamanan, bukan sekadar fungsi utilitas. Apa pun yang mengkodekan ulang, mengubah case, menormalisasi, atau melipat (fold) adalah parser, dan parser adalah tempat bug memori bersarang. Pelajaran historisnya — yang menurut saya memuaskan sebagai orang yang gila bahasa — adalah bahwa huruf ß Jerman yang sederhana, huruf yang sudah dipusingkan para pencetak sejak zaman Fraktur, masih bisa menjangkau enam abad sejarah tipografi dan menulis satu byte melewati ujung heap buffer. Bahasa tidak pernah sederhana. Kita saja yang membangun mesin dengan asumsi bahwa ia sederhana.


