Wenn Linux Ihre primäre Arbeitsumgebung ist, dann sind Sie vielleicht mit dem Executable and Linkable Format (ELF) vertraut, dem Hauptdateiformat, das für ausführbare Dateien, Bibliotheken, Core-Dumps und mehr unter Linux verwendet wird. Ich habe Artikel über native Linux-Tools geschrieben, um ELF-Binärdateien zu verstehen, beginnend damit, wie ELF-Binärdateien erstellt werden, gefolgt von einigen allgemeinen Tipps zur Analyse von ELF-Binärdateien. Wenn Sie mit ELF und ausführbaren Programmen im Allgemeinen nicht vertraut sind, schlage ich vor, zuerst diese Artikel zu lesen.
Wir stellen Capa vor
Capa ist ein Open-Source-Projekt von Mandiant (einem Unternehmen für Cybersicherheit). In den eigenen Worten des Projekts erkennt capa Fähigkeiten in ausführbaren Dateien . Obwohl das primäre Ziel von Capa unbekannte und möglicherweise bösartige ausführbare Dateien sind, führen die Beispiele in diesem Artikel Capa auf alltäglichen Linux-Dienstprogrammen aus, um zu sehen, wie das Tool funktioniert.
Da die meiste Malware Windows-basiert ist, unterstützten frühere Capa-Versionen nur das PE-Dateiformat, ein vorherrschendes ausführbares Windows-Format. Ab v3.0.0 wurde jedoch Unterstützung für ELF-Dateien hinzugefügt (Dank an Intezer).
Weitere Linux-Ressourcen
- Spickzettel für Linux-Befehle
- Spickzettel für fortgeschrittene Linux-Befehle
- Kostenloser Online-Kurs:RHEL Technical Overview
- Spickzettel für Linux-Netzwerke
- SELinux-Spickzettel
- Spickzettel für allgemeine Linux-Befehle
- Was sind Linux-Container?
- Unsere neuesten Linux-Artikel
Was sind Fähigkeiten?
Was bedeutet das Konzept der Fähigkeiten eigentlich bedeuten, vor allem im Zusammenhang mit ausführbaren Dateien? Programme oder Software erfüllen bestimmte Rechenanforderungen oder lösen ein Problem. Um die Dinge einfach zu halten, können unsere Anforderungen vom Suchen einer Datei, Lesen/Schreiben in eine Datei, Ausführen eines Programms, Protokollieren einiger Daten in einer Protokolldatei, Öffnen einer Netzwerkverbindung usw. abweichen. Wir verwenden dann eine Programmiersprache unserer Wahl mit spezifische Anweisungen, um diese Aufgaben zu erfüllen und das Programm zu kompilieren. Die resultierende Binärdatei oder ausführbare Datei führt dann diese Aufgaben im Namen des Benutzers aus, sodass die resultierende ausführbare Datei fähig ist der Durchführung der oben genannten Aufgaben.
Wenn Sie sich den Quellcode ansehen, ist es einfach zu erkennen, was ein Programm tut oder was seine Absicht ist. Sobald das Programm jedoch als ausführbare Datei kompiliert ist, wird der Quellcode in Maschinensprache konvertiert und ist nicht mehr Teil der resultierenden ausführbaren Datei (es sei denn, er wurde mit Debug-Informationen kompiliert). Wir können immer noch einen Sinn daraus machen, indem wir uns die entsprechenden Assembler-Anweisungen ansehen, die durch einige Kenntnisse der Linux-API (glibc/Systemaufrufe) unterstützt werden, aber es ist schwierig. Es gibt Tools wie Decompiler, die versuchen, die Assembly in einen Pseudocode umzuwandeln, der möglicherweise der ursprüngliche Quellcode war. Es ist jedoch kein Eins-zu-Eins-Match, und es ist nur ein Versuch nach bestem Bemühen.
Warum ein anderes Tool?
Wenn wir mehrere native Linux-Tools zum Analysieren von Binärdateien haben, warum brauchen wir dann ein weiteres? Die vorhandenen Tools unterstützen Entwickler bei der Fehlerbehebung und beim Debuggen von Problemen, die während der Entwicklung auftreten können. Sie sind oft der erste Schritt für eine anfängliche Analyse unbekannter Binärdateien, sie reichen jedoch nicht aus.
Manchmal ist keine langwierige Disassemblierung oder langer Pseudocode erforderlich, sondern nur eine kurze Zusammenfassung der Funktionen, die in der Binärdatei basierend auf ihrer API-Nutzung zu sehen sind. Häufig verwenden bösartige Binärdateien und Malware Antianalyse- oder Antiumkehrtechniken, die solche nativen Tools hilflos machen.
Die Hauptzielgruppe von Capa sind Malware- oder Sicherheitsforscher, die häufig auf unbekannte Binärdateien stoßen, für die kein Quellcode verfügbar ist. Sie müssen feststellen, ob es sich um Malware oder eine harmlose ausführbare Datei handelt. Ein erster erster Schritt besteht darin, herauszufinden, was die ausführbare Datei tun kann, bevor Sie zur dynamischen Analyse übergehen. Dies kann mit einigen vordefinierten Regelsätzen erfolgen, die mit einem gängigen Framework abgeglichen werden (das wir weiter unten untersuchen). Native Linux-Tools wurden nicht für solche Zwecke entwickelt.
Capa bekommen
Laden Sie hier ein vorgefertigtes Capa-Linux-Programm herunter. Sie müssen v3.0.0 oder höher verwenden. Capa ist in Python programmiert, das heruntergeladene Programm ist jedoch kein .py Datei, die der Python-Interpreter ausführen kann. Es ist stattdessen eine ausführbare ELF-Datei, die direkt von der Linux-Befehlszeile ausgeführt wird.
$ pwd
/root/CAPA
$
$ wget -q https://github.com/mandiant/capa/releases/download/v3.0.2/capa-v3. 0.2-linux.zip
$
$-Datei capa-v3.0.2-linux.zip
capa-v3.0.2-linux.zip:Zip-Archivdaten, mindestens v2.0 zum Extrahieren
$
$ capa-v3.0.2-linux.zip entpacken
Archiv: capa-v3.0.2-linux.zip
aufblasen:capa
$
$ ls -l capa
-rwxr-xr-x. 1 root root 41282976 Sep 28 18:29 capa
$
$ file capa
capa:ELF 64-bit LSB pie ausführbar, x86-64, Version 1 (SYSV), dynamisch verknüpft, Interpreter /lib64/ld-linux-x86-64.so.2, für GNU/Linux 3.2.0, BuildID[sha1]=1da3a1d77c7109ce6444919f4a15e7e6c63d02fa, entfernt
Befehlszeilenoptionen
Capa wird mit einer Vielzahl von Befehlszeilenoptionen geliefert. Dieser Artikel besucht einige davon, beginnend mit dem Hilfeinhalt:
$ ./capa -h
Verwendung:capa [-h] [--version] [-v] [-vv] [-d] [-q] [--color {auto,always, never}] [-f {auto,pe,elf,sc32,sc64,freeze}]
[-b {vivisect,smda}] [-r REGELN] [-s SIGNATUREN] [-t TAG] [- j]
sample
Das Open-Source-Tool des FLARE-Teams zum Identifizieren von Fähigkeiten in ausführbaren Dateien.
<>
$
Verwenden Sie diesen Befehl, um zu überprüfen, ob die erforderliche Version von Capa (v3 und höher) ausgeführt wird:
$ ./capa --version
capa v3.0.2-0-gead8a83
Capa-Ausgabe und das MITRE ATT&CK-Framework
Die Capa-Ausgabe kann etwas überwältigend sein, also führen Sie sie zuerst mit einem einfachen Dienstprogramm wie pwd aus . Das pwd Befehl unter Linux druckt das aktuelle Arbeitsverzeichnis und ist ein gängiger Befehl. Bitte beachten Sie, dass pwd kann je nach verwendeter Distribution für Sie in die Shell integriert sein (keine separate ausführbare Datei). Identifizieren Sie seinen Pfad mit which Befehl zuerst und geben Sie dann den vollständigen Pfad zu Capa an. Hier ist ein Beispiel:
$ which pwd
/usr/bin/pwd
$
$ file /usr/bin/pwd
/usr/bin/pwd:ELF 64-bit LSB Pie ausführbar, x86-64, Version 1 (SYSV), dynamisch gelinkt, Interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ec306ddd72ce7be19dfc1e62328bb89b6b3a6df5, für GNU/Linux 3.2.0, entfernt
$
$ ./capa -f elf /usr/bin/pwd
Laden :100%| 633/633 [00:00<00:00, 2409,72 Regeln/s]
Matching:100%| 76/76 [00:01<00:00, 38,87 Funktionen/s, 0 Bibliotheksfunktionen übersprungen]
+----------------------- ------------------------------------------------- ------------------------------------+
| md5 | 8d50bbd7fea04735a70f21cca5063efe |
| sha1 | 7d9df581bc3d34c9fb93058be2cdb9a8c04ec061 |
| sha256 | 53205e6ef4e1e7e80745adc09c00f946ae98ccf6f8eb9c4535bd29188f7f1d91 |
| os | Linux |
| Format | elf |
| Bogen | amd64 |
| Pfad | /usr/bin/pwd |
+------------------------+------------- -------------------------------------------------- ---------------------+
+--------------------- -----+-------------------------------------------------------- -----------------------------------+
| ATT&CK-Taktik | ATT&CK-Technik |
|------------------------+----------------- -------------------------------------------------- ------------------|
| ENTDECKUNG | Datei- und Verzeichniserkennung::T1083 |
+------------------------+------------ -------------------------------------------------- ----------------------+
+------------------ -----------+-------------------------------------- -----------------------------------------+
| MBC-Ziel | MBC-Verhalten |
|------------------------+------------ -------------------------------------------------- ------------------|
| DATEISYSTEM | Schreibt Datei::[C0052] |
+--------------------------------------+------- -------------------------------------------------- ----------------------+
+------------------ ------------------------------------+--------------------- -----------------------------------------+
| FÄHIGKEIT | NAMESPACE |
|------------------------------------------ -----------+-------------------------------------- ----------------|
| Dateien unter Linux aufzählen (2 Übereinstimmungen) | Hostinteraktion/Dateisystem/Dateien/Liste |
| Write-Datei unter Linux | Host-Interaktion/Dateisystem/Schreiben |
+------------------------------ -------------------+------------------------------ ------------------------+
Führen Sie Capa mit dem -f elf aus Argument, um ihm mitzuteilen, dass die zu analysierende ausführbare Datei im ELF-Dateiformat vorliegt. Diese Option kann für unbekannte Binärdateien erforderlich sein; Capa ist jedoch durchaus in der Lage, das Format selbst zu erkennen und die Analyse durchzuführen, sodass Sie diese Option bei Bedarf überspringen können. Am Anfang sehen Sie eine Lade-/Übereinstimmungsmeldung, während Capa seine Regeln aus dem Backend lädt und dann die ausführbare Datei analysiert und diese Regeln damit abgleicht. Überspringen Sie die Anzeige, indem Sie das -q hinzufügen Option für alle Befehle.
Die Capa-Ausgabe ist in verschiedene Abschnitte unterteilt. Der erste Abschnitt identifiziert die Binärdatei anhand ihres md5-, sha1- oder sha256-Hashes, gefolgt von Betriebssystem, Dateiformat und Architekturinformationen. Diese Informationen sind oft kritisch, wenn es um ausführbare Dateien geht. In den folgenden Abschnitten verwendet Capa die ATT&CK-Taktik und -Technik, um die Fähigkeiten abzugleichen.
MITRE ATT&CK lässt sich am besten mit den eigenen Worten des Projekts beschreiben:
MITRE ATT&CK® ist eine weltweit zugängliche Wissensdatenbank mit gegnerischen Taktiken und Techniken, die auf realen Beobachtungen basieren.
Wenn Sie mehr über ATT&CK erfahren möchten, lesen Sie bitte das MITRE ATT&CK Framework hier.
Sie können die Ausgabe von Capa in den folgenden zwei Abschnitten mit der des MITRE ATT&CK-Frameworks abgleichen. Ich werde diesen Teil in diesem Artikel überspringen.
Schließlich können Sie im Abschnitt Fähigkeiten zwei spezifische Fähigkeiten sehen, die aufgeführt sind:
Dateien unter Linux auflisten
Datei unter Linux schreiben
Vergleichen Sie dies mit der Natur des pwd Programm, das das aktuelle Verzeichnis anzeigen muss. Hier stimmt es mit der ersten Fähigkeit überein (denken Sie daran, dass in Linux alles eine Datei ist). Was ist mit dem zweiten Teil, der Schreiben einer Datei sagt ? pwd haben wir sicherlich nicht geschrieben Ausgabe in eine beliebige Datei. Denken Sie jedoch an pwd muss den aktuellen Verzeichnisspeicherort auf das Terminal schreiben; wie sonst wird die Ausgabe gedruckt? Wenn Sie sich immer noch nicht sicher sind, wie das funktioniert, führen Sie den folgenden Befehl aus und passen Sie die Ausgabe an. Wenn Sie mit strace nicht vertraut sind oder was es tut, ich habe hier einen Artikel darüber. Konzentrieren Sie sich auf das Schreiben Systemaufruf am Ende des Artikels, wo der pwd ausführbare Datei muss den Verzeichnispfad (String) in 1 schreiben , was für Standardausgang steht. In unserem Fall ist das das Terminal.
$ strace -f /usr/bin/pwd
execve("/usr/bin/pwd", ["/usr/bin/pwd"], 0x7ffd7983a238 /* 49 vars */) =0
brk(NULL)
<>
write(1, "/root/CAPA\n", 11/root/CAPA
) =11
close (1) =0
close (2) =0
EXIT_GROUP (0) =?
+++ mit 0 +++ gesprochenCapa auf verschiedenen Linux-Dienstprogrammen ausführen
Jetzt, da Sie wissen, wie Capa ausgeführt wird, empfehle ich Ihnen dringend, es mit verschiedenen alltäglichen Linux-Dienstprogrammen auszuprobieren. Versuchen Sie bei der Auswahl von Dienstprogrammen, so vielfältig wie möglich zu sein. Wählen Sie beispielsweise Dienstprogramme aus, die mit Dateisystemen oder Speicherbefehlen arbeiten, wie z. B.
ls,mount,cat,echousw. Wechseln Sie als Nächstes zu Netzwerkdienstprogrammen wienetstat,ss,telnetusw., wo Sie die Netzwerkfähigkeiten einer ausführbaren Datei finden. Erweitern Sie es auf umfangreichere Programm-Daemons wiesshdum kryptobezogene Fähigkeiten anzuzeigen, gefolgt vonsystemd,bashusw.Ein Wort der Vorsicht, seien Sie nicht zu erschrocken, wenn Sie Regeln sehen, die Malware für diese nativen Dienstprogramme abgleichen. Bei der Analyse von systemd zeigte Capa beispielsweise Übereinstimmungen für COMMAND AND CONTROL basierend auf der Fähigkeit, Daten von einem Netzwerk zu empfangen. Diese Fähigkeit könnte von echten Programmen für legitime Fälle verwendet werden, während Malware sie für böswillige Zwecke verwenden könnte.
Wird im Debug-Modus ausgeführt
Wenn Sie sehen möchten, wie Capa all diese Fähigkeiten in einer ausführbaren Datei findet, geben Sie
-dan Flag, das zusätzliche Informationen auf dem Bildschirm anzeigt, die helfen könnten, sein Innenleben zu verstehen. Verwenden Sie diese Daten und suchen Sie im Quellcode auf GitHub nach Hinweisen.$ ./capa -q /usr/sbin/sshd -dAls erstes fällt auf, dass Capa Regeln in einem temporären Verzeichnis speichert und von dort aus liest:
DEBUG:capa:reading rules from directory /tmp/_MEIKUG6Oj/rulesDie Debug-Ausgabe zeigt, dass verschiedene Regeln aus diesem Verzeichnis geladen wurden. Sehen Sie sich als Beispiel an, wie versucht wurde, den Hostnamen einer Maschine zu identifizieren:
DEBUG:capa:loaded rule: 'get hostname' with scope: functionMit diesen Informationen ist es einfach, die Regel nachzuschlagen. Gehen Sie einfach zu den
rulesVerzeichnis undgrepfür den spezifischen Regelnamen wie im Beispiel unten. Die Regel ist in einer .yml-Datei angegeben.$ grep -irn "name:get hostname" *
rules/host-interaction/os/hostname/get-hostname.yml:3: name:get hostnameSuchen Sie nach der
-apiAbschnitten, in denen verschiedene APIs aufgelistet sind. Capa sucht nachgethostnameAPI-Nutzung (unter Linux), und Sie können auch das dort aufgeführte Windows-Äquivalent sehen.$ cat _MEIKUG6Oj/rules/host-interaction/os/hostname/get-hostname.yml
rule:
meta:
name:get hostname
namespace:host- Interaktion/Betriebssystem/Hostname
<>
Features:
- oder:
- api:kernel32.GetComputerName
- api:kernel32.GetComputerNameEx
- api:GetComputerObjectName
- api:ws2_32.gethostname
- api:gethostnameWeitere Informationen zu diesem speziellen Systemaufruf unter Linux finden Sie auf der Manpage.
$ man 2 gethostname
GETHOSTNAME(2) Linux Programmer's Manual GETHOSTNAME(2)
NAME
gethostname, sethostname - get/set hostname
<> Ausführliche Verwendung
Eine weitere gute Möglichkeit, um festzustellen, nach welcher API Capa sucht, ist die Verwendung des ausführlichen Modus, wie unten gezeigt. Dieses einfache Beispiel zeigt die Verwendung von
opendir,readdir, undfwriteAPIs:$ ./capa -q /usr/bin/pwd -vv
Dateien unter Linux auflisten (2 Übereinstimmungen)
<>
api:opendir @ 0x20052E8
api:readdir @ 0x2005369, 0x200548A
Datei unter Linux schreiben
<>
os :linux
oder:
api:fwrite @ 0x2002CB5Benutzerdefinierte Regeln
Wie bei anderen guten Tools können Sie Capa erweitern, indem Sie Ihre eigenen Regeln hinzufügen. Dieser Hinweis wurde auch in der Debug-Ausgabe gegeben, falls Sie es bemerkt haben.
$ capa --signature ./path/to/signatures/ /path/to/executableNur spezifische Regeln
Sie können auch nach bestimmten Regeln suchen, anstatt Capa versuchen zu lassen, jede Regel zu erfüllen. Tun Sie dies, indem Sie das
-thinzufügen Flag gefolgt vom genauen Regelnamen:$ ./capa -t "create process on Linux" /usr/sbin/sshd -q -jZeigen Sie den Regelnamen aus den .yml-Dateien innerhalb der
rulesan Verzeichnis. Zum Beispiel:$ grep name rules/host-interaction/process/create/create-process-on-linux.yml
name:create process on LinuxAusgabeformat
Schließlich erlaubt Capa die Ausgabe im JSON-Format mit dem
-jFlagge. Dieses Flag hilft, die Informationen schnell zu konsumieren und die Automatisierung zu unterstützen. Dieser Beispielbefehl erfordert, dass der jq-Befehl installiert ist:$ ./capa -t "create process on Linux" /usr/sbin/sshd -q -j | jq .Abschluss
Capa ist eine würdige Ergänzung zu den dringend benötigten Tools für ausführbare ELF-Dateien. Ich sage dringend benötigt weil wir jetzt regelmäßig Fälle von Linux-Malware sehen. Tools unter Linux müssen aufholen, um diese Bedrohungen zu bewältigen. Sie können mit Capa herumspielen und es auf verschiedenen ausführbaren Dateien ausprobieren und auch Ihre eigenen Regeln schreiben und sie zum Nutzen der Community stromaufwärts hinzufügen.