Halo para peneliti keamanan dan *red teamer*! Hari ini kita akan menyelami **Furtex**, sebuah toolkit *post-exploitation* dan *evasion* untuk Linux yang menarik perhatian karena pendekatannya yang unik. Furtex dirancang untuk melewati sistem deteksi modern dengan memanfaatkan kemampuan tingkat rendah dari kernel Linux, yaitu **io_uring** dan **eBPF**.

## Apa Itu Furtex? Lebih dari Sekadar Toolkit Biasa

**Furtex** bukanlah toolkit biasa yang mengandalkan pustaka atau *framework* pihak ketiga. Sebaliknya, ia dibangun dari awal menggunakan *raw syscalls* atau panggilan sistem mentah. Pendekatan ini memungkinkannya berinteraksi langsung dengan kernel tanpa melalui *layer* abstraksi yang bisa menjadi titik *hook* bagi solusi deteksi. Proyek ini masih aktif dikembangkan, bahkan menerima *pull request* dari komunitas. Anda bisa bergabung dengan komunitas Rootkit Researchers di Discord untuk diskusi lebih lanjut.

Penting untuk diingat, **Furtex** ditujukan secara eksklusif untuk penelitian keamanan, *penetration testing* yang sah, kompetisi CTF, dan pengembangan *defensive tooling*. Jangan pernah menggunakannya pada sistem yang tidak Anda miliki atau tidak memiliki otorisasi tertulis untuk diuji. Penyalahgunaan dapat melanggar hukum siber yang berlaku.

## Membongkar Struktur Furtex

Toolkit ini disusun dengan rapi ke dalam beberapa direktori utama, masing-masing fokus pada aspek tertentu dari *post-exploitation* dan *evasion*:

*   `io_uring/`: Direktori ini berisi 13 *tool* yang memanfaatkan operasi `io_uring` mentah untuk manipulasi *file*, *networking*, injeksi, dan *exfiltration*. Ini adalah jantung dari kemampuan *stealthy* Furtex.
*   `bpf/`: Di sini Anda akan menemukan 15 *tool* untuk manipulasi *map* dan program BPF dari *userspace*. Sangat berguna untuk memahami dan memodifikasi perilaku BPF pada sistem target.
*   `ebpf/`: Direktori ini menampung 9 program BPF sisi kernel dan 2 *runner* untuk memuatnya. Program-program ini dirancang untuk beroperasi di kernel untuk tujuan pengintaian atau *evasion*.
*   `edrs/`: Ini adalah bagian terbesar dari toolkit, dengan 75 *tool* yang didedikasikan untuk *evasion* EDR (Endpoint Detection and Response) dan *post-exploitation* umum.
*   `techniques/`: Direktori ini menyediakan 13 *tool* spesifik untuk melewati semua 25 aturan standar pada Falco, salah satu EDR berbasis perilaku populer.

## Kekuatan di Balik Layar: io_uring dan eBPF

Dua pilar utama **Furtex** adalah **io_uring** dan **eBPF**. Memahami bagaimana keduanya bekerja sangat penting untuk mengapresiasi kehebatan toolkit ini.

### io_uring untuk Operasi Stealthy

**io_uring** adalah antarmuka I/O asinkron baru di kernel Linux yang menawarkan performa dan fleksibilitas luar biasa. Namun, **Furtex** memanfaatkannya untuk *evasion*. Permintaan I/O yang diajukan melalui `io_uring` SQEs diproses melalui *kernel workqueue*. Ini berarti pemanggilan `io_uring_enter(2)` tidak pernah melalui `sys_call_table` dan tidak memicu *tracepoint* `sys_enter_*`. Ini secara otomatis melewati sebagian besar *hook* EDR yang mengandalkan:

*   Penggantian *pointer* `sys_call_table`.
*   *Livepatch* pada `native_sys_call` atau `compat_sys_call`.
*   *Tracepoint* `sys_enter_*`.

Namun, `io_uring` saja tidak cukup untuk semua jenis *bypass*. Untuk *hook point* lain seperti *kprobes* atau BPF LSM, Furtex menyediakan *tool* tambahan. Misalnya, `ftrace_enum` dapat menghapus *kprobe hooks*, dan `bpf_link_detach` dapat melepaskan *link* BPF LSM.

### eBPF: Kontrol Granular Kernel

**eBPF** (extended Berkeley Packet Filter) adalah teknologi kernel yang memungkinkan program *userspace* dieksekusi di dalam kernel secara aman. Furtex memanfaatkan **eBPF** untuk memanipulasi *map* BPF, memuat program BPF sisi kernel, dan berinteraksi dengan komponen kernel secara mendalam. Ini termasuk kemampuan untuk:

*   Mendaftar dan membuang isi *map* BPF.
*   Menyisipkan PID ke dalam *allowlist* EDR.
*   Mendeteksi dan melepaskan *hook* BPF LSM.
*   Bahkan menyembunyikan port atau PID dari pandangan `/proc/net/tcp` atau `getdents64`.

## Persyaratan Sistem

Untuk menjalankan dan membangun **Furtex**, Anda memerlukan lingkungan Linux tertentu dengan beberapa *toolchain* dan *header* yang terinstal.

### Toolchain dan Headers

| Tool / Package                  | Dibutuhkan untuk                                                                                                    |
| :------------------------------ | :------------------------------------------------------------------------------------------------------------------ |
| `gcc`                           | Semua *binary userspace*                                                                                            |
| `clang`                         | Program BPF sisi kernel (`ebpf/*.bpf.c`)                                                                            |
| `make`                          | Sistem *build*                                                                                                      |
| `linux-headers-$(uname -r)`     | `<linux/bpf.h>`, `<linux/io_uring.h>`, dan *header* kernel terkait                                                  |
| `libbpf-dev`                    | `<bpf/bpf_helpers.h>` dan fungsi terkait di program `ebpf/`                                                         |
| `bpftool`                       | Menghasilkan `vmlinux.h` melalui `make vmlinux` di dalam `ebpf/` (memerlukan `CONFIG_DEBUG_INFO_BTF=y` di kernel) |

Untuk Debian, Kali, atau Ubuntu, Anda bisa menginstal semuanya dengan perintah:

```bash
sudo apt install gcc clang make linux-headers-$(uname -r) libbpf-dev bpftool
```

### Versi Kernel dan Kapabilitas

**Furtex** memanfaatkan fitur kernel yang berbeda, sehingga versi kernel Anda memengaruhi *tool* apa saja yang bisa Anda gunakan. Selain itu, banyak *tool* memerlukan kapabilitas Linux tertentu, yang biasanya membutuhkan hak akses `root` atau `CAP_SYS_ADMIN` sebelum kernel 5.8.

| Versi Kernel Minimum | Fitur yang Terbuka                                                     |
| :------------------- | :--------------------------------------------------------------------- |
| 5.4                  | `io_uring` dasar, iterasi *map* BPF                                    |
| 5.6                  | `IORING_OP_OPENAT`, `IORING_OP_STATX`, `pidfd_getfd`                   |
| 5.8                  | Pemisahan `CAP_BPF` + `CAP_PERFMON` (menggantikan `CAP_SYS_ADMIN` untuk BPF) |
| 5.9                  | `BPF_LINK_DETACH`                                                      |
| 5.19                 | `IORING_OP_SOCKET` (digunakan oleh `af_packet_send`, `dns_exfil`, dll) |

| Kapabilitas             | Tool yang Membutuhkannya                                                                                                     |
| :---------------------- | :--------------------------------------------------------------------------------------------------------------------------- |
| `CAP_BPF`               | Semua *tool* `bpf/`, *loader* `ebpf/`                                                                                        |
| `CAP_PERFMON`           | Program *tracepoint* dan *kprobe* `ebpf/`                                                                                    |
| `CAP_NET_RAW`           | `icmp_tunnel`, `af_packet_shell`, `skf_c2_runner`, `icmp_trigger`                                                          |
| `CAP_NET_ADMIN`         | `xdp_socket_send`, `netfilter_flush`                                                                                         |
| `CAP_AUDIT_CONTROL`     | `audit_kill`                                                                                                                 |

## Membangun Furtex

Proses *build* Furtex cukup sederhana dengan `make`:

```bash
make all      # Membangun semua binary
make uring    # Membangun tool io_uring/ saja
make bpf      # Membangun tool userspace bpf/
make ebpf     # Membangun program BPF sisi kernel (memerlukan clang + libbpf)
make edrs     # Membangun semua binary edrs/
make techniques # Membangun tool Falco bypass
make clean    # Menghapus semua binary
```

Khusus untuk direktori `edrs/`, terdapat `Makefile` tersendiri yang memisahkan *binary* berdasarkan kebutuhan privilese:

```bash
cd edrs && make priv    # Untuk tool yang memerlukan root / CAP_*
cd edrs && make unpriv  # Untuk tool yang tidak memerlukan privilese
```

## Menjelajahi Kemampuan EDR Evasion

Direktori `edrs/` adalah inti dari kemampuan *evasion* **Furtex**. Dengan 75 *tool*, Furtex menyediakan berbagai teknik untuk menghindari deteksi EDR. Beberapa contoh *tool* yang menonjol meliputi:

*   `edr_recon`: Mendeteksi EDR dari 12 vendor berbeda dengan memindai proses, artefak, modul, BPF, dan *kprobes*.
*   `audit_kill`: Menonaktifkan atau membatasi *logging* audit Linux melalui `NETLINK_AUDIT`.
*   `ftrace_enum`: Mendata dan menghapus *kprobe* atau *ftrace hooks*.
*   `livepatch_bypass`: Memanfaatkan `io_uring` untuk melewati *livepatch hooks* pada *syscall dispatcher*.
*   `af_packet_shell`: C2 Ethernet mentah yang melewati `netfilter OUTPUT`.
*   `memfd_userexec`: Mengeksekusi ELF dari *stdin* ke `memfd` tanpa `execve` tradisional.
*   `hollow_proc`: Melakukan *process hollowing* dengan nama samaran di `ps`.
*   `pidfd_steal`: Mencuri *file descriptor* yang terbuka dari proses lain melalui `pidfd_getfd`.

## Menargetkan Falco: Studi Kasus Spesifik

Direktori `techniques/` secara spesifik menargetkan Falco, solusi deteksi ancaman berbasis perilaku yang populer, dengan mengabaikan semua 25 aturan *default*-nya. Furtex mendekati *bypass* Falco dari dua arah utama:

*   **Axis A (Prevent Event):** Mencegah *event* mencapai Falco sama sekali. Contohnya, `io_uring` melewatkan *tracepoint* `sys_enter_*`, atau *ring buffer* Falco dikuras atau dibanjiri secara diam-diam.
*   **Axis B (Evade Rule Condition):** *Event* mencapai Falco, tetapi kondisi aturan tidak cocok karena manipulasi data. Misalnya, penyamaran nama proses (`proc.name spoof`), *path pivot*, atau penggunaan *flag* alternatif.

Beberapa contoh *tool* dan aturan Falco yang dapat dilewati:

| Aturan Falco                      | Metode Bypass (Axis)           | Tool yang Digunakan                         |
| :-------------------------------- | :----------------------------- | :------------------------------------------ |
| 1  Directory traversal monitored file read | `io_uring` OPENAT (A)          | `uring_ops cat`, `per_rule_bypass dir-traversal` |
| 3  Read sensitive file untrusted   | `io_uring` atau `prctl` (A/B)  | `uring_ops creds`, `bypass_file_rules read-masked` |
| 7  Contact K8S API Server          | `io_uring` CONNECT (A)         | `uring_ops shell`, `per_rule_bypass k8s-connect` |
| 10 Clear Log Activities           | `ftruncate` tanpa `O_TRUNC` (B) | `bypass_file_rules log-clear`               |
| 18 Detect release_agent Escape    | `io_uring` OPENAT+WRITE (A)    | `cgroup_escape proof/shell`, `uring_ops write` |
| 25 Fileless execution via memfd_create | Shellcode via `mmap`, no `execve` (B) | `exe_from_memfd_bypass sc`, `proc_ghost ghost-sc` |
| Semua Aturan                      | Kuras *ring buffer* atau hapus `scap.ko` (A) | `ringbuf_overflow`, `kmod_unload`           |

## Peringatan Penting

Seperti yang telah disebutkan, **Furtex** adalah *tool* yang sangat kuat dan harus digunakan dengan sangat hati-hati dan tanggung jawab. Semua teknik yang didemonstrasikan di sini didasarkan pada riset keamanan publik dan dokumentasi kernel. Penyalahgunaan *tool* ini dapat memiliki konsekuensi hukum yang serius. Para pengembang **Furtex** tidak bertanggung jawab atas penyalahgunaan apa pun. Dengan menggunakan perangkat lunak ini, Anda setuju bahwa Anda sepenuhnya bertanggung jawab untuk mematuhi hukum yang berlaku.

## Referensi

*   https://github.com/MatheuZSecurity/Furtex

Jelajahi Furtex, toolkit post-exploitation dan evasion Linux yang inovatif, memanfaatkan io_uring dan eBPF untuk operasi tersembunyi, bypass EDR, dan penelitian keamanan tingkat lanjut.

Mengungkap Furtex: Toolkit Post-Exploitation Linux Generasi Berikutnya dengan io_uring dan eBPF

Reggi

Solusi praktis integrasi webmail custom ke dalam dashboard Gmail. Kelola, baca, dan kirim email domain pribadi langsung dari satu tempat tanpa ribet gonta-ganti tab.

Mengapa Kamu Masih Buka Dua Tab Terpisah? Panduan Setup Custom Webmail Langsung di Dashboard Gmail

Pelajari efisiensi merakit mesin tetas telur listrik AC otomatis dengan modal murah untuk mendongkrak hasil ternak unggas tanpa repot bolak-balik telur manual.

Otomasi Ternak Unggas: Kenapa Rakit Sendiri Mesin Penetas Telur AC Jauh Lebih Worth It Dibanding Cara Konvensional?

Pelajari bagaimana mesin tetas telur berbasis arus listrik DC bekerja menjaga suhu dan kelembapan ideal untuk mendongkrak keberhasilan penetasan telur unggas.

Mesin Tetas Telur Arus DC: Solusi Hardware Murah Buat Tingkatin Angka Penetasan Unggas

Kupas tuntas seluk-beluk mobil aki anak dengan kontrol ganda dan fitur multimedia. Pahami batas spesifikasi hardware sebelum eksekusi build sendiri.

EV Versi Mini: Membedah Mobil Listrik Aki Lengkap dengan Remote Control dan Fitur Multimedia

Pelajari cara merakit smart power strip berbasis NodeMCU dan Blynk untuk kontrol daya nirkabel serta integrasi IoT yang aman dan efisien.

Mengapa Beli Mahal Kalau Bisa Bikin Sendiri? Rancang Smart Power Strip Berbasis NodeMCU dan Blynk

Solusi tuntas mengatasi bug sistem dan software bermasalah di MacBook dengan panduan install ulang macOS lewat Internet Recovery secara aman.

#post-exploitation

Getting Lastest Post..

Populer Bulan Ini