Pada 2025, saya menemukan kerentanan di AF_ALG Linux Kernel yang memungkinkan user biasa mendapatkan akses root. Tulisan ini menelusuri kembali bagaimana saya menemukan CVE-2025-39964 dan bagaimana kami mengembangkan exploit-nya, sebelum Copy Fail membuat AF_ALG ramai dibicarakan pada 2026.

AF_ALG merupakan sebuah fitur yang ada di Linux Kernel. Dengan AF_ALG, kernel menyediakan sebuah API untuk melakukan sebuah enkripsi/dekripsi kriptografi. User mode program hanya perlu berinteraksi dengan API dan kernel akan melakukan operasi tersebut.

Terdapat sebuah kerentanan yang cukup fatal di AF_ALG pada saat menangani sebuah masukan yang datang dari user program. Dengan memahami mekanisme tersebut, terdapat kerentanan memory corruption (out-of-bounds access) yang dapat di-eksploitasi sehingga membuat user biasa menjadi root. Bukan cuman itu, kerentanan ini juga dapat digunakan untuk escape dari Docker container, dan langsung menjadi root di host. Kerentanan ini juga ternyata sudah berada di Linux sejak sekitar 2011

Editorial (IDNSEC): CVE-2025-39964 ditemukan oleh Muhammad Alifa Ramdhan saat melakukan riset di STAR Labs. Kredit juga diberikan kepada rekannya, Bing-Jhong Billy Jheng, yang turut membantu menyelesaikan exploit chain. Artikel ini ditulis oleh Ramdhan dan diterbitkan di IDNSEC. Vulnerability ini dilaporkan secara bertanggung jawab kepada maintainer Linux kernel dan digunakan sebagai submission untuk Google kernelCTF, dengan reward $113,337.00 USD.

Linux Kernel Attack Surface

Pembaca mungkin ingat Copy Fail, yang diumumkan pada 2026 dan kemudian, bersama DirtyFrag, meraih Best Privilege Escalation Bug di Pwnie Awards 2026. Copy Fail juga menggunakan AF_ALG, tetapi bug yang saya bahas di sini berbeda. Copy Fail berasal dari logic flaw pada jalur AEAD yang tidak membutuhkan race, sedangkan CVE-2025-39964 muncul ketika dua writer berbagi AF_ALG socket. Saya menemukan race ini saat membaca source code sekitar September 2025, sebelum Copy Fail diumumkan.

Saya merupakan seorang vulnerability research yang memang cukup sering menghabiskan waktu untuk mencari kerentanan di area sistem operasi salah satunya yakni Linux Kernel. Pada saat itu, yang saya targetkan adalah menggunakan temuan saya untuk program KernelCTF. KernelCTF merupakan program dari Google dimana Google akan memberikan hadiah untuk researcher yang bisa mendemonstrasikan exploit LPE pada Linux latest stable.

Untuk membuat LPE exploit di Linux Kernel, researcher harus melakukan security audit pada kode-kode dan subsystem, istilahnya attack surface yang ada di Linux Kernel. Sebagai contoh dari vuln yang cukup terkenal, dirtycow merupakan bug yang ada di subsystem mm, dirtypipe kerentanannya ada di subsystem fs/pipe.

Ketika sedang melihat-lihat attack surface apa yang selanjutnya menarik untuk diaudit, saya menemukan AF_ALG. Ketika membaca dokumentasinya, hal pertama yang menarik perhatian saya adalah AF_ALG dapat diakses secara langsung dari unprivileged userspace melalui socket API. Dari sudut pandang kernel exploitation, karakteristik seperti ini menarik karena tidak membutuhkan privilege atau konfigurasi khusus untuk mencapai kode kernel. Yang membuatnya semakin menarik bagi saya saat itu adalah, sejauh yang saya telusuri, belum pernah ada submission kernelCTF yang menggunakan vulnerability dari AF_ALG sebagai entry point.

Interaksi dengan AF_ALG

Untuk bisa berinteraksi dengan AF_ALG, user program harus memanggil `socket(2)` untuk mendapatkan socket file descriptor AF_ALG, dan bind(2) untuk memilih algoritma apa yang ingin digunakan. Contoh seperti ini ketika mau menggunakan AES-CBC dari AF_ALG API:

int tfmfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
struct sockaddr_alg sa = {
      .salg_family = AF_ALG,
      .salg_type = "skcipher", /* symmetric key cipher */
      .salg_name = "cbc(aes)", /* AES in CBC mode */
};
bind(tfmfd, (struct sockaddr *)&sa, sizeof(sa));

Untuk AES-CBC, kernel memerlukan parameter tambahan, yakni adalah kunci AES. Kunci ini bisa di-set dengan setsockopt.

unsigned char key[32] = {0}; /* 256 bit key */
setsockopt(tfmfd, SOL_ALG, ALG_SET_KEY, key, sizeof(key));

Setelah key di-set, user program harus memanggil accept yang akan memberikan file descriptor lain yang siap digunakan untuk operasi encrypt/decrypt.

int opfd = accept(tfmfd, NULL, 0);

Untuk melakukan operasi encrypt/decrypt, program dapat memanggil sendmsg dengan file descriptor opfd. Ketika sendmsg dipanggil, program bisa menginisiasi IV, dan operasi yang ingin dilakukan (encrypt atau decrypt) pada control field di message header, sekalian dengan data bytes yang ingin diproses.

char cbuf[CMSG_SPACE(sizeof(__u32)) +
          CMSG_SPACE(sizeof(struct af_alg_iv) + 16)] = {0};

struct iovec iov = {
    .iov_base = buf,
    .iov_len = 0x1000,
};

struct msghdr msgh = {
    .msg_iov = &iov,
    .msg_iovlen = 1,
    .msg_control = cbuf,
    .msg_controllen = sizeof(cbuf),
};

struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msgh);
cmsg->cmsg_level = SOL_ALG;
cmsg->cmsg_type = ALG_SET_OP;
cmsg->cmsg_len = CMSG_LEN(sizeof(__u32));
*(__u32 *)CMSG_DATA(cmsg) = ALG_OP_ENCRYPT;

cmsg = CMSG_NXTHDR(&msgh, cmsg);
cmsg->cmsg_level = SOL_ALG;
cmsg->cmsg_type = ALG_SET_IV;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct af_alg_iv) + 16);

struct af_alg_iv *alg_iv = (void *)CMSG_DATA(cmsg);
alg_iv->ivlen = 16;
memset(alg_iv->iv, 0x01, 16);

ssize_t n = sendmsg(opfd, &msgh, MSG_MORE);

Contoh diatas merupakan pemanggilan sendmsg pertama kali, dengan menginisiasi IV dan setting operasi encrypt (dengan ALG_OP_ENCRYPT), dengan menyertakan data dengan panjang 0x1000 yang akan diproses oleh kernel. Di contoh ini, pemanggilan sendmsg dilakukan dengan mengikutsertakan flag MSG_MORE, flag ini memerintahkan kernel bahwa data yang dikirim belum sepenuhnya lengkap, dengan kata lain program bisa memanggil sendmsg lagi dengan data tambahan yang akan digabungkan dengan data yang dikirim sebelumnya. Ketika sendmsg() selanjutnya dipanggil tanpa MSG_MORE, kernel tidak lagi menunggu input tambahan. Lalu, untuk meminta kernel melakukan proses enkripsi dan mendapatkan hasilnya, program dapat memanggil read(), recv(), atau recvmsg() pada opfd.

Internal AF_ALG

Di sini saya akan menggunakan Linux Kernel v6.12.44 sebagai acuan analisis, karena pada versi inilah saya melakukan bug hunting dan mengembangkan exploit pada saat itu. Source code yang dibahas pada bagian ini dapat dilihat pada `crypto/af_alg.c`, `crypto/algif_skcipher.c`, dan `include/crypto/if_alg.h`.

Sebelum masuk lebih jauh ke source code, terdapat satu hal penting yang perlu dipahami. Pemanggilan sendmsg() pada AF_ALG tidak langsung melakukan proses enkripsi. Data yang dikirim user terlebih dahulu dikumpulkan oleh kernel di dalam sebuah TX scatter-gather list. Kemudian, ketika user memanggil recvmsg(), barulah kernel membuat crypto request dan menggunakan data yang sebelumnya dikumpulkan tersebut sebagai input.

Secara sederhana, alurnya seperti berikut:

Alur data AF_ALG dari sendmsg hingga ciphertext dikembalikan ke userspace
Alur data AF_ALG

Untuk tipe algoritma skcipher, handler awal dari sendmsg() adalah skcipher_sendmsg(). Fungsi ini mengambil ukuran IV dari cipher yang sebelumnya dipilih, lalu meneruskan semua proses penerimaan datanya ke af_alg_sendmsg().

unsigned int ivsize = crypto_skcipher_ivsize(tfm);
return af_alg_sendmsg(sock, msg, size, ivsize);

Artinya, sebagian besar mekanisme yang menerima data dari user, mengalokasikan buffer, dan menyimpan state antar-pemanggilan sendmsg() berada di fungsi ini:

int af_alg_sendmsg(struct socket *sock, struct msghdr *msg,
                   size_t size, unsigned int ivsize)

Parameter msg berisi data beserta control message yang dikirim user, size berisi panjang data yang ingin dikirim, sedangkan ivsize berisi ukuran IV yang diwajibkan oleh cipher yang sedang digunakan. Untuk AES-CBC ukuran IV-nya adalah 16 byte, terlepas dari apakah key yang digunakan adalah AES-128, AES-192, atau AES-256.

Pada bagian awal fungsi, AF_ALG akan memproses control message dengan af_alg_cmsg_send(). Dari sinilah kernel memperoleh informasi seperti ALG_OP_ENCRYPT, ALG_OP_DECRYPT, IV, dan associated-data length untuk AEAD. Setelah metadata tersebut divalidasi, AF_ALG mulai memasukkan data dari user ke buffer yang dimiliki oleh socket.

Context pada opfd

Setiap opfd mempunyai sebuah context bertipe struct af_alg_ctx. Context inilah yang mempertahankan data dan status operasi walaupun program memanggil sendmsg() beberapa kali.

Relasi object-nya dapat disederhanakan menjadi seperti berikut:

Relasi opfd, alg_sock, af_alg_ctx, tsgl_list, dan scatterlist
Relasi object pada opfd

struct af_alg_ctx memiliki cukup banyak field, tetapi untuk memahami vulnerability ini kita tidak perlu membahas semuanya. Beberapa state yang paling relevan adalah:

FieldKegunaan
tsgl_listLinked list yang menyimpan TX scatter-gather list berisi input dari user
usedTotal byte input yang saat ini telah disimpan oleh kernel
moreMenandakan bahwa user masih akan mengirim data tambahan melalui MSG_MORE
mergeMenandakan bahwa page terakhir masih mempunyai ruang dan data berikutnya dapat digabungkan ke sana
initMenandakan bahwa metadata untuk operasi tersebut sudah diinisialisasi
encMenentukan apakah operasi yang dilakukan adalah encrypt atau decrypt

State-state ini bukan hanya variable lokal yang hilang ketika sendmsg() selesai. Semuanya disimpan pada context yang sama selama opfd tersebut masih digunakan. Karena itu, hasil dari satu pemanggilan sendmsg() akan memengaruhi bagaimana pemanggilan berikutnya diproses.

Bagaimana Input Disimpan

Data yang dikirim dari user tidak disimpan sebagai satu buffer besar yang contiguous. AF_ALG membaginya menjadi beberapa memory page, kemudian setiap bagian direpresentasikan menggunakan struct scatterlist.

Sebagai contoh, jika user mengirim 10 KB data pada sistem dengan page berukuran 4 KB, secara sederhana data tersebut dapat tersimpan seperti berikut:

Input 10 KB dibagi menjadi tiga memory page dan scatterlist entry
Pembagian input ke memory page

Masing-masing scatterlist entry menyimpan informasi mengenai page yang digunakan, offset awal data di dalam page, dan panjang datanya. Dengan begitu, kernel tidak harus mencari satu area physical memory sebesar 10 KB yang berurutan. Crypto API cukup menerima daftar yang menunjukkan di mana setiap bagian data berada.

Scatterlist tersebut dikelompokkan lagi di dalam struct af_alg_tsgl:

struct af_alg_tsgl {
        struct list_head list;
        unsigned int cur;
        struct scatterlist sg[];
};

Field sg adalah array scatterlist, sedangkan cur menunjukkan berapa entry yang telah terisi. Jika cur bernilai 3, maka entry yang valid adalah sg[0], sg[1], dan sg[2]. Dengan kata lain, scatterlist terakhir yang sedang digunakan dapat diperoleh dengan perhitungan:

sg = sgl->sg + sgl->cur - 1;

Untuk kondisi normal dengan cur = 3, perhitungan tersebut akan menghasilkan sg[2]. Perhitungan sederhana ini nantinya menjadi bagian yang sangat penting dari vulnerability.

Satu struct af_alg_tsgl hanya dapat menampung scatterlist entry dalam jumlah tertentu, yang dibatasi oleh MAX_SGL_ENTS. Jika array pada object terakhir sudah penuh, af_alg_alloc_tsgl() akan mengalokasikan object af_alg_tsgl baru, menginisialisasi cur dengan nilai 0, lalu menambahkannya ke bagian paling belakang dari ctx->tsgl_list.

Jadi, bentuk data yang disimpan di dalam context kurang lebih seperti berikut:

Struktur tsgl_list yang berisi beberapa object af_alg_tsgl dan scatterlist entry
Struktur tsgl_list

Proses di dalam af_alg_sendmsg()

Setelah control message diproses, af_alg_sendmsg() akan melakukan loop selama masih ada data yang perlu disalin dari user. Secara garis besar, terdapat dua kemungkinan.

Pertama, jika page terakhir sudah penuh atau belum ada page yang dapat digunakan, kernel akan mengalokasikan page baru. Data kemudian disalin dengan memcpy_from_msg(), scatterlist entry diisi, sgl->cur dinaikkan, dan ctx->used ditambah sesuai jumlah byte yang berhasil disalin.

Kedua, jika page terakhir belum penuh, AF_ALG tidak perlu langsung mengalokasikan page baru. Sisa ruang di page tersebut dapat digunakan untuk menampung data dari pemanggilan sendmsg() selanjutnya. Kondisi ini ditandai oleh ctx->merge.

Misalnya user hanya mengirim 2 KB data ke page yang memiliki kapasitas 4 KB:

Isi page terakhirUkuran
Data yang sudah disalin2048 byte
Ruang yang masih kosong2048 byte
Total PAGE_SIZE4096 byte

Karena masih terdapat ruang kosong, ctx->merge akan bernilai true. Ketika sendmsg() berikutnya dipanggil, fungsi akan masuk ke branch berikut:

if (ctx->merge) {
        sgl = list_entry(ctx->tsgl_list.prev,
                         struct af_alg_tsgl, list);
        sg = sgl->sg + sgl->cur - 1;
        /* append data into the last page */
}

Secara intuitif, ctx->merge = true dapat dibaca sebagai: data berikutnya dapat dilanjutkan ke scatterlist entry terakhir.

Setelah proses copy selesai, AF_ALG menyimpan apakah pemanggilan tadi menggunakan MSG_MORE ke dalam ctx->more. Jika nilainya true, berarti user menyatakan bahwa input operasi ini belum selesai. Pemanggilan sendmsg() berikutnya dapat melanjutkan input yang sama tanpa harus mengirim ulang seluruh metadata.

Secara sederhana, flow normal af_alg_sendmsg() adalah:

Flow normal af_alg_sendmsg ketika merge aktif atau scatterlist baru diperlukan
Flow normal af_alg_sendmsg

Sampai di sini, mekanismenya terlihat cukup masuk akal. Kernel menghindari pemborosan satu page penuh untuk input yang kecil, dan state pada af_alg_ctx memungkinkan data dikirim secara bertahap.

Namun terdapat satu asumsi yang tidak ditulis secara eksplisit di dalam kode:

Jika ctx->merge bernilai true, maka af_alg_tsgl terakhir pasti mempunyai setidaknya satu scatterlist entry yang valid.

Atau jika ditulis sebagai invariant:

ctx->merge == true  =>  last_sgl->cur > 0

Dengan kondisi tersebut, operasi sgl->cur - 1 aman dilakukan karena cur tidak mungkin bernilai 0. Pada awalnya saya juga melihat hubungan ini sebagai sesuatu yang natural: bagaimana mungkin kernel ingin melanjutkan penulisan ke entry terakhir jika entry tersebut belum ada?

Pertanyaannya kemudian berubah menjadi: apakah invariant tersebut benar-benar selalu dijaga pada setiap jalur eksekusi, termasuk ketika terdapat lebih dari satu thread yang memanggil sendmsg() pada opfd yang sama?

Ketika Dua Thread Memanggil sendmsg() Bersamaan

af_alg_sendmsg() memang memanggil lock_sock() sebelum memodifikasi context. Sekilas, ini membuat beberapa pemanggilan sendmsg() terlihat telah diserialisasi. Tetapi ketika send buffer penuh, fungsi dapat masuk ke af_alg_wait_for_wmem() untuk menunggu sampai tersedia ruang kembali.

Di dalam af_alg_wait_for_wmem(), proses menunggu tersebut dilakukan melalui macro sk_wait_event():

if (sk_wait_event(sk, &timeout, af_alg_writable(sk), &wait)) {
        err = 0;
        break;
}

Jika hanya membaca fungsi tersebut, proses unlock dan lock socket memang tidak langsung terlihat. Keduanya berada di dalam implementasi macro `sk_wait_event()`. Jika hanya mengambil bagian yang relevan, macro tersebut melakukan:

release_sock(__sk);
/* wait_woken() while the condition is false */
lock_sock(__sk);
/* evaluate the condition again */

Jadi, selama thread tidur menunggu send buffer kembali writable, socket lock sengaja dilepas. Hal ini memang diperlukan agar operasi lain dapat mengonsumsi data dan membuat ruang baru. Setelah thread dibangunkan, lock tersebut diambil kembali sebelum af_alg_sendmsg() melanjutkan eksekusi.

Konsekuensinya, dua thread dapat sama-sama mempunyai pemanggilan sendmsg() yang belum selesai terhadap opfd yang sama. Keduanya tidak memodifikasi context pada waktu yang persis bersamaan karena masih ada socket lock, tetapi state yang dilihat thread kedua setelah bangun dapat berbeda dari state ketika thread tersebut mulai menunggu.

Kondisi awal yang saya gunakan adalah:

last_sgl->cur = MAX_SGL_ENTS - 1
ctx->merge    = false
send buffer   = penuh

Kemudian dua thread melakukan sendmsg() dan sama-sama tertahan di af_alg_wait_for_wmem(). Ketika sebagian buffer dilepas, thread pertama terbangun. Karena object af_alg_tsgl terakhir masih menyisakan satu entry, thread ini menggunakan entry tersebut. Saya membuat data yang disalin berukuran lebih kecil dari PAGE_SIZE, sehingga page terakhir tidak terisi penuh dan ctx->merge berubah menjadi true.

Pada diagram di bawah, saya menggunakan tail.cur untuk menunjukkan nilai cur pada object af_alg_tsgl terakhir. Field cur bukan berada langsung di dalam af_alg_ctx, tetapi object tersebut dapat diakses melalui entry terakhir dari ctx->tsgl_list.

Interleaving kedua thread tersebut dapat digambarkan seperti berikut:

Interleaving dua writer pada AF_ALG yang merusak invariant antara ctx merge dan tail cur
Interleaving dua writer dan perubahan state af_alg_ctx

Setelah Thread A selesai, tetapi sebelum Thread B melanjutkan, state-nya menjadi:

last_sgl->cur = MAX_SGL_ENTS
ctx->merge    = true

Thread kedua masih berada di wait path. Setelah ruang buffer kembali tersedia, thread kedua melanjutkan eksekusinya dari posisi setelah pengecekan writable memory. Karena af_alg_tsgl terakhir sekarang sudah penuh, af_alg_alloc_tsgl() mengalokasikan object baru dan memasukkannya ke akhir tsgl_list.

Object baru tersebut dimulai dengan:

new_last_sgl->cur = 0

Pada thread kedua, saya memberikan userspace address yang invalid agar memcpy_from_msg() gagal. Page yang baru saja dialokasikan dibersihkan kembali dan fungsi keluar melalui error path. Tetapi object af_alg_tsgl yang baru tetap menjadi entry terakhir, sementara nilai ctx->merge yang sebelumnya dibuat oleh thread pertama masih bernilai true.

Untuk pertama kalinya, context berada pada state berikut:

ctx->merge       = true
last_sgl->cur    = 0

Inilah state yang sebelumnya terlihat tidak mungkin terjadi.

Pada pemanggilan sendmsg() selanjutnya, ctx->merge membuat kernel mencoba mengambil scatterlist entry terakhir:

sg = sgl->sg + sgl->cur - 1;

Tetapi karena sgl->cur bernilai 0, perhitungannya berubah menjadi:

sg = sgl->sg + 0 - 1
   = &sgl->sg[-1]

Pointer tersebut tidak lagi menunjuk ke dalam array sg[], tetapi ke memory yang berada sebelum array. Ketika field dari scatterlist palsu tersebut digunakan oleh memcpy_from_msg(), terjadilah out-of-bounds access yang menjadi akar dari CVE-2025-39964.

Yang menarik bagi saya adalah, baris yang melakukan sgl->cur - 1 sebenarnya terlihat benar jika invariant sebelumnya selalu terpenuhi. Bug ini tidak muncul karena programmer lupa melakukan pengecekan sederhana pada sebuah input user. Bug muncul karena interleaving antara dua thread dan sebuah error path memungkinkan state bersama masuk ke kombinasi yang tidak pernah diharapkan oleh kode tersebut.

Pada tahap ini saya sudah bisa mendapatkan KASAN crash:

BUG: KASAN: slab-out-of-bounds in af_alg_sendmsg
Read of size 8 by task exploit

Tetapi sebuah crash belum otomatis berarti bahwa vulnerability tersebut dapat digunakan untuk mendapatkan root. Pertanyaan selanjutnya adalah: memory apa yang sebenarnya berada tepat sebelum sg[], seberapa jauh data tersebut dapat dikontrol, dan apakah out-of-bounds ini dapat diubah menjadi primitive yang berguna untuk eksploitasi?

Dari Out-of-Bounds Menjadi Arbitrary Write

Setelah mendapatkan KASAN crash, hal pertama yang perlu saya pahami adalah posisi sg[-1] terhadap object yang sedang digunakan. Pada kernel dan konfigurasi yang saya eksploitasi, layout kedua struct tersebut adalah:

struct af_alg_tsgl
    offset 0x00: list_head       (16 byte)
    offset 0x10: cur             (4 byte)
    offset 0x14: padding         (4 byte)
    offset 0x18: sg[0]

sizeof(struct scatterlist) = 0x20

Karena sg[0] dimulai pada offset 0x18, maka posisi sg[-1] dapat dihitung menjadi:

offset sg[0] - sizeof(struct scatterlist)
= 0x18 - 0x20
= -0x8

Dengan kata lain, scatterlist palsu tersebut dimulai delapan byte sebelum object af_alg_tsgl.

Setiap af_alg_tsgl dialokasikan sebagai object berukuran 4096 byte. Jika allocator menempatkan object lain tepat sebelum af_alg_tsgl yang vulnerable, maka sg[-1].page_link akan membaca delapan byte terakhir dari object sebelumnya, yaitu pada offset 0xff8.

PosisiData yang dibaca sebagai
Object sebelumnya + 0xff8sg[-1].page_link
Delapan byte pertama af_alg_tsgl.list.nextsg[-1].offset dan sg[-1].length
Object af_alg_tsgl + 0x18sg[0] yang sebenarnya

Di sinilah out-of-bounds tersebut mulai dapat diubah menjadi sesuatu yang berguna. Saya melakukan heap spray menggunakan allocation dengan ukuran yang sama, lalu mengisi bagian akhir object sebelumnya dengan data yang dapat dikontrol. Tujuannya adalah membuat delapan byte pada offset 0xff8 menjadi nilai yang nantinya dibaca kernel sebagai sg[-1].page_link.

Field page_link pada struct scatterlist digunakan untuk mendapatkan alamat struct page. Setelah itu, vulnerable path menghitung alamat tujuan copy kurang lebih seperti berikut:

dest = page_address(sg_page(sg)) + sg->offset + sg->length;
memcpy_from_msg(dest, msg, len);

Dengan mengontrol sg[-1].page_link, kita dapat memengaruhi page yang dikembalikan oleh sg_page(sg). Namun sg[-1].offset dan sg[-1].length dibaca dari pointer list.next pada awal object af_alg_tsgl saat ini. Nilainya berasal dari alamat linked list, bukan dari nilai page_link yang kita isi melalui spray. Kedua field tersebut juga memengaruhi destination, sehingga hanya mengatur page_link belum cukup untuk mengetahui alamat copy secara persis.

Secara konsep, progression exploit-nya adalah:

Tahapan eksploitasi dari sg negatif hingga overwrite core_pattern dan eksekusi sebagai root
Progression exploit CVE-2025-39964

Tentunya pada implementasi nyata, mengubah kontrol terhadap page_link menjadi arbitrary write tidak sesederhana langsung mengisinya dengan alamat core_pattern. Kernel menggunakan struct page dan alamat vmemmap, sementara KASLR membuat alamat-alamat tersebut tidak langsung diketahui oleh unprivileged user.

Properti Usercopy di Balik memcpy_from_msg()

Credit untuk trik usercopy ini dan penyelesaian exploit chain-nya saya berikan kepada rekan kerja saya, Bing-Jhong Billy Jheng. Ia melihat bahwa jalur memcpy_from_msg() dapat digunakan untuk mencari destination hasil perhitungan, meskipun pointer linked list ikut menentukan sg[-1].offset dan sg[-1].length.

Pada awalnya, mencoba banyak kemungkinan page_link terdengar berbahaya. Jika hasil perhitungannya menunjuk ke alamat yang tidak valid dan kernel melakukan memcpy() biasa, satu tebakan yang salah dapat langsung menyebabkan kernel page fault dan membuat sistem crash. Oracle seperti itu tidak terlalu berguna karena setiap percobaan yang gagal berarti kernel harus direstart.

Namun vulnerable path ini tidak menggunakan memcpy() biasa. Penulisan dilakukan melalui memcpy_from_msg():

err = memcpy_from_msg(page_address(sg_page(sg)) +
                      sg->offset + sg->length,
                      msg, len);

Implementasi `memcpy_from_msg()` kemudian meneruskan proses copy menuju copy_from_iter_full():

static inline int memcpy_from_msg(void *data, struct msghdr *msg, int len)
{
        return copy_from_iter_full(data, len, &msg->msg_iter) ? 0 : -EFAULT;
}

Karena data pada msg_iter berasal dari userspace, jalur tersebut akhirnya menggunakan `copy_from_user_iter()`, yang pada Linux v6.12.44 memanggil raw_copy_from_user():

if (access_ok(iter_from, len)) {
        to += progress;
        res = raw_copy_from_user(to, iter_from, len);
}

Hal yang menarik adalah access_ok() di sini memvalidasi alamat sumber dari user, bukan pointer tujuan to yang berasal dari scatterlist. Pada kondisi vulnerability, pointer to inilah yang telah berubah menjadi alamat hasil perhitungan sg[-1].

Pada target x86-64 yang saya gunakan, implementasi `raw_copy_from_user()` memakai usercopy routine yang mempunyai exception handling untuk fault pada kedua sisi operasi copy, baik source maupun destination. Routine tersebut juga membuka akses SMAP selama usercopy berlangsung. Akibatnya, apabila destination yang salah tadi ternyata jatuh pada userspace page yang valid dan writable, copy dapat berhasil. Apabila destination-nya belum ter-mapping, fault tersebut ditangani oleh exception table dan dikembalikan sebagai jumlah byte yang gagal disalin, bukan berubah menjadi kernel oops.

memcpy_from_msg() kemudian mengubah incomplete copy tersebut menjadi -EFAULT. Dari userspace, hasilnya menjadi oracle yang sangat bersih:

Destination hasil perhitunganHasil copyHasil sendmsg()Kondisi kernel
Jatuh pada userspace page yang mappedBerhasilMengembalikan jumlah byte yang dikirimTetap berjalan
Jatuh pada alamat yang unmappedUsercopy menangkap faultGagal dengan EFAULTTetap berjalan

Properti terakhir inilah yang membuat kami dapat terus mencoba tanpa membuat kernel crash untuk setiap tebakan yang salah. Dalam PoC, copy dilakukan sepanjang satu byte. sendmsg() mengembalikan 1 ketika destination valid dan -1 dengan errno == EFAULT ketika destination tidak valid.

Kami kemudian memetakan virtual address range yang besar di userspace dan mengubah nilai page_link secara terkontrol. Oracle menunjukkan apakah destination yang dihitung jatuh pada page yang sudah di-mapping tanpa membuat kernel crash ketika tebakan meleset. Setelah page ditemukan, hasil copy menunjukkan offset sebenarnya meskipun ada kontribusi dari list.next. Dengan posisi tersebut diketahui, exploit memperhitungkan offset di dalam page lalu menggeser page_link secara relatif menuju page kernel yang berisi core_pattern.

Detail implementasinya cukup panjang karena mencakup mapping address range, binary search menggunakan oracle, pencarian page dengan mincore(), dan perhitungan selisih antara page yang ditemukan dengan page target. Seluruh perhitungan dan source exploit tersebut saya dokumentasikan lebih lengkap pada kernelCTF exploit write-up CVE-2025-39964.

Untuk artikel ini, hal yang paling penting adalah hubungan antara bug dan primitive yang dihasilkan:

sg[-1] membuat kernel membaca page_link dari heap object yang dapat dikontrol. Nilai tersebut kemudian digunakan untuk menghitung destination dari memcpy_from_msg(), sehingga out-of-bounds read terhadap metadata berubah menjadi kernel write primitive.

Mengapa Menargetkan core_pattern?

core_pattern menentukan bagaimana kernel menangani core dump. Jika nilainya diawali dengan karakter pipe (|), kernel akan menjalankan program yang dituliskan setelahnya dan mengirimkan core dump kepada program tersebut.

Dengan arbitrary write tadi, exploit mengganti isi core_pattern dengan command yang mengarah kembali ke binary exploit. Setelah itu sebuah child process sengaja dibuat crash. Kernel kemudian menjalankan binary tersebut sebagai core-dump handler dengan privilege root.

Pada environment kernelCTF yang menjadi target saya, primitive ini tidak hanya memberikan local privilege escalation dari user biasa menjadi root. Karena AF_ALG dapat dijangkau dari dalam container dan kernel yang dieksploitasi adalah kernel milik host, jalur yang sama juga dapat digunakan untuk keluar dari Docker container dan mendapatkan akses root pada host.

Saya memilih menjelaskan bagian exploit sampai tingkat ini karena pembaca tetap perlu memahami mengapa crash tersebut exploitable. Namun detail seperti ukuran setiap spray, urutan grooming allocator, nilai address range, dan kalkulasi binary search akan membuat cerita discovery tenggelam di dalam detail implementasi. Bagi pembaca yang ingin mereproduksi exploit-nya, bagian tersebut lebih mudah diikuti langsung melalui exploit.md dan source PoC.

Bagaimana Bug Ini Diperbaiki

Kode skcipher yang vulnerable dapat ditelusuri sampai commit `8ff590903d5f`, yaitu crypto: algif_skcipher - User-space interface for skcipher operations, yang masuk bersama Linux 2.6.38 pada 2011. Kernel yang terdampak tetap vulnerable hingga perbaikannya pada 2025, bergantung pada konfigurasi dan backport masing-masing vendor. Ketika saya menemukannya, bug ini sudah berada di kode tersebut selama sekitar 14 tahun.

Masalah utamanya bukan hanya tidak adanya pengecekan cur == 0. Kondisi tersebut merupakan akibat dari dua writer yang menggunakan satu af_alg_ctx dan melanjutkan operasi setelah state context berubah selama wait path.

Karena itu, patch upstream memperbaikinya dengan menambahkan exclusive ownership untuk writer. Ketika sebuah sendmsg() masih berlangsung, writer lain pada socket yang sama akan mendapatkan error -EBUSY:

lock_sock(sk);
if (ctx->write) {
        release_sock(sk);
        return -EBUSY;
}
ctx->write = true;

Sebelum fungsi selesai, ctx->write dikembalikan menjadi false. Dengan perubahan tersebut, socket lock masih boleh dilepas ketika menunggu memory, tetapi thread lain tetap tidak dapat memulai write kedua terhadap context yang sama.

Menurut saya fix ini juga menjelaskan root cause vulnerability dengan sangat baik. Implementasi lama secara implisit menganggap hanya ada satu writer yang sedang membangun input. Patch tersebut membuat asumsi itu menjadi aturan yang benar-benar diperiksa oleh kernel. Perubahan lengkapnya dapat dilihat pada commit `crypto: af_alg - Disallow concurrent writes in af_alg_sendmsg`.

Di bawah ini merupakan demo exploit local privilege escalation yang dijalankan pada environment kernelCTF. Exploit memicu race condition pada AF_ALG, membentuk arbitrary kernel write, lalu mendapatkan akses root dari user biasa.

Demo local privilege escalation CVE-2025-39964 pada kernelCTF
Demo exploit LPE pada kernelCTF

Melalui submission kernelCTF, temuan dan exploit ini memperoleh reward sebesar $113,337.00 USD. Reward tersebut diberikan setelah impact-nya didemonstrasikan dalam bentuk exploit LPE yang dapat bekerja pada target kernelCTF.

Penutup: Menemukan Vulnerability dan Membuat Exploit

Exploit yang sudah selesai dapat membuat prosesnya terlihat sederhana. Kenyataannya, saya perlu cukup lama membaca kode dan menguji race sebelum mendapatkan crash yang berguna. Setelah itu, masih ada pekerjaan engineering untuk mengubah crash tersebut menjadi exploit yang reliable.

Bagian research dimulai jauh sebelum ada KASAN crash. Saya perlu memilih attack surface yang dapat dijangkau oleh unprivileged user, memahami bagaimana AF_ALG menyimpan input, lalu membuat model mengenai state yang seharusnya selalu benar. Dari sana pertanyaannya bukan langsung “bagaimana mendapatkan root?”, tetapi “apakah merge benar-benar selalu berarti terdapat SG entry terakhir?”

Setelah hipotesis tersebut dapat dibuktikan dan menghasilkan KASAN crash, pekerjaannya belum selesai. Bagian berikutnya lebih banyak menjadi proses engineering: membuat race condition dapat dipicu secara konsisten, memahami layout object di heap, dan mengontrol page_link. Billy menemukan properti usercopy yang dapat dipakai sebagai oracle ketika alamat kernel belum diketahui. Dengan oracle tersebut, destination yang salah mengembalikan EFAULT tanpa menjatuhkan kernel, sehingga kami dapat menemukan posisi copy sebelum mengarahkan write ke core_pattern.

Menurut saya, kedua proses itu sama pentingnya. Dari membaca source code, saya menemukan asumsi pada shared state yang ternyata dapat dipatahkan. Engineering exploit menunjukkan dampaknya ketika kondisi tersebut benar-benar terjadi. Saya menuliskan langkah-langkah di antaranya supaya pembaca dapat mengikuti bagaimana sebuah pertanyaan tentang kode berkembang menjadi vulnerability dan exploit yang bekerja.