macOS GCD - Grand Central Dispatch

Impara l'hacking di AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)!

Altri modi per supportare HackTricks:

Se vuoi vedere la tua azienda pubblicizzata su HackTricks o scaricare HackTricks in PDF Controlla i PIANI DI ABBONAMENTO!
Ottieni il merchandising ufficiale di PEASS & HackTricks
Scopri La Famiglia PEASS, la nostra collezione di NFT esclusivi
Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @carlospolopm.
Condividi i tuoi trucchi di hacking inviando PR a HackTricks e HackTricks Cloud repos di github.

Informazioni di base

Grand Central Dispatch (GCD), noto anche come libdispatch (libdispatch.dyld), è disponibile sia su macOS che su iOS. È una tecnologia sviluppata da Apple per ottimizzare il supporto dell'applicazione per l'esecuzione concorrente (multithread) sull'hardware multicore.

GCD fornisce e gestisce code FIFO a cui la tua applicazione può inviare attività sotto forma di oggetti block. I blocchi inviati alle code di invio vengono eseguiti su un pool di thread completamente gestito dal sistema. GCD crea automaticamente thread per eseguire le attività nelle code di invio e pianifica l'esecuzione di tali attività sui core disponibili.

{% hint style="success" %} In sintesi, per eseguire codice in parallelo, i processi possono inviare blocchi di codice a GCD, che si occuperà della loro esecuzione. Pertanto, i processi non creano nuovi thread; GCD esegue il codice fornito con il proprio pool di thread (che potrebbe aumentare o diminuire secondo necessità). {% endhint %}

Questo è molto utile per gestire con successo l'esecuzione parallela, riducendo notevolmente il numero di thread creati dai processi e ottimizzando l'esecuzione parallela. Questo è ideale per attività che richiedono grande parallelismo (forza bruta?) o per attività che non dovrebbero bloccare il thread principale: ad esempio, il thread principale su iOS gestisce le interazioni dell'interfaccia utente, quindi qualsiasi altra funzionalità che potrebbe far bloccare l'applicazione (ricerca, accesso a un sito web, lettura di un file...) è gestita in questo modo.

Blocchi

Un blocco è una sezione di codice autocontenuta (come una funzione con argomenti che restituisce un valore) e può anche specificare variabili vincolate.
Tuttavia, a livello di compilatore i blocchi non esistono, sono os_object. Ciascuno di questi oggetti è formato da due strutture:

letterale del blocco:
Inizia con il campo isa, che punta alla classe del blocco:
NSConcreteGlobalBlock (blocchi da __DATA.__const)
NSConcreteMallocBlock (blocchi nello heap)
NSConcreateStackBlock (blocchi nello stack)
Ha flags (che indicano i campi presenti nel descrittore del blocco) e alcuni byte riservati
Il puntatore alla funzione da chiamare
Un puntatore al descrittore del blocco
Variabili importate dal blocco (se presenti)
descrittore del blocco: La sua dimensione dipende dai dati presenti (come indicato nei flag precedenti)
Ha alcuni byte riservati
La sua dimensione
Di solito avrà un puntatore a una firma in stile Objective-C per sapere di quanto spazio è necessario per i parametri (flag BLOCK_HAS_SIGNATURE)
Se le variabili sono referenziate, questo blocco avrà anche puntatori a un aiutante di copia (che copia il valore all'inizio) e a un aiutante di smaltimento (liberandolo).

Code di invio

Una coda di invio è un oggetto nominato che fornisce l'ordinamento FIFO dei blocchi per le esecuzioni.

I blocchi sono impostati nelle code da eseguire e queste supportano 2 modalità: DISPATCH_QUEUE_SERIAL e DISPATCH_QUEUE_CONCURRENT. Naturalmente il seriale non avrà problemi di condizione di gara poiché un blocco non verrà eseguito fino a quando il precedente non sarà terminato. Ma l'altro tipo di coda potrebbe averlo.

Code predefinite:

.main-thread: Da dispatch_get_main_queue()
.libdispatch-manager: Gestore delle code di GCD
.root.libdispatch-manager: Gestore delle code di GCD
.root.maintenance-qos: Compiti a priorità più bassa
.root.maintenance-qos.overcommit
.root.background-qos: Disponibile come DISPATCH_QUEUE_PRIORITY_BACKGROUND
.root.background-qos.overcommit
.root.utility-qos: Disponibile come DISPATCH_QUEUE_PRIORITY_NON_INTERACTIVE
.root.utility-qos.overcommit
.root.default-qos: Disponibile come DISPATCH_QUEUE_PRIORITY_DEFAULT
.root.background-qos.overcommit
.root.user-initiated-qos: Disponibile come DISPATCH_QUEUE_PRIORITY_HIGH
.root.background-qos.overcommit
.root.user-interactive-qos: Priorità più alta
.root.background-qos.overcommit

Nota che sarà il sistema a decidere quali thread gestiscono quali code in ogni momento (più thread potrebbero lavorare nella stessa coda o lo stesso thread potrebbe lavorare in code diverse in un certo momento)

Attributi

Quando si crea una coda con dispatch_queue_create il terzo argomento è un dispatch_queue_attr_t, che di solito è o DISPATCH_QUEUE_SERIAL (che in realtà è NULL) o DISPATCH_QUEUE_CONCURRENT che è un puntatore a una struttura dispatch_queue_attr_t che consente di controllare alcuni parametri della coda.

Oggetti di invio

Ci sono diversi oggetti che libdispatch utilizza e code e blocchi sono solo 2 di essi. È possibile creare questi oggetti con dispatch_object_create:

blocco
dati: Blocchi di dati
gruppo: Gruppo di blocchi
io: Richieste di I/O asincrone
mach: Porte Mach
mach_msg: Messaggi Mach
pthread_root_queue: Una coda con un pool di thread pthread e senza code di lavoro
coda
semaforo
sorgente: Sorgente di eventi

Objective-C

In Objective-C ci sono diverse funzioni per inviare un blocco da eseguire in parallelo:

dispatch_async: Invia un blocco per l'esecuzione asincrona su una coda di invio e restituisce immediatamente.
dispatch_sync: Invia un oggetto blocco per l'esecuzione e restituisce dopo che quel blocco ha finito di eseguire.
dispatch_once: Esegue un blocco solo una volta per tutta la durata di un'applicazione.
dispatch_async_and_wait: Invia un elemento di lavoro per l'esecuzione e restituisce solo dopo che ha finito di eseguire. A differenza di dispatch_sync, questa funzione rispetta tutti gli attributi della coda quando esegue il blocco.

Queste funzioni si aspettano questi parametri: dispatch_queue_t queue, dispatch_block_t block

Questa è la struttura di un Blocco:

struct Block {
void *isa; // NSConcreteStackBlock,...
int flags;
int reserved;
void *invoke;
struct BlockDescriptor *descriptor;
// captured variables go here
};

E questo è un esempio per utilizzare il parallelismo con dispatch_async:

#import <Foundation/Foundation.h>

// Define a block
void (^backgroundTask)(void) = ^{
// Code to be executed in the background
for (int i = 0; i < 10; i++) {
NSLog(@"Background task %d", i);
sleep(1);  // Simulate a long-running task
}
};

int main(int argc, const char * argv[]) {
@autoreleasepool {
// Create a dispatch queue
dispatch_queue_t backgroundQueue = dispatch_queue_create("com.example.backgroundQueue", NULL);

// Submit the block to the queue for asynchronous execution
dispatch_async(backgroundQueue, backgroundTask);

// Continue with other work on the main queue or thread
for (int i = 0; i < 10; i++) {
NSLog(@"Main task %d", i);
sleep(1);  // Simulate a long-running task
}
}
return 0;
}

Swift

libswiftDispatch è una libreria che fornisce binding Swift al framework Grand Central Dispatch (GCD) originariamente scritto in C.
La libreria libswiftDispatch incapsula le API C GCD in un'interfaccia più amichevole per Swift, rendendo più semplice e intuitivo per gli sviluppatori Swift lavorare con GCD.

DispatchQueue.global().sync{ ... }
DispatchQueue.global().async{ ... }
let onceToken = DispatchOnce(); onceToken.perform { ... }
async await
var (data, response) = await URLSession.shared.data(from: URL(string: "https://api.example.com/getData"))

Esempio di codice:

import Foundation

// Define a closure (the Swift equivalent of a block)
let backgroundTask: () -> Void = {
for i in 0..<10 {
print("Background task \(i)")
sleep(1)  // Simulate a long-running task
}
}

// Entry point
autoreleasepool {
// Create a dispatch queue
let backgroundQueue = DispatchQueue(label: "com.example.backgroundQueue")

// Submit the closure to the queue for asynchronous execution
backgroundQueue.async(execute: backgroundTask)

// Continue with other work on the main queue
for i in 0..<10 {
print("Main task \(i)")
sleep(1)  // Simulate a long-running task
}
}

Frida

Il seguente script Frida può essere utilizzato per agganciarsi a diverse funzioni dispatch ed estrarre il nome della coda, la traccia dello stack e il blocco: https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js

frida -U <prog_name> -l libdispatch.js

dispatch_sync
Calling queue: com.apple.UIKit._UIReusePool.reuseSetAccess
Callback function: 0x19e3a6488 UIKitCore!__26-[_UIReusePool addObject:]_block_invoke
Backtrace:
0x19e3a6460 UIKitCore!-[_UIReusePool addObject:]
0x19e3a5db8 UIKitCore!-[UIGraphicsRenderer _enqueueContextForReuse:]
0x19e3a57fc UIKitCore!+[UIGraphicsRenderer _destroyCGContext:withRenderer:]
[...]