https://t.
me/librosdehacking
SECCIÓN 2
Este Libro En 30 Segundos
“En un mundo en el que la totalidad del cono
cimiento humano se duplica aproximadament
e cada diez años, nuestra seguridad solament
e puede descansar en nuestra capacidad de a
prender.”
-Nathaniel Branden
Scapy es una de las herramientas de manipulación de paquetes más
importantes. Además cuenta con la añadida cualidad de poder usarse como
librería en nuestro propio software, permitiéndonos diseñar programas
basándonos en él.
Este libro contiene un contenido teórico acotado, pero suficiente, para que el
alumno puede entender todos los conceptos explicados: desde la base hasta
los conceptos más avanzados.
Aprenderá a desenvolverse con soltura en la línea de comandos y el CLI de
Scapy. A paralelización de tareas y los entresijos de los hilos de Python:
limitaciones, características, cuando usarlos y cuándo no es conveniente.
Practicará con autómatas de estados finitos: diseñándolos e
implementándolos usando Scapy y su Automaton. Todo ello sin necesidad
de aprender las compleja teoría matemática que lo envuelve.
CAPÍTULO 1
Introducción A Scapy
“Scapy es una potente herramienta para la
manipulación interactiva de paquetes. Es capaz de forjar y
descodificar una amplia serie de protocolos, capturarlos,
reenviarlos, emparejar envíos y respuestas, y mucho más.
Puede realizar fácilmente tareas clásicas como:
exploración, tracerouting, sondeo de puertos, ataques o
descubrimiento de redes.”
Fuente: Proyecto Scapy
http://www.secdev.org/projects/scapy/
SECCIÓN 1
Qué Aprenderás En Este Capítulo
“Todas las piezas deben unirse sin ser forzad
as. Debe recordar que los componentes que e
stá reensamblando fueron desmontados por u
sted, por lo que si no puede unirlos debe exist
ir una razón. Pero sobre todo, no use un mart
illo”
-Manual de mantenimiento de IBM, año 1925
En este capítulo aprenderá a lo fundamentos de Scapy, sus modos de
funcionamiento y porqué es una de las mejores herramientas para el análisis
de redes.
Aprenderemos las funciones de Scapy que nos proporcionarán ayuda de
otras funciones, tipos de datos y modos de funcionamiento.
Aprenderemos cómo se analizan y de depuran las tramas de red. A
generarlas y configurarlas de manera básica, creando desde el primer
momento tráfico de red real.
SECCIÓN 2
¿Qué Es Scapy?
Descripción breve
Scapy es un software especializado en la manipulación de paquetes y tramas
de red.
Scapy está está escrito en el lenguaje de programación Python y puede ser
usado de modo interactivo, con su CLI (Command Line Interpreter), o
como librería en nuestros programas escritos en Python.
Por qué usar Scapy
Scapy nos proporciona una potencia y control extraordinario sobre los
sistemas de comunicaciones. Nos permite manejar, a tan bajo nivel como
queramos, la información de los protocolos que se va a enviar a la red.
Por si fuera poco, Scapy es muy fácil de usar, rápido de instalar y no
necesitas saber Python para usarlo.
Para qué se usa Scapy
Scapy es una navaja Suiza de la manipulación de redes. Por este motivo
puede ser usada para muchos cometidos y ámbitos:
Investigación en redes de comunicaciones.
Como base para crear el software necesario para poder trabajar con
protocolos desconocidos o poco extendidos. Esto puede resultar muy útil
para entornos industriales donde no existe una estandarización clara.
Pruebas de calidad y de comportamiento de circuitería de red. Útil para
fabricantes y organizaciones que quieren mantener un nivel de calidad
óptimo en sus sistemas de comunicaciones.
Pruebas de seguridad y hacking ético con las que manipular el tráfico
generado, a fin de conseguir combinaciones inesperadas que provoquen
funcionamientos anómalos en los sistemas y que pueden ser explotados por
usuarios maliciosos o atacantes.
Qué tiene Scapy diferente de otras
tools
Ya existen muchas librerías para la manipulación de paquetes de red.
Entonces, ¿Por qué usar Scapy? He aquí algunas razones:
Permite manipular el tráfico de red a muy bajo nivel.
Permite utilizar pilas de protocolos y combinarlos como deseemos. Otras
librerías no lo permiten.
Permite configurar todos los parámetros de cada protocolo.
Es muy sencillo de usar.
Una vez conocidas las pautas básicas, es muy intuitivo.
En qué está hecho Scapy y por
qué importa eso?
Scapy está escrito en el lenguaje de programación Python. El versión oficial
está diseñada e implementada en Python 2.7 (o superior), aunque también
existe una versión extraoficial que funciona para el nuevo Python 3.X.
Python es un leguaje muy sencillo de aprender y usar. Casi pseudo-código.
Esto da la oportunidad a que cualquier persona con unos conocimientos
muy básicos a programar en Python.
Scapy puede ser usado como una librería más de Python. Esto es muy
interesante porque podemos hacer nuestros propios programas usando
Scapy como base para la manipulación del tráfico de red, pero teniendo
todas las ventajas y resto de librerías existentes en Python.
Funcionamiento de Scapy y el
bajo nivel
El funcionamiento y concepción de Scapy es su propia piedra angular: Da
una increíble potencia y flexibilidad, a cambio de que han de tenerse buenos
conocimientos de los protocolos de red que se desean testar.
Para enviar tráfico a la red, tendremos que indicarle a Scapy qué es
exactamente lo que queremos enviar: Capa a capa del protocolo elegido, en
la mayoría de los casos TCP/IP.
Esto no ha de asustar el lector. Una vez haya hecho unas pocas pruebas, verá
que es muy sencillo familiarizarse con un protocolo. Le sorprenderá lo
rápido que se pueden aprender y profundizar en ellos gracias a Scapy.
Instalación de Scapy
La instalación es muy sencilla, si utilizamos una distribución de Linux
estándar o Mac. Scapy es un paquete de Python únicamente, aunque tiene
varias dependencias.
La instalación básica, aunque suficiente para ejecutar Scapy, no incluye
soporte de módulos adicionales (como soporte para TCPDump o
GNUPlot) y es recomendable instalarlos para disponer de todas las
características de Scapy.
Las instrucciones de instalación están perfectamente detalladas en la guía
oficial de instalación:
http://www.secdev.org/projects/scapy/portability.html
SECCIÓN 3
El Modo Interactivo
Modos de funcionamiento de Scapy
Scapy cuenta con 2 posibles modos de funcionamiento:
El interactivo.
El programático.
El modo interactivo consiste en un intérprete de comandos con la funcionalidad de Scapy inline. Su aspecto es muy
parecido a una Shell de Unix o la consola de Python:
El modo programático hace alusión a
cuando usamos Scapy como librería en nuestro propio programa. No ejecutaremos Scapy directamente, sino que
será nuestro código quien se encargue de cargarlo y utilizarlo conforme le hayamos indicado.
La llamada a éste será igual que cuando ejecutamos cualquier otro programa en Python:
Permisos y usuarios
Es importante destacar que cuando trabajamos con la red a bajo nivel hay ciertas tareas que solo están permitidas o
reservadas al administrador del sistema.
Esto es así para evitar un uso fraudulento de la red, como podría ser el limitar que cualquier usuario pueda leer toda
la comunicación que circula por la tarjeta de red. De no se así, supondría un grave fallo de seguridad para todos los
usuarios del sistema.
Por este motivo Scapy necesita privilegios de administrador para ejecutarse con todas sus funcionalidades. Este es
un detalle importante que muchas personas olvidan y no consiguen hacer funcionar Scapy a pleno rendimiento.
Para ejecutar Scapy en modo administrador bastará hacerlo con el domando del sistema sudo antes de ejecutar
Scapy.
Qué es un intérprete
Cuando trabajamos con Scapy en modo interactivo, lo que realmente estamos haciendo es interactuar con un
intérprete de comandos o CLI.
En este modo de funcionamiento tendremos pre-cargadas la mayor parte de las funciones y librerías de las que
consta Scapy. Además, el modo interactivo, cuenta con autocompletado (usando la tecla tabulador <TAB>)
Este modo es muy útil, y tremendamente rápido, para pruebas muy cambiantes que no tiene un patrón fijo o en las
que una prueba depende del resultado de la anterior. Nos permite hacer test al vuelo y analizar lo resultados desde
el propio terminal.
Si tienes conocimientos de Python, probablemente te resulte familiar. El CLI de Scapy es el mismo que el Python,
pero “vitaminado”.
Elementos básicos del intérprete
Tras ejecutar Scapy en modo interactivo y que se lance el intérprete, nos encontramos encontraremos con el
siguiente terminal:
Si el lector se encuentra con los warnings que aparecen en la captura, es que necesita instalar librerías adicionales
que Scapy requiere. No son imprescindibles para la mayor parte de las tareas, pero sin ellas no podrá ejecutar
ciertas acciones.
No se preocupe por el mensaje de IPv6. Éste se debe a una configuración errónea de IPv6 en sus tarjetas de red.
Nos es necesario preocuparse por él, salvo que queramos trabajar con IPv6.
En el intérprete también podemos observar la versión en ejecución de Scapy. Asegúrese que es la 2.3 o superior.
Observamos el comienzo del cursor y punto de inicio de comandos donde escribiremos nuestras órdenes para el
intérprete:
Auto-completado
Al igual que ocurre la línea de comandos tradicional de Linux, Python y Scapy también disponen de
autocompletado en sus terminales. El funcionamiento es muy parecido.
Tras escribir algún carácter, si pulsamos 2 veces seguidas el tabulador nos aparecerán las funciones o estructuras
disponibles que comiencen por esos caracteres. Si escribimos una carácter más, se recibirá el número de elementos
a autocompletar hasta que solo quede uno, que se acabará de escribir por nosotros:
VÍDEO 1.1 - Listado de funciones disponibles.
El autocompletado nos será de gran ayuda para ahorrar tiempo y no tener que recordar exactamente el nombre d
e todas las funciones.
Como curiosidad, si pulsa 2 veces el tabulador, sin haber escrito previamente ningún carácter, Scapy nos mostrará
todos los elementos disponibles:
VÍDEO 1.2 - Autocompletado en consola.
Variables y elementos de flujo del intérprete
Como ya se ha comentado varias veces, el intérprete de Scapy es realmente un wrapper o caparazón sobre el CLI
de Python. Eso significa que tenemos toda la potencia de heredada de Python en el intérprete de Scapy.
La definición de variables, elementos de control de flujo, condicionales, listas, cadenas de texto o cualquier otra
característica estará a nuestro alcance.
SECCIÓN 4
Funciones De Ayuda
Qué es una función de ayuda
Existen funciones en Scapy que nos darán información útil sobre sus
propias librerías, otras funciones o cualquier otra información que
necesitemos.
Estas funciones se pueden ejecutar en el modo interactivo, y nos
proporcionan la información por consola.
Qué funciones de ayuda hay?
Existen varias funciones de ayuda en Scapy. Unas nos ayudarán a darnos
información genérica del entorno y otras de determinadas partes de Scapy.
Estas funciones son las siguientes:
ls()
lsc()
help()
Doble tabulación
Cómo listar todas las funciones
Scapy tiene multitud de funciones, parámetros y clases. Es realmente
complicado recordar toda esta información.
Por ese motivo, Scapy nos proporciona una función para listar todas las
funciones disponibles. Este es el resultado que obtendremos si usamos la
función lsc():
Scapy dispone de multitud de tipos de datos (de los que se hablará más
adelante). Si queremos visualizar todos los tipos de datos, no solamente las
funciones, bastará con que pulsemos 2 veces la tecla de tabulación:
Información de una función o
dato
Cada función o tipo de dato en Scapy tienen diferente número de
parámetros para ser llamados.
Es muy complicado recordarlos todos, más aún si añadimos la complicación
de que muchos parámetros han de pasarse en un determinado orden. Para
suplir este problema, podemos usar la función help() de Scapy.
Que nos proporcionará la siguiente información sobre la función send():
Recordar que para salir de la ayuda, tendremos que pulsar la tecla “q”, al
igual que en el editor VI.
Si lo que queremos es mostrar información de un tipo de dato, aunque
podemos usar la función help(), ésta no nos aportará información útil para el
modo interactivo, por lo que se recomienda usar la función ls(…) en su
lugar.
SECCIÓN 5
Construcción De Paquete Básico
Qué es un paquete en Scapy
Un paquete en Scapy es un conjunto de datos estructurados y preparados
para ser enviados a la red.
Los paquetes deben de seguir una estructura lógica, conforme al tipo de
comunicación que se quiera simular. Es decir:
Si se quiere enviar un paquete TCP/IP han de seguirse la reglas del
protocolo definidas en el estándar en estándar TCP/IP.
Wireshark como debugger
Todos los programadores hacen uso de un debugger para tener un mayor
control sobre los errores y ahorrar tiempo de depuración en su software.
En términos de redes en lugar de un depurador, usamos un analizador que
nos permita visualizar y diseccionar los paquetes. De esta forma podremos
ver qué es lo que realmente estamos enviando a la red.
Se recomienda usar Wireshark como analizador, ya que es gratuito,
multiplataforma y tremendamente completo.
Se puede descargar de su web oficial. La instalación es guiada y muy
sencilla: https://www.wireshark.org/download.html
Nuestro primer paquete
Construir un paquete básico en Scapy es tan básico como hacer lo siguiente:
¿Qué hemos hecho? Muy fácil:
Le hemos indicado a Scapy que queremos construir un paquete, que
almacenaremos en la variable pkg. Y que contendrá 2 capas o layers: IP e
ICMP.
El orden con el que se construirán las capas en el paquete será el mismo en
el que nosotros le indiquemos. Es decir, en nuestro ejemplo:
Capa 1: IP.
Capa 2: ICMP.
No te preocupes sino lo acaba de entender. Explicaremos en detalle estos
conceptos más adelante.
Configurando el paquete
Cuando construimos un paquete tendremos que indicar cierta información
básica, sino será configurado con sus parámetros por defecto.
Por defecto, la capa IP(), se configura como IP de destino la 127.0.0.1, que
hace referencia a la máquina local donde se está ejecutando Scapy.
Si queremos que el paquete se envíe a la IP 10.0.1.1, tendremos que
configurar la capa IP de la siguiente manera:
Todos los tipos de datos siguen el mismo formato de configuración.
Enviando un paquete
Para enviar un paquete en Scapy tenemos varias funciones. La más básica es
la función send().
Esta función necesita, como mínimo, el paquete que se quiere enviar a la red
como parámetro. Podemos crear un paquete, guardarlo en 1 variable y
pasarle dicha variable como parámetro:
O bien pasarle como parámetro el contenido del paquete directamente:
Haciendo un Ping
Un ping tan solo es una solicitud a un sistema para comprobar que este está
activo en la red o “vivo”.
En términos de protocolos de red es un paquete ICMP del tipo 8 (Echo
Request) encapsulado en un paquete IP con el destino al que se quiera hacer
el ping.
Usando Wireshak y Scapy vemos como la petición progresa correctamente y
el destino contesta con un ICMP Reply, indicando que lo ha recibido y que
está activo:.
CAPÍTULO 2
Uso Avanzado De Scapy
“Scapy le permite construir exactamente los paquetes
que desea. Aunque crea que apilar una capa 802.1q sobre
una TCP no tiene ningún sentido, puede para ciertas
personas lo tenga. Personas que están construyendo algún
producto o realizando pruebas de seguridad y quieran
evitar los límites impuestos por las herramientas de redes
tradicionales.”
Fuente: Proyecto Scapy
SECCIÓN 1
Qué Aprenderás En Este Capítulo
“Una vez un ordenador me venció jugando al
ajedrez, pero no me opuso resistencia cuand
o pasamos al kick boxing”
-Emo Philips
En este capítulo aprenderá qué es un layer en Scapy: tipos y los más usados.
Veremos los conceptos básicos para poder crear nuestros propios layers, así
como el porqué y cuándo hacerlo.
Se explicarán conceptos básicos (y no tan básicos) de redes de
comunicaciones, pilas de protocolos, modelos y estándares. Todo ello sin
entrar en teoría y centrándose en los aspectos importantes y que nos serán
de utilidad para comprender el resto de libro.
Seremos capaces de analizar, interceptar y diseccionar paquetes de red, así
como reusar su contenido. Crearemos y manipularemos ficheros PCAP con
la información capturada o producidad por nosotros.
Lograremos generar grandes flujos de información para realizar ataques de
flooding, analizando las diferentes formas de lograr estos ataques y
minimizar los recursos necesarios para ello.
Aprenderemos a exportar la información de red en varios formatos, como
hexadecimal o base64, así como generar ficheros PDF o gráficas para
analizar resultados o comportamientos.
SECCIÓN 2
Qué Es Un Layer
Definición
En Scapy un layer (o capa) representa, por lo general, un protocolo. Los protocolos de red se estructuran en pilas,
donde cada peldaño consiste en un layer o protocolo.
Un paquete de red está compuesta por múltiples layers, donde cada capa se encarga de una parte de la
comunicación:
VÍDEO 2.1 - Modelo de layers y protocolos
La pila de protocolos de red más conocida es la TCP/IP. En ella se asientan gran parte de las comunicaciones a día
de hoy consta de 4 capas:
Acceso a la red.
Internet.
Transporte.
Aplicación.
El orden es importante
Cada protocolo de comunicaciones se sustenta en una pila de protocolos, que usa como base.
Esta pila de protocolos permiten aislar las capas entre si, aislándolas de lo que por lo que ocurre en la capa superior
e inferior. Tan solo han de preocuparse de lo que ellas hacen.
Para entenderlo mejor, imagine el proceso cuando escribe un e-mail a un amigo.
Usted se encarga de redactar el texto y de decir a quien quiere enviarlo. Aquí acaba su cometido.
Después, su proveedor de correo electrónico se encarga de prepararlo y enviarlo a internet, despreocupándose de
cómo el correo llega al destinatario.
El correo es recibido por el proveedor de internet, que se encarga de hacérselo llegar al proveedor de correo de
destino.
En suministrador de internet destino recibe la información y se la hace llegar al proveedor de correo electrónico
destino.
El proveedor de correo electrónico final, procesa el correo y lo hace llegar a su amigo.
Su amigo lee el correo electrónico que usted le ha enviado.
Lo más interesante de este proceso es que cada interlocutor no ha preocuparse del siguiente paso. Solo ha de
preocuparse de hacer bien su parte. Como en una cadena de montaje.
Pues bien, para que este proceso funcione correctamente cada paso tiene que estar en el orden correcto. Sino, el
receptor del mensaje no sabrá que hacer con él, porque no está prepara para ello.
Los protocolos de comunicaciones funcionan igual. Para que una comunicación TCP/IP funcione correctamente,
las capas tiene que estar “apiladas” en un orden determinado. Este orden lo establece cada protocolo.
Esta forma de implementar protocolos tiene la ventaja de que, si queremos desarrollar un protocolo nuevo,
podemos usar otro existente como base. Solo tendremos que poner “encima” las capas que definan nuestro
protocolo (se verá más adelanta cómo definir un nuevo layer, para implementar un protocolo).
SECCIÓN 3
Pila TCP/IP Y Layers En Scapy
Teoría de redes: OSI y TCP/IP
En los años 1970, Cuando internet no había nacido todavía, ya se estaban investigando sistemas de comunicación
de ordenadores y protocolos para que todos los elementos conectados a una red fueran capaces de comunicarse
llevando a cabo un modelo de comunicación común.
En 1984 se presentó el modelo de referencia OSI como un estándar ISO. Éste fue publicado con la intención de que
fuera adoptado internacionalmente.
Paralelamente, la agencia DARPA (Defense Advanced Research Projects Agency) comenzó a desarrollar un sistema
de protocolos de comunicación que culminó con TCP/IP.
En 1982 el DoD (Department of Defense) Estadounidense anunció la adopción de TCP/IP como estándar para las
comunicaciones militares, y 2 años más tarde reunió a más de 250 fabricantes para promover la adopción de dicho
protocolo.
El resultado fue que OSI quedó como modelo teórico para el estudio de protocolos de comunicaciones y TCP/IP la
implementación real de comunicaciones más usada.
La pila de protocolos TCP/IP se estructurada como sigue:
OSI consta de 7 capas y nos referiremos habitualmente a ella por su número: “Capa 2” o “capa 7”:
Í
VÍDEO 2.2 - Modelo OSI
Como ya se ha visto en varias ocasiones, un paquete enviado a la red ha de pasar por todas las capas: de más arriba
a más abajo.
El siguiente video nos muestra un caso más práctico, en el que abrimos el navegador y solicitamos la web de
google:
Í
VÍDEO 2.3 - Conexión a Google capa a capa.
TCP/IP y la correspondencia con los layes de
Scapy
Cada capa de un protocolo tiene su representación en Scapy, como podemos ver en este video:
Í
VÍDEO 2.4 - Capas TCP/IP y Scapy.
Viabilidad de paquetes construidos
Como ya se ha explicado, los paquetes enviados a la red deben de tener un orden determinado, establecido por el
protocolo que lo define.
Cuando construimos un paquete desde cero, hemos de tener cuidado de construir un paquete que tenga sentido a
nivel de protocolo. Si no cumplimos esta premisa, el sistema destino no será capaz de interpretar el paquete
recibido.
Para que se asimile mejor este concepto, haremos una prueba enviando un paquete ICMP Echo Request, en el que
hemos invertido el orden de la cabecera IP e ICMP.
Comprobamos como Wireshark no es capaz de entender lo que contiene ese paquete:
Siguiendo el protocolo
Los protocolos de comunicaciones no solo se basan en un determinado orden, también en la compatibilidad entre
capas superiores e inferiores de la pila de protocolos.
No todas las capas encajan con todas. Solo ciertas combinaciones son válidas, al igual que un puzzle.
Cada combinación de cada protocolo está definido en su estándar correspondiente.
Por ejemplo, para enviar un paquete del tipo ping, no es necesaria la capa TCP. Además, el protocolo ICMP (en el
que se basa el ping) dice que la capa inferior ha de ser la capa IP y que no puede tener capas superiores.
Sino se cumplen estas reglas, el paquete creado no tendrá sentido y el receptor no será capaz de entenderlo:
Í
VÍDEO 2.5 - Simulación de compatibilidad entre capas.
A pesar de que pueda parecer muy complicado, en la práctica es tremendamente sencillo y muy intuitivo. No te
preocupes si te encuentras algo perdido. Conforme avancemos verás que es mucho más natural de lo que parece.
SECCIÓN 4
Layers Más Usados
Existen multitud de protocolos disponibles en teoría de redes y comunicaciones, aunque
los más usados son los que se apoyan en TCP/IP:
VÍDEO 2.6 - Layer más usados y su orden.
En Scapy, cada protocolo tiene asociado un Layer que normalmente coincide su
nombre con el del protocolo en cuestión salgo alguna excepción, como puede ser la
creación de VLAN (redes de área local virtuales). VLAN es el término popular usado,
pero el estándar que lo define es el 802.1Q y, en Scapy recibe el nombre de Dot1Q. La
parte del prefijo, 802, es común a gran cantidad de protocolo, por eso Scapy
probablemente decidió omitir esa parte en el nombre del layer:
La siguiente figura muestra los protocolos más usados y su equivalencia en Scapy:
Í
VÍDEO 2.7 - Protocolos más usados y Scapy.
SECCIÓN 5
Parámetros De Los Layers
Ver los parámetros de un layer
Los layer en Scapy pueden ser configurados tan detalladamente como
queramos, siempre que sigan el protocolo en cuestión.
Antes de continuar hemos dejar claro algunos conceptos:
La definición de uno tipo layer: Hace referencia a qué parámetros tiene y
como se comporta.
Una instancia de 1 layer: Cuando, a partir de una definición de layer,
creamos una instancia concreta.
En términos de programación tendríamos la siguiente equivalencia:
Definición de uno tipo layer <-> Una clase de programación.
Una instancia de 1 layer <-> Un objeto de una clase concreta.
Si no está familiarizado con estos conceptos de programación, puede que
este símil con una casa le resulte de utilidad:
El plano de la casa sería la clase. Un tipo determinado de casa solo tiene
uno plano de construcción.
Las casas que construyéramos a partir de dicho plano serían las instancias u
objetos de programación. Pueden haber tantas casa como queramos, que
sean del mismo tipo de casa.
Cuando se crea un objeto (o se construye una casa, siguiendo el símil
anterior) se pueden especificar ciertos parámetros en su construcción. En el
caso de las casa podrían ser: color de las ventanas o tipo de muebles. En este
caso decimos que la clase acepta parámetros. Todos los layers en Scapy son
clases, por lo que podemos extrapolar estos conceptos.
La mayor parte de los layers de Scapy aceptan parámetros en su
construcción que nos permitan crearlos con determinadas características:
También podemos modificar dichos parámetros una vez construido un layer.
Tan solo tenemos que acceder a sus propiedades, que corresponden con los
nombres de los parámetros:
Parámetros por defecto de un
layer
Cada layer tiene un numero y tipo diferente de parámetros, en función del
protocolo que implemente.
Para facilitarnos su uso, Scapy pondrá valores por defecto a los campos
menos habituales y aquellos que prácticamente siempre son iguales.
Tomemos por ejemplo el caso del protocolo IP y veamos las opciones de su
cabecera:
Los campos como: versión, flags o TTL (Time To Live), con la
configuración por defecto nos valdrá en la mayor parte de las ocasiones.
Si queremos ver el contenido de estos valores, podremos hacerlo listando las
propiedades de la definición de un layer, con la función ls(…):
Como caso excepcional, vemos que por defecto la IP de origen es siempre la
dirección local de nuestra máquina (o localhost).
Ver la ayuda completa de un
layer
La función ls(…) solo es útil si queremos ver la información de la
definición del layer, pero si lo que queremos es ver cómo quedará nuestra
instancia del layer, una vez construido con los parámetros que deseemos,
debemos usar el método del layer .show():
Si nos fijamos bien, cuando usamos el método .show() hay ciertas
propiedades con el valor None: como chksum o len. Esto es así, porque el
método .show() muestra la información antes de que sea procesado el
paquete o fuera de contexto.
Por ejemplo, el valor checksum de la cabecera IP (propiedad chksum) se
calculará justo antes de enviarse. Su valor depende del resto de propiedades
y del algoritmo usado para calcularse, definido en el estándar IP.
Si queremos ver toda la información, exactamente como será enviada,
usaremos el método .show2():
Observemos que, cuando la propiedad dst es diferente de la localhost, Scapy
automáticamente consulta la tabla de rutas del sistema y completa la
propiedad src con el valor adecuado, que normalmente coincidirá con
nuestra IP.
Tipo de datos de los layers
Un layer en Scapy está compuesto por campos que conforman las
propiedades. Cada uno de esos campos ha de ser de un tipo. El tipo
determinará con qué valores podemos establecerlos, además de que nos
resultará muy útil conocerlos de cara a configurar un layer.
Usando la función ls(…) podremos ver el tipo de los campos de un layer:
Cada tipo de dato representa un tamaño. Por ejemplo:
BitField: 4 bits.
ByteField: 8 bits.
ShortField: 16 bits o 2 bytes.
IntField: 4 bytes.
Los nombres de los tipos de datos pueden tener 3 prefijos:
X (Ej: XByteField): Hace referencia a que se visualizará y tendrá formato
hexadecimal: 0x05.
LE: El tipo de dato está en representación Litte Endian. Por defecto es Big
Endian.
S: Es un número con signo. Por defecto no tienen signo.
Se puede consultar la lista de todos los tipos de datos disponibles en la web
oficial:
http://www.secdev.org/projects/scapy/doc/build_dissect.html#simple-
datatypes
Parámetros binarios o
hexadecimales
Para establecer los valores de los campos de BitField, ByteField o campos
hexadecimales (los que comienzan con X) es muy importante recordar
introducir el valor precedido de “0x…”.
Si no lo hacemos de esta forma, Scapy asumirá que dicho valor está en
decimal y queremos que sea transformado a hexadecimal.
Por ejemplo, si queremos introducir el número “10” en hexadecimal (17 en
decimal) deberíamos introducir: 0x10. Sino, Scapy asumirá que el 10 es
decimal y hay que transformarlo al hexadecimal “0xb”:
RFC para consultar los tipos de
parámetros
Los parámetros de cada layer, están ligados al estándar que los define. La
mayor parte de los estándares de protocolos se encuentran definidos en una
RFC (Request For Comment).
Un RFC explica cómo ha de comportarse un protocolo, campos de envío,
algoritmos que deben ser usados para calcular sumas de comprobación o
cualquier otra información relevante.
Todos los fabricantes deben de implementar el protocolo tal y como se
define en el RFC. Si no lo hace, no podrán comunicarse con otros
fabricantes.
Se recomienda leer los RFC de los protocolos más comunes o, al menos, los
puntos más importantes.
Aquí se listan los RFC de los protocolos más usados:
IP: https://www.ietf.org/rfc/rfc791.txt
TCP: https://tools.ietf.org/rfc/rfc793.txt
UDP: https://www.ietf.org/rfc/rfc768.txt
ICMP: https://tools.ietf.org/rfc/rfc792.txt
ARP: https://tools.ietf.org/rfc/rfc826.txt
SECCIÓN 6
Modos De Envío
Envío de un paquete con Scapy y send
En Scapy enviar un paquete a la red es muy fácil, tan solo hay que usar la función send. El uso de está función nos
garantizará que:
O la información se ha podido enviar correctamente.
O nos mostrará una excepción en caso de error.
Antes de continuar es interesante aclarar un término que se ha usado en varias ocasiones: “envío a la red”. Usamos
esta terminología en lugar de “es enviada a internet” porque puede que la información no salga de nuestra red local
y que su destino sea otra subred o que el paquete sea enviado pero la circuitería de red no sepa como tratarlo y no
progrese.
Anteriormente se ha visto el uso básico de la función send. Aunque en la mayoría de las ocasiones será suficiente
su uso básico, hay ocasiones que puede que necesitemos indicar más parámetros para que la información sea
enviada correctamente.
Estos son los parámetros que acepta la función send:
Í
VÍDEO 2.8 - Uso de la función send(...) y sus parámetros.
loop: Si es diferente de 0 envía el paquete, o lista de paquetes, en bucle de forma infinita hasta que lo paremos
pulsando CTRL+C.
inter: Tiempo, en segundos, que queremos que pase entre paquete y paquete enviado.
verbose: Nos permite cambiar el nivel de log o, incluso, desactivarlo por completo (con el valor 0).
Envío con sendp
La función sendp(…) funciona exactamente igual que send(…) con la salvedad de que lo hace en capa 2.
Esto significa que no son necesarias las rutas del sistema, la información será enviada directamente a través del
adaptador de red indicado como parámetro de la función. La información será enviada aunque aparentemente no
haya comunicación a través de ninguna ruta del sistema.
Esta función, además, nos permite especificar las direcciones físicas o MAC de la tarjeta de red de destino. Sino
indicamos las direcciones, Scapy tratará de resolverlas automáticamente:
Cuándo usar send y sendp
Aunque las diferencias entre ambas funciones son sutiles, son muy importantes:
Cuando construimos un paquete podemos empezar a hacerlo a partir de la capa de protocolos que deseemos:
Si lo hacemos a partir de la capa 3 o IP y confiamos en las rutas del propio sistema operativo para enviarla, será
suficiente con utilizar send(…).
Si, por el contrario, necesitamos un control a más bajo nivel: capa 2 (Ethernet o PPP, por ejemplo) debemos de usar
la función sendp(…).
SECCIÓN 7
Análisis De Respuestas
Recibir las respuestas: la funciones srX
Las funciones de envío send y sendp nos permiten enviar a la red la información que necesitemos, pero no nos
permite recibir las respuestas.
Hay muchas formas de recibir las respuestas de los paquetes que generamos, pero la más útil para el modo
interactivo es la familia de funciones sr (del acrónimo inglés: Send and Receive).
Éstas funciones nos permiten enviar un paquete, tal y como lo hacíamos con las funciones send y sendp, pero
además se quedan esperando la respuesta para que podamos tratarla como necesitemos.
Es importante señalar que no conviene abusar de esta función y solo debería usarse cuando realmente se necesita el
resultado. El motivo es que se queda a la espera de respuesta, bloqueando el terminal.
La familia de funciones sr incluyen las siguientes:
sr(…): Envía y recibe un paquete, o lista de paquetes a la red. Espera hasta que se se ha recibido respuesta a todos
los paquetes enviados. Es importante señalar que esta función trabaja en capa 3. Es decir: para saber cómo enviar
los paquetes usa las rutas del sistema. Sino hay ruta para enviar el paquete/s al destino deseado, no podrá ser
enviado.
sr1(…): Funciona igual que la función sr(…) con la salvedad de que solo captura la primera respuesta recibida
ignorando otras, si las hubiera.
srp(…): Funciona igual que la función sr(…) pero en capa 2. Es decir: nos permite enviar la información por una
tarjeta de red en concreto. La información será enviada siempre, aunque no haya ruta para ello.
srp1(…): Su funcionamiento es idéntico a la función sr1(…) pero en capa 2.
srbt(…): Envía información a través de una conexión Bluetooth.
srloop(…): Nos permita enviar y recibir información N veces. Es decir: podemos indicarle que envíe 1 paquete 3
veces y, por lo tanto, recibiremos la respuesta a los 3 paquetes, en orden consecutivo. Además nos permite
especificar las acciones a tomar cuando se recibe un paquete y cuando no se recibe respuesta.
srploop(…): Igual que srloop pero funciona en capa 2.
Guardar la respuesta en una variable
Además de recibir la información, probablemente nos interese analizarla con calma para diseccionarlas. Para ello
tan solo necesitamos asignar a una variable el resultado de una función del tipo sr.
Las funciones sr que devuelven más de un paquete deberemos de tratarlos como una lista de paquetes:
Í
VÍDEO 2.9 - Uso de la función sr(...) y análisis de respuesta.
Mostrar el contenido del paquete: El método
.show()
Cuando almacenamos el contenido de la respuesta en una variable y, simplemente escribimos el nombre de la
variable y pulsamos enter, veremos por pantalla un resumen del contenido del paquete:
Podemos usar el método .show() para mostrar la información de respuesta más ordenada y fácil de leer,
mostrándonos el paquete por capas de protocolos y tabulados:
Disección de un paquete
Cuando tenemos un paquete completo con todas las capas necesarias para ser enviadas, o cuando recibimos uno,
podemos analizarlo capa a capa.
Podemos acceder a cada una de las capas, como si fuera un diccionario de Python normal. Tomemos este paquete
como ejemplo:
Este paquete es la respuesta a de una conexión TCP a Google. Podemos observar que tiene 3 capas. Ahora
separamos cada una de las capas:
Í
VÍDEO 2.10 - Disección de una conexión TCP.
Incluso podemos comprobar si un layer en concreto se encuentra en el paquete:
Cuando tenemos una capa o capas separadas, podemos acceder a sus propiedades, consultarlas, modificarlas y
volver a incluirla en un paquete nuevo para que sea enviado:
Í
VÍDEO 2.11 - Análisis con Wireshark de un paquete.
SECCIÓN 8
Lectura De Ficheros PCAP
Qué es un fichero .pcap
PCAP (Packet CAPture) hace referencia al API que permite capturar paquetes de red para su procesamiento.
Por analogía, la información capturada usando esta técnica se guarda en un fichero con extensión .pcap. Este
fichero contiene tramas y paquetes de red.
Estos ficheros son muy útiles si necesitamos guardar el resultado de un análisis de red para su posterior procesado o
como evidencia del trabajo realizado.
La información almacenada en un fichero .pcap podremos analizarla tantas veces como necesitemos sin que se vea
alterado el fichero original.
Qué herramientas usan el formato .pcap
El formato PCAP es un estándar de facto y prácticamente todas las herramientas de análisis de redes y protocolos
lo usan:
TCPDump/WinDump.
Wireshark/TShark.
Ettercap.
Snort.
Dsniff.
Además, existen librerías para prácticamente todos los lenguajes de programación que nos permiten manipular los
ficheros PCAP, con lo que podremos usarlo en nuestros propios programas de manera realmente sencilla.
Generar un fichero .pcap con Wireshark
Generar un fichero PCAP con Wireshark es realmente sencillo, tan solo hay que seguir los siguientes pasos:
Abrir Wireshark y capturar tráfico de red.
Parar la captura de tráfico cuando tengamos toda la información que necesitamos.
Seleccionamos el menú: File -> Save.
Elegimos una ubicación para el fichero y le añadimos la extensión .pcap.
En el desplegable “Save as” elegiremos la opción “Wireshark/tcpdump/… - pcap (…”.
Í
VÍDEO 2.12 - Generar archivo PCAP con Wireshark.
Cargar un fichero .pcap
Scapy incorpora 2 funciones para trabajar con fichero PCAP, que nos permitirán leer y escribir sobre los mismos:
rdcap(…): Lee y carga un fichero .pcap.
wdcap(…): Escribe el contenido de una lista de paquetes en un fichero .pcap.
Para poder realizar pruebas, realizaremos una captura con Wireshark y lo guardaremos con formato .pcap en un
directorio donde tengamos acceso de lectura y escritura.
Después, cargaremos el contenido de un paquete y se lo asociaremos a una variable. El parámetro de la función
rdcap(…) indica la ubicación del fichero. La ruta al fichero debe de ser absoluta, o bien posicionarnos en le mismo
directorio del fichero donde se encuentra el fichero .pcap, y ejecutar Scapy:
Í
VÍDEO 2.13 - Lectura/escritura de fichero PCAP.
Cuando cargamos el contenido en una variable y la imprimimos por el pantalla, podemos ver que Scapy nos
presenta un pequeño resumen de número de paquetes TCP, UDP, ICMP y otros que contiene el fichero PCAP.
Análisis del contenido del fichero
Una vez cargado el contenido de un fichero, ya podemos comenzar a trabajar con él. Podemos realizar cualquier
operación, como si la información contenida en el fichero la hubiésemos generado con el propio Scapy.
Además, también podemos extraer estadísticas, listar los paquetes, sesiones o ver el contenido tal y como se vería
en TCPDump:
Í
VÍDEO 2.14 - Análisis de un fichero PCAP.
Extracción de paquetes y tramas
Una vez cargado el fichero PCAP podemos acceder a su contenido de varias formas:
Acceso a las sesiones de conexiones: Una sesión está compuesta por todos los paquetes que forman parte de una
misma conexión lógica. Es decir: Si hemos hecho una búsqueda en Google, la sesión constaría de todos los
paquetes necesarios para recibir esa información. Es importante destacar que Scapy se encarga de ordenar y
unificar los paquetes en función de cada sesión, ya que probablemente la información no se haya recibido en orden.
Acceso al contenido en crudo: Según el orden de recepción de cada paquete.
Las sesiones son guardadas en un diccionario de Python y el contenido en crudo en una lista.
En el siguiente ejemplo veremos cómo buscar sesiones TCP web sin cifrar (puerto TCP 80) y cómo extraer su
contenido:
Í
VÍDEO 2.15 - Búsqueda de conexiones TCP sin cifrar.
Búsqueda de tramas y paquetes
Scapy nos permite, no solo diseccionar los paquetes, sino también inspeccionarlos y buscar el contenido que
necesitemos en él.
Estos son unos pocos ejemplos de lo que podríamos hacer con Scapy:
Búsqueda de enlaces a recursos: Una imagen, por ejemplo.
Buscar usuarios y passwords en tramas de red.
Buscar qué dominios son accedidos o consultados por los usuarios.
Í
VÍDEO 2.16 - Búsqueda avanzada de información en PCAP.º
SECCIÓN 9
Reinyección En Modo Flood
Qué es el Flooding
Cuando hablamos de flooding (inundación) estamos haciendo referencia a una afluencia masiva de información en
muy poco tiempo.
En el caso de la auditoría de redes nos referirnos a enviar muchos paquetes a un mismo destino en un corto periodo
de tiempo.
Flooding como ataque
El flooding puede ser usado como ataque por la propia naturaleza y definición de éste:
Si enviamos mucha información a un mismo destino en un tiempo muy pequeño podemos provocar una denegación
de servicio en el sistema destino, con las siguientes consecuencias:
Colapso de la red de comunicaciones del objetivo, por lo que no podría establecer más comunicaciones con más
clientes.
Causar un fallo del sistemas operativo o el software destino. Éstos pueden no estar preparados para este tipo de
comportamientos y provocar un comportamiento inesperado, que se suele traducir en una caída del sistema o del
software.
Generación de información para la inyección
Para llevar a cabo un ataque de inundación es necesario tener gran cantidad de información para enviar. El tiempo
de envío es crucial, por lo que deberíamos de tener toda la información preparada antes del envío.
Cuando queramos generar la información, podemos encontrarnos con estos problemas:
Scapy está desarrollado en Python. Python es un lenguaje interpretado y no fue concebido para un proporcionar un
alto rendimiento.
Scapy genera la información en el momento de enviarla. Si queremos mandar 100.000 paquetes, el tiempo de
conversión será demasiado alto, por lo que no conseguiríamos un flujo de información lo suficientemente elevado.
Para solventar estos problemas podemos optar por las siguientes soluciones:
Generar una cantidad de paquetes pequeña, pero indicar a la función de envío que re-use esa información en lugar
de llamar a la función N veces o generar más paquetes de envío.
Pre-generar todos los paquetes que deseemos enviar, guardarlos en un fichero PCAP y después pasar el contenido
de ese fichero a la función de envío.
Generar información reusable
Generar una cantidad de información pequeña, indicando a la función de envío que re-use dicha información, en
lugar de llamar a la función de envío N veces o generar más paquetes de envío.
Para esto podemos hacer uso del parámetro count de las funciones de envío. Se recomienda usar la funciones de
capa 2, ya que suelen dar un mayor rendimiento al no tener que usar la tablas de resolución de direcciones del
sistema.
Además, para incrementar el número de paquetes por segundo, desactivaremos la salida por pantalla cada vez que
se envíe un paquete. Para ello configuraremos el valor del parámetro verbose a 0:
VÍDEO 2.17 - Generar información re-usable.
Generar PCAP
Un PCAP contiene información de paquetes y tramas de red ya generadas. En crudo podríamos decir. Si logramos
generar un fichero PCAP y después cargarlo, Scapy no tendría que gastar tiempo en generar los paquetes al vuelo,
lo cual nos ahorraría mucho tiempo.
Al igual que antes, desactivando el modo verbose lograremos incrementar el rendimiento.
Hemos de tener cuidado cuando generemos listas de paquetes muy grandes ya que, sino, podemos llegar a
consumir mucha memoria. En su lugar, usaremos generadores de Python (que usaremos igual que una lista, pero
con paréntesis, en lugar de corchetes) y la función xrange en lugar de range:
Í
VÍDEO 2.18 - Generar PCAP con información re-usable.
Inyección de datos en crudo
Aunque la generación de paquetes reusables y la precarga de PCAP optimizan el envío de información, pueden no
ser lo suficientemente rápidos como para generar un ataque de flooding.
Las limitaciones intrínsecas de Python no permiten enviar información de manera más óptima, usando Python
puro.
Scapy está preparado para solventar este problema y nos proporciona un método todavía más rápido para enviar
información usando TCP Replay.
TCP Replay es una herramienta, escrita en C, que es capaz de generar tráfico a una velocidad increíblemente
rápida. Aunque podemos usarla desde su propia línea de comandos, Scapy nos da la posibilidad de usarla desde
código de Python, usando la función sendpfast(…). Esta función es una capa de abstracción sobre tcpreplay.
Su uso es muy sencillo:
Le indicaremos la información a enviar, bien sea desde un fichero PCAP o una lista de paquetes.
Especificaremos la interfaz de salida.
Si queremos optimizar el rendimiento, podemos indicar que cache la información a enviar. Hay que usar este
parámetro con cuidado, porque cargará en memoria toda la información.
Cuando la función sendpfast(…) termina, nos muestra un pequeño resumen con información interesante sobre el
envío, como: cantidad de paquetes enviados por segundo, numero de paquetes o cantidad total de información
enviada, en bytes:
VÍDEO 2.19 - Uso de TCPReplay con sendpfast.
SECCIÓN 10
Creación De Un Nuevo Layer
¿Por qué crear un layer?
Si bien es cierto que Scapy incluye layers para una gran cantidad de protocolos y que en raras ocasiones
necesitaremos añadir un nuevo layer, existen circunstancias en las que nos puede ser realmente útil saber crear
nuestro propio layer.
Existen muchos fabricantes que desarrollan sus propios protocolos de comunicaciones, por diversos motivos:
El estándar no se adapta a sus necesidades y, tomándolo como base, lo extienden con sus propias funcionalidades.
No existe estándar para el sistema que se está implementando. Esto es muy habitual en entornos I+D e
infraestructuras críticas y SCADA, como pueden ser: presas, centrales nucleares, sistemas de control mecánico, etc.
Desean que su protocolo sea propietario y forme parte de su propiedad intelectual e industrial. Suele desembocar
en patentes.
Un layer no es ni más ni menos que implementar la definición de un protocolo en formato Scapy. Para esto
necesitaremos saber la especificación del protocolo y cómo éste se comporta.
¿Dónde se almacenan los Layers?
Los layers de Scapy se almacena en el directorio de instalación de éste. Dependiendo del sistema operativo y el
método de instalación, puede estar en ubicaciones diferentes.
Una forma de encontrar el directorio, es utilizar los comandos de Linux locate, grep y head, en el siguiente orden:
Buscar la palabra “scapy” con locate.
Redireccionar la salida anterior y filtrar por la palabra “site-packages”. Éste es un directorio especial en Python,
donde se almacenan los paquetes instalados con el comando “pip”.
Nos aparecerán muchos directorios con resultados, pero realmente todos cuelgan de la misma raíz, que es la que
nos interesa. Por eso, podemos usar el comando head para obtener solo 2 dos primeros elementos.
Una vez localizado el directorio de Scapy, nos dirigiremos a él. Hay muchas carpetas, pero nos interesan solamente
2: contrib y layers. Ambas contienen layers, pero existe una diferencia:
contrib: Los layers incluidos en este paquete no serán cargados automáticamente cuando Scapy se inicie. Los
tendremos que cargar manualmente, como cualquier otra librería de Python. Este paquete suele contener layers de
uso poco habitual.
layers: Todos los layers ubicados en este paquete son cargados automáticamente cuando se inicia Scapy. De esta
forma es muy cómo trabajar con ellos, ahorrándonos la tediosa labor de cargarlos uno por uno, ya que hay decenas
de ellos.
Í
VÍDEO 2.20 - Localizando directorios de layers de Scapy.
Tipos de datos de los layers
Aunque ya se presentó anteriormente los tipos de datos en Scapy, vamos a hacer un pequeño resumen:
Scapy tiene diversos tipos de elementos que pueden contener una capa o layer:
Desde lo más sencillos y básicos: int, long, float…
Hasta tipos más complejos: IPField, DNSField, Opciones de cabecera TCP…
Tipos básicos
Lo tipos básicos se agrupan por la longitud de éstos:
Tipo bit (BitField): 4 bits.
Byte (ByteField): 8 bits.
Int (IntField): 4 bytes.
El modo de representación, según la siguiente convención de prefijos:
X (Ej: XByteField): Hace referencia a que se visualizará y tendrá formato hexadecimal: 0x05.
LE: El tipo de dato está en representación Litte Endian. Por defecto es Big Endian.
S: Es un número con signo. Por defecto no tiene signo.
Tipos Complejos
Los tipos complejos están formados por la composición de tipos básicos que, además de la información que
contienen, incluyen la lógica de comprobación para validar que el tipo dato es correcto. Por ejemplo, el tipo IPField
incluye la siguiente lógica, para IPv4:
Comprueba que la IP proporcionada es de tipo string.
Valida que la IP introducida tiene 4 valores numéricos separados por 3 puntos.
Comprueba que cada valor numérico es mayor o igual que cero y menor o igual que 255.
En caso de proporcionarse un nombre de dominio como parámetro, automáticamente lo resuelve y obtiene su IP.
Los tipos complejos son muy útiles para construir nuestras propias capas porque nos ahorran gran cantidad de
trabajo.
Se puede consultar la lista de todos los tipos de datos disponibles en la web oficial:
http://www.secdev.org/projects/scapy/doc/build_dissect.html#simple-datatypes
Estructura básica de un layer
Para construir un layer en Scapy, tendremos que comenzar a adentrarnos un poco en programación con Python
Un layer es una clase que hereda de la clase especial: Packet. Scapy es capaz de buscar y detectar todas las clases
que heredan de esta clase. Cuando las encuentra, asume que son layers.
En el siguiente código podemos ver un ejemplo de un layer real:
# -*- coding: utf-8 -*-
from scapy.all import Packet
from scapy.fields import IntEnumField, IntField, LongField
class SemaforoProtocol(Packet):
name = "Semaforo"
fields_desc = [
IntField("tiempo_verde", 20),
IntField("tiempo_rojo", 15),
IntField("tiempo_amarillo", 2),
LongField("contador_ciclos", 0),
IntEnumField("luz_on", 1,
{
1: "rojo",
2: "verde",
3: "amarillo"
})
En el ejemplo vemos un layer simulado de un semáforo. El semáforo hereda de la clase Packet, como se ha
comentado.
La clase tiene una serie de propiedades:
name: Nombre descriptivo de nuestra capa.
fields_desc: esta es la lista de tipos de datos que contendrá nuestra capa. En el caso de nuestro semáforo, hemos
incluido los siguientes campos:
tiempo_verde: duración, en segundos, que el semáforo estará en verde.
tiempo_rojo: duración, en segundos, que el semáforo estará en rojo.
tiempo_amarillo: duración, en segundos, que el semáforo estará en ámbar.
contador_ciclos: contador del número de veces que ha tenido lugar el ciclo de luces:
verde-amarillo-rojo.
luz_on: indica qué luz está encendida en un determinado momento.
Por último, tendremos que añadir nuestro nuevo layer a la lista de layers que son cargados por defecto cuando Scapy
arranca, siguiendo los siguientes pasos:
Guardaremos nuestra capa en el directorio “layers/”, en el punto de instalación de Scapy, con un nombre descriptivo
en minúsculas y con la extensión “.py”.
Editamos el fichero fichero “config.py”, en el directorio de instalación de Scapy, y añadiremos nuestra capa a la
lista de Python “load_layers”. En dicha lista, añadiremos un elemento más, que será el nombre del fichero con el
que hemos guardado le layer, sin la extensión “.py”.
Í
VÍDEO 2.21 - Creación de un Layer de Scapy.
SECCIÓN 11
Exportar Información Y Creación De Gráficas
Exportar paquetes en hexadecimal
Exportar un paquete, o lista de paquetes, a formato hexadecimal puede sernos de ayuda si queremos reutilizar dicha
información.
Un caso muy útil de reutilización podría ser un payload de un exploit.
Los exploit son programas capaces de aprovechar fallos de seguridad de sistemas o software. Suelen constar de 2
partes:
La parte encargada de aprovechar el fallo de seguridad y que logra ejecutar código (como comandos del sistema) en
el sistema remoto.
El payload: el código que queremos ejecutar en el sistema. Se suelen enviar en el formato más cercano al código
máquina, que suele ser hexadecimal.
Ahora que ya sabemos como funciona un exploit, imaginemos que queremos ejecutar un ataque masivo a un
objetivo A. Queremos realizar una denegación de servicio, por lo que necesitamos lanzar gran cantidad de paquetes
al objetivo.
Utilizamos uno o varios exploits para buscar máquinas vulnerables en internet o nuestra red local. En el payload del
exploit insertaremos el código hexadecimal de un PING.
La generación del código hexadecimal en Scapy es realmente fácil. Tan solo tenemos que crear el paquete y utilizar
la función str(…) para obtener el código en hexadecimal:
Llevar a cabo este ataque es algo más complejo de lo explicado, pero no ha servido por ser ilustrativo.
Exportar paquetes en base64
Del mismo modo que la exportación a hexadecimal en Scapy nos puede ayudar en para a la hora de la preparación
de otros tipos de ataques, la exportación en formato base64 nos abre otro abanico de posibilidades:
Imaginemos, por ejemplo, un sitio web con un parámetro vulnerable una URL. Y que, a través de dicho parámetro,
podemos ejecutar código arbitrario en el sistema.
Al igual que en el caso de la exportación hexadecimal, queremos usar esa máquina para realizar una ataque de
denegación de servicio contra otra máquina. En este caso, el payload del exploit tendríamos que pasarlo en formato
base64, por ser un formato compatible con http.
Para generar un base64 de salida, tan solo tendremos que usar la función export_object(…).
Es muy importante para que no obtengamos errores, es que a la función deberemos de pasarle una cadena de texto
como entrada. Por lo tanto, tendremos que usar la función str(…) previamente:
Exportar a PDF
Scapy incorpora la funcionalidad de exportar la información de un paquete a un PDF.
El PDF resultante es un mapa con la representación binaria del paquete y sus correspondientes capas en Scapy. Está
función es tremendamente didáctica y nos será de gran utilidad para el estudio y comprensión de protocolos.
Para generar el PDF deberemos tener instalada la librería PyX de Python, así como sus dependencias.
Generar el documento es muy sencillo, tan solo tendremos que usar el método .pdfdump(…), que tienen todos los
paquetes construidos con Scapy, e indicarle la ruta donde queremos almacenar el fichero:
El resultado es un PDF como el que se puede ver en la imagen:
Crear gráficas con información de Scapy
Scapy ofrece la posibilidad de mostrar gráficas con la información que queramos, a partir de los paquetes de
respuesta obtenidos de las funciones tipo srX(…).
Para poder usar dicha funcionalidad tendremos que asegurarnos que tenemos instalada la librería gnuplot-py.
Las gráficas nos pueden ser de utilidad para realizar estudios de comportamientos y representar la información de
forma visual.
Antes de mostrar los ejemplos reales, es conveniente que recordemos algunos conceptos e introduzcamos algunos
nuevos:
Como ya sabemos, la función sr(…) envía un paquete o lista de paquetes.
La función sr(…) devuelve 2 valores: los paquetes a los que se ha obtenido respuesta y a los que no la han
obtenido.
Scapy nos proporciona la función sniff(…): que nos permite crear un sniffer y guardar la información obtenida en
una variable para su posterior análisis.
Hay ciertas capas de Scapy, como TCP, cuyos parámetros podemos establecerlos con listas, en lugar de con un
único valor. Scapy lo reconocerá y generará todos los paquetes con esa información. Es decir: si en el layer TCP, en
puerto de destino establecemos la lista: [1, 22, 80, 8080]; TCP(dport=[1,22,80,8080]), Scapy automáticamente
generará 1 paquete diferente por cada puerto. En este caso 4 paquetes TCP.
En un paquete de Scapy, podemos consultar 2 propiedades muy interesantes:
.time: Nos indica cuando fue generado el paquete.
.sent_time: Nos indica cuando ha sido enviado el paquete. Esta propiedad estará a 0
en los paquete que recibamos de un sistema remoto, ya que, realmente solo podemos
saber cuando se nos ha enviado. Y dicho tiempo es considerado por Scapy el
momento del envío, en la propiedad .time.
Los paquetes que no han obtenido respuesta se devuelven en una estructura interna de Scapy, pero que se comporta
como una lista común de Python:
Í
VÍDEO 2.22 - Creación de listas de paquetes con listas de valores.
Cada elemento de la lista, a su vez, es una lista de 2 valores:
Posición 0: Contiene el paquete enviado, tal cual nosotros los creamos.
Posición 1: Contiene el paquete recibido, como respuesta al que nosotros enviamos.
Vamos a estudiar un par ejemplos sobre con los que poder apreciar su potencial:
Estudio de tiempos de respuesta.
Estudio de dispersión en la generación de numero de secuencia de la cabecera TCP.
Estudios de tiempos de respuesta
Crearemos una gráfica con los tiempos de respuesta un paquete ICMP:
En el Eje X veremos cada uno de los paquetes enviados.
En el Eje Y veremos el tiempo que se ha tardado en responder a ese paquete.
Para esta práctica se usarán las propiedades .time y .sent_time, explicadas anteriormente, a fin de determinar el
tiempo de respuesta de cada paquete:
Í
VÍDEO 2.23 - Estudio de tiempos de respuesta en conexiones TCP.
Estudio de la dispersión en identificadores TCP
Cada paquete TCP tiene un número de identificador de secuencia que es usado por el protocolo para controlar el
correcto orden en el que se envían y reciben los paquetes entre emisor y receptor.
Estos valores deberían de ser lo más aleatorios posibles ya que, si un atacante pudiera predecir el valor del siguiente
identificador de secuencia y lo enviara antes que emisor legítimo, no solo lograría hacerse pasar por el emisor, sino
que éste ya no podría de poder comunicarse con el receptor.
Antiguamente este fue un problema muy grave y muchos sistemas operativos tuvieron que ser parcheados de
urgencia. Actualmente es un problema resuelto.
Como segunda práctica, analizaremos los identificadores de secuencia de una comunicación TCP a un web http,
analizando la aleatoriedad de estos valores. Crearemos una gráfica con estas respuestas:
En el Eje X veremos cada uno de los paquetes enviados.
En el Eje Y veremos el valor del identificador de secuencia del paquete enviado.
Í
VÍDEO 2.24 - Análisis de números de secuencia TCP.
CAPÍTULO 3
Usando Scapy Como Librería
“Puede utilizar Scapy para hacer sus propias
herramientas automatizadas. También puede extender
Scapy sin tener que su código fuente.
Si ha construido algunas herramientas interesantes,
por favor ¡contribuya de nuevo a la lista de correo!
Puede utilizar fácilmente Scapy en sus propias
herramientas. Sólo importe lo que necesite y hágalo.”
Fuente: proyecto Scapy
SECCIÓN 1
Qué Aprenderemos En Este Capítulo
“El único sistema seguro es aquél que está a
pagado en el interior de un bloque de hormig
ón protegido en una habitación sellada rodea
da por guardias armados”
-Gene Spafford
En este capítulo aprenderá a usar Scapy en sus propios scripts y programas,
con los que podrá crear sus propias librerías y software en muy poco tiempo
y con toda la potencia de Scapy.
Estudiaremos el funcionamiento interno del multithreading (hilos) en
Python. Sus problemas de diseño. Sus ventajas. Cómo y cuándo usarlos, así
como alternativas para conseguir multhreading real en aplicación Python.
Configuraremos el sistema de log definiendo niveles de depuración. Loggear
información de forma remota y local, así como la capacidad de configurar
varios sistemas de bitácora de manera simultánea.
Explicaremos cómo realizar fuzzing con Scapy y las capacidades nativas de
que éste dispone.
Por último, estudiaremos teoría de autómatas finitos deterministas sin
necesidad de la complejidad matemática que les rodea. Veremos cómo crear
pilas de protocolos de comunicaciones en unas pocas lineas usando, la poca
conocida, libraría de Scapy: Automaton.
SECCIÓN 2
Funciones Y Llamadas
Importar y llamar funciones de Scapy
Una de las principales características de Scapy es que nos permite usar las mismas funciones del modo interactivo,
como parte de nuestros programas.
Cuando se inicia Scapy en línea de comandos, todas las funciones son importadas automáticamente, no así cuando
usamos Scapy como librería:
# -*- coding: utf-8 -*-
from scapy.all import send, sniff
El siguiente código muestra cómo importar las funciones send y sniff.
Como veremos, prácticamente la totalidad de las funciones se importan de la librería “scapy.all”.
La llamada a una función de Scapy, será del mimo modo que en el terminal:
Í
VÍDEO 3.1 - Uso de la función sniff.
Importar Layers
Del mismo modo que importamos funciones, habremos de importar aquellos layers con los que queramos trabajar.
La librería base desde donde la importaremos seguirá siendo: scapy.all:
# -*- coding: utf-8 -*-
from scapy.all import TCP, IP
El uso de los layers, será idéntico al que hacíamos de ellos en el modo interactivo:
Í
VÍDEO 3.2 - Envío y recepción de paquetes.
Funciones con funciones como parámetros
Muchas funciones en Scapy aceptan, como uno de sus parámetros de entrada, una función en lugar de un tipo
básico común (int, float…). Aunque pueda parecer un concepto un tanto enrevesado, lo cierto es que es realmente
útil.
Imaginemos, por ejemplo, la función de Scapy sniff(…). Si mostramos su ayuda, nos aparecerá la siguiente
información:
Nos fijamos en el parámetro prn. Este parámetro estará presente en otras muchas funciones y, tal y como se puede
ver en la documentación, hace referencia a una función como parámetro de entrada, como comentamos
anteriormente.
En el caso de la función sniff(…), está función será aplicada a cada paquete capturado. O, dicho de otro modo, cada
vez que la sniff(…) intercepte un paquete llamará a esta función con el paquete interceptado como parámetro.
Esta funcionalidad nos da una gran potencia: imaginemos que queremos hacer un pequeño programa que intercepte
todas las comunicaciones y que vaya almacenando todos los host detectados en la red. Usando esta característica
sería muy sencillo:
Í
VÍDEO 3.3 - Creación de sniffer descubridor de hosts.
SECCIÓN 3
Envío De Información
Creación de paquetes
Ya hemos visto en varias ocasiones cómo construir un paquete en Scapy. En este punto ampliaremos un poco más
los conceptos de construcción e incluiremos algunos trucos que nos resultarán de gran ayuda.
Hasta ahora, construíamos un paquete para recibir un respuesta a un PING como sigue:
# -*- coding: utf-8 -*- #
from scapy.all import IP, ICMP
if __name__ == '__main__':
pkg = IP(dst="google.com")/ICMP()
No es necesario que construyamos todo el paquete de una vez. Podemos hacerlo por partes, según nos convenga:
# -*- coding: utf-8 -*- #
from scapy.all import IP, ICMP
if __name__ == '__main__':
ip_layer = IP(dst="google.com")
icmp_layer = ICMP()
pkg = ip_layer/icmp_layer
Otra parte olvidada de los paquetes es el payload final. Existen ciertos protocolos que nos permiten poner cualquier
tipo de información y añadir un payload u otro puede ser tan sencillo como añadir un texto:
# -*- coding: utf-8 -*- #
from scapy.all import IP, ICMP
if __name__ == '__main__':
ip_layer = IP(dst="google.com")
tcp_layer = TCP(dport=80)
payload = "GET / HTTP/1.1\n\rHost: google.com\n\r\n\r"
pkg = ip_layer/icmp_layer/payload
Esto último nos puede resultar de utilidad para crear paquetes con firmas de validación diferentes. Es decir: que con
un pequeña variación (un carácter más, por ejemplo) el paquete será diferente. Esto es muy útil para ciertos ataques
de fuzzing.
Fuzzing con Scapy
El fuzzing, por definición, es una técnica que consiste en generar combinaciones de valores en los parámetros de
entrada de un sistema.
En el caso del análisis y auditoría de redes, consistirá en la generación de gran cantidad de paquetes de red,
variando y combinando los valores de cada una de los layers de los paquetes enviados. De esta manera lograremos
paquetes con combinaciones de flags y parámetros inválidos.
La finalidad es analizar la respuesta y comportamiento del sistema auditado ante este tipo de técnicas, ya que puede
darse el caso (y de hecho se da a menudo) que ante ciertas combinaciones de valores, los sistemas remotos tienden
a comportamientos extraños o dejan de funcionar a pleno rendimiento hasta que sean reiniciados o, incluso, hasta
hasta que no se hace un reseteo completo.
Scapy incorpora capacidades para facilitarnos el fuzzing. Alguna ya se han visto en otros apartados, pero las
retomaremos y explicaremos en el contexto del fuzzing:
Í
VÍDEO 3.4 - Creación de fuzzer con Scapy.
Los campos que usaremos más comúnmente usados para fuzzing serán:
Puertos de origen y destino de TCP.
Flags TCP.
El flag ID de los layers: TCP e IP.
Direcciones MAC de origen, del layer Ether.
IPs de origen.
Añadir texto aleatorio, como payload.
Para ello podemos ayudarnos de algunas clases que Scapy proporciona para generar valores aleatorios:
IPs: Usando RandIP().
Puertos: Usando RandInt() y módulo 255.
Textos aleatorios en el Payload: Usando RandString().
Direcciones MAC aleatorias: Usando RandMac().
Tipos básicos (para flags, por ejemplo): usando RandShort(), RandByte()…
Parámetros en la línea de comandos
La creación de scripts y programas adaptados a nuestras necesidades es una de las cosas que más potencia y
flexibilidad nos dará en nuestro trabajo, si sabemos cómo parametrizar ciertos valores.
Es muy molesto y poco productivo tener que cambiar nuestro código cada vez que queramos cambiar la IP de
destino, modificar el puerto destino u origen o cualquier otro valor. En su lugar podemos hacer un interfaz en línea
de comandos que nos permita cambiar estos valores cuando llamamos a nuestro programa.
Para hacer esta interfaz, usaremos la librería nativa de Python argparse. Ésta nos permite configurar cada
parámetro de manera muy sencilla. Incluso construye la ayuda para el uso de nuestro programa de manera
automática.
Para aprender mejor la potencia de esta funcionalidad, hagamos un ejemplo que nos permitirá especificar:
VÍDEO 3.5 - Uso de argparser.
El destino de un paquete: A este parámetro lo llamaremos target.
El puerto de destino: A este parámetro lo llamaremos port.
Los flags de la cabecera TCP: que queremos habilitar en el paquete. A este parámetro lo llamaremos tcp-flags.
# -*- coding: utf-8 -*-
import argparse
from scapy.all import TCP, IP, send
# ----------------------------------------------------------------------
def send_pkg(args):
"""Envia la informacion con los parametros de 'args'
:param args: Configuracion de los parametros de entrada
:type args: Argparser
"""
target = args.target
port = args.port
tcp_flags = args.tcp_flags
ip_layer = IP(dst=target)
tcp_layer = TCP(dport=int(port), flags=tcp_flags)
send(ip_layer/tcp_layer)
def main():
args = argparse.ArgumentParser(description="Interfaz de
linea de comandos")
args.add_argument("--target", dest="target", help="host
destino")
args.add_argument("--port", dest="port", help="puesto
destino")
args.add_argument("--tcp-flags", dest="tcp_flags",
help="flags TCP activos cuando sea enviado el paquete")
parsed_args = args.parse_args()
send_pkg(parsed_args)
if __name__ == '__main__':
main()
SECCIÓN 4
Scapy Y Multithreading
Hilos en Python
Los hilos son una de las mejoras maneras de paralelizar trabajos costosos o de poder realizar tareas de forma
paralela, gracias a la capacidad de multiprocesamiento y concurrencia de los procesadores actuales.
Lamentablemente Python no fue diseñado para tareas de alto rendimiento, sino para hacer extremadamente sencilla
y rápida la codificación de software.
Guido Van Rossum (creador de Python) tomo la decisión de que Python no implementara hilos reales, porque de
esta manera el diseño del lenguaje y su motor de ejecución sería mucho más sencillo de implementar y era menos
probable a que aparecieran errores típicos del desarrollo concurrente, como las condiciones de carrera.
Limitaciones
Debido a que a que el motor de ejecución de Python (también llamado máquina virtual) no fue diseñada con la
característica de creación de hilos, Python tiene limitaciones en el uso de los mismos.
Podemos usar hilos en Python, pero la ejecución de éstos es simulada. ¿qué significa esto?
Cuando desarrollamos usando hilos en Python, lo que realmente ocurre es que el motor de Python ejecuta nuestro
programa en un único proceso y en dicho proceso registra los hilos “virtuales” que, como programadores, creemos.
La limitación de Python consiste en que solo se podrá ejecutar un hilo a la vez. La máquina virtual de Python
designa un tiempo de ejecución para ejecutar cada hilo. Este tiempo es el mismo para todos los hilos. Cuando este
tiempo finaliza, suspende ese hilo y lo intercambia por otro. De tal forma que, de nuevo, solamente hay un hilo
ejecución. Por esta razón decimos que los hilos son simulados. Esta animación ayudará a aclarar este concepto:
Í
VÍDEO 3.6 - Funcionamiento hilos en Python.
Debemos de tener claro este modo de funcionamiento de Python, ya que muchos problemas que en otros lenguajes
se solucionan mediante hilos, no podrán trasladarse tal cual a Python.
Como apunte final, comentar que existen varias implementaciones del motor de Python. Python es un lenguaje de
programación que tiene definido su modo de funcionamiento mediante los llamados PEP y cualquiera que
implemente este funcionamiento podrá escribir un motor compatible con el código de Python que escribamos.
El motor oficial de Python está escrito en C. Pero existen otro escritos en diferentes lenguajes. Lo más curioso, e
interesante, es que algunos de ellos no tienen la limitación de los hilos comentada y pueden ejecutar hilos reales. El
problema es que estas implementaciones no son compatibles 100% con las versiones oficiales de Python y su uso
es bastante limitado.
Estas son algunas de las máquinas virtuales disponibles actualmente:
Pypy: Escrita en RPython. Es una gran alternativa al motor oficial debido a su alta compatibilidad, gran
rendimiento y bajo consumo de memoria.
IronPython: Escrita en .NET. Una gran opción para usar Python conjuntamente a otros lenguajes de Microsoft,
como C#. Implementa hilos reales, pero presenta muchas incompatibilidades.
Jython: Escrita en Java. Implementa hilos reales, pero su desarrollo está algo estancado y actualmente no soporta
Python 3, ni las últimas mejoras de Python 2.7.
Qué paralelizar
Debido a las restricciones de motor de Python, podemos encontrarnos con ciertos problemas, resueltos en otros
lenguajes, que cuando los portamos a Python pueden darnos resultados paradójicos.
Uno de estos problemas suele ser el procesamiento concurrente de una lista de elementos. En otros lenguajes
lanzaríamos un hilo para que cada valor se procesara en paralelo y conseguiríamos una gran mejora de velocidad.
En Python el comportamiento es diferente:
Según lo estudiado hasta ahora, cada elemento que se procesa lanzaría un hilo “virtual”.
Cada uno de estos hilos, como ya se ha comentado, estaría ejecutándose un determinado tiempo, prefijado por el
motor de Python.
Si el tiempo en procesar cada elemento de las lista, es mayor que el tiempo prefijado para cambiar de hilo, entonces
ese hilo tendrá que ejecutarse varias veces hasta finalizar el procesamiento del elemento. Es muy importante
destacar que el cambio entre hilos consume tiempo.
La cantidad de hilos en ejecución es limitada, ya que sino saturaríamos la máquina virtual de Python y el sistema.
Con estas premisas, tomemos el siguiente ejemplo:
En procesar un elemento tardamos 21 unidades de tiempo.
El motor de Python asigna 20 unidades de tiempo para cada hilo.
Creamos 5 hilos.
Tenemos 100 elementos para procesar.
Esto significa que, para procesar 1 elemento necesitamos 2 ejecuciones de un hilo. Hasta que un hilo no finaliza no
podemos crear uno nuevo ni procesar otro elemento.
En la segunda ejecución de cada hilo, solo quedaría 1 unidad de tiempo por procesar, pero este hilo quedaría
suspendido hasta que finalicen de ejecutarse los otros 4 y vuelva a tocarle su turno de ejecución.
El resultado para este problema sería que el procesamiento de los 100 elementos tardaría casi el doble que si
hubiéramos escrito ese mismo programa sin hilos y se ejecutara de forma secuencial. Y he aquí la paradoja
comentada: cuando el sentido común nos dice que el tiempo de ejecución mediante hilos debería de reducirse casi
tanto como el número éstos, los resultados empíricos nos demuestran que no solo no es así, sino que su ejecución
será más lenta.
La conclusión de este estudio es que, en Python, los hilos solamente han de usarse para ciertos casos de uso muy
concretos, como los siguientes:
Funciones de ejecución continuada: Como las funciones que procesan las conexiones de clientes de un servidor
web.
Operaciones de entrada / salida: Como el acceso a ficheros o a la red.
Ejecución de tareas de larga duración: Como operaciones matemáticas complejas.
Ejemplo
Como ejemplo de concurrencia usando Python y Scapy, haremos un escáner de puestos TCP muy sencillo. El
funcionamiento será muy simple:
Usando Scapy lanzaremos un paquete TCP-SYN.
Si el sistema analizado nos devuelve un SYN-ACK, significará que dicho puesto está abierto.
Usaremos 5 hilos de ejecución concurrente.
Finalmente mostraremos los resultados por pantalla.
VÍDEO 3.7 - Creación de escáner de puertos multi-hilo con Scapy y Python.
# -*- coding: utf-8 -*-
import threading
from scapy.all import sr1, IP, TCP
CONCURRENCY = 5
OPEN_PORTS = []
VERBOSE = 1
def analyze_port(host, port, sem):
if VERBOSE > 0:
print "[ii] Analizando puerto %s " % port
res = sr1(IP(dst=host)/TCP(dport=port), verbose=False, timeout=0.2)
if res[TCP].flags == 18:
OPEN_PORTS.append(port)
if VERBOSE > 1:
print "Puerto %s abierto." % port
# Desbloqueando el semaforo para activar otro hilo
sem.release()
def main():
sem = threading.BoundedSemaphore(value=CONCURRENCY)
threads = []
# Analizamos los primero 80 puertos
for x in range(1, 90):
t = threading.Thread(target=analyze_port, args=("192.168.1.1", x, sem, ))
threads.append(t)
t.start()
sem.acquire()
# Esperamos que todos los hilos finalicen
for x in threads:
x.join()
# Mostrando resultados
print "[*] Puertos abiertos:"
for x in OPEN_PORTS:
print " - %s/TCP" % x
if __name__ == '__main__':
main()
SECCIÓN 5
Interceptación De Paquetes Y El
Sistema Operativo
Como se intercepta un paquete
Para interceptar paquetes en Scapy podemos usar varias funciones que éste
nos provee. Internamente todas ellas usan un sistema de sniffing para
captura la información, bien sea de respuesta o bien sea tráfico de tránsito
de la red.
Es importante saber que Scapy no sigue ningún orden ni protocolo
específico para capturar las respuestas, sino que intercepta toda la
información en crudo.
También es importante tener en cuenta que Scapy no interfiere en la
comunicación con el sistema operativo, es decir:
La interceptación se hace en modo de escucha. Podemos capturar cualquier
información, pero no podemos bloquearla o ponernos en medio de ella sin
más. Imagínese una tubería transparente con agua por la que circulan peces.
Los puede ver, pero no puede interferir en su trayecto.
Problemas de modificar la
vuelo:
Como ya hemos comentado, modificar información al vuelo no es tarea
sencilla. Scapy no lo provee de forma nativa entre sus funciones de envío
estándar.
Para poder modificar información al vuelo, lo primero que deberemos de
hacer es cortar el canal de comunicación desde el origen de la información
(la red) hasta el sistema operativo. Para poder realizar esto tenemos la
limitación de que deberemos de trabajar a nivel del kernel del sistema
operativo.
La forma más sencilla de bloquear el tráfico al sistema operativo es con una
simple regla de firewall, ya que éste trabaja a nivel de kernel.
Una vez tengamos bloqueado el tráfico a la capa del kernel que procesa los
paquetes de red, ya podremos actuar y operar reemplazando el
comportamiento sistema operativo por defecto para ese tráfico de red.
Siguiendo la analogía de la tubería y los peces, lo que ahora necesitamos es
interferir en el sistema de tuberías y poner un pequeño circuito que no deje
llegar los peces (paquetes) que le indiquemos.
El S.O. y la interceptación al
vuelo
Para que un paquete sea procesado por el sistema operativo, tiene que pasar
por su pila de protocolos (por regla general). En caso contrario, dicha
información no llegaría tan siquiera a Scapy.
El problema radica en que si dicha información es procesada por el SO, éste
contestará automáticamente con lo que el protocolo que proceda. Esto puede
que sea un problema para nuestras pruebas:
Imaginemos que queremos hacer un ataque de flood TCP. Tendremos que
lanzar muchos paquetes con el flag SYN activo. Cuando el sistema remoto
nos conteste con un SYN-ACK, para finalizar la conexión a 3 vías, la idea
del ataque es no contestar. De este modo, dejar la conexión entreabierta y
satura la pila del sistema remoto. El problema radica en que si nuestro
sistema operativo recibe ese paquete contestará como el protocolo TCP
indica: con un RST, puesto que él SO no ha iniciado una conexión y, por
tanto, es una intento de conexión errónea.
Para realizar este tipo de ataques tendremos entonces que interponer ciertas
medidas para que el SO no responda por nosotros.
Uso del firewall para ayudar a la
interceptación
Como medida para evitar las respuestas no deseadas por parte del sistema
operativo, el método más sencillo es poner una reglar de firewall.
El firewall funciona al nivel del sistema operativo y podrá filtrar la
entrada/salida de información, aunque esta provenga del propio SO.
En el caso comentado anteriormente, cuando el sistema operativo responde
con un paquete TCP RST, podríamos poner la regla firewall que no permita
en envío del paquete TCP tipo RST a la IP que estemos atacando.
Obviamente, casa sistema operativo es diferente y pueden disponer de
diferentes soluciones firewalls. Tendremos que poner la regla adecuada en
función del sistema operativo y firewall que estemos ejecutando en la
máquina que realizamos el ataque.
SECCIÓN 6
Logging Remoto Con Syslog Y Scapy
Introducción Syslog
Un log es una bitácora que nos permitirá registrar aquella actividad e información que deseemos, de la forma y
manera necesitemos. Todos los sistemas operativos (incluso los de los dispositivos móviles) integran algún sistema
de logging en el propio PC o dispositivo.
Cuando hablamos de logging remoto, nos estamos refiriendo a poder registrar toda la actividad en un sistema
remoto. Un sistema dedicado exclusivamente al almacenamiento y gestión de logs. De esta forma, todos los
dispositivos pueden enviar su bitácora a dicho sistema y éste les proporciona lugar centralizado donde explotar y
manejar dicha información.
Las bitácoras nos serán de gran ayuda cuando necesitamos saber qué hemos hecho y en qué momento. Esto es muy
importante de cara a poder demostrar y probar cuándo sucedió cada acción. En una auditoría de seguridad, de cara
a un cliente, esto puede ser crucial.
Syslog es un estándar de facto en los sistemas de logging, compatible con prácticamente cualquier plataforma,
sistema operativo o lenguaje de programación.
Como configurarlo para el log remoto
El sistema de logging, por defecto, maneja la bitácora usando servidor local de Syslog. Pero podemos configurarlo
para que almacene dicha información en un servidor remoto o, incluso, en ambas ubicaciones.
En Python, configurar un sistema de log remoto, es tan sencillo como indicar el IP/domino del servidor (y resto de
parámetros si los necesitara: usuario, contraseña, puerto…).
Por defecto, la mayoría de instalaciones de servidores Syslog, no requieren contraseña.
En el siguiente código se puede ver la configuración de un sistema de log remoto en código Python:
# -*- coding: utf-8 -*-
import logging
import logging.handlers
# Nivel del log
logging.basicConfig()
logger = logging.getLogger()
logger.setLevel(logging.INFO)
# CONFIGURACION DEL LOG REMOTO
syslog = logging.handlers.SysLogHandler(address=('log.mi_sitio.com', 514))
logger.addHandler(syslog)
def main():
# Level: Info
logger.info("This is a message")
# Level: Debug
logger.debug("This is a message")
# Level: Error
logger.error("This is a message")
if __name__ == '__main__':
main()
Niveles de log
El sistema de log permite guardar información en la bitácora, en función del nivel de detalle que queramos, sin
cambiar ni una línea de nuestro código.
Escribiremos nuestro código, usando el sistema de log, y mostrando la información que creamos necesaria. En
función del nivel de detalle que configuraremos globalmente en nuestra aplicación, se mostrarán unos mensajes u
otros, dejando nuestro código intacto:
def main():
# Level: Info
logger.info("This is a message")
# Level: Debug
logger.debug("This is a message")
# Level: Error
logger.error("This is a message")
Como vemos en el código, cada función corresponde con el nombre de un nivel de log (debug, info o error).
Dependiendo del nivel de log que se indique globalmente, se mostrarán unos mensajes u otros.
Cada nivel de log tiene un valor numérico asignado internamente. Cuando indicamos un nivel, todo los niveles
iguales o superiores estarán también incluidos. Sería como decirle al sistema de log: Muéstrame todos los mensajes
de log que sean, al menos, tan “importantes” como el nivel X.
Los niveles de Log, por defecto, son 5. De menor a mayor importancia:
Debug.
Info.
Warning.
Error.
Critical.
VÍDEO 3.8 - Configuración de niveles de log.
Uso en Scapy
En Scapy podemos usar el sistema de log estándar. Como hemos comentado anteriormente es recomendable hacer,
al menos, las siguientes anotaciones en el log:
Cuándo se va a realizar una prueba.
Cuándo se tiene respuesta (o falta de respuesta) de la misma.
De este modo quedará registrado cuando se ha efectuado cada prueba y cual fue el resultado de la misma:
# -*- coding: utf-8 -*-
import logging
import logging.handlers
from scapy.all import IP, TCP, sr1
# Inicializacion del log
logger = logging.getLogger(__name__)
# Nivel del log
logger.setLevel(logging.DEBUG)
# formatter = logging.Formatter('[%(levelname)s] %(message)s')
formatter = logging.Formatter('(%(asctime)s) %(message)s')
# Manejador: Salida por FICHERO de texto
log_file = logging.FileHandler(filename="scapy_log_1.2.3.7.2_3.txt")
log_file.setFormatter(formatter)
# Manejador: Salida por CONSOLA
log_console = logging.StreamHandler()
log_console.setFormatter(formatter)
# CONFIGURACION DEL LOG REMOTO
log_syslog = logging.handlers.SysLogHandler(address=('log.mi_sitio.com', 514))
log_syslog.setFormatter(formatter)
# Agregramos todos los manejadores a la configuracion del log
logger.addHandler(log_syslog)
logger.addHandler(log_console)
logger.addHandler(log_file)
OPEN_PORTS = []
def analyze_port(target, port):
logger.info(" - Analizando puerto %s" % port)
res = sr1(IP(dst=target)/TCP(dport=port, flags="S"), verbose=False,
timeout=0.2)
if res:
if res[TCP].flags == 18:
logger.info(" |_ Puerto %s Abierto" % port)
OPEN_PORTS.append(port)
else:
logger.debug(" |_ Puerto %s no abierto" % port)
def main():
logger.info("[*] Iniciando escaneo")
# Analizando los primeros 80 puertos
for x in range(70, 81):
analyze_port("192.168.1.1", x)
logger.info("[*] Escaneo finalizado")
# Mostramos resultados
logger.info("[*] Lista de puertos abiertos")
for x in OPEN_PORTS:
logger.critical(" - %s/tcp" % x)
else:
logger.critical("[!] No se han encontrado puertos abiertos")
def xmain():
# Level: Info
logger.info("This is a message")
# Level: Debug
logger.debug("This is a message")
# Level: Error
logger.error("This is a message")
if __name__ == '__main__':
main()
SECCIÓN 7
Automaton: El Autómata De Estados Finitos De Scapy
Que es el Automaton de Scapy
El automaton de Scapy es una funcionalidad poco conocida que nos permite simular modelos de estados de forma
muy sencilla.
Gracias a esta funcionalidad podremos simular pilas de protocolos completas y cada uno de los estados en el que
puede encontrarse.
Una vez hayamos definido el funcionamiento de la pila de protocolos y la respuesta ante cada tipo de situación, su
transformación a código de Python con Scapy es realmente sencilla.
Qué es un autómata
Un autómata es modelo computacional que realiza aciones de forma automática sobre una entrada para producir
una salida.
Un autómata se representa mediante estados y y transiciones:
Un estado: Representa la situación de un autómata en reposo.
Una transición: Representa la acción a tomar, en función de un determinado estímulo de entrada.
Los autómatas se suelen representar:
Como nodos: Para los estados.
Por flechas: Que interconectan los estados con la acción que los hace ir de un estado a otro, para las transiciones.
El nodo inicial: Suele tener un doble círculo.
Gracias a esta representación, es muy sencillo entender conceptualmente, incluso aunque no se sepa teoría de
autómatas y máquinas de estados.
Por ejemplo: podríamos tener un autómata, llamado coche, con 2 estados:
En movimiento.
Parado.
El estímulo para llegar a cada uno de los estados pueden ser los siguientes:
De “Parado” a “En movimiento”. Estímulo: Acelerar.
De “En movimiento” a “Parado”. Estímulo: Frenar.
Tipos de autómatas
Los autómatas están basados en teoría matemática y sus modelos de representación. Estos enfoques están fuera del
alcance de esta formación, por lo que solamente se tratarán a muy alto nivel los tipos de autómatas que existen.
Existen dos principales tipos de autómatas son:
Moore
Una autómata de Moore es un autómata de estados finitos donde las salidas están determinadas por el estado actual
únicamente y no depende directamente de la entrada.
Su representación es la siguiente:
Mealy
Un autómata de Mealy es un tipo de máquina de estados finitos que genera una salida basándose en su estado actual
y una entrada.
Esta es su presentación:
A modo de resumen, podemos concluir con que la principal diferencia entre un modelo y otro es si tienen o no en
cuenta la entrada.
Scapy no sigue ninguno de estos modelos al completo, sino que coge lo mejor de cada uno de ellos para facilitarnos
la tarea de diseño de nuestros autómatas.
Automaton: Estados y transiciones
Finalizada la teoría, entramos ya en la parte específica y más práctica. El automaton de Scapy implementa los
conceptos básicos de un autómata:
Estados.
Transiciones.
Veamos paso a paso como implementarlo:
Creación del esqueleto:
Los primero que deberemos de hacer será importar la librería que implementa el automaton de Scapy.
Crearemos una nueva clase, que será nuestro autómata, que heredará de la clase Automaton de Scapy.
# -*- coding: utf-8 -*-
from scapy.all import *
class HelloWorld(Automaton):
pass
Creación de estados:
Podremos crear un nuevo estado de nuestro autómata, definiendo un nuevo método en la clase y estableciendo el
decorador @ATMT.state.
Todo autómata ha de tener un estado inicial. Para indicar que un estado es el inicial, estableceremos la propiedad
initial al decorador. También podemos establecer que un estado es final (o sumidero) indicando la propiedad final.
Por convención, los estados iniciales y finales se les suele nombrar: BEGIN y END respectivamente, y el resto
serán nombrados en mayúsculas:
# -*- coding: utf-8 -*-
from scapy.all import *
class HelloWorld(Automaton):
@ATMT.state(initial=1) # <- Estado inicial
def BEGIN(self):
print "[e] State=BEGIN"
@ATMT.state
def STATE_N(self):
print "[e] Estate=N"
@ATMT.state(final=1) # <- Estado final
def END(self):
print "[e] State=END"
Transiciones
Un cambio de un estado viene determinado por una transición. Dicha transición se genera cuando se recibe un
estímulo de entrada.
Una transición puede iniciarse de 2 formas:
Generado manualmente.
Con condiciones de estado.
Transiciones manuales
Las transiciones manuales son iniciadas lanzando una excepción cuyo parámetro será el estado siguiente:
# -*- coding: utf-8 -*-
from scapy.all import *
class HelloWorld(Automaton):
@ATMT.state(initial=1)
def BEGIN(self):
raise self.END() # <- Transicion manual
@ATMT.state(final=1)
def END(self):
print "[e] State=END"
Transiciones por condiciones de estado
Las condiciones de un estado son formas de indicarle a Automaton cuándo debe de pasar de un estado a otro, sin
necesidad de indicarlo manualmente.
Scapy define 3 tipos de condiciones que podremos configurar definir para que se produzcan las transiciones:
Automática: se inicia justo después de que se haya alcanzado el estado al que está asociada.
Condicionada a la recepción de un paquete: es iniciada cuando, estando en el estado configurado, se recibe un
paquete de red.
Condicionada por un timeout: es iniciada cuando, estando en el estado configurado, se agota el tiempo de espera.
Una condición es tan solo un método con un decorador que indica que ha de ser tratado como una transición. Y un
parámetro que indica cual es el estado asociado a dicha condición:
# -*- coding: utf-8 -*-
from scapy.all import *
class HelloWorld(Automaton):
@ATMT.state(initial=1)
def BEGIN(self):
print "[e] State=BEGIN"
@ATMT.receive_condition(BEGIN)
def begin_receive(self, pkt):
print " |c::r => BEGIN -> STATE_2> Recibido paquete."
raise self.STATE_2()
@ATMT.timeout(BEGIN, 15)
def begin_timeout(self):
print " |c::t => BEGIN -> END> Timeout recibido!"
raise self.END()
@ATMT.state()
def STATE_2(self):
print "[e] State=STATE 2"
@ATMT.condition(STATE_2)
def state_2_wait_for_nothing(self):
print " |c::c => STATE_2 -> END> recibido paquete."
raise self.END()
@ATMT.action(state_2_wait_for_nothing) # <- Accion
def on_state2_nothing(self):
print " |a => STAT2_2 {on_state2_nothing}-> END}> Accion de condicion
2 - wait for nothing"
@ATMT.state(final=1)
def END(self):
print "[e] State=END"
En el ejemplo hemos creado el siguiente autómata:
Acciones
Por último, tan solo nos queda tratar las llamadas acciones en Automaton. Éstas son ejecutadas justo después de
que una condición finalice y antes de que se alcance el siguiente estado. Dicha acción, se configura mediante un
decorador:
# -*- coding: utf-8 -*-
from scapy.all import *
class HelloWorld(Automaton):
def master_filter(self, pkt):
return True if ICMP in pkt else False
@ATMT.state(initial=True)
def BEGIN(self):
print "[e] State=BEGIN"
@ATMT.receive_condition(BEGIN, prio=1)
def begin_receive(self, pkt):
print " |c::r => BEGIN -> STATE_2> Recibido paquete."
raise self.STATE_2()
@ATMT.timeout(BEGIN, 15)
def begin_timeout(self):
print " |c::t => BEGIN -> END> Timeout recibido!"
raise self.END()
@ATMT.state()
def STATE_2(self):
print "[e] State=STATE 2"
@ATMT.condition(STATE_2)
def state_2_wait_for_nothing(self):
print " |c::c => STATE_2 -> END> recibido paquete."
raise self.END()
@ATMT.action(state_2_wait_for_nothing)
def on_state2_nothing(self):
print " |a => STAT2_2 {on_state2_nothing}-> END}> state 2 wait for
nothing"
@ATMT.state(final=1)
def END(self):
print "[e] State=END"
Con lo que nos quedaría una representación final del autómata como sigue:
Ejecución de un automaton
Una vez tenemos creado y bien definido nuestro autómata en Scapy, la ejecución es realmente sencilla. Tan solo
tendremos que llamar al método run(…) para comience a ejecutarse:
def main():
HelloWorld().run()
if __name__ == '__main__':
main()
Se puede ver su funcionamiento en el siguiente video:
Í
VÍDEO 3.9 - Ejecución del Automaton completo.
Automaton: Creación de un servidor DNS
El Automaton de Scapy puede ayudarnos a resolver muchos problemas y situaciones que otro caso serían realmente
complicadas. Ejemplo de ello son las implementaciones que existen por internet de diversos protocolos y servicios
utilizando este modelo.
DNScapy (https://code.google.com/p/dnscapy/) es uno de estos casos. Éste proyecto implementa un servidor y
cliente DNS usando el Automaton de Scapy.
Una vez explicado y entendido el funcionamiento de autómatas, Scapy y su Automaton, nos resultará realmente
sencillo entender su funcionamiento y el código.
El siguiente código es parte del proyecto. En concreto la parte del servidor DNS:
#!/usr/bin/env python2
#-*- coding:utf-8 -*-
### LICENCE ###
# This file is part of DNScapy.
# DNScapy is a free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# DNScapy is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
the
# GNU General Public License for more details: <http://www.gnu.org/licenses/>
### ABOUT DNScapy ###
# DNScapy creates a SSH tunnel through DNS packets
# SSH connection, SCP and proxy socks (SSH -D) are supported
# See http://code.google.com/p/dnscapy/ for more informations
# Copyright (C) Pierre Bienaimé <pbienaim@gmail.com>
# and Pascal Mazon <pascal.mazon@gmail.com>
# DNScapy uses Scapy, wrote by Philippe Biondi <phil@secdev.org>
### DISCLAIMER ###
# We are not responsible for misuse of DNScapy
# Making a DNS tunnel to bypass a security policy may be forbidden
# Do it at your own risks
from scapy.all import IP, UDP, DNS, DNSQR, DNSRR, Raw, send, Automaton,
ATMT, StreamSocket, log_interactive #, txtfy
from random import randint
from threading import Thread
from optparse import OptionParser
from base64 import b64encode, b64decode
import socket, sys
CNAME = 5
TXT = 16
_CON = "a"
_ACK = "b"
_IWT = "c"
_DATA = "d"
_DONE = "e"
_FAST = "f"
class Core(Automaton):
dn = ""
def parse_qname(self, pkt):
return pkt[DNSQR].qname.rsplit(self.dn, 1)[0].split(".")
def master_filter(self, pkt):
return ((self.state.state == "WAITING" or
self.state.state == "DATA_RECEPTION") and
IP in pkt and UDP in pkt and
pkt[UDP].dport == 53 and DNS in pkt and
pkt[DNS].qr == 0 and DNSQR in pkt and
pkt[DNSQR].qname.endswith(self.dn + "."))
def forge_packet(self, pkt, rdata="", rcode=0):
d = pkt[IP].src
dp = pkt[UDP].sport
id = pkt[DNS].id
q = pkt[DNS].qd
t = pkt[DNSQR].qtype
if t == TXT:
# if scapy is patched:
# rdata = txtfy(rdata)
for i in range(0, len(rdata), 0xff+1):
rdata = rdata[:i] + chr(len(rdata[i:i+0xff])) + rdata[i:]
an = (None, DNSRR(rrname=self.dn, type=t, rdata=rdata, ttl=60))[rcode ==
0]
ns = DNSRR(rrname=self.dn, type="NS", ttl=3600, rdata="ns."+self.dn)
return IP(dst=d)/UDP(dport=dp)/DNS(id=id, qr=1, rd=1, ra=1, rcode=rcode,
qd=q, an=an, ns=ns)
class Parent(Core):
def parse_args(self, dn, ext_ip, debug=0, nb_clients=10, ssh_p=22):
self.dn = dn
self.ext_ip = ext_ip
self.dbg = debug
self.nb_clients = nb_clients
self.ssh_p = ssh_p
bpf = "udp port 53"
Automaton.parse_args(self, filter=bpf, debug=debug)
def master_filter(self, pkt):
if Core.master_filter(self, pkt) and pkt[IP].src != self.ext_ip:
self.qname = Core.parse_qname(self, pkt)
return len(self.qname) >= 2
else:
return False
def get_identifier(self):
if len(self.empty_slots) >= 1:
return self.empty_slots.pop()
elif self.kill_children() >= 1:
return self.empty_slots.pop()
else:
return None
def kill_children(self):
for k in self.childs.keys():
if self.childs[k].state.state == "END":
self.childs[k].stop()
del(self.childs[k])
self.empty_slots.add(k)
return len(self.empty_slots)
@ATMT.state(initial=True)
def START(self):
self.childs = {}
self.empty_slots = set(range(1, self.nb_clients+1))
raise self.WAITING()
@ATMT.state()
def WAITING(self):
pass
@ATMT.receive_condition(WAITING)
def true_dns_request(self, pkt):
if not self.qname[-2].isdigit():
qtype = pkt[DNSQR].sprintf("%qtype%")
raise self.WAITING().action_parameters(pkt, qtype)
@ATMT.action(true_dns_request)
def true_dns_reply(self, pkt, qtype):
if qtype == "A":
reply = Core.forge_packet(self, pkt, rdata=self.ext_ip)
elif qtype == "SOA":
reply = Core.forge_packet(self, pkt, rdata="ns.{0} root.{0} {1} 28800
14400 3600000 0".format(self.dn, randint(1, 65535)))
elif qtype == "NS":
reply = Core.forge_packet(self, pkt, rdata="ns."+self.dn)
elif qtype == "MX":
reply = Core.forge_packet(self, pkt, rdata="mail."+self.dn)
elif qtype == "CNAME" or qtype == "TXT":
reply = Core.forge_packet(self, pkt, rcode=3)
elif qtype == "AAAA" or qtype == "NULL":
reply = Core.forge_packet(self, pkt, rcode=4)
else:
reply = Core.forge_packet(self, pkt, rcode=2)
send(reply, verbose=0)
@ATMT.receive_condition(WAITING)
def connection_request(self, pkt):
if len(self.qname) >=3 and self.qname[-3] == _CON:
raise self.WAITING().action_parameters(pkt)
@ATMT.action(connection_request)
def childbirth(self, pkt):
i = self.get_identifier()
if i is not None:
thread = Child(self.dn, i, pkt, self.dbg, self.ssh_p)
self.childs[i] = thread
thread.runbg()
class Child(Core):
def parse_args(self, dn, con_id, first_pkt, dbg=0, ssh_p=22):
self.dn = dn
self.con_id = str(con_id)
self.first_pkt = first_pkt
self.ssh_p = ssh_p
Automaton.parse_args(self, debug=dbg)
def master_filter(self, pkt):
if (Core.master_filter(self, pkt) and pkt[IP].src == self.ip_client):
qname = Core.parse_qname(self, pkt)
if len(qname) >= 4:
if qname[-2].isdigit() and qname[-3] == self.con_id:
self.msg_type = qname[-4]
if len(qname) == 4 and self.msg_type in [_IWT]:
return True
if len(qname) > 4 and self.msg_type in [_ACK, _DATA, _FAST,
_DONE]:
self.arg = qname[-5]
self.payload = qname[:-5]
return True
return False
def calculate_limit_size(self, pkt):
s = self.pkt_max_size - len(pkt[DNS]) - 2*len(DNSRR()) - 3*len(self.dn) -
len("ns.") - 10
if pkt[DNSQR].qtype == TXT:
max_size = 512
s -= len(str(s))
else:
max_size = self.qname_max_size
return min((s, 1)[s<1], max_size)
def fragment_data(self, data, limit_size, qtype):
if qtype == CNAME:
qname = []
rest = data
while len(rest) > 0:
d = rest[:limit_size]
qname.append('.'.join([d[i:i+self.label_size] for i in range(0, len(d),
self.label_size)]))
rest = rest[limit_size:]
elif qtype == TXT:
qname = [data[i:i+limit_size] for i in range(0, len(data), limit_size)]
return qname
def compress(self, l):
""" [1,2,4,12,7,11,3,14,13] => '1-4.7.11-14' """
l.sort()
temp = [[l[0]]]
result = []
j = 0
for i in range(1,len(l)):
if l[i] == l[i-1]+1:
temp[j] += [l[i]]
else:
temp.append([l[i]])
j += 1
for r in temp:
if len(r) > 1:
result.append("{0}-{1}".format(r[0],r[-1]))
else:
result.append(str(r[0]))
return ".".join(result)
@ATMT.state(initial=True)
def START(self):
self.label_size = 63
self.qname_max_size = 253
self.pkt_max_size = 512
self.recv_data = {}
self.ip_client = self.first_pkt[IP].src
self.is_first_wyw_pkt = True
self.iwt_pkt = None
raise self.TICKLING()
@ATMT.state()
def TICKLING(self):
s = socket.socket()
s.connect(("127.0.0.1", self.ssh_p))
self.stream = StreamSocket(s, Raw)
ssh_msg = self.stream.recv()
raise self.CON(ssh_msg.load)
@ATMT.state()
def CON(self, ssh_msg):
if ssh_msg == "":
raise self.TICKLING()
s = self.calculate_limit_size(self.first_pkt)
qtype = self.first_pkt[DNSQR].qtype
self.frag_reply = self.fragment_data(b64encode(ssh_msg), s, qtype)
if len(self.frag_reply) == 1:
pkt = Core.forge_packet(self, self.first_pkt, "{0}.{1}.0.{2}".format(_CON,
self.con_id, self.frag_reply[0]))
else:
pkt = Core.forge_packet(self, self.first_pkt, "{0}.{1}.{2}".format(_CON,
self.con_id, str(len(self.frag_reply)-1)))
send(pkt, verbose=0)
raise self.WAITING()
@ATMT.state()
def WAITING(self):
pass
@ATMT.timeout(WAITING, 600)
def timeout_reached(self):
raise self.END()
@ATMT.receive_condition(WAITING)
def data_pkt(self, pkt):
if self.msg_type in [_ACK, _FAST]:
pkt_nb = self.arg
if pkt_nb.isdigit():
raise self.DATA_RECEPTION(pkt, int(pkt_nb))
@ATMT.receive_condition(WAITING)
def iwt_pkt(self, pkt):
if self.msg_type == _IWT:
raise self.IWT(pkt)
@ATMT.receive_condition(WAITING)
def ttm_pkt(self, pkt):
if self.msg_type == _DATA:
asked_pkt = self.arg
if asked_pkt.isdigit():
raise self.DATA_EMISSION(pkt, int(asked_pkt))
@ATMT.receive_condition(WAITING)
def done_pkt(self, pkt):
if self.msg_type == _DONE:
code = self.arg
if code == _ACK or code == _DATA:
raise self.DONE(pkt, code)
@ATMT.state()
def DATA_RECEPTION(self, pkt, pkt_nb):
if not self.recv_data.has_key(pkt_nb):
self.recv_data[pkt_nb] = "".join(self.payload)
if self.msg_type == _ACK:
ack_pkt = Core.forge_packet(self, pkt, "{0}.{1}".format(_ACK, pkt_nb))
send(ack_pkt, verbose=0)
raise self.WAITING()
elif self.msg_type == _FAST:
self.fast_pkt = pkt
self.to_ack = [pkt_nb]
@ATMT.receive_condition(DATA_RECEPTION)
def got_data(self, pkt):
if self.msg_type == _FAST:
if self.arg.isdigit():
self.fast_pkt = pkt
pkt_nb = int(self.arg)
if not self.recv_data.has_key(pkt_nb):
self.recv_data[pkt_nb] = "".join(self.payload)
if pkt_nb not in self.to_ack:
self.to_ack.append(pkt_nb)
@ATMT.timeout(DATA_RECEPTION, 0.5)
def ack(self):
#TODO check the limit size
l = self.compress(self.to_ack)
ack_pkt = Core.forge_packet(self, self.fast_pkt, "{0}.{1}".format(_FAST, l))
send(ack_pkt, verbose=0)
raise self.WAITING()
@ATMT.state()
def IWT(self, pkt):
"""IWT (I Want This) state of the Child automaton.
After receiving a WYW (What You Want) pkt from the client, the server
says how many DNS pkts he needs to send the reply
"""
if self.iwt_pkt is not None:
send(self.iwt_pkt, verbose=0)
else:
ssh_reply = self.stream.sniff(count=1, timeout=0.1)
iwt_pkt = Core.forge_packet(self, pkt, _DONE)
if len(ssh_reply) > 0:
qtype = pkt[DNSQR].qtype
s = self.calculate_limit_size(pkt)
self.frag_reply = self.fragment_data(b64encode(ssh_reply[0].load), s,
qtype)
self.iwt_pkt = Core.forge_packet(self, pkt,"{0}.{1}".format(_IWT,
str(len(self.frag_reply))))
iwt_pkt = self.iwt_pkt
send(iwt_pkt, verbose=0)
raise self.WAITING()
@ATMT.state()
def DATA_EMISSION(self, pkt, asked_pkt):
if asked_pkt <= len(self.frag_reply):
data_pkt = Core.forge_packet(self, pkt, "{0}.{1}.{2}".format(_DATA,
str(asked_pkt), self.frag_reply[-(asked_pkt+1)]))
send(data_pkt, verbose=0)
raise self.WAITING()
@ATMT.state()
def DONE(self, pkt, code):
if code == _ACK:
if self.recv_data.keys() == range(0,len(self.recv_data)):
d = "".join(self.recv_data.values())
ssh_request = Raw(b64decode(d))
self.stream.send(ssh_request)
self.recv_data.clear()
send(Core.forge_packet(self, pkt, _DONE), verbose=0)
elif code == _DATA:
self.iwt_pkt = None
send(Core.forge_packet(self, pkt, _DONE), verbose=0)
raise self.WAITING()
@ATMT.state(final=True)
def END(self):
pass
if __name__ == "__main__":
v = "%prog 0.99b - 2011"
u = "usage: %prog [options] DOMAIN_NAME EXTERNAL_IP [options]"
parser = OptionParser(usage=u, version=v)
parser.add_option("-g", "--graph", dest="graph", action="store_true",
help="Generate the graph of the automaton, save it to /tmp and exit. You will need
some extra packages. Refer to www.secdev.org/projects/scapy/portability.html. In
short: apt-get install graphviz imagemagick python-gnuplot python-pyx",
default=False)
parser.add_option("-d", "--debug-lvl", dest="debug", type="int", help="Set the
debug level, where D is an integer between 0 (quiet) and 5 (very verbose). Default
is 0", metavar="D", default=0)
parser.add_option("-p", "--ssh-port", dest="port", type="int", help="P is the
listening port of your SSH server. Default is 22.", metavar="P", default=22)
parser.add_option("-c", "--clients", dest="nb_clients", type="int", help="C is the
max number of simultaneous clients your server will handle with. Max is 1000.
Default is 10.", metavar="C", default=10)
(opt, args) = parser.parse_args()
if opt.graph:
Parent.graph(target="> /tmp/dnscapy_server_parent.pdf")
Child.graph(target="> /tmp/dnscapy_server_child.pdf")
sys.exit(0)
if opt.nb_clients > 1000:
parser.error("the max number of simultaneous clients is 1000")
if len(args) != 2:
parser.error("incorrect number of arguments. Please give the domain name to
use and the external IP address of the server")
dn = args[0]
ext_ip = args[1]
log_interactive.setLevel(1)
dnscapy = Parent(dn, ext_ip, debug=opt.debug, nb_clients=opt.nb_clients,
ssh_p=opt.port)
dnscapy.run()
TShark
TShark es la versión del linea de comandos del sniffer y analizador de protocolos Wireshark.
Ettercap
Ettercap es un interceptor/sniffer/registrador para LANs con switch. Soporta direcciones
activas y pasivas de varios protocolos (incluso aquellos cifrados, como SSH y HTTPS).
También hace posible la inyección de datos en una conexión establecida y filtrado al vuelo aun
manteniendo la conexión sincronizada gracias a su poder para establecer un Ataque Man-in-
the-middle(Spoofing).
Web del proyecto: https://ettercap.github.io/ettercap/
Fuente: Wikipedia
Snort
Snort es un sniffer de paquetes y un detector de intrusos basado en red (se monitoriza todo un
dominio de colisión). Es un software muy flexible que ofrece capacidades de almacenamiento
de sus bitácoras (logs) tanto en archivos de texto como en bases de datos abiertas, como lo es
MySQL.
Implementa un motor de detección de ataques y barridos de puertos que permite registrar,
alertar y responder ante cualquier anomalía previamente definida.
Web del proyecto: https://www.snort.org
Fuente: Wikipedia
Dsniff
Dsniff es una colección de herramientas de auditoría de red y pruebas de penetración.: dsniff,
filesnarf, mailsnarf, msgsnarf, urlsnarf y WebSpy.
WebSpy: Permiten monitorizar pasivamente una red de datos de interés (contraseñas,
correo electrónico, archivos, etc.).
arpspoof, dnsspoof y macof: facilitan la interceptación del tráfico de red que
normalmente no está disponible para un atacante (por ejemplo, debido a la capa 2 de
conmutación).
sshmitm y webmitm: implementan ataques activos de MITM (Man In The Middle)
contra SSH redirigida y HTTPS sesiones explotando atascamientos débiles en ad-hoc
PKI.
Web del proyecto: http://www.monkey.org/~dugsong/dsniff/
Guido Van Rossum
Guido van Rossum es un científico de la computación, conocido por ser el autor del lenguaje
de programación Python. Nació y creció en los Países Bajos.
En el ambiente de los desarrolladores del lenguaje Python también se le conoce por el título
BDFL ("Benevolent Dictator for Life'"), teniendo asignada la tarea de fijar las directrices sobre
la evolución de Python, así como la de tomar decisiones finales sobre el lenguaje que todos los
desarrolladores acatan. Van Rossum tiene fama de ser bastante conservador, realizando pocos
cambios al lenguaje entre versiones sucesivas, intentando mantener siempre la compatibilidad
con versiones anteriores.
Fuente: Wikipedia
PEP
El desarrollo de Python se lleva a cabo en gran medida usando los Python Enhancement
Proposal (PEP). Los PEP son el principal mecanismo para proponer nuevas e importantes
funciones, para la recogida de información de la comunidad sobre un tema, y para documentar
las decisiones de diseño que han entrado en Python. Los PEP pendientes son revisados y
comentados por la comunidad Python y por Van Rossum.
Índice de PEP: https://www.python.org/dev/peps/
Fuente: Wikipedia
127.0.0.1
En el contexto de redes TCP/IP, localhost es una dirección reservada que hace referencia al
propio dispositivo o computadora. El nombre localhost es traducido como la dirección IP de
loopback 127.0.0.1 en IPv4.
Capa 1
La capa 1 es la primera capa del Modelo OSI. Es la que se encarga de la topología de red y de
las conexiones globales de la computadora hacia la red, se refiere tanto al medio físico como a
la forma en la que se transmite la información.
Fuente: Wikipedia
Capa 2
En el modelo OSI, esta capa se ocupa del direccionamiento físico, del acceso al medio, de la
detección de errores, de la distribución ordenada de tramas y del control del flujo. Es uno de
los aspectos más importantes que revisar en el momento de conectar dos ordenadores, ya que
está entre la capa 1 y 3 como parte esencial para la creación de sus protocolos básicos (MAC,
IP).
En el modelo TCP/IP, esta es la capa de internet: Internet, semejante a la capa 3 (red) del
modelo OSI.
Fuente: Wikipedia
Capa 7
En modelo OSI, la capa 7 ofrece a las aplicaciones la posibilidad de acceder a los servicios de
las demás capas y define los protocolos que utilizan las aplicaciones para intercambiar datos,
como correo electrónico (Post Office Protocol y SMTP), gestores de bases de datos y servidor
de ficheros (FTP), por UDP pueden viajar (DNS y Routing Information Protocol). Hay tantos
protocolos como aplicaciones distintas y puesto que continuamente se desarrollan nuevas
aplicaciones el número de protocolos crece sin parar.
Fuente: Wikipedia
DARPA
La Agencia de Proyectos de Investigación Avanzados de Defensa, más conocida por su
acrónimo DARPA, proveniente de su nombre original en inglés Defense Advanced Research
Projects Agency, es una agencia del Departamento de Defensa de Estados Unidos responsable
del desarrollo de nuevas tecnologías para uso militar. Fue creada en 1958 como consecuencia
tecnológica de la llamada Guerra Fría, y del que surgieron, década después, los fundamentos
de ARPANET, red que dio origen a Internet.
Fuente: Wikipedia
Debugger
Un depurador (en inglés, debugger), es un programa usado para probar y depurar (eliminar) los
errores de otros programas (el programa "objetivo"). El código a ser examinado puede
alternativamente estar corriendo en un simulador de conjunto de instrucciones (ISS), una
técnica que permite gran potencia en su capacidad de detenerse cuando son encontradas
condiciones específicas pero será típicamente algo más lento que ejecutando el código
directamente en el apropiado (o el mismo) procesador.
Fuente: Wikipedia
DoD
El Departamento de Defensa de Estados Unidos (del inglés: United States Department of
Defense - DoD) es un departamento del brazo ejecutivo del gobierno federal de Estados Unidos
encargado de coordinar y supervisar todas las agencias y funciones del gobierno relacionadas
directamente con la seguridad nacional y las Fuerzas Armadas de los Estados Unidos.
Fuente: Wikipedia
GNUPlot
Gnuplot es un programa muy flexible para generar gráficas de funciones y datos.
Gnuplot puede producir sus resultados directamente en pantalla, así como en multitud de
formatos de imagen, como PNG, EPS, SVG, JPEG, etc. Se puede usar interactivamente o en
modo por lotes (batch), usando scripts. Este programa tiene gran base de usuarios y está
convenientemente mantenido por sus desarrolladores. Existe una ingente cantidad de ayuda en
Internet, aunque gran parte está en inglés.
Web del proyecto: http://www.gnuplot.info
Fuente: Wikipedia
Localhost
En el contexto de redes TCP/IP, localhost es una dirección reservada que hace referencia al
propio dispositivo o computadora.
Locate
locate es un comando del paquete findutils de GNU que provee una fácil y rápida manera de
buscar archivos en el sistema completo basado en patrones de nombres.
El comando es mucho más rápido (aunque menos flexible) que find, pues utiliza los datos en
una base de datos temporal que almacena los nombres de todos los archivos en el sistema, por
lo que también se pueden experimentar fallas al buscar un archivo creado recientemente.
Man online: http://man7.org/linux/man-pages/man1/locate.1.html
Fuente: Wikipedia
Syslog
Syslog es un estándar de facto para el envío de mensajes de registro en una red informática IP.
Por syslog se conoce tanto al protocolo de red como a la aplicación o biblioteca que envía los
mensajes de registro.
Fuente: Wikipedia
TCPDump
Tcpdump es un herramienta en línea de comandos cuya utilidad principal es analizar el tráfico
que circula por la red.
Permite al usuario capturar y mostrar a tiempo real los paquetes transmitidos y recibidos en la
red a la cual el ordenador está conectado.
Fuente: Wikipedia
Verbose
El término verbose hace referencia al nivel de información de depuración que un software
mostrará por los canales destinados a ello, normalmente la linea de comandos o el log del
sistema.
VLAN
Una VLAN, acrónimo de virtual LAN (red de área local virtual), es un método para crear
redes lógicas independientes dentro de una misma red física
Fuente: Wikipedia
Wrapper
En computación, un wrapper hace referencia a la encapsulación de la complejidad de una
funcionalidad, tratando de hacerla más simple para su uso.
CLI
La interfaz de línea de comandos, traducción del inglés command-line interface o CLI es un
método que permite a los usuarios dar instrucciones a algún programa informático por medio
de una línea de texto simple.
Fuente: Wikipedia
TShark
TShark es la versión del linea de comandos del sniffer
y analizador de protocolos Wireshark.
Términos del glosario relacionados
Dsniff, Snort, TCPDump
Índice
Capítulo 2 - Lectura de ficheros PCAP
Ettercap
Ettercap es un interceptor/sniffer/registrador para LANs con switch.
Soporta direcciones activas y pasivas de varios protocolos (incluso
aquellos cifrados, como SSH y HTTPS).
También hace posible la inyección de datos en una conexión
establecida y filtrado al vuelo aun manteniendo la conexión
sincronizada gracias a su poder para establecer un Ataque Man-in-the-
middle(Spoofing).
Web del proyecto: https://ettercap.github.io/ettercap/
Fuente: Wikipedia
Términos del glosario relacionados
Dsniff
Índice
Capítulo 2 - Lectura de ficheros PCAP
Snort
Snort es un sniffer de paquetes y un detector de intrusos basado en red
(se monitoriza todo un dominio de colisión). Es un software muy
flexible que ofrece capacidades de almacenamiento de sus bitácoras
(logs) tanto en archivos de texto como en bases de datos abiertas, como
lo es MySQL.
Implementa un motor de detección de ataques y barridos de puertos
que permite registrar, alertar y responder ante cualquier anomalía
previamente definida.
Web del proyecto: https://www.snort.org
Fuente: Wikipedia
Términos del glosario relacionados
TCPDump, TShark
Índice
Capítulo 2 - Lectura de ficheros PCAP
Dsniff
Dsniff es una colección de herramientas de auditoría de red y pruebas
de penetración.: dsniff, filesnarf, mailsnarf, msgsnarf, urlsnarf y
WebSpy.
WebSpy: Permiten monitorizar pasivamente una red de datos de interés
(contraseñas, correo electrónico, archivos, etc.).
arpspoof, dnsspoof y macof: facilitan la interceptación del tráfico de
red que normalmente no está disponible para un atacante (por ejemplo,
debido a la capa 2 de conmutación).
sshmitm y webmitm: implementan ataques activos de MITM (Man In
The Middle) contra SSH redirigida y HTTPS sesiones explotando
atascamientos débiles en ad-hoc PKI.
Web del proyecto: http://www.monkey.org/~dugsong/dsniff/
Términos del glosario relacionados
Ettercap, TCPDump, TShark
Índice
Capítulo 2 - Lectura de ficheros PCAP
Guido Van Rossum
Guido van Rossum es un científico de la computación, conocido por
ser el autor del lenguaje de programación Python. Nació y creció en los
Países Bajos.
En el ambiente de los desarrolladores del lenguaje Python también se
le conoce por el título BDFL ("Benevolent Dictator for Life'"),
teniendo asignada la tarea de fijar las directrices sobre la evolución de
Python, así como la de tomar decisiones finales sobre el lenguaje que
todos los desarrolladores acatan. Van Rossum tiene fama de ser
bastante conservador, realizando pocos cambios al lenguaje entre
versiones sucesivas, intentando mantener siempre la compatibilidad
con versiones anteriores.
Fuente: Wikipedia
Términos del glosario relacionados
PEP
Índice
Capítulo 3 - Scapy y Multithreading
PEP
El desarrollo de Python se lleva a cabo en gran medida usando los
Python Enhancement Proposal (PEP). Los PEP son el principal
mecanismo para proponer nuevas e importantes funciones, para la
recogida de información de la comunidad sobre un tema, y para
documentar las decisiones de diseño que han entrado en Python. Los
PEP pendientes son revisados y comentados por la comunidad Python
y por Van Rossum.
Índice de PEP: https://www.python.org/dev/peps/
Fuente: Wikipedia
Términos del glosario relacionados
Guido Van Rossum
Índice
Capítulo 3 - Scapy y Multithreading
127.0.0.1
En el contexto de redes TCP/IP, localhost es una
dirección reservada que hace referencia al propio
dispositivo o computadora. El nombre localhost es
traducido como la dirección IP de loopback 127.0.0.1
en IPv4.
Términos del glosario relacionados
Localhost
Índice
Capítulo 1 - Construcción de paquete básico
Capa 1
La capa 1 es la primera capa del Modelo OSI. Es la que se encarga de
la topología de red y de las conexiones globales de la computadora
hacia la red, se refiere tanto al medio físico como a la forma en la que
se transmite la información.
Fuente: Wikipedia
Términos del glosario relacionados
Capa 2, Capa 7
Índice
Capítulo 1 - Construcción de paquete básico
Capa 2
En el modelo OSI, esta capa se ocupa del direccionamiento físico, del
acceso al medio, de la detección de errores, de la distribución ordenada
de tramas y del control del flujo. Es uno de los aspectos más
importantes que revisar en el momento de conectar dos ordenadores, ya
que está entre la capa 1 y 3 como parte esencial para la creación de sus
protocolos básicos (MAC, IP).
En el modelo TCP/IP, esta es la capa de internet: Internet, semejante a
la capa 3 (red) del modelo OSI.
Fuente: Wikipedia
Términos del glosario relacionados
Capa 1, Capa 7
Índice
Capítulo 1 - Construcción de paquete básico
Capa 7
En modelo OSI, la capa 7 ofrece a las aplicaciones la posibilidad de
acceder a los servicios de las demás capas y define los protocolos que
utilizan las aplicaciones para intercambiar datos, como correo
electrónico (Post Office Protocol y SMTP), gestores de bases de datos y
servidor de ficheros (FTP), por UDP pueden viajar (DNS y Routing
Information Protocol). Hay tantos protocolos como aplicaciones
distintas y puesto que continuamente se desarrollan nuevas
aplicaciones el número de protocolos crece sin parar.
Fuente: Wikipedia
Términos del glosario relacionados
Capa 1, Capa 2
Índice
Capítulo 2 - Pila TCP/IP Y Layers en Scapy
DARPA
La Agencia de Proyectos de Investigación Avanzados de Defensa,
más conocida por su acrónimo DARPA, proveniente de su nombre
original en inglés Defense Advanced Research Projects Agency, es una
agencia del Departamento de Defensa de Estados Unidos responsable
del desarrollo de nuevas tecnologías para uso militar. Fue creada en
1958 como consecuencia tecnológica de la llamada Guerra Fría, y del
que surgieron, década después, los fundamentos de ARPANET, red que
dio origen a Internet.
Fuente: Wikipedia
Términos del glosario relacionados
DoD
Índice
Capítulo 2 - Pila TCP/IP Y Layers en Scapy
Debugger
Un depurador (en inglés, debugger), es un programa usado para probar
y depurar (eliminar) los errores de otros programas (el programa
"objetivo"). El código a ser examinado puede alternativamente estar
corriendo en un simulador de conjunto de instrucciones (ISS), una
técnica que permite gran potencia en su capacidad de detenerse cuando
son encontradas condiciones específicas pero será típicamente algo más
lento que ejecutando el código directamente en el apropiado (o el
mismo) procesador.
Fuente: Wikipedia
Índice
Capítulo 1 - Construcción de paquete básico
DoD
El Departamento de Defensa de Estados Unidos (del inglés: United
States Department of Defense - DoD) es un departamento del brazo
ejecutivo del gobierno federal de Estados Unidos encargado de
coordinar y supervisar todas las agencias y funciones del gobierno
relacionadas directamente con la seguridad nacional y las Fuerzas
Armadas de los Estados Unidos.
Fuente: Wikipedia
Términos del glosario relacionados
DARPA
Índice
Capítulo 2 - Pila TCP/IP Y Layers en Scapy
GNUPlot
Gnuplot es un programa muy flexible para generar gráficas de
funciones y datos.
Gnuplot puede producir sus resultados directamente en pantalla, así
como en multitud de formatos de imagen, como PNG, EPS, SVG,
JPEG, etc. Se puede usar interactivamente o en modo por lotes (batch),
usando scripts. Este programa tiene gran base de usuarios y está
convenientemente mantenido por sus desarrolladores. Existe una
ingente cantidad de ayuda en Internet, aunque gran parte está en inglés.
Web del proyecto: http://www.gnuplot.info
Fuente: Wikipedia
Índice
Capítulo 1 - ¿Qué es Scapy?
Localhost
En el contexto de redes TCP/IP, localhost es una
dirección reservada que hace referencia al propio
dispositivo o computadora.
Términos del glosario relacionados
127.0.0.1
Índice
Capítulo 2 - Parámetros de los layers
Locate
locate es un comando del paquete findutils de GNU que provee una
fácil y rápida manera de buscar archivos en el sistema completo basado
en patrones de nombres.
El comando es mucho más rápido (aunque menos flexible) que find,
pues utiliza los datos en una base de datos temporal que almacena los
nombres de todos los archivos en el sistema, por lo que también se
pueden experimentar fallas al buscar un archivo creado recientemente.
Man online: http://man7.org/linux/man-pages/man1/locate.1.html
Fuente: Wikipedia
Índice
Capítulo 2 - Creación de un nuevo layer
Syslog
Syslog es un estándar de facto para el envío de mensajes de registro en
una red informática IP. Por syslog se conoce tanto al protocolo de red
como a la aplicación o biblioteca que envía los mensajes de registro.
Fuente: Wikipedia
Índice
Capítulo 3 - Logging remoto con syslog y scapy
TCPDump
Tcpdump es un herramienta en línea de comandos cuya utilidad
principal es analizar el tráfico que circula por la red.
Permite al usuario capturar y mostrar a tiempo real los paquetes
transmitidos y recibidos en la red a la cual el ordenador está conectado.
Fuente: Wikipedia
Términos del glosario relacionados
Dsniff, Snort, TShark
Índice
Capítulo 1 - ¿Qué es Scapy?
Verbose
El término verbose hace referencia al nivel de
información de depuración que un software mostrará
por los canales destinados a ello, normalmente la linea
de comandos o el log del sistema.
Índice
Capítulo 2 - Modos de Envío
VLAN
Una VLAN, acrónimo de virtual LAN (red de área local virtual), es un
método para crear redes lógicas independientes dentro de una misma
red física
Fuente: Wikipedia
Índice
Capítulo 2 - Layers más usados
Wrapper
En computación, un wrapper hace referencia a la
encapsulación de la complejidad de una funcionalidad,
tratando de hacerla más simple para su uso.
Índice
Capítulo 1 - El modo interactivo
CLI
La interfaz de línea de comandos, traducción del inglés command-line
interface o CLI es un método que permite a los usuarios dar
instrucciones a algún programa informático por medio de una línea de
texto simple.
Fuente: Wikipedia
Índice
Capítulo 1 - ¿Qué es Scapy?
También podría gustarte
- ScapyDocumento154 páginasScapygeniusjoa50% (2)
- ScapyDocumento1 páginaScapyJohanna MeraAún no hay calificaciones
- 2 Manipulación Avanzada de Paquetes TCP IP PDFDocumento15 páginas2 Manipulación Avanzada de Paquetes TCP IP PDFAlexander LeguizamoAún no hay calificaciones
- Hack X Crack ScapyDocumento15 páginasHack X Crack Scapyrugal13100% (1)
- Brayan Andrade - Maltego, Nmap, SpartaDocumento12 páginasBrayan Andrade - Maltego, Nmap, SpartabrayanAún no hay calificaciones
- Ip TablesDocumento8 páginasIp TablesSebastian SanchezAún no hay calificaciones
- Cómo Instalar Python AnacondaDocumento9 páginasCómo Instalar Python AnacondaYoAún no hay calificaciones
- Herramienta de Pentest ScapyDocumento9 páginasHerramienta de Pentest ScapyDaniela PavónAún no hay calificaciones
- Practica IptablesDocumento7 páginasPractica Iptableseco_solidAún no hay calificaciones
- Cap 1Documento6 páginasCap 1Johan NikoAún no hay calificaciones
- Prueba Práctica Grupal EIE855 2023s2Documento42 páginasPrueba Práctica Grupal EIE855 2023s2Joshua Leiva MuñozAún no hay calificaciones
- Software de Simulacion de RedesDocumento15 páginasSoftware de Simulacion de RedesLuis RoldanAún no hay calificaciones
- Software de Simulacion de RedesDocumento12 páginasSoftware de Simulacion de RedesLorena PalaciosAún no hay calificaciones
- Sistema Operativo Kali Linux 1Documento11 páginasSistema Operativo Kali Linux 1Eldragon Xii100% (1)
- Know The OSDocumento7 páginasKnow The OSUser1 User1Aún no hay calificaciones
- Tarea 3Documento10 páginasTarea 3Arturo VillegasAún no hay calificaciones
- Lamp y MQTTDocumento11 páginasLamp y MQTTHenry PastuñaAún no hay calificaciones
- Informe Grupo4 Honeypot 1Documento18 páginasInforme Grupo4 Honeypot 1Guisela LopezAún no hay calificaciones
- Packet TracerDocumento7 páginasPacket TracerFranklin Bendezu ValenzuelaAún no hay calificaciones
- La Seguridad Informática Es Algo Que Nos Preocupa A TodosDocumento6 páginasLa Seguridad Informática Es Algo Que Nos Preocupa A TodosConcepcion VidalAún no hay calificaciones
- 1-Introduccion A PythonDocumento7 páginas1-Introduccion A PythonDavid PradaAún no hay calificaciones
- Lamp y MQTTDocumento12 páginasLamp y MQTTHenry PastuñaAún no hay calificaciones
- CACTI + NAGIOS - Adrian de La ConcepcionDocumento28 páginasCACTI + NAGIOS - Adrian de La Concepcionadri5485100% (1)
- Instalar Apache Spark en Windows 10Documento16 páginasInstalar Apache Spark en Windows 10JuanAún no hay calificaciones
- Paso1 2150506 87 Esteban RodriguezDocumento9 páginasPaso1 2150506 87 Esteban RodriguezEsteban Rodriguez LemusAún no hay calificaciones
- Componentes de Instalacion de GNS3Documento5 páginasComponentes de Instalacion de GNS3boyacomamahuevoAún no hay calificaciones
- ScapyDocumento52 páginasScapykronoxAún no hay calificaciones
- Packet TracerDocumento19 páginasPacket TracerAlexis Crespo Miralles100% (1)
- Annie Informe - Sebastian ReyesDocumento8 páginasAnnie Informe - Sebastian ReyesAndy ErraezAún no hay calificaciones
- Módulo 7 - Metasploit Ver. FinalDocumento50 páginasMódulo 7 - Metasploit Ver. Finalerika1987eternityAún no hay calificaciones
- Curso LaravelDocumento121 páginasCurso LaravelJorge SanchezAún no hay calificaciones
- Ebook Introduccion Vision ArtificialDocumento31 páginasEbook Introduccion Vision Artificialrealvaradog4831100% (4)
- Kohana FrameworkDocumento16 páginasKohana FrameworkLara GabyAún no hay calificaciones
- Manual Cain y AbelDocumento4 páginasManual Cain y AbeldhyabloAún no hay calificaciones
- Informe Practica 2 - Ing TelecomunicacionesDocumento20 páginasInforme Practica 2 - Ing TelecomunicacionesSoraida Bayona GuioAún no hay calificaciones
- SnifferDocumento4 páginasSnifferWalter F. Montero VargasAún no hay calificaciones
- Paso 1Documento19 páginasPaso 1Mauricio RozoAún no hay calificaciones
- Informe de Practicas - Natalí VelasquezDocumento22 páginasInforme de Practicas - Natalí VelasquezOzzy NatalíAún no hay calificaciones
- Como Usar Packet TracerDocumento25 páginasComo Usar Packet Tracermarisosol100% (3)
- Integración de Sistemas: Soluciones - ActivemqDocumento17 páginasIntegración de Sistemas: Soluciones - ActivemqManuel Alejandro Burgos MoraAún no hay calificaciones
- 2 - Anaconda + Python, Creación de Un Entorno y Actualización de PaquetesDocumento6 páginas2 - Anaconda + Python, Creación de Un Entorno y Actualización de Paquetesros.dp15Aún no hay calificaciones
- Arturo Buanzo Busleiman Squid Transparente SololinuxDocumento13 páginasArturo Buanzo Busleiman Squid Transparente SololinuxjoseAún no hay calificaciones
- Anexo 4 Sistema de AutenticaciónDocumento28 páginasAnexo 4 Sistema de AutenticaciónJesús Israel Guamán MolinaAún no hay calificaciones
- SURICATADocumento8 páginasSURICATADaniel HidayatAún no hay calificaciones
- Xplico y Kali Linux PAMCDocumento9 páginasXplico y Kali Linux PAMCpercy_angel_84Aún no hay calificaciones
- Cybercamp 2015 PythonDocumento15 páginasCybercamp 2015 PythonlautiiAún no hay calificaciones
- Tarea 4Documento4 páginasTarea 4Cristóbal Giovanni Ocampo GarciaAún no hay calificaciones
- 1 4 2 Creando Un Prototipo IoTDocumento28 páginas1 4 2 Creando Un Prototipo IoTNekumii Kuran SashitaAún no hay calificaciones
- Empezar Con Kali Linux GUIDocumento9 páginasEmpezar Con Kali Linux GUIIván Alexander Chero CabreraAún no hay calificaciones
- Packet Tracer EspanolDocumento118 páginasPacket Tracer EspanolJose JimenezAún no hay calificaciones
- Comando de La Semana 19 RECON NG 1Documento39 páginasComando de La Semana 19 RECON NG 1Juan Pablo Gonzalez ManriqueAún no hay calificaciones
- CISCO TutoriasDocumento16 páginasCISCO TutoriasAaron Gutierrez BlancoAún no hay calificaciones
- Kali Linux Vs ParrotDocumento30 páginasKali Linux Vs ParrotGeanMarcoPradaAún no hay calificaciones
- Montar Un Ambiente de Trabajo PyDataDocumento3 páginasMontar Un Ambiente de Trabajo PyDataRICHARD ALEXANDER ACEVEDO RAMIREZAún no hay calificaciones
- PRACTICA 4: Instalación y Uso de WiresharkDocumento7 páginasPRACTICA 4: Instalación y Uso de WiresharkZuuuuAún no hay calificaciones
- Intro RaspberryDocumento44 páginasIntro RaspberryJefferson Velásquez RojoAún no hay calificaciones
- Qué Es Packet TracerDocumento12 páginasQué Es Packet TracerDayana Viera100% (5)
- Java 2: Manual de Usuario y Tutorial. 5ª EdiciónDe EverandJava 2: Manual de Usuario y Tutorial. 5ª EdiciónAún no hay calificaciones
- Aprendizaje automático y profundo en python: Una mirada hacia la inteligencia artificialDe EverandAprendizaje automático y profundo en python: Una mirada hacia la inteligencia artificialAún no hay calificaciones
- Python Aplicaciones prácticasDe EverandPython Aplicaciones prácticasCalificación: 4 de 5 estrellas4/5 (18)
- Evidencia 1 Video Disenar Una Planta de Produccion y Su Sistema de DistribucionDocumento3 páginasEvidencia 1 Video Disenar Una Planta de Produccion y Su Sistema de DistribucionYobany Velandia0% (1)
- Trabajo de Investig UltimoDocumento29 páginasTrabajo de Investig UltimoTitor GonzalesAún no hay calificaciones
- AMS Phased Array 2020 EsDocumento102 páginasAMS Phased Array 2020 EsFabio Da SilvaAún no hay calificaciones
- Derecho A La Intimidad y La Ciber Delincuencia Causas y Efectos en El Ecuador WashintonDocumento20 páginasDerecho A La Intimidad y La Ciber Delincuencia Causas y Efectos en El Ecuador WashintonDavid Olivero De La HozAún no hay calificaciones
- SESION 1 - ComputacionDocumento4 páginasSESION 1 - ComputacionaracelyAún no hay calificaciones
- Ejerpractico 28 VALIDACION DE DATOSDocumento5 páginasEjerpractico 28 VALIDACION DE DATOSAledis CompanyAún no hay calificaciones
- Resumen de Los Capítulos Uno y DosDocumento6 páginasResumen de Los Capítulos Uno y Dospaola154Aún no hay calificaciones
- DominiosDocumento3 páginasDominiosDomenicaAún no hay calificaciones
- Booklet Course 7Documento55 páginasBooklet Course 7mevallesmoAún no hay calificaciones
- Historia y Evolución de Las Comunicaciones: Facilitador Richard Manuel Cedeño QuezadaDocumento33 páginasHistoria y Evolución de Las Comunicaciones: Facilitador Richard Manuel Cedeño QuezadaDeivinsonAún no hay calificaciones
- C-Módulo 3. Herramientas Colaborativas - 51:61Documento61 páginasC-Módulo 3. Herramientas Colaborativas - 51:61RGDAún no hay calificaciones
- Formato Proyecto de Grado 2021Documento13 páginasFormato Proyecto de Grado 2021matheus crespinAún no hay calificaciones
- Análisis de Riesgos de La Municipalidad de HauraDocumento25 páginasAnálisis de Riesgos de La Municipalidad de HauraOscar Bryan Yanapa VentocillaAún no hay calificaciones
- Revista .Seguridad - Hacking Etico Mitos y Realidades - 2012-01-16Documento8 páginasRevista .Seguridad - Hacking Etico Mitos y Realidades - 2012-01-16SCRIBDAM007Aún no hay calificaciones
- Detección y Tratamiento de Valores AtípicosDocumento14 páginasDetección y Tratamiento de Valores AtípicosDarwin Jhoel TiteAún no hay calificaciones
- Rúbrica Foro 1 Principios de EconomíaDocumento1 páginaRúbrica Foro 1 Principios de EconomíaemilioAún no hay calificaciones
- 1 CAPITULO No 1Documento7 páginas1 CAPITULO No 1ROXANA CASTILLO MAMANIAún no hay calificaciones
- Fortaleceu3 PDFDocumento2 páginasFortaleceu3 PDFprtar LopezAún no hay calificaciones
- Fundamentos de ProgramacionDocumento10 páginasFundamentos de ProgramacionALEXANDER MAMANI LAYMEAún no hay calificaciones
- Mapaton Siccep - 2023Documento7 páginasMapaton Siccep - 2023Calitoo IGAún no hay calificaciones
- Field BusDocumento4 páginasField BusJoel Ugarte PalacinAún no hay calificaciones
- Taller de InnovacionDocumento7 páginasTaller de InnovaciondiegoAún no hay calificaciones
- Ejercicio 3.5.4: 3.5 Ejercicios Resueltos (Continuación )Documento60 páginasEjercicio 3.5.4: 3.5 Ejercicios Resueltos (Continuación )CR GPAún no hay calificaciones
- Actividad 5Documento25 páginasActividad 5Jorge Andres Mena CañasAún no hay calificaciones
- Guia ATAMDocumento1 páginaGuia ATAMucinfpracticas100% (1)
- Durabrand DB-261k ManualDocumento8 páginasDurabrand DB-261k ManualEduardo0% (2)
- Procedimiento Cambio de Sellos de La Valv. Esf. (Autoguardado) (Autoguardado) IsraelDocumento25 páginasProcedimiento Cambio de Sellos de La Valv. Esf. (Autoguardado) (Autoguardado) IsraelLuis SanangoAún no hay calificaciones
- Brainstorming o Lluvia de IdeasDocumento2 páginasBrainstorming o Lluvia de IdeasBetty VergaraAún no hay calificaciones
- Importancia de La Comunicación y CoordinaciónDocumento6 páginasImportancia de La Comunicación y CoordinaciónEMERSON JUNIOR RAMOS COTRINAAún no hay calificaciones
- Clase 10Documento14 páginasClase 10Keyla Alexandra MirandaAún no hay calificaciones
