SharkPy – Herramienta de la NSA para diseccionar, analizar e interactuar con los datos de paquetes de red utilizando las capacidades de Wireshark y libpcap

0
2870
views

Un módulo de python para diseccionar, analizar e interactuar con datos de paquetes de red como objetos nativos de Python usando las capacidades de Wireshark y libpcap. Los módulos de disección de sharkPy se extienden y de otra forma modifican el tshark de Wireshark. Los módulos de escritura de ficheros de inyección de paquetes y pcap de SharkPy envuelven la útil funcionalidad libpcap.

SharkPy viene con seis módulos que permiten explorar, crear y / o modificar datos de paquetes y (re) enviar datos a través de la red, y escribir (posiblemente modificados) paquetes en un nuevo archivo de salida de pcap. Todo esto se realiza dentro del programa python o de la sesión interactiva de python.

SharkPy.file_dissector – disecciona los paquetes de archivos de captura usando las bibliotecas de disección de Wireshark y presenta disecciones de paquetes detalladas para el caller como objetos nativos de Python.

SharkPy.wire_dissector – captura los paquetes de la interfaz y disecciona los paquetes capturados usando las bibliotecas de disección de Wireshark. Presenta paquetes a los callers como objetos nativos de Python.

SharkPy.file_writer – escribe (posiblemente modificado) paquetes en un nuevo archivo pcap de salida. Por ejemplo, se puede disecar el archivo de captura de paquetes usando sharkPy.file_dissector, crear nuevos paquetes basados ​​en los paquetes del archivo diseccionado y luego escribir paquetes nuevos / modificados en un archivo de salida pcap.

SharkPy.wire_writer – escribe datos arbitrarios (por ejemplo, paquetes modificados) en la interfaz de red especificada usando la funcionalidad libpcap. Actualmente, los usuarios de sharkPy son responsables de construir correctamente los paquetes que se transmiten usando la funcionalidad de este módulo.

SharkPy.utils – un conjunto de funciones de utilidad
SharkPy.protocol_blender – funciones de conveniencia específicas del protocolo. Actualmente contiene funciones para ipv4 y tcp sobre ipv4.

SharkPy se proporciona “tal cual” sin NINGUNA GARANTÍA expresada o implícita bajo GPLv2. Úselo bajo su propio riesgo.

Objetivos del diseño

  • Entregar datos de paquetes diseccionados a los llamadores como objetos nativos de python.
  • Proporcionar funcionalidad dentro de un entorno Python, ya sea un programa python o una sesión interactiva de python.
  • Haga que los comandos no bloqueen siempre que los resultados razonables de la instrucción proporcionen a la persona que llama bajo demanda.
  • Ser fácil de entender y usar suponiendo que uno entiende los conceptos básicos de Wireshark y python.
  • Paquete de funcionalidad en un pequeño número de comandos.
  • Construye e instala lo menos posible el código C enlazándote a librerías compartidas de Wireshark preexistentes.

Instalación

VM

Debe de funcionar el cualqueir distribucion linux, siempre cuando tenga instalado wireshark y python

user@computer:$ sudo apt-get git git clone https://github.com/NationalSecurityAgency/sharkPy
sudo apt-get install libpcap-dev
sudo apt-get install libglib2.0-dev
sudo apt-get install libpython-dev
sudo apt-get install wireshark-dev #if you didn't build/install wireshark (be sure wireshark libs are in LD_LIBRARY_PATH)
sudo apt-get install wireshark #if you didn't build/install wireshark (be sure wireshark libs are in LD_LIBRARY_PATH)
cd sharkPy
sudo ./setup install

Video Instalación

Docker

Primero, crea el directorio SharkPy e inserta el archivo DockerFile. cd al nuevo directorio

user@computer:$ docker build -t "ubuntu16_04:sharkPy" .

video instalación

Diseccionar paquetes en un archivo de captura

user@computer:$ >>> import sharkPy

Las opciones compatibles hasta ahora son DECODE_AS y NAME_RESOLUTION (use la opción para deshabilitar)

user@computer:$ >>> in_options=[(sharkPy.disopt.DECODE_AS, r'tcp.port==8888-8890,http'), (sharkPy.disopt.DECODE_AS, r'tcp.port==9999:3,http')]

Iniciar archivo de lectura y disección.

user@computer:$ >>> dissection = sharkPy.dissect_file(r'/home/me/capfile.pcap', options=in_options)

Utilice sharkPy.get_next_from_file para obtener disecciones de paquete de paquetes de lectura.

user@computer:$ >>> rtn_pkt_dissections_list = []
>>> for cnt in xrange(13):
... pkt = sharkPy.get_next_from_file(dissection)
... rtn_pkt_dissections_list.append(pkt)

Node Attributes:
abbrev: frame.
name: Frame.
blurb: None.
fvalue: None.
level: 0.
offset: 0.
ftype: 1.
ftype_desc: FT_PROTOCOL.
repr: Frame 253: 54 bytes on wire (432 bits), 54 bytes captured (432 bits) on interface 0.
data: 005056edfe68000c29....

Number of child nodes: 17
frame.interface_id
frame.encap_type
frame.time
frame.offset_shift
frame.time_epoch
frame.time_delta
frame.time_delta_displayed
frame.time_relative
frame.number
frame.len
frame.cap_len
frame.marked
frame.ignored
frame.protocols
eth
ip
tcp

Node Attributes:
abbrev: frame.interface_id.
name: Interface id.
blurb: None.
fvalue: 0.
level: 1.
offset: 0.
ftype: 6.
ftype_desc: FT_UINT32.
repr: Interface id: 0 (eno16777736).
data: None.

Number of child nodes: 0

...

Siempre cerrar la sesion

user@computer:$ >>> sharkPy.close_file(dissection)

CAPTURA DE PAQUETES DESDE LA RED Y DISECCIONARLOS

SharkPy wire_dissector proporciona una opción NOT_PROMISCUOUS adicional

user@computer:$ >>> in_options=[(sharkPy.disopt.DECODE_AS, r'tcp.port==8888-8890,http'), (sharkPy.disopt.DECODE_AS, r'tcp.port==9999:3,http'), (sharkPy.disopt.NOT_PROMISCUOUS, None)

Iniciar captura y disección. Tenga en cuenta que la persona que llama debe tener los permisos adecuados. Correr como root puede ser peligroso!

user@computer:$ >>> dissection = sharkPy.dissect_wire(r'eno16777736', options=in_options)
>>> Running as user "root" and group "root". This could be dangerous.

Utilice sharkPy.get_next_from_wire para obtener disecciones

user@computer:$ >>> for cnt in xrange(13):
... pkt=sharkPy.get_next_from_wire(dissection)
... sharkPy.walk_print(pkt) ## much better idea to save pkts in a list

Siempre debe cerrar sesiones de captura.

user@computer:$ >>> sharkPy.close_wire(dissection)

ESCRIBA DATOS (paquetes) A LA RED

Crear objeto de escritura utilizando el nombre de la interfaz

user@computer:$ >>> wr = sharkPy.wire_writer(['eno16777736'])

Enviar comando para escribir datos en la red con tiempo de espera de 2 segundos

user@computer:$ >>> wr.cmd(wr.WRITE_BYTES,' djwejkweuraiuhqwerqiorh', 2)

Compruebe si hay un fallo. Si tiene éxito, obtenga valores de retorno.

user@computer:$ >>> if(not wr.command_failure.is_set()):
... print wr.get_rst(1)
...
(0, 26) ### returned success and wrote 26 bytes. ###

Descarga SharkPy

Toda la información proporcionada en este medio es para fines educativos, en ningún caso alguno se hace responsable e cualquier mal uso de la información. Toda la información es para el desarrollo e investigación de métodos de seguridad informática.

No olvides visitar nuestra hacking shop

shop