Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-27 15:12:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing
History
Translator af30c5053c Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-09 20:00:45 +00:00
..
arm64-basic-assembly.md Translated ['macos-hardening/macos-security-and-privilege-escalation/mac 2023-10-09 20:00:45 +00:00
introduction-to-x64.md Translated ['macos-hardening/macos-security-and-privilege-escalation/mac 2023-10-09 20:00:45 +00:00
README.md Translated ['macos-hardening/macos-security-and-privilege-escalation/mac 2023-10-09 20:00:45 +00:00

README.md

macOS Apps - Inspección, depuración y Fuzzing

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

Análisis estático

otool

otool -L /bin/ls #List dynamically linked libraries
otool -tv /bin/ps #Decompile application

objdump

{% code overflow="wrap" %}

objdump -m --dylibs-used /bin/ls #List dynamically linked libraries
objdump -m -h /bin/ls # Get headers information
objdump -m --syms /bin/ls # Check if the symbol table exists to get function names
objdump -m --full-contents /bin/ls # Dump every section
objdump -d /bin/ls # Dissasemble the binary
objdump --disassemble-symbols=_hello --x86-asm-syntax=intel toolsdemo #Disassemble a function using intel flavour

{% endcode %}

jtool2

La herramienta se puede utilizar como un reemplazo para codesign, otool y objdump, y proporciona algunas características adicionales. Descárgala aquí o instálala con brew.

# Install
brew install --cask jtool2

jtool2 -l /bin/ls # Get commands (headers)
jtool2 -L /bin/ls # Get libraries
jtool2 -S /bin/ls # Get symbol info
jtool2 -d /bin/ls # Dump binary
jtool2 -D /bin/ls # Decompile binary

# Get signature information
ARCH=x86_64 jtool2 --sig /System/Applications/Automator.app/Contents/MacOS/Automator

# Get MIG information
jtool2 -d __DATA.__const myipc_server | grep MIG

Codesign / ldid

{% hint style="danger" %} Codesign se encuentra en macOS mientras que ldid se encuentra en iOS {% endhint %}

# Get signer
codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"

# Check if the app’s contents have been modified
codesign --verify --verbose /Applications/Safari.app

# Get entitlements from the binary
codesign -d --entitlements :- /System/Applications/Automator.app # Check the TCC perms

# Check if the signature is valid
spctl --assess --verbose /Applications/Safari.app

# Sign a binary
codesign -s <cert-name-keychain> toolsdemo

# Get signature info
ldid -h <binary>

# Get entitlements
ldid -e <binary>

# Change entilements
## /tmp/entl.xml is a XML file with the new entitlements to add
ldid -S/tmp/entl.xml <binary>

SuspiciousPackage

SuspiciousPackage es una herramienta útil para inspeccionar archivos .pkg (instaladores) y ver qué hay dentro antes de instalarlo.
Estos instaladores tienen scripts bash preinstall y postinstall que los autores de malware suelen abusar para persistir el malware.

hdiutil

Esta herramienta permite montar imágenes de disco de Apple (.dmg) para inspeccionarlas antes de ejecutar cualquier cosa:

hdiutil attach ~/Downloads/Firefox\ 58.0.2.dmg

Se montará en /Volumes

Objective-C

Metadatos

{% hint style="danger" %} Ten en cuenta que los programas escritos en Objective-C mantienen sus declaraciones de clase cuando se compilan en binarios Mach-O. Estas declaraciones de clase incluyen el nombre y tipo de: {% endhint %}

  • La clase
  • Los métodos de clase
  • Las variables de instancia de clase

Puedes obtener esta información utilizando class-dump:

class-dump Kindle.app

Llamada a funciones

Cuando se llama a una función en un binario que utiliza Objective-C, en lugar de llamar directamente a esa función, el código compilado llamará a objc_msgSend. Esta función llamará a la función final:

Los parámetros que esta función espera son:

  • El primer parámetro (self) es "un puntero que apunta a la instancia de la clase que recibirá el mensaje". En otras palabras, es el objeto sobre el cual se invoca el método. Si el método es un método de clase, esto será una instancia del objeto de la clase (en su totalidad), mientras que para un método de instancia, self apuntará a una instancia instanciada de la clase como objeto.
  • El segundo parámetro (op) es "el selector del método que maneja el mensaje". Nuevamente, de manera más simple, este es simplemente el nombre del método.
  • Los parámetros restantes son cualquier valor que sea requerido por el método (op).
Argumento Registro (para) objc_msgSend
1er argumento rdi self: objeto sobre el cual se invoca el método
2do argumento rsi op: nombre del método
3er argumento rdx 1er argumento para el método
4to argumento rcx 2do argumento para el método
5to argumento r8 3er argumento para el método
6to argumento r9 4to argumento para el método
7mo+ argumento

rsp+
(en la pila)

 5to+ argumento para el método

Swift

Con binarios de Swift, dado que hay compatibilidad con Objective-C, a veces se pueden extraer declaraciones utilizando class-dump, pero no siempre.

Con los comandos de línea jtool -l o otool -l es posible encontrar varias secciones que comienzan con el prefijo __swift5:

jtool2 -l /Applications/Stocks.app/Contents/MacOS/Stocks
LC 00: LC_SEGMENT_64              Mem: 0x000000000-0x100000000    __PAGEZERO
LC 01: LC_SEGMENT_64              Mem: 0x100000000-0x100028000    __TEXT
[...]
Mem: 0x100026630-0x100026d54        __TEXT.__swift5_typeref
Mem: 0x100026d60-0x100027061        __TEXT.__swift5_reflstr
Mem: 0x100027064-0x1000274cc        __TEXT.__swift5_fieldmd
Mem: 0x1000274cc-0x100027608        __TEXT.__swift5_capture
[...]

Puedes encontrar más información sobre la información almacenada en estas secciones en esta publicación de blog.

Además, los binarios de Swift pueden tener símbolos (por ejemplo, las bibliotecas necesitan almacenar símbolos para que se puedan llamar sus funciones). Los símbolos generalmente contienen información sobre el nombre de la función y los atributos de una manera poco legible, por lo que son muy útiles y existen "demanglers" que pueden obtener el nombre original:

# Ghidra plugin
https://github.com/ghidraninja/ghidra_scripts/blob/master/swift_demangler.py

# Swift cli
swift demangle

Binarios comprimidos

  • Verificar la entropía alta
  • Verificar las cadenas (si hay casi ninguna cadena comprensible, está comprimido)
  • El empaquetador UPX para MacOS genera una sección llamada "__XHDR"

Análisis dinámico

{% hint style="warning" %} Tenga en cuenta que para depurar binarios, SIP debe estar desactivado (csrutil disable o csrutil enable --without debug) o copiar los binarios a una carpeta temporal y eliminar la firma con codesign --remove-signature <ruta-del-binario> o permitir la depuración del binario (puede usar este script) {% endhint %}

{% hint style="warning" %} Tenga en cuenta que para instrumentar binarios del sistema (como cloudconfigurationd) en macOS, SIP debe estar desactivado (simplemente eliminar la firma no funcionará). {% endhint %}

Registros unificados

MacOS genera muchos registros que pueden ser muy útiles al ejecutar una aplicación para tratar de entender qué está haciendo.

Además, hay algunos registros que contendrán la etiqueta <private> para ocultar información identificable del usuario o computadora. Sin embargo, es posible instalar un certificado para revelar esta información. Siga las explicaciones de aquí.

Hopper

Panel izquierdo

En el panel izquierdo de Hopper es posible ver los símbolos (Etiquetas) del binario, la lista de procedimientos y funciones (Proc) y las cadenas (Str). Estas no son todas las cadenas, sino las definidas en varias partes del archivo Mac-O (como cstring o objc_methname).

Panel central

En el panel central se puede ver el código desensamblado. Y se puede ver como desensamblado en bruto, como gráfico, como descompilado y como binario haciendo clic en el icono correspondiente:

Al hacer clic derecho en un objeto de código, se pueden ver referencias hacia/desde ese objeto o incluso cambiar su nombre (esto no funciona en el pseudocódigo descompilado):

Además, en la parte inferior central se pueden escribir comandos de Python.

Panel derecho

En el panel derecho se pueden ver información interesante como el historial de navegación (para saber cómo llegó a la situación actual), el gráfico de llamadas donde se pueden ver todas las funciones que llaman a esta función y todas las funciones que esta función llama, e información sobre las variables locales.

dtrace

Permite a los usuarios acceder a las aplicaciones a un nivel extremadamente bajo y proporciona una forma para que los usuarios rastreen programas e incluso cambien su flujo de ejecución. DTrace utiliza sondas que se colocan en todo el kernel y se encuentran en ubicaciones como el inicio y el final de las llamadas al sistema.

DTrace utiliza la función dtrace_probe_create para crear una sonda para cada llamada al sistema. Estas sondas se pueden activar en el punto de entrada y salida de cada llamada al sistema. La interacción con DTrace se realiza a través de /dev/dtrace, que solo está disponible para el usuario root.

{% hint style="success" %} Para habilitar Dtrace sin desactivar completamente la protección SIP, puede ejecutar en modo de recuperación: csrutil enable --without dtrace

También puede dtrace o dtruss binarios que ha compilado. {% endhint %}

Las sondas disponibles de dtrace se pueden obtener con:

dtrace -l | head
ID   PROVIDER            MODULE                          FUNCTION NAME
1     dtrace                                                     BEGIN
2     dtrace                                                     END
3     dtrace                                                     ERROR
43    profile                                                     profile-97
44    profile                                                     profile-199

El nombre de la sonda consta de cuatro partes: el proveedor, el módulo, la función y el nombre (fbt:mach_kernel:ptrace:entry). Si no se especifica alguna parte del nombre, Dtrace la considerará como un comodín.

Para configurar DTrace y activar sondas, así como especificar las acciones a realizar cuando se activan, necesitaremos utilizar el lenguaje D.

Se puede encontrar una explicación más detallada y más ejemplos en https://illumos.org/books/dtrace/chp-intro.html

Ejemplos

Ejecuta man -k dtrace para listar los scripts de DTrace disponibles. Ejemplo: sudo dtruss -n binary

  • En la línea
#Count the number of syscalls of each running process
sudo dtrace -n 'syscall:::entry {@[execname] = count()}'

Inspeccionando, depurando y fuzzing de aplicaciones en macOS

En este directorio, encontrarás herramientas y técnicas para inspeccionar, depurar y realizar fuzzing en aplicaciones en macOS. Estas técnicas te permitirán analizar el comportamiento de las aplicaciones, identificar vulnerabilidades y encontrar posibles formas de escalada de privilegios.

Inspeccionando aplicaciones

La inspección de aplicaciones implica examinar el código y los recursos de una aplicación para comprender su funcionamiento interno. Esto puede ayudarte a identificar posibles vulnerabilidades y a comprender cómo interactúa la aplicación con el sistema operativo.

Herramientas de inspección

  • Hopper Disassembler - Un desensamblador de macOS que te permite examinar el código de una aplicación y comprender su estructura interna.
  • class-dump - Una herramienta de línea de comandos que extrae la declaración de clases y métodos de un binario ejecutable.
  • otool - Una herramienta de línea de comandos que muestra información sobre los archivos binarios de macOS.

Depurando aplicaciones

La depuración de aplicaciones implica ejecutar una aplicación en un entorno controlado y examinar su comportamiento en tiempo de ejecución. Esto te permite identificar y solucionar problemas, así como descubrir posibles vulnerabilidades.

Herramientas de depuración

  • lldb - Un depurador de macOS que te permite examinar y manipular el estado de una aplicación en tiempo de ejecución.
  • Xcode - Un entorno de desarrollo integrado (IDE) que incluye herramientas de depuración para aplicaciones macOS.

Fuzzing de aplicaciones

El fuzzing es una técnica que implica enviar entradas aleatorias o maliciosas a una aplicación para encontrar posibles vulnerabilidades. Esta técnica es especialmente útil para descubrir vulnerabilidades de seguridad desconocidas.

Herramientas de fuzzing

  • AFL - Un marco de fuzzing que utiliza la instrumentación de código para generar entradas aleatorias y encontrar posibles vulnerabilidades.
  • Peach Fuzzer - Una plataforma de fuzzing que te permite crear y ejecutar pruebas de fuzzing personalizadas.
  • Radamsa - Una herramienta de generación de mutaciones que se utiliza en combinación con otras herramientas de fuzzing.

Recursos adicionales

Aquí tienes algunos recursos adicionales que pueden ser útiles para inspeccionar, depurar y realizar fuzzing en aplicaciones en macOS:

¡Diviértete explorando y descubriendo las vulnerabilidades de las aplicaciones en macOS!

syscall:::entry
/pid == $1/
{
}

#Log every syscall of a PID
sudo dtrace -s script.d 1234

syscall::open:entry
{
printf("%s(%s)", probefunc, copyinstr(arg0));
}
syscall::close:entry
{
printf("%s(%d)\n", probefunc, arg0);
}

#Log files opened and closed by a process
sudo dtrace -s b.d -c "cat /etc/hosts"

syscall:::entry
{
;
}
syscall:::return
{
printf("=%d\n", arg1);
}

#Log sys calls with values
sudo dtrace -s syscalls_info.d -c "cat /etc/hosts"

dtruss

dtruss is a command-line tool available on macOS that allows you to trace and inspect system calls made by a process. It can be used for debugging and analyzing the behavior of applications.

To use dtruss, you need to specify the process ID (PID) of the target application. You can find the PID using the ps command or by using tools like Activity Monitor.

Once you have the PID, you can run dtruss with the following syntax:

sudo dtruss -p <PID>

The sudo command is required because dtruss needs root privileges to trace system calls.

When dtruss is running, it will display a list of system calls made by the target process, along with their arguments and return values. This can be useful for understanding how an application interacts with the operating system and identifying any potential security vulnerabilities or performance issues.

Note that dtruss can generate a large amount of output, so it's recommended to redirect the output to a file for further analysis. You can do this by appending > output.txt to the dtruss command.

Keep in mind that dtruss is a powerful tool that should be used responsibly and with proper authorization. It can be used for legitimate purposes like debugging and troubleshooting, but it can also be misused for unauthorized access or malicious activities. Always ensure that you have the necessary permissions and legal authorization before using dtruss or any other similar tool.

dtruss -c ls #Get syscalls of ls
dtruss -c -p 1000 #get syscalls of PID 1000

ktrace

Puedes usar este incluso con SIP activado.

ktrace trace -s -S -t c -c ls | grep "ls("

ProcessMonitor

ProcessMonitor es una herramienta muy útil para verificar las acciones relacionadas con los procesos que un proceso está realizando (por ejemplo, monitorear qué nuevos procesos está creando un proceso).

FileMonitor

FileMonitor permite monitorear eventos de archivos (como creación, modificaciones y eliminaciones) proporcionando información detallada sobre dichos eventos.

Crescendo

Crescendo es una herramienta GUI con la apariencia y sensación que los usuarios de Windows pueden conocer de Procmon de Microsoft Sysinternal. Permite iniciar y detener la grabación de eventos de todo tipo, filtrarlos por categorías (archivo, proceso, red, etc.) y guardar los eventos grabados como archivo json.

Apple Instruments

Apple Instruments son parte de las herramientas de desarrollador de Xcode, utilizadas para monitorear el rendimiento de las aplicaciones, identificar fugas de memoria y rastrear la actividad del sistema de archivos.

fs_usage

Permite seguir las acciones realizadas por los procesos:

fs_usage -w -f filesys ls #This tracks filesystem actions of proccess names containing ls
fs_usage -w -f network curl #This tracks network actions

TaskExplorer

Taskexplorer es útil para ver las bibliotecas utilizadas por un binario, los archivos que está utilizando y las conexiones de red.
También verifica los procesos binarios en virustotal y muestra información sobre el binario.

PT_DENY_ATTACH

En esta publicación de blog puedes encontrar un ejemplo sobre cómo depurar un daemon en ejecución que utiliza PT_DENY_ATTACH para evitar la depuración incluso si SIP está desactivado.

lldb

lldb es la herramienta de hecho para la depuración de binarios en macOS.

lldb ./malware.bin
lldb -p 1122
lldb -n malware.bin
lldb -n malware.bin --waitfor

Puedes configurar la variante de Intel al usar lldb creando un archivo llamado .lldbinit en tu carpeta de inicio con la siguiente línea:

settings set target.x86-disassembly-flavor intel

{% hint style="warning" %} Dentro de lldb, volcar un proceso con process save-core {% endhint %}

(lldb) ComandoDescripción
run (r)Iniciar la ejecución, que continuará sin interrupciones hasta que se alcance un punto de interrupción o el proceso termine.
continue (c)Continuar la ejecución del proceso depurado.
nexti (n / ni)Ejecutar la siguiente instrucción. Este comando omitirá las llamadas a funciones.
stepi (s / si)Ejecutar la siguiente instrucción. A diferencia del comando nexti, este comando entrará en las llamadas a funciones.
finish (f)Ejecutar el resto de las instrucciones en la función actual ("frame") y detenerse.
control + cPausar la ejecución. Si el proceso se ha ejecutado (r) o continuado (c), esto hará que el proceso se detenga ...donde sea que se esté ejecutando actualmente.
breakpoint (b)

b main #Cualquier función llamada main

b <nombrebin>`main #Función principal del binario

b set -n main --shlib <nombrelib> #Función principal del binario indicado

b -[NSDictionary objectForKey:]

b -a 0x0000000100004bd9

br l #Lista de puntos de interrupción

br e/dis <número> #Habilitar/Deshabilitar punto de interrupción

breakpoint delete <número>

help

help breakpoint #Obtener ayuda del comando breakpoint

help memory write #Obtener ayuda para escribir en la memoria

reg

reg read

reg read $rax

reg read $rax --format <formato>

reg write $rip 0x100035cc0

x/s <direcciónreg/memoria>Mostrar la memoria como una cadena terminada en nulo.
x/i <direcciónreg/memoria>Mostrar la memoria como instrucción de ensamblador.
x/b <direcciónreg/memoria>Mostrar la memoria como byte.
print object (po)

Esto imprimirá el objeto al que hace referencia el parámetro

po $raw

{

dnsChanger = {

"affiliate" = "";

"blacklist_dns" = ();

Tenga en cuenta que la mayoría de las API o métodos de Objective-C de Apple devuelven objetos y, por lo tanto, deben mostrarse mediante el comando "print object" (po). Si po no produce una salida significativa, use x/b

memorymemory read 0x000....
memory read $x0+0xf2a
memory write 0x100600000 -s 4 0x41414141 #Escribir AAAA en esa dirección
memory write -f s $rip+0x11f+7 "AAAA" #Escribir AAAA en la dirección
disassembly

dis #Desensamblar la función actual

dis -n <nombrefunc> #Desensamblar función

dis -n <nombrefunc> -b <nombrebase> #Desensamblar función
dis -c 6 #Desensamblar 6 líneas
dis -c 0x100003764 -e 0x100003768 #Desde una dirección hasta la otra
dis -p -c 4 #Comenzar en la dirección actual desensamblando

parrayparray 3 (char **)$x1 #Comprobar el array de 3 componentes en el registro x1

{% hint style="info" %} Cuando se llama a la función objc_sendMsg, el registro rsi contiene el nombre del método como una cadena terminada en nulo ("C"). Para imprimir el nombre a través de lldb, haga lo siguiente:

(lldb) x/s $rsi: 0x1000f1576: "startMiningWithPort:password:coreCount:slowMemory:currency:"

(lldb) print (char*)$rsi:
(char *) $1 = 0x00000001000f1576 "startMiningWithPort:password:coreCount:slowMemory:currency:"

(lldb) reg read $rsi: rsi = 0x00000001000f1576 "startMiningWithPort:password:coreCount:slowMemory:currency:" {% endhint %}

Anti-Análisis Dinámico

Detección de VM

  • El comando sysctl hw.model devuelve "Mac" cuando el host es un MacOS, pero algo diferente cuando es una VM.
  • Jugando con los valores de hw.logicalcpu y hw.physicalcpu, algunos malware intentan detectar si es una VM.
  • Algunos malware también pueden detectar si la máquina es VMware basándose en la dirección MAC (00:50:56).
  • También es posible encontrar si un proceso está siendo depurado con un código simple como:
  • if(P_TRACED == (info.kp_proc.p_flag & P_TRACED)){ //proceso siendo depurado }
  • También puede invocar la llamada al sistema ptrace con la bandera PT_DENY_ATTACH. Esto impide que un depurador se adjunte y realice un seguimiento.
  • Puede verificar si la función sysctl o ptrace está siendo importada (pero el malware podría importarla dinámicamente)
  • Como se señala en este artículo, "Derrotando Técnicas Anti-Depuración: variantes de ptrace en macOS":
    "El mensaje Process # exited with status = 45 (0x0000002d) generalmente es una señal reveladora de que el objetivo de depuración está utilizando PT_DENY_ATTACH"

Fuzzing

ReportCrash

ReportCrash analiza los procesos que se bloquean y guarda un informe de bloqueo en el disco. Un informe de bloqueo contiene información que puede ayudar a un desarrollador a diagnosticar la causa de un bloqueo.
Para aplicaciones y otros procesos que se ejecutan en el contexto de lanzamiento por usuario, ReportCrash se ejecuta como un LaunchAgent y guarda los informes de bloqueo en ~/Library/Logs/DiagnosticReports/ del usuario.
Para demonios, otros procesos que se ejecutan en el contexto de lanzamiento del sistema y otros procesos privilegiados, ReportCrash se ejecuta como un LaunchDaemon y guarda los informes de bloqueo en /Library/Logs/DiagnosticReports del sistema.

Si te preocupa que los informes de bloqueo se envíen a Apple, puedes desactivarlos. Si no, los informes de bloqueo pueden ser útiles para determinar cómo se bloqueó un servidor.

#To disable crash reporting:
launchctl unload -w /System/Library/LaunchAgents/com.apple.ReportCrash.plist
sudo launchctl unload -w /System/Library/LaunchDaemons/com.apple.ReportCrash.Root.plist

#To re-enable crash reporting:
launchctl load -w /System/Library/LaunchAgents/com.apple.ReportCrash.plist
sudo launchctl load -w /System/Library/LaunchDaemons/com.apple.ReportCrash.Root.plist

Dormir

Cuando se realiza fuzzing en un MacOS, es importante evitar que la Mac se duerma:

  • systemsetup -setsleep Never
  • pmset, Preferencias del Sistema
  • KeepingYouAwake

Desconexión SSH

Si estás realizando fuzzing a través de una conexión SSH, es importante asegurarse de que la sesión no se cierre. Para ello, cambia el archivo sshd_config con:

  • TCPKeepAlive Yes
  • ClientAliveInterval 0
  • ClientAliveCountMax 0
sudo launchctl unload /System/Library/LaunchDaemons/ssh.plist
sudo launchctl load -w /System/Library/LaunchDaemons/ssh.plist

Controladores internos

Consulta la siguiente página para descubrir cómo puedes encontrar qué aplicación es responsable de manejar el esquema o protocolo especificado:

{% content-ref url="../macos-file-extension-apps.md" %} macos-file-extension-apps.md {% endcontent-ref %}

Enumeración de procesos de red

Esto es interesante para encontrar procesos que están gestionando datos de red:

dtrace -n 'syscall::recv*:entry { printf("-> %s (pid=%d)", execname, pid); }' >> recv.log
#wait some time
sort -u recv.log > procs.txt
cat procs.txt

O utiliza netstat o lsof

Libgmalloc

{% code overflow="wrap" %}

lldb -o "target create `which some-binary`" -o "settings set target.env-vars DYLD_INSERT_LIBRARIES=/usr/lib/libgmalloc.dylib" -o "run arg1 arg2" -o "bt" -o "reg read" -o "dis -s \$pc-32 -c 24 -m -F intel" -o "quit"

{% endcode %}

Fuzzers

AFL++

Funciona para herramientas de línea de comandos.

Litefuzz

Funciona con herramientas de GUI de macOS. Ten en cuenta que algunas aplicaciones de macOS tienen requisitos específicos como nombres de archivo únicos, la extensión correcta, necesidad de leer los archivos desde el sandbox (~/Library/Containers/com.apple.Safari/Data)...

Algunos ejemplos:

{% code overflow="wrap" %}

# iBooks
litefuzz -l -c "/System/Applications/Books.app/Contents/MacOS/Books FUZZ" -i files/epub -o crashes/ibooks -t /Users/test/Library/Containers/com.apple.iBooksX/Data/tmp -x 10 -n 100000 -ez

# -l : Local
# -c : cmdline with FUZZ word (if not stdin is used)
# -i : input directory or file
# -o : Dir to output crashes
# -t : Dir to output runtime fuzzing artifacts
# -x : Tmeout for the run (default is 1)
# -n : Num of fuzzing iterations (default is 1)
# -e : enable second round fuzzing where any crashes found are reused as inputs
# -z : enable malloc debug helpers

# Font Book
litefuzz -l -c "/System/Applications/Font Book.app/Contents/MacOS/Font Book FUZZ" -i input/fonts -o crashes/font-book -x 2 -n 500000 -ez

# smbutil (using pcap capture)
litefuzz -lk -c "smbutil view smb://localhost:4455" -a tcp://localhost:4455 -i input/mac-smb-resp -p -n 100000 -z

# screensharingd (using pcap capture)
litefuzz -s -a tcp://localhost:5900 -i input/screenshared-session --reportcrash screensharingd -p -n 100000

{% endcode %}

Más información sobre Fuzzing en MacOS

Referencias

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥