Umeet :: Talk

Felipe Andrés Ceballos' talk

`ducky`	`los slides estan en people.nl.linux.org/~felipe/presentaciones/intro-modularizacion-kernel`
`ducky`	`bueno vamos a hace una introduccion teorica`
`ducky`	`a la modularizacion del kernel linux`
`ducky`	`los temas a tratar son los siguientes`
`ducky`	`modo protegido i386`
`ducky`	`espacio de kernel vs espacio de usuario`
`ducky`	`que son los modulos`
`ducky`	`caracteristicas`
`ducky`	`aplicaciones para el manejo de modulos`
`ducky`	`configuracion del kernel linux para darle soporte a modulos`
`ducky`	`conclusiones`
`ducky`	`bueno comenzemos dando una pequena introduccion a lo que es el kernel linux`
`ducky`	`el kernel es el nucleo del sistema el cual nos permite interactuar con la maquina`
`ducky`	`para que esta sea usable`
`ducky`	`el kernel interactua con el hardware directamente`
`ducky`	`linux es un kernel que invento linus torvalds en el año 1991`
`ducky`	`de estructura monolitica o sea esto quiere decir que el kernel es un unico gran proceso`
`ducky`	`divivide su desarrollo en version estable (2.6)`
`ducky`	`y version de desarrollo`
`ducky`	`bueno pasemos a ver lo que es el modo protegido i386`
`ducky`	`es una caracteristica que se introdujo en los procesadores 386`
`ducky`	`para evitar que los procesos y aplicaciones de usuario interfieran con el kernel`
`ducky`	`para elllo se inventaron los ring levels o niveles de proteccion`
`ducky`	`en i386 existen cuatro niveles 0, 1 ,2 y 3`
`ducky`	`Linux usa solo dos de ellos`
`ducky`	`0 o sea modo protegido`
`ducky`	`y 3 para el modo usuario`
`ducky`	`de esta forma se hace una division y se evita que los procesos usuario/kernel interfieran`
`ducky`	`en el modo protegido (ring 0)`
`ducky`	`ocurren todos los procesos de E/S a nivel de kernel, e interaccion con el hardware directamente`
`ducky`	`en el modo usuario (ring 3)`
`ducky`	`toda la interaccion con el usuario`
`ducky`	`y sus aplicaciones`
`ducky`	`los modulos del kernel linux corren en modo protegido (ring 0)`
`ducky`	`al igual que el resto del codigo del kernel linux`
`ducky`	`bueno pasemos ahora si a ver lo que es espacio de kernel y espacio de usuario`
`ducky`	`el espacio de kernel es aquel donde se interactua`
`ducky`	`con estructuras de datos criticas, DMA, IRQs..etc..en fin manejo de hardware a bajo nivel`
`ducky`	`y el espacio de usuario es aquel en donde corren todos los programas de los usuarios`
`ducky`	`en el siguiente grafico`
`ducky`	`http://people.nl.linux.org/~felipe/presentaciones/intro-modularizacion-kernel/mgp00006.html`
`ducky`	`podemos obsevar claramente la disticion que hay entre estos dos espacios`
`ducky`	`en el circulo mas externo podemos apreciar el espacio de usuario, en donde se encuentran`
`ducky`	`las aplicaciones que manejan los mismos tales como lo son`
`ducky`	`el interprete de comandos`
`ducky`	`los editores`
`ducky`	`los visores de imagenes...etc`
`ducky`	`en fin.aplicaciones de los usuarios`
`ducky`	`y en el circulo mas interno podemos apreciar el espacio de kernel con sus subsistemas`
`ducky`	`y driver actuando, tales como lo son`
`ducky`	`networking`
`ducky`	`memoria virtual`
`ducky`	`drivers para sistemas de archivos`
`ducky`	`drivers para dispositivos en general`
`ducky`	`bueno ahora si pasemos a ver`
`ducky`	`Qué es un módulo`
`ducky`	`es una pieza de codigo que corre en espacio de kernel y que se puede insertar o remover`
`ducky`	`en caliente, sin tener que recompilar el kernel o esperar a reiniciar/apagar la maquina para ver los efectos`
`ducky`	`o sea se puede insertar en caliente cuando la maquina esta en marcha`
`ducky`	`los modulos del kernel linux los podemos encontrar en la ruta`
`ducky`	`/lib/modules/"nuestra version de kernel"`
`ducky`	`ejemplo`
`ducky`	`/lib/modules/2.6.9`
`ducky`	`basicamente los modulos (se conocen tambien como modulos cargables)`
`ducky`	`para tres funciones`
`ducky`	`controladores para dispositivos`
`ducky`	`controladores para sistemas de archivos`
`ducky`	`llamadas al sistema`
`ducky`	`se crearon por que`
`ducky`	`tener todos los controladores de dispositivos/sistemas de archivos en una sola imagen binaria (/boot/vmlinuz)`
`ducky`	`esta quedaria bastante grande y consumiria bastante memoria util`
`ducky`	`permite que el desarrollo de los mismos sea mas eficiente, ya que como dije`
`ducky`	`anteriormente no se tiene que esperar a largos ciclos de espera de reinicio de la maquina`
`ducky`	`si no que simplemente, el la persona programa el modulo, lo compila y lo carga`
`ducky`	`si contiene algun error funcional, solamente se debe descargar el modulo`
`ducky`	`corregir sus errores/bugs, recompilrlo y volverlo a cargar`
`ducky`	`No se tiene que recompilar el kernel muy a menudo si no que por ejemplo`
`ducky`	`cuando necesitemos soporte para un x o y dispositivo podemos compilar el controlador como modulo`
`ducky`	`y cargarlo, y una vez se haya hecho esto nuestro kernel contendra todas las funcionalidades`
`ducky`	`que nos brinda aquel controlador o driver`
`ducky`	`por esa razon ahorra tiempo`
`ducky`	`se pueden descargar cuando ya no sean necesarios`
`ducky`	`mas adelante enteremos esto con mas profundidad :)`
`ducky`	`son mas faciles de mantener y/o depurar`
`ducky`	`por ejemplo si un desarrollador esta programando un driver`
`ducky`	`y nota que el funcionamiento de su kernel es bueno, antes de que se cargue el modulo`
`ducky`	`y despues de su carga..el sistema se cuelga...es mucho mas facil notar que el modulo contiene errores funcionales`
`ducky`	`o bugs`
`ducky`	`si este driver/controlador se compilara "incrustado" o ligado a la imagen binaria de arranque`
`ducky`	`el sistema se colgaria apenas arranque`
`ducky`	`bueno ahora veamos algunas caracteristicas de los modulos`
`ducky`	`- no todo puede ser modular`
`ducky`	`en los ultimos tiempos. gran parte del kernel es modular, pero hay ciertas cosas que no lo pueden ser`
`ducky`	`por ejemplo algunas funciones basicas de TCP/IP`
`ducky`	`- son parte del kernel`
`ducky`	`tienen libertad de ejecucion en el sistema, por que como ya dije anteriormente corren en modo protegido (ring 0)`
`ducky`	`ya que es parte del Linux kernel, se compilan junto con el kernel`
`ducky`	`a traves del comando`
`ducky`	`make`
`ducky`	`ese comando..compila la imagen de arranque (/boot/vmlinuz) y sus respectivos modulos`
`ducky`	`una vez hecho esto instalamos los modulos en el sistema a traves del comando`
`ducky`	`make modules_install`
`ducky`	`todo esto obiavemente dentro de nuestro arbol de fuentes del kernel linux`
`ducky`	`que usualmente se encuentra en /usr/src/linux`
`ducky`	`bueno pasemos a la diapositiva 10`
`ducky`	`aplicaciones para el manejo de modulos`
`ducky`	`la carga de un modulo se hace a traves del comando`
`ducky`	`insmod`
`ducky`	`su sintaxis es`
`ducky`	`insmod nombre_del_modulo`
`ducky`	`ejemplo`
`ducky`	`insmod sis900.ko`
`ducky`	`a traves de este comando podremos cargar el driver de mi tarjeta de red`
`ducky`	`en el kernel y poder usar toda la funcionalidad que este nos brinda`
`ducky`	`tambien este comando recibe parametros`
`ducky`	`estos a veces son opcionales`
`ducky`	`insmod sis900.ko [parametros]`
`ducky`	`obiamente podremos hacer esto si previamente hemos compilado el controlador para que sea modular`
`ducky`	`Remocion`
`ducky`	`rmmod`
`ducky`	`su sintaxis es`
`ducky`	`rmmod nombre_modulo`
`ducky`	`a traves de este podremos descargar del kernel el modulo requerido`
`ducky`	`cuando ya no sea necesario`
`ducky`	`Listar modulos`
`ducky`	`se hace a traves del comando`
`ducky`	`lsmod`
`ducky`	`este comando es bastante util ya que nos muestra que modulos estan actualmente cargados en nuestro kernel ademas de algunos otros datos, tales como si tiene dependencias, y si se puede descargar`
`ducky`	`Module Size Used by slamr 373444 2 i810_audio 32788 1 ac97_codec 16652 1 i810_audio sis900 17156 0 ide_scsi 13700 0`
`ducky`	`perdon..`
`ducky`	`Module Size Used by`
`ducky`	`slamr 373444 2`
`ducky`	`i810_audio 32788 1`
`ducky`	`ac97_codec 16652 1 i810_audio`
`ducky`	`sis900 17156 0`
`ducky`	`esa es la salida tipica del comando lsmod`
`ducky`	`para este ejemplo`
`ducky`	`podemos ver que actualmente tengo cargados 4 modulos`
`ducky`	`y aqui hay algo importante que notar`
`ducky`	`la dependencia entre modulos`
`ducky`	`esta ocurre cuando un modulo es dependiente de otro para poderse cargar`
`ducky`	`aqui podemos apreciar que el modulo la tarjeta de sonido i810_audio`
`ducky`	`es dependiente del modulo`
`ducky`	`ac97_codec, esto significa que si no cargamos este modulo, no podremos, cargar el modulo i810_audio`
`ducky`	`y es aqui donde entra en juego un programa importante`
`ducky`	`modprobe`
`ducky`	`este nos permite hacer una carga con resolucion de dependencias entre modulos`
`ducky`	`la sintaxis es`
`ducky`	`modprobe nombre_modulo`
`ducky`	`entonces para el ejemplo anterior`
`ducky`	`si hacemos`
`ducky`	`modprobe i810_audio`
`ducky`	`el automaticamente ..cargará el modulo ac97_codec`
`ducky`	`ahh que pena..aclaro en el ejemplo anterior el formato de lsmod`
`ducky`	`Module Size Used by`
`ducky`	`el primero es el nombre del modulo, el siguiente es el tamano del modulo en memoria, tambien se muestra cuantos usos tiene y si tiene alguna dependencia`
`ducky`	`bueno sigamos adelante con modprobe`
`ducky`	`modprobe es especialmente necesario y util por que lo usa kmod, del cual hablaremos mas tarde`
`ducky`	`informacion acerca de modulos`
`ducky`	`modinfo`
`ducky`	`su sintaxis es`
`ducky`	`modinfo nombre_modulo`
`ducky`	`nos muestra informacion util acerca de un modulo`
`ducky`	`tales como`
`ducky`	`autor`
`ducky`	`descripcion`
`ducky`	`parametros`
`ducky`	`licencia`
`ducky`	`otros.`
`ducky`	`he aqui un ejemplo, voy a hacerle modinfo al modulo que proporciona la funcionalidad del estandar de sonido ac97_codec`
`ducky`	`modinfo ac97_codec`
`ducky`	`license: GPL`
`ducky`	`vermagic: 2.6.9-ac3 PENTIUM4 gcc-3.3`
`ducky`	`depends:`
`ducky`	`aqui podemos ver por ejemplo que es un modulo publicado bajo licencia GPL`
`ducky`	`la version del compilador y la version de kernel para la cual se compiló`
`ducky`	`y alguna dependencia del modulo [si la hubiera]`
`ducky`	`por favor pasemos a la diapositiva 14`
`ducky`	`todas estas aplicaciones para el manejo de modulos`
`ducky`	`se encuentran dentro del paquete`
`ducky`	`module-init-tools (para la serie 2.6)`
`ducky`	`modutils (para la serie 2.4->version estable anterior a la 2.6, todavia bastante usada)`
`ducky`	`Solo disponibles para el superusuario, ya que el manejo de modulos es critico dentro del sistema`
`ducky`	`y por ejemplo si un modulo tiene un hueco de seguridad el sistema completo se verá comprometido`
`ducky`	`[diapositiva 15]`
`ducky`	`aqui encontramos las opciones básicas necesarias para que nuestro kernel linux`
`ducky`	`tenga soporte a modulos`
`ducky`	`CONFIG_MODULES=y`
`ducky`	`Habilita el soporte para módulos cargables`
`ducky`	`CONFIG_KMOD=y`
`ducky`	`Habilita la carga inteligente de módulos`
`ducky`	`Kmod es el cargador de módulos del Kernel, inteligente ya que permite que un módulo se cargue solo cuando se necesite y de forma automática y con resolución de dependencias, sin ninguna intervención del superusuario, carga y descarga módulos según sea necesario, llamando directamente a modprobe y rmmod`
`ducky`	`kmod es bastante inteligente`
`ducky`	`ya que por ejemplo si aun no tengo cargado el driver de mi tarjeta de red`
`ducky`	`y se hace un ifconfig eth0 192.168.0.1`
`ducky`	`el previamente..antes de realizar el ifconfig, kmod llama a modprobe ..y este ultimo carga el controlador de la tarjeta`
`ducky`	`de red`
`ducky`	`ese ifconfig...llevaria por debajo..un modprobe sis900, sin que el usuario administrador lo note`
`ducky`	`bueno ya casi para terminar`
`ducky`	`mostrare dos funciones a nivel de programación que tienen los modulos`
`ducky`	`un módulo SIEMPRE contendrá este par de funciones`
`ducky`	`1."module_init", se ejecuta al momento que se hace insmod`
`ducky`	`2."module_exit", se ejecuta al momento que se hace rmmod`
`ducky`	`y se implementan de la siguiente forma`
`ducky`	`module_init(nombre_de_la_funcion_de_entrada)`
`ducky`	`module_exit(nombre_de_la_funcion_de_salida)`
`ducky`	`cabe anotar que un módulo no posee funcion main()`
`ducky`	`y ahora ..por ultimo en veamos un ejemplo codigo fuente de un modulo hola mundo`
`<linux/module.h`	`/* Necesario para todos modulos */`
`<linux/init.h`	`/* Necesario para module_init y module_exit */`
`<linux/kernel.h`	`/* Necesario para KERN_ALERT */`
`ducky`	`MODULE_LICENSE("GPL");`
`ducky`	`static int hola_init(void)`
`ducky`	`{`
`ducky`	`printk(KERN_ALERT "Hola mundo\n");`
`ducky`	`}`
`ducky`	`static void hola_exit(void)`
`ducky`	`{`
`ducky`	`printk(KERN_ALERT "Adios, kernel\n");`
`ducky`	`}`
`ducky`	`module_init(hola_init);`
`ducky`	`module_exit(hola_exit);`
`ducky`	`bueno ese ejemplo era para que se llevaran una minima idea acerca del codigo fuente de un modulo cargable en Linux`
`ducky`	`finalmente pasemos a las Conclusiones de esta charla`
`ducky`	`Linux es un kernel modular`
`ducky`	`Los módulos cargables son piezas de código que extieden la funcionalidad del Linux kernel y se insertan/remueven en tiempo de ejecución (en caliente)`
`ducky`	`Los módulos cargables corren en espacio de Kernel en modo protegido (ring 0)`
`ducky`	`Referencias`
`ducky`	`KernelAnalysis-HOWTO`
`ducky`	`Module-HOWTO`
`ducky`	`Kernelnewbies español/ingles`
`ducky`	`Gracias por su atención :), y espero que esta charla haya sido de su agrado`
`ducky`	`preguntas :_`
`ducky`	`?`
`ducky`	`muchas gracias a todos`
`sarnold`	`gracias por las presencion ducky :)`
`ducky`	`espero gustosamente sus preguntas`
`ducky`	`thanks a lot sarnold`
`Dec 22 00:06:51 ---bio.hgy.es gives channel operator status to fernand0`
`Dec 22 00:06:56 ---fernand0 sets mode -m #linux`
`sarnold`	`plas plas plas plas plas :)`
`fernand0`	`plas plas plas plas plas plas plas plas plas`
`fernand0`	`plas plas plas plas plas plas plas plas plas`
`fernand0`	`plas plas plas plas plas plas plas plas plas`
`fernand0`	`plas plas plas plas plas plas plas plas plas`
`fernand0`	`plas plas plas plas plas plas plas plas plas`
`azulema`	`muchas gracias, buenas noches`
`urkonn`	`plas plas plas plas plas plas`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`samx`	`el amigo ducky`
`samx`	`queria preguntarle`
`ducky`	`bueno espero les haya gustado, no soy un experto en cuestion de kernel linux, pero gustosamente, resolveria las dudas que esten a mi alcanze`
`javierf`	`plas plas plas plas plas plas`
`ducky`	`dime samx`
`samx`	`Como puedo detectar si existe un hueco en algunos de los modulos de mi kernel`
`samx`	`osea un hueco de seguridad`
`ducky`	`pues eso esta directamente relacionado con funciones del modulo`
`smoke`	`perdon en lo q me levante esto termino :P`
`ducky`	`o tambien puede que el hueco se encuetre en otra parte del kernel, y este modulo se aproveche de ello`
`ducky`	`aqui el companero trulux`
`ducky`	`complementa`
`krocz`	`smoke la unica forma es auditando el codigo`
`trulux`	`ducky, copia desde #@c ;D`
`krocz`	`no existe una manera uniforme para detectar bug en los modulos`
`trulux`	`<<ducky> Los módulos cargables corren en espacio de Kernel en modo protegido (ring 0)`
`trulux`	`<trulux> ducky, hay un problema aún no solventado y que es grave: la infección de módulos del kernel, interponiendo las llamadas init_module para cargar código arbitrario`
`trulux`	`<trulux> el problema es que esto aún no está siendo estudiado en términos de protección`
`trulux`	`<trulux> acabo de terminar unos tests de infección de LKM's en 2.6`
`krocz`	`si fuera asi el trabajo de los expertos en seguridad seria muy simple :)`
`smoke`	`clap clap clap clap clap clap clap clap clap clap clap clap clap clap clap clap clap clap clap clap`
`smoke`	`gracias krocz ;)`
`trulux`	`samx, que tipo de hueco?`
`trulux`	`preguntale a los kernel janitors ;D`
`trulux`	`(risas)`
`krocz`	`jaja`
`trulux`	`bueno, pues contaba en el otro canal lo siguiente`
`trulux`	`los módulos del kernel no poseen tests de integridad por sí solos`
`fernand0`	`pues entonces no es muy dificil`
`fernand0`	`ops`
`fernand0`	`sorry`
`trulux`	`por lo cual, se pueden "atacar" de manera practicamente limpia:`
`krocz`	`trulux la infeccion`
`trulux`	`(cambiando las cabecras que le dicen dónde encontrar el código de init_module)`
`krocz`	`en modulos de kernel`
`trulux`	`krocz, si:`
`krocz`	`al pareciera no esta funcional en 2.6`
`trulux`	`en 2.6:`
`krocz`	`lo que se hacia en 2.4`
`krocz`	`era interceptar las syscall`
`trulux`	`pues yo la tengo en 2.6`
`trulux`	`krocz, no en runtime todavía`
`krocz`	`trulux quizas en runtime`
`krocz`	`seria analizar la estructura de /dev/kmen`
`krocz`	`a si se hacia en runtime`
`trulux`	`krocz, con un kernel de hardened dbeian por ejemplo el raw access al kmemn sería imposible`
`trulux`	`collision hace un test regresivo contra el kmem`
`fernand0`	`hasta mañana!`
`ducky`	`bueno senores muchas gracias por todo, espero haya sido de su agrado la charla. dudas/sugerencias al mail felipe@noslave.net`
`ducky`	`hasta pronto`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`ducky`	`gracias`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`fernand0`	`plas plas plas plas`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`trulux`	`ducky, mi email es lorenzo@gnu.org, si quieres nos ponemos en contacto para probar algo`
`smoke`	`clap clap clap clap clap clap clap clap clap clap`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`smoke`	`clap clap clap clap clap clap clap clap clap clap`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`smoke`	`clap clap clap clap clap clap clap clap clap clap`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`smoke`	`clap clap clap clap clap clap clap clap clap clap`
`smoke`	`clap clap clap clap clap clap clap clap clap clap`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`smoke`	`clap clap clap clap clap clap clap clap clap clap`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`smoke`	`clap clap clap clap clap clap clap clap clap clap`
`trulux`	`CLA CLAA CLAAA CLAAAAAAP`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`ducky`	`visiten es.kernelnewbies.org`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`fernand0`	`gracias ducky!`
`MJesus`	`clap clap clap clap clap clap clap clap clap clap`
`trulux`	`a todo esto, orcero está por aquí?`

Generated by irclog2html.pl by Jeff Waugh - find it at freshmeat.net!

The Organizing Comittee

Email Us More information