Ausführbare Dateien kategorisieren - Schneller Blick in eine ausführbare Datei

Ausführbare Dateien kategorisieren

Schneller Blick in eine ausführbare Datei

Rocco Gagliardi
von Rocco Gagliardi
am 08. September 2022
Lesezeit: 20 Minuten

Keypoints

So analysieren und kategorisieren Sie ausführbare Dateien

  • Oft müssen wir wissen, ob ein Dateiobjekt bestimmte Operationen ausführt oder nicht
  • Es gibt Werkzeuge und Techniken, mit denen wir schnell feststellen können, ob ein Code eine verdächtige Funktion oder ein verdächtiges Muster verwendet
  • Die Definition unseres Ziels ist der schwierigste Teil des gesamten Prozesses
  • Entwickeln Sie Ihre eigenen Werkzeuge, studieren Sie alle Optionen und verwenden Sie diese, um Ihren Code in einer isolierten Umgebung zu analysieren

Gelegentlich müssen wir während unserer Projekte eine Software eingehend untersuchen, ohne Zugang zum Quellcode zu haben. Zum Beispiel kann es erforderlich sein, zu verstehen, wie eine mobile App funktioniert, um zu prüfen, ob sie bestimmte Operationen ausführt oder nicht, oder einfach um zu sehen, ob sie etwas hat, das uns erlaubt, Operationen auszuführen, die nicht vorgesehen waren.

Tomaso Vasella zum Beispiel erklärt in Analysis of mobile applications, wie man eine Android-Anwendung mit Hilfe von Reverse-Engineering-Techniken analysiert (eine grundlegende Einführung in das Reverse-Engineering finden Sie in Reverse Engineering von Ralph Meier). Der Artikel zeigt, wie man einige sehr komplexe Verfahren und Technologien einsetzt, die ein normaler IT-Benutzer wahrscheinlich nicht anwenden kann oder keine Zeit dafür hätte, wenn er es eilig hätte.

Auch wenn tcpdump nicht das erste Werkzeug ist, das Sie bei einem Netzwerkproblem verwenden sollten, gibt es doch einige grundlegende Schritte, die Sie durchführen können, bevor Sie Ghidra starten und anfangen, durch den Code hin und her zu springen.

Wo wollen wir hin?

Wenn Sie eine ausführbare Datei erhalten, ist Ihr erster Gedanke wahrscheinlich: Wo fange ich an? Wenn Sie nur wissen wollen, ob eine Gefahr besteht oder nicht, ist ein Antivirusprogramm unserer Meinung nach ein guter Anfang. Es kann jedoch noch mehr getan werden.

Die Analyse kann grob in statisch und dynamisch unterteilt werden, wie wir in Reverse Engineering gesehen haben. Im Gegensatz zur dynamischen Analyse, die sich auf die Aktivität des Objekts konzentriert, betrachtet die statische Analyse das Aussehen des Objekts. Da die statische Analyse keine laufenden Programme benötigt, ist sie viel einfacher und sicherer. Diese Art der Analyse ist jedoch keine exakte Wissenschaft. Jeder von uns entwickelt im Laufe der Zeit persönliche Fähigkeiten und Methoden, aber die Aufgabe besteht in erster Linie darin, die durch den Code verbreiteten Informationen zu suchen, zu sammeln und zu korrelieren. Es gibt keine Checkliste, der man folgen kann, aber es gibt bekannte Muster und Werkzeuge, die man verwenden kann.

Die zu befolgenden allgemeinen Schritte sind logisch und einfach:

Was wir wissen wollen

Dies ist die schwierigste Phase des Verfahrens. Wir werden zweifellos viele Hinweise finden, wenn wir anfangen, “nach etwas zu suchen”, aber sie werden entweder nicht hilfreich sein oder wir werden viel Zeit damit verbracht haben, unnütze Hinweise zu sammeln.

Daher müssen wir zumindest allgemein den Bereich definieren, an dem wir interessiert sind: Netzwerk-, Dateisystem- oder Registrierungszugriff, Überwachung, Verschleierungs- oder Umgehungsmethoden usw. Auf diese Weise können wir das Objekt nach Verweisen auf bestimmte Funktionen durchsuchen und schnell entscheiden, ob wir es eingehender untersuchen oder zum nächsten Punkt übergehen wollen.

Die Dinge sind nicht immer so einfach; die Programmierer dieser Objekte wenden bestimmte Taktiken an, um Untersuchungen zu erschweren und die Aktivitäten, die das Objekt ausführen soll, so lange wie möglich zu verbergen. So setzen sie beispielsweise Verschleierungsmethoden ein (z. B. Verpacken), oder sie versuchen im Falle einer dynamischen Analyse herauszufinden, ob ein Benutzer wirklich mit dem Objekt arbeitet, ob es in einer Sandbox betrieben wird oder ob jemand versucht, die Aktivitäten des Objekts zu überwachen. Dies sind nur einige der Techniken, die eingesetzt werden, um zu vermeiden, dass moderne Schutzsysteme sie als Gefahr identifizieren.

Lassen Sie uns nun den Umfang unserer Untersuchung festlegen. Wir wollen feststellen, ob das Objekt:

Um eine schnelle erste Antwort zu erhalten – idealerweise innerhalb von Minuten – werden wir nur die statische Analyse anwenden, bevor wir entscheiden, ob wir zur dynamischen Analyse oder sogar zu Disassemblierungstechniken übergehen.

Toolset

Das Toolset hängt von der jeweiligen Situation ab. Wählen Sie Ihre Werkzeuge aus, studieren Sie ihre Optionen im Detail und verwenden Sie sie, um das Objekt in einer isolierten Umgebung zu analysieren, normalerweise eine virtuelle Maschine ohne ständige Netzverbindung. Mit Ausnahme der Untersuchung bestimmter Objekte, wie .NET, kann der statische Teil auf jedem Betriebssystem durchgeführt werden. Wir bevorzugen REMnux, eine spezielle Linux-Distribution, die die meisten unserer bevorzugten Werkzeuge enthält. Unter Windows haben wir die entsprechende Version der meisten Tools zur Verfügung, und wie Mark Russinovich zu sagen pflegt: Im Zweifelsfall procmon ausführen!

Womit wir es zu tun haben

Das folgende Objekt sample_01.exe wurde für die Experimente verwendet. Es ist ratsam, die URL nach dem Lesen des Artikels zu besuchen, wenn Sie mit MalwareBazaar (oder anderen Websites ähnlicher Art) nicht vertraut sind, um die Bedeutung der präsentierten Daten besser einschätzen zu können.

remnux@remnux:~/Desktop/malware/Injecting$ 7z e 24797d733e9fdd39bcf5b3910438bb449c84428082325f27652330019be683b3.zip

7-Zip [64] 16.02 : Copyright (c) 1999-2016 Igor Pavlov : 2016-05-21
p7zip Version 16.02 (locale=en_US.UTF-8,Utf16=on,HugeFiles=on,64 bits,2 CPUs Intel(R) Core(TM) i7-8550U CPU @ 1.80GHz (806EA),ASM,AES-NI)

Scanning the drive for archives:
1 file, 204544 bytes (200 KiB)

Extracting archive: 24797d733e9fdd39bcf5b3910438bb449c84428082325f27652330019be683b3.zip
--
Path = 24797d733e9fdd39bcf5b3910438bb449c84428082325f27652330019be683b3.zip
Type = zip
Physical Size = 204544


Enter password (will not be echoed): >infected<
Everything is Ok                                                           

Size:       208384
Compressed: 204544

remnux@remnux:~/Desktop/malware/Injecting$ mv 24797d733e9fdd39bcf5b3910438bb449c84428082325f27652330019be683b3.exe sample_01.exe

Der erste Schritt ist, zu verstehen, was wir vor uns haben. Wir neigen zu der Annahme, dass die Erweiterung exe mit Windows verbunden ist, aber in Wirklichkeit gibt es mehrere Formate von ausführbaren Dateien, die die Erweiterung exe verwenden. Wir können verschiedene Werkzeuge verwenden, aber die einfachsten sind Datei oder TrID:

emnux@remnux:~/Desktop/malware/Injecting$ file sample_01.exe
sample_01.exe: PE32 executable (GUI) Intel 80386, for MS Windows, UPX compressed


remnux@remnux:~/Desktop/malware/Injecting$ trid sample_01.exe

TrID/32 - File Identifier v2.24 - (C) 2003-16 By M.Pontello
Definitions found:  14978
Analyzing...

Collecting data from file: sample_01.exe
 63.4% (.EXE) UPX compressed Win32 Executable (27066/9/6)
 11.8% (.EXE) Win16 NE executable (generic) (5038/12/1)
 10.5% (.EXE) Win32 Executable (generic) (4505/5/1)
  4.7% (.EXE) OS/2 Executable (generic) (2029/13)
  4.6% (.EXE) Generic Win/DOS Executable (2002/3)

Bei diesem Objekt handelt es sich um eine Portable Executable für MS Windows und wir können sofort ein Detail feststellen: Es enthält komprimierten Code. Der Kompressionsmechanismus ist in diesem Fall wohlbekannt: UPX und wir können den komprimierten Teil einfach extrahieren:

remnux@remnux:~/Desktop/malware/Injecting$ upx -d sample_01.exe -o sample_01.exe_upx_unpacked 
                       Ultimate Packer for eXecutables
                          Copyright (C) 1996 - 2020
UPX 3.96        Markus Oberhumer, Laszlo Molnar & John Reiser   Jan 23rd 2020

        File size         Ratio      Format      Name
   --------------------   ------   -----------   -----------
upx: sample_01.exe: FileAlreadyExistsException: sample_01.exe_upx_unpacked: File exists

Unpacked 0 files.

remnux@remnux:~/Desktop/malware/Injecting$ file sample_01.exe_upx_unpacked 
sample_01.exe_upx_unpacked: PE32 executable (GUI) Intel 80386, for MS Windows

Nach der Dekomprimierung können wir den Inhalt untersuchen:

remnux@remnux:~/Desktop/malware/Injecting$ binwalk -B sample_01.exe_upx_unpacked

DECIMAL       HEXADECIMAL     DESCRIPTION
--------------------------------------------------------------------------------
0             0x0             Microsoft executable, portable (PE)
146968        0x23E18         CRC32 polynomial table, little endian
151840        0x25120         Microsoft executable, portable (PE)
462541        0x70ECD         mcrypt 2.5 encrypted data, algorithm: "sProcessorFeaturePresent", keysize: 1069 bytes, mode: "Q",
463648        0x71320         CRC32 polynomial table, little endian
470260        0x72CF4         XML document, version: "1.0"
483616        0x76120         Microsoft executable, portable (PE)
562449        0x89511         mcrypt 2.5 encrypted data, algorithm: "sProcessorFeaturePresent", keysize: 1069 bytes, mode: "Q",
566944        0x8A6A0         XML document, version: "1.0"
572512        0x8BC60         XML document, version: "1.0"

Wie wir bereits wissen, handelt es sich um ein Microsoft executable, portable (PE), dennoch erscheint diese Zeichenfolge drei Mal! Das Objekt enthält höchstwahrscheinlich mehrere ausführbare Dateien. Falls erforderlich, können die verschiedenen ausführbaren Dateien unabhängig voneinander extrahiert und analysiert werden (es gibt zwei DLL-Dateien):

remnux@remnux:~/Desktop/malware/Injecting$ ll
total 980
drwxrwxr-x 2 remnux remnux   4096 Aug 29 03:28 ./
drwxrwxr-x 8 remnux remnux   4096 Aug 27 05:22 ../
-rw-rw-r-- 1 remnux remnux 204544 Aug 27 05:20 24797d733e9fdd39bcf5b3910438bb449c84428082325f27652330019be683b3.zip
-rw-r--r-- 1 remnux remnux 208384 Aug 27 09:20 sample_01.exe
-rw-r--r-- 1 remnux remnux 579072 Aug 27 09:20 sample_01.exe_upx_unpacked

remnux@remnux:~/Desktop/malware/Injecting$ pecheck -lP -go -D sample_01.exe_upx_unpacked
1: 0x00000000 EXE 32-bit 0x0008d5ff ae78a0d8bee1c8eb4d78e60edd1cc607 0x0008d5ff (EOF) b'' b''
2: 0x00025120 DLL 32-bit 0x0007611f 18c6220175e258be5af701ee26a57c72 0x0008d5ff (EOF) b'' b''
3: 0x00076120 DLL 32-bit 0x0008bb1f e026b2666d2ae5583a934b0f9d4b5d03 0x0008d5ff (EOF) b'' b'ReflectiveLoader32.dll'

remnux@remnux:~/Desktop/malware/Injecting$ ll
total 1960
drwxrwxr-x 2 remnux remnux   4096 Aug 29 03:29 ./
drwxrwxr-x 8 remnux remnux   4096 Aug 27 05:22 ../
-rw-rw-r-- 1 remnux remnux 331776 Aug 29 03:29 18c6220175e258be5af701ee26a57c72.vir
-rw-rw-r-- 1 remnux remnux 204544 Aug 27 05:20 24797d733e9fdd39bcf5b3910438bb449c84428082325f27652330019be683b3.zip
-rw-rw-r-- 1 remnux remnux 579072 Aug 29 03:29 ae78a0d8bee1c8eb4d78e60edd1cc607.vir
-rw-rw-r-- 1 remnux remnux  88576 Aug 29 03:29 e026b2666d2ae5583a934b0f9d4b5d03.vir
-rw-r--r-- 1 remnux remnux 208384 Aug 27 09:20 sample_01.exe
-rw-r--r-- 1 remnux remnux 579072 Aug 27 09:20 sample_01.exe_upx_unpacked

Erste Antwort: Das Objekt verwendet Verschleierungssysteme, auch wenn diese nicht sehr komplex sind.

Lassen Sie uns nun nach einigen netzwerkbezogenen Hinweisen suchen, wie IP-Adressen oder FQDNs. Wir suchen einfach nach statischen Zeichenketten im Code, indem wir strings verwenden, um schnell ein Ergebnis zu erhalten, das malaji.top nach einer kurzen Websuche als eine Domäne identifiziert, die zum Hosten von Befehls- und Kontrollinstrumenten verwendet wird.

remnux@remnux:~/Desktop/malware/Injecting$ strings -7 --encoding=l sample_01.exe_upx_unpacked | grep -E -o "([0-9]{1,3}[\.]){3}[0-9]{1,3}"
0.0.0.0
1.0.0.1
1.0.0.1

remnux@remnux:~/Desktop/malware/Injecting$ strings -7 --encoding=l sample_01.exe_upx_unpacked | grep -E -o "\w+\.\w+\.\w+"
poilcy.itosha.top
reserve.itosha.top
poilcy.malaji.top
reserve.malaji.top
www.itosha.top
site.itosha.top
www.malaji.top
q5y2qclsk18.malaji.top
0.0.0
1.0.0
1.0.0

Zweite Antwort: Es ist sehr wahrscheinlich, dass externe Server, die mit Malware in Verbindung stehen, kontaktiert werden.

Wir können auch Aufrufe bestimmter Funktionen mit Hilfe von Strings filtern. Jeder entwickelt mit zunehmender Erfahrung seine eigene Liste verdächtiger Funktionen; in diesem Fall sind wir an Funktionen interessiert, die Code einspeisen, und eine der am häufigsten verwendeten ist CreateRemoteThread.

remnux@remnux:~/Desktop/malware/Injecting$ strings sample_01.exe_upx_unpacked | egrep -Ha "Create|Debug"
(standard input):CreateThread
(standard input):CreateProcessW
(standard input):CreateFileW
(standard input):OutputDebugStringA
-> (standard input):CreateRemoteThread
(standard input):CreateFileMappingW
(standard input):CreateEventW
(standard input):IsDebuggerPresent
(standard input):CTcpServer::CreateListenSocket
(standard input):CreateFileTransactedW
(standard input):WSACreateEvent
(standard input):CreateEventW
(standard input):CreateMutexW
(standard input):CreateThread
(standard input):CreateFileW
(standard input):CreateFileMappingW
(standard input):OutputDebugStringA
(standard input):HeapCreate
(standard input):CreateIoCompletionPort
(standard input):CreateSemaphoreW
(standard input):IsDebuggerPresent
(standard input):OutputDebugStringW
(standard input):CreateThread
(standard input):IsDebuggerPresent
(standard input):CreateFileW

Dritte Antwort: Es ist sehr wahrscheinlich, dass das Objekt versucht, Code in einen anderen Prozess einzuschleusen.

All diese Beweise lassen vermuten, dass das Objekt mehrere für böswillige Programmierung übliche Taktiken anwendet, und wir können zu einer eingehenderen Analyse übergehen.

Magic Tools

Es dauerte nicht lange, bis wir unser Objekt mit etwas Mühe als potenziell bösartig einstufen konnten. Dennoch mussten wir mehrere Tools einsetzen und die Menge an Informationen filtern, die jedes Tool an uns zurückgab. Das, was wir getan haben, ist kein Wunder; es handelt sich um einfache Muster, die normalerweise verwendet werden.

Das Ziel von capa, einem Programm zur Erkennung von Fähigkeiten in ausführbaren Dateien, ist es, diese Suchvorgänge zu automatisieren. Führen Sie es einfach gegen eine ausführbare Datei aus und es wird Ihnen sagen, wozu das Programm seiner Meinung nach fähig ist.

remnux@remnux:~/Desktop/malware/Injecting$ capa sample_01.exe
loading : 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 661/661 [00:00<00:00, 2281.69 rules/s]
WARNING:capa:--------------------------------------------------------------------------------
WARNING:capa: This sample appears to be packed.
WARNING:capa: 
WARNING:capa: Packed samples have often been obfuscated to hide their logic.
WARNING:capa: capa cannot handle obfuscation well. This means the results may be misleading or incomplete.
WARNING:capa: If possible, you should try to unpack this input file before analyzing it with capa.
WARNING:capa: 
WARNING:capa: Identified via rule: (internal) packer file limitation
WARNING:capa: 
WARNING:capa: Use -v or -vv if you really want to see the capabilities identified by capa.
WARNING:capa:--------------------------------------------------------------------------------

Nach der vorgeschlagenen Dekomprimierung:

remnux@remnux:~/Desktop/malware/Injecting$ capa sample_01.exe_upx_unpacked 
loading : 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 661/661 [00:00<00:00, 2189.72 rules/s]
matching: 100%|█████████████████████████████████████████████████████████████████████████████████████| 749/749 [00:05<00:00, 144.79 functions/s, skipped 443 library functions (59%)]
+------------------------+------------------------------------------------------------------------------------+
| md5                    | ae78a0d8bee1c8eb4d78e60edd1cc607                                                   |
| sha1                   | 89ae94027b21be1e58ad87794102cda58e48c369                                           |
| sha256                 | 6a0fee390b022dabe88985bdeca5a46b55ae647ccb646288fcae3a6017eecbe4                   |
| os                     | windows                                                                            |
| format                 | pe                                                                                 |
| arch                   | i386                                                                               |
| path                   | sample_01.exe_upx_unpacked                                                         |
+------------------------+------------------------------------------------------------------------------------+

+------------------------+------------------------------------------------------------------------------------+
| ATT&CK Tactic          | ATT&CK Technique                                                                    |
|------------------------+------------------------------------------------------------------------------------|
| DEFENSE EVASION        | Indicator Removal on Host::File Deletion T1070.004                                 |
|                        | Obfuscated Files or Information:: T1027                                            |
|                        | Process Injection::Thread Execution Hijacking T1055.003                            |
|                        | Reflective Code Loading:: T1620                                                    |
| DISCOVERY              | File and Directory Discovery:: T1083                                               |
|                        | System Information Discovery:: T1082                                               |
| EXECUTION              | Shared Modules:: T1129                                                             |
| PRIVILEGE ESCALATION   | Access Token Manipulation:: T1134                                                  |
+------------------------+------------------------------------------------------------------------------------+

+-----------------------------+-------------------------------------------------------------------------------+
| MBC Objective               | MBC Behavior                                                                  |
|-----------------------------+-------------------------------------------------------------------------------|
| DATA                        | Encode Data::XOR [C0026.002]                                                  |
| DEFENSE EVASION             | Obfuscated Files or Information::Encoding-Standard Algorithm [E1027.m02]      |
|                             | Self Deletion::COMSPEC Environment Variable [F0007.001]                       |
| EXECUTION                   | Install Additional Program:: [B0023]                                          |
| FILE SYSTEM                 | Delete File:: [C0047]                                                         |
|                             | Get File Attributes:: [C0049]                                                 |
|                             | Read File:: [C0051]                                                           |
|                             | Writes File:: [C0052]                                                         |
| MEMORY                      | Allocate Memory:: [C0007]                                                     |
| OPERATING SYSTEM            | Environment Variable::Get Variable [C0034.002]                                |
| PROCESS                     | Check Mutex:: [C0043]                                                         |
|                             | Create Process:: [C0017]                                                      |
|                             | Create Process::Create Suspended Process [C0017.003]                          |
|                             | Create Thread:: [C0038]                                                       |
|                             | Resume Thread:: [C0054]                                                       |
+-----------------------------+-------------------------------------------------------------------------------+

+------------------------------------------------------+------------------------------------------------------+
| CAPABILITY                                           | NAMESPACE                                            |
|------------------------------------------------------+------------------------------------------------------|
| self delete                                          | anti-analysis/anti-forensic/self-deletion            |
| get MAC address on Windows                           | collection/network                                   |
| encode data using XOR                                | data-manipulation/encoding/xor                       |
| contains PDB path                                    | executable/pe/pdb                                    |
| contain a resource (.rsrc) section                   | executable/pe/section/rsrc                           |
| extract resource via kernel32 functions              | executable/resource                                  |
| contain an embedded PE file                          | executable/subfile/pe                                |
| get common file path (2 matches)                     | host-interaction/file-system                         |
| delete file                                          | host-interaction/file-system/delete                  |
| check if file exists                                 | host-interaction/file-system/exists                  |
| enumerate files via kernel32 functions               | host-interaction/file-system/files/list              |
| get file attributes                                  | host-interaction/file-system/meta                    |
| read file via mapping                                | host-interaction/file-system/read                    |
| write file on Windows (3 matches)                    | host-interaction/file-system/write                   |
| get disk information                                 | host-interaction/hardware/storage                    |
| print debug messages                                 | host-interaction/log/debug/write-event               |
| check mutex                                          | host-interaction/mutex                               |
| get system information on Windows (3 matches)        | host-interaction/os/info                             |
| check OS version                                     | host-interaction/os/version                          |
| create process on Windows (2 matches)                | host-interaction/process/create                      |
| create process suspended                             | host-interaction/process/create                      |
| inject thread                                        | host-interaction/process/inject                      |
| acquire debug privileges                             | host-interaction/process/modify                      |
| modify access privileges                             | host-interaction/process/modify                      |
| resume thread                                        | host-interaction/thread/resume                       |
| link function at runtime on Windows (5 matches)      | linking/runtime-linking                              |
| parse PE header (2 matches)                          | load-code/pe                                         |
| spawn thread to RWX shellcode                        | load-code/shellcode                                  |
+------------------------------------------------------+------------------------------------------------------+

In der zweiten Tabelle ATT&CK Tactic können Sie die bekannten Techniken ablesen, die von diesem Objekt verwendet werden. Beachten Sie, dass keine Netzwerkaktivität gemeldet wird, was normalerweise bei einer dynamischen Analyse der Fall ist.

capa führt Hunderte von Überprüfungen durch, die normalerweise von Hand durchgeführt würden, und stellt die Ergebnisse in einer zusammenfassenden Tabelle zusammen. Dazu nutzt es die Arbeit vieler Experten, die sich Tausende von Objekten angesehen und mit Hilfe von yara-Regeln die Anhaltspunkte kodiert haben, die uns Muster oder Zeichenketten im Objekt erkennen lassen. Wenn wir capa ausführen, können wir in wenigen Sekunden herausfinden, ob wir uns das Objekt näher ansehen müssen oder ob es als sauber angesehen werden kann.

Tipps

Die Entschlüsselung der Ausgabe von Tools wie capa erfordert jedoch einige Reverse-Engineering-Fähigkeiten. Daher empfehlen wir bestimmte Tools und Suchmuster, um manuell zu erkunden, was capa automatisch durchführt.

Welche Werkzeuge sind zu verwenden?

Die Werkzeuge sind wichtig, aber sie sind nicht der wichtigste Teil des gesamten Prozesses. Es ist besser, sich auf einige wenige Werkzeuge zu konzentrieren und zu lernen, wie man sie gut einsetzt, als zu versuchen, herauszufinden, wie man sie alle einsetzt, zumal viele von ihnen sich überschneidende Funktionen haben. Es lohnt sich auf jeden Fall, einen Blick auf die folgenden zu werfen:

Ziel Tool Bemerkungen
Object categorization file
TrID
Diese Gruppe von Tools dient der Erkennung verschiedener Dateitypen anhand ihrer Binärsignaturen. Es gibt Unterschiede zwischen den Hilfsprogrammen, daher sollten Sie je nach den Umständen das beste wählen oder einfach beide verwenden.
Search strings
bbcrack
floss
bbcrack (Balbucrack) ist ein Tool zum Knacken typischer Malware-Verschleierungen wie XOR, ROL, ADD (und viele Kombinationen) und zur Überprüfung auf bestimmte Muster (IP-Adressen, Domainnamen usw.). Der FLARE Obfuscated String Solver (FLOSS) verwendet fortschrittliche statische Analysetechniken, um Strings aus Malware-Binärdateien automatisch zu entschleiern.
Analisys pecheck
capa
Tools zur Suche nach bekannten bösartigen Mustern.
Extraction pecheck
Dieses Tool wird verwendet, um in einer ausführbaren PE-Datei nach eingebetteten ausführbaren Dateien wie DLLs, EXEs, Overlays usw. zu suchen.

Worauf ist zu achten?

Allgemeine Prüfungen:

Bei Objekten, die für Microsoft Windows bestimmt sind, können wir mit der Suche nach bestimmten Funktionen beginnen:

Risiko Funktion
Keylogging GetAsyncKeyState
SetWindowsHookEx
Injection CreateRemoteThread
WriteProcessMemory
VirtualAllocEx
Defense GetTickCount
GetCursorPosition
GetForegroundWindow
Execution WinExec
ShellExecute
CreateProcess
Data Manipulation GetClipboardData
GetWindowText
Network Interaction InternetOpen
HttpOpenRequest
HttpSendRequest
InternetReadFile

Zusammenfassung

Wir haben gezeigt, wie wir durch die Konzentration auf wichtige Details und die Anwendung einiger einfacher Methoden schnell entscheiden können, ob ein verdächtiges Objekt mehr Aufmerksamkeit erfordert. Mit Hilfe einiger Tools und der Definition der zu suchenden Objekte können wir sehr gute Ergebnisse erzielen, indem wir einfach eine statische Analyse des verdächtigen Objekts durchführen. Tools wie capa machen sich die Erfahrung von Fachleuten zunutze, die ihre Untersuchungsmuster kodifiziert und öffentlich gemacht haben. Um die Informationen, die uns diese Technologien zugänglich machen, zu verstehen, braucht man auf jeden Fall Kenntnisse über die Funktionsweise von Systemen und Programmierfähigkeiten. Ein guter Anfang sind die in diesem Artikel erwähnten Tools, der Rest wird sich mit der Erfahrung ergeben.

Über den Autor

Rocco Gagliardi

Rocco Gagliardi ist seit den 1980er Jahren im Bereich der Informationstechnologie tätig. In den 1990er Jahren hat er sich ganz der Informationssicherheit verschrieben. Die Schwerpunkte seiner Arbeit liegen im Bereich Routing, Firewalling und Log Management.

Links

Sie wollen Ihr Log und Monitoring auf das nächste Level bringen?

Unsere Spezialisten kontaktieren Sie gern!

×
USB Armory Drive

USB Armory Drive

Rocco Gagliardi

Seccomp-bpf

Seccomp-bpf

Rocco Gagliardi

Sandboxing von Containern

Sandboxing von Containern

Rocco Gagliardi

Sie wollen mehr?

Weitere Artikel im Archiv

Sie brauchen Unterstützung bei einem solchen Projekt?

Unsere Spezialisten kontaktieren Sie gern!

Sie wollen mehr?

Weitere Artikel im Archiv