Process Herpaderping

Process Herpaderping è un metodo per oscurare le intenzioni di un processo modificando il contenuto su disco dopo che l'immagine è stata mappata. Ciò risulta in un comportamento curioso da parte dei prodotti di sicurezza e del sistema operativo stesso.

Sommario

Generalmente, un prodotto di sicurezza interviene sulla creazione di un processo registrando un callback nel kernel di Windows (PsSetCreateProcessNotifyRoutineEx). A questo punto, un prodotto di sicurezza può ispezionare il file usato per mappare l'eseguibile e determinare se questo processo deve essere autorizzato a essere eseguito. Questo callback del kernel viene invocato quando il thread iniziale viene inserito, non quando l'oggetto processo viene creato.

A causa di ciò, un attore può creare e mappare un processo, modificare il contenuto del file, quindi creare il thread iniziale. Un prodotto che effettua l'ispezione al callback di creazione vedrebbe il contenuto modificato. Inoltre, alcuni prodotti utilizzano un approccio di scansione su scrittura che consiste nel monitorare le scritture dei file. Un'ottimizzazione comune qui è registrare che il file è stato scritto e rimandare l'ispezione effettiva fino a quando non si verifica IRP_MJ_CLEANUP (ad esempio quando l'handle del file viene chiuso). Pertanto, un attore che utilizza un flusso di lavoro write -> map -> modify -> execute -> close eluderà la scansione su scrittura che si basa esclusivamente sull'ispezione a IRP_MJ_CLEANUP.

Per abusare di questa convenzione, scriviamo prima un binario su un file di destinazione su disco. Quindi, mappiamo un'immagine del file di destinazione e la forniamo al sistema operativo da usare per la creazione del processo. Il sistema operativo mappa gentilmente il binario originale per noi. Usando l'handle del file esistente, e prima di creare il thread iniziale, modifichiamo il contenuto del file di destinazione per oscurare o falsificare il file che supporta l'immagine. Qualche tempo dopo, creiamo il thread iniziale per iniziare l'esecuzione del binario originale. Infine, chiuderemo l'handle del file di destinazione. Esaminiamolo passo dopo passo:

1. Scrivi il binario di destinazione su disco, mantenendo l'handle aperto. Questo è ciò che verrà eseguito in memoria.
2. Mappa il file come sezione immagine (NtCreateSection, SEC_IMAGE).
3. Crea l'oggetto processo usando l'handle della sezione (NtCreateProcessEx).
4. Usando lo stesso handle del file di destinazione, oscura il file su disco.
5. Crea il thread iniziale nel processo (NtCreateThreadEx).
   • A questo punto il callback di creazione del processo nel kernel scatterà. I contenuti su disco non corrispondono a ciò che è stato mappato. L'ispezione del file in questo momento porterà a un'attribuzione errata.
6. Chiudi l'handle. IRP_MJ_CLEANUP si verificherà qui.
   • Poiché abbiamo nascosto i contenuti di ciò che è in esecuzione, l'ispezione in questo momento porterà a un'attribuzione errata.

@startuml
hide empty description

[*] --> CreateFile
CreateFile --> FileHandle
FileHandle --> Write
FileHandle --> NtCreateSection
Write -[hidden]-> NtCreateSection
NtCreateSection --> SectionHandle
SectionHandle --> NtCreateProcessEx
FileHandle --> Modify
NtCreateProcessEx -[hidden]-> Modify
NtCreateProcessEx --> NtCreateThreadEx
Modify -[hidden]-> NtCreateThreadEx
NtCreateThreadEx --> [*]
FileHandle --> CloseFile
NtCreateThreadEx -[hidden]-> CloseFile
NtCreateThreadEx --> PspCallProcessNotifyRoutines
PspCallProcessNotifyRoutines -[hidden]-> [*]
CloseFile --> IRP_MJ_CLEANUP
IRP_MJ_CLEANUP -[hidden]-> [*]
PspCallProcessNotifyRoutines --> Inspect
PspCallProcessNotifyRoutines -[hidden]-> CloseFile 
IRP_MJ_CLEANUP --> Inspect
Inspect -[hidden]-> [*]

CreateFile : Crea il file di destinazione, mantieni l'handle aperto.
Write : Scrivi il payload sorgente nel file di destinazione.
Modify : Oscura il file su disco.
NtCreateSection : Crea la sezione usando l'handle del file.
NtCreateProcessEx : La sezione immagine per il processo viene mappata e memorizzata nella cache nell'oggetto file.
NtCreateThreadEx : La sezione in cache viene utilizzata.
NtCreateThreadEx : Le routine di notifica del processo scattano nel kernel.
Inspect : I contenuti su disco non corrispondono a ciò che è stato eseguito. 
Inspect : L'ispezione del file in questo momento porterà a un'attribuzione errata.
@enduml

Comportamento

Vedrai nella demo qui sotto, CMD.exe è usato come destinazione di esecuzione. La prima esecuzione sovrascrive i byte su disco con un pattern. La seconda esecuzione sovrascrive CMD.exe con ProcessHacker.exe. Lo strumento Herpaderping aggiusta il binario per assomigliare il più possibile a ProcessHacker.exe, conservando persino la firma originale. Nota le molteplici esecuzioni dello stesso binario e come il processo appare all'utente rispetto a ciò che è nel file su disco.

Approfondimento

Abbiamo osservato il comportamento e parte di questo potrebbe sorprendere. Proviamo a spiegare questo comportamento.

Approfondimento tecnico

Contesto e Motivazione

Nella progettazione di prodotti per la protezione delle piattaforme Windows, molti ingegneri in questo settore (me compreso) hanno fatto affidamento su nozioni preconcette riguardo a come il sistema operativo gestirà i dati. In questo scenario, alcuni potrebbero aspettarsi che il file su disco rimanga "bloccato" quando il processo viene creato. Non puoi eliminare il file. Non puoi scriverci. Ma puoi rinominarlo. Come si vede qui, nelle giuste condizioni, puoi effettivamente scriverci. Rimani vigile sulle tue supposizioni, mettile sempre in discussione e fai le tue ricerche.

La motivazione per questa ricerca è nata quando ho scoperto come eseguire l'analisi quando un file viene scritto. Con il precedente background nella ricerca su Process Hollowing e Doppelganging, avevo teorizzato che questo potesse essere possibile. L'obiettivo è fornire una migliore sicurezza. Non puoi creare una serratura migliore senza prima capire come rompere quella vecchia.

Tecniche Simili

Herpaderping è simile a Hollowing e Doppelganging, tuttavia ci sono alcune differenze chiave:

Process Hollowing

Process Hollowing implica modificare la sezione mappata prima che l'esecuzione inizi, che in astratto appare così: map -> modify section -> execute. Questo flusso di lavoro porta il flusso di esecuzione previsto del processo Hollowed a divergere in codice non inteso. Doppelganging potrebbe essere considerato una forma di Hollowing. Tuttavia, Hollowing, a mio parere, è più vicino all'iniezione in quanto Hollowing di solito implica una scrittura esplicita nel codice già mappato. Questo differisce da Herpaderping dove non ci sono sezioni modificate.

Process Doppelganging

Process Doppelganging è più vicino a Herpaderping. Doppelganging abusa delle operazioni su file in transazione e generalmente prevede questi passaggi: transact -> write -> map -> rollback -> execute. In questo flusso di lavoro, il sistema operativo creerà la sezione immagine e gestirà le transazioni, quindi la sezione immagine memorizzata nella cache finisce per essere ciò che hai scritto nella transazione. Il sistema operativo ha corretto questa tecnica. Beh, hanno corretto il crash che causava. Forse considerano questo un uso "legale" di una transazione. Fortunatamente, Windows Defender cattura la tecnica Doppelganging. Doppelganging differisce da Herpaderping in quanto Herpaderping non si basa su operazioni su file in transazione. E Defender non cattura Herpaderping.

Confronto

Per riferimento, le tecniche generalizzate:

Possiamo vedere le differenze qui. Sebbene Herpaderping sia probabilmente più rumoroso di Doppelganging, in quanto i bit malevoli arrivano effettivamente sul disco, abbiamo visto che i prodotti di sicurezza sono ancora incapaci di rilevare Herpaderping.

Possibile Soluzione

Non c'è una soluzione chiara qui. Sembra ragionevole che impedire a una sezione immagine di essere mappata/memorizzata in cache quando c'è accesso in scrittura al file dovrebbe chiudere il buco. Tuttavia, potrebbe non essere una soluzione pratica.

Un'altra opzione potrebbe essere di scaricare le modifiche al file nella sezione immagine memorizzata in cache se non è stata ancora mappata in un processo. Tuttavia, poiché la mappatura nel nuovo processo avviene a NtCreateProcess, probabilmente non è una soluzione valida.

Da un punto di vista del rilevamento, non c'è un buon modo per identificare i bit effettivi che sono stati mappati; l'ispezione a IRP_MJ_CLEANUP o un callback registrato a PsSetCreateProcessNotifyRoutineEx porta a un'attribuzione errata poiché i bit su disco sono stati modificati; dovresti ricostruire il file dalla sezione che è stata creata. Vale la pena notare qui che c'è un nuovo callback in Windows 10 a cui puoi registrarti, PsSetCreateProcessNotifyRoutineEx2, tuttavia soffre dello stesso problema del callback precedente: viene chiamato quando il thread iniziale viene eseguito, non quando l'oggetto processo viene creato. Microsoft ha aggiunto PsSetCreateThreadNotifyRoutineEx che viene chiamato quando il thread iniziale viene inserito se registrato con PsCreateThreadNotifyNonSystem, a differenza di quando sta per iniziare l'esecuzione (come faceva il vecchio callback). Estendere PSCREATEPROCESSNOTIFYTYPE per essere chiamato quando l'oggetto processo viene creato non aiuterà; abbiamo visto nella sezione Approfondimento che l'oggetto sezione immagine viene memorizzato nella cache alla chiamata NtCreateSection, non a NtCreateProcess.

Non possiamo identificare facilmente cosa è stato eseguito. Siamo lasciati a cercare di rilevare il comportamento sfruttatore da parte dell'attore; lascio la scoperta degli indicatori comportamentali come esercizio per il lettore.

Piattaforme Notevolmente Affette

Di seguito è riportato un elenco di prodotti e sistemi operativi Windows che sono stati testati al (31/8/2020). I test sono stati effettuati con un binario notoriamente malevolo.

Divulgazione Responsabile

Questa vulnerabilità è stata divulgata al Microsoft Security Response Center (MSRC) il 17/7/2020 e un caso è stato aperto da MSRC il 22/7/2020. MSRC ha concluso la loro indagine il 25/8/2020 e ha stabilito che i risultati sono validi ma non soddisfano i loro criteri per una correzione immediata. Al momento il loro caso è chiuso, senza risoluzione, ed è segnato per una revisione futura, senza una tempistica.

Siamo in disaccordo sulla gravità di questo bug; questo è stato comunicato a MSRC il 27/8/2020.

1. Ci sono vulnerabilità simili in questa classe (Hollowing e Doppelganging).
2. La vulnerabilità si dimostra capace di sconfiggere le funzionalità di sicurezza inerenti al sistema operativo (Windows Defender).
3. La vulnerabilità consente a un attore di ottenere l'esecuzione di codice arbitrario.
4. L'utente non viene informato dell'esecuzione di codice non inteso.
5. Le informazioni sul processo presentate all'utente non riflettono accuratamente ciò che è in esecuzione.
6. Le strutture per identificare accuratamente il processo non sono intuitive o sono errate, persino dal kernel.

Sorgente

Questo repository contiene uno strumento per esercitare il metodo Herpaderping di offuscamento del processo. L'utilizzo è il seguente:

Process Herpaderping Tool - Copyright (c) Johnny Shaw
ProcessHerpaderping.exe SourceFile TargetFile [ReplacedWith] [Options...]
Usage:
  SourceFile               Source file to execute.
  TargetFile               Target file to execute the source from.
  ReplacedWith             File to replace the target with. Optional,
                           default overwrites the binary with a pattern.
  -h,--help                Prints tool usage.
  -d,--do-not-wait         Does not wait for spawned process to exit,
                           default waits.
  -l,--logging-mask number Specifies the logging mask, defaults to full
                           logging.
                               0x1   Successes
                               0x2   Informational
                               0x4   Warnings
                               0x8   Errors
                               0x10  Contextual
  -q,--quiet               Runs quietly, overrides logging mask, no title.
  -r,--random-obfuscation  Uses random bytes rather than a pattern for
                           file obfuscation.
  -e,--exclusive           Target file is created with exclusive access and
                           the handle is held open as long as possible.
                           Without this option the handle has full share
                           access and is closed as soon as possible.
  -u,--do-not-flush-file   Does not flush file after overwrite.
  -c,--close-file-early    Closes file before thread creation (before the
                           process notify callback fires in the kernel).
                           Not valid with "--exclusive" option.
  -k,--kill                Terminates the spawned process regardless of
                           success or failure, this is useful in some
                           automation environments. Forces "--do-not-wait
                           option.

Clonazione e Compilazione

Il repository usa sottomoduli, dopo la clonazione assicurati di inizializzare e aggiornare i sottomoduli. I file di progetto sono mirati a Visual Studio 2019.

git clone https://github.com/jxy-s/herpaderping.git
cd .\herpaderping\
git submodule update --init --recursive
MSBuild .\herpaderping.sln

Crediti

I seguenti sono utilizzati senza modifiche. Crediti ai loro autori.

• Windows Implementation Libraries (WIL)
  Una libreria C++ solo header creata per semplificare la vita degli sviluppatori su Windows attraverso interfacce C++ leggibili e type-safe per i pattern comuni di codifica Windows.
• Process Hacker Native API Headers
  Collezione di file header dell'API Native. Raccolti da file header e file di simboli Microsoft, oltre a molto reverse engineering e deduzioni.