1. Introdução
Depois de um ataque, um hacker provavelmente vai querer
dificultar o trabalho do pessoal da segurança.
Para isto, uma opção fácil é o rootkit, que
nada mais é do que um programa modificado que
não faz o que normalmente deveria fazer.
Ex. um 'ps' que mostre processos errados
ou um 'ls' que não mostre alguns arquivos.
Além disso eles escondem backdoors, alteram logs, enfim.
Os rootkits mais básicos fazem o seu serviço
de um modo "curto e grosso", já os mais elaborados
alteram arquivos, têm opções iguais ao comando normal,
e até enganam verificadores de arquivos para que eles
não possam ser detectados pelo seu código CRC (código
que verifica a validade de um arquivo).
No entanto ainda pode se identificá-los sabendo o
seu código criptográfico MD5 (usando o comando md5sum,
por exemplo) e conferindo os resultados contra um
banco de dados, que pode ser tanto de programas válidos
quanto de rootkits famosos.
1.1. O que são Kernel Rootkits?
Estes rootkits trabalham diretamente no kernel,
permitindo alterar a saída do kernel (!!) de modo a causar
erros, retornar dados inválidos, e outros,
tudo isto *sem modificar arquivos de sistema*.
São bem difíceis de serem descobertos.
2. O básico
2.1. Enganando o kernel
Existem basicamente 2 maneiras de enganar o
kernel para permitir a entrada de um rootkit:
* carregando um módulo, que vem disfarçado
como um driver ou programa útil.
Assim o rootkit tem acesso avançado ao kernel.
* alterando o /dev/kmem:
O /dev/kmem é um dispositivo que dá
acesso à memória usada pelo kernel.
Felizmente os kernels mais novos já
tiveram este dispositivo tornado somente-leitura.
Um programa pode alterar o conteúdo ou simplesmente escrever
lixo para o kernel causando um travamento.
Uma demonstração de como funciona está
em
http://online.securityfocus.com/archive/1/273002 .
A técnica aplica um patch no kernel, "ao vivo", sem parar nenhum processo.
2.2. Aonde os rootkits podem agir? Básico da teoria de funcionamento deles
Quando uma chamada de sistema é executada o
"controle de fluxo" cai no seguinte caminho:
- Uma interrupção é chamada e o sistema
"volta a atenção" para esta chamada.
Um rootkit pode alterar a chamada para cair num lugar errado.
- A função system_call() do kernel procura o
endereço apropriado para a função. Aí é que a
maioria dos rootkits entra, corrompendo ou
alterando a lista de endereços de modo a causar erro.
- Esta função retorna dados, e o programa
continua a funcionar. Tecnicamente isto pode
ser abusado corrompendo os dados da saída;
mas ainda não é usada por nenhum rootkit.
3. Rootkits famosos
- SucKIT: o rootkit mais famoso, que usa a
técnica do /dev/kmem para acessar diretamente
as portas da rede, e permitir invasões remotas.
Provavelmente não funciona mais no Kernel 2.6.5.
Rootkits que usam o modo LKM (Linux Kernel Modules):
- RIAL: esconde arquivos e conexões. O comando 'less' é
desativado. Rootkit bem fraco, basta executar
"cat /proc/modules" para pegá-lo.
- heroin: esconde arquivos e processos,
não provê invasões remotas. Não aparece com
"lsmod" nem permite o uso de "rmmod" mas
pode ser encontrado com o comando "cat /proc/ksyms | grep heroin" .
- afhrm: redireciona arquivos para darem em
locais errados. Não funciona nos Kernels 2.2 ou mais avançados.
- Synapsis: esconde arquivos, portas e processos,
mas tem vários bugs. Dá direitos de root a um usuário qualquer.
Pode ser encontrado com "cat /proc/modules".
- adore: rootkit bem avançado, que permite
executar qualquer comando com privilégios de root ("backdoor local").
- knark: esconde arquivos, processos, serviços,
redireciona comandos e dá privilégios de root,
oferecendo um backdoor para permitir o controle remoto.
Se esconde e impede o uso do "rmmod".
- itf: esconde arquivos, processos, redireciona comandos,
dá privilégios de root e instala um backdoor.
Também impede o uso do "rmmod".
- kis: pode desativar firewalls, permitir acesso
remoto, esconder processos, arquivos e outros,
além de descarregar módulos. Se esconde como todos outros rootkits.
- adore-ng: igual ao adore mas altera dados do(s) drive(s) de disco rígido.
4. Como detectá-los?
Para se ter uma lista de módulos tem 2 comandos:
ou
Infelizmente a maioria dos rootkits se escondem dos comandos acima.
Rootkits LKM alteram o "mapa do kernel", que
geralmente está num arquivo chamado "System.map"
na mesma localização do kernel (/boot). Assim
é possível compará-lo com o System.map de um
kernel com a mesma versão do seu.
Podemos usar o programa "kern_check"
(
http://la-samhna.de/library/kern_check.c)
para verificar o arquivo system.map. Compile-o e chame-o com:
Onde "/caminho/ao" é a pasta onde está seu System.map
Ou o KSTAT, que analisa o /dev/kmem e
pode ser pego em
http://www.s0ftpj.org/tools/kstat24_v1.1-2.tgz
E assim concluo o tutorial sobre rootkits,
mostrando o método de operação deles, como detectar e previni-los.
A melhor solucao contra eles e' sempre manter o seu Kernel atualizado.
