DeathSleep

Prima di tutto

Tutto ciò che è affermato qui deriva dalla mia comprensione dei vari argomenti trattati, sia tramite lettura che esperienza durante lo sviluppo. Sono consapevole di non essere un esperto e l'ultima cosa che voglio è diffondere disinformazione, quindi se pensi che qualcosa non sia corretto, mi piacerebbe che me lo facessi notare, puoi contattarmi su twitter o aprendo issue in questo repo. Grazie mille per la tua comprensione. :)

Basi

L'obiettivo principale di questa tecnica è chiaro: terminare il thread corrente e ripristinarlo prima di riprendere l'esecuzione, ma cosa significa esattamente e quali nuovi vincoli impone?

Per poter ripristinare l'esecuzione, dobbiamo salvare due cose prima di terminare il thread: primo, lo stato della CPU, e secondo, lo stack, e impostarli di nuovo efficacemente dopo che il nuovo thread è stato lanciato.

Ho parlato di nuovi vincoli che appariranno in questa tecnica, e ce ne sono due grandi: Primo, dobbiamo memorizzare al di fuori dello stack tutto ciò di cui abbiamo bisogno dal momento in cui il thread termina fino a quando lo stack viene ripristinato, e come vedrete, crea alcune nuove sfide.

Secondo, abbiamo sempre bisogno di almeno un altro thread in esecuzione nel nostro processo, poiché stiamo terminando il nostro thread, se non ci sono altri thread il processo terminerà. Non penso che questo sia un grosso problema, poiché la maggior parte degli agenti vengono iniettati in altri processi, possiamo presumere che questo processo manterrà almeno un thread in esecuzione.

Componenti di DeathSleep:

Possiamo vedere in questo POC 4 funzioni principali:

• Programma principale: Qui è dove scriveresti il codice del tuo agente, ed è la porzione di codice che farà uso di DeathSleep
• Funzione Awake: questo è il punto di ingresso di tutti i nostri thread, ed è responsabile di salvare il punto di partenza dello stack che ripristineremo. Inoltre, è responsabile di ripristinare lo stack e il contesto CPU quando necessario, o semplicemente di avviare il nostro programma principale.
• DeathSleep: questa è la funzione principale di questa tecnica, ed è responsabile di eseguire il backup del contesto del thread e dello stack, e anche di preparare tutto per la magia.
• Rebirth: Una semplice funzione responsabile solo di lanciare i nostri nuovi thread.

Salvare lo stack.

Quando stiamo per salvare lo stack, sorge una domanda: quanto dello stack deve essere salvato?

Rivediamo prima cosa c'è nello stack dopo aver chiamato la funzione DeathSleep (questa è la funzione che salva il contesto, lo stack e prepara tutto per l'offuscamento e il ripristino)

Come possiamo vedere, ogni funzione ha tre parti:

• Shadow space: questo è uno spazio di 32 byte, allocato dal chiamante, ma utilizzato dal chiamato. Per quanto ne so e ho potuto vedere, la sua funzione principale è contenere, se necessario, gli argomenti passati alla funzione chiamata nei registri, ma può essere utilizzato per qualsiasi cosa decida la funzione chiamata.
• Indirizzo di ritorno: questo è l'indirizzo della prossima istruzione da eseguire nella funzione chiamante, inserito dall'istruzione CALL, quindi l'istruzione RET nella funzione chiamata prenderà semplicemente questo indirizzo e "salterà" ad esso quando termina.
• Spazio dello stack della funzione: Questo è lo spazio riservato dal chiamato per memorizzare il valore dei registri che devono essere ripristinati e il valore delle sue variabili locali.

La porzione minima dello stack che ovviamente dobbiamo salvare è tutto ciò che è all'interno del nostro programma principale, cioè il suo shadow space, il suo indirizzo di ritorno e tutto fino alla funzione DeathSleep. Tutto ciò che precede non è realmente necessario (salvare lo stack usato dalla funzione di ingresso ha i suoi vantaggi, ma ne discuteremo più avanti), poiché quello è lo stack utilizzato dalle routine di Windows per lanciare il nostro nuovo thread. Oltre a questo, ho deciso di memorizzare anche lo shadow space della funzione DeathSleep (non realmente necessario, ma rende il calcolo dell'Rsp al momento del risveglio più facile).

Quindi alla fine, stiamo salvando questo:

Come trovare i nostri indirizzi di stack:

Ogni funzione in una compilazione standard dovrebbe essere composta da 3 parti: il prologo, il codice della funzione e l'epilogo.

L'Rsp (puntatore allo stack) dovrebbe essere modificato solo nel prologo e nell'epilogo della funzione. Il prologo aumenta il puntatore dello stack (ricorda che aumentare lo stack significa ridurre gli indirizzi, poiché vanno in direzioni opposte), per salvare i registri, per contenere tutte le sue variabili locali e poi per contenere lo shadow space, e l'epilogo fa esattamente l'opposto.