mirror of https://github.com/carlospolop/hacktricks synced 2024-11-22 20:53:37 +00:00

Translator af61328779 Translated ['macos-hardening/macos-security-and-privilege-escalation/mac

2024-07-19 11:28:35 +00:00

Configuración de Frida en iOS

{% hint style="success" %} Aprende y practica Hacking en AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprende y practica Hacking en GCP: HackTricks Training GCP Red Team Expert (GRTE)

Apoya a HackTricks

Revisa los planes de suscripción!
Únete al 💬 grupo de Discord o al grupo de telegram o síguenos en Twitter 🐦 @hacktricks_live.
Comparte trucos de hacking enviando PRs a los HackTricks y HackTricks Cloud repositorios de github.

{% endhint %}

WhiteIntel es un motor de búsqueda alimentado por la dark-web que ofrece funcionalidades gratuitas para verificar si una empresa o sus clientes han sido comprometidos por malwares robadores.

Su objetivo principal de WhiteIntel es combatir la toma de cuentas y los ataques de ransomware resultantes de malware que roba información.

Puedes visitar su sitio web y probar su motor de forma gratuita en:

{% embed url="https://whiteintel.io" %}

Instalando Frida

Pasos para instalar Frida en un dispositivo con Jailbreak:

Abre la aplicación Cydia/Sileo.
Navega a Administrar -> Fuentes -> Editar -> Agregar.
Ingresa "https://build.frida.re" como la URL.
Ve a la nueva fuente de Frida añadida.
Instala el paquete de Frida.

Si estás usando Corellium, necesitarás descargar la versión de Frida desde https://github.com/frida/frida/releases (frida-gadget-[tuversión]-ios-universal.dylib.gz) y descomprimir y copiar a la ubicación dylib que Frida solicita, por ejemplo: /Users/[tuusuario]/.cache/frida/gadget-ios.dylib

Después de instalar, puedes usar en tu PC el comando frida-ls-devices y verificar que el dispositivo aparezca (tu PC necesita poder acceder a él).
Ejecuta también frida-ps -Uia para verificar los procesos en ejecución del teléfono.

Frida sin dispositivo con Jailbreak y sin parchear la aplicación

Consulta esta publicación de blog sobre cómo usar Frida en dispositivos no jailbreak sin parchear la aplicación: https://mrbypass.medium.com/unlocking-potential-exploring-frida-objection-on-non-jailbroken-devices-without-application-ed0367a84f07

Instalación del Cliente Frida

Instala frida tools:

pip install frida-tools
pip install frida

Con el servidor Frida instalado y el dispositivo funcionando y conectado, verifica si el cliente está funcionando:

frida-ls-devices  # List devices
frida-ps -Uia     # Get running processes

Frida Trace

# Functions
## Trace all functions with the word "log" in their name
frida-trace -U <program> -i "*log*"
frida-trace -U <program> -i "*log*" | swift demangle # Demangle names

# Objective-C
## Trace all methods of all classes
frida-trace -U <program> -m "*[* *]"

## Trace all methods with the word "authentication" from classes that start with "NE"
frida-trace -U <program> -m "*[NE* *authentication*]"

# Plug-In
## To hook a plugin that is momentarely executed prepare Frida indicating the ID of the Plugin binary
frida-trace -U -W <if-plugin-bin> -m '*[* *]'

Obtener todas las clases y métodos

Autocompletar: Simplemente ejecuta frida -U <program>

Obtener todas las clases disponibles (filtrar por cadena)

{% code title="/tmp/script.js" %}

// frida -U <program> -l /tmp/script.js

var filterClass = "filterstring";

if (ObjC.available) {
for (var className in ObjC.classes) {
if (ObjC.classes.hasOwnProperty(className)) {
if (!filterClass || className.includes(filterClass)) {
console.log(className);
}
}
}
} else {
console.log("Objective-C runtime is not available.");
}

{% endcode %}

Obtener todos los métodos de una clase (filtrar por cadena)

{% code title="/tmp/script.js" %}

// frida -U <program> -l /tmp/script.js

var specificClass = "YourClassName";
var filterMethod = "filtermethod";

if (ObjC.available) {
if (ObjC.classes.hasOwnProperty(specificClass)) {
var methods = ObjC.classes[specificClass].$ownMethods;
for (var i = 0; i < methods.length; i++) {
if (!filterMethod || methods[i].includes(filterClass)) {
console.log(specificClass + ': ' + methods[i]);
}
}
} else {
console.log("Class not found.");
}
} else {
console.log("Objective-C runtime is not available.");
}

{% endcode %}

Llamar a una función

// Find the address of the function to call
const func_addr = Module.findExportByName("<Prog Name>", "<Func Name>");
// Declare the function to call
const func = new NativeFunction(
func_addr,
"void", ["pointer", "pointer", "pointer"], {
});

var arg0 = null;

// In this case to call this function we need to intercept a call to it to copy arg0
Interceptor.attach(wg_log_addr, {
onEnter: function(args) {
arg0 = new NativePointer(args[0]);
}
});

// Wait untill a call to the func occurs
while (! arg0) {
Thread.sleep(1);
console.log("waiting for ptr");
}


var arg1 = Memory.allocUtf8String('arg1');
var txt = Memory.allocUtf8String('Some text for arg2');
wg_log(arg0, arg1, txt);

console.log("loaded");

Frida Fuzzing

Frida Stalker

From the docs: Stalker es el motor de trazado de código de Frida. Permite que los hilos sean seguido, capturando cada función, cada bloque, incluso cada instrucción que se ejecuta.

Tienes un ejemplo implementando Frida Stalker en https://github.com/poxyran/misc/blob/master/frida-stalker-example.py

Este es otro ejemplo para adjuntar Frida Stalker cada vez que se llama a una función:

console.log("loading");
const wg_log_addr = Module.findExportByName("<Program>", "<function_name>");
const wg_log = new NativeFunction(
wg_log_addr,
"void", ["pointer", "pointer", "pointer"], {
});

Interceptor.attach(wg_log_addr, {
onEnter: function(args) {
console.log(`logging the following message: ${args[2].readCString()}`);

Stalker.follow({
events: {
// only collect coverage for newly encountered blocks
compile: true,
},
onReceive: function (events) {
const bbs = Stalker.parse(events, {
stringify: false,
annotate: false
});
console.log("Stalker trace of write_msg_to_log: \n" + bbs.flat().map(DebugSymbol.fromAddress).join('\n'));
}
});
},
onLeave: function(retval) {
Stalker.unfollow();
Stalker.flush();  // this is important to get all events
}
});

{% hint style="danger" %} Esto es interesante desde el punto de vista de la depuración, pero para fuzzing, estar constantemente .follow() y .unfollow() es muy ineficiente. {% endhint %}

Fpicker

fpicker es un conjunto de herramientas de fuzzing basado en Frida que ofrece una variedad de modos de fuzzing para fuzzing en proceso, como un modo AFL++ o un modo de trazado pasivo. Debería funcionar en todas las plataformas que son compatibles con Frida.

Instalar fpicker y radamsa

# Get fpicker
git clone https://github.com/ttdennis/fpicker
cd fpicker

# Get Frida core devkit and prepare fpicker
wget https://github.com/frida/frida/releases/download/16.1.4/frida-core-devkit-16.1.4-[yourOS]-[yourarchitecture].tar.xz
# e.g. https://github.com/frida/frida/releases/download/16.1.4/frida-core-devkit-16.1.4-macos-arm64.tar.xz
tar -xf ./*tar.xz
cp libfrida-core.a libfrida-core-[yourOS].a #libfrida-core-macos.a

# Install fpicker
make fpicker-[yourOS] # fpicker-macos
# This generates ./fpicker

# Install radamsa (fuzzer generator)
brew install radamsa

Preparar el FS:

# From inside fpicker clone
mkdir -p examples/wg-log # Where the fuzzing script will be
mkdir -p examples/wg-log/out # For code coverage and crashes
mkdir -p examples/wg-log/in # For starting inputs

# Create at least 1 input for the fuzzer
echo Hello World > examples/wg-log/in/0

Script de Fuzzer (examples/wg-log/myfuzzer.js):

{% code title="examples/wg-log/myfuzzer.js" %}

// Import the fuzzer base class
import { Fuzzer } from "../../harness/fuzzer.js";

class WGLogFuzzer extends Fuzzer {

constructor() {
console.log("WGLogFuzzer constructor called")

// Get and declare the function we are going to fuzz
var wg_log_addr = Module.findExportByName("<Program name>", "<func name to fuzz>");
var wg_log_func = new NativeFunction(
wg_log_addr,
"void", ["pointer", "pointer", "pointer"], {
});

// Initialize the object
super("<Program nane>", wg_log_addr, wg_log_func);
this.wg_log_addr = wg_log_addr; // We cannot use "this" before calling "super"

console.log("WGLogFuzzer in the middle");

// Prepare the second argument to pass to the fuzz function
this.tag = Memory.allocUtf8String("arg2");

// Get the first argument we need to pass from a call to the functino we want to fuzz
var wg_log_global_ptr = null;
console.log(this.wg_log_addr);
Interceptor.attach(this.wg_log_addr, {
onEnter: function(args) {
console.log("Entering in the function to get the first argument");
wg_log_global_ptr = new NativePointer(args[0]);
}
});

while (! wg_log_global_ptr) {
Thread.sleep(1)
}
this.wg_log_global_ptr = wg_log_global_ptr;
console.log("WGLogFuzzer prepare ended")
}


// This function is called by the fuzzer with the first argument being a pointer into memory
// where the payload is stored and the second the length of the input.
fuzz(payload, len) {
// Get a pointer to payload being a valid C string (with a null byte at the end)
var payload_cstring = payload.readCString(len);
this.payload = Memory.allocUtf8String(payload_cstring);

// Debug and fuzz
this.debug_log(this.payload, len);
// Pass the 2 first arguments we know the function needs and finally the payload to fuzz
this.target_function(this.wg_log_global_ptr, this.tag, this.payload);
}
}

const f = new WGLogFuzzer();
rpc.exports.fuzzer = f;

{% endcode %}

Compilar el fuzzer:

# From inside fpicker clone
## Compile from "myfuzzer.js" to "harness.js"
frida-compile examples/wg-log/myfuzzer.js -o harness.js

Llama al fuzzer fpicker usando radamsa:

{% code overflow="wrap" %}

# Indicate fpicker to fuzz a program with the harness.js script and which folders to use
fpicker -v --fuzzer-mode active -e attach -p <Program to fuzz> -D usb -o examples/wg-log/out/ -i examples/wg-log/in/ -f harness.js --standalone-mutator cmd --mutator-command "radamsa"
# You can find code coverage and crashes in examples/wg-log/out/

{% endcode %}

{% hint style="danger" %} En este caso no estamos reiniciando la aplicación ni restaurando el estado después de cada payload. Así que, si Frida encuentra un crash, los siguientes inputs después de ese payload también podrían hacer que la aplicación se caiga (porque la aplicación está en un estado inestable) incluso si el input no debería hacer que la aplicación se caiga.

Además, Frida se enganchará a las señales de excepción de iOS, por lo que cuando Frida encuentra un crash, probablemente no se generarán informes de crash de iOS.

Para prevenir esto, por ejemplo, podríamos reiniciar la aplicación después de cada crash de Frida. {% endhint %}

Logs & Crashes

Puedes revisar la consola de macOS o el cli de log para verificar los logs de macOS.
También puedes revisar los logs de iOS usando idevicesyslog.
Algunos logs omitirán información añadiendo <private>. Para mostrar toda la información necesitas instalar algún perfil de https://developer.apple.com/bug-reporting/profiles-and-logs/ para habilitar esa información privada.

Si no sabes qué hacer:

vim /Library/Preferences/Logging/com.apple.system.logging.plist
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Enable-Private-Data</key>
<true/>
</dict>
</plist>

killall -9 logd

Puedes verificar los fallos en:

iOS
Configuración → Privacidad → Análisis y mejoras → Datos de análisis
/private/var/mobile/Library/Logs/CrashReporter/
macOS:
/Library/Logs/DiagnosticReports/
~/Library/Logs/DiagnosticReports

{% hint style="warning" %} iOS solo almacena 25 fallos de la misma aplicación, por lo que necesitas limpiar eso o iOS dejará de crear fallos. {% endhint %}