ECNOLÓGICO Y D E ESTUDIOS SUPERIORES DE MONTERREYhomepage.cem.itesm.mx/raulm/theses/kgarcia.pdf ·...

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 (%

)


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 (%

)


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 (%

)



16

21

26

31

36

41

46

1.5 2 2.5 3 3.5 4 4.5 5

Falsos Negativos (%

)



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.


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 (%

)



92


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 (%

)



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 (%

)


Diagramas de Caja

0

5

10

15

20

25

30

35

40

45

50

55

0 2 4 6 8 10 12

Falsos Negativos (%

)


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 (%

)


NMF

0

5

10

15

20

25

30

35

40

45

50

55

0 2 4 6 8 10 12

Falsos Negativos (%

)


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.


Diagramas de Caja

K-medias en Línea

NMF

KHMM

Stide

0 2 4 6 8 10 12

Métod

os



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.


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



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).


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).


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.

ECNOLÓGICO Y D E ESTUDIOS SUPERIORES DE MONTERREYhomepage.cem.itesm.mx/raulm/theses/kgarcia.pdf ·...

Documents

Transcript of ECNOLÓGICO Y D E ESTUDIOS SUPERIORES DE MONTERREYhomepage.cem.itesm.mx/raulm/theses/kgarcia.pdf ·...