IDS de red para la deteccion de ataques sobre SSH y FTP Perez Sifre Jose

Agradecimientos
A mis padres y a mi pareja. Simplemente gracias.
1
Índice
Agradecimientos .............................................................................................. 1
Índice ................................................................................................................. 2
Índice de figuras ............................................................................................... 4
Índice de tablas ................................................................................................ 6
1. Introducción.................................................................................................. 7
2. Estado del arte.............................................................................................. 9
2.1. IDS ...................................................................................................... 9
2.1.1. Tipos de IDS ................................................................................. 9
2.1.2. Modo de detección ..................................................................... 10
2.1.3. Origen de los datos .................................................................... 12
2.1.4. Comportamiento ......................................................................... 14
2.1.5. IDS basados en red más usados. .............................................. 14
2.2. Deep learning aplicado en los IDS .................................................... 15
2.2.1. Historia de la inteligencia artificial .............................................. 15
2.2.2. Deep Learning ............................................................................ 17
2.2.3. Redes neuronales ...................................................................... 17
2.3. Redes Neuronales aplicadas a un IDS ............................................. 23
2.4. Datasets en la actualidad .................................................................. 24
3. Motivación y objetivos ............................................................................... 26
4. Metodología ................................................................................................ 27
4.1. Metodología de trabajo ..................................................................... 27
4.1.1. Desarrollo en cascada ................................................................ 27
4.1.2. Desarrollo iterativo ..................................................................... 27
5. Desarrollo del proyecto ............................................................................. 29
5.1. Entorno de trabajo y tecnologías a utilizar ........................................ 29
2
5.1.1. Software ..................................................................................... 29
5.1.2. Hardware .................................................................................... 32
5.2. Dataset.............................................................................................. 32
5.3. Pre-procesamiento del Dataset......................................................... 33
5.4. División del dataset y Métricas a utilizar ........................................... 38
5.5. Arquitectura de la red ........................................................................ 40
5.6. Resultados obtenidos ....................................................................... 42
5.6.1. Resultados obtenidos mediante Talos........................................ 42
5.6.2. Experimentación con los mejores modelos. ............................... 45
5.6.3. Análisis de los resultados obtenidos .......................................... 55
5.7. Experimentando en un entorno real .................................................. 65
5.7.1. SSH ............................................................................................ 67
5.7.2. FTP............................................................................................. 70
6. Conclusión .................................................................................................. 73
7. Posibles mejoras y trabajo futuro ............................................................. 74
8. Bibliografía y referencias........................................................................... 75
Anexo A ........................................................................................................... 79
Anexo B ........................................................................................................... 81
Anexo C ........................................................................................................... 83
3
Índice de figuras
Ilustración 1: Defensa en profundidad ................................................................ 8
Ilustración 2: Tipos de IDS ............................................................................... 10
Ilustración 3: Logo Snort .................................................................................. 14
Ilustración 4: Logo Suricata .............................................................................. 15
Ilustración 5: Test de Turing ............................................................................. 16
Ilustración 6: Relación Inteligencia artificial, Machine learning y Deep Learning
......................................................................................................................... 17
Ilustración 7: Comparativa neurona biológica e artificial .................................. 19
Ilustración 8: Función de activación Sigmoid.................................................... 19
Ilustración 9: Función de activación Tanh ........................................................ 20
Ilustración 10: Función de activación ReLu ...................................................... 20
Ilustración 11: Red neuronal densa .................................................................. 20
Ilustración 12: Red neuronal convolucional ...................................................... 21
Ilustración 13: Red neuronal recurrente ........................................................... 22
Ilustración 14: Fórmula error cuadrático medio ................................................ 22
Ilustración 15: Fórmula entropía cruzada ......................................................... 22
Ilustración 16: Tablero Trello ............................................................................ 27
Ilustración 17: Logo TensorFlow ...................................................................... 29
Ilustración 18: Logo Keras ................................................................................ 30
Ilustración 19: Logo Scikit-Learn ...................................................................... 30
Ilustración 20: Logo Talos ................................................................................ 31
Ilustración 21: Logo Anaconda ......................................................................... 32
Ilustración 22: Información contenida en el fichero csv .................................... 34
Ilustración 23: Mezcla de datos ........................................................................ 35
Ilustración 24: Fórmula normalización de datos ............................................... 36
Ilustración 25: Código para la normalización .................................................... 36
Ilustración 26: Esquema red neuronal ejemplo ................................................ 38
Ilustración 27: Código para la codificación ....................................................... 38
Ilustración 28: Diccionario hiperparametros Talos I .......................................... 41
Ilustración 29: Modelo sin utilizar Talos ............................................................ 41
Ilustración 30: Modelo utilizando Talos ............................................................ 42
Ilustración 31:Gráfica de resultados generales ................................................ 43
4
Ilustración 32: Mejor arquitectura del modelo ................................................... 45
Ilustración 33: Gráfica tasa de acierto con 50 épocas ...................................... 46
Ilustración 34: Gráfica tasa de acierto con 50 épocas ampliada ...................... 46
Ilustración 35: Diccionario hiperparametros Talos II ......................................... 47
Ilustración 36: Comparativa funciones de activación ........................................ 49
Ilustración 37: Resultados funciones de activación entrenamiento I ................ 49
Ilustración 38: Resultados funciones de activación validación I ....................... 49
Ilustración 39: Resultados funciones de activación entrenamiento II ............... 50
Ilustración 40: Resultados funciones de activación validación II ...................... 50
Ilustración 41: Diccionario hiperparametros Talos ............................................ 51
Ilustración 42: Comparativa optimizadores ...................................................... 53
Ilustración 43: Resultados optimizadores entrenamiento I ............................... 53
Ilustración 44: Resultados optimizadores validación I ...................................... 54
Ilustración 45: Resultados optimizadores entrenamiento II .............................. 54
Ilustración 46: Resultados optimizadores validación II ..................................... 54
Ilustración 47: Comparativa matrizes de confusión .......................................... 57
Ilustración 48: Cálculos mediante matriz de confusión ..................................... 58
Ilustración 49: Código cálculos matriz de confusión ......................................... 58
Ilustración 50: Matriz de confisión Adam .......................................................... 65
Ilustración 51: Entorno virtual a utilizar ............................................................. 66
Ilustración 52: Escenario ataque servicio SSH ................................................. 67
Ilustración 53: Interfaz gráfica herramienta CICFlowMeter .............................. 68
Ilustración 54: Resultado del IDS ante un flujo maligno ................................... 68
Ilustración 55: Resultado función predict, sobre tráfico inyectado .................... 69
Ilustración 56: Resultados obtenidos ante tráfico maligno SSH ....................... 69
Ilustración 57: Comparación características tráfico inyectado y real ................ 70
Ilustración 58: Escenario ataque servicio FTP ................................................. 71
Ilustración 59: Flujo de tráfico FTP utilizando Wireshark.................................. 72
Ilustración 60: Flujo de tráfico FTP generado ................................................... 72
Ilustración 61: Flujo de tráfico FTP dado .......................................................... 72
5
Índice de tablas
Tabla 1: Comparación IDS basados en firmas y anomalías ............................. 11
Tabla 2: Comparación IDS basados en host y red ........................................... 13
Tabla 3: Información ataques a la red .............................................................. 33
Tabla 4: Tráfico contenido en el fichero csv ..................................................... 34
Tabla 5: Ejemplo normalización ....................................................................... 36
Tabla 6: Datos sin codificar .............................................................................. 37
Tabla 7: Datos codificados mediante la codificación a entero .......................... 37
Tabla 8: Datos codificadoes mediante One-Hot ............................................... 37
Tabla 9: Matriz de confusión ............................................................................ 40
Tabla 10: Valores ordenados por val_accuracy de mejor a peor ..................... 43
Tabla 11: Valores obtenidos ordenados por accuracy de mejor a peor ........... 43
Tabla 12: Valores ordenados por val_accuracy de peor a mejor ..................... 44
Tabla 13: Valores obtenidos ordenados por la accuracy de peor a mejor ........ 44
Tabla 14: Resultados respecto a las funciones de activación .......................... 50
Tabla 15: Resultados respecto a los optimizadores ......................................... 55
Tabla 16: Valores dataset entrenamiento en función del tráfico benigno ......... 59
Tabla 17: Valores dataset entrenamiento en función del tráfico FTP ............... 59
Tabla 18: Valores dataset entrenamiento en función del tráfico SSH .............. 60
Tabla 19: Valores dataset validación en función del tráfico benigno ................ 60
Tabla 20: Valores dataset validación en función del tráfico FTP ...................... 60
Tabla 21: Valores dataset validación en función del tráfico SSH ..................... 61
Tabla 22: Valores dataset test en función del tráfico benigno .......................... 61
Tabla 23: Valores dataset test en función del tráfico FTP ................................ 61
Tabla 24: Valores dataset test en función del tráfico SSH ............................... 62
Tabla 25: Valores optimizador SGD ................................................................. 63
Tabla 26: Valores optimizadores Adadelta, Adagrad y RMSProp .................... 64
Tabla 27: Valores optimizadores Adam, Nadam, Adamax ............................... 64
6
1. Introducción
En la actualidad, es indiscutible que las tecnologías de la información se han
convertido en parte imprescindible de cualquier entorno, ya sea una empresa, una
administración pública, una organización del sector social o incluso a título particular.
Las empresas han tenido que asumir que, para mantener su posición estratégica, es
imprescindible la utilización de tecnologías de la información en su cadena de generación
de valor. Actualmente la tecnología no es una mera herramienta sin la cual las empresas
reducirían sus márgenes de beneficios porque ciertos procesos serían más lentos, sino que
son en realidad el corazón diferenciador y el motor económico de éstas.
Sin embargo, no todas ellas son conscientes de las limitaciones y peligros que las
tecnologías de la información pueden tener en la empresa. Es por ello, que paralelamente
a la aparición de estas nuevas herramientas, aparece otro concepto el cual, cada día, toma
más relevancia, la seguridad de estas tecnologías de la información.
Podemos entender como seguridad una característica de cualquier sistema que nos
indica que ese sistema está libre de todo peligro, daño o riesgo, y que es, en cierta manera,
infalible. Pero como esta característica, es muy difícil de conseguir podemos suavizar esta
definición de seguridad y hablar de fiabilidad, que sería la probabilidad de que un sistema
se comporte tal y como se espera de él. A grandes rasgos para mantener un sistema seguro
(o fiable) hablamos de garantizar tres aspectos básicos:
1. La confidencialidad exige que los objetos de un sistema han de ser accedidos
únicamente por elementos autorizados a ello.
2. La disponibilidad indica que los objetos del sistema tienen que permanecer
accesibles a elementos autorizados; es el contrario de la negación de servicio
3. La integridad significa que los objetos sólo pueden ser creados o modificados
por elementos autorizados, y de una manera controlada y por tanto no han sido
modificados por terceros no autorizados
Junto con la fiabilidad o grado de seguridad de un sistema, entra, el concepto de
defensa en profundidad el cual se basa en la premisa asumida anteriormente, de que todo
componente de un sistema puede ser vulnerado, y por tanto no se debe delegar la
seguridad de un sistema en un único método o componente de protección. Por tanto, la
idea principal de la defensa en profundidad consiste en dividir la seguridad en diversas
7
capas, de forma que, para acceder a la última de estas, donde reside la información más
importante de la empresa, por ejemplo, los datos, sea necesario previamente haber roto
todas las capas previas.
Ilustración 1: Defensa en profundidad
Los elementos que componen un sistema de defensa en profundidad pueden variar
según la necesidad y recursos de los que disponga una compañía, pero uno de los
principales, y el que vamos a desarrollar en este proyecto, son los sistemas de detección
de intrusos, también conocidos como IDS por sus siglas en inglés (Intrusion Detection
System), los cuales serán colocados en la capa de red, para poder detectar un
funcionamiento anómalo del sistema.
8
2. Estado del arte
Para comprender de una forma más clara los conceptos a cubrir en este proyecto,
vamos a ver por separado cada uno de los elementos sobre los que vamos a trabajar.
2.1. IDS
A grandes rasgos, podríamos definir a un IDS [1] como un dispositivo o aplicación
de software que monitoriza una red o sistemas en busca de actividad maliciosa o
violaciones de políticas. Cualquier actividad de intrusión o violación generalmente se
informa a un administrador o se recopila de forma centralizada utilizando un sistema de
información de seguridad y gestión de eventos. Por tanto, es capaz de identificar posibles
violaciones de seguridad que incluyen tanto intrusiones, (ataque desde fuera de la
organización) como mal uso (ataque desde dentro de la organización).
Es importante contextualizar un IDS dentro de un sistema de red, donde tenemos
otros elementos que trabajan al mismo nivel realizando funciones similares. Uno de estos
elementos son los firewalls, que realiza funciones de prevención, por tanto, aunque ambos
se relacionan [2] con la seguridad de la red, un sistema de detección de intrusos (IDS)
difiere de un firewall en que un IDS busca intrusiones para evitar que sucedan mientras
que los firewalls limitan el acceso entre redes para evitar intrusiones sin poder identificar,
por ejemplo, un ataque desde el interior de la red.
Un IDS evalúa una posible intrusión una vez que ha tenido lugar y señala una
alarma. Esto se logra tradicionalmente examinando las comunicaciones de red,
identificando heurísticas y patrones (a menudo conocidos como firmas) de ataques
informáticos comunes, y tomando medidas para alertar a los operadores. Por otra parte,
un sistema que termina las conexiones se denomina sistema de prevención de intrusiones
el cual analizaremos en los siguientes apartados.
2.1.1. Tipos de IDS
En la actualidad existe una gran variedad de IDS según sus funciones como
podemos ver en la siguiente imagen:
9
Ilustración 2: Tipos de IDS
2.1.2. Modo de detección
•
IDS basado en firmas
Este tipo de IDS [3] se centra en la búsqueda de una "firma", patrones, o una
identidad conocida, de una intrusión o evento de intrusión específico. Necesita
actualizaciones periódicas de qué firmas o identidades son comunes en este momento
para garantizar que su base de datos de intrusos esté actualizada. Se podría decir, por
tanto, que los IDS basados en firmas son tan buenos como la actualización de su base de
datos en un momento dado.
Los atacantes pueden sortear los IDS basados en firmas cambiando frecuentemente
pequeñas cosas sobre cómo se produce el ataque, por lo que las bases de datos no pueden
seguir el ritmo. Además, significa que un tipo de ataque completamente nuevo puede no
ser detectado en absoluto por IDS basados en firmas porque la firma no existe en la base
de datos. Este podría ser el principal punto débil de este tipo de IDS que, sin embargo, un
IDS basado en anomalías como el que vamos a desarrollar en este proyecto si podría
detectar. Además, cuanto más grande sea la base de datos, mayor será la carga de
procesamiento para que el sistema analice cada conexión y la compare con la base de
datos.
•
IDS basados en anomalías
10
A diferencia de los IDS basados en firmas, como se ha mencionado anteriormente,
los IDS basados en anomalías buscan los tipos de ataques desconocidos que los IDS
basados en firmas encuentran difíciles de detectar. Debido al rápido crecimiento del
malware y los tipos de ataque, los IDS basados en anomalías utilizan enfoques de
aprendizaje automático para comparar modelos de comportamiento confiable con
comportamiento nuevo. Como resultado, se marcarán anomalías o comportamientos de
aspecto extraño o inusual. Sin embargo, el comportamiento previamente desconocido
pero legítimo también puede marcarse accidentalmente, también conocido como falsos
positivos, lo que puede causar algunos problemas, sobre todo a los administradores de
sistemas al tener que estar revisando este tipo de alarmas.
Por otro lado, uno de los puntos fuertes de los IDS basados en anomalías, es su
capacidad para determinar cuándo alguien está sondeando o barriendo lo que suele
preceder al ataque de una red.
Las principales diferencias entre los dos modos las podemos ver en la siguiente
tabla:
Basados en firmas
Basados en anomalías
Rendimientos de
Baja tasa de falsas alarmas; Alta
Baja tasa de alarmas perdidas;
detección
tasa de alarmas perdidas
Alta tasa de alarmas falsas.
Eficiencia de
Alto, disminuye con la escala de
Depende de la complejidad del
detección
base de datos de firmas
modelo.
Dependencia del
Casi todas las detecciones
Bajo, solo el diseño de la
dominio de
dependen de
característica
conocimiento
conocimiento del dominio
depende del conocimiento del
dominio
Interpretación
Diseño basado en dominio
Solo emite resultados de
conocimiento, fuerte
detección,
interpretativo
habilidad interpretativa débil
capacidad
Detección de ataques
Solo detecta ataques conocidos
desconocidos
Detecta ataques conocidos y
desconocidos
Tabla 1: Comparación IDS basados en firmas y anomalías
11
2.1.3. Origen de los datos
•
Sistema de detección de intrusos basado en host (HIDS)
Consiste en un agente en un host que identifica intrusiones mediante el análisis de
llamadas al sistema, registros de aplicaciones, modificaciones del sistema de archivos
(binarios, archivos de contraseña, bases de datos, listas de control de acceso, etc.) y
estados del host. En un HIDS, los sensores generalmente consisten en un agente de
software. Algunos IDS basados en aplicaciones también forman parte de esta categoría.
Los sistemas de detección de intrusos también pueden ser específicos del sistema
utilizando herramientas personalizadas y honeypots[4]. En el caso de la seguridad física
del edificio, IDS se define como un sistema de alarma diseñado para detectar la entrada
no autorizada.
•
Sistema de detección de intrusos basado en red (NIDS)
Es una plataforma independiente que identifica intrusiones al examinar el tráfico de
red pudiendo monitorizar al mismo tiempo múltiples hosts. Los sistemas de detección de
intrusos en red obtienen acceso al tráfico de la red conectándose a un concentrador de red,
a un conmutador de red configurado para la duplicación de puertos o una toma de red. En
un NIDS, los sensores se colocan en los puntos de estrangulamiento de la red para
monitorizar, a menudo en la zona desmilitarizada (DMZ) o en los límites de la red. Los
sensores capturan todo el tráfico y analizan el contenido de paquetes individuales para
detectar tráfico malicioso. Un ejemplo de un NIDS como veremos es Snort.
Finalmente, junto con lo visto en el apartado de IDS basado en anomalías,
llegaríamos a la principal cuestión de los NIDS basados en anomalías, ¿Cómo podríamos
distinguir un tráfico anómalo de uno benigno? debido a que la respuesta a esta pregunta
depende de muchos parámetros, como, por ejemplo, la cantidad de tráfico a la que
estamos habituados, porque para para lo que una empresa es una cantidad normal, para
otra podría suponer una denegación de servicio. Sin embargo, alguno de los
comportamientos que podríamos analizar son los siguientes [5]:
- ¿Se completó el three-way handshake [6] entre dos anfitriones? Si fue así, esto
significa que el servidor escucha en el puerto en el que el cliente solicitó y el servidor
aceptó la conexión. Esto está bien si el comportamiento esperado es que el servidor
escucha en el puerto solicitado. Sin embargo, ¿qué sucede si el puerto del servidor no es
12
el que espera escuchar? Esto podría indicar que se está ejecutando algún servicio, solo
conocido por el administrador del sistema. Sin embargo, también podría significar que
alguien instaló maliciosamente alguna aplicación de puerta trasera en el servidor sin
ningún consentimiento.
- ¿Se transmitieron los datos? Mediante herramientas de análisis de tráfico
podemos ver, el número de bytes de datos que se enviaron en una conexión. Si vemos
datos transmitidos, esto significa que los dos hosts están hablando entre sí. Cuando
realizamos algún tipo de análisis retrospectivo de actividad inesperada entre dos hosts,
observar la cantidad de bytes intercambiados puede ser útil para evaluar la gravedad de
lo que podría haber ocurrido. Es posible que no podamos ver los bytes de datos reales o
la carga útil, pero los números pueden ser reveladores. Los largos intercambios
individuales y el número de intercambios en conjunto pueden indicar fácilmente un daño
potencial por parte de un intruso.
- ¿Quién comenzó y/o terminó la conexión? Al determinar qué host inició y
finalizó la conexión, podemos tener una idea de quién tiene el control. Por lo general, el
cliente solicita la conexión y el servidor responde. Cualquiera de los hosts puede finalizar
la conversación, así que observaremos quien inicia la terminación con un RESET o FIN.
Por último, en la siguiente tabla podemos ver las principales diferencias entre los
IDS basados en host y los IDS basados en red:
IDS basado en host
Origen de los datos
IDS basado en red
Registros del sistema operativo o Tráfico de red
programas de aplicación
Despliegue
En cada anfitrión; Depende del En los nodos de la red clave; Fácil
sistema operativo; Difícil de de implementar
implementar
Eficiencia de
Baja, debe procesar muchos logs
detección
Alta, puede detectar ataques en
tiempo real
Trazabilidad de la
Rastree el proceso de intrusión
intrusión
de acuerdo con las rutas de intrusión de acuerdo con las
llamadas del sistema
Limitación
No
se
puede
Rastrea la posición y el tiempo de
direcciones IP y marcas de tiempo
analizar
comportamiento de la red.
el Monitoriza solo el tráfico que pasa
en un segmento de red
Tabla 2: Comparación IDS basados en host y red
13
2.1.4. Comportamiento
Respecto al comportamiento tenemos dos tipos de sistemas de detección:
•
Pasivos
Los sistemas de detección de intrusos pasivos son aquellos que no están diseñados
para responder ante un ataque, simplemente lo detectan avisando de que alguna anomalía
se ha producido
•
Activos
Los sistemas de detección activos también conocidos como IPS por sus siglas en
inglés (Intrusion Prevention System) combinan el funcionamiento de un IDS junto con
una respuesta ante la detección de un ataque
2.1.5. IDS basados en red más usados.
Debido a que en este proyecto vamos a desarrollar un IDS basado en red, vamos a
ver resumidamente los NIDS más utilizados en la actualidad.
•
Snort
Snort [7] es un sistema de prevención de intrusiones basado en red de código
abierto, capaz de realizar análisis de tráfico en tiempo real y registro de paquetes en redes
IP. Puede realizar análisis de protocolos, búsqueda o coincidencia de contenido, y puede
usarse para detectar una variedad de ataques y sondeos, como por ejemplo
desbordamientos de buffer, escaneos de puertos furtivos, o ataques CGI.
Ilustración 3: Logo Snort
•
Suricata
14
Suricata [8] es un motor de detección de amenazas basado en red de código abierto.
El motor Suricata es capaz de detección de intrusos en tiempo real (IDS), prevención de
intrusos en línea (IPS), monitoreo de seguridad de red (NSM) y procesamiento pcap fuera
de línea.
Suricata utiliza un lenguaje de firma completo para determinar las amenazas
conocidas y qué tipo de comportamiento es probable que provenga de un intruso. Una
instancia de Suricata puede inspeccionar el tráfico de varios gigabits, y el motor se basa
en una base de código moderna y escalable diseñada para funcionar a un alto nivel.
Detecta automáticamente protocolos en cualquier puerto y puede aplicar la lógica
de detección a cada paquete y protocolo a medida que pasa. Como parte de esto, puede
registrar solicitudes HTTP, que pueden ayudar a detectar ataques de escaneo o inundación
utilizando grandes cantidades de solicitudes de protocolo "normales" para abrumar una
red.
Ilustración 4: Logo Suricata
2.2. Deep learning aplicado en los IDS
2.2.1. Historia de la inteligencia artificial
No hay duda de que, en la actualidad, la inteligencia artificial es uno de los campos
con mayor inversión y visión de futuro que empieza a ser aplicada prácticamente en todos
los campos de la informática, incluyendo el de la ciberseguridad.
El origen de la inteligencia artificial empezó a formar sus bases en los 50 gracias a
Alan Turing [9], el que es considerado por muchos el padre de la IA (Inteligencia
artificial), por su publicación “Computing Machinery and Intelligence” [10], donde se
15
introdujeron los primeros conceptos sobre la inteligencia de las máquinas mediante el
Test de Turing, el cual afirma que:
«Una computadora puede ser llamada inteligente si logra engañar a una persona
haciéndole creer que es un humano» - Alan Turing
Ilustración 5: Test de Turing
Desde entonces, la inteligencia artificial ha pasado por diferentes etapas de menos
afluencia como el invierno de la IA [11], o de más afluencia como en el año 1996 cuando
un ordenador llamado Deep Blue derrotó al mejor jugador de ajedrez por aquellos
momentos Gary Kasparov [12], hasta encontrarse en el punto actual, donde dentro de la
propia IA han aparecido otras ramas como son el aprendizaje automático (Machine
learning) el cual desarrolla técnicas que permiten a las máquinas aprender por sí mismas
mediante algoritmos a partir de datos suministrado y el aprendizaje profundo (Deep
learning) la idea principal del cual es la resolución de problemas a partir de redes
neuronales profundas que pretenden imitar la forma en la que nuestro cerebro toma
decisiones. En la siguiente imagen, podemos ver a alto nivel a los principales
componentes del mundo de la IA.
16
Ilustración 6: Relación Inteligencia artificial, Machine learning y Deep Learning
2.2.2. Deep Learning
Podemos definir al aprendizaje profundo como una clase de algoritmos de
aprendizaje automático que usa varias capas para extraer progresivamente características
de nivel superior de la entrada sin formato. Por ejemplo, en el procesamiento de imágenes,
las capas inferiores pueden identificar bordes, mientras que las capas superiores pueden
identificar los conceptos relevantes para un ser humano, como dígitos, letras o caras.
Debido a que vamos a utilizar el aprendizaje profundo empleando la arquitectura
de redes neuronales artificiales para la implementación de nuestro IDS de red basado en
anomalías, vamos a ver el funcionamiento de estas redes neuronales.
2.2.3. Redes neuronales
Las redes neuronales artificiales (ANN) por sus siglas en ingles Artificial Neural
Network, son sistemas informáticos vagamente inspirados en las redes neuronales
biológicas que constituyen los cerebros de los animales. Dichos sistemas "aprenden" a
realizar tareas considerando ejemplos, generalmente sin ser programados con reglas
específicas de la tarea. Uno de los campos donde más son utilizadas las redes neuronales
artificiales es en el reconocimiento de imágenes, debido a que pueden aprender a
identificar imágenes que contienen, por ejemplo, gatos, analizando imágenes de ejemplo
que se han etiquetado manualmente como "gato" o "no gato" y utilizando los resultados
para identificar gatos en otras imágenes. Lo hacen sin ningún conocimiento previo, en
17
cambio, generan automáticamente características de identificación a partir de los
ejemplos que procesan.
Para entender con más detalle como las redes neuronales consiguen llevar a cabo la
función para la cual son desarrolladas vamos a ver con más detalle los elementos por los
cuales están formadas y diferentes parámetros y opciones que más tarde modificaremos
para conseguir distinguir entre tráfico normal y el anómalo.
•
Neuronas artificiales
Las neuronas artificiales son la base de las redes neuronales, ya que se basan en una
colección de estas, las cuales pretenden modelar el funcionamiento de las neuronas en un
cerebro biológico. La primera neurona artificial apareció en 1958 gracias al trabajo
realizado por F. Rosenblatt [13] la cual denominó como perceptrón simple. Podemos ver
las partes de una neurona artificial mediante la siguiente analogía respecto a una
biológica.
Dendritas: la cantidad de entradas que acepta la neurona o número de dimensiones
de los datos de entrada.
Sinapsis: pesos asociados con las dendritas. Estos son los valores que cambian
durante la fase de entrenamiento.
Baias o sesgo. Le permite aprender sobre un límite de decisión que no está centrado
en el origen del espacio D-dimensional.
Núcleo (célula del cuerpo): esta es una función que une los valores provenientes de
las sinapsis, definiendo así el comportamiento de la neurona. Para simular la acción de la
neurona biológica, es decir, disparando (activando) solo cuando hay ciertos estímulos en
la entrada. El funcionamiento del núcleo viene dado por la siguiente función:
Axón: este es el valor de salida de la neurona. Puede ser utilizado como entrada por
otras neuronas.
En la siguiente imagen podemos ver un resumen de los expuesto anteriormente:
18
Ilustración 7: Comparativa neurona biológica e artificial
•
Función de activación
La función de activación [14] es importante para que una red neuronal aprenda. Su
propósito principal es convertir una señal de entrada de un nodo en una señal de salida,
la cual será usada como entrada a la siguiente capa en la pila. La función de activación
decide, por tanto, si una neurona debe activarse o no mediante el cálculo de la suma
ponderada y añadiéndole un sesgo adicional. El motivo es introducir la no linealidad en
la salida de una neurona. Hay varios tipos de funciones de activación, pero las principales
son:
Sigmoid. Proporciona una salida en el rango [0,1] permitiendo interpretar la
predicción como una probabilidad:
Ilustración 8: Función de activación Sigmoid
Tanh. Es similar a Sigmoid pero mejora el rendimiento. La función oscila entre (1,1). La principal ventaja de esta función es que las entradas negativas fuertes se asignarán
a la salida negativa y solo las entradas de valor cero se asignarán a las salidas cercanas a
cero. Por lo tanto, es menos probable que se bloqueen durante el entrenamiento.
19
Ilustración 9: Función de activación Tanh
ReLu. Es la función de activación más utilizada y que varía de cero a infinito. [0,
∞) dando una salida de "x" si x es positivo y 0 en caso contrario.
Ilustración 10: Función de activación ReLu
•
Tipo de capas
Una vez hemos visto como está compuesta una única neurona o perceptrón, vamos
a ver como estas pueden formar una red neuronal para así añadir un mayor grado de
abstracción en función del tipo de capas que pueden formar, lo cual nos indica como se
relacionan las neuronas de cada capa entre sí. Los principales tipos que podemos
encontrar en la actualidad son los siguientes:
Red neuronal densa: Es una topología de red particular en la que las neuronas entre
dos capas adyacentes están completamente conectadas por pares, pero las neuronas dentro
de una sola capa no comparten conexiones. En la siguiente imagen podemos ver un
esquema de cuál sería su arquitectura:
Ilustración 11: Red neuronal densa
Como podemos ver, está formada por diversas capas, entre las que podemos
distinguir la capa de entrada formada por las neuronas que introducen los valores a la red.
20
Las capas ocultas cuyo diseño no es tan simple como en la capa de entrada y de salida,
por el simple hecho de que no hay reglas, es decir, modificando el número de capas
ocultas y neuronas en cada una de ellas podremos modelar la realidad de una forma
distinta. Y por último la capa de salida que realiza la clasificación y tiene tantas neuronas
como posibles clases presente el problema.
Este tipo de red será la que vamos a utilizar en este proyecto por las propiedades
que nos ofrece, ya que como vamos a ver a continuación los otros dos tipos de redes
neuronales son utilizadas en otro tipo de problemas.
Red neuronal convolucional. La principal diferencia de la red neuronal
convolucional con el modelo visto anteriormente es que cada neurona no se une con todas
y cada una de las capas siguientes, sino que solo con un subgrupo de ellas para poder
especializarse en una tarea en concreto, es por ello que son muy utilizadas en los campos
de visión artificial.
Ilustración 12: Red neuronal convolucional
Red neuronal recurrente: Las redes neuronales recurrentes no tienen una estructura
de capas, sino que permiten conexiones arbitrarias entre las neuronas, incluso pudiendo
crear ciclos, con esto se consigue crear la temporalidad, permitiendo que la red tenga
memoria, es por ello que son más utilizadas para trabajar con data sets con variables
temporales.
21
Ilustración 13: Red neuronal recurrente
•
Funciones de coste
Una vez tenemos claro los elementos que forman una red neuronal y como se
conectan estos elementos entre sí, nos queda ver cómo funcionan o aprenden estas redes.
Para ello deberemos definir la relación entre la salida del modelo y los datos reales. Para
ello, definiremos una función de pérdida o coste. Esta función se utilizará para evaluar
cómo debemos ajustar un modelo en función de la diferencia entre el valor real y el valor
predicho. Las principales funciones de coste que tenemos son:
Error cuadrático medio: Como bien indica su nombre, calcula el error de la red
mediante la diferencia al cuadrado entre las predicciones y los resultados esperados. Su
función de coste sería la siguiente:
Ilustración 14: Fórmula error cuadrático medio
Entropía cruzada [15]: Mide el rendimiento de un modelo de clasificación cuyo
resultado es un valor de probabilidad entre 0 y 1. La pérdida de entropía cruzada aumenta
a medida que la probabilidad pronosticada difiere de la etiqueta real. Por lo tanto, por
ejemplo, predecir una probabilidad de 0.012 cuando la etiqueta de observación real es 1
sería malo y daría como resultado un alto valor de pérdida.
Definimos la función de costo de entropía cruzada como:
Ilustración 15: Fórmula entropía cruzada
Donde n es el número total de elementos de datos de entrenamiento, la suma es
sobre todas las entradas de entrenamiento, x, e y es el resultado deseado correspondiente.
•
Propagación hacia atrás.
La propagación hacia atrás es un algoritmo que utiliza el error en la salida obtenido
anteriormente para reducir el error y propagar ese error hacia las capas ocultas y de
22
entrada con el objetivo de que, en las siguientes iteraciones, la salida obtenida se aproxime
a la salida esperada. El algoritmo busca el mínimo de la función de error y ajustará los
pesos con respecto a ese error. Para ello se utilizan algoritmos como:
El descenso del gradiente: Es un algoritmo de optimización utilizado para
minimizar algunas funciones moviéndose iterativamente en la dirección del descenso más
pronunciado según lo definido por el negativo del gradiente. Por tanto, utilizaremos el
descenso de gradiente para actualizar los parámetros de nuestro modelo.
El descenso del gradiente estocástico: [16] es una modificación del algoritmo del
descenso del gradiente para mejorar algunas de las debilidades que este tiene, como su
velocidad antes grandes cargas de datos, introduciendo el descenso del gradiente
estocástico aleatoriedad al seleccionar los puntos de datos en cada paso para calcular las
derivadas, por tanto este último elige aleatoriamente un punto de datos del conjunto de
datos completo en cada iteración para reducir enormemente los cálculos.
Por tanto, estos serían los elementos principales que necesitamos para crear una red
neuronal artificial que, como veremos a lo largo del desarrollo del proyecto vamos a
modelar según nuestras necesidades.
2.3. Redes Neuronales aplicadas a un IDS
Una vez hemos definido los pilares básicos sobre los que se basa este proyecto,
vamos a ver como relacionarlos, es decir, como se utiliza la inteligencia artificial para la
detección de intrusos.
Como hemos visto anteriormente existen dos tipos de IDS, los basados en host y
los basados en red, pero en este proyecto nos vamos a centrar en los basados en red, por
consiguiente, hemos visto los principales IDS basados en red que hay en la actualidad,
Snort y Suricata. Sin embargo, respecto al modo de detección, ambos se basan en la
detección mediante firmas, lo cual es una gran solución para detectar ataques conocidos,
pero no lo es para detectar nuevos ataques o previamente no reconocidos.
Es por ello, que en los últimos años se ha visto un aumento en el uso del aprendizaje
automático para estas tareas. Muchas compañías están descubriendo los beneficios de
incorporar el aprendizaje automático sobre sus productos o servicios. Por ejemplo,
PayPal, utiliza aprendizaje profundo para reconocer patrones de fraude y Google usa
23
varias implementaciones de aprendizaje profundo para potenciar el reconocimiento visual
o de voz [17].
El problema de algunas aplicaciones es que son demasiado difíciles de codificar
con algoritmos para buscar patrones en enormes dimensiones. Dado que los NIDS
basados en anomalías utilizan modelos de redes neuronales profundas, serán capaces de
detectar ataques aunque estos no hayan sido previamente registrados por el hecho de
analizar y abstraer un comportamiento, en vez de seguir un patrón en concreto, sin
embargo, pese a esta gran ventaja respecto a los basados en firmas, el funcionamiento o
la tasa de acierto queda limitada (como todas las aplicaciones de aprendizaje automático)
por el conjunto de datos utilizado para entrenar al modelo como podremos comprobar al
final de este proyecto.
2.4. Datasets en la actualidad
Para que la red neuronal sea capaz de distinguir entre un tráfico correcto y uno
anómalo le será necesario un conjunto de valores de entrada categorizados. Para ello se
pueden utilizar dos métodos. Por una parte, podemos crear este dataset, a mano, es decir,
para este caso en concreto tendríamos que recolectar nosotros mismos el tráfico benigno
y maligno, para así pasárselo a la red neuronal como entrada, lo cual conlleva un gran
esfuerzo, por lo que no suele ser un método recomendado a no ser que no exista ya un
dataset creado. Por otra parte, podemos utilizar un dataset que ya ha sido creado y
probado para la tarea que vayamos a realizar.
Existen una gran variedad de estos entre los que destacan, por ejemplo, el dataset
del MNIST con una base de datos de los números del cero al nueve escritos a mano[18],
utilizada como ejemplo básico de introducción a las redes neuronales.
Para este trabajo vamos a utilizar un dataset ya creado, entre los que podemos
destacar.
1. DARPA1998
El conjunto de datos DARPA1998 [19] fue construido por el laboratorio Lincoln
del MIT y es ampliamente utilizado en estudios IDS. Para compilarlo, los investigadores
recolectaron tráfico de Internet en más de nueve semanas. El conjunto de datos contiene
paquetes sin etiquetas y con etiquetas. Como los paquetes sin etiquetas no se pueden
24
aplicar directamente a modelos tradicionales de aprendizaje automático, el conjunto de
datos KDD99 fue construido para superar este inconveniente
2. KDD99
El conjunto de datos KDD99 [20] es uno de los conjuntos de datos de referencia
IDS más extendidos en la actualidad. Sus compiladores extrajeron características de 41
dimensiones de los datos en DARPA1998. Las etiquetas en KDD99 son las mismas que
las DARPA1998. Hay cuatro tipos de características en KDD99, es decir, características
básicas, características de contenido, basadas en host características estadísticas y
características estadísticas basadas en el tiempo. Desafortunadamente, el conjunto de
datos KDD99 incluye muchos defectos. Primero, los datos están gravemente
desequilibrados, lo que hace que los resultados de la clasificación estén sesgados hacia
clases mayoritarias, y, además, hay muchos registros duplicados y existen registros
redundantes. Por último, pero no menos importante, los datos de KDD son demasiado
antiguos para representar el entorno de red actual por lo que este Dataset tampoco será
utilizado en este proyecto.
3. CSE-CIC-IDS2018
Este conjunto de datos [21] es el resultado de un proyecto colaborativo entre el
Communications Security Establishment (CSE) y el Instituto Canadiense de
Ciberseguridad (CIC) que utiliza la noción de perfiles para generar un conjunto de datos
de ciberseguridad de manera sistemática. Incluye una descripción detallada de las
intrusiones junto con modelos de distribución abstractos para aplicaciones, protocolos o
entidades de red de nivel inferior. El conjunto de datos incluye siete escenarios de ataque
diferentes, como son, fuerza bruta, Heartbleed, Botnet, DoS, DDoS, ataques web e
infiltración de la red desde el interior. La infraestructura de ataque incluye 50 máquinas
y la organización víctima tiene 5 departamentos que incluyen 420 ordenadores y 30
servidores. Este conjunto de datos incluye el tráfico de red y los archivos de registro de
cada máquina desde el lado de la víctima, junto con 80 características de tráfico de red
extraídas del tráfico capturado usando CICFlowMeter-V3.
Debido a las características que nos ofrece este Dataset y al ser el más actual, vamos
a utilizarlo como conjunto de datos de entrada para el entrenamiento. En el desarrollo del
proyecto veremos con más detalle su estructura y que datos vamos o no a utilizar.
25
3. Motivación y objetivos
La motivación para el desarrollo de este proyecto es por una parte el aprendizaje de
uno de los principales campos de investigación actual, como es la inteligencia artificial,
y su aplicabilidad en nuevos ámbitos de la ingeniería informática, como puede ser la
ciberseguridad, y, por otra parte, como se mejora la seguridad de los servicios ofrecidos
sobre internet, mediante herramientas especializadas para esta función como son los
sistemas de detección de intrusos. Es por ello que, este proyecto me parecía ideal para
juntar estas dos inquietudes y comprobar posteriormente si los resultados de este trabajo
son en cierta medida aplicables a un entorno real.
El principal objetivo de este proyecto de fin de master será el de analizar, diseñar,
e implementar un sistema de detección de intrusos basado en la inteligencia artificial,
debido a que los IDS existentes aún enfrentan desafíos en la mejora de la precisión de
detección, principalmente en dos campos, el primero reduciendo la tasa de falsas alarmas
y el segundo en detectar ataques desconocidos. Es por ello que están apareciendo los IDS
que aprovechen los métodos de aprendizaje automático de modo que pueden descubrir
automáticamente las diferencias esenciales entre datos normales y datos anormales con
alta exactitud y en los cuales me gustaría indagar realizando para ello los siguientes
objetivos:
•
Investigar y contextualizar los sistemas de detección de intrusos en la
actualidad.
•
Investigar cómo podemos aplicar las diferentes técnicas de Deep Learning
aplicadas a un sistema de detección de intrusos.
•
Experimentar con las diferentes opciones que nos ofrecen las redes
neuronales para resolver de la forma más optima el problema.
•
Análisis, evaluación y conclusiones que podemos extraer de los resultados
obtenidos.
•
Aplicar y analizar los resultados del modelo en un entorno real para su
posible posterior usabilidad en este entorno.
26
4. Metodología
4.1. Metodología de trabajo
Como metodología de trabajo para este proyecto hemos utilizado el desarrollo en
cascada, durante los primeros pasos de investigación, y a la hora de desarrollar la red
neuronal en sí hemos utilizado una metodología iterativa
4.1.1. Desarrollo en cascada
Para el desarrollo del proyecto hemos utilizado una metodología en cascada, ya que,
al inicio de este, hemos especificado unos procesos u objetivos que deberíamos ir
consiguiendo, y a medida que tuviéramos los primeros terminados y bien definidos
podríamos seguir con los siguientes. Para ello, tras un conjunto de objetivos realizado, ha
sido necesaria una reunión, para ver si el desarrollo había sido el adecuado en cada
proceso, y de esta forma poder seguir con el siguiente, o por el contrario modificarlo hasta
que cumpliera con los requisitos establecidos.
Para identificar los procesos de una forma clara y ordenada he utilizado la
herramienta Trello. Un ejemplo de un tablero de Trello durante las primeras semanas de
trabajo es el siguiente:
Ilustración 16: Tablero Trello
4.1.2. Desarrollo iterativo
Por otra parte, una vez tenemos una idea clara de que queremos hacer y cómo,
empezamos con el desarrollo de la red neuronal de una forma iterativa, ya que primero
cumplimos unos requisitos básicos como por ejemplo que aprendiera con cierto grado de
27
acierto, y posteriormente en cada ciclo hemos ido mejorando esta tasa de acierto ya se
mediante, por ejemplo, el modelado de la arquitectura de la red, o mediante la
modificación de alguno de los parámetros de entrada en el Dataset.
28
5. Desarrollo del proyecto
5.1. Entorno de trabajo y tecnologías a utilizar
En este proyecto vamos a utilizar distintos entornos de trabajo y diferentes
tecnologías las cuales vamos a analizar brevemente.
5.1.1. Software
•
Python
Python [22] es un lenguaje de programación interpretado, multiplataforma y
multiparadigma. Es de código abierto y de escritura rápida y robusta cuya filosofía hace
hincapié en la legibilidad de su código.
He elegido Python como lenguaje ya que este proporciona un entorno bien
estructurado y probado para la implementación de algoritmos de inteligencia artificial.
Para ello Python cuenta con numerosas librerías para trabajar con el análisis de datos que
facilita el procesamiento de grandes volúmenes de datos. Algunas de las que vamos a
utilizar son:
•
TensorFlow
TensorFlow [23] es una biblioteca de código abierto para aprendizaje automático a
través de un rango de tareas, y desarrollado por Google para satisfacer sus necesidades de
sistemas capaces de construir y entrenar redes neuronales para detectar y descifrar
patrones y correlaciones, análogos al aprendizaje y razonamiento usados por los
humanos.
Tensorflow trabaja a un nivel más bajo, por lo que para interactuar con esta
biblioteca utilizaremos una API de alto nivel llamada Keras.
Ilustración 17: Logo TensorFlow
29
•
Keras
Keras [24] es una API de redes neuronales de alto nivel, escrita en Python y capaz
de ejecutarse sobre TensorFlow, CNTK o Theano. Las principales funciones que nos
ofrece Keras son:
-La facilidad de uso ya que Keras es una API diseñada para seres humanos, no para
máquinas, ofreciendo una API consistente y simple, que minimiza la cantidad de acciones
del usuario requeridas para casos de uso comunes.
-Modularidad. Un modelo se entiende como una secuencia o un gráfico de módulos
independientes totalmente configurables que se pueden conectar con la menor cantidad
de restricciones posible. En particular, las capas neurales, las funciones de costo, los
optimizadores, los esquemas de inicialización, las funciones de activación y los esquemas
de regularización son módulos independientes que puede combinar para crear nuevos
modelos.
-Fácil extensibilidad. Los nuevos módulos son fáciles de agregar (como nuevas
clases y funciones), y los módulos existentes proporcionan amplios ejemplos. Poder crear
fácilmente nuevos módulos permite una expresividad total, lo que hace que Keras sea
adecuado para la investigación avanzada.
Ilustración 18: Logo Keras
•
Sklearn
Scikit-learn [25] es una librería utilizada para el Machine Learning. Proporciona
una gran variedad de algoritmos de aprendizaje tanto supervisados como no supervisados.
Ilustración 19: Logo Scikit-Learn
30
•
Pandas
Pandas [26] es una biblioteca de software escrita para el lenguaje de programación
Python para la manipulación y análisis de datos. En particular, ofrece estructuras de datos
y operaciones para manipular tablas numéricas y series de tiempo.
•
Numpy
Numpy [27] es una librería para el lenguaje de programación Python, que agrega
soporte para matrices y matrices multidimensionales grandes, junto con una gran
colección de funciones matemáticas de alto nivel para operar en estas matrices.
•
Pickle
El módulo Python Pickle [28] se usa para serializar y deserializar una estructura de
objeto Python. Mediante esta librería podremos almacenar e importar los Datasets de una
forma más eficiente.
•
Talos
Talos [29] es una librería que nos permite configurar, realizar y evaluar
experimentos de optimización de hiperparámetros en una red neuronal de una forma más
clara e intuitiva.
Ilustración 20: Logo Talos
•
Matplotlib
Matplotlib [30] es una librería para la generación de gráficos.
•
Anaconda
Anaconda [31] es una distribución libre y abierta de los lenguajes Python y R, para
trabajar en entornos de ciencia de datos, y aprendizaje automático. Esto incluye
procesamiento de grandes volúmenes de información, análisis predictivo y cómputos
31
científicos. Está orientado a simplificar el despliegue y la administración de los paquetes
de software
Ilustración 21: Logo Anaconda
•
Jupyter
JupyterLab [32] es un entorno de desarrollo interactivo basado en la web para
código y datos. Jupyter nos permite configurar y organizar la interfaz de usuario para
admitir una amplia gama de flujos de trabajo en ciencia de datos, y aprendizaje
automático. Además, es extensible y modular, lo que nos permite escribir complementos
que agreguen nuevos componentes y se integren con los existentes.
5.1.2. Hardware
Como hardware utilizaré una máquina virtual proporcionada por la Escuela
Politécnica Superior de la universidad con los siguientes recursos:
-Procesador: AMD Opteron 63xx 3,72 GHz (2 procesadores)
-Memoria RAM: 4 GB
-Sistemas Operativo: Windows 10 (64 bits)
Como podemos ver, los recursos de la máquina no son los idóneos para trabajar en
un entorno de alto procesamiento, pero aprovecharemos el hecho de no ser una máquina
de uso propio, para la ejecución continua del algoritmo de aprendizaje, sobre todo
mediante la herramienta Talos como veremos en el próximo apartado.
5.2. Dataset.
El dataset a utilizar será el creado por la Communications Security Establishment
(CSE) y el Instituto Canadiense de Ciberseguridad (CIC) datado en el 2018. En los
datasets proporcionados se recoge el tráfico generado durante varios días sobre el mismo
escenario, pero con distintitos tipos de ataques, es por ello, que nos vamos a centrar en el
32
tráfico generado el día 14-02-2018 ya que este se corresponde con los ataques de fuerza
bruta sobre los protocolos SSH y FTP.
Ambos ataques de fuerza bruta son realizados sobre la misma máquina víctima, un
Ubuntu 16.4 con IP 172.31.69.25. Por otra parte, el atacante utilizará dos máquinas con
Kali Linux, como podemos ver en la siguiente tabla:
Atacante
Víctima
Nombre del
Fecha
ataque
Inicio
Finalización
del
del ataque
ataque
IP privada:
IP privada:
Fuerza bruta
14-02-
172.31.70.4
172.31.69.25
sobre FTP
2018
IP pública:
IP pública:
18.221.219.4
18.217.21.148
IP privada:
IP privada:
Fuerza bruta
14-02-
172.31.70.6
172.31.69.25
sobre SSH
2018
IP pública:
IP pública:
18.219.211.138
18.217.21.148
10:32
12:09
14:01
15:31
Tabla 3: Información ataques a la red
Para la realización del ataque se utiliza la herramienta Patator. Patator es [33] es
una herramienta multihilo bastante completa y flexible para la realización de ataques de
fuerza bruta escrita en Python. También puede guardar cada respuesta en un archivo de
registro separado para su posterior revisión. Para el ataque se usan los módulos de FTP y
SSH en la máquina Kali Linux atacante. Para obtener una lista de contraseñas, utilizan un
diccionario que contiene 90 millones de palabras.
5.3. Pre-procesamiento del Dataset
Para cada día, nos ofrecen la información de tres modos distintos, por una parte,
tenemos los logs generados, un fichero pcap con todo el tráfico procesado y por último
un fichero csv con toda la información extraída por la herramienta CICFlowMeter [34].
Como dataset utilizaremos el fichero csv, ya que la herramienta CICFlowMeter ya
nos ha extraído del fichero pcap toda la información que necesitaremos en 79
características, como pueden ser puertos, longitud de los paquetes etc.
33
El conjunto de datos en el fichero csv, contiene tráfico normal (benigno) y maligno
compuesto en este caso por los dos tipos de ataques que vamos a distinguir. Para que el
dataset puede ser utilizado por el algoritmo de entrenamiento, previamente tendremos
que realizar unas tareas de procesamiento de los datos:
1. Limpieza de filas
El primer problema con el que nos encontramos en el dataset, es la aparición de
valores no numéricos, los cuales no podrán ser procesados por la red neuronal. Estos
valores que hemos podido encontrar son “Nan” e “Infinity” como podemos ver en la
siguiente captura del fichero csv:
Ilustración 22: Información contenida en el fichero csv
Por tanto, el primer paso a realizar, será generar un nuevo csv, que como datos de
entrenamiento solo contenga valores numéricos, eliminando, por tanto, todas aquellas
filas que no cumplan este requisito, obteniendo en el nuevo fichero la siguiente división
del tráfico:
Tipo de tráfico
Número de filas
Porcentaje del total limpio
Total
1048550
Filas eliminadas
3799
Total limpio
1044751
100%
FTP Fuerza bruta
193354
18,52%
SSH Fuerza bruta
187589
17,95%
Benigno
663808
63,53%
Tabla 4: Tráfico contenido en el fichero csv
Por último, como podemos ver en los porcentajes, el tráfico Benigno triplica al de
FTP o SSH, por lo que reduciremos este para que su porcentaje sea más o menos el mismo
que par los otros dos tipos de tráfico.
2. Extracción de columnas no necesarias
Como se ha mencionado anteriormente, la herramienta CICFlowMeter nos ha
extraído toda la información en 79 características distintas, pero algunas de estas no nos
34
serán útiles, o no pueden ser entendidas por la red neuronal para el aprendizaje, como
puede ser por ejemplo la columna del Timestamp ya que, al no utilizar una red neuronal
recurrente, este valor más tarde será normalizado y no tendrá sentido para la red. El resto
de características o columnas si serán utilizadas para entrenar a la red.
3. Mezcla de datos
Los datos en el csv, vienen ordenados como se produjeron, es decir, primero
tenemos un pequeño bloque de tráfico benigno, a continuación, el bloque del ataque de
fuerza bruta sobre FTP, luego tráfico benigno, después el otro bloque de ataque de fuerza
bruta sobre SSH y finalmente otro bloque de tráfico benigno. Esto supone un problema
para el aprendizaje de la red neuronal, ya que, al principio, al recibir un bloque de 193354
filas de ataque por fuerza bruta sobre FTP, la red se especializará en detectar solamente
este tipo de entrada, lo que producirá que más tarde, al recibir todo el tráfico benigno
siempre se equivoque prediciendo ataques sobre FTP.
Para evitar este problema utilizaré la función shuffle sobre todo el conjunto de
entrada:
Ilustración 23: Mezcla de datos
4. Normalización
En el dataset que vamos a utilizar, dependiendo del tipo de característica, los
valores que esta tiene varían respecto a los valores de otra, por ejemplo, los valores de la
característica Flow IAT MAX siempre serán mayores que los valores en Flow IAT MIN,
entonces, estas dos características están en rangos muy diferentes. Es por ello que estas
dos entradas afectaran de forma distinta a la red si no se normalizan, ya que, el ingreso o
peso atribuido influirá intrínsecamente en el resultado debido a su mayor valor sin esto
significar necesariamente que sea más importante como predictor.
Es por ello, que sobre todos los valores de entrada aplicaré la normalización cuyo
objetivo es cambiar los valores de las columnas numéricas en el conjunto de datos a una
escala común, sin distorsionar las diferencias en los rangos de valores.
35
Para la normalización utilizaré la estrategia min-max normalization, donde para
cada característica, el valor mínimo de esa característica se transforma en un 0, el valor
máximo se transforma en un 1 y cualquier otro valor se transforma en un decimal entre 0
y 1. Para ello utilizaré la siguiente fórmula:
Ilustración 24: Fórmula normalización de datos
Donde 𝑥 = (𝑥1 , … 𝑥𝑛 ) y 𝑧𝑖 es su 𝑖 𝑡ℎ información normalizada. Para ver este de una
forma más clara, podemos ver un pequeño ejemplo de cómo quedarían unos valores de
entrada tras su normalización:
Dato1
Dato2
Dato3
Dato1
Dato2
Dato3
10
2
748
0
0
1
12
13
234
0.4
1
0
15
2
543
1
0
0.60
12
2
347
0.4
0
0.22
Tabla 5: Ejemplo normalización
Para ello utilizaré el método fit_transform que nos ofrece la clase
MinMaxScaler[35] correspondiente a la librería Sklearn
Ilustración 25: Código para la normalización
5. Codificación
En el dataset con el que vamos a trabajar, tenemos tres tipos de tráfico, FTP Fuerza
bruta, SSH Fuerza bruta, Benigno, es decir, se trata de datos categóricos ya que contienen
etiquetas en vez de valores numéricos, lo cual no puede ser interpretado por nuestra red
neuronal. Para solventar este problema utilizaremos la codificación One-Hot, mediante la
cual estas variables categóricas se convierten en valores numéricos. Vamos a ver esto en
un ejemplo aplicado a nuestro dataset. Supongamos que tenemos la siguiente entrada:
Flow Duration
Tot Fwd Pkts
Tot Bwd Pkts
Label
25
12
3
Benign
36
754
3
4
FTP-BruteForce
432
2
0
SSH-BruteForce
434
5
0
Benign
3254
12
4
Benign
Tabla 6: Datos sin codificar
Donde las tres primeras columnas son los valores de entrada a la red (la X) y la
última se corresponde con el tipo de tráfico (lo que tiene que predecir el algoritmo).
Primero realizaremos lo que se conoce como codificación a entero:
Flow Duration
Tot Fwd Pkts
Tot Bwd Pkts
Label
25
12
3
0
754
3
4
1
432
2
0
2
434
5
0
0
3254
12
4
0
Tabla 7: Datos codificados mediante la codificación a entero
Para finalmente aplicar la codificación One-Hot:
Flow Duration
Tot Fwd Pkts
Tot Bwd Pkts
Label
25
12
3
1, 0, 0
754
3
4
0, 1, 0
432
2
0
0, 0, 1
434
5
0
1, 0, 0
3254
12
4
1, 0, 0
Tabla 8: Datos codificadoes mediante One-Hot
De este modo, mediante esta codificación, podemos representar la salida que una
red neuronal produce, activando la neurona correspondiente dependiendo del tipo de
tráfico que supone que recibe como entrada:
37
Ilustración 26: Esquema red neuronal ejemplo
Para ello utilizaré los métodos fit y transform [36] que nos ofrece la librería Sklearn
y el método to_categorical [37] correspondiente con Keras:
Ilustración 27: Código para la codificación
Todos los pasos realizados anteriormente se ejecutarán en un programa previo al de
la red neuronal que podemos encontrar en el Apéndice A.
5.4. División del dataset y Métricas a utilizar
Para la evaluación del algoritmo dividiremos el dataset en tres partes:
•
Set de entrenamiento: El conjunto de datos real que utilizamos para entrenar
el modelo (pesos y sesgos en este caso). El modelo ve y aprende de estos
datos. Para este set vamos a utilizar un 81% de los datos totales.
•
Set de validación: Es el conjunto de datos utilizado para proporcionar una
evaluación imparcial de un modelo ajustado en el conjunto de datos de
entrenamiento mientras se ajustan los hiperparámetros del modelo. Para este
set vamos a utilizar un 10% de los datos totales.
•
Set de test: Es el conjunto de datos utilizado para proporcionar una
evaluación imparcial de un modelo final ajustado en el conjunto de datos de
entrenamiento. Para este set vamos a utilizar un 9% de los datos totales.
38
Para evaluar el funcionamiento de la red neuronal utilizaré las siguientes métricas:
•
Precisión. La precisión se define como la proporción de muestras
clasificadas correctamente con respecto a las muestras totales. La precisión
es una métrica adecuada cuando el conjunto de datos está equilibrado. En
entornos de red reales; sin embargo, las muestras normales son mucho más
abundantes que las muestras anormales; por lo tanto, la precisión no suele
ser una métrica adecuada.
𝑃𝑟𝑒𝑐𝑖𝑠𝑖ó𝑛 =
•
𝑉𝑃 + 𝑉𝑁
𝑉𝑃 + 𝐹𝑃 + 𝐹𝑁 + 𝑉𝑁
Tasa verdaderos negativos (TVN). Esta tasa nos indica la tasa de verdaderos
negativos que son correctamente clasificados.
𝑇𝑉𝑁 =
•
𝑉𝑁
𝑉𝑁 + 𝐹𝑃
Tasa verdaderos positivos (TVP): También conocida como recall. Se define
como la proporción de muestras positivas verdaderas respecto al número de
muestras positivas totales. La tasa de detección refleja la capacidad del
modelo para reconocer ataques, que es una métrica importante en los IDS.
TVP =
•
𝑉𝑃
𝑉𝑃 + 𝐹𝑁
La tasa de falsos negativos (TFN) se define como la relación de muestras
falsas negativas respecto al total de muestras positivas. En la detección de
ataques, el TFN también se denomina tasa de alarma perdida.
𝑇𝐹𝑁 =
•
𝐹𝑁
𝑉𝑃 + 𝐹𝑁
La tasa de falsos positivos (TFP) se define como la proporción de muestras
negativas clasificadas incorrectamente como positivas. En la detección de
ataques, el TFP también se denomina tasa de falsas alarmas, y se calcula del
siguiente modo:
𝑇𝐹𝑃 =
39
𝐹𝑃
𝑉𝑁 + 𝐹𝑃
•
Matriz de confusión [38]. Es una herramienta que nos permitirá la
visualización del desempeño de nuestro algoritmo. Cada columna de la
matriz representa el número de predicciones de cada clase, mientras que
cada fila representa a las instancias en la clase real. En la siguiente tabla
podemos ver un simple ejemplo de una matriz de confusión
Valor Predicho
Valor Real
Gato
Perro
Conejo
Gato
5
3
0
Perro
2
3
2
Conejo
0
2
11
Tabla 9: Matriz de confusión
5.5. Arquitectura de la red
Uno de los puntos más difíciles a la hora de implementar una red neuronal, es sin
duda, la arquitectura que esta debe tener, tanto a nivel de capas ocultas y neuronas por
cada una de estas capas, como funciones de activación, funciones de coste, sobre
entrenamiento etc.
Esto es debido, como explica Elie Burzstein [39] en una de sus conferencias [40],
a la dificultad de poder modelar el problema que estamos abordando mediante redes
neuronales, ya que no existe ninguna regla ni protocolo que ante tal tipo de problema al
que nos enfrentemos, nos indique que hiperparámetros debemos utilizar para conseguir
un resultado óptimo, además de la gran variedad de opciones entre las que podemos
elegir, es por ello, que como nos comenta Elie Burzstein, el mejor método para esta tarea,
se trata simplemente de la prueba y error, es decir, ir modificando los parámetros de la
red, según veamos que mejora o no la tasa de acierto.
Dado que este es un problema ya conocido, en la actualidad existen una gran
variedad de herramientas para agilizar este proceso [41]. En mi caso voy a utilizar la
herramienta Talos. Para ello primero en un diccionario de Python, declararé los
hiperparámetros y los límites que deseo comprobar:
40
Ilustración 28: Diccionario hiperparametros Talos I
Como podemos ver, los parámetros los cuales irán variando sus valores son el
número de neuronas de entrada (input_neuron), número de capas ocultas(hidden_layers)
número de neuronas en las capas ocultas(first_neuron), si utilizaremos dropout o
no(dropout), tamaño del lote(batch_size) y, por último, los optimizadores(optimizer).
Una vez tenemos los hiperparametros definidos, prepararemos el modelo Keras.
Para ello, simplemente remplazaré los parámetros que vamos a probar, por referencias al
diccionario de parámetros. En la siguiente imagen podemos ver el cambio del modelo
tradicional utilizando Keras que hemos desarrollado en este proyecto, sin hiperparametos
frente al modelo con hiperparametros:
Ilustración 29: Modelo sin utilizar Talos
41
Ilustración 30: Modelo utilizando Talos
Como modelo de optimización utilizaré grid search mediante el cual se procesarán
todas las permutaciones de hiperparámetros en el límite de parámetros dado, lo que
producirá 384 modelos distintos. Por tanto, una vez tenemos el modelo creado podemos
ejecutarlo, en este caso en la máquina virtual proporcionada, debido al tiempo necesario
para que Talos, realice todas las permutaciones posibles.
En el apéndice B, podemos encontrar el modelo creado mediante Talos.
5.6. Resultados obtenidos
5.6.1. Resultados obtenidos mediante Talos.
Una vez Talos ha concluido su ejecución obtenemos 384 valores distintos de
precisión tanto para el subset de entrenamiento como para el de validación. La
herramienta ha guardado estos resultados tanto en gráficas mediante TensorBoard como
en un fichero csv. Como podemos ver en la siguiente imagen, al obtener unas tasas de
acierto tan parecidas y con tantos datos, mediante las gráficas nos será imposible obtener
los mejores modelos:
42
Ilustración 31:Gráfica de resultados generales
Es por ello que utilizaremos el fichero csv para extraer información que nos pueda
ser útil. Primero ordenaremos todos los valores en función de la mejor tasa de acierto en
la validación y entrenamiento.
Tabla 10: Valores ordenados por val_accuracy de mejor a peor
Tabla 11: Valores obtenidos ordenados por accuracy de mejor a peor
Mediante los valores obtenidos podemos extraer las siguientes conclusiones:
1. El modelo funciona mejor con una sola capa oculta.
43
2. No es necesario aplicar dropout.
3. La mejor cantidad de neuronas en las capas ocultas es de 256 neuronas.
4. Ambos optimizadores obtienen unos resultados similares.
5. El número de neuronas en la capa de entrada parece indiferente
Ahora ordenaremos estos valores en función de las peores tasas de acierto
obtenidas:
Tabla 12: Valores ordenados por val_accuracy de peor a mejor
Tabla 13: Valores obtenidos ordenados por la accuracy de peor a mejor
Mediante los valores obtenidos podemos extraer las siguientes conclusiones:
1. Los peores resultados se obtienen con 2 o 3 capas ocultas
44
2. Los peores resultados se obtienen con dropout
3. El optimizador nadam en este caso tiene peores resultados
4. El número de neuronas parece equitativo entre los peores resultados
Por tanto, a partir de los peores y mejores resultados, el modelo que mejor resuelve
este problema sería el siguiente.
Ilustración 32: Mejor arquitectura del modelo
5.6.2. Experimentación con los mejores modelos.
Mediante las pruebas anteriores hemos podido detectar que arquitectura, sobre todo
a nivel de neuronas y capas se adapta mejor al modelo, en este apartado, a partir del mejor
modelo obtenido anteriormente vamos a profundizar un poco más en otros parámetros y
así ver qué resultados obtenemos.
Primero vamos a ver el número de épocas o iteraciones necesarias para nuestra red
neuronal. Para ello vamos a ejecutar la red con un número elevado de épocas y mediante
unas gráficas ver cómo se comporta. Los resultados obtenidos son los siguientes:
45
Ilustración 33: Gráfica tasa de acierto con 50 épocas
Como podemos ver, a partir de las primeras iteraciones el comportamiento ya es
lineal, es decir, que ya no mejora, por lo que no sería necesario pasarle al algoritmo un
número tan elevado de iteraciones. Para ver exactamente cuantas son necesarias, vamos
a crear otro gráfico para ver esto con más detalle:
Ilustración 34: Gráfica tasa de acierto con 50 épocas ampliada
En este caso hemos ampliado la gráfica entre las iteraciones cero y ocho donde
podemos comprobar que, a partir de la iteración cuarta, el algoritmo ya ha alcanzado su
tasa máxima de acierto.
Una vez hemos visto el número de épocas óptimo para la resolución del problema,
vamos a realizar una serie de pruebas sobre los dos parámetros que menos hemos probado
46
durante la ejecución de Talos, las funciones de activación, donde solo hemos probado con
relu y los diferentes optimizadores disponibles, ya que solo hemos probado con adam y
nadam.
En ambos casos vamos a utilizar la mejor arquitectura de red que hemos obtenido.
•
Funciones de activación [42]:
Para ver cómo funciona nuestro algoritmo en función de la función de activación
utilizada voy a utilizar Talos para las pruebas y TensorBoard para la visualización de los
gráficos. Para ello utilizaré el siguiente diccionario:
Ilustración 35: Diccionario hiperparametros Talos II
Los valores obtenidos por cada uno de las funciones son los siguientes:
Tasa de acierto entrenamiento
Tasa de acierto validación
Función de activación ReLu
Función de activación Sigmoid
47
Función de activación Tanh
Función de activación Elu
Función de activación Selu
48
Función de activación Linear
Ilustración 36: Comparativa funciones de activación
Debido a que las tasas de acierto son muy similares entre todas las funciones, vamos
a ver los resultados mediante una misma gráfica y unas tablas para comparar los
resultados.
Ilustración 37: Resultados funciones de activación entrenamiento I
Ilustración 38: Resultados funciones de activación validación I
49
Ilustración 39: Resultados funciones de activación entrenamiento II
Ilustración 40: Resultados funciones de activación validación II
Tabla 14: Resultados respecto a las funciones de activación
Por tanto, las funciones de activación que mejores resultados nos han dado son
ReLu y Elu, con un porcentaje de 99,9942% y 99,9923% de acierto respectivamente en
el dataset de validación, mientras que los peores resultados los hemos obtenido mediante
Sigmoid con un 99,9789%, y Tanh con una tasa del 99,9722%.
•
Optimizadores [43]:
50
Al igual que en las funciones de activación voy a utilizar Talos para las pruebas y
TensorBoard para la visualización de los gráficos. Para ello utilizaré el siguiente
diccionario:
Ilustración 41: Diccionario hiperparametros Talos
Los valores obtenidos por cada uno de los optimizadores son los siguientes:
Tasa de acierto entrenamiento
Tasa de acierto validación
Optimizador Adam
Optimizador Nadam
51
Optimizador SGD
Optimizador RMSProp
Optimizador Adagrad
52
Optimizador Adadelta
Optimizador Adamax
Ilustración 42: Comparativa optimizadores
Debido a que las tasas de acierto son muy similares entre todos los optimizadores,
vamos a ver los resultados mediante una misma gráfica y unas tablas para comparar los
resultados.
Ilustración 43: Resultados optimizadores entrenamiento I
53
Ilustración 44: Resultados optimizadores validación I
Ilustración 45: Resultados optimizadores entrenamiento II
Ilustración 46: Resultados optimizadores validación II
Finalmente, como los valores de precisión obtenidos entre los distintos
optimizadores, son muy similares, vamos a ver mediante la siguiente tabla el orden de
mejor optimizador a peor respecto a la precisión en la val_accuracy
54
Tabla 15: Resultados respecto a los optimizadores
Los optimizadores que mejores resultados nos han dado son Adam y Nadam, con
un porcentaje de 99,9952% y 99,9942% de acierto respectivamente en el dataset de
validación, mientras que los peores resultados los hemos obtenido mediante Adagrad con
un 99,9741%, pero sobre todo con SGD con un 99,8755%.
5.6.3. Análisis de los resultados obtenidos
Mediante las pruebas realizadas anteriormente solamente obtenemos la precisión
de nuestro modelo, pero esto, como hemos visto en el apartado de métricas puede que no
sea suficiente, por tanto, mediante la matriz de confusión de cada métrica, vamos a ver
con más detalle como clasifica nuestro modelo en función del optimizador utilizado. Para
ello vamos a utilizar los tres datasets disponibles, el de entrenamiento, el de validación y
el de test, con una distribución equitativa, de los tres tipos de tráfico a analizar.
Matriz de confusión
Matriz de confusión
Matriz de confusión test
entrenamiento 487993
validación 60247 muestras
54222 muestras
muestras
Optimizador Adam
55
Optimizador Nadam
Optimizador SGD
Optimizador RMSProp
Optimizador Adagrad
56
Optimizador Adadelta
Optimizador Adamax
Ilustración 47: Comparativa matrizes de confusión
Los valores obtenidos por las matrices de confusión los utilizaré para calcular la
tasa de verdades positivos (TVP), la tasa de verdaderos negativos (TVN), la tasa de falsos
positivos (TFP) y por último la tasa de falsos negativos (TFN). Este tipo de métricas se
suelen utilizar en variables binarias, es decir, que sean de un tipo o de otro, por ejemplo,
tráfico benigno o maligno. Dado que, en este proyecto, dentro del tráfico maligno,
estamos diferenciando dos tipos de ataques un sobre SSH y el otro sobre FTP, a estas
métricas se les tendrá que añadir en función de que variable se están calculando, por
ejemplo, TVPFTP, se referirá a la tasa de verdaderos positivos en función de ataques
sobre FTP. Por tanto, para calcular estos valores, me basaré en la matriz de confusión
como podemos ver en la siguiente imagen:
57
Ilustración 48: Cálculos mediante matriz de confusión
Siendo la implementación de la imagen anterior la siguiente:
Ilustración 49: Código cálculos matriz de confusión
•
Los resultados obtenidos con el subset de entrenamiento son:
58
Benigno
Entrenamiento
Optimizador
TVPB
TVNB
TFPB
TFNB
Adam
0.999983
0.999994
0.000006
0.000017
Nadam
0.999972
0.999994
0.000006
0.000028
SGD
0.997838
0.999987
0.000013
0.002162
RMSProp
0.999861
0.999984
0.000016
0.000139
Adagrad
0.999733
0.999984
0.000016
0.000267
Adadelta
0.999883
0.999971
0.000029
0.000117
Adamax
0.999966
0.999983
0.000016
0.000033
Tabla 16: Valores dataset entrenamiento en función del tráfico benigno
FTP
Entrenamiento
Optimizador
TVPFTP
TVNFTP
TFPFTP
TFNFTP
Adam
1
0.999922
0.000078
0
Nadam
1
0.999922
0.000078
0
SGD
1
0.999484
0.000516
0
RMSProp
1
0.999882
0.000118
0
Adagrad
1
0.999882
0.000118
0
Adadelta
1
0.999894
0.000106
0
Adamax
1
0.9999185
0.000082
0
Tabla 17: Valores dataset entrenamiento en función del tráfico FTP
SSH
Entrenamiento
Optimizador
TVPSSH
TVNSSH
TFPSSH
TFNSSH
Adam
0.999816
0.999991
0.000009
0.000184
Nadam
0.999816
0.999985
0.000015
0.000184
SGD
0.999802
0.999277
0.000723
0.000198
RMSProp
0.999796
0.999964
0.000036
0.000204
Adagrad
0.999796
0.999896
0.000104
0.000204
Adadelta
0.999769
0.999964
0.000036
0.000231
59
Adamax
0.999795
0.999985
0.000015
0.000204
Tabla 18: Valores dataset entrenamiento en función del tráfico SSH
•
Los resultados obtenidos con el sub set de validación son:
Benigno
Validación
Optimizador
TVPB
TVNB
TFPB
TFNB
Adam
0.999865
1
0
0.000135
Nadam
0.999865
1
0
0.000135
SGD
0.998112
0.999974
0.000026
0.001888
RMSProp
0.999820
0.999974
0.000026
0.000180
Adagrad
0.999506
0.999974
0.000026
0.000494
Adadelta
0.999775
0.999974
0.000026
0.000225
Adamax
0.999865
0.999974
0.000026
0.000135
Tabla 19: Valores dataset validación en función del tráfico benigno
FTP
Validación
Optimizador
TVPFTP
TVNFTP
TFPFTP
TFNFTP
Adam
1
0.999927
0.000073
0
Nadam
1
0.999927
0.000073
0
SGD
1
0.999732
0.000268
0
RMSProp
1
0.999927
0.000073
0
Adagrad
1
0.999902
0.000098
0
Adadelta
1
0.999902
0.000098
0
Adamax
1
0.999927
0.000073
0
Tabla 20: Valores dataset validación en función del tráfico FTP
SSH
Validación
Optimizador
TVPSSH
TVNSSH
TFPSSH
TFNSSH
Adam
0.999947
0.999976
0.000024
0.000053
Nadam
0.999947
0.999976
0.000024
0.000053
60
SGD
0.999893
0.999229
0.000771
0.000107
RMSProp
0.999893
0.999952
0.000048
0.000107
Adagrad
0.999893
0.999807
0.000193
0.000107
Adadelta
0.999893
0.999952
0.000048
0.000107
Adamax
0.999893
0.999976
0.000024
0.000107
Tabla 21: Valores dataset validación en función del tráfico SSH
•
Los resultados obtenidos con el sub set de test son:
Benigno
Test
Optimizador
TVPB
TVNB
TFPB
TFNB
Adam
0.999950
1
0
0.000050
Nadam
0.999950
1
0
0.000050
SGD
0.997980
1
0
0.002020
RMSProp
0.999697
1
0
0.000303
Adagrad
0.999748
1
0
0.000252
Adadelta
0.999950
0.999971
0.000029
0.000050
Adamax
1
1
0
0
Tabla 22: Valores dataset test en función del tráfico benigno
FTP
Test
Optimizador
TVPFTP
TVNFTP
TFPFTP
TFNFTP
Adam
1
0.999919
0.000081
0
Nadam
1
0.999919
0.000081
0
SGD
1
0.999566
0.000434
0
RMSProp
1
0.999783
0.000217
0
Adagrad
1
0.999919
0.000081
0
Adadelta
1
0.999919
0.000081
0
Adamax
1
0.999919
0.000081
0
Tabla 23: Valores dataset test en función del tráfico FTP
SSH
Test
Optimizador
TVPSSH
TVNSSH
61
TFPSSH
TFNSSH
Adam
0.999824
0.999973
0.000027
0.000176
Nadam
0.999824
0.999973
0.000027
0.000176
SGD
0.999824
0.999274
0.000726
0.000176
RMSProp
0.999824
0.999973
0.000027
0.000176
Adagrad
0.999824
0.999866
0.000134
0.000176
Adadelta
0.999765
0.999973
0.000027
0.000235
Adamax
0.999824
1
0
0.000176
Tabla 24: Valores dataset test en función del tráfico SSH
Como podemos ver en los resultados obtenidos, podemos sacar algunas
conclusiones de los resultados en general independientemente del optimizador utilizado:
1. No se ha equivocado nunca, en los tres subconjuntos utilizados, a la hora de
clasificar el tráfico de ataque sobre FTP, es decir, siempre que el modelo ha
recibido una muestra de ataque FTP ha predicho que efectivamente se
correspondía con una ataque sobre FTP de ahí que la tasa de verdadero positivos
sobre FTP es uno, mientras que, siempre que ha recibido un ataque FTP, nunca
ha predicho que se tratara otro tipo de tráfico, por eso la tasa de falsos negativos
es cero.
2. Como podemos observar, en los tres subconjuntos generados, siempre hay cierto
tipo de tráfico exacto, que se corresponde con un ataque SSH, pero que el modelo,
interpreta como ataque FTP, sin importar el optimizador a utilizar. Es por ello que
en el dataset de entrenamiento siempre vemos que se ha equivocado 26 veces, en
la validación una y en el test tres.
3. Como vemos en las matrices de confusión, exceptuando el caso del optimizador
SGD, el modelo se equivoca más en dos casos concretos. Cuando recibe tráfico
maligno sobre SSH, a veces predice que es tráfico maligno FTP, como hemos
visto en el punto anterior, y cuando recibe tráfico benigno, que a veces predice
que se trata de tráfico maligno SSH
Por tanto, como visión general de todos los optimizadores, el algoritmo clasifica
perfectamente el tráfico maligno FTP, el tráfico Benigno lo confunde más con ataques
sobre SSH que sobre TFP, y por último el tráfico maligno SSH, lo confunde más con FTP
que con el tipo Benigno.
62
Respecto a los optimizadores de forma individual obtenemos las siguientes
conclusiones.
1. Como hemos visto anteriormente, todos tienen unos patrones de
comportamiento similares, excepto el optimizador SGD. Como podemos ver en
las tablas de las métricas, sus valores son más o menos iguales que el resto, pero
la tasa de falsos negativos respecto al tráfico real Benigno, es muy elevada en
comparación con los otros optimizadores, por lo que SGD, ante un tráfico
Benigno real, predecirá con más frecuencia que se trata de tráfico tanto maligno
SSH como FTP que los otros optimizadores.
Entrenamiento
Validación
Test
Tabla 25: Valores optimizador SGD
2. Adadelta, Adagrad y RMSProp se comportan de forma muy parecida. Respecto
a la tasa de verdaderos positivos, que es la métrica más importante en un sistema
de detección de intrusos, estos tres optimizadores, obtienen una clasificación
perfecta del tráfico maligno FTP, pero oscilan en el mismo porcentaje de acierto
en los otros dos tipos de tráfico, entre un 99,973% de mínimo y un 99,988% de
máximo, sin haber, por tanto, notables diferencias entre el acierto en el tráfico
benigno y el maligno SSH.
63
Tasa
de
verdaderos
positivos Tasa
benignos
de
verdaderos
positivos
malignos SSH
Tabla 26: Valores optimizadores Adadelta, Adagrad y RMSProp
3. Por otra parte, Adam, Nadam, y Adamax, como podemos ver en la siguiente
comparativa, obtienen un porcentaje de tasa de verdaderos positivos respecto al
tráfico maligno SSH muy similar, a los tres optimizadores vistos en el punto
anterior, ya que ahora las tasas de acierto oscilan entre el 99,979% y el 99, 981%
y antes entre el 99,976% y el 99,979%, sin embargo, donde estos tres
optimizadores si se diferencian de los anteriores es en la tasa de acierto de
tráfico benigno, donde las tasas oscilan entre el 99,996% y el 99,998% mientras
que anteriormente, la tasa máxima 99,986% no alcanzaba ni la mínima actual.
Tasa
de
verdaderos
positivos Tasa
benignos
de
verdaderos
positivos
malignos SSH
Tabla 27: Valores optimizadores Adam, Nadam, Adamax
4. Por tanto, de estos tres últimos optimizadores, el que mejor tasa de acierto tiene
es Adam, con un 100% sobre ataques FTP, un 99,998% sobre tráfico benigno y
un 99,981% sobre ataques SSH.
Finalmente, en este sistema de detección de intrusos, hemos tratado de separar dos
tipos de ataques y ver si también los podía distinguir, lo cual ha realizado con una tasa de
acierto muy elevada, pero la función principal de un IDS es la de detectar amenazas, es
decir, si una muestra es benigna o maligna, lo cual en nuestro mejor modelo obtenido se
realiza de una manera prácticamente perfecta, como podemos ver en la siguiente imagen:
64
Ilustración 50: Matriz de confisión Adam
Donde sobre, 602.462, solamente no ha sabido predecir que la muestra recibida era
un ataque, en 2 ocasiones.
5.7. Experimentando en un entorno real
Por último, como hemos analizado en los resultados obtenidos, la tasa de acierto
del mejor modelo obtenido es prácticamente del 100%, por lo que vamos a experimentar
con este modelo, en un entorno distinto del que ha aprendido a clasificar el tráfico, para
de este modo, poder comprobar si el IDS obtenido podría ser utilizado para la detección
de ataques de fuerza bruta en un entorno “real”.
Para la puesta en marcha del entorno de pruebas, utilizaré tres máquinas virtuales
distintas, dos de ellas serán los servidores, una para el servicio SSH, y la otra para FTP,
mientras que la última será la maquina atacante. Los sistemas operativos y herramientas
a utilizar serán los mismos que en el entorno de pruebas del dataset. En la siguiente
imagen, podemos ver el entorno utilizado:
65
Ilustración 51: Entorno virtual a utilizar
Antes de realizar las pruebas pertinentes, debemos tener en cuenta que el
aprendizaje de la red neuronal está basado en datos, donde la comprensión de estos es el
primero paso. Pero estos datos pueden ser presentados de distintas formas, lo cual puede
reflejar de distinto modo un ataque.
Por ejemplo, podemos diseñar un IDS basado en paquetes, ya que estos son las
unidades básicas de comunicación de red, representando los detalles de cada
comunicación. Para ello necesitaríamos primero analizar, por ejemplo, su encabezado
donde se especifica de forma estructurada las direcciones IP, puertos y otros campos
específicos para varios protocolos, o la porción de datos de la aplicación donde se
contiene la carga útil de los protocolos de la capa de aplicación. Este sistema permite que
los paquetes pueden procesarse instantáneamente sin almacenamiento en caché; por lo
tanto, la detección puede ocurrir en tiempo real. Sin embargo, los paquetes individuales
no reflejan el estado de comunicación completo ni el contexto información de cada
paquete, por lo que es difícil detectar algunos ataques, como DDOS.
Es por ello que en este trabajo utilizamos como datos de entrada los flujos de una
comunicación, extraídos mediante la herramienta CICFlowMeter. Los datos de flujo
66
contienen paquetes agrupados en un período, que es la fuente de datos más extendida para
IDS. Las principales ventajas de este modo son:
1. El flujo representa todo el entorno de red, pudiendo detectar la mayoría de
los ataques, especialmente DOS y fuerza bruta.
2. Sin análisis de paquetes o reestructuración de sesión, el preprocesamiento
del flujo es simple.
Sin embargo, el flujo ignora el contenido de los paquetes; por lo tanto, su efecto de
detección para U2R y R2L es insuficiente. A demás, al extraer características de flujo, los
paquetes deben ser cacheados, lo cual puede complicar su análisis en tiempo real. Otro
problema que podemos encontrar es, la fuerte heterogeneidad del flujo lo que puede
causar efectos de detección deficientes.
En este caso la herramienta CICFlowMeter terminará los flujos TCP con la
desconexión de la conexión (por paquete FIN) mientras que los flujos UDP terminarán
con un tiempo de espera de flujo.
5.7.1. SSH
Para comprobar su funcionamiento sobre SSH, lanzaremos el servicio OpenSSHServer [44] en la máquina víctima junto con un sniffer de tráfico como es Wireshark [45],
mientras que en la maquina atacante lanzaremos la herramienta Patator con el módulo de
ssh_login.
Ilustración 52: Escenario ataque servicio SSH
67
Una vez tenemos el tráfico capturado, utilizaremos CICFlowMeter para extraer los
flujos de comunicación y el programa import.py para el preprocesamiento de este dataset
a evaluar.
Ilustración 53: Interfaz gráfica herramienta CICFlowMeter
Con el dataset listo mediante la función predict[47] y utilizando el modelo
generado evaluaremos el tráfico generado. Los resultados obtenidos a diferencia de lo que
podíamos esperar, es que todo el tráfico generado es benigno, es decir, no ha sido capaz
de detectar el ataque por fuerza bruta. Por tanto, para intentar detectar porque se ha
comportado de ese modo, vamos a extraer un flujo de tráfico maligno del propio dataset
de entrenamiento para inyectarlo en el dataset generado en nuestro propio entorno de
pruebas, para ver si en este caso si lo detecta. Pero obtenemos el siguiente resultado.
Ilustración 54: Resultado del IDS ante un flujo maligno
Como podemos ver el resultado sigue sin ser el esperado ya que la salida [1. 0. 0.]
se corresponde con el tráfico benigno (esta salida nos está indicando que la neurona de la
68
capa de salida de la red activada es la primera. En este caso aún no hemos aplicado la
función softmax, que devolvería la neurona con el valor más alto, un 0).
El error del modelo, se debe al modo de procesar los datos de entrada, más
concretamente a la normalización utilizada, ya que, en el entorno de pruebas, el número
de flujos ha sido de 140, mientras que en el entrenamiento teníamos 487993 flujos, por
lo cual los valores máximos y mínimos de cada propiedad son muy distintos. Para
solventar este problema, vamos a utilizar la normalización L2, que no se ve afectada por
este factor, y que nos produce un modelo con una tasa de acierto cerca del 100% al igual
que nos ocurría con la normalización min-max.
En este caso al ejecutar la función predict sobre el tráfico maligno inyectado del
dataset de entrenamiento si obtenemos el resultado esperado:
Ilustración 55: Resultado función predict, sobre tráfico inyectado
Ahora al aplicar softmax sobre ese resultado nos devolvería un 2, correspondiente
con el tráfico maligno sobre SSH. Sin embargo, nuestro IDS, sigue sin detectar los ataques
que hemos realizado en el entorno de prueba, al utilizar la función predict:
Ilustración 56: Resultados obtenidos ante tráfico maligno SSH
Esto es debido a que los valores extraídos difieren bastante de los valores del ataque
sobre el que ha aprendido en el entrenamiento, es decir, las características del flujo de
comunicación del entorno de prueba, no han sido las mismas que en el dataset de
entrenamiento, como podemos ver en la siguiente imagen, y, por tanto, el modelo no es
capaz de detectar ataques de fuerza bruta sobre SSH.:
69
Ilustración 57: Comparación características tráfico inyectado y real
5.7.2. FTP
Para comprobar su funcionamiento sobre FTP, lanzaremos el servicio Vsftpd en la
segunda máquina víctima junto con el sniffer de tráfico Wireshark, mientras que en la
maquina atacante lanzaremos la herramienta Patator con el módulo de ftp_login.
70
Ilustración 58: Escenario ataque servicio FTP
Los resultados obtenidos son exactamente los mismo que en el caso anterior, para
que detecte los ataques del dataset de entrenamiento hemos tenido que utilizar de nuevo
la normalización L2, pero los ataques que hemos generado nosotros mismos, no son
detectados por el modelo. En este caso, vamos a analizar las características de cada flujo,
mediante los ficheros csv generado por CICFlowMeter en ambos casos y la captura
obtenida mediante Wireshark.
En la siguiente imagen podemos ver el flujo de datos obtenido mediante Wireshark:
71
Ilustración 59: Flujo de tráfico FTP utilizando Wireshark
Donde podemos observar que realizamos un intento de conexión incorrecto, donde
el cliente envía un total de 4 paquetes FTP al servidor, el servidor responde con un total
de 5 paquetes, y 8 paquetes más para el establecimiento, mantenimiento y cierre de sesión,
lo que hace un total de 17 paquetes intercambiados con 192 bytes de información, que
como podemos observar en la siguiente imagen se corresponde con lo extraído mediante
el CICFlowMeter:
Ilustración 60: Flujo de tráfico FTP generado
Sin embargo, y es por ello que los resultados no sean los esperados, en el dataset
de entrenamiento, estos valores no son parecidos:
Ilustración 61: Flujo de tráfico FTP dado
Lo cual nos hace entender, porque el modelo generado, no ha sido capaz de detectar
los ataques FTP ya que al igual que en estas columnas que son las más sencilla de entender
y visualizar mediante Wireshark, ocurre con el resto, donde los valores son muy distintos.
72
6. Conclusión
Respecto a las conclusiones extraídas mediante este trabajo podemos dividirlas en
dos campos.
Por una parte, el modelo que hemos construido a partir del dataset ofrecido por el
CSE y el CIC, se comporta de una manera excelente, donde hemos podido concluir que
el mejor modelo estará compuesto por una única capa oculta de 256 neuronas, junto con
una capa de entrada con 32 neuronas.
Respecto a las funciones de optimización los resultados son muy similares entre las
distintas opciones ofrecidas, destacando entre todas ellas la función ReLu. En cuanto a
los optimizadores, también nos ofrecen unos resultados muy similares, donde destaca
Adam, con un 100% de acierto sobre ataques FTP, un 99,998% sobre tráfico benigno y
un 99,981% sobre ataques SSH.
Por tanto, los resultados obtenidos mediante el IDS utilizando algoritmos de
inteligencia artificial han sido excelentes.
Por otra parte, al aplicar el modelo obtenido mediante el dataset que nos ha sido
dado, al tráfico generado por nosotros mismos simulando los mismos ataques que estaban
presentes en el dataset, el modelo no ha sido capaz de reconocer el tipo de tráfico que
recibía, debido a las características de los flujos de comunicación que no eran las mismas
que en el caso dado, lo cual nos lleva a concluir que el modelo implementado es muy
bueno respecto al dataset mediante el cual entrena, pero no puede generalizar de un forma
correcta para enfrentare a ataques en un entorno real.
Por tanto, los resultados obtenidos mediante el IDS en un entorno diferente al de
entrenamiento no han sido los esperados.
Por último, respecto a los objetivos del trabajo, han sido todos realizados con éxito
a pesar, de que como se ha comentado antes, los resultados obtenidos en el entorno real
no han sido los deseados.
73
7. Posibles mejoras y trabajo futuro
Vistos los resultados que hemos obtenido las principales mejoras y posibles trabajos
futuros se podrían centrar en la mejora de la tasa de acierto en un entorno diferente al de
entrenamiento, ya sea mediante el uso de otro dataset ya existente, o mediante la creación
de uno mismo, el cual se acerque más al entorno real donde lo queramos aplicar.
Una posible mejora respecto a IDS, hubiera sido el uso de más tipos de datos de
entrada, para así conseguir una red neuronal más inteligente, que supiera distinguir no
solo entre un ataque de fuerza bruta al protocolo SSH o FTP y tráfico benigno, sino que
también fuera capaz de detectar otro tipo de ataques, y no solo en los protocolos que
hemos analizado. Esto podría ser posible, ya que junto al dataset que hemos utilizado, se
encontraban otros tipos de dataset los cuales contenían información sobre diferentes
ataques.
También sería interesante probar con otro tipo de red neuronal. Como hemos visto
en el estado del arte, existen otros tipos de redes neuronales a parte de la red neuronal
densa utilizada en este proyecto. Para el problema al que nos enfrentamos, en un principio
utilizar una red convolucional no sería la mejor opción debido a que el ámbito en el que
esta se aplica es muy distinto al nuestro, sin embargo, puede que el uso de una red
neuronal recurrente si sea una buena opción, ya que una de las variables de todos los
paquetes intercambiados en una red es el tiempo y este tipo de redes, es la que mejor
trabaja con esta variable.
74
8. Bibliografía y referencias
[1] Wikipedia (2020). Intrusion detection system. [En línea]. Disponible en
https://en.wikipedia.org/wiki/Intrusion_detection_system
[2] Dnsstuff (2018) What Is an Intrusion Detection System? Latest Types and Tools. [En
línea]. Disponible en https://www.dnsstuff.com/intrusion-detection-system#scanningattacks
[3] Ajay Yadav (2018) Network Design: Firewall, IDS/IPS. [En línea]. Disponible en
https://resources.infosecinstitute.com/network-design-firewall-idsips/#gref
[4]
Wikipedia
(2019).
Honeypot.
[En
línea].
Disponible
en
https://es.wikipedia.org/wiki/Honeypot
[5] Judy Novak; Stephen Northcutt (2002) Network Intrusion Detection, Third Edition
(p. 44)
[6] Geeksforgeeks (2019) TCP 3-Way Handshake Process. [En línea]. Disponible en
https://www.geeksforgeeks.org/tcp-3-way-handshake-process/
[7] Snort (2020) Snort [En línea]. Disponible en https://www.snort.org/faq/what-is-snort
[8] Suricata (2020) Suricata [En línea]. Disponible en: https://suricata-ids.org/
[9]
Wikipedia
(2020).
Alan
Turing.
[En
línea].
Disponible
en
https://es.wikipedia.org/wiki/Alan_Turing
[10] A. M. Turing (1950) Computing Machinery and Intelligence. [En línea]. Disponible
en: https://phil415.pbworks.com/f/TuringComputing.pdf
[11]
Wikipedia
(2020).
AI
winter.
[En
línea].
Disponible
en
https://en.wikipedia.org/wiki/AI_winter
[12] Wikipedia (2020).Deep Blue versus Gary Kasparov. [En línea]. Disponible en
https://es.wikipedia.org/wiki/Deep_Blue_versus_Gary_Kasparov
[13]
Fran
Ramírez (2018) Historia de la
IA.
[En línea].
https://empresas.blogthinkbig.com/historia-de-la-ia-frank-rosenblatt-y-e/
75
Disponible:
[14] Aurélien Géron (2018) Neural networks and deep learning (c. Introduction to
Artificial Neural Networks)
[15] Michael Nielsen (2019) Improving the way neural networks learn. [En línea].
Disponible en http://neuralnetworksanddeeplearning.com/chap3.html
[16] Aishwarya V Srinivasan (2019) Stochastic Gradient Descent — Clearly Explained
[En
línea].
Disponible
https://towardsdatascience.com/stochastic-gradient-descent-
clearly-explained-53d239905d31
[17] Tensorflow. (2019) All case studies and mentions [En línea]. Disponible en:
https://www.tensorflow.org/about/case-studies
[18] Yann LeCun; Corinna Cortes, Christopher J.C. Burges (2019) THE MNIST
DATABASE
of
handwritten
digits
[En
línea].
Disponible
en:
http://yann.lecun.com/exdb/mnist/
[19]
Lincoln
Laboratory
(1998)1998
DARPA
INTRUSION
DETECTION
EVALUATION DATASET. [En línea]. Disponible en: https://www.ll.mit.edu/rd/datasets/1998-darpa-intrusion-detection-evaluation-dataset
[20] University of California, Irvine (1999) KDD99 Dataset. 1999. [En línea]. Disponible
en: http://kdd.ics.uci.edu/databases/kddcup99/kddcup99.html
[21] Canadian Institute for Cybersecurity (2019) CSE-CIC-IDS2018 on AWS. [En línea].
Disponible en https://www.unb.ca/cic/datasets/ids-2018.html
[22] Python (2020) Python. [En línea]. Disponible en: https://www.python.org/
[23]
Tensorflow
(2020)
Tensorflow.
[En
línea].
Disponible
en:
https://www.tensorflow.org/
[24] Keras (2020) Keras. [En línea]. Disponible en: https://keras.io
[25] Scikit-Learn. (2020) Scikit-Learn [En línea]. Disponible en: https://scikitlearn.org/stable/
[26] Pandas (2020) Pandas. [En línea]. Disponible en: https://pandas.pydata.org/
[27] NumPy developers (2020) Numpy. [En línea]. Disponible en: https://numpy.org/
76
[28]
Pickle.
(2020)
Pickle
[En
línea].
Disponible
en:
Disponible
en:
https://docs.python.org/3/library/pickle.html#module-pickle
[29]
Autonomio
(2020)
Talos.
[En
línea].
https://github.com/autonomio/talos
[30] Matplotlib (2020) Matplotlib. [En línea]. Disponible en: https://matplotlib.org/
[31] Anaconda (2020). Anaconda. [En línea]. Disponible en: https://www.anaconda.com/
[32] Jupyter (2020). Jupyter. Disponible en: https://jupyter.org/
[33]
Lanjelot.
(2020)
Patator.
[En
línea].
Disponible
en
https://github.com/lanjelot/patator
[34] Canadian Institute for Cybersecurity (2019) CICFlowMeter. [En línea]. Diponible
en http://www.netflowmeter.ca/netflowmeter.html
[35] Scikit-learn. (2019). sklearn.preprocessing.MinMaxScaler. [En línea]. Disponible en
https://scikitlearn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html
[36] Scikit-learn. (2019). sklearn.preprocessing.LabelEncoder. [En línea]. Disponible en:
https://scikitlearn.org/stable/modules/generated/sklearn.preprocessing.LabelEncoder.html
[37] Keras (2020) Keras utils. [En línea]. Disponible en https://keras.io/utils/
[38]
Wikipedia
(2019).
Matriz
de
confusión.
[En
línea].
Disponible
en
https://es.wikipedia.org/wiki/Matriz_de_confusi%C3%B3n
[39]
Wikipedia
(2020).
Elie
Bursztein.
[En
línea].
Disponible
en
https://en.wikipedia.org/wiki/Elie_Bursztein
[40] Youtube (2019) Cutting Edge TensorFlow: New Techniques (Google I/O'19). [En
línea]. Disponible en: https://www.youtube.com/watch?v=Un0JDL3i5Hg
[41] Mikko (2018) A Comprehensive List of Hyperparameter Optimization & Tuning
Solutions.
[En
línea].
Disponible
en
https://medium.com/@mikkokotila/a-
comprehensive-list-of-hyperparameter-optimization-tuning-solutions-88e067f19d9
[42] Keras (2020) Keras activations. [En línea]. Disponible en https://keras.io/activations/
77
[43] Keras (2020) Keras optimizers. [En línea]. Disponible en: https://keras.io/optimizers/
[44] OpenSSH (2020) OpenSSH. [En línea]. Disponible en: https://www.openssh.com/
[45] Wireshark (2020) Wireshark. [En línea]. Disponible en: https://www.wireshark.org/
78
Anexo A
Import.py
79
80
Anexo B
KerasTuner.py
81
82
Anexo C
bestIDS.py
83
84