Documentos de Académico
Documentos de Profesional
Documentos de Cultura
TFM CarlosTristanGonzalez
TFM CarlosTristanGonzalez
GIJÓN.
Acrónimos XVI
Agradecimientos XVII
1. Introducción 1
1.1. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2. Motivación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.1. Definición . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3. Arquitectura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
iii
2.4.1.3. Mensajes simétricos . . . . . . . . . . . . . . . . . . . 13
3. Desarrollo 19
3.1.1. Virtualización . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.1.2.1. OpenSwitch . . . . . . . . . . . . . . . . . . . . . . . . 22
3.1.3.1.2. VirtualBox . . . . . . . . . . . . . . . . . . . 26
iv
3.1.3.2.2. NS-3 . . . . . . . . . . . . . . . . . . . . . . . 27
3.1.3.2.3. GNS3 . . . . . . . . . . . . . . . . . . . . . . 27
3.1.4.1. OpenDayLight . . . . . . . . . . . . . . . . . . . . . . 28
3.1.4.2. ONOS . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.1.4.3. POX . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.1.4.4. Ryu . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.4.4.1. Controlador . . . . . . . . . . . . . . . . . . . . . . . . 40
3.4.4.2. Switch . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
v
3.5.1. Arquitectura de una aplicación en Ryu . . . . . . . . . . . . . . 42
4. Aspectos de seguridad 45
4.1.3.1.2. Implementación . . . . . . . . . . . . . . . . . 50
4.1.6. Mejoras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
vi
4.2.3. Mitigación del ataque en una red tradicional . . . . . . . . . . . 65
4.3.7. Mejoras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
vii
4.4.2. Protocolos de redundancia de primer salto . . . . . . . . . . . . 90
4.4.5.1.1. OSPF . . . . . . . . . . . . . . . . . . . . . . 93
4.4.5.1.2. EIGRP . . . . . . . . . . . . . . . . . . . . . 94
4.4.5.1.3. RIP . . . . . . . . . . . . . . . . . . . . . . . 94
4.4.5.2.1. HSRP . . . . . . . . . . . . . . . . . . . . . . 95
Anexos 117
viii
Anexo I. Aplicación de switch de capa 2 . . . . . . . . . . . . . . . . . . . . 117
Bibliografía 151
ix
Índice de figuras
2.1. Vista general de la arquitectura de las redes definidas por software [2] . 5
3.6. Primer escenario, con el switch OVS y las máquinas virtuales introducidas. 39
4.1. Paquete ARP capturado por medio del programa Wireshark, donde la
máquina con dirección IP 10.10.10.10 solicita quién tiene la IP 10.10.10.11. 49
x
4.3. Escaneo detectado por el controlador, en forma de llegada de paquetes
ARP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.6. Ping realizado tras detectar ataque, no funciona por el apagado del puerto. 57
xi
4.17. Paquete capturado por Wireshark en la máquina receptora del ataque
de doble tagging. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.22. Tráfico de paquetes RIPv2 entre las puertas de enlace legítimas. . . . . 100
4.24. Rutas aprendidas por el router R1, mostradas tras la ejecución del
comando «show ip route». . . . . . . . . . . . . . . . . . . . . . . . . . 102
4.26. Rutas aprendidas por el router R1 tras el ataque RIP, mostradas tras la
ejecución del comando ’show ip route’. . . . . . . . . . . . . . . . . . . 105
xii
4.30. Mensaje de advertencia en el controlador de la recepción de un paquete
RIP por un puerto no autorizado. . . . . . . . . . . . . . . . . . . . . . 109
4.31. Hipotético escenario con dos puertas de enlace distintas en cada switch. 110
xiii
Índice de tablas
xiv
Índice de Códigos
4.1. Función creada para el apagado de un determinado puerto . . . . . . . 52
4.2. Parte de código de la aplicación para detección de escaneos ARP . . . . 52
4.3. Función creada para descartar tráfico entrante de un determinado puerto 61
4.4. Fichero de configuración para aplicación de detección escaneos en red . 63
4.5. Función para creación de regla PVLAN . . . . . . . . . . . . . . . . . . 68
4.6. Generación de paquete para ataque PVLAN . . . . . . . . . . . . . . . 70
4.7. Código en aplicación para detectar y mitigar el ataque PVLAN . . . . 73
4.8. Script para la generación de los paquetes de ataque a una PVLAN . . . 74
4.9. Función que comprueba la VLAN nativa de destino de un puerto troncal 83
4.10. Script para la generación de los paquetes de ataque de doble etiqueta . 84
4.11. Parte del código de la aplicación de mitigación de ataques por
envenenamiento de tablas de rutas, en la que se obtiene si el paquete
procesado es EIGRP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
4.12. Script para la generación de paquetes RIPv2 fraudulentos. . . . . . . . 103
4.13. Parte del código de la aplicación de mitigación de ataques por
envenenamiento de tablas de rutas, con las mejoras que distinguen entre
switches. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
4.14. Código para detectar la llegada de paquetes EIGRP y si constituyen un
ataque por denegación de servicio . . . . . . . . . . . . . . . . . . . . . 113
5.1. Aplicación por defecto de un switch de capa 2. . . . . . . . . . . . . . . 117
5.2. Aplicación para detección de escaneos en red . . . . . . . . . . . . . . . 121
5.3. Aplicación para detener ataques PVLAN . . . . . . . . . . . . . . . . . 127
5.4. Aplicación para detener ataques de envenenamiento de rutas . . . . . . 132
5.5. Aplicación para detener ataques de doble tagging . . . . . . . . . . . . 138
5.6. Aplicación base de Ryu con funcionalidades VLAN . . . . . . . . . . . 146
xv
Acrónimos
GB . . . . . . . . . . . GigaByte.
MV ó VM . . . Máquina Virtual.
xvi
Agradecimientos
A todos mis compañeros de máster durante estos últimos dos años. Muy
especialmente a D. Enrique Álvarez Cofiño-García, D. Alejandro Casanova Alonso
y D. Javier Montes Antuña. Por todas las ayudas que me han ofrecido, su gran
compañerismo y, ante todo, grandes personas tanto dentro como fuera del ámbito de
estudios. Muchas gracias.
xvii
UNIVERSIDAD DE OVIEDO
Escuela Politécnica de Ingeniería de Gijón Hoja 1 de 155
1. Introducción
En este capítulo se comentan los principales objetivos del proyecto, así como las
motivaciones para llevarlo a cabo y el ámbito de estudio de este trabajo.
1.1.- Objetivos
Son muchos los ataques que pueden realizarse en un entorno LAN. De todos ellos,
se van a investigar algunos de los más extendidos, como por ejemplo el escaneo de
servicios, en donde un usuario malintencionado intenta obtener información de todos los
dispositivos de la red, con el objetivo de poder explotar sus vulnerabilidades. También
son objeto de estudio ataques unidireccionales en redes VLAN y PVLAN, en los que
el atacante puede enviar tráfico ilegítimo a usuarios a los que no tiene permitido el
acceso. También se investiga la forma de detener ataques para el envenenamiento de
rutas, donde un usuario malicioso modifica el comportamiento de la red con la intención
de interponerse en las comunicaciones y capturar el tráfico entre dos o más equipos
pudiendo obtener información sensible como contraseñas o datos bancarios, entre otros.
Es por ello que se aprovecha la versatilidad de las redes SDN así como
su programabilidad para conseguir los mismos resultados que con las técnicas
implementadas en las redes tradicionales pero reduciendo el coste y el esfuerzo.
1.2.- Motivación
Las Redes Definidas por Software constituyen hoy en día un hecho en muchos
aspectos del mundo de las redes: centros de datos, redes cloud o algunos ámbitos
universitarios son la prueba de que este nuevo paradigma, nacido en 2009, está cada
día más presente y ha venido para quedarse.
Una de las partes que componen este tipo de redes es la capa de aplicaciones:
piezas o conjuntos de software que interactúan con la red y pueden modificar
su comportamiento. Existen multitud de ellas enfocadas a diversos propósitos:
encaminamiento de tráfico, políticas de calidad de servicio o seguridad. Las aplicaciones
pertenecientes al ámbito de la seguridad, en la actualidad, son escasas y dejan al
descubierto muchas carencias solucionadas en el concepto tradicional de redes por
medio de hardware específico o la aplicación de varios protocolos simultáneamente.
La llegada de las SDN ha mejorado algunos aspectos respecto a las redes tradicionales,
sin embargo en el aspecto de seguridad los problemas se mantienen e incluso aparecen
algunos nuevos.
También es objeto de trabajo la capa de control, que aglutina toda la lógica de las SDN
y da soporte a las aplicaciones anteriormente mencionadas.
2.1.- Definición
El controlador es el elemento que contenga toda la lógica de la red. Cuenta con una
visión general de su topología y, junto con otra información, se encarga de elaborar, y
posteriormente enviar a cada dispositivo (switches y routers) las reglas de reenvío que
deben seguir. También tiene la capacidad de controlar y gestionar todos y cada uno de
los dispositivos de la red, como cortafuegos, servidores DNS, servidores NAT, etcétera.
Los cuatro pilares [1] que definen este nuevo concepto de red son:
Figura 2.1.- Vista general de la arquitectura de las redes definidas por software [2]
Las redes SDN son el fruto de mejoras en modelos preexistentes que no tuvieron
el impacto y el apoyo suficiente. Desde la aparición de Internet, elementos como los
enrutadores o los conmutadores han ido incrementando progresivamente la integración
de nuevos servicios y mejoras en la seguridad. Paralelamente, la capacidad de
computación ha ido aumentando casi exponencialmente su valor.
Así mismo, dentro de cada capa del protocolo, existía un manager. En el caso de la
capa de control, se encargaba de determinar qué elementos de control estarían activos
durante las fases de arranque del sistema. Para la capa de reenvío o datos, asocia cada
elemento de reenvío a uno o varios elementos de control.
Otro proyecto, que sería previo a la aparición de las SDN, tenía el nombre de
Ethane [4]. El creciente número de operaciones que un dispositivo de red podía ejecutar,
unido a una mayor sofisticación de las mismas, incrementaban el nivel de complejidad
traduciéndose, en definitiva, en una menor escalabilidad. La solución pasaba por delegar
todas estas tareas a un dispositivo de orden superior, actuando el resto como simples
encaminadores de paquetes.
Existía total control sobre quién enviaba cada paquete dentro de la red. Cada
usuario estaba registrado dentro de la red, así como su ubicación y acciones.
Una política de encaminamiento centralizada en un único elemento físico, el
controlador, el cual decidía quién podía comunicarse con quién. Esto era posible
añadiendo reglas de encaminamiento en cada dispositivo. Si no existía ninguna
regla coincidente, el paquete era descartado directamente.
Su adopción fue algo más significativa que ForCES, puesto que tenía mayor
compatibilidad con los dispositivos presentes en el mercado. Es considerado el
predecesor de protocolos como OpenFlow, el pilar fundamental de las SDN.
2.3.- Arquitectura
En los siguientes apartados se procede a explicar cada una de las capas que
conforman este nuevo concepto de redes. Existen tres bien diferenciadas: capa de
Aplicación, capa de Infraestructura y capa de Control.
El desarrollo de estas aplicaciones depende en buena medida del soporte que provea
el controlador. Cada uno consta de sus propias librerías. El más extendido es Java,
presente en todas las versiones los controladores más relevantes. Así mismo, existen
otras alternativas tanto en C como en Python.
Esta capa es, sin duda, el objetivo principal de un ataque cibernético. Un fallo
de seguridad podría comprometer a toda la estructura de una SDN puesto que la
intrusión de agentes maliciosos no solo les permitiría tener acceso al controlador, sino
también tanto al plano de aplicaciones (a través del NorthBound) como el plano
de infraestructura (a través del SouthBound). Puede suponer también la captación
de tráfico entre el controlador y el resto de capas de la red, llegando incluso a la
modificación de los contenidos de las tablas de enrutamiento de sus dispositivos.
Por último, destacar que, para hacer posible la comunicación entre la capa de
control y las aplicaciones, es necesario realizar un proceso de traducción de los
requisitos de estas últimas a un lenguaje de programación de más alto nivel. Las
alternativas disponibles van desde los más conocidos como Python, C++ o Java,
soluciones intermedias con el uso de librerías como Cisco OnePK ó, por último,
nuevos lenguajes específicamente diseñados para ello tales como FML (Flow-based
Management Language) o Nettle.
Esta capa comprende todos los elementos hardware que conforman la red, los
cuales comparten todas sus capacidades hacia la capa de control, mediante interfaces
«SouthBound». Estos dispositivos realizan, además del envío y recepción de paquetes,
dos tareas distintas: control y gestión. En el caso del control, el hardware de red se
encarga de recolectar el estado de la misma (tráfico, congestiones, topología a través
del protocolo LLDP, etcétera) y ésta es enviada al controlador, quien tras recibir esta
información elabora las reglas necesarias de reenvío de paquetes.
En el caso de la gestión, se debe focalizar la diferencia de las SDN con respecto a las
redes tradicionales, en donde en estas últimas los dispositivos, de manera autónoma,
ejecutan complejos algoritmos de encaminamiento para obtener la mejor ruta. Para las
redes definidas por software esta tarea es delegada en el controlador. En caso de que
un paquete no coincida con ninguna de las reglas, los dispositivos de la red envían ese
paquete al controlador para su posterior procesamiento. De esta manera, los dispositivos
de red se encuentran en un aprendizaje constante a medida que rellenan de información
sus tablas de rutas.
Gestionado por la Open Network Foundation (ONF) desde marzo de 2011, vio
la luz en su primera versión (0.1.0) en noviembre de 2007 fruto del trabajo de unos
desarrolladores de la Universidad de Standford. La primera versión estable (1.0.0) y, a
su vez, la más ampliamente conocida, no llegó hasta diciembre de 2009. A día de hoy,
la versión más reciente es la 1.5.1, publicada en abril del año 2015. Se tiene constancia
de la existencia de una versión 1.6 que data del año 2016, aunque la especificación de
la misma aún no ha sido puesta en conocimiento por parte de esta organización.
Se trata de un protocolo abierto y que está diseñado para manejar y dirigir el tráfico
de una red de forma centralizada, independientemente de su heterogeneidad.
Tabla de flujos o tabla «flow», que contiene todas las reglas de intercambio de
paquetes. El dispositivo busca alguna coincidencia en ellas cada vez que le llegue
un paquete.
Canal de comunicaciones, a través del cual el dispositivo se conecta al controlador
de la red.
El propio protocolo OpenFlow, que establece las reglas de intercambio de
mensajes entre controlador y dispositivo, así como el manejo de sus tablas de
flujo (añadir nuevas rutas, eliminarlas o modificarlas).
información como la versión del protocolo y el tipo de mensaje, tal y como se puede
observar en la figura 2.3. Estos mensajes pueden dividirse en tres grandes grupos:
- De controlador a Switch.
- Asíncronos.
- Simétricos.
A diferencia de los anteriores, son enviados desde los elementos de red hacia el
controlador, sin que éste haya realizado ninguna petición previa. La especificación de
OpenFlow habla de cuatro principales tipos de mensajes asíncronos. Packet-in, cuando
un paquete no tiene ninguna entrada en la «Tabla flow» del elemento de la red; Flow-
Removed, si una entrada de la «Tabla Flow» ha sido eliminada; Port-Status, si ha
cambiado el estado de algún puerto; Error que, como su propio nombre indica, avisa
de si se ha producido algún tipo de error.
Una vez establecida esta conexión entre controlador y switch, el protocolo OpenFlow
especifica que el controlador debe «descubrir» la ubicación de los switches de la red.
De lo que en realidad se trata este descubrimiento es la generación por parte del
controlador de la topología de la red. Esto quiere decir, que el controlador utiliza
Desde el lanzamiento de la primera versión estable, la 1.0.0 [8], han sido numerosos
los cambios producidos [23] en las distintas versiones del protocolo.
Figura 2.5.- Esquema del proceso de «entubado» o pipeline diseñado en la versión 1.1.0
del protocolo OpenFlow [9].
La versión 1.2.0 [10] añade soporte para direccionamiento IPv6. Define 44 campos
[30] por defecto, entre los que se incluye, por ejemplo, la separación de puertos TCP
y UDP y amplía la capacidad de modificación de los paquetes. Esta versión sienta
las bases para una alta disponibilidad del controlador, permitiendo la conexión de un
mismo dispositivo a varios controladores. Se definen tres roles para el controlador:
Equal: Con capacidad total para modificar un switch. Cada switch puede tener
N controladores equal.
Master: También con capacidad total para modificar un switch. Cada uno puede
tener únicamente asociado un controlador máster.
Slave. Con capacidad únicamente de lectura, cada switch puede tener asociados
N controladores slave.
reglas de sus tablas «Flow»: En vez de etiquetarse con un «flag», lo que se ejecuta es
una regla específica, a definir por el administrador de la red.
En su versión más reciente, la 1.5.0, [12] se introducen nuevas mejoras así como la
posibilidad de monitorizar flujos de tráfico. En la figura 2.6 se muestra un esquema
general de los principales elementos que conforman un switch OpenFlow tal y como
establece esta especificación.
Resulta de interés aprovechar las ventajas que ofrecen las SDN e investigar en el
desarrollo de aplicaciones que preserven la seguridad en la red frente a posibles ataques
comunes: Denegación de servicio, envío de paquetes fraudulentos, envenenamiento
de rutas o captación de información son algunos de los ejemplos más comunes. El
ámbito de las redes SDN se encuentra todavía en fase de evolución y explotación,
máxime si se trata del caso particular de las aplicaciones. Si bien su número aumenta
periódicamente, pocas profundizan en temas de seguridad más allá de detección de
ataques por denegación de servicio o aseguramiento de la conectividad segura a nivel
de protocolo OpenFlow.
3. Desarrollo
En este capítulo se detalla el entorno de trabajo objeto de esta investigación.
También se mencionan las distintas herramientas y programas utilizados.
Durante los siguientes apartados, se describen cada una de las alternativas a estudiar
para la implementación del entorno de trabajo, así como las soluciones finalmente
adoptadas para el presente proyecto.
3.1.1.- Virtualización
La virtualización es una tecnología desarrollada por IBM en los años 60, aunque
no fue hasta el final de los 90 cuando verdaderamente irrumpió, no solo en el área
tradicional de los servidores, sino también en muchos otros ámbitos del mundo de la
computación.
Consumo de recursos: Dadas las limitaciones del equipo físico con el que
se cuenta, es un aspecto muy a tener en cuenta. Es conveniente que sea un
dispositivo virtualizado con un bajo consumo de recursos, tanto de memoria
como de procesador y que ello no redunde en un bajo rendimiento. Hay que
ser conscientes de que el aprovisionamiento de recursos en el entorno de trabajo
debe repartirse, no solamente en estos equipos de la red, sino también en las
máquinas que simulan los ataques y aquéllas que hagan de usuarios destinatarios
de los mismos, así como del controlador de red.
3.1.2.1.- OpenSwitch
Open vSwitch - abreviado, OVS - es una plataforma de código abierto (open source)
que consiste en un switch multicapa virtual, con el objetivo de proveer soporte a redes
fundamentalmente virtualizadas. Nació en el año 2009 bajo la licencia 2.0 de Apache
y hoy en día es utilizado por multitud de plataformas a nivel internacional, así como
los principales software de virtualización, tales como VirtualBox o VMWare.
Cuenta con integración con diversos protocolos, como por ejemplo NetFlow, sFlow
o LACP. Soporta también la creación de redes LAN virtuales (VLAN) y desde hace
varios años se integra junto a OpenFlow en todas sus versiones. [47]
Hipervisor Hipervisor
Servidor Servidor
Dada su facilidad de uso, su interoperabilidad así como contar con una amplia
comunidad y soporte, se convierte en un firme candidato para este proyecto. En la
tabla 3.1 se adjuntan los requerimientos mínimos en un sistema de OVS.
Una vez determinados los dispositivos de red a usar, el siguiente paso es buscar
el mejor entorno posible para su implementación. La paleta de soluciones se reduce a
dos grandes opciones: la utilización de un software para la virtualizacion de sistemas
operativos, o apostar por programas orientados a la emulación de redes.
No son pocas las alternativas de las que se disponen hoy en día en el mercado y su
elección depende, en buena medida, del equipamiento con el que se cuente para dicha
simulación y sus características, tales como el tipo de procesador, su arquitectura o la
cantidad de memoria, entre otras.
Se parte de una estación de trabajo que cuenta con las especificaciones que se
muestran, reflejadas en la tabla 3.2
Dadas las circunstancias de crisis sanitaria, durante las cuales cursa este proyecto,
no es posible disponer de dicho equipamiento. Es por ello que se utiliza una
virtualización de Tipo 2 o hosted.
Es un programa desarrollado por VMware Inc [37]. Cuenta con más de 20 años
de desarrollo y es uno de los software de virtualización más extendidos en entornos
profesionales.
3.1.3.1.2.- VirtualBox
Una de sus grandes bazas es la facilidad de manejo por parte de casi cualquier tipo
de usuario. Entre sus características más destacadas, están la ejecución de máquinas de
manera remota por medio del protocolo Remote Desktop Protocolo (RDP), soporte de
almacenamiento de discos utilizando iSCSI o la aceleración en 3D gracias a un paquete
de controladores desarrollados por Oracle.
3.1.3.2.2.- NS-3
Existen proyectos de SDN realizados con NS-3, aunque estos se limitan a ámbitos
muy concretos en el entorno inalámbrico y no permite la inclusión de elementos
externos, como por ejemplo el uso de máquinas virtuales en sus redes.
3.1.3.2.3.- GNS3
sencillo para un usuario medio. Una de las múltiples características que incorpora
es la posibilidad de utilizar imágenes binarias de equipamiento de redes reales, como
por ejemplo, los sistemas de Cisco iOS. Ello permite una simulación de red muy fiel a
la realidad en un entorno virtual.
El número de controladores de red para este tipo de redes ha ido creciendo de manera
casi exponencial desde la aparición de NOX, el primer controlador de redes SDN. Con
el transcurso del tiempo, la aparición de nuevos controladores ha ido ligada también a
una ampliación de características de los mismos. Entre los más populares a día de hoy
destacan OpenDayLight, POX -versión de NOX escrita en Python-, Floodlight y Ryu.
De todos ellos se analizan, entre otras características, su integración con el protocolo
OpenFlow y la facilidad de diseño de aplicaciones que ofrecen. También su soporte y
consumo de recursos.
De este análisis se obtiene el controlador que más se ajusta a los propósitos iniciales
del presente Trabajo Fin de Máster
3.1.4.1.- OpenDayLight
3.1.4.2.- ONOS
Cuenta con una serie de APIs REST para su control por medio de diversos
programas y, al igual que OpenDayLight, está desarrollado enteramente en Java,
dotándolo de una mayor interoperabilidad.
Desde el mes de julio de 2016, cuenta con soporte para la versión 1.5 de OpenFlow,
la más reciente hasta el momento. En la tabla 3.6 se muestran los requisitos mínimos
para la ejecución de ONOS.
3.1.4.3.- POX
Tiene a cargo una extensa documentación [41] entre la que se encuentra el desarrollo
de aplicaciones en su entorno de programación. POX viene incluido en programas como
Mininet [42], un emulador de redes SDN basado también en Python.
Existe un proyecto, adicional a POX, denominado POX Web GUI [43] que permite
de una forma sencilla monitorizar toda la red desde el controlador: desde consultar la
tabla de flujos de los dispositivos de red hasta mirar qué tipos de paquetes han sido
recibidos en cada uno de sus puertos.
3.1.4.4.- Ryu
Escrito en lenguaje Python y con soporte para todos los sistemas Linux, cuenta con
una versión tanto gráfica como por consola. También es posible hacer uso de Scapy
por medio de scripts en lenguaje Python, siempre y cuando se incluya al principio del
archivo las sentencias de importación requeridas.
Ofrece al usuario multitud de posibilidades para realizar escaneos dentro de una red:
Por rango de puertos, por un puerto específico, protocolos específicos o varias subredes
a la vez entre otras opciones.
En cuanto a los elementos de red, es posible añadir tanto switches como routers.
Por defecto, vienen los dispositivos mostrados en la figura 3.3.
Controlador
Switch
Atacante Objetivo
Todo ello está realizado con los elementos que vienen por defecto en el programa
GNS3. Sin embargo, esto no sirve para los propósitos de este proyecto y es necesario
adecuarlo convenientemente:
El switch debe ser Open vSwitch. Esto requiere la realización una serie de pasos
para su inclusión en el presente proyecto, que se comentan más adelante.
El controlador es una máquina virtual Ubuntu Server, con las características
especificadas en el apartado 3.3
El atacante se sustituye por una máquina virtual con el sistema operativo Kali
Linux, con 2GB de RAM y 20GB de almacenamiento.
El objetivo del ataque es una máquina virtual Ubuntu Server, con las mismas
características que el controlador, especificadas en el apartado 3.3.
Con interfaz de gestión: Cuenta con un puerto dedicado exclusivamente para ser
conectado al controlador.
Sin interfaz de gestión: A diferencia del anterior, cualquier puerto puede ser
utilizado para conectarse al controlador.
Se hace uso del switch con una interfaz de gestión específica, puesto que permite
realizar de una manera paralela una red de gestión, separada del plano de datos,
aislando al controlador del resto de usuarios de la red.
Una vez realizados todos los pasos, aparece el nuevo switch disponible en la paleta
de dispositivos y se permite su importación al escenario. El resultado final se muestra
en la figura 3.5, donde puede verse un escenario compuesto por un switch Open vSwitch
y tres elementos conectados a él: el controlador, el atacante y el objetivo del ataque.
Figura 3.6.- Primer escenario, con el switch OVS y las máquinas virtuales introducidas.
El controlador está en una red independiente. Con ello se asegura que con el
controlador únicamente puede comunicarse el switch y no cualquier usuario de la
red. Se define a esta red con la dirección 10.15.10.0/29.
La dirección de partida de la red de los equipos es la 10.10.10.0/24, si bien esta
cambia en función de los distintos escenarios a estudiar.
El bridge interno del switch que se utiliza es el etiquetado como «br0».
3.4.4.1.- Controlador
Ello conllevará a la aparición de una larga lista de mensajes que finalizan con
la siguiente sentencia: wsgi starting up on http://0.0.0.0:8080. Eso significa que está
funcionando correctamente.
Una vez comprobada la correcta ejecución, se configura la interfaz de red con los
parámetros descritos en el apartado 3.4.1. La dirección IP es la 15.0.0.1 y la máscara,
al ser una red /29 la 255.255.255.248. Todo ello se realiza por medio de los comandos
ifconfig de Linux:
3.4.4.2.- Switch
puede ser mediante un programa externo como PuTTY. Para MacOS se integra junto
con la consola terminal del sistema operativo de Apple.
A lo largo de los diferentes escenarios que se van a realizar en este trabajo, pueden
existir dos tipos de dispositivos que ejerzan como máquinas finales: bien como atacantes,
como objetivo de los ataques, o simplemente emulación de equipos secundarios en la
red, para comprobar la conectividad de la misma. Estos pueden ser:
Máquinas virtuales: Son las que reciben los distintos ataques y todas ellas
disponen de sistemas operativos Linux. Los parámetros de configuración de sus
interfaces de red siguen el proceso análogo al descrito para el controlador.
VPCs: Son máquinas con funcionalidades muy limitadas que simulan
equipamiento de usuarios finales. Su propósito es comprobar la conectividad de
red en distintos tipos de escenarios. Poseen una interfaz por línea de comandos.
Para la asignación de direcciones IP basta con introducir el comando ip seguido
de la dirección que se desee.
Los entornos más extendidos son Java y C, liderados por ONOS y OpenDayLight.
En los últimos años, han ido apareciendo diferentes alternativas en Python, como
POX o Ryu entre otros grandes controladores. Existen también proyectos asociados
a OpenDayLight, que hacen uso de este lenguaje de programación aunque no son del
todo oficiales.
Existen varias aplicaciones que vienen de serie tras la primera instalación. Entre
ellas, Firewalls, VLANs o SimpleSwitch. Se parte como base de SimpleSwitch, que es
la aplicación base del resto.
Toda aplicación cuenta con una cola FIFO para recibir eventos. Estos pueden ser,
por ejemplo, la llegada de un paquete al controlador o el cambio del estado en un
puerto de un dispositivo. De igual manera que una aplicación recibe eventos, también
puede generarlos: modificar tablas de flujo, cambiar el estado de un puerto, obtener
estadísticas de tráfico, etcétera.
Cada evento recibido puede tener asociada una o varias funciones que realizan
distintas tareas. El evento principal en todas ellas es la llegada de un paquete al
controlador, evento packet_in. Para indicar este evento, se utiliza la marcación
especial en Python con un @. A continuación se muestra un ejemplo de una función
que maneje un paquete de llegada al controlador.
@set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
def packet_in_handler(self, ev):
msg = ev.msg
dp = msg.datapath
ofp = dp.ofproto
ofp_parser = dp.ofproto_parser
actions = [ofp_parser.OFPActionOutput(ofp.OFPP_FLOOD)]
out = ofp_parser.OFPPacketOut(
datapath=dp, buffer_id=msg.buffer_id, in_port=msg.in_port, actions=actions)
dp.send_msg(out)
El paquete recibido puede ser decodificado, por medio de las librerías packet o
ethernet presentes. Para ello es necesaria su importación:
45
UNIVERSIDAD DE OVIEDO
Escuela Politécnica de Ingeniería de Gijón Hoja 46 de 155
Existen multitud de herramientas para realizar este tipo de actos en redes. Para
este proyecto, se hace uso del software nmap. Para llevar a cabo el escaneo, el usuario
ejecuta un comando de escaneo en una red completa, como puede ser el que sigue:
$ nmap 192.168.0.0/24
Para poder mitigar un escaneo en la red, se actúa directamente sobre el switch que
da soporte a la red objeto de ese escaneo. Se va a partir de un enfoque reactivo, es
decir, que una vez se detecte que un determinado usuario está realizando un escaneo,
se realicen las acciones necesarias para detenerlo. Existen dos enfoques a la hora de
detener un escaneo en red ejecutado por un usuario malintencionado:
Figura 4.1.- Paquete ARP capturado por medio del programa Wireshark, donde la
máquina con dirección IP 10.10.10.10 solicita quién tiene la IP 10.10.10.11.
Las direcciones IP pueden variar a lo largo del tiempo, dependiendo de si éstas son
estáticas o dinámicas e, incluso, de la configuración establecida por el administrador
de la red. Sin embargo, la dirección física es única para cada dispositivo del mundo y,
por tanto, no varía. A partir de ellas puede determinarse información, por ejemplo, del
tipo de dispositivo que se trata o de su fabricante.
4.1.3.1.2.- Implementación
Cada vez que el controlador recibe un paquete que no encaja en ninguna de las reglas
que tiene implementadas, existen dos opciones a definir por el administrador de la red:
o bien ese paquete es descartado, o se envía al controlador para su procesamiento. Esto
es posible configurarlo gracias a lo que en OpenFlow se denomina miss-table, una de
las novedades introducidas a partir de la versión 1.3. En el caso de las peticiones ARP,
cada vez que un dispositivo la recibe, ésta es automáticamente enviada al controlador.
Por medio de distintas funciones que provee Ryu, es posible procesar este paquete
y extraer de él todo tipo de información relevante para el propósito de este trabajo,
entre otros:
Teniendo en cuenta un escaneo en una subred «tipo», esto es, con un máximo de 254
dispositivos, se presuponen un mínimo de otras tantas peticiones ARP. Es por ello que
se determina un umbral de 50 peticiones ARP como máximo por dispositivo o puerto.
En caso de que este umbral se supere, se procede al apagado del puerto correspondiente
del dispositivo.
Por cada petición ARP, se determina el puerto por el que ha llegado al switch y
se comprueba si su número se encuentra en el diccionario como «clave». En caso de
no ser así, se crea una nueva entrada en el diccionario y se le asigna un contador, con
valor inicial de 1. En caso de existir dicha clave, este contador incrementa su valor de
uno en uno cada vez que un paquete ARP sea recibido por dicho puerto.
Para el apagado del puerto, se crea una función, shutdown_port, que recibe los
siguientes parámetros:
$ nmap 10.10.10.0/24
Para hacer la comprobación de que los escaneos de red son detectados y se actúa
en consecuencia, se habilita el código comentado en anteriores apartados, encargado
de desactivar todo puerto que recibe un volumen de tráfico ARP superior a un umbral
preestablecido. Cuando un puerto físico de un dispositivo cambia de estado, como es
este caso de «encendido» a «apagado», se le envía un mensaje al controlador informando
de que se han producido cambios en los puertos.
Este hecho es notificado por parte del controlador con mensajes de advertencia e
información, que han sido puestos a propósito a la hora de desarrollar el programa.
Dichos mensajes se observan en la figura 4.4. Se advierte al usuario de que se ha
detectado un escaneo en el puerto 4 en este caso concreto. A continuación, se le informa
de que dicho puerto se ha apagado. De manera adicional, se muestra un mensaje propio
al protocolo OpenFlow, DPSET, informando de que se ha producido un cambio en
uno de los puertos del switch, mensaje que se corresponde con la última línea mostrada
en la citada figura 4.4.
Figura 4.4.- Escaneo detectado por el controlador. Mensajes en forma de alerta del
ataque y del apagado del puerto.
el cual se ejecuta el ataque. Esto se refleja en la figura 4.5. Sin embargo, debe hacerse
aquí una mención: si la dirección IP hubiese sido, por ejemplo, 10.10.10.25, el escaneo
sí daría resultados positivos, puesto que el límite establecido de peticiones es de 50,
aunque el resultado final sería el mismo: el puerto del atacante apagado y, por tanto,
el ataque detenido.
Figura 4.6.- Ping realizado tras detectar ataque, no funciona por el apagado del puerto.
4.1.6.- Mejoras
Teniendo esto en cuenta, en caso de que se reciban 50 peticiones ARP por un mismo
puerto, se pueden distinguir dos situaciones bien distintas:
Por un lado, que esas 50 peticiones hayan sido espaciadas a lo largo del tiempo.
Se trataría de una situación normal dentro de cualquier red, fruto de ajustes,
instalación de programas o apagado y encendido rutinario de equipamiento en
red.
Que se hubieran recibido en un espacio muy corto de tiempo, entre medio minuto
y un minuto. En este caso, se hablaría más bien de un escaneo de servicios.
Es por ello que se evitarían falsos positivos por ataques, debido al recuento total
de paquetes sin tener en cuenta la diferencia de llegada entre ellos.
momento la conectividad del usuario atacante, sin darle ningún tipo de pista de que
haya sido descubierto.
Para insertar la regla en la tabla de flujos, se crea una función dentro de la clase
general de la aplicación. Esta contiene todas las instrucciones necesarias, siguiendo la
documentación establecida por Ryu. En esta función se pasan como parámetros los
siguientes objetos:
match: El conjunto de reglas de flujo que deben satisfacer los paquetes que
procesa el switch. Aquí se especifica que todo aquel paquete procedente de ese
puerto sea descartado.
Instructions: Las acciones a realizar sobre esos paquetes que satisfacen
el criterio anteriormente descrito. En este caso concreto, se quiere que
todos ellos sean descartados por el switch. Esto se indica con la variable
OFPIT_CLEAR_ACTIONS.
out_port: Puerto o conjunto de puertos de salida sobre los que aplicar esta
regla. No se hacen distinciones de puertos en esta primera versión de la regla, por
tanto se indica que se aplique a todos los puertos del dispositivo. Esto se indica
con la opción OFPP_ANY.
out_group: Los grupos son abstracciones de OpenFlow que permiten
representar un conjunto de puertos como una única entidad. Un ejemplo de
grupos es el de multicast. Aquí tampoco se hacen distinciones y se marcan todos
Código 4.3.- Función creada para descartar tráfico entrante de un determinado puerto
def drop_arp_traffic(self ,datapath,port):
parser = datapath.ofproto_parser
ofproto = datapath.ofproto
match = parser.OFPMatch(in_port=port)
actions = [parser.OFPInstructionActions(ofproto.OFPIT_CLEAR_ACTIONS,[])]
mod = parser.OFPFlowMod(datapath=datapath,
out_port=ofproto.OFPP_ANY,
out_group=ofproto.OFPG_ANY,
match=match, instructions=actions)
datapath.send_msg(mod)
Para aplicar esta política selectiva, basta con la introducción de una variable que
contenga el identificador único de los puertos a los cuales no se quiere aplicar la política
de detección de escaneos en red. Una vez incluida dicha variable, en las comprobaciones
de llegada de paquetes ARP, se realiza una primera comprobación de si el puerto de
llegada de dicho paquete se encuentra excluido o no.
Hasta ahora, todos los parámetros de las aplicaciones mencionadas con anterioridad
estaban definidos explícitamente en el código fuente. Esta técnica, denominada hard-
coding en inglés, está altamente desaconsejada en términos de programación, máxime si
se trata de variables que contengan información sensible como usuarios y contraseñas.
Es necesario llevar, por tanto, todos los parámetros susceptibles de ser modificados por
cualquier administrador a un fichero de configuración externo.
El controlador de la red.
10.10.10.120
Controlador
AA:AA:AA:AA:AA:AA
R1
Switch
PVLAN 1 PVLAN 2
10.10.10.1 10.10.10.2
Atacante Objetivo
paquete. Una vez llega al router, analiza la dirección IP de destino, con la cual sí tiene
comunicación, y es enviada al usuario objetivo del ataque.
Para evitar este tipo de ataques en el plano de las redes convencionales, se actuaría
sobre el router por medio de la declaración de listas de control de acceso (ACLs). En ella
se especifica que todo el tráfico entre máquinas de la misma red debe ser bloqueado. En
la figura 4.8 se muestra un ejemplo de una ACL para un router de Cisco, que deniega
todo el tráfico IP entre dos máquinas de distintas PVLAN, la máquina 10.10.10.1 y la
máquina 10.10.10.2.
Figura 4.8.- Lista de control de acceso para un router de Cisco, con el objetivo de
denegar todas las comunicaciones IP entre dos máquinas.
pero sobre una tabla de flujo: que todo tráfico entre equipos de una misma red se
bloquee.
Como bien se ha explicado en la sección 2.4, para cada flujo de tráfico entrante
en el switch se puede establecer una serie de acciones a tomar por el dispositivo, a
destacar tres: el envío por un determinado puerto del switch, el envío de este tráfico
al controlador o su descarte. En este caso, se establece una regla que indique que todo
tráfico entre dispositivos de la misma red se descarte. Esta regla sirve como base, sujeta
a futuros ajustes en función de nuevos requerimientos que puedan surgir.
OpenFlow, entre sus reglas para las tablas de flujo, permite establecer como criterios
tanto la dirección IP de origen como la de destino. Para una red con múltiples
dispositivos a los que queremos aplicar esta directriz, implica crear una regla por cada
uno de ellos. Es necesario buscar alguna forma de aplicar el menor número de reglas
posibles que afecten al mayor conjunto de dispositivos, por ejemplo, especificar una
subred y no solamente un único dispositivo. Esto es importante, puesto que el número
de entradas en la tabla de flujos es limitado.
En el plano del controlador objeto de este proyecto, Ryu, se debe crear la aplicación
que introduzca automáticamente la regla, o reglas, en la tabla de flujos del switch, con
el fin mitigar este tipo de ataques.
La instrucción que ha de darse al switch debe indicar que toda petición cuya
dirección de origen y de destino se encuentren en el mismo segmento de red, sea
descartada. Aunque parezca una regla sencilla, se debe lidiar con determinados aspectos
a la hora de implementarla correctamente, entre ellos:
Para crear las reglas de flujos en el switch, se deben de indicar las direcciones de
red sobre las que se pretende restringir el tráfico. No se trata de una información
trivial, puesto que cada red es diferente y esta información varía dependiendo de la
configuración realizada. Es por ello que, dicha información, ha de ser suministrada por
el propio administrador de la red.
información esgrimida por Ryu establece que esto es posible, siempre que se indique la
dirección base de la red así como su máscara, en formato decimal.
3. Hacer uso del protocolo X11 por medio de SSH que permite ejecutar, de forma
gráfica, aplicaciones de Linux.
Se utiliza esta última opción debido a que Wireshark, en su versión gráfica, resulta
un programa muy sencillo de utilizar.
Campo Valor
MAC Origen 00:00:00:00:02:00
MAC Destino ca:01:13:13:00:00
IP Origen 10.10.10.5
IP Destino 10.10.10.6
Interfaz eth1
Tabla 4.1.- Datos de configuración para generación del paquete de ataque a una PVLAN
en Scapy.
$ sudo wireshark
Una vez iniciado, se selecciona la interfaz de red a través de la cual se van a capturar
los paquetes. En el caso de esta máquina, la etiquetada como «eth0», tal y como se
muestra en la figura 4.9
Figura 4.10.- Envío de paquetes exitoso desde la interfaz por línea de comandos de
Scapy.
De igual manera, si todo sale como estaba previsto, se debe encontrar en el objetivo
del ataque el rastro del ataque, en forma de paquetes recibidos. En la figura 4.11 se
observa perfectamente este hecho, con los paquetes marcados en rojo.
El código empleado en el controlador para detener este ataque se muestra con detalle
en el código 4.7.
Código 4.8.- Script para la generación de los paquetes de ataque a una PVLAN
#Importacion de Scapy y todos sus paquetes
from scapy import all as scapy
import sys
def main():
try :
packet = scapy.Ether(src="aa:aa:aa:aa:aa:aa", dst="ca:01:13:13:00:00")
packet = packet/scapy.IP(dst="10.10.10.6",ttl=(1,4))
scapy.sendp(packet, iface ="eth1")
except Exception as e:
print(e)
sys . exit ()
if __name__ == "__main__":
main()
Figura 4.12.- Paquetes capturados en la máquina objetivo del ataque de PVLAN, donde
no aparece ninguno perteneciente al ataque.
Así mismo, en la consola de información del controlador, debe aparecer la alerta que
ha sido incluida en el código de la aplicación, advirtiendo del ataque y de la correcta
implementación de la regla en el switch. Esto se detalla en la figura 4.13
Figura 4.13.- Información mostrada por la consola del controlador, advirtiendo del
ataque y de que la regla se ha implementado con éxito.
Se han señalado en la figura 4.13 en color rojo con línea discontinua dos partes:
Como comprobación final, quedaría ver si, en efecto, la regla está vigente en el
dispositivo. En Open vSwitch esto se puede realizar introduciendo el siguiente comando
en el dispositivo:
Introduciendo este comando, se muestran todas las reglas del switch. En la figura
4.14 se representa la información de las tablas de flujo del switch. Se ha subrayado en
azul claro la reglas de interés y la acción asociada (drop, en este caso, que es descartar).
Figura 4.14.- Tabla de flujos del controlador, en la que se observa la regla de restricción
de comunicación entre dispositivos de la misma red, con el fin de mitigar el ataque de
PVLANs.
Las VLAN (virtual local area network) son segmentos lógicos dentro de una misma
red física. Estas divisiones de una red en varias más pequeñas permiten reducir el
dominio de difusión y ayudan a la administración de la red. Estos segmentos se
administran por medio de un switch que permita tal acción para así albergar diferentes
redes VLAN.
La comunicación entre equipos de una misma VLAN está permitida, no siendo así
entre equipos que pertenezcan a segmentos de redes VLAN distintas. Este aspecto es
muy importante tenerlo en cuenta sobre todo en lo que respecta a temas de seguridad.
Una misma red virtual puede pertenecer a múltiples switches, estando por tanto la
conectividad asegurada. Esto es posible mediante la conexión de los switches entre sí y
definiendo lo que se denominan «puertos troncales» (trunk ports), que permiten el paso
de información de múltiples VLAN entre switches. Cada red virtual tiene asignada un
identificador único, que consiste en un número comprendido entre 1 y 4096.
VLAN 20: Es la nativa y pertenece al enlace troncal entre los dos dispositivos
conmutadores de red. A esta VLAN pertenece también el atacante, con dirección
IP 10.10.10.1 en una red 10.10.10.0/29
VLAN 30: Es la objetivo de ataque en este caso, cuya dirección de red es la
10.10.10.8/29 y el objetivo una dirección IP 10.10.10.10.
El objetivo de este ataque es que el usuario malicioso pueda enviar tráfico desde la
VLAN 20 hasta la 30.
Controlador
Switch red
administración
Switch 1 Switch 2
VLAN 20 VLAN 30
10.10.10.0/29 10.10.10.8/29
10.10.10.1 10.10.10.10
Atacante Objetivo
La trama que viaja por el enlace entre los dos switches contiene entonces una única
etiqueta, la de la VLAN 30. Cuando ésta llega al segundo de los switches, al observar
la etiqueta, envía la trama correspondiente al equipo de la VLAN 30.
Existen varias formas de evitar este tipo de ataques entre redes VLAN distintas. El
primero, y más evidente, es evitar que un usuario cualquiera pueda conectarse, de forma
directa, a un puerto troncal del switch. Sin embargo, existen ataques que permiten
cambiar un puerto normal y convertirlo en troncal, como por ejemplo, utilizando el
protocolo DTP (dynamic trunk port).
En las redes definidas por software, el controlador puede actuar sobre los paquetes
modificando sus campos, añadiendo o eliminando etiquetas existentes. Así mismo, estas
acciones pueden recaer sobre los switches de la red, gracias a las acciones incluidas en
las tablas de flujo correspondientes.
La aplicación que viene por defecto, y que contiene toda la lógica de las VLANs
para dispositivos que utilicen como controlador Ryu, se adjunta en el Anexo VII.
En síntesis, lo que realiza es una inspección de los paquetes que llegan al controlador.
El administrador de la red debe indicar, para cada puerto, las VLANs correspondientes
y su modo (acceso o troncal). Una vez hecho esto, el controlador comprueba si los
paquetes que le llegan contienen algún tipo de etiqueta VLAN. Si cumplen este
criterio, se analiza qué puertos tienen asociada esa VLAN, gracias a la información
proporcionada previamente:
Para evitar los ataques de doble etiquetado, se deben efectuar cambios a nivel de
aplicación que modifiquen la forma en que el controlador los procesa una vez llegan.
Este cambio es el siguiente: todo tráfico recibido en un puerto troncal, sin etiquetar,
debe ser etiquetado con la VLAN nativa antes de atravesar el troncal. En caso de
que ya viniese etiquetado con la nativa, no se hace nada. Para el resto de casos, el
funcionamiento sigue siendo el que viene marcado por defecto.
dpid: Número de identificación único del switch, para realizar las comprobaciones
de los puertos en las listas proporcionadas por el administrador de la red.
out_port_trunk: Lista que contiene todos los puertos troncales candidatos
para la salida del paquete.
src_vlan: Número identificativo de la VLAN presente en el paquete recibido.
En caso de contener múltiples etiquetas, siempre se obtiene el de la etiqueta más
externa.
Código 4.9.- Función que comprueba la VLAN nativa de destino de un puerto troncal
def check_out_port_trunk(self,dpid,out_port_trunk,src_vlan):
checker = [False, "" ]
for port in out_port_trunk:
if src_vlan in port_vlan[dpid][port ]:
checker = [True,port_vlan[dpid][port]]
return checker
checker[1]=port_vlan[dpid][port]
return checker
En el caso que la tupla sea [True, null], el paquete se procesa de manera normal,
sin modificar ninguna de sus etiquetas. Se suprime la acción de eliminar la primera
etiqueta, como se realizaba hasta el momento.
En la primera instrucción se pasa como argumento el tipo de paquete, que para este
caso es de tipo 802.1Q, cuyo identificador en hexadecimal es 0x8001 y en decimal es
33024.
actions = []
actions.append(parser.OFPActionPushVlan(33024))
actions.append(parser.OFPActionSetField(vlan_vid=src_vlan))
A estas acciones, se le suman también aquellas que envían el paquete por todos los
puertos candidatos troncales, incluidos en la variable out_port_trunk.
Código 4.10.- Script para la generación de los paquetes de ataque de doble etiqueta
from scapy import all as scapy
import sys
def main():
try :
packet = scapy.Ether(dst='08:00:27:16:1e:bf' , src='08:00:27:db:9c:b2')
packet=packet/scapy.Dot1Q(vlan=20)/scapy.Dot1Q(vlan=30)
packet=packet/scapy.IP(dst='10.10.10.10', src='10.10.10.1')/scapy.ICMP()
scapy.sendp(packet, iface ="eth1")
except Exception as e:
print(e)
sys . exit ()
if __name__ == "__main__":
main()
El primer switch recibe el paquete generado a través del puerto troncal 4, que da acceso
al atacante. Siguiendo el procedimiento que tienen los switches por defecto, elimina la
primera etiqueta y la envía por el enlace troncal, cuya VLAN nativa es la misma que
la del atacante. Dicho paquete es recibido por el puerto 10 del segundo switch con
únicamente una etiqueta, la de la VLAN 30, cuyo puerto asociado es el número 2. La
trama llega finalmente al destino del ataque.
Para poder tener la trazabilidad del paquete en todo momento, se han habilitado
mensajes de depuración en el controlador que informa en todo momento del puerto de
llegada del paquete así como de la etiqueta de VLAN que tiene asociada más externa.
Al ejecutar el script, aparecen los mensajes que pueden observarse en la figura 4.16.
de las que contenía. En consecuencia, el switch interpreta que ese paquete es para el
ordenador víctima, reenviándolo por su correspondiente puerto.
Figura 4.17.- Paquete capturado por Wireshark en la máquina receptora del ataque de
doble tagging.
Mediante la doble etiqueta, el tráfico llega al destino tal y como estaba previsto.
Esto abre la puerta a ataques unidireccionales hacia el objetivo, desde denegación del
servicio hasta el envío de malware vía UDP.
Ahora se procede a ejecutar el mismo tipo de ataque, pero con las modificaciones
en el funcionamiento de la red efectuadas y explicadas en el apartado 4.3.4.1.
script que en el apartado anterior, donde se envía un paquete con doble etiqueta. Al
haber modificado el comportamiento de los switches, para ambos debe llegar el paquete
con la misma etiqueta externa, en este caso, con la de la VLAN 20. El resultado en el
controlador, tras la ejecución del ataque, se muestra en la figura 4.18.
Como era previsible, en la máquina objetivo este paquete no es recibido, tal y como
se observa en la figura 4.19.
4.3.7.- Mejoras
Todas las configuraciones de las VLAN por dispositivo se llevan a un fichero externo,
en formato YAML. Para cada switch, se indican los puertos de acceso, los troncales y
las VLAN que tienen asociadas. Cuenta con la siguiente estructura:
port_vlan = {
2855770673994: {
10:[20],
4:[20]
},
143080643644224: {
2:[30],
10:[20]
}
}
access= { 2855770673994:[],
143080643644224:[2]
}
trunk = { 2855770673994:[4,10],
143080643644224:[10]
}
Para que un entorno de red LAN tradicional sea seguro debe hacerse una correcta
configuración de estos protocolos. En el ámbito de estudio de este proyecto, se pretende
aplicar técnicas de SDN para mitigar los problemas de seguridad que una mala
configuración de estos protocolos puede provocar.
Dos de los protocolos más utilizados en redes son Open Shortest Path First (OSPF)
y Enhanced Interior Gateway Routing Protocol (EIGRP). Ambos proporcionan
mecanismos de autenticación y seguridad. Sin embargo, esto requiere una configuración
minuciosa de los dispositivos que empleen dichos protocolos.
Existen varios protocolos de redundancia de primer salto, como por ejemplo el Hot
Standby Routing Protocol (HSRP) de Cisco, donde un router es el activo y el resto se
El escenario objeto de trabajo para este apartado está constituido por dos redes:
La 10.10.10.0/24 y la 120.10.10.0/24. Ambas cuentan con sus puertas de enlace,
10.10.10.120 y 120.10.10.1 respectivamente.
La red 10.10.10.0/24 cuenta con dos usuarios, el atacante y la víctima del ataque.
El objetivo es interceptar el tráfico que tenga como destino la red 120.10.10.0/24.
R2
F1/1 120.10.10.1
F0/0 20.0.0.1
Red 120.10.10.0/24
Switch
10.10.10.5 10.10.10.6
Atacante Objetivo
4.4.5.1.1.- OSPF
Existen dos maneras de proteger las comunicaciones por mensajes del protocolo
OSPF: mediante la autenticación de los mensajes o la declaración de aquellas interfaces
por las que no se desean «aprender» nuevas rutas como «pasivas».
Autenticación por texto plano: Conocida también como «tipo 1», utiliza
contraseñas sin cifrar en las cabeceras de los mensajes.
Autenticación MD5: O de «tipo 2» y cifra las contraseñas mediante el
algoritmo MD5.
4.4.5.1.2.- EIGRP
Dichas claves han de ser introducidas por el propio administrador de la red, puesto
que no se encuentran activadas de inicio al utilizar este protocolo.
4.4.5.1.3.- RIP
RIPv1 no ofrece ningún tipo de autenticación, lo que hace más vulnerable a este
protocolo a ataques. La versión 2 introduce autenticación, mediante los anteriormente
mencionados MD5 o texto plano.
4.4.5.2.1.- HSRP
Al igual que OSPF, HSRP ofrece autenticación de los mensajes mediante texto
plano y el algoritmo MD5. Esto debe ser habilitado por el administrador de la red,
puesto que la opción que se establece por defecto es la de mensajes sin ningún tipo de
autenticación.
a los cuales no esté conectado ningún router, este tráfico al ser recibido en el switch se
descartaría automáticamente. Sin embargo, han de tenerse en cuenta ciertos aspectos
de configuración que pueden ser propios a cada sistema, como por ejemplo, la existencia
de puertos troncales o las distintas topologías de red existentes.
Siguiendo las directrices de los anteriores ataques, se establecen en los switches una
serie de reglas de flujo, acorde con las exigencias que quiera establecer el administrador
de la red. Si bien la inclusión de reglas es una opción válida, existen otros enfoque
igualmente válidos para mitigar estos ataques en el plano de las SDN.
contenido para una serie de receptores interesados. Cualquier paquete que llegue a un
switch en una red SDN con dirección IP de destino multicast, no va a encontrar, a menos
que se haya especificado previamente algún tipo de regla, coincidencias en la tabla del
switch. Esto supone que se aplica la opción por defecto establecida por el administrador
de red. En el caso de este trabajo, esta opción es la del envío al controlador. Es por
ello que, de partida, está asegurado que todo paquete de protocolos de enrutamiento
es reenviado al controlador.
Por medio del uso de funciones definidas en la biblioteca de Ryu, es posible extraer
el tipo de paquete que llega al controlador, así como el id del protocolo asociado, en
caso de tratarse de una trama IP. Cada cabecera de un paquete IP contiene un campo
de 8 bits de longitud que se corresponden con el identificador del protocolo que tienen
asociado, como puede observarse en la figura 4.21. Estos valores, pueden consultarse
en la literatura o cualquier fuente de información sobre el protocolo. En este caso
concreto, interesa conocer los valores que tienen asociados los protocolos EIGRP y
OSPF en dicho campo: EIGRP tiene el valor 88 y OSPF el 89.
En el código 4.11 se muestra una parte del código empleado en la aplicación, para
el caso concreto de los paquetes EIGRP. Para el resto de protocolos, el procedimiento
es análogo al mostrado.
Figura 4.22.- Tráfico de paquetes RIPv2 entre las puertas de enlace legítimas.
En cada paquete RIP recibido, podemos obtener información muy valiosa, como
por ejemplo las redes que anuncia cada router y su métrica. Estos datos son los
que el atacante necesita para poder replicar y generar paquetes fraudulentos. En
concreto, como se refleja la figura 4.23 la puerta de enlace 10.10.10.120 anuncia la
red 120.10.10.0/24 con una métrica de 2. A partir de ello, se procede por parte del
atacante a generar los paquetes RIP.
Tras el intercambio de mensajes, cada router ha aprendido las rutas anunciadas por
el otro. Para comprobar esto, se ejecuta el comando show ip route en el router R1, que
es la puerta de enlace de la red y se observa la siguiente información, mostrada en la
figura 4.24
Figura 4.24.- Rutas aprendidas por el router R1, mostradas tras la ejecución del
comando «show ip route».
En la última línea se puede observar como ha aprendido, por medio de RIP, que se
puede acceder a la red 120.10.20.0/24 a través de la dirección 20.0.0.1.
Para la generación de los paquetes RIP fraudulentos, se hace uso de Scapy. Se crea
un script de Python que se encarga de lanzar, en cada ejecución, un paquete con los
siguientes parámetros:
Por parte del atacante, es necesario que se envíen paquetes RIPv2 de manera
constante para que el router no deje de olvidar las rutas.
Con la instrucción «loop» se indica que la repetición del envío de manera indefinida,
y con el parámetro «inter» que sea cada 30 segundos.
Como se observa en la imagen 4.26, la ruta para acceder a la red 120.10.20.0/24 es,
únicamente, a través del atacante.
Figura 4.26.- Rutas aprendidas por el router R1 tras el ataque RIP, mostradas tras la
ejecución del comando ’show ip route’.
Para comprobar que, en efecto, la ruta está envenenada y los paquetes puede ser
capturados por el atacante, se procede a realizar una prueba de este hecho. Se incluye
un PC de prueba en la red 120.10.10.0/24, con dirección IP 120.10.10.10. El PC objetivo
del ataque, intenta enviar tráfico hacia ese ordenador y el router desvía ese tráfico hacia
el atacante, puesto que en su tabla de rutas así está indicado. Para simular tráfico, basta
con hacer un simple ping desde el equipo atacado hacia el PC con IP 120.10.10.10. En
la máquina atacante, se ejecuta Wireshark con el fin de comprobar si los paquetes
ICMP se reciben aunque no fuese su destinatario legítimo.
Al no haber enrutado el tráfico hacia la red legítima, los pings ejecutados por la
víctima no son respondidos, mostrándose el mensaje «timeout» correspondiente en la
consola de comandos:
Figura 4.28.- Pings sin respuesta en la máquina víctima, consecuencia del desvío de
tráfico de manera ilegítima.
Para completar el ataque de forma exitosa, el atacante podría enrutar todo el tráfico
a la red legítima y actuaría como intermediario, interceptando todo el tráfico de ida y
vuelta. Es lo que se conoce como ataque Man in the Middle
Ports_enabled = [13]
Con ello, todos los mensajes que provienen del atacante, conectado al puerto 4,
deben descartarse y no afectar a las tablas de rutas de los dispositivos de enrutamiento
legítimos. Se debe mostrar por el controlador una alerta al usuario, indicando que se
ha recibido un paquete RIP por el puerto 4 y que dicho puerto no está autorizado para
recibir dicho tráfico, como se observa en la figura 4.29
Con esto, el router R1 deja de recibir mensajes RIP falsificados. Al cabo de tres
minutos, el router al no recibir paquetes RIP del atacante considera esa ruta como no
válida y la elimina de su tabla, como bien se expone en la figura 4.30, en donde ya no
se refleja la red 120.10.20.0/24 asociada al usuario malicioso, el 10.10.10.5.
4.4.7.- Mejoras
En una red definida por software, un mismo controlador puede manejar varios
switches de manera simultánea. De igual forma, una red puede estar gobernada por
varios controladores, bien de manera simultánea, o con un controlador principal y varios
que tienen que estar disponibles de manera inmediata en caso de indisponibilidad del
controlador principal.
eth1 eth2
Dispositivo A Dispositivo B
Figura 4.31.- Hipotético escenario con dos puertas de enlace distintas en cada switch.
Por tanto, resulta lógico que para el switch A se permita tráfico de protocolos de
enrutamiento en el puerto 1 y, en el caso del switch B para el puerto 2 únicamente.
Tal y como está construida la aplicación, esto solamente sería posible declarando los
puertos 1 y 2 como accesibles a este tipo de tráfico. El resultado sería que el switch
A tendría un puerto, el número 2, libre de restricciones y el B el puerto 1, de manera
innecesaria. Una configuración mal hecha y que compromete a la red. El problema se
agravaría si se contase con un mayor número de switches en la red.
Es por ello que debe distinguirse entre switches. Para hacer esto posible, se hace
uso de un identificador único con el que cuenta cada switch de la red, denominado
dpid (datapath ID). En cada paquete que es recibido por el controlador, entre otras
informaciones, es posible extraer este identificador, que indica el switch que ha enviado
dicho paquete. Con ello, resulta relativamente sencillo implementar esta mejora.
Basta con conocer los identificadores de cada switch y comprobar qué puertos tiene
permitidos. Esto implica modificar, por un lado, la variable de puertos definida con
anterioridad, que consistía en una lista, por un diccionario. Las claves únicas van a ser
los identificadores del switch. Para el ejemplo de escenario mencionado con anterioridad,
la configuración de la variable Ports_enabled sería como sigue:
Por otro lado en el código 4.11, durante la comprobación, debe consultarse la lista
de puertos asociados al switch del que provenga el paquete. El cambio se muestra en
el código 4.13, concretamente en la línea 6.
Con esta mejora lo que se persigue es evitar este tipo de situaciones que se
aprovechan del funcionamiento de la aplicación. La técnica que se utiliza para ello es la
misma que la implementada en el ataque de escaneo: detectar si se recibe un volumen
importante de tráfico de un mismo tipo, por un puerto concreto. Las acciones llevadas
a cabo pasan por establecer una regla en el switch que automáticamente descarte ese
tipo de tráfico, evitando así su llegada al controlador.
Para instaurar la regla que descarte los paquetes en el switch, se crea una función,
drop_routing_traffic, análoga a la expuesta en el código 4.3 pero con una diferencia,
que en los argumentos que se introducen en dicha función se indica también el id del
protocolo correspondiente.
Ports_enabled: Vector que contiene los números de puertos por los que está
permitido el paso del tráfico de enrutamiento.
deltha_time: Tiempo máximo, en milisegundos, que puede transcurrir entre
llegada de paquetes del mismo tipo de tráfico de enrutamiento, para que no sea
considerado como una tormenta o ataque por denegación de servicio.
max_count: Cuenta máxima a partir de la cual se aplican las medidas de
descarte de tráfico en el switch.
0002855770673994: #Switch-1
PROTOCOLS_MODULE:
Ports_enabled: [15]
deltha_time: 50 #In miliseconds
max_count: 10 #Number of matches
0143080643644224: #Switch-2
PROTOCOLS_MODULE:
Ports_enabled: [4, 13]
deltha_time: 500 #In miliseconds
max_count: 20 #Number of matches
Aunque son muchas las tareas a explotar en este ámbito, los resultados obtenidos
han superado las expectativas iniciales de este proyecto. Las SDN se han consolidado
en los últimos años, aunque no han estado exentas de los problemas de seguridad que
adolecen las redes tradicionales. Sin embargo, las posibilidades que ofrecen este tipo
de aplicaciones, sobre todo en una cuestión tan capital como es la seguridad y que día
a día es más creciente, convierten a esta tecnología de red en un claro candidato a
sustituir las redes actuales.
class SimpleSwitch13(app_manager.RyuApp):
OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]
_CONTEXTS = {'dpset': dpset.DPSet}
def __init__(self, ∗args, ∗∗kwargs):
super(SimpleSwitch13, self) .__init__(∗args, ∗∗kwargs)
self .mac_to_port = {}
self .dpset = kwargs['dpset']
@set_ev_cls(ofp_event.EventOFPPortDescStatsReply, MAIN_DISPATCHER)
def port_desc_stats_reply_handler(self, ev):
ports = []
print(ev.msg.body)
for p in ev.msg.body:
ports.append('port_no= %d hw_addr= %s name= %s config=0x %08x '
' state=0x %08x curr=0x %08x advertised=0x %08x '
'supported=0x %08x peer=0x %08x curr_speed= %d '
'max_speed= %d' %
(p.port_no, p.hw_addr,
p.name, p.config,
p. state , p.curr, p.advertised ,
p.supported, p.peer, p.curr_speed,
p.max_speed))
self . logger .debug('OFPPortDescStatsReply received: %s', ports)
@set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
def switch_features_handler(self, ev):
datapath = ev.msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
match = parser.OFPMatch()
actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER,
ofproto.OFPCML_NO_BUFFER)]
self .add_flow(datapath, 0, match, actions)
inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS,
actions) ]
if buffer_id:
mod = parser.OFPFlowMod(datapath=datapath, buffer_id=buffer_id,
priority =priority, match=match,
instructions =inst)
else :
mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
match=match, instructions=inst)
datapath.send_msg(mod)
def add_custom_flow(self,datapath,port,dest,vlanid):
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
#match = parser.OFPMatch(in_port=port,eth_type=0x0800,vlan_vid=vlanid)
match = parser.OFPMatch(vlan_vid=vlanid)
actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER)]
@set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
#Aqui es donde debemos actuar con la vaina
def _packet_in_handler(self, ev):
# If you hit this you might want to increase
# the "miss_send_length" of your switch
if ev.msg.msg_len < ev.msg.total_len:
self . logger .debug("packet truncated: only %s of %s bytes",
ev.msg.msg_len, ev.msg.total_len)
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = msg.match['in_port']
port_info = self .dpset.get_port(datapath.id, in_port)
hw_addr = port_info[1]
pkt = packet.Packet(msg.data)
eth = pkt.get_protocols(ethernet.ethernet)[0]
if eth.ethertype == ether_types.ETH_TYPE_LLDP:
# ignore lldp packet
return
dst = eth.dst
src = eth.src
dpid = format(datapath.id, "d"). zfill (16)
self .mac_to_port.setdefault(dpid, {})
print(pkt)
self . logger . info ("packet in %s %s %s %s", dpid, src, dst, in_port)
actions = [parser.OFPActionOutput(out_port)]
ARP_COUNTER = {}
vlans_dict = {}
vlans_ports = {}
device_ip = '15.0.0.2 '
gateway_ip = ''
gateway_mac = ''
gateway_port = 0
network_ip = ''
subnet_mask = ''
config_file = {}
ospf_counter = {}
eigrp_counter = {}
class SimpleSwitch13(app_manager.RyuApp):
OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]
_CONTEXTS = {'dpset': dpset.DPSet}
def __init__(self, ∗args, ∗∗kwargs):
def update_yaml_file(self,dpid):
global config_file , network_ip, subnet_mask, gateway_ip, device_ip
a_yaml_file = open("config.yaml")
config_file = yaml.load(a_yaml_file, Loader=yaml.FullLoader)
network_ip = config_file[dpid][ 'PVLAN_MODULE']['Network_IP']
subnet_mask = config_file[dpid]['PVLAN_MODULE']['Subnet_Mask']
gateway_mac = config_file[dpid]['PVLAN_MODULE']['Gateway_MAC']
gateway_ip = config_file[dpid][ 'PVLAN_MODULE']['Gateway_IP']
req = ofp_parser.OFPPortDescStatsRequest(datapath, 0)
datapath.send_msg(req)
@set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
def switch_features_handler(self, ev):
datapath = ev.msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
match = parser.OFPMatch()
actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER,
ofproto.OFPCML_NO_BUFFER)]
inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS,
actions) ]
if buffer_id:
mod = parser.OFPFlowMod(datapath=datapath, buffer_id=buffer_id,
priority =priority, match=match,
instructions =inst)
else :
mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
match=match, instructions=inst)
datapath.send_msg(mod)
def add_custom_flow(self,datapath,dest):
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
match = parser.OFPMatch(eth_dst=dest)
actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER)]
self .add_flow(datapath, 2, match, actions)
@set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
def _packet_in_handler(self, ev):
# If you hit this you might want to increase
# the "miss_send_length" of your switch
global gateway_mac
global gateway_port
global gateway_port_numbers
global ospf_counter, eigrp_counter
if ev.msg.msg_len < ev.msg.total_len:
self . logger .debug("packet truncated: only %s of %s bytes",
ev.msg.msg_len, ev.msg.total_len)
msg = ev.msg
datapath = msg.datapath
dpid = format(datapath.id, "d"). zfill (16)
self .update_yaml_file(dpid)
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = msg.match['in_port']
port_info = self .dpset.get_port(datapath.id, in_port)
hw_addr = port_info[1]
pkt = packet.Packet(msg.data)
eth = pkt.get_protocols(ethernet.ethernet)[0]
dst = eth.dst
src = eth.src
if eth.ethertype == ether_types.ETH_TYPE_LLDP:
# ignore lldp packet
return
if eth.ethertype == ether_types.ETH_TYPE_IP:
ip = pkt.get_protocol(ipv4.ipv4)
srcip = ip.src
dstip = ip.dst
proto = ip.proto
global ARP_COUNTER
current_milli_time = lambda: int(round(time.time() ∗ 1000))
#Detectar ARP
if dst == 'ff: ff : ff : ff : ff : ff ' :
if dpid in ARP_COUNTER:
deltha = current_milli_time() - int(ARP_COUNTER[dpid][src]['timestamp'])
ARP_COUNTER[src]['timestamp'] = current_milli_time()
if deltha < 50: #Hay escaneo
ARP_COUNTER[src]['counter'] += 1
if ARP_COUNTER[src]['counter'] >= 10:
self . logger .debug("ALERTA: Escaneo de servicios detectado en el puerto %s.",in_port)
self .send_port_mod(datapath, in_port, hw_addr, datapath.ofproto.OFPPC_PORT_DOWN,
datapath.ofproto.OFPPF_PAUSE)
self . logger .debug("INFO: El puerto %s ha sido apagado",in_port)
if dpid not in ARP_COUNTER:
ARP_COUNTER[src]= {'counter': 1, 'timestamp':current_milli_time()}
self . logger . info ( 'ARP-COUNTER-VALUE %s', str(ARP_COUNTER[src]['counter']))
out_port = self.mac_to_port[dpid][dst]
else :
out_port = ofproto.OFPP_FLOOD
actions = [parser.OFPActionOutput(out_port)]
# install a flow to avoid packet_in next time
if out_port != ofproto.OFPP_FLOOD:
match = parser.OFPMatch(in_port=in_port, eth_dst=dst, eth_src=src)
if msg.buffer_id != ofproto.OFP_NO_BUFFER:
self .add_flow(datapath, 1, match, actions, msg.buffer_id)
return
else :
self .add_flow(datapath, 1, match, actions)
data = None
if msg.buffer_id == ofproto.OFP_NO_BUFFER:
data = msg.data
out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id,
in_port=in_port, actions=actions, data=data)
datapath.send_msg(out)
inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS,
actions) ]
if buffer_id:
mod = parser.OFPFlowMod(datapath=datapath, buffer_id=buffer_id,
priority =priority, match=match,
instructions =inst)
else :
mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
match=match, instructions=inst)
datapath.send_msg(mod)
def add_flow_pvlan(self,datapath,address,subnet_mask):
parser = datapath.ofproto_parser
ofproto = datapath.ofproto
match = parser.OFPMatch(eth_type=ether_types.ETH_TYPE_IP,
ipv4_dst=(address, subnet_mask), ipv4_src=(address, subnet_mask))
actions = [parser.OFPInstructionActions(ofproto.OFPIT_CLEAR_ACTIONS,[])]
mod = parser.OFPFlowMod(datapath=datapath,
out_port=ofproto.OFPP_ANY,
out_group=ofproto.OFPG_ANY,
match=match, instructions=actions)
datapath.send_msg(mod)
def send_port_mod(self, datapath, port_no, hard_addr, mask, advertise):
ofp = datapath.ofproto
ofp_parser = datapath.ofproto_parser
config = 1
req = ofp_parser.OFPPortMod(datapath, port_no, hard_addr, config,
ofp.OFPPC_PORT_DOWN, advertise)
datapath.send_msg(req)
@set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
def _packet_in_handler(self, ev):
global gateway_mac
global gateway_port
global gateway_port_numbers
global ospf_counter, eigrp_counter
if ev.msg.msg_len < ev.msg.total_len:
self . logger .debug("packet truncated: only %s of %s bytes",
ev.msg.msg_len, ev.msg.total_len)
msg = ev.msg
datapath = msg.datapath
dpid = format(datapath.id, "d"). zfill (16)
self .update_yaml_file(dpid)
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = msg.match['in_port']
port_info = self .dpset.get_port(datapath.id, in_port)
hw_addr = port_info[1]
pkt = packet.Packet(msg.data)
eth = pkt.get_protocols(ethernet.ethernet)[0]
dst = eth.dst
src = eth.src
if eth.ethertype == 335:
self . logger .debug('Paquete LLC. Mac: %s Puerto: %s ',eth.src, in_port)
gateway_mac = eth.src
gateway_port = in_port
if eth.ethertype == ether_types.ETH_TYPE_LLDP:
# ignore lldp packet
return
if eth.ethertype == ether_types.ETH_TYPE_IP:
ip = pkt.get_protocol(ipv4.ipv4)
srcip = ip.src
dstip = ip.dst
proto = ip.proto
if eth.ethertype == ether_types.ETH_TYPE_IP:
ip = pkt.get_protocol(ipv4.ipv4)
if (dst == gateway_mac) and (dstip != gateway_ip):
self . logger .debug('WARNING: Paquete con MAC destino Puerta de enlace fraudulento')
self .add_flow_pvlan(datapath,gateway_ip,subnet_mask)
self . logger .debug('INFO: Nueva regla anadida en el switch satisfactoriamente.')
actions = [parser.OFPActionOutput(out_port)]
if out_port != ofproto.OFPP_FLOOD:
match = parser.OFPMatch(in_port=in_port, eth_dst=dst, eth_src=src)
if msg.buffer_id != ofproto.OFP_NO_BUFFER:
self .add_flow(datapath, 1, match, actions, msg.buffer_id)
return
else :
self .add_flow(datapath, 1, match, actions)
data = None
if msg.buffer_id == ofproto.OFP_NO_BUFFER:
data = msg.data
ARP_COUNTER = {}
vlans_dict = {}
vlans_ports = {}
device_ip = '15.0.0.2 '
config_file = {}
ospf_counter = {}
eigrp_counter = {}
class SimpleSwitch13(app_manager.RyuApp):
OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]
_CONTEXTS = {'dpset': dpset.DPSet}
def __init__(self, ∗args, ∗∗kwargs):
super(SimpleSwitch13, self) .__init__(∗args, ∗∗kwargs)
self .mac_to_port = {}
self .dpset = kwargs['dpset']
def update_yaml_file(self,dpid):
@set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
def switch_features_handler(self, ev):
datapath = ev.msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
match = parser.OFPMatch()
actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER,
ofproto.OFPCML_NO_BUFFER)]
self .add_flow(datapath, 0, match, actions)
self . logger .debug('Features request successfully sent ' )
self .send_port_desc_stats_request(datapath)
def add_flow(self, datapath, priority , match, actions, buffer_id=None):
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS,
actions) ]
if buffer_id:
mod = parser.OFPFlowMod(datapath=datapath, buffer_id=buffer_id,
priority =priority, match=match,
instructions =inst)
else :
mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
match=match, instructions=inst)
datapath.send_msg(mod)
def add_flow_routing_protocols(self,datapath,dest):
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
# IP Protos
# OSPF: 0x59
# EIGRP: 0x58
ip_protocols = (0x0059,0x0058)
match1 = parser.OFPMatch(in_port=port,eth_type=ip_protocols)
match2 = parser.OFPMatch(eth_type=ip_protocols)
actions1 = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER)]
actions2 = [parser.OFPInstructionActions(ofproto.OFPIT_CLEAR_ACTIONS,[])]
self .add_flow(datapath, 2, match1, actions1)
self .add_flow(datapath, 1, match2, actions2)
def drop_routing_traffic( self ,datapath,proto,port):
parser = datapath.ofproto_parser
ofproto = datapath.ofproto
match = parser.OFPMatch(eth_type=ether_types.ETH_TYPE_IP,ip_proto=proto,
in_port=port)
actions = [parser.OFPInstructionActions(ofproto.OFPIT_CLEAR_ACTIONS,[])]
mod = parser.OFPFlowMod(datapath=datapath,
out_port=ofproto.OFPP_ANY,
out_group=ofproto.OFPG_ANY,
match=match, instructions=actions)
#self.add_flow(datapath, 2, match, actions)
datapath.send_msg(mod)
@set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
#Aqui es donde debemos actuar con la vaina
def _packet_in_handler(self, ev):
# If you hit this you might want to increase
# the "miss_send_length" of your switch
global gateway_mac
global gateway_port
global gateway_port_numbers
global ospf_counter, eigrp_counter
if ev.msg.msg_len < ev.msg.total_len:
self . logger .debug("packet truncated: only %s of %s bytes",
ev.msg.msg_len, ev.msg.total_len)
msg = ev.msg
datapath = msg.datapath
dpid = format(datapath.id, "d"). zfill (16)
self .update_yaml_file(dpid)
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = msg.match['in_port']
port_info = self .dpset.get_port(datapath.id, in_port)
hw_addr = port_info[1]
pkt = packet.Packet(msg.data)
eth = pkt.get_protocols(ethernet.ethernet)[0]
dst = eth.dst
src = eth.src
if eth.ethertype == ether_types.ETH_TYPE_LLDP:
# ignore lldp packet
return
if eth.ethertype == ether_types.ETH_TYPE_IP:
ip = pkt.get_protocol(ipv4.ipv4)
srcip = ip.src
dstip = ip.dst
proto = ip.proto
self .mac_to_port.setdefault(dpid, {})
self . logger . info ("packet in %s %s %s %s", dpid, src, dst, in_port)
if eth.ethertype == ether_types.ETH_TYPE_IP:
ip = pkt.get_protocol(ipv4.ipv4)
if (dst == gateway_mac) and (dstip != gateway_ip):
self . logger .debug('WARNING: Paquete con MAC destino Puerta de enlace fraudulento')
#Aqui debiera ir el envio de regla para dump en la tabla de matching
self .add_flow_pvlan(datapath,gateway_ip,subnet_mask)
self . logger .debug('INFO: Nueva regla anadida en el switch satisfactoriamente.')
#return
if proto == 88:
self . logger .debug(" ------------------------------- ")
self . logger .debug("EIGRP PACKET RECEIVED. PORT %s",in_port)
self . logger .debug(" ------------------------------- ")
if in_port not in config_file [dpid ][ 'PROTOCOLS_MODULE']['Ports_enabled']:
if in_port not in eigrp_counter:
eigrp_counter[in_port]={'counter':1,'timestamp':current_milli_time()}
else :
deltha = int(current_milli_time()) - int (eigrp_counter[in_port]['timestamp'])
eigrp_counter[in_port]['timestamp'] = current_milli_time()
#GLOBAL VARIABLES
port_vlan = {2855770673994:{10:[20],4:[20]},143080643644224:{2:[30],10:[20]}}
access= {2855770673994:[],143080643644224:[2]}
trunk = {2855770673994:[4,10],143080643644224:[10]}
security_enabled = True
class VlanSwitch13(app_manager.RyuApp):
OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]
def __init__(self, ∗args, ∗∗kwargs):
super(VlanSwitch13, self) .__init__(∗args, ∗∗kwargs)
self .mac_to_port = {}
@set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
def switch_features_handler(self, ev):
datapath = ev.msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
match = parser.OFPMatch()
actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER,
ofproto.OFPCML_NO_BUFFER)]
self .add_flow(datapath, 0, match, actions)
def add_flow(self, datapath, priority , match, actions, buffer_id=None):
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS,
actions) ]
if buffer_id:
mod = parser.OFPFlowMod(datapath=datapath, buffer_id=buffer_id,
priority =priority, match=match,
instructions =inst)
else :
mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
match=match, instructions=inst)
datapath.send_msg(mod)
def vlan_members(self,dpid,in_port,src_vlan):
B=[]
self .access_ports = []
self .trunk_ports = []
if src_vlan == "NULL":
return
#Mira que puertos tienen esa VLAN exceptuando el que lo recibio
for item in port_vlan[dpid]:
vlans=port_vlan[dpid][item]
if src_vlan in vlans and item!=in_port:
B.append(item)
#De esos puertos, mira los que son de acceso y los que son troncales
for port in B:
if port in access [dpid ]:
self .access_ports.append(port)
else :
self .trunk_ports.append(port)
# ---------------------------------------------------------------#
def getActionsArrayTrunk(self,out_port_access,out_port_trunk,parser):
actions= [ ]
for port in out_port_trunk:
actions .append(parser.OFPActionOutput(port))
actions .append(parser.OFPActionPopVlan())
for port in out_port_access:
actions .append(parser.OFPActionOutput(port))
return actions
def getActionsArrayTrunkNoNativa(self,out_port_access,out_port_trunk,parser,native_vlan):
actions= [ ]
#Si no esta etiquetada la nativa, tenemos que forzar el asunto
actions .append(parser.OFPActionPushVlan(33024))
actions .append(parser.OFPActionSetField(vlan_vid=native_vlan))
for port in out_port_trunk:
actions .append(parser.OFPActionOutput(port))
for port in out_port_access:
actions .append(parser.OFPActionOutput(port))
return actions
def getActionsArrayAccess(self,out_port_access,out_port_trunk,src_vlan, parser):
actions= [ ]
for port in out_port_access:
actions .append(parser.OFPActionOutput(port))
actions .append(parser.OFPActionPushVlan(33024))
actions .append(parser.OFPActionSetField(vlan_vid=src_vlan))
for port in out_port_trunk:
actions .append(parser.OFPActionOutput(port))
return actions
def getActionsNormalUntagged(self,dpid,in_port,parser):
actions= [ ]
for port in port_vlan[dpid]:
if port_vlan[dpid][port][0]==" " and port!=in_port:
actions .append(parser.OFPActionOutput(port))
if dpid in trunk:
for port in trunk[dpid ]:
if port != in_port:
actions .append(parser.OFPActionOutput(port))
return actions
def check_out_port_trunk(self,dpid,out_port_trunk,src_vlan):
checker = [False, "" ]
for port in out_port_trunk:
if src_vlan in port_vlan[dpid][port ]:
checker = [True,port_vlan[dpid][port]]
return checker
checker[1]=port_vlan[dpid][port]
return checker
# ---------------------------------------------------------------#
@set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
def _packet_in_handler(self, ev):
# If you hit this you might want to increase
# the "miss_send_length" of your switch
out_port_unknown = 0
out_port = self.mac_to_port[dpid][dst]
if src_vlan!= "NULL":
if out_port in access[dpid ]:
out_port_type = "ACCESS"
else :
out_port_type = "TRUNK"
else :
out_port_type = "NORMAL"
else :
out_port_unknown = 1
out_port_access = self.access_ports
out_port_trunk = self.trunk_ports
self . logger .debug("DEST: %s. OUT PORT TYPE: %s \n",dst,out_port_type)
if out_port_unknown!=1:
if vlan_header_present and out_port_type == "ACCESS":
match = parser.OFPMatch(in_port=in_port, eth_dst=dst, vlan_vid=(0x1000 | src_vlan))
actions = [parser.OFPActionPopVlan(), parser.OFPActionOutput(out_port)]
elif vlan_header_present and out_port_type == "TRUNK":
match = parser.OFPMatch(in_port=in_port, eth_dst=dst, vlan_vid=(0x1000 | src_vlan))
actions = [parser.OFPActionOutput(out_port)]
elif vlan_header_present!=1 and out_port_type == "TRUNK":
self . logger .debug("OUT PORT IS TRUNK AND PACKET HAS NO HEADER")
match = parser.OFPMatch(in_port=in_port, eth_dst=dst)
actions = [parser.OFPActionPushVlan(33024), parser.OFPActionSetField(vlan_vid=src_vlan),
parser.OFPActionOutput(out_port)]
else :
match = parser.OFPMatch(in_port=in_port, eth_dst=dst)
actions = [parser.OFPActionOutput(out_port)]
if msg.buffer_id != ofproto.OFP_NO_BUFFER:
self .add_flow(datapath, 1, match, actions, msg.buffer_id)
return
else :
self .add_flow(datapath, 1, match, actions)
else :
if vlan_header_present:
#Aqui tengo que ver si la VLAN de la primera etiqueta coincide con la de la nativa
if security_enabled:
if out_port_trunk != ['']:
passer=self .check_out_port_trunk(dpid,out_port_trunk,src_vlan)
if passer [0]:
#self. logger .debug("LA VLAN NATIVA ESTA PRESENTE EN LA PRIMERA ETIQUETA:
%s",src_vlan)
actions = self .getActionsArrayTrunk(out_port_access,out_port_trunk,parser)
match = parser.OFPMatch(in_port=in_port, eth_dst=dst, vlan_vid=(0x1000 | src_vlan))
#self.add_flow(datapath, 1, match, actions)
else :
#self. logger .debug("LA VLAN NATIVA NO ESTA PRESENTE EN LA PRIMERA
ETIQUETA: %s",src_vlan)
match = parser.OFPMatch(in_port=in_port, eth_dst=dst, vlan_vid=(0x1000 | src_vlan))
actions =
self .getActionsArrayTrunkNoNativa(out_port_access,out_port_trunk,parser,passer[1])
#self.add_flow(datapath, 1, match, actions)
if out_port_access != ['' ]:
actions = self .getActionsArrayTrunk(out_port_access,out_port_trunk,parser)
else :
actions = self .getActionsArrayTrunk(out_port_access,out_port_trunk,parser)
match = parser.OFPMatch(in_port=in_port, eth_dst=dst, vlan_vid=(0x1000 | src_vlan))
elif vlan_header_present==0 and src_vlan!= "NULL": #IF UNTAGGED BUT
GENERATED FROM VLAN ASSOCIATED PORT
actions = self .getActionsArrayAccess(out_port_access,out_port_trunk,src_vlan, parser)
elif in_port_type == "NORMAL UNTAGGED":
actions = self .getActionsNormalUntagged(dpid,in_port,parser)
else :
actions = [parser.OFPActionOutput(ofproto.OFPP_FLOOD)]
data = None
if msg.buffer_id == ofproto.OFP_NO_BUFFER:
data = msg.data
out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id,
in_port=in_port, actions=actions, data=data)
datapath.send_msg(out)
Una vez se establecen las conexiones entre los switches de la red, el controlador
les manda la orden de que reenvíen por todos sus puertos los paquetes LLDP. A
continuación, un paquete LLDP es enviado al switch más cercano (S1) que le llega
por el puerto número 3. S1 reenvía este paquete a todos los switches conectados a el,
que en este escenario de ejemplo serán S2 y S3. El paquete reenviado por S1 en el
puerto 1 llegará a S3 en el puerto 1, y el paquete reenviado por S1 en el puerto 2 llega
a S2 por el puerto 2. Una vez lleguen los paquetes a S2 y S3, estos reenvían los paquetes
LLDP por todos sus puertos, llegando a S4 en este caso tanto por el puerto 1 como
por el puerto 2.
A parte de reenviar los paquetes LLDP por cada puerto, cada switch envía una
respuesta al controlador. Como en cada respuesta van acumulándose los saltos que
realiza cada paquete, una vez lleguen al controlador, este sabe que S3 está conectado
a S1 a través de su puerto número 1 y que S2 está conectado a S1 a través de su
puerto número 2. De manera análoga se realiza con S4 y con cuantos niveles de switches
conectados se quiera. De esta forma el controlador es capaz de recrear toda la topología
de la red.
3 2 2 3
S1 S2
H1 1 1 H2
1 3
3 2 2 1
S3 S4
H3 H4
Figura 5.1.- Escenario de una red ejemplo conformada por 4 switches, 3 ordenadores y
un controlador.
#GLOBAL VARIABLES
port_vlan = {2:{3:[" " ],1:[30],2:[20],4:[20,30]},3:{4:[20,30],1:[30],2:[20],3:[ " "]}}
access= {2:[1,2],3:[1,2]}
trunk = {2:[4],3:[4]}
class VlanSwitch13(app_manager.RyuApp):
OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]
def __init__(self, ∗args, ∗∗kwargs):
super(VlanSwitch13, self) .__init__(∗args, ∗∗kwargs)
self .mac_to_port = {}
@set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
def switch_features_handler(self, ev):
datapath = ev.msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
match = parser.OFPMatch()
actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER,
ofproto.OFPCML_NO_BUFFER)]
self .add_flow(datapath, 0, match, actions)
def add_flow(self, datapath, priority , match, actions, buffer_id=None):
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS,
actions) ]
if buffer_id:
actions .append(parser.OFPActionOutput(port))
return actions
def getActionsNormalUntagged(self,dpid,in_port,parser):
actions= [ ]
for port in port_vlan[dpid]:
if port_vlan[dpid][port][0]==" " and port!=in_port:
actions .append(parser.OFPActionOutput(port))
if dpid in trunk:
for port in trunk[dpid ]:
if port!=in_port:
actions .append(parser.OFPActionOutput(port))
return actions
@set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
def _packet_in_handler(self, ev):
# If you hit this you might want to increase
# the "miss_send_length" of your switch
if ev.msg.msg_len < ev.msg.total_len:
self . logger .debug("packet truncated: only %s of %s bytes",
ev.msg.msg_len, ev.msg.total_len)
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = msg.match['in_port']
#SWITCH ID
dpid = datapath.id
pkt = packet.Packet(msg.data)
eth = pkt.get_protocols(ethernet.ethernet)[0]
vlan_header = pkt.get_protocols(vlan.vlan) #If packet is tagged,then this will have non-null
value
if eth.ethertype == ether_types.ETH_TYPE_8021Q : #Checking for VLAN Tagged Packet
vlan_header_present = 1
src_vlan=vlan_header[0].vid
elif dpid not in port_vlan:
vlan_header_present = 0
in_port_type = "NORMAL SWITCH "
src_vlan = "NULL"
elif port_vlan[dpid][in_port][0]== " " or in_port in trunk[dpid ]:
vlan_header_present = 0
in_port_type = "NORMAL UNTAGGED"
src_vlan = "NULL"
else :
vlan_header_present = 0
src_vlan=port_vlan[dpid][in_port][0]
if eth.ethertype == ether_types.ETH_TYPE_LLDP:
# ignore lldp packet
return
dst = eth.dst
src = eth.src
#CREATE NEW DICTIONARY ENTRY IF IT DOES NOT EXIST
self .mac_to_port.setdefault(dpid, {})
self . logger . info ("packet in %s %s %s %s", dpid, src, dst, in_port)
# learn a mac address to avoid FLOOD next time.
self .mac_to_port[dpid][src] = in_port
#Determine which ports are members of in_port's VLAN
self .vlan_members(dpid,in_port,src_vlan)
out_port_type = " "
if dst in self .mac_to_port[dpid]:
out_port_unknown = 0
out_port = self.mac_to_port[dpid][dst]
if src_vlan!= "NULL":
if out_port in access[dpid ]:
out_port_type = "ACCESS"
else :
out_port_type = "TRUNK"
else :
out_port_type = "NORMAL"
else :
out_port_unknown = 1
out_port_access = self.access_ports
out_port_trunk = self.trunk_ports
if out_port_unknown!=1:
if vlan_header_present and out_port_type == "ACCESS" :
match = parser.OFPMatch(in_port=in_port, eth_dst=dst, vlan_vid=(0x1000 | src_vlan))
actions = [parser.OFPActionPopVlan(), parser.OFPActionOutput(out_port)]
elif vlan_header_present and out_port_type == "TRUNK" :
Bibliografía
[1] Diego Kreutz, Fernando MV Ramos, P Esteves Verissimo, C Esteve
Rothenberg, Siamak Azodolmolky, and Steve Uhlig. Software-defined networking:
A comprehensive survey
https://ieeexplore.ieee.org/document/6994333/
[3] Rachid Nait Takourout, Samuel Pierre, Laurent Marchand, Separation of the
Control Plane and Forwarding Plane in Next-Generation Routers
http://www.larim.polymtl.ca/pdf/52.pdf
[4] Jianying Luo, Justin Pettit, Martin Casado, John Lockwood, Nick McKeown,
Prototyping Fast, Simple, Secure Switches for Ethane
http://yuba.stanford.edu/~nickm/papers/ethane-hoti07.pdf
[5] Andreas Wundsam, Dan Levin, Srini Seetharaman, Anja Feldmann, OFRewind:
Enabling Record and Replay Troubleshooting for Networks
[6] SFlow
https://sflow-rt.com/index.php
[13] Vivek Tiwari, (2013), SDN and OpenFlow for begginers (e-Book)
[14] Kevin Benton, L. Jean Camp, Chris Small, (2013), OpenFlow Vulnerability
Assesment http://www.ljean.com/files/vulnerability_analysis.pdf
[16] Daniel Romão, Niels van Dijkhuizen, Stavros Konstantaras, George Thessalonikefs,
Practical Security Analysis of OpenFlow
https://www.os3.nl/_media/2013-2014/courses/ssn/projects/practical_
security_analysis_of_openflow_report.pdf(24 Diciembre 2013)
[21] Tiantian Ren, Yanwei Xu, Analysis of the new features of the OpenFlow 1.4
http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.827.7016&
rep=rep1&type=pdf (2014)
[22] Rowan Klöti, Vasileios Kotronis, Paul Smith, OpenFlow: A Security Analysis
https://www.tik.ee.ethz.ch/file/9ee69e89be779fd1448a7356d79ddb18/
openflow_sec.pdf (2013)
[23] Ching-Hao, Chang and Dr. Ying-Dar Lin, OpenFlow Version Roadmap
http://speed.cis.nctu.edu.tw/~ydlin/miscpub/indep_frank.pdf
(Septiembre 2015)
[25] Jeremy M. Dover, A denial of service attack against the Open Floodlight SDN
controller
http://dovernetworks.com/wp-content/uploads/2013/12/OpenFloodlight-
12302013.pdf
http://ecee.colorado.edu/~ekeller/classes/spring2014_advnet/papers/
ofrewind_usenixatc_2011_wendsam.pdf
[27] Seungwon Shin, Vinod Yegneswaran, Phillip Porras, Guofei Gu, AVANT-GUARD:
Scalable and Vigilant Switch Flow Management in Software-Defined Networks
(2013)
[31] Putty.org
https://www.putty.org/
[33] Nmap.org
https://nmap.org/
[36] NAKIVO, Hyper-V or VirtualBox. Which one to choose for your infrastructure?
https://www.nakivo.com/blog/hyper-v-virtualbox-one-choose-
infrastructure/