ecnolÓgico y d e estudios superiores de monterreyhomepage.cem.itesm.mx/raulm/theses/kgarcia.pdf ·...
TRANSCRIPT
INST
TITUTO T
DETECCOM
TECNOLÓ
CCIÓN DPUTAD
L
KAREN
Aseso Comi
DOCTORA
ÓGICO Y D
DE INTRDORA ANLLAMA
PROP
N AZUR
or:
ité de Tesis:
ADO EN C
DI
DE ESTUD
RUSIONNALIZADAS AL
PUESTA DPRESENT
RIM GA
DR. R
DRA.DR. DR. DR. DR.
CIENCIAS
CIEMBRE
IOS SUPE
NES FORANDO BL SISTE
DE TESIS TA
ARCÍA G
RAÚL MON
. NORA ERI LUIS ENRI JORGE CA LUIS ÁNG RAÚL MO
COMPUT
E, 2010
ERIORES D
RENSE BITÁCOMA
GAMBO
NROY BORJA
IKA SÁNCHIQUE SUCA
ARLOS MEXGEL TREJO RONROY BOR
TACIONAL
DE MONTE
A NIVEORAS DE
OA
A
HEZ VELÁZAR SUCCARX PERERA RODRÍGUE
RJA
LES
ERREY
EL E
ZQUEZ R
EZ
2
PUBLICACIONES Los resultados de esta tesis han sido pre-aprobados por 2010 International Conference on Information Security and Artificial Intelligence (ISAI 2010).
3
RESUMEN El cómputo forense consiste en examinar y explicar el estado actual de un sistema después
de una posible intrusión proveyendo evidencia legal extraída de la información analizada.
Con el cómputo forense es posible determinar cómo un atacante logró acceder a los
recursos de un sistema y cuáles fueron sus acciones de daño posteriores.
Investigaciones recientes han puesto sus esfuerzos en encontrar metodologías y desarrollar
mecanismos adecuados para la realización óptima del análisis forense en sistemas de
Tecnologías de Información. Los resultados han sido satisfactorios, sin embargo ningún
trabajo ha sido suficiente y continúa el tema de investigación abierto para mejorar las
metodologías que son aplicadas en la actualidad.
El objetivo de esta investigación es desarrollar una metodología de cómputo forense basada
en el análisis de bitácoras de llamadas al sistema capaz de determinar si un sistema ha sido
atacado, así como identificar los eventos que el atacante realizó para llevar a cabo su
objetivo. Estos eventos corresponden a la ejecución de ciertas aplicaciones o programas en
el equipo de cómputo. Sin embargo, resolver este problema no es una tarea sencilla debido
a las grandes cantidades de datos que son generados en un sistema.
En esta investigación partimos de la premisa de que dentro de una computadora un atacante
generalmente corre un programa llamado exploit, el cual toma ventaja de alguna
vulnerabilidad del sistema operativo o una aplicación causando un comportamiento no
autorizado y mal intencionado cuyas consecuencias normalmente repercuten en pérdidas
monetarias y/o de información delicada para las víctimas o los poseedores de esos equipos
y esa información.
La propuesta que se presenta en este documento se interesa en localizar la ejecución de
dicho exploit y se sustenta en el hecho de que la ejecución de cualquier programa es
registrado mediante llamadas al sistema en una bitácora del sistema. De esta forma
contamos con un registro de todas las llamadas al sistema que ejecutan en un equipo de
4
cómputo, siendo las más comunes aquellas pertenecientes a las aplicaciones que son usadas
más frecuentemente en dicho sistema, de tal suerte que cuando un exploit es ejecutado se
hace posible identificarlo mediante las llamadas al sistema que éste genera, ya que difieren
de aquellas invocadas normalmente por procesos y/o aplicaciones usuales.
Para localizar la ejecución de un exploit en una bitácora de llamadas al sistema proponemos
el uso de una metodología implementada de diferentes formas las cuales consisten en el uso
de diversas técnicas probabilísticas, de agrupamiento y clasificación con el fin de modelar
el comportamiento usual en una computadora y con base en éste, identificar el momento en
que sucedió el ataque. Para hacer la información más tratable, proponemos el uso de
Sequitur, un algoritmo que elimina información redundante mejorando la detección de
intrusiones ya que captura aspectos temporales de las bitácoras. Lo anterior mediante la
creación de reglas, las cuales contienen un conjunto de llamadas al sistema que se repiten
más de dos veces en una bitácora.
En este documento se presentan los experimentos realizados y los resultados obtenidos en
el uso de la metodología propuesta. Los experimentos consistieron en una comparación del
porcentaje de detección y de falsas alarmas entre el uso de diversos métodos como media,
diagramas de caja, K-medias en línea, matriz de factorización no negativa y modelos
ocultos de Markov, este último método usado en conjunto con k-medias, aplicados sobre la
metodología propuesta. También se comparó el tiempo que tarda cada uno de los métodos
en completarse. Los resultados obtenidos muestran una superioridad de HMM con k-
medias sobre los demás métodos, seguido por los métodos de análisis probabilístico simple
y con el menor desempeño k-medias en línea y la matriz de factorización no negativa.
En este documento se presentan los experimentos realizados y los resultados obtenidos del
uso de la metodología propuesta. Este trabajo destaca los resultados obtenidos por métodos
de análisis probabilístico simple tales como media y diagramas de caja, sobre métodos de
agrupamiento y clasificación como K-medias en línea, matriz de factorización no negativa
y modelos ocultos de Markov, este último combinado con K-medias para mejorar su
resultado. Nuestros experimentos consistieron en comparar cada uno de esos métodos
5
respecto a su porcentaje de detección y su porcentaje de falsas alarmas. Además, se llevó a
cabo una comparación del tiempo que tarda cada uno de los métodos en ejecutarse con cada
uno de los experimentos realizados. Nuestros principales resultados destacan una
superioridad de HMM con k-medias sobre los demás métodos, seguido por los métodos de
análisis probabilístico simple; por otro lado, los métodos con menor desempeño fueron k-
medias en línea y la matriz de factorización no negativa.
La investigación que presentamos no sólo tiene aportación en el área de detección de
intrusiones forense. Otra aportación se encuentra en el área de detección de intrusos basada
en mal uso, en cuyo caso se requiere del uso de firmas de ataque. Estas firmas de ataque
pueden ser fácilmente construidas a partir de la evidencia que un ataque ha dejado dentro
de una bitácora de llamadas al sistema.
La simplicidad de las metodologías presentadas y los buenos resultados obtenidos con las
mismas hacen de estas técnicas una buena forma de detectar en tiempo razonable y de
manera confiable si ha habido un ataque, y su posición en una bitácora de llamadas al
sistema.
6
ÍNDICE DE FIGURAS Figura 1 CLASIFICACIÓN GENERAL DE UN SISTEMA DE DETECCIÓN DE INTRUSIONES. .... 22 Figura 2 EJEMPLO DE ESTRUCTURAS DE ÁRBOLES DE LAS SECUENCIAS DE LLAMADAS AL SISTEMA. ............................................................................................................................... 26 Figura 3 GRAFO DE TRASLAPE.. .......................................................................................... 30 Figura 4 EJEMPLO DE UN DIAGRAMA DE CAJA. ............................................................ 42 Figura 5 ARQUITECTURA GENERAL DE UN HMM. ......................................................... 48 Figura 6 ELEMENTOS DE UN HMM.. ................................................................................ 48 Figura 7 FRAGMENTO DE UNA BITÁCORA DE LLAMADAS AL SISTEMA. ................... 55 Figura 8 PRIMER PROCESO: CONSTRUCCIÓN DEL MODELO DE HISTORIAL. ............. 56 Figura 9 SEGUNDO PROCESO: CONSTRUCCIÓN DEL MODELO DE LA BITÁCORA DE VALIDACIÓN. ...................................................................................................................... 57 Figura 10 TERCER PROCESO: DETECCIÓN DE INTRUSIONES. ...................................... 58 Figura 11 EJEMPLO DE LA ÚLTIMA ETAPA EN EL PROCESO DE DETECCIÓN DE INTRUSIONES. ..................................................................................................................... 65 Figura 12 SALIDA DEL ALGORITMO SUBSTRACTIVE CLUSTERING. .............................. 81 Figura 13 DIAGRAMA DEL PROCESO USADO EN LA EXTRACCIÓN DE ESTADOS DE UN HMM. ............................................................................................................................. 82
7
ÍNDICE DE TABLAS Tabla 1 EJEMPLO DEL FUNCIONAMIENTO DE SEQUITUR. ............................................ 40 Tabla 2 GENERACIÓN DE BITÁCORAS PARA LA CONSTRUCCIÓN DEL MODELO DEL HISTORIAL. .......................................................................................................................... 68 Tabla 3 BITÁCORAS DE LLAMADAS AL SISTEMA GENERADAS. .................................. 68 Tabla 4 GENERACIÓN DE LAS BITÁCORAS DE VALIDACIÓN. ...................................... 69 Tabla 5 BITÁCORAS DE VALIDACIÓN. ............................................................................ 70 Tabla 6 ATAQUES USADOS EN LA ETAPA DE VALIDACIÓN DE NUESTRA EXPERIMENTACIÓN. .......................................................................................................... 70 Tabla 7 HERRAMIENTAS USADAS EN LOS MÉTODOS DE DETECCIÓN. ....................... 86 Tabla 8 VALOR ENTRÓPICO DE LAS BITÁCORAS. ....................................................... 102 Tabla 9 EJEMPLO DEL ANÁLISIS DE CALIDAD DE LAS REGLAS DE PRODUCCIÓN. . 104
8
TABLA DE CONTENIDO
RESUMEN ............................................................................................................................ 2 1 INTRODUCCIÓN ...................................................................................................... 10
1.2 ORGANIZACIÓN DEL DOCUMENTO ......................................................................... 16
2 ESTADO DEL ARTE EN DETECCIÓN DE INTRUSIONES ............................. 17
2.1 INTRODUCCIÓN ............................................................................................................ 17 2.2 SEGURIDAD COMPUTACIONAL ................................................................................ 18
2.2.1 ATAQUES COMPUTACIONALES ........................................................................ 19 2.2.2 CLASIFICACIÓN DE ATAQUES COMPUTACIONALES .................................. 20
2.3 SISTEMAS DE DETECCIÓN DE INTRUSIONES (IDS) .............................................. 21 2.4 CLASIFICACION DE LOS IDS ...................................................................................... 22 2.5 DETECCIÓN BASADA EN ANOMALÍAS .................................................................... 24
2.5.2 DETECCIÓN BASADA EN MODELOS ................................................................ 28 2.5.2.1 DISTANCIA ENTRE COMPORTAMIENTOS ............................................... 31 2.5.2.2 MODELOS DEL SISTEMA OPERATIVO ..................................................... 33
2.5.2 DETECCIÓN BASADA EN USOS INDEBIDOS ................................................... 34 2.6 SISTEMAS DE DETECCIÓN DE INTRUSIONES FORENSE ..................................... 36 2.7 CONCLUSIONES ............................................................................................................ 36
3 BLOQUES DE CONSTRUCCIÓN .......................................................................... 38
3.1 INTRODUCCIÓN ............................................................................................................ 38 3.2 MÉTODOS DE ANÁLISIS DE SECUENCIAS .............................................................. 39
3.2.1 SEQUITUR ............................................................................................................... 39 3.3 MÉTODOS DE CLASIFICACIÓN .................................................................................. 41
3.3.1 DIAGRAMAS DE CAJA ......................................................................................... 41 3.3.2 K-MEDIAS EN LÍNEA ............................................................................................ 43 3.3.3 MATRIZ DE FACTORIZACIÓN NO-NEGATIVA (NMF) ................................... 45 3.3.4 MODELOS OCULTOS DE MARKOV (HMM) ..................................................... 47
3.4 CONCLUSIONES ............................................................................................................ 52
4 METODOLOGÍA DE DETECCIÓN DE INTRUSIONES FORENSE ................ 53
4.1 INTRODUCCIÓN ............................................................................................................ 53 4.2 DESCRIPCIÓN DE LA METODOLOGÍA ...................................................................... 54
9
4.3 REDUCCIÓN DE LAS BITÁCORAS ............................................................................. 58 4.3.1 REDUCCIÓN DE LAS BITÁCORAS DEL HISTORIAL ...................................... 59 4.3.2 REDUCCIÓN DE LAS BITÁCORAS DE VALIDACIÓN ..................................... 60
4.4 SEGMENTACIÓN DE LAS BITÁCORAS REDUCIDAS ............................................. 61 4.5 CONSTRUCCIÓN DE LOS MODELOS ......................................................................... 61 4.6 DETECCIÓN DE INTRUSIONES FORENSE ................................................................ 63 4.7 CONCLUSIONES ............................................................................................................ 65
5 CONSTRUCCIÓN DE LOS MODELOS DE DETECCIÓN ................................ 66
5.1 INTRODUCCIÓN ............................................................................................................ 66 5.2 DESCRIPCIÓN DEL CONJUNTO DE DATOS ............................................................. 67
5.2.1 DATOS EN LA CONSTRUCCIÓN DEL MODELO DEL HISTORIAL ............... 67 5.2.2 DATOS EN LA CONSTRUCCIÓN DEL MODELO DE LA BITÁCORA DE
VALIDACIÓN .......................................................................................................... 68 5.3 CARACTERÍSTICAS DE LOS DATOS ......................................................................... 71 5.4 MODELOS CON DIAGRAMAS DE CAJA .................................................................... 75 5.5 MODELOS CON K-MEDIAS EN LÍNEA ...................................................................... 78 5.6 MODELOS CON NMF .................................................................................................... 79 5.7 MODELOS CON KHMM ................................................................................................ 80 5.8 CONCLUSIONES ............................................................................................................ 83
6 EXPERIMENTOS Y RESULTADOS ...................................................................... 84
6.1 INTRODUCCIÓN ............................................................................................................ 84 6.2 AMBIENTE DE EXPERIMENTACIÓN ......................................................................... 86 6.3 RESULTADOS EXPERIMENTALES ............................................................................. 87 6.4 CONCLUSIONES ............................................................................................................ 98
7 OBTENCIÓN DE UN MODELO DEL HISTORIAL FIEL PARA LA
DETECCIÓN DE INTRUSIONES FORENSE ..................................................... 100 7.1 INTRODUCCIÓN .......................................................................................................... 100 7.2 ENTROPÍA DE LAS LLAMADAS AL SISTEMA ....................................................... 101 7.3 CALIDAD Y FACTOR DE REDUCCIÓN DE LAS REGLAS DE PRODUCCIÓN ... 103 7.5 CONCLUSIONES .......................................................................................................... 106
8 CONCLUSIONES .................................................................................................... 108 REFERENCIAS ............................................................................................................... 112
10
1 INTRODUCCIÓN
Un sistema de detección de intrusiones o IDS por sus siglas en inglés (Intrusion Detection
System) es un elemento de la seguridad computacional que surge como consecuencia de las
vulnerabilidades de los sistemas y de sus medidas de seguridad implementadas. Un IDS se
define como un mecanismo encargado de monitorear el uso de computadoras y/o la red
sobre la cual se comunican para buscar usos no autorizados o comportamiento anómalo y
enviar alertas o restringir el acceso a los servicios que proveen [Cunningham et al., 1998].
Una intrusión, también conocida como ataque, es cualquier actividad maliciosa dirigida a
una computadora o a un equipo de red, así como a los servicios que éstos proveen
[Crothers, 2003] y se ve como una secuencia de acciones que alteran su estado y
comprometen su seguridad, poniendo en riesgo su integridad, confidencialidad y
disponibilidad. Los ataques se dividen en cinco fases de ejecución, pero las más estudiadas
son: la fase de penetración y de explotación.
La etapa de penetración sucede en el momento en que el atacante toma control de cualquier
aplicación dentro de una computadora e inyecta remotamente código de ataque. La fase de
explotación es cuando el atacante usa el control que tiene sobre la aplicación para dañar el
resto del sistema ejecutando el código recientemente inyectado. A ese código de ataque se
le conoce como exploit en la comunidad de seguridad.
11
Diversas investigaciones enfocan sus esfuerzos en desarrollar mejores sistemas de
detección de intrusiones que protejan los sistemas computacionales y/o las redes de
computadoras de robos o daños a su información. Desafortunadamente, conforme avanzan
las investigaciones y mejoran los IDS’s, también los intrusos mejoran las técnicas de ataque
logrando penetrar en un sistema computacional sin ser detectados para así concretar la
intrusión.
Debido a esto, surge la necesidad de contar con mecanismos capaces de detectar la
ejecución de un ataque, específicamente la ejecución de un exploit, después de su
penetración en un sistema. Dichos mecanismos son cruciales para proporcionar evidencia
digital en un proceso legal. Por otro lado, tal evidencia es de utilidad en la construcción de
nuevas firmas de ataque que serán interpretadas por un sistema de detección de intrusiones
en la detección de nuevos ataques.
Sin embargo, desarrollar una metodología para detectar la ejecución de un exploit no es una
tarea sencilla, Primero, es necesario considerar que en la mayoría de los casos, la ejecución
de un exploit es registrada en una o varias bitácoras del sistema, por lo que se requiere
analizar algunas de ellas en busca de actividades inusuales que puedan indicar la ejecución
del ataque.
En esta investigación nos hemos enfocado en las bitácoras que registran las llamadas al
sistema generadas por cualquier actividad en una computadora, debido a que las llamadas al
sistema son el elemento de más bajo nivel en una computadora del cual se puede obtener
una bitácora. Además de que cada acción llevada a cabo en un sistema operativo
desencadena la ejecución de una o más llamadas al sistema, ninguna acción puede ser
llevada a cabo sin ejecutarlas. Esto nos da un completo conocimiento de las acciones que se
llevan a cabo en una computadora.
Al problema de detectar la ejecución de un exploit lo hemos nombrado, detección de
intrusiones forense. Para tener éxito en el desarrollo de la metodología de detección de
intrusiones forense hay que considerar dos aspectos clave. El primero es que la evidencia
12
que se busca en una bitácora depende de la exactitud del modelo de comportamiento
normal de un sistema y construir este modelo resulta complicado debido a tres factores
principales:
1. El comportamiento normal de un sistema difiere ligeramente del comportamiento
anómalo a nivel de llamadas al sistema;
2. No todos los programas pueden tener acceso a ciertas llamadas al sistema y es posible
que la evidencia de esos programas no quede registrada en su totalidad, y;
3. El comportamiento anómalo genera muy poca información respecto a la longitud total
de una bitácora y no es fácil hacer una separación entre ellos.
El segundo aspecto a considerar es que cualquier actividad computacional genera grandes
volúmenes de información, por lo que la construcción de un modelo de detección y el
análisis de las bitácoras de llamadas al sistema consumen demasiado tiempo de
procesamiento.
En esta tesis se propone desarrollar una metodología para dar solución al problema de
detección de intrusiones forense considerando los dos aspectos antes mencionados. Esta
metodología la hemos fundamentado en un modelo de detección de intrusiones basado en
anomalías para una computadora, el cual es capaz de localizar en una bitácora de llamadas
al sistema la ejecución de un exploit, asumiendo que el atacante logró evadir los
mecanismos de seguridad implementados en el equipo de cómputo y que la evidencia de la
intrusión ha sido registrada en dicha bitácora.
Los modelos basados en anomalías a diferencia de otros, tienen mayor capacidad de
adaptarse a los ambientes cambiantes de un sistema para poder detectar anomalías que
nunca antes se habían presentado en dicho sistema, con base en su comportamiento normal.
Investigaciones demuestran que este tipo de modelos tienen mayor porcentaje de falsos
positivos; sin embargo, presentan un menor número de falsas alarmas por lo que son los
más investigados en la comunidad de detección de intrusiones.
13
El enfoque seguido por esta metodología corresponde a la construcción de dos modelos de
comportamiento de una computadora que son confrontados por métodos de clasificación
para la identificación de uno o varios ataques en las bitácoras de un sistema. El primer
modelo representa el comportamiento normal de un sistema y es construido a partir de un
historial de bitácoras libres de ataque. El segundo modelo es construido a partir del sistema
que se cree ha sido atacado y el cual será validado de posibles intrusiones.
Debido a que el éxito de la metodología de detección de intrusiones forense depende de la
exactitud de los modelos de detección, así como del análisis de grandes volúmenes de
información que se generan en una bitácora, esta investigación se sustenta en la hipótesis de
que el comportamiento normal de un sistema es repetitivo y el uso de un algoritmo capaz de
capturar esa repetitividad proporcionará información adecuada a métodos de clasificación
con los cuales será posible obtener modelos más exactos que facilitarán la identificación de
un ataque. Al mismo tiempo este algoritmo reducirá los volúmenes de información que
deberán ser analizados para la construcción de los modelos de detección, disminuyendo el
tiempo de procesamiento. Esta hipótesis nos lleva a las siguientes hipótesis particulares.
1. El uso de métodos estadísticos para clasificación de comportamiento, como diagramas
de caja es suficiente para lograr una adecuada detección de intrusiones forense, en
comparación con métodos más especializados tales como k-medias en línea, matriz de
factorización no negativa y modelos ocultos de Markov.
2. Aplicando un método de reducción de secuencias es posible capturar la repetición de
llamadas al sistema de una bitácora y proveer información que alimente a los métodos
de clasificación para mejorar el proceso de detección de intrusiones forense, además de
disminuir la complejidad computacional asociada a este proceso.
3. Considerando sólo una porción de cada bitácora de comportamiento normal que será
analizada, es posible obtener un modelo fiel contra el cual serán comparados los
modelos que deben ser validados de posibles intrusiones, logrando disminuir el tiempo
de procesamiento que requiere la detección de intrusiones forense.
14
Con base en estas hipótesis, las contribuciones de esta tesis son las siguientes:
1. Con el propósito de llevar a cabo la clasificación de comportamiento en una
computadora se propone la construcción de dos modelos de comportamiento, uno de
ellos extraído del uso normal del sistema, el segundo generado de una bitácora
posiblemente atacada. Para la construcción de estos modelos se han aplicado cuatro
métodos distintos y se ha comparado su calidad de clasificación de cada uno de ellos.
Los métodos implementados como clasificadores son: diagramas de caja, k-medias en
línea, matriz de factorización no negativa y los modelos ocultos de Markov combinado
con k-medias para mejorar la calidad de su clasificación.
Los resultados obtenidos a lo largo de la investigación han demostrado que el método
de modelos ocultos de Markov combinado con k-medias es el de mejor desempeño con
el menor porcentaje de falsos positivos y negativos en la detección. Sin embargo, los
experimentos también han mostrado que técnicas estadísticas relativamente sencillas
como son diagramas de caja, obtiene mejores resultados de clasificación respecto a
técnicas más especializadas como k-medias en línea y matriz de factorización no
negativa y pueden ser competitivas con otros métodos más complejos como modelos
ocultos de Markov.
Adicionalmente, se midió el tiempo de construcción de los modelos de detección y los
resultados demostraron que los modelos ocultos de Markov combinado con k-medias y
diagramas de caja son los métodos que requieren mayor tiempo de procesamiento,
mientras que la matriz de factorización no negativa tiene el menor tiempo de
procesamiento, seguido por k-medias en línea. Una comparación como la que se
presenta en esta tesis no había sido desarrollada. En esta comparación se muestra que se
pueden usar técnicas simples de clasificación para llevar a cabo detección de intrusiones
forense con un tiempo menor de aplicación al de técnicas más complejas y con un
desempeño comparable.
2. Para hacer la detección de intrusiones forense más tratable, la metodología propuesta en
15
esta investigación se ha complementado con una etapa de pre-procesamiento, la cual
tiene su fundamento en capturar el factor de repetición de una bitácora con la finalidad
de usar ese factor como métrica para clasificar comportamiento de un sistema y así
lograr de manera exitosa el proceso de detección.
Como contribución adicional de este pre-procesamiento, se logra agilizar la realización
de la detección al reducir la longitud de las bitácoras que serán analizadas después de
eliminar de ellas información repetitiva. El algoritmo implementado en esta etapa es
Sequitur [Nevill-Manning & Witten, 1997] y éste logra compactar las llamadas al
sistema contenidas en las bitácoras sin perder información clave para la detección. Los
resultados de nuestros experimentos demuestran que Sequitur reduce significativamente
una bitácora de llamadas al sistema, logrando un promedio de reducción cercano al
95%. Esta reducción de bitácoras puede ser usada por cualquier otra metodología
forense que necesite analizar grandes cantidades de información y que presenten
repetición en sus elementos; siempre y cuando se pueda prescindir de aquellos
elementos que no tienen un patrón de repetición.
3. Con el propósito de construir un modelo fiel del comportamiento normal de un sistema
usando solo una fracción de las bitácoras analizadas, de tal suerte que se disminuya la
carga de información a examinar y el tiempo de procesamiento en la construcción del
modelo, se ha llevado a cabo una serie de análisis que consiste en tres cálculos sobre las
llamadas al sistema de una bitácora. El primero, mide la variabilidad de las llamadas al
sistema de una bitácora respecto a la variabilidad de las llamadas al sistema de varias
porciones de distintos porcentajes de ésta. Esta variabilidad se calculó usando la medida
de entropía y los resultados arrojan que los valores de entropía de las distintas porciones
de una bitácora y la totalidad de ésta, no difiere significativamente entre ellos, en
promedio hay una variabilidad de 6.89%.
El segundo y tercer cálculo se llevaron a cabo mediante el uso de Sequitur. Con este
algoritmo se factorizó repetición de las llamadas al sistema de una bitácora y
fragmentos de diferentes porcentajes de ésta. El proceso de factorización de repetición
es realizado a partir de las sub-secuencias que se repiten dos o más veces en una
16
bitácora o un fragmento de ella; en primera instancia se evaluaron las sub-secuencias
factorizadas considerando el total de una bitácora y sus fragmentos, y aquellas iguales
en todos los casos fueron contabilizadas demostrando con los experimentos que las sub-
secuencias generadas usando una bitácora completa, en su mayoría, son las mismas que
se generaron de usar solo fragmentos de ésta, específicamente, 98.74%. Empleando los
mismos resultados, se calculó el factor de reducción usando las sub-secuencias de
mayor repetición de una bitácora y sus fragmentos. Hemos demostrado que la
diferencia promedio de reducción es mínima y equivale al 3.46%.
Lo anterior demuestra que es posible usar una fracción de bitácoras de llamadas al
sistema para construir un modelo de comportamiento normal de éste. Esta reducción de
las bitácoras demuestra que es posible usar fragmentos de información para construir
modelos de comportamiento normal de un sistema, lo cual permite analizar una mayor
cantidad de información en un menor tiempo y así obtener un mejor desempeño en
aquellos métodos forenses o de seguridad computacional que usen modelos de
comportamiento normal para detectar comportamientos anómalos.
1.2 ORGANIZACIÓN DEL DOCUMENTO
El documento se organiza como se describe a continuación. En el capítulo 2 se presenta el
estado del arte en sistemas de detección de intrusiones sobre una computadora,
específicamente los sistemas basados en anomalías. El capítulo 3 muestra cada una de las
técnicas que conforman la metodología desarrollada en esta investigación para llevar a cabo
detección de intrusiones forense sobre una computadora. En el capítulo 4 se presenta de
manera global nuestra metodología. En el capítulo 5 se desarrolla la forma en que fueron
usadas las técnicas del capítulo 3, así como la descripción de los datos usados en la
investigación. El capítulo 6 presenta los resultados obtenidos al aplicar la metodología.
Adicionalmente, el capítulo 7 refiere el método que ha sido desarrollado para asegurar
fidelidad de los modelos de detección que forman parte de la metodología de detección de
intrusiones forense. Finalizamos con el capítulo 6 en el que se discuten las conclusiones a
las que se llegó durante la investigación.
17
2 ESTADO DEL ARTE EN DETECCIÓN DE
INTRUSIONES
2.1 INTRODUCCIÓN
El uso creciente de los sistemas de computadoras ha incrementado el problema de accesos
no autorizados, provocando manipulación inadecuada de los recursos que provee un
sistema y específicamente de la información contenida en éste. En el pasado, los intrusos
necesitaban conocimiento muy profundo de las redes y las computadoras para llevar a cabo
su ataque. En la actualidad, el alto nivel de conectividad proporciona acceso a una gran
variedad de fuentes de información por lo que los intrusos están cada vez más preparados
para cometer sus actos delictivos.
Para proteger los sistemas computacionales de estas actividades maliciosas, se han
desarrollado los sistemas de detección de intrusiones. Esta investigación se interesa
específicamente en los sistemas de detección de intrusiones basados en una computadora
que fundamentan su funcionamiento en modelar el comportamiento normal del sistema o
aplicaciones que intentan protegerse. Para lo cual, se estudian y presentan en este capítulo
los trabajos que se han desarrollado al respecto. Con la finalidad de comprender mejor estas
investigaciones, se provee la descripción de sistemas de detección de intrusiones y su
clasificación.
18
También se menciona la importancia que tienen los sistemas de detección de intrusiones
forense en sistemas computacionales y la falta de éstos en el área de seguridad, mismos que
surgen de la necesidad de contar con mecanismos capaces de detectar intrusiones después
de que fueron concretadas, con el propósito de identificar el tipo de ataque que se ejecutó y
los recursos que fueron vulnerados para así proporcionar evidencia con diversos fines y/o
realizar acciones de recuperación de los recursos computacionales dañados.
El capítulo se organiza de la siguiente forma: en la sección 2.2 se presenta una introducción
a seguridad computacional y ataques computacionales y su clasificación. En la sección 2.3
se detalla en qué consiste un sistema de detección de intrusiones para continuar con su
clasificación en 2.4. Los avances en detección de intrusiones se presentan en la sección 2.5,
y en 2.6 se menciona un nuevo tema de investigación que no ha sido introducido
abiertamente en la comunidad, referente a detectar intrusiones posteriores a su perpetración.
El capítulo finaliza con las conclusiones en la sección 2.7.
2.2 SEGURIDAD COMPUTACIONAL
La seguridad computacional tiene por objetivo proteger de amenazas constantes un sistema
computacional y sus recursos, principalmente la información contendía en éste, por lo que
está directamente relacionada con la preservación de las características de seguridad de un
sistema de tecnologías de información, las cuales incluyen confidencialidad, integridad y
disponibilidad [Rusell et al., 1991].
• La confidencialidad se refiere a que un recurso computacional debe ser únicamente
accesible por aquellos usuarios que estén autorizados y con los permisos adecuados,
estos permisos generalmente son categorizados en lectura y/o escritura.
• La integridad tiene que ver con que el recurso se mantenga completo y consistente;
es decir, no sea alterado ante incidentes o intentos de acciones maliciosas.
19
• La disponibilidad significa que el sistema informático y/o la información contendida
en éste puedan ser accedidos por los usuarios autorizados, en el momento y forma
en que se necesiten.
Dentro del área de seguridad computacional se han propuesto y desarrollado diversos
mecanismos que protegen los sistemas de ataques computacionales. Entre ellos
encontramos, los mecanismos de control de acceso, los modelos de protección, los
mecanismos de identificación y autenticación, los antivirus y los sistemas de detección de
intrusiones. Éstos últimos forman la principal y más actual línea de defensa en el esquema
general de protección de un sistema computacional, y son útiles para detectar tanto
incidentes de seguridad como intentos de romper con ella. A continuación se presenta una
descripción de ataques computacionales y su clasificación.
2.2.1 Ataques Computacionales
Un ataque computacional, comúnmente llamado intrusión en el área de detección de
intrusiones, se define como cualquier actividad maliciosa dirigida a un sistema
computacional o a los servicios que éste provee [Crothers, 2003], y se ve como una
secuencia de acciones sobre el sistema operativo que alteran su estado y comprometen su
seguridad. Un ataque se conforma de seis etapas que lo llevan a su culminación, éstas son:
1. Reconocimiento, que involucra la obtención de información de una víctima.
2. Exploración, en la cual se utiliza la información obtenida en el reconocimiento para
investigar el sistema objetivo y tratar de obtener información sobre éste.
3. Penetración, sucede en el momento en el que el atacante toma control de un sistema e
inyecta código remoto en él, este código es conocido por la literatura como exploit.
4. Explotación, es cuando el atacante usa el control que tiene sobre la aplicación para
dañar el resto del sistema y aprovechándose de alguna vulnerabilidad en éste ejecuta el
código recientemente inyectado (exploit).
5. Continuación, se da cuando el atacante una vez que accedió al sistema busca implantar
herramientas que le permitan tener nuevos accesos en el futuro.
20
6. Eliminación de evidencia, cuando el atacante intenta borrar las huellas que fue dejando
durante la intrusión para evitar ser detectado por los administradores de seguridad.
2.2.2 Clasificación de Ataques Computacionales
Existen varias clases de ataques las cuales son clasificadas por [Kendall, 1999] con base en
su impacto sobre el sistema operativo, esta clasificación incluye los ataques de denegación
de servicio (DoS), elevación de privilegios de usuario a súper usuario (U2R), remoto a local
(R2U) y de prueba. Cada uno de estos ataques aprovecha alguna vulnerabilidad del sistema
para así lograr su propósito.
• Denegación de servicio (DoS). Un ataque de negación de servicio consiste en
saturar un sistema computacional con peticiones falsas de tal manera que los
servicios o recursos del sistema computacional atacado no estén disponibles para los
usuarios o procesos que los solicitan.
• Elevación de privilegios (U2R). Los ataques de elevación de privilegios se llevan a
cabo por un usuario que cuenta con acceso ordinario a un sistema y usando ese
acceso ejecuta un programa dentro del mismo, el cual aprovechándose de alguna
vulnerabilidad eleva los privilegios del usuario a los de un administrador.
• Remoto a local (R2U). Este tipo de ataques ocurre cuando un atacante que no
dispone de cuenta alguna en una computadora, logra acceder (como usuario o
administrador) a dicha máquina. En la mayoría de estos ataques, el atacante entra en
el sistema informático a través de Internet.
• Exploración (probe). Este tipo de ataques es llevado a cabo mediante un escáner de
red, el cual consiste en un programa capaz de escanear todos los dispositivos que se
encuentran en una red, así como las características y vulnerabilidades de éstos. Un
escáner es útil para que un atacante pueda planear una invasión posterior. Estos
ataques generalmente son precursores de otros.
21
2.3 SISTEMAS DE DETECCIÓN DE INTRUSIONES (IDS)
Los sistemas de detección de intrusiones o IDS por sus siglas en inglés (Intrusión
Detección Systems), están encargados de monitorear eventos para el descubrimiento
oportuno de actividades que ponen en riesgo la integridad, disponibilidad y
confidencialidad de un sistema de tecnologías de información. Las investigaciones
dedicadas a la creación de IDS’s se enfocan en:
• Identificar la aparición de patrones de un ataque conocido o la desviación del
comportamiento normal de un sistema.
• Identificar vulnerabilidades en la configuración del sistema.
• Auditar la integridad de un sistema crítico o archivo de datos crítico.
• Resaltar violaciones de usuario de una política de seguridad.
Los sistemas de detección de intrusiones están compuestos de tres elementos funcionales
básicos:
1. Una fuente de información que proporciona eventos conocidos de sistema o eventos
conocidos de ataque.
2. Un mecanismo de análisis que busca evidencias de intrusiones en una computadora
o en una red de computadoras.
3. Un mecanismo de respuesta que actúa según la información obtenida por el
mecanismo de análisis, este mecanismo puede tomar dos tipos acciones:
• Respuestas pasivas. En este caso, el detector no toma acciones que puedan
cambiar el curso de un ataque, únicamente se limita a enviar o registrar la
alarma correspondiente al responsable calificado.
• Respuestas activas. En este caso, el detector además de generar una alarma,
reacciona modificando el entorno. Ejemplos de éstas son: bloqueó de las
acciones del intruso o el cierre de la sesión del usuario sospechoso.
22
2.4 CLASIFICACION DE LOS IDS
Existen dos grandes enfoques al momento de clasificar los sistemas de detección de
intrusiones: en función de la información que analizan (fuente de información) y en función
de cómo lo hacen (estrategia de detección), ver Figura 1.
Figura 1 Clasificación General de un Sistema de Detección de Intrusiones.
De acuerdo con las fuentes de información, los IDS’s se clasifican en:
1. IDS’s basados en red (NIDS). Monitorean los paquetes que circulan por la red en
busca de elementos que logren un ataque contra alguno de los sistemas ubicados en
ella; el IDS puede situarse en cualquiera de las máquinas o en un elemento que
analice todo el tráfico en la red. Esté donde esté, monitoreará diversas máquinas y
no una sola: esta es la principal diferencia con los sistemas de detección de intrusos
basados en computadora.
IDS
Basados en Red
Basados en Computadora
Fuentes de Información
Estrategia de Detección
Detección de Anomalías
Detección de Usos Indebidos
Basados en Aplicación
23
2. IDS’s basados en computadora (HIDS). Monitorean los eventos de un sistema
operativo, específicamente las secuencias de llamadas al sistema1. Mientras que los
sistemas de detección de intrusos basados en red operan bajo todo un dominio de
colisión, los basados en máquina realizan su función protegiendo un único sistema;
el IDS es un proceso que despierta periódicamente buscando patrones que puedan
denotar un intento de intrusión y alertando o tomando las medidas oportunas en
caso de que uno de estos intentos sea detectado.
3. IDS’s basados en aplicación. Monitorean aplicaciones específicas del sistema. Este
tipo de IDS’s hace uso de un perfil que describe el comportamiento normal de la
aplicación que están monitoreando, si observan cualquier desviación de ese
comportamiento anotan la anomalía para posteriormente lanzar una alarma de
ataque.
La segunda aproximación clasifica a los IDS en:
1. IDS’s de anomalías (AIDS). Hacen uso del comportamiento normal de un proceso y
anota como un ataque cualquier actividad que se desvía de él. Para efectuar la
detección de intrusos basada en anomalías se requieren dos etapas principales
[Forrest et al., 1996]:
• Fase de entrenamiento o aprendizaje (training phase): en esta etapa el
detector acumula eventos cuando el dispositivo a monitorear no se encuentra
bajo el control de un ataque; con estos eventos se construye una base de
datos y se asume que esa información representa el perfil de
comportamiento ordinario.
• Fase de monitoreo o de prueba (phase test): con la información obtenida en
la fase de entrenamiento el detector de intrusos monitorea el funcionamiento
del dispositivo en tiempo de ejecución para encontrar anomalías.
1 Las llamadas al sistema proveen una interfaz entre los procesos y el sistema operativo. Generalmente, las llamadas cambian de acuerdo al sistema que se opere. Para que un usuario se comunique directamente con el sistema puede realizar llamadas desde programas escritos en un lenguaje de alto nivel.
24
Estos sistemas son capaces de detectar ataques nuevos, pero tienen la desventaja de
que frecuentemente etiquetan comportamiento ordinario como malicioso lo que
genera una tasa alta de falsos positivos2.
2. IDS’s de usos indebidos (MIDS). Su funcionamiento se basa en el conocimiento del
comportamiento de un ataque y si la información analizada coincide con ese
comportamiento se lanza una alarma. Para realizar la detección, esta clase de
sistemas requiere al igual que la anterior de dos fases principales:
• Fase de entrenamiento o adquisición, que consiste en construir una base de
datos con firmas de ataque conocidas.
• Fase de monitoreo o prueba, en la cual el detector de intrusiones lleva a cabo
el monitoreo del dispositivo analizado en tiempo de ejecución con la
finalidad de encontrar anomalías. Este tipo de sistemas es muy efectivo
detectando ataques conocidos. Sin embargo, falla detectando ataques
nuevos.
En la clasificación de los IDS’s cuyas fuentes de información son una computadora y las
aplicaciones que en ella se ejecutan, se han desarrollado numerosas investigaciones que
proponen arquitecturas basadas en analizar secuencias de llamadas al sistema. El trabajo de
investigación que se presenta en este documento recae en este tipo de sistemas, por lo que
en los siguientes capítulos se estudia el estado del arte al respecto.
2.5 DETECCIÓN BASADA EN ANOMALÍAS
El estado del arte en detección de intrusiones basada en anomalías corresponde a la segunda
generación de Stide llamada T-Stide [Hofmeyr et al., 1998], desarrollado en la universidad
de Nuevo México. T-Stide es uno de los mejores detectores de anomalías conocidos que ha
sido aplicado a detección de intrusiones, su objetivo es detectar ataques que explotan
2 Un falso positivo se refiere a considerar una actividad no anómala como maliciosa. A diferencia de un falso negativo que indica que una acción anómala fue considerada como no anómala.
25
procesos que se ejecutan en una computadora con privilegios de súper usuario. La primera
generación de este detector fue introducida en 1996 por Forrest y su equipo, quienes se
interesaron en desarrollar un método de detección de intrusiones con base en un sistema
inmune natural [Forrest et al., 1996].
Un sistema inmune trabaja por anomalías; es decir debe reconocer una serie de patrones
con los que distingue lo normal y todo lo que no recae en ese conjunto lo considera
anómalo y lo elimina. Además, este sistema es dinámico y autómata, por lo tanto, una vez
que entra un patógeno o molécula extraña es manejado por una respuesta innata y una
respuesta adaptativa; ésta última cambia conforme lo hacen las características del ambiente,
y su sistema de detección consiste en células llamadas linfocitos que funcionan como
detectores independientes que circulan por el sistema linfático detectando los patrones
extraños mediante la unión de los receptores que cubren su superficie con las moléculas
extrañas. Esta habilidad es posible gracias a la gran diversidad de receptores de los
linfocitos, que se genera por procesos genéticos que permiten la aleatorización.
Al basarse en un sistema inmune, la detección de intrusiones debe ser una aplicación de
sistemas adaptables, en la cual los patrones de comportamiento cotidiano del sistema de
cómputo y de los usuarios cambian constantemente. Con base en este funcionamiento, tanto
Stide como T-Stide son un método muy sencillo de detección de intrusiones que monitorea
las llamadas al sistema usadas por procesos privilegiados activos desde el inicio de su
ejecución hasta su fin.
El enfoque general del detector de Forrest y su equipo consiste de una ventana de
deslizamiento de tamaño fijo que explora la secuencia de llamadas al sistema de un proceso
y caracteriza el comportamiento normal de éste mediante patrones locales en la secuencia,
las desviaciones de esos patrones son usados para identificar violaciones de seguridad del
proceso en ejecución. Este detector requiere de dos procesos principales: 1) el primero
requiere capturar secuencias de llamadas al sistema de comportamiento normal de un
programa, y construir una base de datos con sub-secuencias de llamadas al sistema
observadas en las secuencias de comportamiento normal del programa monitoreado; 2) en
26
el segundo proceso se escanean secuencias de llamadas al sistema que podrían contener
comportamiento anormal y se buscan patrones no presentes en la base de datos normal para
determinar anormalidad.
Para construir la base de datos de patrones normales de T-Stide [Hofmeyr et al., 1998], se
desliza una ventana de tamaño k que cruza la secuencia de llamadas al sistema obtenidas
por la ejecución de varios procesos bajo condiciones seguras y se registra cada una de las
sub-secuencias únicas de longitud k que son observadas. Por ejemplo, suponemos que
tenemos una k=3 y que se observa la siguiente secuencia de llamadas para la construcción
de la base de datos: open, read, mmap, mmap, open, read, mmap, entonces se obtienen las
siguientes secuencias únicas que formaran parte de la base de datos de comportamiento
normal.
1) open, read, mmap
2) read, mmap, mmap
3) mmap, mmap, open
4) mmap, open, read
Los requerimientos de almacenamiento de la base de datos son del orden O(Nk), donde N es
el número de secuencias únicas (en el ejemplo anterior N=4). Sin embargo, como las
secuencias son almacenadas como estructuras de árboles (ver Figura 2), el requerimiento de
almacenamiento generalmente es menor a ese orden.
Figura 2 Ejemplo de estructuras de árboles de las secuencias de llamadas al sistema.
open
read
mmap
read
mmap
mmap
mmap
mmap open
open read
27
Con el mismo método que se construye la base de datos de comportamiento normal, se
analizan nuevas secuencias de comportamiento en busca de posibles anomalías. De esta
forma, las secuencias que no se encuentran en la base de datos normal son consideradas
posibles anomalías y éstas son sumadas a lo largo del análisis, al finalizar el procedimiento,
se reporta el número total de anomalías encontradas, así como el porcentaje de
anormalidad, el cual se calcula considerando el número de anomalías y la longitud de la
secuencia de llamadas al sistema analizada.
En la experimentación de T-Stide realizada por Forrest y su equipo se usaron ventanas de
distintos tamaños que van desde 3 hasta 15 llamadas al sistema, los resultados mostraron
que el rango de detección más efectivo fue con una ventana de tamaño 6. Dos años más
tarde en la investigación de [Warrender et al., 2000], se llevo a cabo una comparación entre
cuatro métodos de detección basada en anomalías que incluía Stide, T-Stide, las técnicas de
inducción de reglas y los modelos ocultos de Markov (HMM).
Los HMM’s obtuvieron el menor porcentaje de falsos positivos en la mayoría de los
experimentos. Sin embargo, el trabajo concluyó que métodos más sencillos que HMM
como Stide, T-Stide y las técnicas de inducción de reglas son suficientes para resolver el
problema de detección. Entre Stide y T-Stide, el segundo obtuvo el mejor porcentaje de
detección. A lo largo de las investigaciones, las pruebas experimentales mostraron que T-
Stide tiene mejor porcentaje de exactitud que Stide. Sin embargo, trabajos posteriores han
demostrado que este detector tiene limitaciones para detectar ataques que aparentan
comportamiento normal de un proceso, por lo que puede ser burlado por los intrusos.
La metodología desarrollada en la investigación que se presenta en este documento tiene
similitudes con a la usada por Stide, ya que el análisis que hemos llevado a cabo está
basado en anomalías, con el cual se construyó un modelo de comportamiento normal que se
comparó para realizar la detección de un ataque. También se usó una ventana de
deslizamiento sobre los datos normales para extraer ciertas características de ellos y
construir el modelo de comportamiento normal.
28
2.5.2 Detección Basada en Modelos
Una forma de detección de intrusiones por anomalías es aquella basada en modelos, la cual
involucra monitorear un proceso para ver si su comportamiento se ajusta al programa que
se está ejecutando. El reto principal de estas investigaciones es construir un modelo contra
el cual, el comportamiento de un proceso será comparado. Para este objetivo se han
propuesto diversos acercamientos, uno de ellos es el de [Giffin et al., 2004], quienes
proponen un modelo innovador que compara la ejecución de un proceso contra el modelo
una aplicación o programa específico. Las investigaciones más relevantes de este tipo de
detección de intrusiones se fundamentan en modelos sensibles al contexto, como un
autómata push-down sensibles al contexto.
El modelo propuesto por Giffin et al. fue llamado DICK, el cual específica las secuencias
de llamadas al sistema correctas que un programa es capaz de generar, así como los
cambios que ocurren en base a las llamadas a función. El modelo DICK tiene dos
componentes principales: 1) un analizador binario y 2) un monitor en tiempo de ejecución.
El primer componente está encargado de leer un programa en binario, analizarlo y construir
el modelo del programa. El modelo del programa es una máquina de estados finita que
define todas las posibles secuencias de llamadas al sistema que una aplicación puede
generar durante su ejecución normal (sin ataque).
Adicionalmente, se hace una re-escritura del código del programa en binario que
posteriormente el usuario ejecutará en su ambiente computacional. El segundo componente
monitorea la ejecución del programa re-escrito para asegurar que se siga el modelo
construido. Cualquier desviación del modelo indica que una violación de seguridad ha
ocurrido. Otro punto importante que tratan en su investigación Giffin et al. es restringir la
generación de llamadas al sistema nulas, para lo cual, adicional a su enfoque propuesto
permiten manejar argumentos de llamadas al sistema que mejoran la construcción del
modelo de un programa. La similitud de esta metodología con la que proponemos es
únicamente la comparación de un modelo de comportamiento normal con un
comportamiento que se desconoce si es normal o es resultado de un ataque.
29
En el mismo año, un nuevo enfoque de detección basada en anomalías fue propuesto por
[Haizhi et al., 2004], en el cual se introduce el término de waypoints para detectar ataques.
Los waypoints evitan que se ejecuten llamadas al sistema que son de alto riesgo para la
seguridad del sistema. Un waypoint se ve como un checkpoint en el control de flujo dentro
de una sección del código de un programa. Los waypoints pueden reportar información de
control de flujo de un proceso en tiempo de ejecución para asistir la detección de
intrusiones. Se pueden asignar atributos de seguridad a cada waypoint o a una secuencia de
waypoints.
Debido a que los waypoints y el código del programa que se monitorea se alojan en el
kernel del sistema, los atacantes no pueden manipular los waypoints directamente. Por
consiguiente, los ataques que combinan las llamadas al sistema de múltiples funciones o
procedimientos no pueden ser construidos por un intruso y como consecuencia, es difícil
atacar el sistema. Sin embargo, los ataques que usan secuencias legítimas de llamadas al
sistema del contexto actual, no pueden ser detectados por el mecanismo de waypoints.
Los IDS basados en modelo son fácilmente burlados, ya que el comportamiento de un
programa (o aplicación) es el mismo o similar para cualquier computadora con el mismo
sistema operativo. Por lo tanto, para un atacante resulta fácil modelar el comportamiento de
cualquier programa siempre que conozca el tipo y la versión del sistema operativo instalado
en la computadora que será atacada y así modificar su ataque para que su apariencia sea
igual a la del comportamiento normal de la aplicación. Esto fue demostrado en varias
investigaciones, una de las más relevantes fue el trabajo de [Sufatrio & Yap, 2005].
En la investigación de [Sufatrio & Yap, 2005] transforman ataques detectables con la
finalidad de observar si cambiando parámetros de los sistemas de detección de intrusiones
se pueden prevenir tales ataques. En su enfoque de transformación de ataques utilizaron un
grafo de traslape. El grafo de traslape se construye a partir de un trazo de llamadas al
sistema del comportamiento normal de un proceso, por ejemplo suponemos que tenemos la
siguiente secuencia que indica el comportamiento normal del proceso que queremos
representar: ABCDOPCDABPCA. Suponiendo que la ventana de desplazamiento que
30
analiza las sub-secuencias de esa secuencia es de tamaño 3, entonces las sub-secuencias
obtenidas son:
ABC-BCD-CDO-DOP-OPC-PCD-CDA-DAB-ABP-BPC-PCA.
El grafo de traslape G es construido con los sub-trazos identificados en el trazo normal del
proceso, ver Figura 3. Para transformar un ataque básico se considera que dado un grafo de
traslape G y una secuencia de ataque A=[A1, A2, A3,…,Al] detectable por el IDS se puede
construir automáticamente una variante del ataque L=[L1, L2, L3,…,Lm]; donde m es mayor
o igual a l y L contiene a A y donde las otras llamadas al sistema que conforman a L son
nulas respecto a A, es decir, no alteran el efecto dañino del ataque. Posteriormente,
automatizaron una búsqueda de los ataques modificados encontrando la secuencia de
ataque más corta, a partir de la implementación de la estrategia branch-and-bound y el
algoritmo de la ruta más corta de Dijkstra.
Figura 3 Grafo de traslape. Se constituye con dos tipos de arcos: arcos directos (líneas sencillas) y pseudo arcos (líneas dobles). Los pseudo arcos unen dos sub-trazos que no son contiguos en el trazo original.
Esta investigación convierte una secuencia de llamadas al sistema de ataque detectada A en
una secuencia equivalente no detectada A’. Si A y A’ son semánticamente equivalentes y A’
es una secuencia permitida por el modelo del programa, entonces A’ es un ataque no
detectado. Por lo tanto, se demuestra que los IDS’s de anomalías basados en modelo son
DAB
ABP
OPC
PCD
CDA
ABC BCD
CDO
DOP
BPC
PCA
31
fácilmente burlados modificando la huella de un ataque de tal manera que se asemeje al
comportamiento normal de un programa. Esta debilidad se presenta en todas las
metodologías basadas en la construcción de modelos de comportamiento normal; sin
embargo, puede ser disminuida mediante la regeneración periódica de los modelos
construidos con base en las actualizaciones del sistema y de las aplicaciones que trabajan
sobre éste. Desafortunadamente, esto no evita que el sistema de detección pueda ser
evadido.
2.5.2.1 Distancia entre Comportamientos
A la par del trabajo de Sufatrio y su equipo, se introduce en [Gao et al., 2005] el concepto
de distancia entre comportamientos para la detección de intrusiones. Esta distancia es una
medida de la desviación de los comportamientos de los procesos comparados y se propuso
para detectar si un proceso ha sido comprometido midiendo su distancia de comportamiento
contra otros procesos ejecutados con la misma entrada; es decir, miden la distancia de
comportamiento de un proceso que se cree ha sido atacado contra la distancia de otros
procesos bajo las mismas condiciones de entrada, si se observa una desviación notable,
entonces se asume que el proceso ha sido atacado.
Específicamente el trabajo de [Gao et al., 2005] analiza las llamadas al sistema producidas
por dos procesos idénticos residentes en distintos sistemas pero con las mismas
características de entrada y se modela el comportamiento observado, asumiendo que se
trata de actividad normal. Posteriormente se monitorearon las llamadas al sistema de los
procesos y cuando la distancia entre sus comportamientos crece es porque se presenta un
comportamiento anormal en alguno de ellos. Los resultados que presentan muestran una
cantidad muy baja de falsos positivos. Sin embargo, este trabajo permite otras líneas de
investigación ya que no evalúan la resistencia de su método ante la presencia de ataques
que simulan el comportamiento normal de un proceso.
Un año después Gao y su equipo proponen un nuevo acercamiento con base en el uso de
modelos ocultos de Markov (HMM) para calcular la distancia de comportamiento [Gao et
32
al., 2006]. En esta investigación los símbolos observados son comportamientos de procesos
como llamadas al sistema emitidas y los estados ocultos corresponden a tareas agregadas
realizadas por los procesos como leer de un archivo. Esas tareas deben ser las mismas en
dos procesos que corren el mismo programa en un lugar distinto, de tal forma que debe de
ser posible relacionar los comportamientos observables de los dos procesos, el cual se
distanciará cuando un ataque se efectúe en uno de ellos.
Su metodología usa un solo HMM para modelar ambos procesos y no un HMM para cada
proceso, como es hecho usualmente. Para la experimentación calcularon las distancias entre
comportamientos de procesos ejecutados en diferentes servidores web Apache, Abyss, y
MyServer y en diferentes plataformas Linux y Windows. En este mismo trabajo se evalúan
las falsas alarmas aplicando su metodología de distancia entre los comportamientos.
Muestran que su acercamiento presenta mejores resultados que [Gao et al., 2005] y una
gran mejora en cuanto a la cantidad de falsas alarmas. Además de lo anterior el costo
computacional es prácticamente el mismo. Los autores afirman que un HMM tiene mejores
propiedades que le permiten calcular de mejor manera la distancia entre dos
comportamientos.
Las investigaciones de Gao y su equipo, al igual que las propuestas basadas en modelo
pueden ser vulneradas por los intrusos modificando el ataque, de tal suerte que la ejecución
de éste parezca la ejecución normal de un proceso y con esto la medida de las distancias
entre dos procesos, sin importar el método aplicado, no logre detectar las diferencias entre
comportamiento normal y anómalo. Esto es fácilmente logrado ya que el comportamiento
normal de un proceso es el mismo o similar para cualquier computadora con el mismo
sistema operativo. Por lo tanto, para un atacante resulta fácil modelar el comportamiento de
cualquier proceso siempre que conozca el tipo y la versión del sistema operativo instalado
en la computadora que será atacada. Como ya se ha mencionado esta debilidad se presenta
en todas las metodologías basadas en anomalías que tienen como objetivo construir el
modelo de comportamiento normal del sistema que será evaluado.
33
2.5.2.2 Modelos del Sistema Operativo
El trabajo de [Giffin et al., 2006] propone la construcción de dos modelos, un modelo de un
programa mediante el comportamiento de llamadas al sistema de las aplicaciones y un
modelo de seguridad crítica del estado del sistema operativo. Su arquitectura consiste en
definir los ataques por su efecto malicioso sobre el sistema operativo y determinan que dos
secuencias de llamadas al sistema son equivalentes con respecto al ataque si ambas
producen el mismo efecto malicioso sobre el sistema operativo. El trabajo no se restringe a
analizar secuencias de llamadas al sistema de ataque conocido o transformaciones de ataque
conocidas. Si no que, a partir del modelo de un sistema operativo, extraen secuencias de
ataque.
La arquitectura de [Giffin et al., 2006] modela el sistema operativo con respecto a su estado
de seguridad crítica y se construyen posibles secuencias de ataque no detectadas en un
modelo de amenaza particular. El modelo del sistema operativo incluye tres componentes:
1) un conjunto de variables de estado, 2) un conjunto de asignaciones iniciales a las
variables, y 3) un conjunto de relaciones de transición de llamadas al sistema que alteran el
estado de las variables. Las variables de estado modelan el estado de seguridad crítica
interno del sistema operativo y pueden ser: 1) los identificadores de usuario que indican los
privilegios de los procesos, 2) los permisos de acceso de archivos y 3) los descriptores de
archivos activos.
A partir del modelo del sistema operativo, Giffin et al. implementaron un modelo de un
proceso como un autómata no determinista, PDA, en donde un estado corresponde a un
punto del proceso o programa en su código. El estado inicial es el punto de entrada del
proceso. Los estados finales corresponden a los puntos de terminación del proceso; los
cuales generalmente son una llamada al sistema exit. Los símbolos del alfabeto son las
llamadas al sistema generadas por el proceso al ejecutarse. Los símbolos de pila son
direcciones de retorno que especifican donde una llamada a función retorna. Y por último,
la relación de transición describe el flujo de control válido en un proceso.
34
El modelo PDA propuesto tiene tres tipos de transiciones:
• Transiciones de llamadas al sistema. Estas transiciones indican que el proceso puede
generar una llamada al sistema en la transición de un estado inicial a otro final.
• Transiciones de llamadas a función. Estas transiciones indican que el programa
mete la dirección de retorno en la pila de llamadas al sistema cuando hay una
transición de estados.
• Transiciones de retornos de función. Nos indican que el programa regresa una
llamada a función y extrae la dirección de retorno de la pila de llamadas.
El trabajo de Giffin et al. muestra que formalizando los efectos de un ataque sobre el
sistema operativo provee un mecanismo para encontrar ataques no detectados. Sin
embargo, la identificación de los datos del sistema operativo que constituyen un estado
relevante de seguridad es una operación manual. Además, cuando se encuentra que no hay
ataque no existe un método que pueda verificarlo.
Por otro lado, si los datos relevantes de un sistema operativo no son incluidos en el modelo,
entonces el sistema puede fallar en la detección de ataques. Como resultado, la ausencia de
un ataque en el sistema operativo abstracto provee evidencia de que el modelo detectará un
ataque cuando se opere un sistema operativo real.
2.5.2 Detección Basada en Usos Indebidos
Un enfoque de detección basado en usos indebidos que trabaja analizando las llamadas al
sistema generadas en un sistema operativo y en la cual apoyamos esta investigación es el de
[Godínez et al., 2006]. El método que proponen se basa en el uso de redes de palabras
[Young et al., 2002], las cuales descomponen un problema de reconocimiento de patrones
en una cadena más pequeña, logrando que el problema sea más tratable.
Este trabajo consiste en dividir el ataque en n segmentos de tamaño fijo. Para cada
segmento se construye un HMM que reconoce la aparición de ese segmento así como
35
algunas de sus variantes. Se construye también un HMM para reconocer la apariencia de
llamadas al sistema nulas que no afectan la nocividad del ataque. Posteriormente, ligando
todos los HMM’s asociados con un ataque forman una red de palabras capaz de reconocer
algunas variantes de un ataque filtrando llamadas al sistema redundantes.
Su arquitectura incorpora tres módulos principales, el primero de ellos filtra atributos de las
llamadas al sistema, el segundo segmenta una sesión, y posteriormente se incorpora un
discriminador de servicio para separar secuencias de entrada múltiples en servicios
individuales. El filtro se basa en la teoría de Rough Set3 [Komorowski et al., 1998] y toma
como entrada una bitácora de llamadas al sistema con sus atributos, el propósito es eliminar
atributos redundantes o superfluos de las llamadas. En el proceso de segmentación, se
segmenta la bitácora filtrada y se sustituyen las sub-secuencias comunes para reducir la
longitud de la bitácora. Con el uso de n-gramas4[Manning & Schütze, 1999] se
identificaron esas sub-secuencias.
Por último, el módulo de selección de servicio recibe la salida de la segmentación y su
salida son las mismas secuencias pero separadas por servicio. Este módulo es un
discriminador que usa HMM’s para calcular la probabilidad de que una sub-secuencia de
llamadas al sistema pertenezca a cierto servicio. Esta selección reduce el espacio de
búsqueda para el siguiente estado del IDS. La arquitectura propuesta en esta investigación
considera en su evaluación la detección de algunas variantes de ataques. Sin embargo, no se
abarca el conjunto total de posibles variantes que puedan generarse de uno o varios ataques.
En esta investigación, cada una de las técnicas usadas, analiza las llamadas al sistema
generadas de igual forma que se hizo en [Godínez et al., 2006] y [Young et al., 2002]. Con
estas llamadas al sistema se construyeron los modelos de comportamiento normal de un
sistema, mismos que fueron usados para analizar futuras secuencias de llamadas al sistema
y así determinar, con base en su comparación contra los modelos generados, si el
3 La teoría de Rough Set consiste en que a todo objeto se le puede asociar algún tipo de información basada en sus atributos y/o características. Estos atributos son representados por medio de una tabla de información, en donde las filas representan los objetos y las columnas representan los atributos. 4 Un n-grama es una sub-secuencia de n elementos para una secuencia dada.
36
comportamiento que representan es propio de un ataque, o es considerado comportamiento
normal del sistema y sus aplicaciones.
2.6 SISTEMAS DE DETECCIÓN DE INTRUSIONES FORENSE
Como hemos visto a lo largo de las secciones previas, las investigaciones que se han
desarrollado proporcionan metodologías de detección de intrusiones pensadas para
funcionar en tiempo de ejecución, con la finalidad de reportar que una actividad maliciosa
(intrusión) ha sido detectada y así detenerla antes de que ésta cause daños en el sistema. Sin
embargo, todas esas investigaciones han sido desarrolladas fuera de línea, por lo que
implícito en ellas surge un nuevo término, el cual hemos denominado en esta investigación
sistemas de detección de intrusiones forense.
Los sistemas de detección de intrusiones forense surgen de la necesidad de contar con
mecanismos capaces de identificar automáticamente el momento exacto de la ejecución de
un ataque y los pasos seguidos por éste después de que fue concretado en una computadora.
El término forense es atribuido ya que se trata de un proceso realizado posterior al evento,
que en este caso particular es una intrusión. Además de que éste incluye la identificación,
interpretación y presentación de evidencias digitales, mismas que pueden ser usadas con
tres fines principales: el primero, es proporcionar evidencia en un proceso legal; segundo,
estas evidencias pueden ser usadas para construir nuevas firmas de ataques que serán
implementadas para futuras detecciones. Por último, con esa información es probable que
se puedan revertir los efectos del ataque.
2.7 CONCLUSIONES
A lo largo del capítulo hemos analizado los avances de investigación respecto al tema de
detección de intrusiones, específicamente aquellas metodologías que se basan en el análisis
37
de llamadas al sistema. Cabe destacar que no se menciona el estado del arte en detección de
intrusiones forense ya que este término no ha sido introducido en la literatura, ni se han
realizado aplicaciones para dar solución a este problema.
Sin embargo, algunos de los acercamientos que hemos estudiado en el estado del arte
presentan de forma implícita una alternativa de solución a este problema,
desafortunadamente éstos muestran vulnerabilidades ante la detección de ataques que dejan
una huella débil en los registros del sistema. De aquí, la importancia de realizar
aportaciones en este campo, el cual hasta el momento no ha sido explorado.
38
3 BLOQUES DE CONSTRUCCIÓN
3.1 INTRODUCCIÓN
En capítulo 1 de este documento se introdujo un nuevo problema en el área de seguridad
computacional al que se nombró, detección de intrusiones forense. Como solución a este
problema, hemos desarrollado una metodología que se presenta en el siguiente capítulo del
documento. Esta metodología está conformada por bloques de construcción, los cuales
requieren la aplicación de ciertos métodos para análisis de secuencias y clasificación de
datos. Con el propósito de introducir al lector el funcionamiento de estos métodos, previo a
la forma en que se usaron para una mejor comprensión, este capítulo se enfoca en explicar
cada uno de ellos.
El capítulo se divide en dos secciones principales, métodos de análisis de secuencias y
métodos de clasificación de datos. En la sección 3.2.1 se describen los fundamentos del
algoritmo Sequitur, el cual ha sido usado en el área de detección de intrusiones para
comprimir secuencias de comandos en sistemas operativos y extraer sub-secuencias de
comandos de mayor repetición con la finalidad de mejorar la detección de intrusiones
[Posadas, 2006]. En la sección de métodos de clasificación, se muestra una visión general
de los algoritmos implementados como clasificadores, éstos son: diagramas de caja, k-
medias en línea, matriz de factorización no-negativa y modelos ocultos de Markov.
39
3.2 MÉTODOS DE ANÁLISIS DE SECUENCIAS
3.2.1 Sequitur
Sequitur es un algoritmo que infiere una gramática de una secuencia con base en las sub-
secuencias repetidas de ésta [Nevill-Manning & Witten, 1997]. Cada repetición da lugar a
una regla de producción en la gramática y la sub-secuencia repetida es reemplazada por un
símbolo no terminal, denominado meta-símbolo. Formalmente, definimos Σ como un
conjunto de símbolos terminales, que para nuestro propósito son llamadas al sistema.
También, el conjunto de meta-símbolos denotado por R= {m1, m2,…, mb} y δ el símbolo de
inicio, donde δ∉R∪Σ, y cada meta-símbolo está asociado con una regla de producción de la
forma: m → x1 x2… xc, para xi∈R∪Σ y m∈R∪{δ}.
Para ilustrar el funcionamiento del algoritmo recurrimos a la Tabla 1, extraída de [Craig et
al., 1997], donde se ejemplifican las gramáticas que resultan de procesar la secuencia:
abcdbcabcd, ignorando que cada letra de la secuencia representa una llamada al sistema en
nuestra investigación. La primera columna muestra el número de símbolo que es leído. La
segunda presenta la secuencia observada según se van leyendo sus símbolos. La columna
tres provee la gramática creada de la secuencia y la última, es una descripción de las
acciones realizadas.
Como podemos ver en el ejemplo de la Tabla 1, cuando Sequitur observa un nuevo
símbolo, este es agregado en δ. Los dos últimos símbolos de δ, el nuevo símbolo y su
predecesor, forman un nuevo digrama. Si este digrama ocurre en cualquier lugar de la
gramática, entonces se cumple la propiedad de digrama único, y este digrama es
reemplazado por un meta-símbolo, m. La propiedad de digrama único se ejemplifica en el
paso 6, cuando Sequitur agrega la última c, el digrama bc aparece dos veces. Por lo tanto,
Sequitur crea una nueva regla de producción con el meta-símbolo A, y reemplaza las sub-
secuencias bc por A. Después del paso 9, un tercer bc aparece y A reemplaza la tercera
ocurrencia. Esto resulta en un nuevo par de digramas repetidos, aA. Por lo tanto, se forma
una nueva regla con el meta-símbolo B, el cual reemplaza las dos ocurrencias de aA.
40
Sequitur crea y mantiene la jerarquía de la gramática por un proceso iterativo: la
substitución de A por bc resulta en el nuevo digrama aA, el cual también es reemplazado
por B. Para secuencias más largas, esos cambios forman y reemplazan reglas más largas en
la sección más alta de la jerarquía. Las reglas más largas se forman por el efecto de una
regla de utilidad, la cual asegura que cada regla es usada más de una vez. El paso 10 en la
tabla demuestra esa idea: cuando d es agregada a δ, el nuevo digrama Bd causa una nueva
regla con el meta-símbolo C. Sin embargo, al formar esa regla deja solo una aparición de B,
violando la regla de utilidad. Así el meta-símbolo B es removido de la gramática y las
reglas en las que aparece, son reemplazadas por su regla de producción correspondiente,
ver últimas líneas en la Tabla 1.
No. Paso
Cadena
Gramática
Comentarios
1 a δ → a 2 ab δ → ab 3 abc δ → abc 4 abcd δ → abcd 5 abcdb δ → abcdb 6 abcdbc δ → abcdbc bc aparece dos veces δ → aAdA
A → bc Se refuerza, digrama único
7 abcdbca δ → aAdAa A → bc
8 abcdbcab δ → aAdAab A→ bc
9 abcdbcabc δ → aAdAaA A→ bc
bc aparece dos veces
δ → aAdAaA A→ bc
Se refuerza, digrama único aA aparece dos veces
δ → BdAB A→ bc B→ aA
Se refuerza, digrama único
10 abcdbcabcd δ → BdABd A→ bc B→ aA
Bd aparece dos veces
δ → CAC A → bc B → aA C → Bd
Se refuerza, digrama único B solo se usa una vez
δ → CAC A → bc C → aAd
Se refuerza la regla de utilidad
Tabla 1 Ejemplo del funcionamiento de Sequitur [Nevill-Manning & Witten, 1997].
41
Sequitur es un algoritmo que opera incrementalmente y su uso de memoria es lineal
respecto al tamaño de la gramática. Esto ha permitido que el algoritmo sea aplicado en
diferentes dominios de investigación para comprimir secuencias muy largas.
3.3 MÉTODOS DE CLASIFICACIÓN
El problema de detección de intrusiones es un problema de clasificación en el que se
requiere extraer de extensas fuentes de datos información para desarrollar modelos
predictivos y/o explicativos. Los modelos tienen dos factores relevantes, su función que es
la de clasificar los datos analizados y su modo de representar el conocimiento como pueden
ser reglas o redes, entre otras representaciones. Diversos algoritmos han sido propuestos
para la extracción de modelos. En esta investigación se propone la implementación de
cuatro algoritmos que hemos usado para explorar el problema de detección de intrusiones
forense: diagramas de caja, k-medias en línea, matriz de factorización no negativa y
modelos ocultos de Markov. A continuación se describe cada uno de ellos.
3.3.1 Diagramas de Caja
Los diagramas de caja5 son una técnica propuesta en 1977 por J. W. Tukey [Johnson,
1997]. Estos diagramas son representaciones gráficas de una distribución estadística
unidimensional, muy útiles cuando se requiere encontrar límites ante la presencia de
valores atípicos u observaciones numéricamente distantes del resto de los datos. El término
en inglés de estos valores es outliers, puntos que se salen del margen establecido y
modifican notablemente parámetros como la media y la desviación estándar. Los diagramas
de caja son específicamente eficaces para la descripción gráfica de comparaciones entre
conjuntos de observaciones; dicho de otra manera, debido a que este método también
provee una medida de la simetría o asimetría de la distribución, del sesgo y de la dispersión,
permite contrastar conjuntos de datos distintos, de una misma variable.
5 El método de diagramas de caja es mejor conocido en la literatura por su término en inglés Box Whiskers.
42
Figura 4 Ejemplo de un diagrama de caja.
Este método consta de seis parámetros, tres de ellos representan medidas descriptivas de un
conjunto de observaciones y estos son: límite inferior, primer cuartil, mediana (o segundo
cuartil), tercer cuartil, límite superior, y rango intercuartil. En la siguiente sección se
detallan cada una de estas medidas. La Figura 4 muestra un ejemplo de un diagrama de
caja. Como se puede observar en la imagen, la mitad central de los datos que va del primero
al tercer cuartil, se representa con un rectángulo y la mediana se identifica con una barra
dentro de esa caja.
Medidas Descriptivas
La mediana es la medida que divide en mitades un conjunto de datos y se usa como medida
descriptiva del centro de un conjunto de datos. Formalmente, la mediana de n
observaciones, x1, x2,…,xn, puede definirse como el valor intermedio, después que los datos
son ordenados de acuerdo a su tamaño de menor a mayor. Específicamente, si las
observaciones se organizan conforme a su tamaño y n es un número impar, la mediana es el
valor de la observación con el número ; si por el contrario, n es un número par, la
mediana se define como la media (promedio) de las observaciones con los números y .
Además de la mediana, existen otros puntos de división de los datos, como son los
cuartiles. Un cuartil es un valor que divide un conjunto de datos, de tal manera que cada
Límite inferior
3
Cuartil 1º 4.5
Mediana 5 Cuartil 3º
6.5
Límite superior
9
43
una de ellas contiene el mismo número de frecuencias. La diferencia entre el primer cuartil
y el tercero, es lo que se conoce como rango intercuartil , IQR. El primer cuartil, Q1, es un
valor con un cuarto, o 25%, de las observaciones por debajo de su valor. Este cuartil es
también el vigesimoquinto percentil P0.25 de la muestra. El segundo cuartil, Q2, es el 50º
percentil, es decir, la mediana. El tercer cuartil, Q3, representa el 75º percentil del total de la
muestra.
Los límites superior (LS) e inferior (LI) corresponden a los extremos del diagrama y son las
medidas mediante las cuales se define el rango numérico que describe el comportamiento
de los datos. Aquellas observaciones que se encuentren fuera de esos límites son
consideradas valores atípicos. Los límites se calculan sumando o restando a la mediana, el
valor que se obtiene de multiplicar la constante 1.5 por el IQR. Esta constante puede ser
modificada para mover la posición de los límites, según sea requerido.
3.3.2 K-medias en Línea
K-medias en línea es una variante del algoritmo de agrupamiento K-medias. El método K-
medias fue introducido en [Bottou, 2003] y es un algoritmo que pone N datos en un espacio
dimensional I dentro de K grupos. Cada grupo es parametrizado por un vector m(k) que
representa su media. Los datos son denotados por {x(n)} donde n corre de 1 a N. Cada
vector x tiene I componentes xi. Se considera que el espacio que ocupa x es un espacio real
y que se tiene una métrica para definir la distancia entre dos puntos:
,
K-medias es un algoritmo iterativo de dos pasos. Al comienzo, K-medias es inicializado
con variables aleatorias. En el primer paso, que se conoce como etapa de asignación, cada
dato n es asignado a la media más cercana. En el segundo paso, llamado actualización, las
medias son ajustadas con respecto a la media de los puntos que ya han sido seleccionados
previamente. El procedimiento de este algoritmo se compone de los siguientes pasos:
44
1. Inicialización, con un conjunto de variables aleatorias {m(k)}.
2. Asignación. Cada dato n es asignado a la media más cercana. Para denotar la
medida de estimación, , que indica el grupo, k(n), al que pertenece un dato x(n),
se calcula la siguiente forma:
argmin ,
Como alternativa, la representación equivalente de esta asignación de datos a un
grupo se da por una medida de “responsabilidades”, . En el paso de asignación,
a se le da el valor de 1, si la media k, es la media más cercana a la media del
dato x(n); de otra forma, es igual a cero.
1 .0 .
3. Actualización. En esta etapa los parámetros del modelo; es decir, las medias, son
ajustadas respecto a la siguiente fórmula:
∑
4. Donde, R(k) es la “responsabilidad” total de la media k,
5. Si R(k) = 0, entonces se dice que la media no tiene “responsabilidades”.
6. Los pasos de asignación y actualización se repiten, hasta que las asignaciones no
reflejen ningún cambio considerable.
45
La diferencia entre k-medias y k-medias en línea radica en que el segundo algoritmo va
actualizando las medias conforme va recibiendo un nuevo dato del conjunto total de
observaciones que se están analizando.
Formalmente, K-medias en línea es un método de agrupamiento que usa K centros, m(k),
para encontrar grupos en un conjunto de puntos x1,…, xL. Este algoritmo usa la distancia de
cada uno de los grupos a los centros definidos y el centro más cercano es el grupo dentro
del cual el dato analizado es clasificado. La distancia se calcula por la similitud de los datos
que serán agrupados. Este algoritmo puede ser derivado en línea con la siguiente función de
pérdida:
,
Esta función mide el error de cuantificación, que se define como el error en la posición del
punto x, cuando éste es reemplazado por el centro más cercano. La función de costo
correspondiente mide el promedio del error de cuantificación.
3.3.3 Matriz de Factorización No-Negativa (NMF)
La matriz de factorización no negativa, NMF por sus siglas en inglés Non-negative Matrix
Factorization, es una técnica muy reciente, cuya utilidad principal es una representación
lineal de datos que necesitan ser analizados. Este método fue desarrollado por [Lee, 1999],
e intenta resolver la problemática de encontrar dos factores no negativos W y H dada una
matriz negativa V, de tal forma que se cumpla la siguiente ecuación:
En donde V es una matriz negativa y W y H los dos factores no negativos, que
multiplicados dan como resultado la matriz V. NMF puede ser usada para el análisis
estadístico de datos multivariantes de la siguiente forma: dado un conjunto de vectores de
datos multivariantes de n dimensiones, estos vectores son vaciados en las columnas de una
matriz V de tamaño n X m, donde m es el número de muestras en el conjunto de datos. Esta
46
matriz es factorizada en una matriz W de tamaño n X r y una matriz H, r X m. Usualmente r
se escoge menor que n o m, de esta forma W y H son matrices más pequeñas que la
original, lo que significa que son una forma comprimida de la matriz original. La ecuación
anterior puede ser reescrita de la siguiente forma:
Una representación esquemática de las matrices es la siguiente:
Donde v y h son columnas correspondientes de V y H, cada vector en v es aproximado por
una combinación linear de las columnas de W, delimitadas por los componentes de h. De
esta forma, W contiene la base que es optimizada para la aproximación lineal de los datos
en V. Es decir que la matriz W contiene los elementos base o características principales de
V, mientras que H contiene las particularidades de V. Debido a que pocos vectores base son
usados para representar una gran cantidad de vectores, una buena aproximación únicamente
puede lograrse si los vectores base son capaces de representar la estructura de los datos.
Un ejemplo puede ser la extracción de características de un rostro para su reconocimiento.
En este caso, NMF extrae las características locales de la imagen, lo cual significa que sólo
algunos pixeles de la imagen de entrada contribuyen a la formación de la imagen de salida,
por lo tanto hay una mayor estabilidad de la imagen extraída y existe más robustez frente a
rotaciones, escalados y pequeñas variaciones. Las bases obtenidas representan rasgos
Matriz V Matriz W Matriz H
n variables aleatorias por muestra
m vectores de datos r vectores base m vectores de datos
r vectores base
Coeficiente de la proyección
47
característicos de las imágenes de entrenamiento sin que exista un elemento predominante
sobre el resto que marque la reconstrucción de la imagen definitiva.
3.3.4 Modelos Ocultos de Markov (HMM)
Un Modelo Oculto de Markov, HMM por sus siglas en inglés Hidden Markov Model, es
una cadena de Markov con parámetros desconocidos, que modela un proceso doblemente
estocástico. El objetivo de usar estos modelos es determinar los parámetros ocultos de dicha
cadena a partir de los parámetros observables. La diferencia fundamental respecto a un
modelo de Markov habitual consiste en que los estados no son directamente visibles por el
observador, pero sí lo son las variables influidas por el estado.
Un HMM consta de estados y arcos [Brown, 1999]. Dentro de cada estado un símbolo es
generado y la transición entre ellos es permitida a través de los arcos. Existen dos tipos de
parámetros de probabilidad de los HMM’s: la probabilidad de transición de estados y las
probabilidades de emisión de símbolos, las cuales son agregadas a los arcos y estados,
respectivamente.
Las probabilidades de emisión de símbolos determinan qué símbolo tiene mayor
probabilidad de ser producido para cada estado en el HMM. Mientras que las
probabilidades de transición de estados determinan qué estado del HMM será elegido con
base en el estado actual. Esta transición de estado es importante porque cada estado tiene
diferentes probabilidades de emisión, de tal manera que los símbolos emitidos dependen de
las transiciones de estado. La Figura 5 muestra una representación gráfica de lo que
representa un modelo oculto de Markov.
48
Figura 5 Arquitectura general de un HMM. Cada óvalo representa una variable aleatoria que puede tomar determinados valores. La variable aleatoria x(t) es el valor de la variable oculta en el instante de tiempo t. La variable aleatoria y(t) es el valor de la variable observada en el mismo instante de tiempo t. Las flechas indican dependencias condicionales.
Formalmente, un HMM se especifica por la tupla de 5 elementos (S, K, Π, A, B). En donde
S y K son el conjunto de estados y el alfabeto de salida, Π es la probabilidad de los estados,
A la probabilidad de las transiciones de estado y B la probabilidad de la emisión de los
símbolos. Sea O una secuencia de entrada, donde O = O1, O2,…, OT, un HMM puede
modelar esa secuencia con sus parámetros de probabilidad usando procesos de Markov.
Una vez que un modelo λ es construido, la probabilidad de ocurrencia de la secuencia O,
dado el modelo λ, puede ser evaluada y se describe como λ = (A, B, π). La Figura 6,
muestra los elementos del modelo, λ.
Conjunto de estados: S = {s1,…,sN}. Alfabeto de salida: K = {k1,…,kM} = {1,…,M}. Probabilidades iniciales de los estados: Π = {πi}, i ∈ S. Probabilidades de transición: A = {aij}, i, j ∈ S. Probabilidades de emisión de un símbolo: B = {bijk}, i, j ∈ S, k ∈ K. Secuencia de estados: X = (X1,…,XT+1); Xt: S → {1,…,N}. Secuencia de salida: O = (o1,…,oT); ot ∈ K.
Figura 6 Elementos de un HMM [Manning & Schütze, 1999].
St St+1 St+2 St+2
E E E E
P(S1) P(St+1|St)
P(E|St)
T T +1 T +2 T +3
49
Existen tres preguntas fundamentales que queremos conocer de los HMMs [Manning &
Schütze, 1999]:
- Dado un modelo λ = (A, B, π), ¿qué tan probable una secuencia de observación O es
producida por el modelo? Esto se representa como, P (O | λ).
- Dada una secuencia de observación, O y un modelo λ, ¿cómo elegimos una
secuencia de estados (X1,…,XT+1) que mejor explique la secuencia de
observaciones?
- Dada una secuencia de observaciones O y un conjunto de estados, ¿cómo
encontramos el modelo λ = (A, B, π) que explique mejor los datos observados? Otra
forma de expresar esto, ¿cómo encontrar los parámetros π, A y B?
Esas preguntas corresponden a la etapa de evaluación, decodificación y aprendizaje,
respectivamente. La primera pregunta se usa para decidir entre modelos cuál es el mejor
para representar un proceso determinado y éste se resuelve usando el procedimiento hacia
adelante-hacia atrás o forward-backward.
La segunda pregunta permite determinar qué ruta fue seguida “probablemente” a través de
la cadena de Markov, la cual puede usarse para llevar a cabo un proceso de clasificación,
como se requiere en aplicaciones de reconocimiento de patrones. Esta pregunta se resuelve
con el algoritmo Viterbi. La tercera pregunta está relacionada con problemas que deben ser
resueltos en los que no se conocen los parámetros y éstos tienen que ser estimados a partir
de los datos con que se cuenta. Esto se puede resolver con el algoritmo Baum-Welch.
Generalmente, en las aplicaciones de HMM los parámetros que van a construir el modelo
no están disponibles, solo se conoce A. El método más común de seleccionar los parámetros
de un modelo λ*, que mejor exprese una secuencia de datos observados, es el de estimación
de máxima probabilidad (o maximum likelihood). El uso de esta estimación significa que se
desea encontrar los valores que maximicen P(O | λ):
50
argmax |
Este proceso de aprendizaje de parámetros generalmente se lleva a cabo usando el
algoritmo de Baum-Welch. Dada una secuencia de observaciones, O=(o1,...,ot), el algoritmo
de Baum-Welch permite estimar los parámetros de un modelo oculto de Markov λ, que
maximizan la probabilidad de ocurrencia de dicha secuencia de observaciones.
El éxito de los HMM’s se basa en la existencia de un algoritmo de aprendizaje automático
iterativo, el cual ajusta los parámetros de un HMM a una secuencia de datos de
entrenamiento, generando un modelo con estados. Los estados son conectados entre sí con
una probabilidad, sin dependencia del estado anterior y sin conocer el estado en el que se
encuentra, de esta forma el siguiente estado es calculado con base en un conjunto de
características. Una de las principales aplicaciones que hacen uso de estos modelos es el
reconocimiento del habla. Esta técnica ha permitido modelar adecuadamente la gran
variabilidad en el tiempo de la señal de voz.
Varias de estas aplicaciones de los modelos ocultos de Markov, específicamente aquellas
que usan estos modelos como clasificador de datos, requieren medir la distancia entre dos
HMM’s para determinar la similitud o diferencia entre dos conjuntos de datos. Para medir
la distancia de dos modelos se han propuesto diversas funciones, todas ellas con
características específicas que definen las situaciones de uso más convenientes.
Formalmente, la medida de distancia entre dos HMM’s, es una función que asigna un par
de modelos λ = (A, B) y λ’ = (A’, B’) a un número real positivo d(λ, λ’). El caso más
general de la medida de distancias es la distancia euclidiana y una variación de ésta, es la
medida de distancia euclidiana minimizada. Sin embargo, ambas medidas no toman en
cuenta la estructura temporal representada en la cadena de Markov, por lo que dos modelos
pueden dar una distancia cercana a cero aunque las medidas de probabilidad Pλ y Pλ’ sean
completamente diferentes. Debido a esto, en el trabajo de [Falkhausen et al., 1995] se
introduce una nueva medida de distancia llamada Kulback-Liebler.
51
La distancia Kullback-Leibler es una medida de la diferencia entre dos funciones de
probabilidad Pλ y Pλ’. Esta medida es una de las menos exploradas y se basa en la
discriminación de la medida de probabilidad en el espacio de características de las
secuencias producidas por un HMM. Formalmente, la distancia de Kullback-Leibler entre
dos probabilidades Pλ y Pλ’ se representa de la siguiente forma:
λ|| λ′ log
Siempre que Pλ > 0 y Pλ’ > 0 para todos los valores de x, y además Pλ y Pλ’ sumen 1. La
distancia de Kullback-Leibler no es simétrica, por lo que no siempre se cumple que:
DKL(Pλ|| Pλ’) = DKL(Pλ’|| Pλ).
Otra medida que se usa para calcular la distancia entre dos HMM’s es la métrica de
Levinson, la cual fue la primera métrica compuesta para comparar HMM’s discretos. Esta
medida se basa en la comparación de las matrices de dos modelos usando distancia
euclidiana:
Donde son las probabilidades de observación para el modelo . Se asume que el número
de estados en ambos modelos es el mismo. Una medida alternativa considera la suma de las
distancias mínimas:
52
Estas métricas no toman en cuenta la estructura temporal de la cadena de Markov, por lo
cual hay casos en los que dos HMM’s tienen una distancia de Levinson cercana a cero,
mientras que las medidas de probabilidad de ambos modelos son completamente distintas.
Una forma más de medir la distancia es la métrica de Porilki, dicha distancia está definida
de la siguiente forma:
Esta distancia evalúa la correspondencia de dos secuencias de observaciones a partir de dos
modelos distintos. es una secuencia de observaciones generada por el modelo , y
| es la probabilidad de la observación de la secuencia del modelo dado. Los
términos | y | indican la probabilidad de cada secuencia dada por el
correspondiente modelo; mientras que los términos cruzados | y | miden
la probabilidad de que las secuencias sean generadas por el otro modelo. Es decir que si las
trayectorias son las mismas, los términos directos y cruzados se cancelan y la distancia
tiende a cero, de lo contrario, la distancia se incrementa.
3.4 CONCLUSIONES
En este capítulo se presentaron las bases teóricas del algoritmo Sequitur diseñado para
analizar secuencias de símbolos, entre otras aplicaciones. Este algoritmo ha sido usado por
diversas investigaciones en el área de detección de intrusiones con resultados satisfactorios
en la compresión de secuencias. También se describieron los métodos de diagramas de caja,
k-medias en línea y su antecesor k-medias, NMF y HMM, mismos que han sido
ampliamente estudiados y usados por diversas investigaciones, especialmente en ciencias
computacionales y cuyo funcionamiento permite que sean implementados en aplicaciones
que requieren clasificación de datos.
53
4 METODOLOGÍA DE DETECCIÓN DE
INTRUSIONES FORENSE
4.1 INTRODUCCIÓN
En el capítulo 2 de este documento hemos estudiado las investigaciones relacionadas con
sistemas de detección de intrusiones y un nuevo problema es introducido, el cual hemos
denominado detección de intrusiones forense. En términos generales, este es un problema
de clasificación en el que debe distinguirse entre dos comportamientos, normal y anómalo.
En este capítulo se muestra a nivel general la metodología que proponemos para resolver
ese problema, para lo que se requiere la implementación de algunos métodos usados como
clasificadores de datos. En el capítulo anterior se introdujeron los fundamentos teóricos de
los métodos usados como parte de nuestra metodología.
La metodología propuesta fue diseñada con base en dos aspectos fundamentales, los cuales
son necesarios para lograr una exitosa detección de intrusiones forense. El primero se
refiere a que la efectividad del método de detección obedece a la exactitud del modelo que
captura el comportamiento normal del sistema analizado. El segundo, a que el
comportamiento normal de un sistema representa un patrón regular y constante que genera
grandes volúmenes de información en una bitácora, mientras que la ejecución de un ataque
54
queda registrada en unos cuantos registros de la bitácora, lo que por tanto la hace difícil de
distinguir.
Con el propósito de introducir al lector la contribución de este documento, el capítulo se
organiza de la siguiente forma: en la sección 4.2 se hace una descripción general de la
estructura de nuestra metodología y se muestra gráficamente cada uno de los procesos
involucrados en el desarrollo de ésta. En las secciones 4.3, 4.4 y 4.5 formalizamos las
etapas que forman parte de los procesos que comparten el mismo procedimiento; estas
etapas incluyen la reducción de bitácoras en 4.3, la segmentación de las bitácoras reducidas
en 4.4 y la construcción de los modelos en 4.5. En la sección 4.6 se detalla el último
proceso que corresponde a la detección de intrusiones forense. Finalizamos con las
conclusiones sobre el diseño de la metodología en la sección 4.7.
4.2 DESCRIPCIÓN DE LA METODOLOGÍA
La metodología de detección de intrusiones forense que hemos desarrollado en esta
investigación sustenta su procedimiento en el análisis de bitácoras de llamadas al sistema,
las cuales son generadas por la ejecución de algún proceso en respuesta a la solicitud de una
aplicación o programa invocado por un usuario. Una llamada al sistema es un mecanismo
mediante el cual un proceso solicita un servicio del sistema operativo e incluye al menos
los siguientes parámetros: objeto, sujeto y valor de retorno.
El objeto representa el elemento del sistema operativo sobre el cual la llamada al
sistema tiene impacto, por ejemplo éste puede ser la ruta de un archivo, nombre de un
archivo, etc.
El sujeto indica el proceso en el que fue ejecutada la llamada así como la sesión a la que
pertenece.
El valor de retorno es un valor numérico, que en ocasiones es acompañado de una breve
descripción, e indica el resultado producido una vez que la llamada fue ejecutada en el
sistema operativo.
55
Para nuestro propósito, y como particularidad de nuestra metodología propuesta los
primeros dos parámetros son eliminados de las bitácoras analizadas. Por lo tanto, al
referirnos al término bitácora a lo largo de este documento, solo estamos considerando las
llamadas al sistema y su valor de retorno.
El Figura 7 muestra un pequeño fragmento de una bitácora de llamadas al sistema de la
forma en que han sido usadas para esta investigación. El número que se localiza después
del símbolo igual (=) representa el valor de retorno o el resultado de la ejecución de una
llamada al sistema, donde cualquier valor igual o mayor a cero indica que la llamada fue
realizada con éxito y cualquier número negativo significa que hubo fracaso en la ejecución.
Cualquier descripción después del número negativo obtenido en la ejecución de una
llamada no es considerada.
Figura 7 Fragmento de una bitácora de llamadas al sistema.
El diseño de nuestra metodología comprende tres procesos. El primero de ellos está
encargado de construir un modelo que representa el perfil de comportamiento normal del
sistema que se cree ha sido atacado. Para construir este modelo, usamos un conjunto de
bitácoras extraídas de un período de tiempo que antecede al momento del posible ataque y
que se supone es libre de ataques.
execve = 0 brk(0) = 0x922c000 access = -1 ENOENT (No such file or directory) open = 3 fstat64 = 0 mmap = 0 read = 1 write = 1 rt_sigprocmask = 0 read = 1 fcntl64 = 0 getdents64 = 0 close = -1 EBADF (Bad file descriptor) fstatat64 = -1 ENOENT write = 22 openat = 3 close = 0 …
56
En caso extremo, si no se cuenta con el registro previo de llamadas al sistema generadas en
el sistema, es posible generar bitácoras posteriores al ataque, pero registradas después de
realizar un procedimiento de recuperación en el que se tiene la certeza de un estado seguro.
A estas bitácoras las nombraremos a lo largo del documento, historial. La Figura 8 muestra
el procedimiento seguido para la construcción del modelo del historial.
Como se observa en la fFigura 8, el proceso de construcción del modelo del historial
comprende las etapas de reducción de bitácoras, segmentación de las bitácoras reducidas y
construcción del modelo. Los números que identifican estas etapas en el diagrama
corresponden a la sección de este capítulo en donde se detalla su procedimiento.
Para la construcción del modelo del historial (ver recuadro 4.5 de la Figura 8) se
implementan cuatro métodos que tienen la funcionalidad de clasificar los datos analizados,
y cuya clasificación representa el modelo del historial. El cuarto método es una variante de
HMM a la que hemos llamado KHMM debido a que se aplica K-medias a los datos previo
a su clasificación con HMM. La forma en que se uso cada uno de los métodos es detallado
en el capítulo 5 de este documento.
Figura 8 Primer Proceso: Construcción del modelo de Historial.
4.4.Segmentación
Caja de Bigotes
MNF
Kmedias en Línea
KHMM
4.5. Construcción de los Modelos
Modelo Del
Historial
Modelo de Reducción
(MRH)
Historial de
Bitácoras
4.3.(2)Reducción de Bitácoras
57
El segundo proceso de la metodología está diseñado para construir el modelo de la bitácora
que se supone ha sido atacada, a la que llamamos bitácora de validación. El procedimiento
seguido en este proceso se muestra en la Figura 9 y como puede observarse, éste se
conforma por las mismas etapas del primer proceso: reducción, segmentación y
construcción del modelo.
Sin embargo, a diferencia del primer proceso, en éste la etapa de reducción de las bitácoras
es llevada a cabo de manera distinta. Por lo tanto, en la siguiente sección, en donde se
describe el procedimiento de reducción de las bitácoras, se hace una división entre la forma
de reducir las bitácoras del historial y la bitácora de validación.
Figura 9 Segundo Proceso: Construcción del modelo de la Bitácora de Validación.
En el tercer proceso de nuestra metodología, el modelo de la bitácora de validación será
comparado contra el modelo del historial, con el objetivo de descartar la ejecución de un
ataque o, en caso contrario, encontrar posibles anomalías y finalmente uno o varios ataques.
La Figura 10 muestra gráficamente el tercer proceso involucrado.
4.4. Segmentación
Caja de Bigotes
MNF
Kmedias en Línea
HMM
4.5. Construcción de los Modelos
Bitácora de Validación
Modelo Bitácora de Validación
4.3.(2)Reducción de Bitácora
58
Figura 10 Tercer Proceso: Detección de Intrusiones.
Para que la metodología propuesta pueda ser usada se necesita contar con las llamadas al
sistema, y dado que cualquier sistema operativo las genera, nuestra metodología puede ser
aplicada en cualquiera de ellos. Sin embargo es necesario usar algún proceso que obtenga
las llamadas al sistema para que puedan ser analizadas.
4.3 REDUCCIÓN DE LAS BITÁCORAS
La etapa de reducción de bitácoras consiste en llevar a cabo factorización de repetición de
sub-secuencias de llamadas al sistema contenidas en una bitácora, cuidando no eliminar
información fundamental en la detección de intrusiones. La factorización de repetición
tiene dos propósitos: el primero es la extracción de características que provean información
de la bitácora analizada para obtener una clasificación acertada entre comportamiento
normal y anómalo de los datos contenidos en ésta. El segundo, es acelerar la construcción
de los modelos de detección (historial y validación) para lograr que el tiempo en que se
alcanza la detección de intrusiones sea oportuno. En las siguientes dos secciones se
presenta la descripción de la etapa de reducción de las bitácoras, del historial y de
validación, respectivamente.
Comparación de Modelos
Modelo Del
Historial
Modelo Bitácora de Validación
Detección de Intrusiones
Forense
59
4.3.1 Reducción de las Bitácoras del Historial
Una de las aplicaciones del algoritmo Sequitur [Nevill-Manning & Witten, 1997],
introducido en la sección 3.2, y que forma parte de la metodología de detección de
intrusiones forense es la reducción significativa de las bitácoras del historial. Este algoritmo
lleva a cabo el proceso de reducción mediante la factorización de repetición de las llamadas
al sistema contenidas en las bitácoras del historial que serán analizadas. Formalmente, este
algoritmo recibe como entrada una sola bitácora Bi y trabaja secuencialmente leyendo las
llamadas contenidas en ella en busca de sub-secuencias que se repiten dos o más veces,
denotadas en su forma básica por <sc1 sc2… scl>. A estas sub-secuencias se les asigna un
meta-símbolo, m, que las identifica y con lo que son reemplazadas en Bi. Debido a que este
algoritmo es recursivo, un meta-símbolo puede representar no solo una sub-secuencia de
llamadas al sistema, sino también de meta-símbolos o una combinación de ambos.
Adicionalmente, y como otra aplicación de Sequitur en nuestra metodología, es la creación
de un Modelo de Reducción basado en el Historial (MRH), el cual se construye agregando
a una base de datos las sub-secuencias de mayor repetición con su respectivo meta-símbolo.
Así, cada elemento de la base de datos toma el término de regla de producción; es decir,
cada par de meta-símbolos y sub-secuencia de elementos es una regla de producción, cuya
forma básica es m→ <sc1 sc2… scl>. La salida de la reducción de una bitácora es una
secuencia reducida Bir y un MRH denotado por R = {m1, m2,…, ma}, tal que al reemplazar
recursivamente cada mi por su correspondiente regla de producción en Bir, se obtiene la
secuencia original Bi.
Formalizando la etapa de reducción de las bitácoras del historial, denotamos con HB= {B1,
B2, B3,…,Ba} la entrada a ésta, que representa el historial de una computadora posiblemente
atacada, donde Bi = <sc1, sc2, sc3,…> es una secuencia de llamadas al sistema. Cada
bitácora Bi es compactada con Sequitur y se produce una secuencia Bir= <e1, e2, e3,…> para
cada Bi donde |Bir| < |Bi| y ej puede tomar dos posibles valores: una llamada al sistema, sc, o
un meta-símbolo, m, que equivale a una sub-secuencia de llamadas al sistema que se repite
más de dos veces en Bi. El resultado final de esta etapa es un conjunto de bitácoras
reducidas denotado con HB r = {B1
r, B2r, B3
r,…, Bar}.
60
Usando el algoritmo Sequitur hemos logrado compactar satisfactoriamente las bitácoras, sin
perder información importante. Los resultados a lo largo de nuestra experimentación
reflejan un promedio de reducción para cada bitácora cercano al 95%.
4.3.2 Reducción de las Bitácoras de Validación
Para reducir el tamaño de la o las bitácoras de validación que serán analizadas una vez que
se tiene la creencia de que contienen un ataque, se usa el MRH con la finalidad de sustituir
dentro de la bitácora, las sub-secuencias de llamadas al sistema que corresponden a una
regla de reproducción del MRH por su meta-símbolo correspondiente. Antes de realizar la
sustitución en la bitácora de validación, si alguna regla de producción del MRH está
conformada no sólo de llamadas al sistema sino también aparece un meta-símbolo,
entonces éste es reemplazado por su regla de producción.
Formalizando el procedimiento de reducción, denotamos la bitácora de validación con Bv=
<sc1, sc2, sc3,…> y el MRH con R = {m1, m2,…, ma} como la entrada al proceso. Si mi en R
es de la forma mi → <e1 e2… ek> donde ej puede tomar el valor de una llamada al sistema o
un meta-símbolo, entonces cada ej que equivale a un meta-símbolo, mi, es reemplazado
recursivamente por su regla de producción hasta que mi quede en su forma simple mi →
<sc1 sc2… scl> generando R’. Cada regla de reproducción <sc1 sc2… scl> en R’ es buscada
en Bv y reemplazada por su correspondiente meta-símbolo, mi. El resultado es una bitácora
reducida, Bvr.
Usando el MRH logramos compactar altamente las bitácoras de validación que son
analizadas. Los experimentos arrojan un promedio de reducción por bitácora del 92.8%, lo
que infiere que el comportamiento normal observado en las bitácoras del historial se ve
reflejando en las bitácoras de validación. Por lo tanto, con base en la hipótesis de que la
ejecución de un ataque genera comportamiento inusual en el sistema, se espera que con esta
etapa de reducción, las llamadas al sistema ejecutadas por el ataque, en su mayoría, no sean
reducidas con el MRH dejándonos ver la ejecución del mismo.
61
4.4 SEGMENTACIÓN DE LAS BITÁCORAS REDUCIDAS
Cada bitácora reducida, ya sea del historial o de validación, es segmentada haciendo
deslizar una ventana de longitud k que cruza Bxr con saltos de longitud l, donde l ≤ k. Cada
segmento, w, de Bxr y de longitud k es registrada en Wx = <w1, w2, w3,…, wl>, donde wj =
<e1, e2, e3,…>, con 1≤ j ≤ l. Por ejemplo, consideremos la secuencia de elementos <sc1, sc2,
sc3, m1, sc4, m2, m3, m3, sc1, sc1, sc2, sc2, m1, m2>, con k= 6 y l= 4, entonces W contiene los
valores: << sc1, sc2, sc3, m1, s4, m2>, < sc4, m2, m3, m3, sc1, sc1>, < sc1, sc1, sc2, sc2, m1,
m2>>.
Cada wi∈W se representa mediante un conjunto de características wi{c1, c2, c3,…}, y se crea
un vector Vx = [w1{c1, c2, c3,…}, w2{c1, c2, c3,…}, w3{c1, c2, c3,…},…,wn{c1, c2, c3,…}],
con 1≤ i ≤ n, como entrada a los clasificadores que generan el modelo correspondiente
(modelo del historial o modelo de la bitácora de validación). El modelo del historial
generado se representa por Go, donde Go es un límite representativo del comportamiento
normal de un sistema. El modelo de la bitácora de validación generado es Gv={q1, q2,
q3,…}, donde q corresponde a una w y es una medida de comportamiento que será
comparada contra Go para encontrar posibles anomalías. En la siguiente sección
presentamos una descripción del uso de cada uno de estos clasificadores. La descripción de
cada una de las características usadas en la metodología desarrollada es detallada en el
capítulo 5 de este documento.
4.5 CONSTRUCCIÓN DE LOS MODELOS
Los componentes principales de los sistemas de detección de intrusiones forense son los
modelos de detección que caracterizan un perfil de comportamiento, con el cual será
posible llevar a cabo una exitosa detección de intrusiones. Estos modelos están
conformados por el modelo del historial y el modelo de la bitácora de validación y su
caracterización es llevada a cabo mediante el establecimiento de métricas y modelos
estadísticos. Por lo tanto, para construir estos modelos se propone el uso de cuatro
62
clasificadores de datos: diagramas de caja, k-medias en línea, matriz de factorización no
negativa, y modelos ocultos de Markov; éste último han sido complementados con el uso
de K-medias y la implementación de ambos algoritmos ha sido nombrada KHMM.
Los diagramas de caja son representaciones gráficas que describen características de los
datos, por lo que pueden ser usados como clasificadores. Dentro de las métricas
estadísticas, ésta fue elegida para dar solución al problema de detección de intrusiones, ya
que asocia cinco medidas estadísticas para la extracción de información sobre la dispersión
y simetría de los datos que son analizados permitiendo identificar observaciones que se
alejan inusualmente del resto de los datos. Además, esta técnica es fácil de construir e
interpretar.
El siguiente algoritmo implementado es el de k-medias en línea, éste es una variante de k-
medias, la diferencia entre estas dos metodologías radica en que k-medias en línea realiza
una reasignación de los centros por cada dato analizado, mientras que k-medias reasigna los
centros después de cada iteración, es decir después de que analiza todo un conjunto de
datos, razón por la cual es posible obtener mejores resultados de clasificación. En el área de
detección de intrusiones el algoritmo k-medias en línea no ha sido considerado. Sin
embargo, k-medias tiene sus aportaciones en sistemas basados en red. El último trabajo que
implementa k-medias es el [Jianliang et al., 2009], y fue usado para agrupar y analizar los
datos en la detección, sus resultados mostraron que el método es capaz de detectar ataques
desconocidos.
Otro de los algoritmos usados para la construcción de los modelos de detección es el de
matriz de factorización no negativa. El uso de este algoritmo fue basado en el trabajo de
[Mex et al., 2006], quienes enfocan sus esfuerzos en proveer una metodología para la
detección de intrusiones que enmascaran su comportamiento intrusivo como
comportamiento normal. Su metodología consiste en el uso de matrices de factorización no
negativa con ayuda de una fase de normalización que mejora la clasificación de los datos.
El más reciente trabajo relacionado con el uso de este algoritmo es el de [Mex et al., 2008],
desarrollado para detección de intrusiones en redes móviles.
63
Por último, el algoritmo más completo de nuestra metodología es el de modelos ocultos de
Markov complementado con el uso de K-medias. Esta unión de métodos se llevo a cabo
con el propósito de hacer un agrupamiento previo a la clasificación, tal que el proceso de
clasificación fuera más exacto. Los modelos ocultos de Markov han sido ampliamente
usados en diversas aplicaciones, tales como detección de intrusiones, reconocimiento del
habla, aplicaciones de bio-informática, entre otros. Específicamente, este método ha sido
considerado como parte de nuestra metodología por los resultados obtenidos en
investigaciones previas dentro del área de detección de intrusiones.
En 1999 en el trabajo de [Lane, 1999] se investigó el uso de HMM para crear perfiles de
usuario. En ese mismo año en la investigación de [Warrender et al., 1999] usaron HMM
como el modelo de detección usando llamadas al sistema. Más tarde en el trabajo de [Jha et
al., 2001], se presenta un método de detección de anomalías que usa cadenas de Markov
para construir el clasificador y sus resultados fueron parecidos a los experimentos
realizados por [Warrender et al., 1999] dos años antes. En [Gao et al., 2006] se usa el
método HMM para modelar dos comportamientos y se propone una medida de distancia
para evaluar desviaciones de comportamiento normal.
El uso de modelos ocultos de Markov ha sido combinado con el uso de K-medias, el
objetivo de esta variante es mejorar el proceso de clasificación, ya que éste primero agrupa
con K-medias las observaciones de datos en conglomerados con base en sus características.
Después de obtener esos conglomerados los HMM´s son entrenados para generar los
modelos de detección. En el capítulo 5 se extiende el uso de esta técnica, al igual que el de
diagramas de caja, k-medias en línea y NMF.
4.6 DETECCIÓN DE INTRUSIONES FORENSE
El proceso de detección de intrusiones de nuestra metodología consta de dos etapas
principales: la primera consiste de una comparación de los dos modelos generados,
mientras que la segunda etapa, filtra las anomalías extraídas de la primera etapa que se cree
64
representan falsas alarmas. Esta segunda etapa se lleva a cabo con la finalidad de mejorar el
proceso de detección de intrusiones.
A partir del modelo del historial, Go y el modelo Gv=<q1, q2, q3,…> extraído de una
bitácora de validación, donde qi corresponde a una wj en Wv. Nuestra metodología de
detección de intrusiones forense realiza una comparación de los valores de qi contra Go.
Para el proceso de comparación, definimos la función d(qi, Go), que calcula la distancia
entre los modelos qi y Go. Si d(qi, Go) > u, donde u es un umbral precisado a partir de Go,
entonces, la ventana wj en Wv que corresponde a qi, es etiquetada como anómala.
La salida del proceso de comparación es una secuencia, A= <a1, a2, a3,…> en la cual, la
variable, ak, es una etiqueta que puede tomar dos posibles valores: normal o anómalo, y el
orden de ak en A es igual al orden de wj en Wv. Por lo tanto, cada valor de ak corresponde a
una ventana wi en Wv.
Debido a que las ventanas analizadas incluyen traslapes entre ellas, y la longitud de la
ventana es al menos de la misma longitud que una secuencia generada por un ataque
pequeño, cualquier ataque se localiza en más de una ventana. Para delimitar la detección de
ataques, después del proceso de comparación en el que se encontraron las ventanas con
posibles anomalías, se ha aplicado un filtro como parte del proceso.
El filtro consiste en descartar las ventanas anómalas que están aisladas de uno o varios
conjuntos anómalos; es decir, esta eliminación únicamente es aplicada cuando aparece una
sola ventana aislada. La Figura 11 muestra un ejemplo del uso de este filtro. Después del
filtro, la primera y última ventanas etiquetadas como anómalas representan el inicio y fin
del segmento de ataque.
Si durante la aplicación de éste último filtro se encuentran dos o más conjuntos de ventanas
anómalas separadas, sin importar la cantidad de ventanas normales que se encentren entre
ellas, cada conjunto es considerado un ataque distinto, como se muestra en la Figura 11.
65
Figura 11 Ejemplo de la última etapa en el proceso de detección de intrusiones.
4.7 CONCLUSIONES
El éxito de la metodología de detección de intrusiones forense propuesta en esta
investigación depende principalmente de los métodos de clasificación implementados como
parte de ella. Sin embargo, hemos mejorado el uso de estos métodos mediante la aplicación
del algoritmo Sequitur, el cual nos permite reducir la carga de trabajo en la construcción de
los modelos de detección de intrusiones, incorporando una etapa de factorización que
elimina repetición de llamadas al sistema en las bitácoras analizadas. Al mismo tiempo, que
permite la extracción de características de los datos para la construcción de los modelos de
detección. En el capítulo 5 se detalla el uso de los métodos de clasificación en la
construcción de los modelos de detección.
Inicio del segmento atacado
Se elimina
Fin del segmento atacado
Inicio del segmento atacado
Se elimina
Fin del segmento atacado
66
5 CONSTRUCCIÓN DE LOS MODELOS DE DETECCIÓN
5.1 INTRODUCCIÓN
Para resolver el problema de detección de intrusiones forense, hemos enfocado nuestros
esfuerzos en encontrar diferencias que nos permitan discernir entre el perfil de
comportamiento “normal” de un sistema contra el perfil de comportamiento “anómalo” que
arroja la ejecución de un ataque sobre ese mismo sistema, o en su defecto, sobre un sistema
con características de configuración iguales, o similares.
Con la finalidad de cumplir nuestro objetivo, en el capítulo anterior hemos presentado
nuestra metodología propuesta para detección de intrusiones forense. El diseño de esta
metodología se basa principalmente en la construcción de dos modelos de detección. El
primer modelo corresponde al historial de un sistema y el segundo a la bitácora que será
validada acerca de posibles ataques en ella. Ambos modelos son construidos bajo ciertas
características extraídas de nuestros datos de experimentación, después de que estos han
sido pre-procesados y segmentados por ventanas deslizantes que forman un vector de
características, Vi, de m × n, donde i indica a qué datos pertenece V, historial o bitácora de
validación, m representa el número de ventanas, v, o segmentos arrojados por el ventaneo, y
n es el número de características elegidas de los datos de cada una de las ventanas.
67
El modelo de detección constituido tanto por el modelo del historial como el de la bitácora
de validación se creó usando algoritmos de clasificación y los datos que alimentan estos
métodos, corresponden a la información incluida en el vector de características, Vi. El
desarrollo de este capítulo lo iniciamos con la descripción del conjunto de datos que han
sido usados para este propósito, seguida por la descripción de las características que fueron
consideradas para la construcción de nuestro modelo de detección. Posteriormente,
ofrecemos al lector las especificaciones de uso de cada algoritmo empleado: diagramas de
caja, k-medias en línea, matriz de factorización no negativa (NMF) y la fusión de modelos
ocultos de Markov junto con K-medias, a la cual hemos llamado KHMM. Finalizamos con
una breve discusión acerca del capítulo.
5.2 DESCRIPCIÓN DEL CONJUNTO DE DATOS
En la construcción y evaluación de los modelos de detección se realizaron una serie de
experimentos, para los cuales se emplearon dos conjuntos de bitácoras de llamadas al
sistema. El primero corresponde a las bitácoras libres de ataque usadas para la construcción
del modelo del historial. El segundo conjunto comprende una serie de bitácoras, las cuales
contienen varios ataques con el propósito de evaluar el rendimiento de detección de los
métodos que forman parte de nuestra metodología. En las siguientes dos secciones, 5.2.1 y
5.2.2 se describen los dos conjuntos de datos usados, respectivamente.
5.2.1 DATOS EN LA CONSTRUCCIÓN DEL MODELO DEL HISTORIAL
Para la construcción del modelo del historial, como se ha mencionado previamente, el
objetivo fue capturar el comportamiento global de un sistema cualquiera mientras éste se
encuentra en condiciones seguras. Razón por la cual, se recolectaron 25 bitácoras de
llamadas al sistema generadas en 3 máquinas con diferentes versiones del mismo sistema
operativo por 3 usuarios. La Tabla 2 muestra las máquinas con los sistemas operativos
usados por los usuarios y el número de bitácoras generadas por cada uno de ellos.
68
Usuarios Máquina Sistema Operativo Bitácoras Generadas
1 1 Fedora 8.0 5
2 Red Hat Enterprise 4.0 5
2 1 Fedora 8.0 5
2 Fedora 10.0 5
3 3 Ubutu 9.1 5
Tabla 2 Generación de bitácoras para la construcción del modelo del historial.
Dentro de cada bitácora de llamadas al sistema generada se aseguró que la actividad
habitual de cada uno de los usuarios, en su mayoría, quedará registrada. Por otro lado, sin
importar la versión de Linux usada, todas ellas implementan el mismo conjunto de llamadas
al sistema ya que se basan en el mismo sistema, Unix. La Tabla 3 muestran el tamaño en
KB y el número de llamadas al sistema de las bitácoras generadas por cada usuario.
Usuario 1
Bitácora Historial
Tamaño (KB)
# Llamadas al Sistema
1 56712 636903 2 23132 255080 3 66067 651181 4 112762 1458625 5 113877 1619356 6 38019 419229 7 77575 867072 8 10115 123946 9 7923 91299 10 12804 161987 (a) Bitácoras generadas por el usuario 1.
Usuario 2
Bitácora Historial Tamaño (KB) # Llamadas
al Sistema 1 52727 588049 2 53074 601109 3 2358 30899 4 33338 368110 5 30020 348315 6 10441 117275 7 3383 41488 8 60392 647372 9 31655 333615 10 23139 228352
(b) Bitácoras generadas por el usuario 2.
Usuario 3
Bitácora Historial Tamaño (KB) # Llamadas
al Sistema 1 130222 15018322 10756 139691 3 4054 37049 4 55404 592546 5 12438 106800
(c) Bitácoras generadas por el usuario 3.
Tabla 3 Bitácoras generadas por los usuarios 1 (inciso a) , 2 (inciso b) y 3 (inciso c).
69
5.2.2 DATOS EN LA CONSTRUCCIÓN DEL MODELO DE LA BITÁCORA DE VALIDACIÓN
Para la construcción de los modelos de las bitácoras de validación, se generaron 7 bitácoras
por 3 usuarios en 3 computadoras. Cada una de estas bitácoras corresponde a 8 horas de
captura, de las cuales, 5 incluyen la ejecución de algunos ataques. Estos ataques fueron
inyectados aleatoriamente mediante un programa durante la sesión monitoreada.
Las Tabla 4 y Tabla 5 muestran la información relacionada con las bitácoras creadas para la
etapa de validación, en la Tabla 4 se puede observar el usuario que la generó, la máquina
identificada por un número y el sistema operativo usado, un número consecutivo que
identifica cada una de las 7 bitácoras, así como el número de ataques que fueron ejecutados
en los sistemas que ellas representan. Como se puede observar en la tabla, la bitácora 5 es
la única que se generó por dos usuarios distintos.
Usuario Máquina Sistema Operativo Bitácora # Ataques
1
1 Fedora 8.0 1 7
1 Fedora 8.0 3 0
2 Red Hat 9.0 6 7
2 2 Red Hat 9.0 2 0
3 Ubuntu 5.0 5 7
3 1 Fedora 8.0 4 11
3 Ubuntu 5.0 7 13
Tabla 4 Generación de las bitácoras de validación.
Para complementar la información de la Tabla 4, en la Tabla 5 se presenta información
adicional de las bitácoras de validación generadas. El propósito de esta tabla es mostrar el
tamaño de cada bitácora de validación medido en KB y su longitud en términos del número
de llamadas al sistema que las conforman. La primera columna es el identificador numérico
de la bitácora (mismo identificador de la Tabla 4) y la segunda columna indica si incluye o
no ataques.
70
Bitácora Validación Atacada # Llamadas al Sistema Tamaño (KB)
1 Si 10359484 923843
2 No 3844113 349275
3 No 5656301 512975
4 Si 5431717 456239
5 Si 6450701 523579
6 Si 4367746 380779
7 Si 7299279 670851
Tabla 5 Bitácoras de validación.
Los ataques inyectados en las bitácoras de validación explotan 5 vulnerabilidades distintas
en diferentes versiones de Linux, cuatro de esas vulnerabilidades corresponden a un
desbordamiento de búfer y una a race condition6, los ataques que explotan ambas
vulnerabilidades pertenecen a la clasificación de ataques de tipo elevación de privilegios.
La Tabla 6 muestra los ataques recolectados en esta etapa, el sistema operativo vulnerable
usado y una breve descripción de su funcionamiento.
Ataque Sistema Operativo Descripción vmsplice Fedora 8.0 Aprovecha una vulnerabilidad de tipo
desbordamiento de búfer en la llamada al sistema vmsplice.
Vmsplice 2 Fedora 8.0 Aprovecha una vulnerabilidad de tipo desbordamiento de búfer en la llamada al sistema vmsplice.
kon Red Hat 9.0 Aprovecha una vulnerabilidad de tipo desbordamiento de búfer sobre la aplicación /usr/bin/kon.
copy_from_user Ubuntu 5.0 Aprovecha una vulnerabilidad de tipo desbordamiento de búfer en la llamada al sistema copy_from_user.
Race condition al cambiar dueño de un
archivo
Fedora 8.0 Aprovecha una vulnerabilidad de tipo race condition al cambiar el dueño de un archivo mediante la llamada al sistema chown.
Tabla 6 Ataques usados en la etapa de validación de nuestra experimentación.
6 Un race condition ocurre cuando el sistema realiza dos o más operaciones al mismo tiempo, sin embargo debido a la naturaleza del sistema, las operaciones deben ser realizadas de forma secuencial.
71
5.3 CARACTERÍSTICAS DE LOS DATOS
Para la construcción de los modelos de detección, nuestra metodología propone el uso de
ciertos atributos, o características de comportamiento, –este último término es el que
hemos empleado a lo largo de este documento–, las cuales nos ofrecen información acerca
del factor de repetición de una bitácora, con el cual creemos obtener un mecanismo de
medición de lo que representa el comportamiento normal y anómalo de un sistema y así
tener la capacidad de distinguirlos entre sí; esto, basado en la hipótesis de que la ejecución
de un ataque refleja una secuencia de llamadas al sistema distinguible del resto, que han
sido producidas por cualquier otro proceso que generalmente es solicitado en un sistema.
Además, el comportamiento normal se vuelve repetitivo debido a que los programas en un
sistema no cambian drásticamente y a que un usuario tiene cierta tendencia a ejecutar en
repetidas ocasiones las mismas aplicaciones.
Con la finalidad de seleccionar de manera más precisa las características de
comportamiento que proporcionan información útil durante la etapa de construcción de los
modelos de detección, se llevó a cabo un análisis estadístico con el cálculo de media y
desviación estándar sobre ciertas características (medibles) de elementos extraídos de las
bitácoras pre-procesadas. A continuación se listan estas características.
1. Media de llamadas al sistema consecutivas. Esta variable indica la media de
llamadas al sistema consecutivas que se encuentran en una ventana
2. Número máximo de llamadas al sistema consecutivas. Consideramos que el número
de llamadas al sistema consecutivas es un indicador pertinente acerca de
anormalidad, en el que esperamos identificar un ataque a mayor número de
llamadas al sistema consecutivas encontradas en una ventana o varias ventanas.
3. Número máximo de meta-símbolos consecutivos. Esta característica al igual que la
siguiente mide el grado de reducción de una ventana respecto al número de meta-
símbolos que se localizan en la misma.
72
4. Longitud de la ventana sin reducción. Con este valor podemos observar el tamaño
real de una ventana sin reducción, una menor reducción aumenta las probabilidades
de que un ataque haya sido ejecutado en esa(s) ventana(s).
5. Número de llamadas al sistema. Al igual que la característica 2, ésta fue
seleccionada esperando discernir anormalidad de normalidad a menor grado de
reducción en una ventana. El valor de esta medida generalmente será mayor al de la
característica 2 y en el peor de los casos igual a ésta, por lo que, se considera
complementaria a la característica 2.
6. Número de meta-símbolos. Mide el número de meta-símbolos encontrados en una
ventana de elementos y se cree que este valor es de gran utilidad en la identificación
de comportamiento normal en el sistema; la hipótesis de esto consiste en que a
mayor número de meta-símbolos, mayor reducción de llamadas al sistema en una
ventana.
7. Número de llamadas al sistema distintas. Se eligió esta medida considerando que la
ejecución de un ataque probablemente reflejará un mayor número de llamadas al
sistema distintas.
8. Número de meta-símbolos distintos. A pesar de que se cree que el comportamiento
normal tiene un mayor factor de reducción, es posible que el comportamiento
anormal también sea reducido de la misma forma. Sin embargo, midiendo la
variabilidad de meta-símbolos suponemos que es más eficiente diferenciar un
ataque, ya que éste indica un comportamiento no repetitivo.
9. Media de llamadas al sistema exitosas. Esta variable mide el promedio de llamadas
por ventana que fueron ejecutadas sobre el sistema con éxito. Por lo tanto, esta
medida nos facilita la identificación de un ataque en una bitácora, específicamente,
cuando se analizan aquellos ataques que dependen de la ejecución fallida de una
llamada al sistema, como son los ataques de desbordamiento de búfer.
73
Estas características son extraídas en el orden listado previamente, para cada ventana de
elementos que conforma el vector de entrada a los algoritmos diagramas de caja, k-medias
en línea, NMF y KHMM. Dicho orden fue determinado con base en la importancia de cada
una de ellas. Para lo cual, se llevaron a cabo una serie de experimentos, mismos que
consistieron en usar cada una de las características por separado para la construcción de un
modelo de detección y así evaluar con cuál de ellas se obtiene el menor porcentaje de falsos
positivos y falsos negativos; es decir, los mejores resultados de detección de intrusiones.
Los experimentos se condujeron de la siguiente forma: se eligió una sola bitácora del
historial previamente capturado, ésta fue reducida y segmentada en ventanas de longitud
100, tal como se menciona en la metodología de detección propuesta en la sección 4.2. Para
cada ventana se obtuvieron los valores de una de las características y se calculó la media y
la desviación estándar. Con base en estas medidas se extrajeron tres límites superiores y
tres inferiores, los cuales fueron el resultado de sumar y restar respectivamente a la media,
la desviación estándar multiplicada por 0.8, 1 y 1.3; estos valores los hemos considerado
representativos de comportamiento normal. Sucesivamente se calcularon los límites de
comportamiento normal (tres superiores y tres inferiores) para cada una de las
características restantes.
Posteriormente, para determinar la importancia de las características; es decir, cuál de ellas
provee mejor grado de detección, se evaluaron los límites de normalidad calculados con
cada una de ellas. Para este propósito, se seleccionaron aleatoriamente dos bitácoras de
nuestro conjunto de validación, una de ellas libre de ataque, mientras que la otra incluye la
ejecución de un ataque de tipo desbordamiento de búfer. Estas dos bitácoras de evaluación
fueron reducidas y segmentadas en ventanas como se presentó en la metodología y sobre
esta segmentación se calcularon los valores de las nueve características, cada uno de ellos
fue comparado contra los límites de normalidad establecidos previamente, y si cualquiera
de esos valores se sale de los límites (superior e inferior), entonces la ventana es
considerada anómala. Los resultados de este análisis son mostrados en la gráfica 5.1, en
donde se observan las curvas ROC consideradas en la priorización de las características.
74
Gráfica 5.1. Curvas ROC obtenidas durante la evaluación de las características.
Como se observa en la gráfica 5.1, los resultados de esta experimentación nos proporcionan
las bases para determinar el orden de importancia de las características de comportamiento,
de tal manera que la característica que ofrece el menor porcentaje de falsos positivos y
negativos, en este caso la media de llamadas al sistema consecutivas, es considerada la más
importante.
Para ejemplificar algunas de las características de comportamiento, consideremos la
siguiente secuencia de elementos: w = < sc1, sc2, sc3, m1, s4, m2, m3, m3, sc1, sc1, sc2, sc2, m1,
m2>. Con la finalidad de facilitar la estimación de los valores, en este ejemplo, que
corresponden a cada característica, hemos separado las sub-secuencias de llamadas al
sistema de las sub-secuencias de meta-símbolos, respetando su orden de aparición en la
secuencia de entrada. De esta forma tenemos: as = < sc1, sc2, sc3>, bs = < sc4>, cs = < sc1,
sc1, sc2, sc2> y am = < m1>, bm = < m2, m3, m3>, cm = < m1, m2>.
60
65
70
75
80
40 45 50 55 60 65 70
Falsos Negativos (%
)
Falsos Positivos (%)
1. Media de llamadas al sistema consecutivas 2. Número máximo de llamadas al sistema consecutivas
3. Número máximo de meta‐símbolos consecutivos 4. Longitud de la ventana sin reducción
5. Número de llamadas al sistema 6. Número de meta‐símbolos
7. Número de llamadas al sistema distintas 8. Número de meta‐símbolos distintos
9. Media de llamadas al sistema exitosas
75
El número máximo de llamadas al sistema consecutivas corresponde a la longitud más
grande de las sub-secuencias de llamadas, cs. La segunda característica es la suma de as, bs
y cs. La media de llamadas consecutivas es el promedio de longitudes de as, bs y cs. Para
calcular la media de llamadas exitosas, es necesario descomponer cada uno de los meta-
símbolos de la secuencia analizada, w, por su correspondiente regla de producción y hacer
un mapeo de w descompuesta en la bitácora original, con la finalidad de esclarecer cuales
de las llamadas al sistema fueron ejecutadas satisfactoriamente en el sistema cuando se
invocaron por un proceso. Suponiendo que sc1 y sc2 son exitosas y que dentro de los meta-
símbolos ninguna llamada fue satisfactoria, la media de llamadas exitosas, es el número de
veces que aparece sc1 y sc2 entre el total de llamadas al sistema de w descompuesta. El
mismo procedimiento se sigue para extraer los valores de las características que
corresponden a los meta-símbolos en w.
Con el uso de las características de comportamiento mencionadas previamente, hemos
podido diferenciar entre las llamadas al sistema que corresponden a un sistema en
situaciones seguras, de aquellas que expresan la existencia de un ataque. Por lo que,
basamos la detección de intrusiones forense en el uso de estas características, como
mejoramiento de la calidad de nuestra información, la cual nos permitirá obtener mejores
resultados en la etapa de clasificación de nuestro modelo de detección. En las siguientes
secciones, presentamos la forma en que se usaron las características en la construcción de
nuestros modelos.
5.4 MODELOS CON DIAGRAMAS DE CAJA
En la solución de cualquier problema, sin importar el área de investigación, los datos que
serán analizados deben recolectarse de tal forma que ofrezcan información vital, necesaria
para dar solución al problema estudiado. Una vez que se han reunido esos datos, estos
deben ser descritos y analizados para producir información resumida que oriente en la toma
de decisiones respecto a la solución del problema. Las representaciones gráficas son una
manera eficaz de analizar esta información. Por lo que, en nuestra metodología de
detección de intrusiones forense, hemos usado una de las representaciones gráficas poco
76
explotadas en esta área y cuyas características prometen aportar información suficiente para
nuestro propósito, esta representación corresponde a los diagramas de caja.
Debido a que el comportamiento normal de un sistema es repetitivo, mientras que la
ejecución de un ataque genera un perfil de comportamiento inusual en el sistema,
justificamos el uso del método de diagramas de caja, considerando que entre los límites
superior e inferior del diagrama se localizan más del 75% de los datos debido a que la
mayoría de los valores de la función modelada difieren ligeramente (comportamiento
normal) y solo unos cuantos se salen de lo común (comportamiento anómalo).
Para construir los modelos de nuestra metodología de detección de intrusiones forense con
los diagramas de caja, se hicieron pruebas usando las bitácoras del historial (ver Tabla 2) y
tres bitácoras aleatorias del conjunto de las bitácoras de validación que incluyen un ataque
distinto, Tabla 4, de esta forma encontramos la constante más apropiada en la definición de
los límites superior e inferior del vector de características de los datos representativos del
comportamiento normal. Generalmente, el valor de esa constante es de 1.5, debido a que
con este número se logra capturar el 95% de los datos dentro de los límites establecidos.
Sin embargo, para fines de un obtener un modelo más descriptivo de los datos que son
analizados, es posible modificar esa constante, de tal manera que se reduzcan o amplíen los
límites, hasta obtener la mejor clasificación de nuestros datos de entrada.
Mediante curvas ROC, se modelaron las características de las bitácoras del historial y de
tres bitácoras que incluyen un ataque distinto, el cual fue ejecutado en un ambiente
controlado y se conoce el lugar exacto de la ejecución de éste en la bitácora. Las pruebas se
realizaron usando cuatro valores de constantes distintas para definir los límites superior e
inferior. Los valores de las constantes usadas fueron: 1, 1.25, 1.5 y 1.75. En la gráfica 5.2
se muestra una comparación de los falsos positivos (eje de las x’s) y falsos negativos (eje de
las y’s) generados por el análisis de las tres bitácoras con ataque, y con las cuales se usaron
los límites definidos por cuatro distintas constantes. De acuerdo con este análisis, se
determinó que la constante a usar en la construcción de los modelos del historial es de 1.5
para obtener mejores resultados en el proceso de detección.
77
Gráfica 5.2. Comparación de los límites superiores para la media de llamadas al sistema consecutivas, usando
el historial de un sistema (línea azul) y una bitácora atacada (línea roja).
La entrada al método de diagramas de caja para modelar el historial y la bitácora de
validación es un vector de características de comportamiento V. Para el uso de este método,
primero se calculan los cuartiles, Q1, Q2 y Q3, y los límites superiores e inferiores definidos
para el modelado de los valores atípicos se infieren de las siguientes fórmulas:
1. IQR = Q3 – Q1
2. LS = mediana + (1.5 * IQR)
3. LI = mediana – (1.5 * IQR)
El valor de 1.5 significa que la caja del diagrama extienden el rango intercuartil 1.5 veces
desde la mediana. La salida del método es una gráfica para cada una de las características
consideradas, mediante la cual podemos determinar si una ventana de datos analizada
corresponde a una anomalía. Hemos considerado dos factores de decisión acerca de la
anormalidad de una ventana:
15
20
25
30
35
40
20 25 30 35 40
Falsos Negativos (%
)
Falsos Positivos (%)
1. Bitácora 1 2. Bitácora 2 3. Bitácora 3
78
1. Si el resultado del método muestra comportamiento anómalo para una o más
características de una ventana, entonces la ventana es etiquetada anormal.
2. Si el resultado del método muestra comportamiento anómalo para la mitad o más de
las características de una ventana, entonces la ventana es anormal.
La salida del método es un modelo representado por un vector Go de m × 2, donde m es
igual al número de elementos de Vi; es decir, m se define respecto al número de ventanas de
características que fueron analizadas. La primera columna es el identificador de la ventana
y la segunda corresponde a su clasificación, la cual puede tener el valor de 1 o 2, donde 1 es
representativo de normalidad y 2 de anomalía en el sistema.
5.5 MODELOS CON K-MEDIAS EN LÍNEA
El método de k-medias en línea nos da la funcionalidad de agrupar los dantos en función de
la similitud que existe entre ellos. El uso de este algoritmo como clasificador de
comportamiento para dar solución al problema de detección de intrusiones lo basamos en la
hipótesis de que los valores representativos del perfil de comportamiento normal quedan
agrupados en un mismo grupo. En cambio, esperamos que los valores pertenecientes a un
comportamiento anómalo sean agrupados en un nuevo grupo. Este algoritmo, lo hemos
usado en nuestra metodología, ya que tenemos la certeza de que las bitácoras del historial
del sistema que será modelado son libres de ataque. Por lo tanto, cualquier ventana de
características agrupada en una clase distinta a la de la mayoría de las ventanas de las
bitácoras del historial, es clasificada como anómala.
En la construcción de nuestro modelo de detección, la entrada a este proceso es un vector
de características V, como lo hemos mencionado en el capítulo 4, que corresponde tanto a
las bitácoras del historial, Tabla 2, como a cada una de las bitácoras de validación, Tabla 4;
es decir, V = VH ∪ VE, donde VH fue extraído del historial y VE de la bitácora de validación.
Cada elemento del vector V es sometido a una etapa de normalización, con la finalidad de
estandarizar los valores de V y obtener una mejor clasificación. Esta fase, nos da como
salida, VN, que es usada como entrada al algoritmo K-medias en línea.
79
El proceso de clasificación de comportamiento con K-medias en línea para la detección ha
sido llevado a cabo mediante dos iteraciones. Para la primera iteración, en la fase de
asignación del algoritmo, se seleccionaron aleatoriamente dos elementos de V, los cuales
para K-medias representan los centros de iniciación considerados para llevar a cabo la
clasificación. El resultado de esta primera iteración, arroja dos nuevos centros que son
usados en la segunda iteración del algoritmo. La salida de K-medias en línea, al igual que
en los diagramas de caja, es un modelo representado por un vector Go de m × 2, donde m es
igual al número de elementos de V y donde la segunda columna corresponde a la
clasificación de la ventana m, la cual puede tomar el valor de normal o anómalo.
5.6 MODELOS CON NMF
El uso del método de matriz de factorización no negativa (NMF) lo basamos en el trabajo
de Carlos Mex Perera y su equipo de trabajo especializado en detección de intrusiones
[Mex et al., 2006], quienes han obtenido resultados competitivos en el área. Para la
aplicación de este algoritmo dentro de nuestra metodología, se usaron las primeras 20
bitácoras del historial (ver Tabla 2) para entrenamiento del método. Las 5 bitácoras
restantes del historial fueron usadas para estimar un valor delta D, el cual es usado como
umbral representativo de comportamiento normal.
Específicamente, en la construcción del modelo de detección, el algoritmo NMF trabaja
mediante tres etapas. En la primera etapa la entrada a NMF es un vector de características
VH1, extraído de las primeras 20 bitácoras del historial. La salida del algoritmo en esta fase
es una matriz H, la cual representa la factorización del vector de entrada. La siguiente fase
es un proceso iterativo, en el cual durante cada iteración se recibe como entrada a NMF la
matriz H y cada uno de los elementos (renglones) del vector de características VH2
generado con las 5 bitácoras del historial que no fueron consideradas en la etapa previa. La
salida de NMF en cada iteración es un valor delta D, obteniendo n número de deltas. Estos
valores delta son usados para calcular un umbral que representa el comportamiento normal
de un sistema. El umbral es obtenido calculando la mediana de los valores de delta.
80
Cualquier valor mayor al umbral es considerado anómalo, mientras que aquellos valores
iguales o menores al umbral son etiquetados como normales.
La tercera y última fase de NMF al igual que la segunda etapa, es un proceso iterativo que
consiste en proveer como entrada en cada iteración, la matriz H y un elemento (renglón) del
vector de características VE extraído de la bitácora de validación. La salida de esta etapa es
una delta D’, la cual es comparada contra el umbral; si su valor es mayor al umbral es
considerado anómalo, de lo contrario si el valor es igual o menor al umbral, entonces el
elemento es clasificado como normal. Finalmente la salida de nuestro modelo usando NMF
es un vector Go de m × 2, donde m es igual al número de elementos de VE y la segunda
columna corresponde a la clasificación de la ventana w en la posición m.
5.7 MODELOS CON KHMM
Para usar los modelos ocultos de Markov en la construcción de los modelos de detección,
hemos aplicado una variante, la cual requiere de un pre-procesamiento de los datos
analizados con el algoritmo K-medias. Esta combinación de métodos la hemos llamado
KHMM y basamos su uso en el trabajo de [Avilés et al., 2009]. El uso de KHMM en la
clasificación de comportamiento consiste en un pre-procesamiento de las características de
comportamiento del historial y la bitácora de validación, para así construir cada uno de los
modelos de detección, respectivamente. La salida de K-medias es un conjunto de
aglomeraciones de los elementos del vector de entrada Vi, donde i indica a qué datos
pertenece V, historial o bitácora de validación.
K-medias agrupa los elementos de Vi de acuerdo a la similitud de sus características de
comportamiento. Sin embargo, como parte del procedimiento del algoritmo, se debe
agregar un parámetro que corresponde al número de grupos que serán creados. Para
calcular este parámetro, hemos usado el algoritmo de agrupamiento substractivo (o
substractive clustering). Este algoritmo clasifica un conjunto de datos respecto a la
distancia que existe entre ellos. El Figura 12 muestra el resultado de uno de los
experimentos realizados, donde se puede ver el número de grupos que son seleccionados
81
considerando diferentes puntos de distancia para una muestra de las bitácoras del historial.
Como se observa en el cuadro, entre las distancias 0.04 y 0.0418 hay una variabilidad
menor del número de grupos de extraídos.
Distancia entre los datos Número de grupos generados
0.05 → 273 0.04 → 1900 0.041 → 1808
0.0415 → 1682 0.0418 → 1530 0.0419 → 599
0.042 → 527 0.043 → 422 0.044 → 375 0.045 → 341
Figura 12 Salida del algoritmo Substractive Clustering considerando los datos de una bitácora del historial. La distancia entre los datos corresponde a la distancia que hay entre cada punto de datos. El número de grupos generado es la cantidad de aglomerados respecto a la distancia de los datos.
Usando los parámetros de 512 y 1500 y el vector, Vi, como entrada a K-medias, nuestra
salida es una secuencia de grupos, Zi, para cada Vi, donde Zi es la entrada al HMM para la
construcción del modelo. En la construcción de este HMM, necesitamos además de Zi el
número de estados del modelo, para obtener este número óptimo de estados usamos el
algoritmo mostrado en la Figura 13, mediante el cual obtenemos el número de estados
adecuado para generar el HMM.
El uso de este algoritmo también nos da como salida un HMM que modela las bitácoras del
historial de un sistema. Usando el número de estados generado, creamos varios HMM’s que
modelan cada elemento de VE donde E nos dice que V corresponde o fue extraída de la
bitácora de validación; es decir, de la bitácora que será evaluada para encontrar en ella
posibles ataques. Nuestro modelo de detección desarrollado, propone el uso de una función
de distancia entre los HMM’s de la bitácora de validación y el HMM del historial para
clasificar los datos en normal y anómalo.
La d
hemo
impl
librer
7 http:
Fi
distancia cal
os usado c
ementación
ría ya existe
://www.run.m
igura 13 Diagr
lculada entr
como parte
n de este al
ente de Java
montefiore.ulg.
rama del proce
re los HMM
del proce
lgoritmo qu
a, llamada J
.ac.be/~franco
eso usado en la
M’s generad
so de clas
ue ha sido
Jahmm7.
ois/software/ja
extracción de
dos por nue
ificación e
considerada
ahmm/
estados de un
estro model
s la de Ku
a en esta in
HMM.
lo de detecc
ullback Lei
nvestigación
82
ción, que
ibler. La
n es una
83
5.8 CONCLUSIONES
Usando métodos tan sencillos como diagramas de caja para clasificar y algoritmos
especializados como HMM’s es posible modelar el comportamiento de un sistema con la
finalidad de llevar a cabo detección de intrusiones forense. El algoritmo de K-medias en
línea es un método de agrupamiento que hemos usado para nuestro propósito, como método
de clasificación, debido a que tenemos datos sobre los cuales nos basamos para conocer lo
que pertenece a comportamiento normal de un sistema. Por lo que en la etapa de
construcción de un modelo de detección usamos ese conocimiento para llevar a cabo la
clasificación.
Los algoritmos que usamos para clasificación son suficientemente eficientes para permitir
detectar la ejecución de un ataque, y su metodología de implementación es también
alcanzable. Por otro lado, los atributos definidos y ordenados de acuerdo a su importancia
son útiles durante este proceso. Debido a lo cual, creemos que la combinación de la
medición de estos atributos junto con los métodos que proponemos usar nos brindará
buenos resultados de detección.
A lo largo de este capítulo hemos presentado los algoritmos usados en la construcción de
los modelos de detección de intrusión forense, así como una breve descripción acerca de las
bases teóricas de esos métodos. La forma de uso de tales algoritmos en nuestra metodología
de detección de intrusiones forense difiere ligeramente entre ellos. Sin embargo, la salida
de éstos representa el modelo de detección propuesto en el capítulo previo. En el capítulo 6
presentamos los resultados de cada uno de los métodos, haciendo una comparación respecto
su grado de detección.
84
6 EXPERIMENTOS Y RESULTADOS
6.1 INTRODUCCIÓN
Con el objetivo de evaluar nuestra metodología de detección de intrusiones forense, se han
conducido los experimentos considerando dos indicadores de rendimiento: el porcentaje de
falsos negativos (o alarmas perdidas) y porcentaje de falsos positivos, conocidos también
como falsas alarmas. El porcentaje de falsos negativos está directamente relacionado con el
porcentaje de detección y éste representa la cantidad de ventanas anómalas que no fueron
detectadas por la metodología respecto al número total de ventanas anómalas presentes en
una bitácora de validación, las cuales conforman un ataque. Los falsos positivos expresan la
cantidad de ventanas que son clasificadas incorrectamente como anómalas.
Adicionalmente, se llevó a cabo una evaluación de nuestra metodología mediante una
comparación de los resultados obtenidos contra el rendimiento de detección de Stide, un
sistema de detección de intrusiones desarrollado por Steve Hofmeyr [Hofmeyr et al., 1998]
y el cual se considera la principal investigación en el área de detección de intrusiones
basada en el análisis de llamadas al sistema. Stide construye una base de datos con
secuencias de llamadas al sistema de longitud fija, las cuales son extraídas de
comportamiento normal. Con esta base de datos el detector analiza series de tiempo o
conjuntos de series de tiempo, para lo cual inicia dividiendo estas series en un conjunto de
secuencias de longitud fija y compara ese conjunto contra la base de datos. Finalmente,
85
Stide reporta la consistencia de las series de tiempo con la base de datos existente. Para más
detalles de este detector ver sección 2.5.
Debido a la falta de conjuntos estándares de datos en la comunidad de investigación de
detección de intrusiones, es difícil realizar una comparación y evaluación objetiva de las
metodologías propuestas con este propósito. Por lo tanto, se ha recopilado una serie de
ataques de tipo elevación de privilegios para construcción y validación de la metodología
propuesta, así también se generaron una serie de bitácoras de llamadas al sistema
representativas del historial y otras más que incluyen la ejecución de alguno de los ataques
recopilados. Los detalles de estos ataques y las bitácoras generadas se detallaron en la
segunda sección del capítulo 5.
Para mostrar nuestros resultados de manera más expresiva, hemos recurrido al uso de
curvas ROC [Provost et al., 1998]. Estas curvas son una herramienta para análisis de
resultados que nos permite observar gráficamente el comportamiento de detección respecto
al porcentaje de falsos positivos y falsos negativos. La interpretación de estas curvas nos
dice que entre más cercanas estén al eje de los 0’s, significa que se tiene mayor precisión.
En este capítulo presentamos los detalles de nuestros experimentos y los resultados
obtenidos.
El capítulo se organiza de la siguiente forma: en la sección 6.2 se muestran los detalles de
la implementación de las técnicas de diagramas de caja, k-medias en línea, matriz de
factorización no negativa (NMF) y k-medias con modelos ocultos de markov (KHMM) en
los experimentos, incluido el sistema de detección de intrusiones Stide. En la sección 6.3 se
muestran los resultados obtenidos y el análisis de éstos. Los resultados son presentados con
base en dos análisis, en el primero evaluamos el comportamiento de detección de los
métodos considerando que el sistema monitoreado ha sido atacado. El segundo análisis se
monitorea un sistema que se cree ha sido atacado, pero no existe la presencia de ataque.
Finalizamos con la sección 6.4 correspondiente a las conclusiones del capítulo.
86
6.2 AMBIENTE DE EXPERIMENTACIÓN
Durante la etapa de experimentación, para la construcción de los modelos de detección se
empleó un equipo Intel Xeon corriendo a 2.99 GHz con 1.00 GB en memoria RAM y un
sistema operativo Microsoft Windows XP. La implementación de cada método aplicado en
la detección, se llevó a cabo usando las siguientes herramientas: Matlab 7.7.0, HTK8,
JAHMM9 y Stide_v2.1. En la Tabla 7 mostramos esas herramientas y los métodos que
fueron implementados en ellas.
Software Método
Matlab 7.7.0
Media y Desviación Estándar Diagramas de Caja K-medias en Línea y K-medias NMF
HTK HMM
JAHMM Distancia Kullback-Leibler
Stide_v2.1 Sistema de detección de intrusiones basado en anomalías.
Tabla 7 Herramientas usadas en los métodos de detección.
Para los métodos de media, desviación estándar, diagramas de caja, k-medias y k-medias en
línea, se usaron librerías propias del programa Matlab. Sin embargo, para la matriz de
factorización no negativa se uso un programa desarrollado por Carlos Mex-Perera
introducido en [Mex-Perera et al., 2006] que trabaja sobre Matlab.
Para la implementación de los modelos ocultos de Markov se ha usado el programa HTK
[Young et al., 2002] debido a que es una herramienta estable bien documentada y muy
explotada por investigadores en el área. Complementamos el uso de HTK con Jahmm para
calcular la distancia Kullback-Leibler entre dos HMM’s. Jahmm es una implementación en
8 http://htk.eng.cam.ac.uk/ 9 http://www.run.montefiore.ulg.ac.be/~francois/software/jahmm/
87
Java de los modelos ocultos de Markov y algoritmos relacionados. Para el uso del sistema
de detección de intrusiones Stide10 hemos instalado la versión más estable, v2.1.
En la siguiente sección se muestran los resultados obtenidos en la etapa de experimentación
con: diagramas de caja, k-medias en línea, matriz de factorización no negativa, la variante
de HMM’s que hemos llamado KHMM y Stide.
6.3 RESULTADOS EXPERIMENTALES
En el capítulo 5, sección 5.2 hemos presentado el conjunto de datos usado y las
especificaciones tecnológicas que condujeron la realización de los experimentos seguidos
en la validación de nuestra metodología de detección de intrusiones forense. A
continuación presentamos los resultados obtenidos con cada uno de los métodos propuestos
para la construcción de modelos de detección durante la etapa de experimentación.
Los resultados son divididos y presentados con base en dos escenarios. En el escenario uno,
se evalúa el comportamiento de detección de los métodos propuestos en nuestra
metodología, considerando una situación en la que el sistema monitoreado efectivamente ha
sido atacado. Para este escenario se usaron 5 de las 7 bitácoras de validación que incluyen
la ejecución de varios ataques, ver Tabla 5.
El segundo escenario comprende una situación en la que se cree que el sistema monitoreado
ha sido atacado, sin embargo no existe la presencia de un ataque, en este escenario se
evalúa el comportamiento de los métodos de detección ante la ausencia de ataques. Los
datos usados en el segundo escenario, son las 2 bitácoras de validación que no incluyen
ataques de la Tabla 5. En el resto del documento a una bitácora de validación, la
llamaremos bitácora.
10 http://www.cs.unm.edu/~immsec/data-sets.htm
88
Escenario 1. Para efectos de evaluación de los resultados obtenidos, en este primer
escenario hemos comparado los resultados considerando dos análisis.
1. El primer análisis muestra los resultados producidos con diagramas de caja, k-
medias en línea, NMF, KHMM y Stide para cada una de las bitácoras analizadas.
Cada gráfica de este análisis corresponde a una bitácora y en ella se observan las
curvas ROC generadas por cada uno de los métodos. Debido al funcionamiento de
K-medias en línea, los resultados de este método solo pueden ser representados
mediante un único punto en la curva ROC.
En este primer análisis una discusión acerca del factor de rendimiento (menor
porcentaje de falsos positivos y negativos) contra el tiempo que ocupó cada método
para la construcción de los modelos es llevado a cabo con el propósito de hacer una
comparación entre efectividad y rapidez.
Ese tiempo se muestra gráficamente para cada una de las bitácoras analizadas en
función de segundos y éste incluye tanto el tiempo de construcción del modelo de la
bitácora del historial como el de la bitácora de validación. A lo largo de la discusión
acerca de los resultados obtenidos, nos referimos a ese tiempo como el tiempo de
construcción del modelo de detección.
2. El segundo análisis muestra en una gráfica las curvas ROC obtenidas de un solo
método para todas las bitácoras exceptuando Stide, ya que éste ha sido evaluado en
el primer análisis. Es decir, hay solo cuatro gráficas, en las cuales cada curva es el
resultado de la detección de las bitácoras analizadas.
Primer Análisis
Como se puede ver en la gráfica 6.1 todas las curvas tienen diferente rendimiento en
distintas regiones de la gráfica. Sin embargo, nosotros estamos interesados en obtener el
mejor factor de rendimiento, el cual se obtiene con el menor porcentaje de falsos positivos
89
y falsos negativos; es decir, el mejor rendimiento corresponde a la curva más cercana al 0
en la gráfica (o incluso el punto más cercano).
La gráfica 6.1 muestra los resultados obtenidos con la bitácora 1 y se observa que la mejor
precisión corresponde al método de KHMM, mientras que la peor es la del método de K-
medias en línea. Por otro lado, el rendimiento de diagramas de caja y NMF están muy
cercanos entre ellos en los puntos que tienen un menor porcentaje de falsos negativos.
Evaluando los resultados de cada método contra Stide, se puede observar que KHMM,
NMF y diagramas de caja tienen mejores resultados que Stide.
En cada una de las gráficas de las curvas ROC de este primer análisis se muestra en un
cuadro el punto o los puntos que obtuvieron el mejor rendimiento respecto a todos los
métodos comparados.
Gráfica 6.1. Curvas ROC que muestra el rendimiento de los métodos con la Bitácora de validación 1.
En la gráfica 6.2 se observa que las curvas de KHMM, NMF y diagramas de caja están muy
cercanas entre ellas. Sin embargo, el mejor punto (marcado con un cuadro en la gráfica)
corresponde al método de diagramas de caja. Al igual que en la gráfica 6.1 el rendimiento
de KHMM, NMF y diagramas de caja mejora el de Stide.
K-medias en Línea NMF
Stide KHMM
Diagramas de Caja
19
24
29
34
39
44
49
1.5 2 2.5 3 3.5 4 4.5 5
Falsos Negativos (%
)
Falsos Positivos (%)
Bitácora de Validación 1
90
Gráfica 6.2. Curvas ROC que muestra el rendimiento de los métodos con la bitácora de validación 4.
La gráfica 6.3 muestra los resultados de rendimiento obtenidos con la bitácora 5. En ella se
puede ver que los diagramas de caja tienen el menor porcentaje de falsos positivos y
KHMM tiene el menor porcentaje de falsos negativos. Sin embargo, el punto con mejor
rendimiento es el de KHMM, el cual mantiene una ligera diferencia con el mejor punto de
diagramas de caja. Estos dos puntos fueron encerrados en un cuadro dentro de la gráfica.
Gráfica 6.3. Curvas ROC que muestra el rendimiento de los métodos con la bitácora de validación 5.
K-medias en Línea
Diagramas de Caja
Stide
NMF
KHMM
Diagramas de Caja
KHMM
NMF K-medias en Línea
Stide
12
17
22
27
32
37
42
1.5 2 2.5 3 3.5 4 4.5 5
Falsos Negativos (%
)
Falsos Positivos (%)
Bitácora de Validación 4
16
21
26
31
36
41
46
1.5 2 2.5 3 3.5 4 4.5 5
Falsos Negativos (%
)
Falsos Positivos (%)
Bitácora de Validación 5
91
La comparación con Stide demuestra una vez más que excepto por K-medias en línea los
métodos que se proponen para la detección de intrusiones forense obtienen mejores
resultados y esto se puede comprobar en las curvas ROC de la gráfica 6.3.
En la gráfica 6.4 se observa claramente que el mejor método para el análisis de la bitácora 6
fue KHMM, el mejor punto de éste método se encuentra encerrado en un cuadro. Stide se
mantiene superior a K-medias en línea pero lo mejoran diagramas de caja, NMF y KHMM.
Gráfica 6.4. Curvas ROC que muestra el rendimiento de los métodos con la Bitácora de validación 6.
En la gráfica 6.5 se observa que el método con mejor rendimiento durante el análisis de la
bitácora 7 fue KHMM. Se han encerrado en un cuadro los dos mejores puntos de éste
método. La evaluación con Stide demuestra que éste obtuvo el rendimiento más bajo.
A diferencia de las curvas de las bitácoras anteriores (de la 1 a la 6), en la gráfica 6.5 se ve
que el rango de falsos positivos va de 10 a 12.5 %. Esto se debe a que con la bitácora 7 en
particular, todos los métodos detectan un mayor porcentaje de falsos positivos lo que indica
que la bitácora presenta comportamiento anómalo a pesar de ser normal. En el segundo
análisis se detalla esta diferencia mediante gráficas y se hace una discusión al respecto.
Diagramas de Caja
NMF
K-medias en Línea
KHMM
Stide
1
6
11
16
21
26
31
36
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5 5
Falsos Negativos (%
)
Falsos Positivos (%)
Bitácora de Validación 6
92
Gráfica 6.5. Curvas ROC que muestra el rendimiento de los métodos con la Bitácora de validación 7.
Ya hemos visto el desempeño de cada uno de los métodos con las 7 bitácoras de validación.
A continuación mostramos una gráfica, en la cual se lleva a cabo un análisis del tiempo
requerido en la construcción de los modelos por los métodos implementados.
Gráfica 6.6. Tiempo de construcción del modelo de detección con cada uno de los métodos para las 7
bitácoras de validación.
K-medias en Línea
NMF
Diagramas de Caja
KHMM
Stide
10
20
30
40
50
60
70
80
90
10 10.5 11 11.5 12 12.5
Falsos Negativos (%
)
Falsos Positivos (%)
Bitácora de Validación 7
0
500
1000
1500
2000
2500
3000
3500
1 2 3 4 5 6 7
Tiem
po (seg)
Bitácora
Diagramas de Caja
K‐medias en Línea
NMF
KHMM
Stide
93
En la gráfica 6.6 se observa el tiempo en métrica de segundos que cada método empleó en
la construcción de los modelos de detección. Los números del eje da las x’s identifican las
bitácoras. En todos los casos (para las 7 bitácoras) NMF es el que ocupa menor tiempo en
la construcción del modelo de detección de intrusiones, seguido por K-medias en línea. Por
el contrario KHMM, el cual tiene mejor rendimiento de detección, ocupa mayor tiempo de
construcción seguido por Stide, éste último en alguno de los casos se traslapa con
diagramas de caja y en otros ocupa más tiempo que éste.
En este primer análisis hemos analizado la precisión de detección de intrusiones de cada
método para las siete bitácoras de validación. Las curvas han demostrado que KHMM es
mejor que los otros métodos, respecto al rendimiento, ya que tiene un menor porcentaje de
falsos positivos y negativos. Sin embargo, con la bitácora de validación 5, el método de
diagramas de caja en algunos puntos obtuvo mejor precisión que KHMM y en el resto de
las bitácoras, el rendimiento de diagramas de caja es el que se acerca más al de KHMM.
Contrario a estos resultados, en el análisis de tiempo de construcción, NMF es el mejor de
todos los métodos con un menor tiempo de construcción.
Segundo Análisis
Las gráficas 6.7, 6.8, 6.9 y 6.10 muestran una comparación del rendimiento del método de
diagramas de caja, k-medias en línea, NMF y KHMM con cada una de las bitácoras
analizadas, respectivamente. Como se observa en ellas, el análisis de la bitácora 7 con
cualquiera de los métodos fue el de menor rendimiento, separándose de los resultados del
resto de las bitácoras principalmente en el porcentaje de falsos positivos arrojados. Las
curvas de las bitácoras 1, 4, 5 y 6 están muy cercanas entre ellas para cualquiera de éstos
cuatro métodos. Sin embargo, para la bitácora 6 los cuatro métodos obtuvieron el mejor
rendimiento.
La diferencia de rendimiento de la bitácora 7 con el resto de las bitácoras puede ocurrir
debido a que las llamadas al sistema por medio de las cuales se generó el modelo del
historial no contenían todas las posibles secuencias de comportamiento normal del sistema,
94
por lo que al encontrarse en la bitácora 7 secuencias normales no modeladas del sistema,
este comportamiento es detectado como ataque, incrementando el número de falsos
positivos en el análisis de esta bitácora. A continuación se presentan de manera consecutiva
las gráficas del segundo análisis.
Gráfica 6.7. Rendimiento de cada bitácora con el método de diagramas de caja.
Gráfica 6.8. Rendimiento de cada bitácora con el método de diagramas de k medias en línea.
Bitácora 1
Bitácora 6
Bitácora 7
Bitácora 4
Bitácora 5
Bitácora 1
Bitácora 7
Bitácora 5
Bitácora 4
Bitácora 6
0
5
10
15
20
25
30
35
40
45
50
55
0 2 4 6 8 10 12
Falsos Negativos (%
)
Falsos Positivos (%)
Diagramas de Caja
0
5
10
15
20
25
30
35
40
45
50
55
0 2 4 6 8 10 12
Falsos Negativos (%
)
Falsos Positivos (%)
K‐medias en Línea
95
Gráfica 6.9. Rendimiento de cada bitácora con el método de NNMF.
Gráfica 6.10. Rendimiento de cada bitácora con el método de KHMM.
Como puede verse en las gráficas de este análisis, el comportamiento de los métodos al
analizar las bitácoras es similar, ya que el modelo del historial obtenido es único y el nivel
de detección de los métodos depende en gran medida de la correcta construcción de este
modelo. El modelo del historial que se construyó para esta investigación ha sido suficiente
Bitácora 5 Bitácora 7
Bitácora 1
Bitácora 4
Bitácora 6
Bitácora 5
Bitácora 7
Bitácora 1
Bitácora 4
Bitácora 6
0
5
10
15
20
25
30
35
40
45
50
55
0 2 4 6 8 10 12
Falsos Negativos (%
)
Falsos Positivos (%)
NMF
0
5
10
15
20
25
30
35
40
45
50
55
0 2 4 6 8 10 12
Falsos Negativos (%
)
Falsos Positivos (%)
KHMM
96
para que los métodos tuvieran un buen nivel de detección. Sin embargo, es posible obtener
un modelo del historial más exacto si se usan bitácoras de comportamiento normal de un
solo sistema y que además reflejen períodos de uso del sistema prolongados.
Escenario 2. Mediante gráficas se muestran los resultados de falsos positivos que los
métodos encontraron en las bitácoras de validación 2 y 3 de la Tabla 5 del capítulo 5. De la
misma manera que en el primer análisis del escenario 1 se llevó a cabo una evaluación de
los métodos comparándolos contra los resultados obtenidos por el uso de Stide durante la
etapa de experimentación en nuestra detección. Hay que considerar que las bitácoras que
fueron usadas en este escenario son libres de ataque. Por lo tanto, los resultados únicamente
arrojan el porcentaje de falsos positivos y éstos son graficados en el eje de las x’s, mientras
que el eje de las y’s identifica el método al que se refieren los resultados. El análisis
realizado en este escenario se interesa en obtener el menor porcentaje de falsos positivos.
La gráfica 6.11 muestra los resultados obtenidos con la bitácora 2 y se puede observar que
el método con menor número de falsos positivos es KHMM. En un pequeño cuadro se
encierra el mejor punto de KHMM. Sin embargo, el método que ocupo menos tiempo en la
construcción del modelo de detección es el de NMF, como se ve en la gráfica 6.6.
Gráfica 6.11. Curvas ROC que muestra el rendimiento de los métodos con la Bitácora de validación 2.
Diagramas de Caja
K-medias en Línea
NMF
KHMM
Stide
0 2 4 6 8 10 12
Métod
os
Falsos Positivos (%)
Bitácora de Validación 2
97
La evaluación contra Stide, como se observa en la gráfica 6.11 demuestra que este detector
de intrusiones en su primer punto tiene mejor rendimiento que K-medias en línea, sin
embargo la diferencia entre ambos es mínima y en general Stide no presenta los mejores
resultados.
La gráfica 6.12 que se muestra a continuación presenta los resultados obtenidos para la
bitácora de validación 3.
Gráfica 6.12. Curvas ROC que muestra el rendimiento de los métodos con la Bitácora de validación 3.
En la gráfica 6.12 se puede observar que diagramas de caja tuvo mejor rendimiento, ya que
éste presenta el punto con menor porcentaje de falsos positivos. Sin embargo, los resultados
de KHMM están muy cercanos a los de diagramas de caja e incluso en algunos puntos
KHMM tiene mejor rendimiento que diagramas de caja. La comparación de cada método
contra Stide revela que todos los métodos usados obtienen menor tasa de falsos positivos
que Stide.
A pesar de que diagramas de caja y KHMM están muy cercanos en su rendimiento, el
método que ocupa el menor tiempo de ejecución es el de diagramas de caja, esto se puede
Diagramas de Caja
K-medias en Línea
NMF
KHMM
Stide
0 1 2 3 4 5 6 7 8 9 10
Métod
os
Falsos Positivos (%)
Bitácora de Validación 3
98
ver en la gráfica 6.6. Por lo tanto, para la bitácora 2 concluimos que el mejor método es
diagramas de caja.
Concluyendo con el análisis de los dos escenarios, los resultados respecto al rendimiento de
los métodos indican que KHMM y diagramas de caja son los mejores con un porcentaje
menor de falsos positivos. Este es un resultado prometedor e interesante, debido a que
diagramas de caja que es un método estadístico básico puede obtener resultados muy
buenos, comparables a métodos sofisticados y especializados en clasificación como
KHMM.
6.4 CONCLUSIONES
La variedad de sistemas Linux utilizados no afecta el desempeño de nuestra metodología,
por el contrario, nos permite verificar que nuestra metodología es aplicable en diferentes
plataformas de Linux, siempre que no cambie la implementación del conjunto de llamadas
utilizadas por el sistema operativo.
En este capítulo se presentó el escenario de experimentación que se siguió para capturar el
comportamiento normal y anómalo requerido en la validación de nuestra metodología de
detección de intrusiones forense, así como los resultados obtenidos. Hemos procurado tener
aleatoriedad en las bitácoras trazadas y los ataques colectados para verificar la efectividad
de detección.
Los resultados obtenidos con el uso de los cuatro métodos para construir nuestros modelos
de detección, demuestran que todos ellos tienen un buen desempeño de detección,
proporcionando mejores resultados la variante de los modelos ocultos de Markov, KHMM.
Sin embargo, el uso de estos métodos por sí solos no darían los resultados obtenidos. Estos
se ven beneficiados dentro de nuestra metodología que incluye una etapa de pre-
procesamiento y una etapa de filtrado, con la cual ha sido posible disminuir el porcentaje de
falsos positivos arrojados por los métodos.
99
La etapa de experimentación incluyó el análisis del desempeño del detector de intrusiones
considerado como el estado del arte en el área, Stide. Una comparación de este detector con
cada método propuesto fue llevada a cabo y los resultados demuestran que diagramas de
caja, NMF y KHMM tienen mejor rendimiento respecto al porcentaje de falsos negativos y
positivos durante la etapa de detección usando las bitácoras que fueron generadas para
nuestro propósito. Sin embargo, estos resultados pueden verse afectados debido a que Stide
específicamente fue construido para analizar aplicaciones, por lo que un modelo de
comportamiento normal de una sola aplicación difiere a nivel llamadas al sistema de un
modelo de comportamiento normal de un sistema en su totalidad considerando que éste es
usado por varios usuarios. En el siguiente capítulo se discuten las conclusiones a las que se
llegó a lo largo de esta investigación.
100
7 OBTENCIÓN DE UN MODELO DEL HISTORIAL FIEL PARA LA DETECCIÓN DE INTRUSIONES FORENSE
7.1 INTRODUCCIÓN
Las metodologías de detección de intrusiones basadas en anomalías que fundamentan su
funcionamiento en observar llamadas al sistema, como la que se presenta en este
documento, tienen que analizar una gran cantidad de llamadas al sistema contenidas en una
o varias bitácoras de la computadora que necesita ser examinada con la finalidad de
construir un modelo que sea representativo de su comportamiento normal (modelo del
historial).
Debido a esto, surge la necesidad de estudiar las llamadas al sistema de una bitácora y
determinar si es posible construir un modelo fiel del historial usando solamente una
fracción de esa bitácora que permita disminuir la carga de información y el tiempo de
procesamiento en la construcción del modelo. Con este propósito, hemos propuesto y
desarrollado un método de análisis que consiste en llevar a cabo tres cálculos sobre las
llamadas al sistema de una bitácora.
Estos tres cálculos son: 1) entropía de las llamadas al sistema, cuya finalidad es medir la
variabilidad de las llamadas al sistema, 2) calidad de las reglas de producción extraídas con
Sequitur, con el propósito de verificar que las reglas obtenidas con una bitácora completa,
en su mayoría, son las mismas que las reglas obtenidas de usar solo una fracción de ella y,
101
3) factor de reducción de una bitácora usando tales reglas, para medir el grado de reducción
que logran las reglas de producción que fueron extraídas de una bitácora completa y solo
una fracción de ésta.
En este capítulo se presentan los detalles de los experimentos realizados con los tres
cálculos propuestos y los resultados que se obtuvieron de este método. El capítulo se
organiza de la siguiente manera: en la sección 7.2 se muestran los experimentos realizados
y los resultados obtenidos con el análisis de entropía, en la sección 7.3 el análisis de la
calidad de las reglas de producción y su factor de reducción. Por último, en el apartado 7.4
se presentan las conclusiones a las que se llegaron en este capítulo.
7.2 ENTROPÍA DE LAS LLAMADAS AL SISTEMA
La entropía está cuantitativamente relacionada con la similitud y simetría de una secuencia
de llamadas al sistema. Dicha entropía nos indica el límite teórico para la compresión de las
llamadas al sistema mediante una medida extraída de las llamadas contenidas en la
secuencia. El cálculo del valor de la entropía se lleva a cabo con la siguiente fórmula:
log
La entropía depende de la probabilidad p(x) de que x tome el valor de una llamada al
sistema cualquiera. Por lo tanto, p(xi) es la probabilidad de encontrar la llamada al sistema x
en una secuencia dada de llamadas al sistema.
Para calcular la entropía de las llamadas al sistema, se seleccionaron aleatoriamente 6
bitácoras del historial y se extrajeron de cada una de esas bitácoras 4 fracciones que
equivalen al 30, 40, 50 y 90% del total de la bitácora. Posteriormente, se calculó el valor de
la entropía de las llamadas al sistema de cada una de las bitácoras y sus fracciones. Los
incisos de la (a) a la (f) de la Tabla 8 muestran los resultados obtenidos del análisis de la
entropía para cada una de las bitácoras seleccionadas. La primera columna de las tablas de
102
entropía indica el porcentaje de la bitácora, la segunda es el número de llamadas al sistema
correspondiente a ese porcentaje y la tercera, el valor entrópico de ese número de llamadas.
Bitácora 1 Porcentaje Llamadas S. Entropía
30% 76482 3.51534 40% 101976 3.55332 50% 127470 3.40694 90% 229446 2.72977
100% 254940 2.9406 (a) Valor Entrópico (Bitácora 1).
Bitácora 2 Porcentaje Llamadas S. Entropía
30% 39036 2.2781740% 52048 2.2320750% 65060 2.1939890% 117108 2.16486
100% 130120 2.16318 (b) Valor Entrópico (Bitácora 2).
Bitácora Aleatoria 3 Porcentaje Llamadas S. Entropía
30% 35454 4.65147 40% 47272 4.71029 50% 59090 4.6763 90% 106361 3.75735
100% 118179 3.59388 (c) Valor Entrópico (Bitácora 3).
Bitácora Aleatoria 4 Porcentaje No.
Ll dEntropía
30% 27374 4.0521140% 36499 3.7726850% 45624 3.4944790% 82123 3.25524
100% 91248 3.33661 (d) Valor Entrópico (Bitácora 4).
Bitácora Aleatoria 5 Porcentaje Llamadas S. Entropía
30% 9266 2.53011 40% 12354 2.11115 50% 15443 1.83951 90% 27797 1.69217
100% 30885 2.04686 (e) Valor Entrópico (Bitácora 5).
Bitácora Aleatoria 6 Porcentaje Llamadas S. Entropía
30% 104477 4.1771240% 139303 4.2565950% 174129 4.243290% 313432 3.79544
100% 348258 3.6696 (f) Valor Entrópico (Bitácora 6).
Tabla 8 Valor entrópico de las bitácoras 1 a la 6.
Para facilitar la comparación del valor de la entropía obtenida en nuestros experimentos, se
graficaron los resultados de las tablas anteriores, esto se muestra en la gráfica 7.1. Como se
puede observar en la gráfica 7.1, los valores de la entropía de los fragmentos y la totalidad
de un
las ll
Gráfic
Los r
que e
repet
7.3
De la
regla
extra
de la
obten
sistem
produ
na bitácora,
lamadas al s
ca 7.1. Entrop
resultados o
el comporta
titivo.
CALIDPRODU
a misma for
as de produ
ajeron 4 frac
as bitácoras
ner un conju
ma que se
ucción gene
0
5
10
15
20
25
30
35
40
45
50
Valor de En
trop
ía, no difieren
sistema que
pía de 6 bitáco
obtenidos en
amiento de
DAD Y FAUCCIÓN
rma que par
ucción se u
cciones de c
s completas
unto de reg
repiten do
erado por u
1
n significat
conforman
oras aleatorias
n el análisis
un sistema
ACTOR DN
ra el análisi
usaron las m
cada una de
s y sus frac
las de produ
os o más
una bitácora
2 3
tivamente en
n una bitáco
y sus corresp
s de la entro
registrado
DE REDU
is de la entr
mismas 6 b
e ellas corre
cciones fuer
ucción que
veces en l
a fue compa
3 4
Bitácora
Entrop
ntre ellos; e
ra.
pondientes por
opía de las l
en una bitá
UCCIÓN
ropía, en la
bitácoras de
spondientes
ron sometid
equivalen a
la bitácora.
arado contra
4 5
pía
es decir, ha
rciones del 30
llamadas al
ácora de lla
DE LAS
evaluación
e comportam
s al 30, 40,
dos al algor
a sub-secuen
Cada con
a cada uno
6
ay poca vari
, 40, 50, 90 y
sistema dem
amadas al si
REGLAS
n de la calid
miento norm
50 y 90%. C
ritmo Sequ
ncias de lla
njunto de r
de los conj
103
iación de
100%.
muestran
istema es
S DE
dad de las
mal y se
Cada una
itur para
amadas al
reglas de
juntos de
30%
40%
50%
90%
100%
104
reglas generados con sus fragmentos y se midió el número de reglas cuya secuencia de
elementos es el mismo. Para ejemplificar este análisis, suponemos que tenemos dos
conjuntos de reglas de producción, R1 y R2, el primero es la salida de Sequitur usando el
total de una bitácora, el segundo usando el 50% de la misma bitácora. La Tabla 9 muestra
las reglas de producción de los dos conjuntos. Como se puede observar en la tabla las reglas
1,2 3 y 5 son iguales, respecto a la secuencia de sus elementos, por lo cual ambos conjuntos
difieren en un 20%.
Conjunto de Reglas Reglas de Producción
R1 1 → open, mmap, close 2 → write, mmap, read 3 → fstat, close 4 → execv, read, write 5 → fstat, mmap, close
R2 1 → open, mmap, close 2 → write, mmap, read 3 → fstat, close 4 → ptrace, read, exit 5 → fstat, mmap, close
Tabla 9 Ejemplo del análisis de calidad de las reglas de producción.
La gráfica 7.2 muestra los resultados obtenidos con este análisis que mide la calidad de las
reglas de producción generadas por cada bitácora y sus fragmentos correspondientes.
Para
produ
análi
comp
La gr
Nú
dl
Gráfic
reforzar lo
ucción, se
isis previo.
portamiento
ráfica 7.3 m
0
500
1000
1500
2000
2500
3000
3500
4000
4500
Núm
ero de
reglas
ca 7.2. Númer
os resultad
midió el fa
Este expe
o normal de
muestra los r
1
ro de reglas ig
dos obtenid
actor de red
erimento se
el sistema c
resultados o
2
Núme
uales obtenida
dos con el
ducción de
e llevo a ca
con cada co
obtenidos de
3
Bitácora
ero de Reglas
as por cada bi
análisis de
las reglas d
abo reducie
onjunto de r
e esta exper
4
Obtenidas
itácora y sus f
e la calida
de producci
endo una s
reglas de pr
rimentación
5
fragmentos.
ad de las r
ión generad
séptima bit
roducción o
n.
6
105
reglas de
das en el
ácora de
obtenido.
30%
40%
50%
90%
100%
Gráfic
reglas
Al ig
obser
las b
en su
Para
produ
el 10
7.5
En e
mode
sistem
la ca
llegó
Rd
ió(%
)
ca 7.3. Porcen
s de producció
gual que lo
rvar en la g
itácoras son
u totalidad, y
comprend
ucción extr
00% tiene un
CONC
este capítulo
elo del hist
ma de una b
alidad de las
ó a la conc
0
10
20
30
40
50
60
70
80
90
100
1
Redu
cción (%
)
ntaje de reduc
ón extraídos d
os resultado
gráfica 7.3 q
n suficientem
ya que su fa
der mejor l
aídas con e
na diferenci
LUSION
o se mostró
torial. Se ob
bitácora resp
s reglas de p
clusión de q
1
cción de una
de las seis bitác
os del anál
que las regla
mente buen
actor de red
los resultad
l 40% de la
ia promedio
ES
ó un métod
bservó en l
pecto a su v
producción
que es posi
2
R
bitácora libre
coras y sus co
lisis previo
as de produ
nas como la
ducción cam
dos, el por
as llamadas
o de 3.46%.
do para med
os resultado
valor entróp
generadas c
ible usar ú
3
Bitácora
Reducción con
e de ataque, u
orrespondiente
del númer
ucción const
as que han s
mbia en prop
rcentaje de
al sistema
dir la exact
os a los qu
pico son rep
con algunas
únicamente
4
n MRH
usando cada u
es fragmentos
ro de regla
truidas con
ido generad
porciones m
e reducción
contra las r
titud en la
ue se llegó,
etitivas. Por
s bitácoras l
un fragmen
5
uno de los co
.
as iguales, p
solo una po
das con las b
menores.
n de las r
reglas gener
construcció
que las llam
r otro lado,
libres de ata
nto del 40%
6
106
onjuntos de
podemos
orción de
bitácoras
eglas de
radas con
ón de un
madas al
se midió
aque y se
% de las
30%
40%
50%
90%
100%
107
bitácoras del historial para construir nuestro modelo que formará parte de la solución al
problema de detección de intrusiones forense.
108
8 CONCLUSIONES
A lo largo de este documento se ha introducido un campo de investigación en el área de
seguridad computacional al que se denominó, sistemas de detección de intrusiones forense.
El término forense fue tomado por la necesidad de contar con mecanismos de detección de
intrusiones post a la ejecución exitosa de uno o varios ataques. En los primeros capítulos se
presentaron ampliamente las contribuciones de esta investigación y se describió el estado
del arte en detección de intrusiones, en donde se observaron las debilidades de algunos
métodos de detección que se han propuesto desde que la problemática de detección de
intrusiones surgió. En capítulos centrales, hemos descrito la metodología propuesta para dar
solución al problema antes mencionado, las técnicas usadas, la implementación de éstas y
los experimentos que validan esta investigación.
Los resultados obtenidos en esta disertación muestran que se llevo a cabo con éxito la
aplicación de métodos de detección y localización para la clasificación de comportamiento,
como son los de diagramas de caja, al igual que técnicas más especializadas como modelos
ocultos de Markov combinados con k-medias (KHMM). La comparación entre estos 2
métodos ha demostrado que KHMM tiene mejor precisión de detección que diagramas de
caja. Sin embargo, la diferencia de precisión entre ambos métodos nos indica que pueden
ser comparables respecto al tiempo de construcción de los modelos más el tiempo de
aplicación. Además, diagramas de caja presenta mejores resultados de detección al
compararse con otros 2 métodos más que también fueron implementados y propuestos, los
cuales corresponden a K-medias en línea y matriz de factorización no negativa. Esta
109
discusión responde a la hipótesis 1 que se planteó en el capítulo 1 de este documento que
dice:
4. El uso de métodos estadísticos para clasificación de comportamiento, como diagramas
de caja es suficiente para lograr una adecuada detección de intrusiones forense, en
comparación con métodos más especializados tales como k-medias en línea, matriz de
factorización no negativa y modelos ocultos de Markov.
Por otro lado, hemos logrado un enfoque de detección de intrusiones forense basado en la
factorización de repetición de llamadas al sistema de una bitácora, mediante el algoritmo
Sequitur. Con esta factorización hemos extraído información que nos permitió definir una
métrica adecuada sobre la que se aplicaron los métodos de clasificación en la construcción
de los modelos de detección. Además, debido a que este factor de repetición reduce la
longitud de las bitácoras que son analizadas se logró disminuir la carga de trabajo al
momento de analizar las bitácoras durante la construcción de los modelos. Esta discusión
argumenta la hipótesis 2, la cual indica lo siguiente:
5. Aplicando un método de reducción de secuencias es posible capturar la repetición de
llamadas al sistema de una bitácora y proveer información que alimente a los métodos
de clasificación para mejorar el proceso de detección de intrusiones forense, además de
disminuir la complejidad computacional asociada a este proceso.
Adicionalmente, logramos aplicar un método sencillo para construir modelos de
comportamiento normal aproximados; es decir, hemos logrado que el modelo con el cual se
hace clasificación entre normal y anómalo sea lo más fiel posible, lo cual resulta en un
mejor proceso de detección de intrusiones forense. Este método consistió en usar solo un
porcentaje de cada una de las bitácoras del historial, para lo cual llevamos a cabo un
análisis de entropía de las llamadas al sistema de las bitácoras y un análisis en el que se
evalúo la calidad de las llamadas al sistema. Los resultados nos dicen que un modelo de
comportamiento normal construido considerando la totalidad de llamadas al sistema de las
bitácoras del historial, comparado con otro modelo construido únicamente con el 40% de
llamadas al sistema de las bitácoras, es suficientemente bueno. Esto, además de
110
proporcionarnos evidencia de que estamos construyendo un modelo fiel de comportamiento
normal, nos permitió disminuir aun más la carga de trabajo en el análisis de las bitácoras
durante la construcción del modelo de comportamiento normal. Lo anterior, da argumento a
la hipótesis 3:
6. Considerando solo una porción de cada bitácora de comportamiento normal que será
analizada, es posible obtener un modelo fiel contra el cual serán comparados los
modelos que deben ser validados de posibles intrusiones, logrando disminuir el tiempo
de procesamiento que requiere la detección de intrusiones forense.
Los resultados presentados en esta investigación son favorables y esto se ve reflejado en las
curvas ROC que muestran el buen rendimiento de la metodología propuesta y su
efectividad, por lo que concluimos que la metodología usada es un buen acercamiento para
la resolución del problema de detección de intrusiones forense. Dichos resultados presentan
un pequeño porcentaje de falsos positivos y negativos, y cuentan con un alto porcentaje de
detección.
8.1 TRABAJO FUTURO
Algunas mejoras a la metodología pueden implementarse con la finalidad de disminuir el
porcentaje de falsos positivos y negativos que son generados. Una de ellas consiste en la
búsqueda de mejores características de los datos que serán analizados para obtener una
mejor diferenciación entre comportamiento normal de un sistema y el de un ataque.
Incluso, una métrica mejor definida de la información en las bitácoras que debe ser
analizada sería capaz de identificar ataques cuya huella en el sistema es similar a la del
comportamiento normal del sistema.
Además, la investigación que se ha presentado en este documento abre nuevos campos de
investigación en el área de seguridad informática, específicamente en el tema referente a
ataques computacionales. Uno de estos campos es la construcción de familias de ataque, las
cuales pueden ser usadas en los sistemas de detección de intrusiones con la finalidad de
111
llevar a cabo una eficiente detección. Estas familias agrupan ataques con estructura similar,
los cuales son medidos por los eventos de alto nivel que la conforman; es decir, los ataques
que son detectados mediante la metodología propuesta en esta investigación permiten
caracterizar cada ataque detectado en términos de eventos de alto nivel (EAN) a partir de
un análisis exhaustivo de dichos ataques, donde un EAN se ve como una relación de
llamadas al sistema y refleja una solicitud sobre el sistema operativo.
Por otro lado, los ataques detectados a través de la metodología propuesta en esta
investigación pueden usarse para la construcción de firmas de ataque, las cuales serán
usadas para futuras detecciones como parte de los IDS basados en computadora. La
caracterización de estas firmas de ataque puede llevarse a cabo mediante el uso de redes de
petri coloreadas (CPN), como se muestra en la investigación de [Aguirre, 2010]. En este
trabajo se presentó una forma de construir firmas de ataque mediante el uso de dicha
metodología, en el cual cada nodo de la red representa una solicitud al sistema que cambia
el estado del sistema produciendo diferentes alternativas de respuesta. De esta forma, se
van construyendo las firmas de ataque respecto a las huellas que éstos dejan sobre el
sistema operativo.
112
REFERENCIAS
[Avilés et al., 2009] Avilés H., Sucar L.E., Pineda L., and Mendoza C., A comparison of
Dynamic Naïve Bayesian Classifiers and Hidden Markov Models for Gesture Recognition.
Preprint submitted to Computer Vision and Image Understanding. 2009.
[Brown, 1999] Brown, M. (1999), RNA Modeling Using Stochastic Context-Free
Grammars. PhD thesis, University of California, Santa Cruz.
[Bottou, 2003] Léon Bottou, Stochastic learning. In Advanced Lectures on Machine
Learning, 2003, pp. 146–168.
[Jianliang et al., 2009] Meng Jianliang, Shang Haikun, Bian Ling, The Application on
Intrusion Detection Based on K-means Cluster Algorithm. ifita, vol. 1, pp.150-152, 2009
International Forum on Information Technology and Applications, 2009.
[Craig et al., 1997] Craig G. N. and Witten, I. H., Identifying hierarchical structure in
sequences: A linear-time algorithm, CoRR, vol. cs.AI/9709102, 1997.
[Crothers, 2003] Crothers, T. (2003), Implementing intrusion detection systems: a hands-on
guide for securing the network. Published by Wiley Publishing, Inc. 2003.
[Cunningham et al., 1998] Cunningham, R. K., Lippmann, R. P., Fried, D. J., Garfinkel, S.
L., Graf, I., and Kendall, K. R. (1999). Evaluating Intrusion Detection Systems without
Attacking your Friends: The 1998 DARPA Intrusion Detection Evaluation. SANS 1999.
[Falkhausen et al., 1995] M. Falkhausen, H. Reininger, and D.Wolf. 1995. Calculation of
distance measures between hidden Markov models. In Proceedings of Eurospeech ’95,
pages 1487–1490, Madrid.
113
[Forrest et al., 1996] Forrest, S., Hofmeyr, S. A., Somayaji, A., and Longstaff, T. A.: A
Sense of Self for Unix Processes. In 1996 IEEE Symposium on Security and Privacy, pages
120-128. 1996.
[Gao et al., 2005] Debin Gao, Michael K. Reiter, and Dawn Xiaodong Song, Behavioral
distance for intrusion detection, in RAID, 2005, pp. 63–81.
[Gao et al., 2006] Debin Gao, Michael K. Reiter, and Dawn Xiaodong Song, Behavioral
distance measurement using hidden markov models, in RAID, 2006, pp. 19–40.
[Giffin et al., 2004] Giffin, J. T., Jha, S., Miller, B. P.: Efficient Context-sensitive intrusion
detection. In NDSS 2004. 2004.
[Giffin et al., 2006] Giffin, J. T., Jha, S., and Miller, B. P.: Automated discovery of mimicry
attacks. In Proceedings of the 9th Conference on Recent Advances in Intrusion Detection,
RAID 2006, volume to appear of Lecture Notes in Computer Science, page to appear.
Springer-Verlag, 2006.
[Godínez, 2004] Godinez, F. (2004). Intrusion Detection Using Probabilistic Methods and
Performance Enhacing Techniques. PhD thesis, Instituto Tecnológico y de Estudios
Superiores de Monterrey. 2004.
[Godínez et al., 2006] Godinez, F., Hutter, D., and Monroy, R.: On the Use of Word
Networks to Mimicry Attack Detection. In: Lecture Notes in Computer Science. Springer
Berlin, Heidelberg, volume 3995, ETRICS 2006, pages 423-435.
[Haizhi et al., 2004] Haizhi, X., Wenliang, D., and Chapin, J.: Context Sensitive Anomaly
Monitoring of Process Control Flow to Detect Mimicry Attacks and Impossible Paths. In
7th International Symposium, RAID 2004, volume 3224 of Lecture Notes in Computer
Science, 2004, pages 21-38.
114
[Hofmeyr et al., 1998] Hofmeyr, S. A., Forrest, S., and Somayaji, A.: Intrusion Detection
using Sequences of System Calls. In Journal of Computer Security, 6(3), 1998, pages 151-
180.
[Hofmeyr & Forrest, 2000] Hofmeyr, S.A. and Forrest, S.: Architecture for an Artificial
Immune System. In Evolutionary Computation, 8(4), 2000, pages 443-447.
[Jha et al., 2001] Somesh Jha, Kymie M. C. Tan, and Roy A. Maxion, Markov chains,
classifiers, and intrusion detection, in CSFW, 2001, pp. 206–219.
[Johnson, 1997] Johnson R. A. (1997). Probabilidad y Estadística para Ingenieros de
Miller y Freund. Prentice Hall And Simon & Schuster Company. México, 1997.
[Kendall, 1999] Kendall, K.: A Database of Computer Attacks for the Evaluation of
Intrusion Detection Systems. Massachusetts Institute of Technology. June 1999.
[Killourhy et al., 2004] Killourhy, K. S., Maxion, R. A., Tan, M. C.: A Defense-Centric
Taxonomy Based on Attack Manifestations. In International Conference on Dependable
Systems and Networks (DSN’04), 2004, pages 102-111.
[Komorowski et al., 1998] Komorowski, J., Polkowski, L., Skowron, A.: Rough sets: A
tutorial. In: Rough- Fuzzy Hybridization: A New Method for Decision Making. Springer-
Verlag (1998).
[Kruegel et al., 2003] Kruegel, C., Mutz, D., Valeur, F. and Vigna, G.: On the Detection of
Anomalous System Call Arguments. In: Lecture Notes in Computer Science. Springer
Berlin, Heidelberg, volume 2808, 2003, pages 326-343.
[Lane, 1999] Terran Lane, Hidden markov models for humancomputer interface modeling,
in In Proceedings of IJCAI-99 Workshop on Learning About Users, 1999, pp. 35–44.
115
[Lee, 1999] Lee, DD & Seung, HS (1999). Learning the parts of objects by non-negative
matrix factorization. Nature 401, 788–791.
[Manning & Schütze, 1999] Manning, C. D. and Schutze, H. (1999). Foundations of
Statistical Natural Language Processing. MIT Press, Massachusets Institute of
Technology, Cambridge, Massachusets 02142.
[Mex et al., 2006] C. Mex-Perera, R. Posadas, J. A. Nolazco, R. Monroy, A. Soberanes and
L. Trejo. An improved Non-negative Matrix Factorization Method for Masquerade
Detection. In, R. Vázquez and J.A. Díaz, Proceedings of the 1st Mexican International
Conference on Informatics Security, MCIS 2006, pages (to appear), Mexico, 2006. © IEEE
Computer Society Press.
[Mex et al., 2008] Carlos Mex-Perea, José Zamora-Elizondo and Raul Monrroy. An
Intrusion Detection for a Mobile Ad-Hoc Networks based on a Non-Negative Matrix
Factorization Method. Journal of Research in Computing, 40:131-140, 2008.
[Nevill-Manning & Witten, 1997] Nevill-Manning, C.G., Witten, I.H.: Identifying
hierarchical structure in sequences: a linear-time algorithm. Journal of Artificial
Intelligence Research, JAIR 7 (1997) 67-82.
[Provost et al., 1998] Provost, F. J., Fawcett, T., & Kohavi, R. (1998). The case against
accuracy estimation for comparing induction algorithms. Proceedings of the Fifteenth
International Conference on Machine Learning, pp. 445-453.
[Posadas, 2006] Román Posadas, Analysis of masquerade detectors performance under
synthesized sessions, M.S. thesis, Instituto Tecnológico y de Estudios Superiores de
Monterrey, 2006.
[Ross, 2009] Ross S. M. (2009). Introduction to Probability and Statistics for Engineers
and Scientist. 4a. Edition. Canada: Elsevier Academic Press Publications. Canada, 2009.
116
[Rusell et al., 1991] Rusell D., and Gangemi G. T., Computer Security Basics. O’Reilly &
Associates, Inc., Sebastopol, California, December 1991.
[Sufatrio & Yap, 2005] Sufatrio and Yap, R. H. C.: Improving host-based IDS with
argument abstraction to prevent mimicry attacks. In Proceedings of the 8th Conference on
Recent Advances in Intrusion Detection, RAID 2005, volume 3858 of Lecture Notes in
Computer Science, Springer-Verlag, 2005, pages 146–164.
[Tan, Killourhy & Maxion, 2002] Tan, K., Killourhy, K. S., and Maxion, R. A.:
Undermining an anomaly-based intrusion detection system using common exploits. In
Proceedings of the 5th Conference on Recent Advances in Intrusion Detection, RAID 2002,
volume 25116 of Lecture Notes in Computer Science, pages 54–73. Zürich, Switzerland,
2002.
[Tan, McHugh & Killourhy, 2002] Tan, K., McHugh, J., and Killourhy, K.: Hiding
intrusions: From the abnormal to the normal and beyond. In 5th International Workshop
on Information Hiding, volume 2578 of Lecture Notes in Computer Science,
Noordwijkerhout, Netherlands, 2002, pages 1–17.
[Warrender et al., 1999] Warrender C., Forrest S., and Pearlmutter B. A., Detecting
intrusions using system calls: Alternative data models, in IEEE Symposium on Security
and Privacy. 1999, pp. 133–145, IEEE Computer Society.
[Young et al., 2002] Young, S., Evermann, G., Kershaw, D., Moore, G., Odell, J., Ollason,
D., Povey, D., Valtchev, V., and Woodland, P.: The HTK Book for HTK Version 3.2.
Cambridge University Engineering Department. 2002.