STRACE COMO HERRAMIENTA DE SEGURIDAD EN LINUX Boris Alejandro Hurtado Sáenz Asesora Sandra Julieta Rueda Rodríguez, Ph.D. Profesora Asistente Universidad de Los Andes Facultad de Ingeniería Departamento de Ingeniería de Sistemas y Computación Bogotá, 2017
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
STRACE COMO HERRAMIENTA DE SEGURIDAD EN LINUX
Boris Alejandro Hurtado Sáenz
Asesora
Sandra Julieta Rueda Rodríguez, Ph.D.
Profesora Asistente
Universidad de Los Andes
Facultad de Ingeniería
Departamento de Ingeniería de Sistemas y Computación
Figura 1 Llamadas al sistema en Linux. ..................................................................................................................................... 10 Figura 2. Análisis dinámico. ............................................................................................................................................................. 12 Figura 3. Strace dentro del contexto de Linux. ........................................................................................................................ 14 Figura 4. Rastreo de un proceso por medio de Strace. ........................................................................................................ 15 Figura 5 Entorno de una máquina virtual. ............................................................................................................................... 16 Figura 6. Chequeo de instalación y versión de Strace .......................................................................................................... 17 Figura 7. Instalación de Strace. ...................................................................................................................................................... 18 Figura 8. Script que imprime una línea en consola. .............................................................................................................. 20 Figura 9. Archivo ejecutable .sh que imprime en consola. .................................................................................................. 21 Figura 10. Código del programa en C .......................................................................................................................................... 21 Figura 11. Información Strace sobre el programa. ............................................................................................................... 22 Figura 12. Información sobre las llamadas al sistema que realiza el programa. .................................................... 22 Figura 13. Programa que trata de hacer bufferoverflow. .................................................................................................. 24 Figura 14. Programa que trata de hacer bufferoverflow: ejecución correcta y con la que lo produce .......... 25 Figura 15. Ejecución del programa con Strace. ...................................................................................................................... 25 Figura 16. Programa monitoreado con Strace cuando no se produce el bufferoverflow ..................................... 26 Figura 17. Programa monitoreado con Strace cuando se produce el bufferoverflow. .......................................... 26 Figura 18. Código del programa que lee un archivo y retorna la primera línea ...................................................... 27 Figura 19. Ejecución del programa. ............................................................................................................................................. 27 Figura 20. Ejecución del programa monitoreado por Strace .......................................................................................... 28 Figura 21. Lista de llamadas al sistema que genera el programa .................................................................................. 28
4
RESUMEN
Los sistemas operativos son software especial que manejan y controlan todas las funciones
de un computador, por esta razón son objetivos de variados ataques informáticos. Con el fin
de mitigar estos ataques existe la seguridad informática.
Una de las tareas de la seguridad informática es intentar garantizar que un software es
benigno. Para esto, hay dos maneras de analizar software; análisis dinámico y análisis
estático. El análisis dinámico evalúa el código de un programa y los distintos escenarios en
los que se puede encontrar el programa. El análisis estático, evalúa el comportamiento del
programa mientras se encuentra en ejecución.
En el caso específico de los sistemas operativos Linux, hay una gran variedad de software
para fortalecer la seguridad informática. Para este proyecto se va a hacer énfasis en una
herramienta proporcionada por Linux llamada Strace. Esto se debe a que Strace permite
monitorear todos los recursos que un software le pide al sistema operativo mientras se está
ejecutando, debido a la información que proporciona Strace un usuario es capaz de conocer
cómo actúa el software y qué recursos usa durante su ejecución.
En este proyecto se usará esta herramienta que realiza análisis dinámico sobre el software
que está siendo ejecutado. Lo anterior con el fin de evaluar el comportamiento de software y
determinar si es benigno o malicioso.
Al realizar la implementación del proyecto se espera poder entender qué tipo de llamadas
realiza un programa o software benigno y qué tipo de llamadas realiza un software malicioso.
Con la información obtenida se realizará una clasificación o perfilamiento de los programas
en las dos categorías anteriormente mencionadas.
Este proyecto permite entender cómo funciona Strace. Asimismo, se logró usar Strace cómo
una herramienta de seguridad informática que tiene como fin evaluar software mientras se
está ejecutando. Gracias a la información que proporciona Strace es posible entonces crear
perfiles de software en los que se distingue entre software benigno y malicioso.
5
1. INTRODUCCIÓN
Los sistemas operativos son software que se encargan de manejar los recursos de hardware
y software de la máquina con el fin de proveer servicios para os usuarios o procesos que
corren en nombre de dichos usuarios. Esto quiere decir que todos los programas o software
necesitan un sistema operativo para funcionar. Otra forma de expresar lo anterior es decir
que el sistema operativo controla lo que pasa en un computador.
Existen varios Sistemas Operativos, entre los que se encuentra Linux, un sistema operativo
de núcleo Unix de código abierto publicado en 1991. Linux fue creado por Linus Torvalds
debido a que trabajaba con Minix, un sistema operativo Unix-like (que se comporta
similarmente a Unix) que no era gratuito. Torvalds empezó a escribir el kernel para publicar
la versión 0.11 bajo una licencia freeware, más adelante publicaría la versión 0.12 bajo la
Licencia Pública General de GNU. Linux fue creado para dar a las personas acceso a un
sistema UNIX-like de modo gratuito. (LivingInternet, s.f.)
Desde su publicación la utilización de Linux ha venido en aumento, “Según estadísticas de
Market Share en su informe mensual sobre el uso de sistemas operativos, Linux por primera
vez en la historia ocupa 1% del ocupando el tercer lugar en el mercado de los sistemas
operativos” (Lainx, 2009). Para cifras más recientes se puede tener en cuenta el artículo
publicado en la página muycomputer, “NetMarketShare le da a Linux un 4,83% de cuota de
mercado en PC, correspondiente a septiembre de 2017” (Poymerol, 2017).
Por lo tanto, el manejo de la seguridad en sistemas Linux es un problema que concierne cada
vez a más usuarios. Por esta razón, se han desarrollado con el paso del tiempo varias
herramientas para manejar la seguridad en estos sistemas operativos. Algunos ejemplos son:
• Nmap, que realiza una detección de los servicios que presta cierta red y los equipos
que se encuentran en dicha red. (Marnigroedu, 2010).
• ClamAv, que es un antivirus gratis para Linux.
• Snort, que cumple con la detección de intrusos en una red, detecta ataques y posible
escaneo de puertos. (Marnigroedu, 2010).
• CHKrootkit que “es un Unix-programa basado en la intención de ayudar a los
administradores de sistemas controlar su sistema de rootkits conocidos. Se trata de
un script de shell utilizando UNIX / Linux herramientas como las cuerdas y los
6
comandos grep para buscar programas del sistema básico de firmas y para la
comparación de un recorrido de los archivos / proc con la salida de la PS (estado de
proceso) para buscar discrepancias” (Marnigroedu, 2010).
El problema es que no todas las herramientas se enfocan en revisar el software que está
instalado en la máquina. Por lo tanto, un usuario puede instalar software en su máquina sin
que alguna herramienta detecte si es benigno o malicioso. Existen herramientas que hacen
esto a través de análisis dinámico y análisis estático. Ambos tipos de análisis tienen sus
respectivas ventajas y desventajas, en el apartado de análisis de software se discutirá este
tema y se explicará por qué se escogió Strace cómo herramienta de trabajo.
Strace es una herramienta de análisis dinámico. De hecho, se han creado herramientas que
realizan una función similar a la de Strace, las herramientas de análisis dinámico permiten al
usuario conocer de qué manera se comporta un software en ejecución y qué servicios solicita
al sistema operativo. Strace cumple los requerimientos que se esperan solucionar; hacer uso
de una herramienta de análisis dinámico para evaluar distintos tipos de software, clasificar el
software entre benigno y malicioso, utilizar los filtros que proporciona Strace para acceder a
información específica sobre el comportamiento del software.
7
2. DESCRIPCIÓN DEL PROBLEMA
La seguridad informática tiene como objetivo proteger los datos de las personas, los datos
que atraviesan distintas redes y las infraestructuras computacionales. En otras palabras, es el
área encargada de minimizar los riesgos para los usuarios y empresas en cuestiones de
tecnologías de la información. Para lograr este objetivo, la seguridad informática debe
disponer de distintas herramientas que permitan evaluar las amenazas que se presentan contra
sus sistemas con el fin de evitar los riesgos que se derivan de dichas amenazas. “Para que las
empresas puedan utilizar las tecnologías de la información y las comunicaciones con
garantías es necesario disponer de guías, métricas y herramientas que les permitan conocer
en cada momento su nivel de seguridad y las vulnerabilidades que aún no han sido cubiertas”
El análisis dinámico se realiza al ejecutar un programa, observar la manera en la que se
ejecuta y qué recursos le pide al sistema operativo. Bajo este tipo de análisis, se puede
observar cómo se ejecuta el programa, que flujos de control son tomados. La ventaja de este
tipo de análisis es que “Hay poca o ninguna incertidumbre sobre los flujos de control que se
tomaron, qué valores fueron computados, qué cantidad de memoria fue consumida, qué tanto
se demoró el programa en ejecutarse” (Ernst, 2003) De igual forma, los análisis dinámicos
pueden ser tan rápidos como la ejecución del programa.
3.2.1.1. DESVENTAJAS DEL ANÁLISIS DINÁMICO.
La desventaja principal es que este análisis es realizado sobre una ejecución específica, esto
significa que se tiene en cuenta únicamente las variables que el programa usó en esa
ejecución. Es decir, a medida que las variables de ejecución cambien, la ejecución del
programa va a tomar otro rumbo. Un ejemplo podría ser los flujos de control que toma el
programa si un campo de texto recibe letras o valores numéricos. Lo anterior muestra que
cuando se realiza un análisis estático, los resultados no se pueden generalizar para todas las
ejecuciones de software.
3.2.1.2. CONSTRUCCIÓN ADECUADA DEL ANÁLISIS DINÁMICO
Dado que el análisis dinámico tiene en cuenta los valores de la ejecución en el momento, “el
reto principal de construir análisis dinámicos es seleccionar una buena función de
abstracción, el reto principal de realizar un buen análisis dinámico es seleccionar un conjunto
representativo de casos (entradas del programa que está siendo analizado” (Ernst, 2003). En
el artículo de Michael Ernst también se menciona que dependiendo de la calidad de las
pruebas se puede obtener información relevante sobre el programa o sobre las pruebas como
tal, por ende, es necesario crear pruebas que de alguna forma traten de generalizar la manera
en la que se va a ejecutar el programa.
3.2.2. ANÁLISIS ESTÁTICO
Este tipo de análisis evalúa el código de un software y trata de determinar todos los posibles
escenarios de ejecución del programa. Generalmente, este tipo de análisis son más seguros
ya que tratan de inferir los posibles caminos que va a tomar el programa al ejecutarse, esto
se logra “construyendo modelos del estado del programa, y determinando los estados posibles
a alcanzar por el programa. No obstante, debido a que existen múltiples posibilidades de
ejecución, se opta por construir un modelo abstracto del programa” (Becerra, 2015). Este
12
análisis entonces crea un modelo de ejecución del programa y ejecuta en ambientes seguros
el programa para ver o determinar su comportamiento. En la figura dos (2) se puede apreciar
cual es el proceso que se debe seguir para realizar un análisis estático exitosamente, de estos
cinco pasos, probablemente el más importante es el de crear un modelo abstracto adecuado
que permita simular los futuros estados en los que se pueda encontrar el software.
Figura 2. Análisis dinámico. Tomado de: http://www.verifysoft.com/en_grammatech_how_static_analysis_works.html
3.2.2.1. DESVENTAJAS DEL ANÁLISIS ESTÁTICO.
Dado que existen varios estados en los que se puede encontrar el programa, el análisis debe
mantener monitoreado todos estos posibles estados. Por lo tanto, la tarea de crear modelos
abstractos que traten de contener todos los posibles escenarios se dificulta, además el tiempo
de ejecución de estos análisis puede llegar a ser muy amplio, razón por la cual el tiempo
también debería ser un motivo de preocupación a la hora de construir estos análisis.
3.2.2.2. CONSTRUCCIÓN ADECUADA DEL ANÁLISIS ESTÁTICO.
En principio, se debería crear un modelo que logre comprender los posibles estados de un
programa sin que sea muy pesado al momento de ejecutarse, para esto, se podría poner
restricciones en los retornos de las funciones o del software analizado.
3.2.3. ANÁLISIS DINÁMICO VS ANÁLISIS ESTÁTICO
Cada tipo de análisis tiene sus fortalezas y desventajas. Por una parte, el análisis estático
prueba el código del software antes de que se ejecute y por la otra, el análisis dinámico prueba
13
el software mientras se está ejecutando. Para el proyecto cómo tal se escogió el análisis
dinámico dado que se quería ver cómo era la interacción de un programa en ejecución con el
Kernel de Linux, qué recursos pedía y que acciones tomaba. Todo lo anterior mientras se
ejecutaba un programa específico.
3.3. STRACE
“Escrito originalmente por Paul Kranenburg para el sistema operativo Sun, fue inspirado por
su funcionalidad de rastreo. Se hizo un puerto para Linux y fue mejorada por Branko
Lankester, quién también escribió el soporte para el kernel de Linux” (Linux.die, s.f.).
Se trata de una herramienta de análisis dinámico que permite monitorear las llamadas al
sistema y las señales que se reciben. Por medio de Strace, es posible ver cómo interactúa un
programa con el kernel de Linux y todas las llamadas al sistema que este realiza.
Generalmente Strace se usa para ver qué problemas presenta un programa desde el momento
que se ejecuta, es decir, puede utilizarse como una herramienta de debugging. La figura 3
muestra cómo funciona Strace en el contexto de Linux, la herramienta se encarga de
monitorear el tráfico que pasa por la interfaz de llamadas al sistema, debido a esto Strace es
capaz de obtener información de las llamadas que realiza un software específico. No obstante,
la función más importante de Strace es monitorear las llamadas al sistema, por esta razón, se
trata también de una herramienta útil que permite entender las interacciones de un programa
con el usuario y el Kernel. Asimismo, permite observar i un programa realiza las acciones
adecuadas o las acciones para las que fue creado. Otra función de Strace es que permite
rastrear procesos, como se puede observar en la figura 4, en la cual se muestra cómo Strace
se adhiere a un proceso con el fin de obtener toda la información relevante que luego podrá
ser observada a través de los reportes que proporciona la herramienta. Strace puede
monitorear procesos específicos de un programa por medio de los filtros, de los cuales se
hablará en el apartado de evaluación. Para que Strace pueda monitorear las llamadas al
sistema debe hacer uso de una llamada al sistema ptrace. Esta llamada al sistema puede ser
usada por los programas para rastrear otras llamadas al sistema, leer y escribir registros y
manipular la entrega de señales a los procesos monitoreados. La llamada al sistema ptrace
puede ir acompañada de distintos “flags” entre ellos se encuentran PTRACE_ATTACH que
se encarga de suministrar el ID del proceso monitoreado. Luego se usa el flag
PTRACE_SYSCALL, que permite inspeccionar los argumentos de las llamadas al sistema y
14
obtener información relevante sobre el proceso y las llamadas al sistema que realiza
(packagecloud, 2016).
Figura 3. Strace dentro del contexto de Linux. En esta figura se puede ver de qué manera Strace es capaz de monitorear las llamadas al sistema, toma la información directamente de la interfaz de llamadas al sistema de Linux. Tomado de:
Figura 4. Rastreo de un proceso por medio de Strace. En esta figura se puede apreciar el monitoreo que hace la herramienta a un proceso específico, igual que en la figura 3, Strace realiza esta acción a través de la interfaz de
llamadas al sistema. Tomado de: https://sysdig.com/blog/sysdig-vs-dtrace-vs-strace-a-technical-discussion/
4. PROPUESTA DE SOLUCIÓN
Con todas las definiciones explicadas anteriormente es posible entonces crear una solución
para el problema planteado que trata sobre la seguridad informática y de cómo saber si un
software es benigno o malicioso.
La propuesta para detectar si un programa es malicioso o benigno consiste entonces en hacer
uso de la herramienta Strace para conocer qué llamadas al sistema se hacen. En la sección de
trabajos relacionados se explicará por qué se decidió usar Strace como herramienta del
proyecto. Así, con base en los resultados que provee la Strace se podrá ver si un programa
actúa adecuadamente, es decir, como se supone que debería hacerlo.
A partir de los resultados, se podrá especificar cuál es la diferencia entre los programas que
actúan adecuadamente y los programas que realizan acciones maliciosas, entiéndase acciones
maliciosas cómo accesos a información sensible, modificación de datos sin el permiso del
usuario, etc. Con estás especificaciones se podrá crear perfiles para los programas benignos
y perfiles para los programas maliciosos y de esta manera entender qué tienen en común los
programas maliciosos y de qué forma puede un usuario prevenir instalar este software en su
computador.
4.1. DISEÑO DE LA SOLUCIÓN
Para la solución, se decidió instalar una máquina virtual con sistema operativo versión Linux
16.04.3 que se ejecutase sobre el software VirtualBox y soportara Strace. Las
especificaciones de la máquina virtual son las siguientes:
• Sistema operativo: Linux v. 16.04.3
• Memoria RAM: 4GB
• El procesador de la máquina real: Intel ® Core ™ i7-4500U CPU @ 1.80 GHz 2.40
GHz
Con El sistema operativo instalado, se revisó que efectivamente Strace estuviese instalado
para empezar a realizar las pruebas sobre software real. Para este proyecto se usarán Scripts
escritos por el autor y programas en C escritos también por el autor así como ejemplos de