Tutorial Build Tool Real-Time FIM Pakai Rust Aya eBPF di VPS Linux

Kenapa FIM Tradisional Sering Bikin Pusing?

Bayangkan skenario ini: jam dua malam, server VPS Anda disusupi peretas. Attacker berhasil masuk, mengubah isi /etc/passwd, lalu menanamkan backdoor di /etc/shadow. Kalau Anda mengandalkan tool File Integrity Monitoring (FIM) tradisional seperti Tripwire atau AIDE, biasanya ada skrip cron yang berjalan tiap beberapa jam untuk memeriksa perubahan file.

Masalahnya, FIM gaya lama bekerja seperti petugas ronda yang cuma lewat 3 jam sekali. Di antara jeda pemeriksaan itu, peretas punya waktu yang sangat luang untuk mengeksekusi aksi, menghapus jejak, lalu kabur sebelum skrip cron berikutnya berjalan. Selain itu, proses hashing ribuan file secara berkala memakan I/O disk yang sangat tinggi dan membuat CPU server melonjak mendadak.

Alternatif lain yang sering dipakai adalah API inotify di level user-space. Metode ini memang lebih cepat dibanding cron scan, tapi punya kelemahan teknis yang cukup fatal: inotify membutuhkan satu file descriptor untuk setiap direktori yang dipantau. Ketika struktur folder server sangat besar, limit file descriptor sistem akan cepat habis. Ditambah lagi, karena berjalan di user-space, proses monitoring ini sangat mudah dimatikan oleh attacker jika mereka berhasil mengantongi akses root.

Di sinilah eBPF (Extended Berkeley Packet Filter) hadir sebagai solusi modern. eBPF mengamankan server langsung dari dalam kernel Linux. Setiap kali ada panggilan sistem (syscall) untuk membuka atau mengubah file, program eBPF di dalam kernel akan langsung mencegat dan memverifikasi event tersebut secara real-time. Tanpa perlu polling disk, tanpa makan memori besar, dan tanpa beban overhead yang membebani server.

Arsitektur FIM Berbasis eBPF dan Rust Aya

Untuk membuat program eBPF, kita biasanya membutuhkan toolchain C yang cukup rumit seperti LLVM Clang. Tapi dengan library Aya di ekosistem Rust, kita bisa menulis program eBPF murni menggunakan bahasa Rust dari ujung ke ujung. Aplikasi FIM berbasis Aya ini terbagi menjadi dua komponen utama:

• Kernel-space Program: Kode Rust serba ringkas yang dikompilasi ke target khusus bpfel-unknown-none. Kode ini ditempelkan (attach) langsung ke tracepoint kernel syscalls/sys_enter_openat untuk mencegat setiap proses yang mencoba membuka atau memodifikasi file.
• User-space Application: Aplikasi Rust standar yang bertugas memuat (load) bytecode eBPF ke dalam kernel, menerima data event kejadian melalui Ring Buffer, lalu menampilkan notifikasi peringatan (alert) ketika ada aktivitas mencurigakan.

Persiapan Environment & Toolchain Rust

Sebelum mulai menulis kode, pastikan VPS Linux Anda menggunakan kernel versi 5.8 atau yang lebih baru agar mendukung fitur eBPF modern dan Ring Buffer. Jalankan perintah berikut untuk menyiapkannya:

# Install Rust toolchain nightly (diperlukan untuk kompilasi target eBPF)
rustup toolchain install nightly --component rust-src

# Install cargo-generate dan bpf-linker
cargo install cargo-generate
cargo install bpf-linker

# Generate template project Aya
cargo generate https://github.com/aya-rs/aya-template

Saat perintah cargo generate dijalankan, terminal akan menampilkan prompt interaktif. Isi nama project dengan fim-ebpf, pilih tipe program TracePoint, lalu masukkan tracepoint category syscalls dan tracepoint name sys_enter_openat.

Kompilasi eBPF Probe: Tracepoint sys_enter_openat

Buka file fim-ebpf-ebpf/src/main.rs. Di dalam file ini, kita akan menulis kode yang berjalan di dalam kernel-space. Kode ini bertugas menangkap argumen syscall openat, membaca path file dari memori proses, lalu memeriksa apakah file tersebut masuk dalam daftar file sensitif.

#![no_std]
#![no_main]

use aya_ebpf::{
    macros::tracepoint,
    programs::TracePointContext,
    helpers::bpf_probe_read_user_str_bytes,
};

#[tracepoint]
pub fn fim_ebpf(ctx: TracePointContext) -> u32 {
    match unsafe { try_fim_ebpf(ctx) } {
        Ok(ret) => ret,
        Err(_) => 1,
    }
}

unsafe fn try_fim_ebpf(ctx: TracePointContext) -> Result<u32, i64> {
    // Offset argumen filename pada tracepoint sys_enter_openat berada pada byte ke-16
    let filename_ptr: *const u8 = ctx.read_at(16)?;
    let mut buf = [0u8; 128];

    // Baca string path dari user-space memory ke buffer kernel
    let filename = bpf_probe_read_user_str_bytes(filename_ptr, &mut buf)?;

    // Filter file sensitif: /etc/passwd
    let target = b"/etc/passwd";
    if filename.len() >= target.len() && &filename[..target.len()] == target {
        // Event terdeteksi di level kernel
        return Ok(0);
    }

    Ok(0)
}

#[panic_handler]
fn panic(_info: &core::panic::PanicInfo) -> ! {
    unsafe { core::hint::unreachable_unchecked() }
}

Menerima Event di User-Space & Alert Real-Time

Selanjutnya, buka file fim-ebpf/src/main.rs untuk bagian user-space. Aplikasi ini bertugas meload program eBPF yang sudah dikompilasi tadi ke dalam kernel VPS dan menempelkannya ke tracepoint sys_enter_openat.

use aya::programs::TracePoint;
use aya::{include_bytes_aligned, Bpf};
use aya_log::BpfLogger;
use tokio::signal;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    // Load eBPF bytecode yang telah dikompilasi
    #[cfg(debug_assertions)]
    let mut bpf = Bpf::load(include_bytes_aligned!(
        "../../target/bpfel-unknown-none/debug/fim-ebpf"
    ))?;

    if let Err(e) = BpfLogger::init(&mut bpf) {
        eprintln!("Gagal inisialisasi eBPF logger: {}", e);
    }

    // Attach program ke tracepoint sys_enter_openat
    let program: &mut TracePoint = bpf.program_mut("fim_ebpf").unwrap().try_into()?;
    program.load()?;
    program.attach("syscalls", "sys_enter_openat")?;

    println!("FIM Probe eBPF berhasil di-load! Memantau akses file sensitif...");
    println!("Tekan Ctrl+C untuk menghentikan.");

    signal::ctrl_c().await?;
    println!("Menghentikan FIM Probe...");

    Ok(())
}

Jalankan project FIM ini menggunakan perintah berikut (dibutuhkan akses root untuk meload program ke kernel):

cargo xtask run

Sekarang, buka jendela terminal baru di VPS Anda lalu coba baca isi file /etc/passwd:

cat /etc/passwd

Aktivitas tersebut akan seketika tertangkap oleh probe eBPF secara real-time tanpa delay sedikit pun.

Mitigasi Overhead Kernel & Filtering False Positive

Mencegat syscall populer seperti openat membutuhkan kehati-hatian ekstra. Sistem operasi Linux memanggil openat puluhan ribu kali per detik untuk berbagai aktivitas normal. Jika semua event dilempar begitu saja ke user-space, context switch antara kernel dan user-space akan melonjak drastis dan justru membebani CPU.

• Kernel-Side Filtering: Lakukan penyaringan path file atau Process ID (PID) langsung di dalam kode eBPF (kernel-space). Hindari melempar event yang tidak relevan ke aplikasi user-space.
• Filter Mode Akses (Flags): Syscall openat menerima flag akses seperti O_RDONLY, O_WRONLY, atau O_RDWR. Jika FIM Anda difokuskan untuk mendeteksi modifikasi file (tampering), filter argumen flag di eBPF untuk mengabaikan operasi read-only (O_RDONLY). Langkah sederhana ini bisa memangkas hingga 90% noise event log.
• Gunakan Ring Buffer: Selalu prioritaskan struktur data BPF_MAP_TYPE_RINGBUF dibandingkan PERF_EVENT_ARRAY. Ring buffer eBPF membagi alokasi memori secara efisien antar-core CPU, mencegah data hilang (dropped events) saat trafik I/O server sedang sangat tinggi.

Saatnya Coba Sendiri

Membangun sistem File Integrity Monitoring sendiri menggunakan Rust dan Aya eBPF memberi Anda kendali penuh atas keamanan server Linux tanpa perlu mengorbankan performa. Anda mendapatkan performa pemantauan real-time tingkat kernel dengan konsumsi RAM dan CPU yang jauh lebih hemat dibandingkan solusi FIM tradisional berbasis polling disk.

Langkah terbaik untuk memulainya adalah mencoba langsung. Compile template Aya di atas pada VPS staging Anda, tambahkan daftar file penting lain seperti /etc/shadow atau /etc/sudoers ke dalam filter eBPF, lalu amati betapa ringannya resource server Anda saat monitoring berjalan.