Si Linux est votre environnement de travail principal, vous connaissez peut-être le format ELF (Executable and Linkable Format), le principal format de fichier utilisé pour les exécutables, les bibliothèques, les vidages de mémoire, etc., sous Linux. J'ai écrit des articles couvrant les outils Linux natifs pour comprendre les binaires ELF, en commençant par la façon dont les binaires ELF sont construits, suivis de quelques conseils généraux sur la façon d'analyser les binaires ELF. Si vous n'êtes pas familier avec ELF et les exécutables en général, je vous suggère de lire ces articles en premier.
Présentation de Capa
Capa est un projet open source de Mandiant (une société de cybersécurité). Selon les propres termes du projet, capa détecte les capacités dans les fichiers exécutables . Bien que la cible principale de Capa soit des exécutables inconnus et peut-être malveillants, les exemples de cet article exécutent Capa sur des utilitaires Linux quotidiens pour voir comment l'outil fonctionne.
Étant donné que la plupart des logiciels malveillants sont basés sur Windows, les versions antérieures de Capa ne prenaient en charge que le format de fichier PE, un format exécutable dominant de Windows. Cependant, à partir de la v3.0.0, la prise en charge des fichiers ELF a été ajoutée (grâce à Intezer).
Plus de ressources Linux
- Aide-mémoire des commandes Linux
- Aide-mémoire des commandes Linux avancées
- Cours en ligne gratuit :Présentation technique de RHEL
- Aide-mémoire sur le réseau Linux
- Aide-mémoire SELinux
- Aide-mémoire sur les commandes courantes de Linux
- Que sont les conteneurs Linux ?
- Nos derniers articles Linux
Que sont les capacités ?
Que signifie le concept de capacités signifie réellement, en particulier dans le contexte des fichiers exécutables ? Les programmes ou logiciels répondent à certains besoins informatiques ou résolvent un problème. Pour garder les choses simples, nos exigences peuvent varier de la recherche d'un fichier, la lecture/écriture dans un fichier, l'exécution d'un programme, l'enregistrement de certaines données dans un fichier journal, l'ouverture d'une connexion réseau, etc. Nous utilisons ensuite un langage de programmation de notre choix avec instructions spécifiques pour accomplir ces tâches et compiler le programme. Le binaire ou les exécutables résultants effectuent ensuite ces tâches au nom de l'utilisateur, de sorte que l'exécutable résultant est capable d'effectuer les tâches ci-dessus.
En regardant le code source, il est facile d'identifier ce que fait un programme ou quelle est son intention. Cependant, une fois que le programme est compilé en tant qu'exécutable, le code source est converti en langage machine et ne fait plus partie de l'exécutable résultant (sauf s'il est compilé avec les informations de débogage). Nous pouvons toujours lui donner un sens en regardant les instructions d'assemblage équivalentes soutenues par une certaine connaissance de l'API Linux (appels glibc/système), cependant, c'est difficile. Il existe des outils tels que des décompilateurs qui tentent de convertir l'assemblage en un pseudo-code de ce qui aurait pu être le code source d'origine. Cependant, il ne s'agit pas d'une correspondance en tête-à-tête, et ce n'est qu'une tentative au mieux.
Pourquoi un autre outil ?
Si nous avons plusieurs outils Linux natifs pour analyser les binaires, pourquoi en avons-nous besoin d'un autre ? Les outils existants aident les développeurs à résoudre et à déboguer les problèmes pouvant survenir au cours du développement. Ils sont souvent la première étape d'une analyse initiale sur des binaires inconnus, cependant, ils ne sont pas suffisants.
Parfois, ce qui est nécessaire n'est pas un long désassemblage ou un long pseudo-code, mais juste un bref résumé des capacités vues dans le binaire en fonction de son utilisation de l'API. Souvent, les fichiers binaires malveillants et les logiciels malveillants utilisent des techniques anti-analyse ou anti-inversion qui rendent ces outils natifs impuissants.
Le public principal de Capa est constitué de chercheurs en logiciels malveillants ou en sécurité qui rencontrent souvent des binaires inconnus pour lesquels le code source n'est pas disponible. Ils doivent identifier s'il s'agit d'un logiciel malveillant ou d'un exécutable bénin. Une première étape initiale consiste à découvrir ce que l'exécutable peut faire avant de passer à l'analyse dynamique. Cela peut être fait avec des ensembles de règles prédéfinis correspondant à un cadre populaire (que nous explorons ci-dessous). Les outils Linux natifs n'ont pas été conçus pour de telles utilisations.
Obtenir une capacité
Téléchargez un programme Capa Linux pré-construit à partir d'ici. Vous devez utiliser v3.0.0 ou supérieur. Capa est programmé en Python, cependant le programme téléchargé n'est pas un .py fichier que l'interpréteur Python peut exécuter. Il s'agit plutôt d'un exécutable ELF qui s'exécute directement à partir de la ligne de commande Linux.
$ pwd
/root/CAPA
$
$ wget -q https://github.com/mandiant/capa/releases/download/v3.0.2/capa-v3.0.2-linux.zip
$
$ file capa-v3.0.2-linux.zip
capa-v3.0.2-linux.zip: Zip archive data, at least v2.0 to extract
$
$ unzip capa-v3.0.2-linux.zip
Archive: capa-v3.0.2-linux.zip
inflating: capa
$
$ ls -l capa
-rwxr-xr-x. 1 root root 41282976 Sep 28 18:29 capa
$
$ file capa
capa: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=1da3a1d77c7109ce6444919f4a15e7e6c63d02fa, stripped
Options de ligne de commande
Capa est livré avec une variété d'options de ligne de commande. Cet article en visite quelques-uns, en commençant par le contenu de l'aide :
$ ./capa -h
usage: capa [-h] [--version] [-v] [-vv] [-d] [-q] [--color {auto,always,never}] [-f {auto,pe,elf,sc32,sc64,freeze}]
[-b {vivisect,smda}] [-r RULES] [-s SIGNATURES] [-t TAG] [-j]
sample
The FLARE team's open-source tool to identify capabilities in executable files.
<< snip >>
$
Utilisez cette commande pour vérifier si la version requise de Capa (v3 et supérieure) est en cours d'exécution :
$ ./capa --version
capa v3.0.2-0-gead8a83
Sortie Capa et framework MITRE ATT&CK
La sortie Capa peut être un peu écrasante, alors lancez-la d'abord sur un utilitaire simple, tel que pwd . Le pwd La commande sous Linux imprime le répertoire de travail actuel et est une commande courante. Veuillez noter que pwd peut être un shell intégré pour vous (pas d'exécutable séparé) selon la distribution que vous utilisez. Identifiez son chemin en utilisant le which d'abord, puis fournissez le chemin complet vers Capa. Voici un exemple :
$ which pwd
/usr/bin/pwd
$
$ file /usr/bin/pwd
/usr/bin/pwd: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=ec306ddd72ce7be19dfc1e62328bb89b6b3a6df5, for GNU/Linux 3.2.0, stripped
$
$ ./capa -f elf /usr/bin/pwd
loading : 100%| 633/633 [00:00<00:00, 2409.72 rules/s]
matching: 100%| 76/76 [00:01<00:00, 38.87 functions/s, skipped 0 library functions]
+------------------------+------------------------------------------------------------------------------------+
| md5 | 8d50bbd7fea04735a70f21cca5063efe |
| sha1 | 7d9df581bc3d34c9fb93058be2cdb9a8c04ec061 |
| sha256 | 53205e6ef4e1e7e80745adc09c00f946ae98ccf6f8eb9c4535bd29188f7f1d91 |
| os | linux |
| format | elf |
| arch | amd64 |
| path | /usr/bin/pwd |
+------------------------+------------------------------------------------------------------------------------+
+------------------------+------------------------------------------------------------------------------------+
| ATT&CK Tactic | ATT&CK Technique |
|------------------------+------------------------------------------------------------------------------------|
| DISCOVERY | File and Directory Discovery:: T1083 |
+------------------------+------------------------------------------------------------------------------------+
+-----------------------------+-------------------------------------------------------------------------------+
| MBC Objective | MBC Behavior |
|-----------------------------+-------------------------------------------------------------------------------|
| FILE SYSTEM | Writes File:: [C0052] |
+-----------------------------+-------------------------------------------------------------------------------+
+------------------------------------------------------+------------------------------------------------------+
| CAPABILITY | NAMESPACE |
|------------------------------------------------------+------------------------------------------------------|
| enumerate files on Linux (2 matches) | host-interaction/file-system/files/list |
| write file on Linux | host-interaction/file-system/write |
+------------------------------------------------------+------------------------------------------------------+
Exécutez Capa avec le -f elf argument pour lui dire que l'exécutable à analyser est au format de fichier ELF. Cette option peut être requise pour les binaires inconnus ; cependant, Capa est parfaitement capable de détecter le format par lui-même et d'effectuer l'analyse, vous pouvez donc ignorer cette option si nécessaire. Au début, vous verrez un message de chargement/correspondance lorsque Capa charge ses règles à partir du backend, puis analyse l'exécutable et fait correspondre ces règles avec lui. Passer l'affichage en ajoutant le -q option à toutes les commandes.
La sortie Capa est divisée en plusieurs sections. La première section identifie de manière unique le binaire à l'aide de son hachage md5, sha1 ou sha256 suivi du système d'exploitation, du format de fichier et des informations d'architecture. Ces informations sont souvent critiques lorsqu'il s'agit d'exécutables. Dans les sections suivantes, Capa utilise la tactique et la technique ATT&CK pour correspondre aux capacités.
MITRE ATT&CK est mieux décrit dans les propres mots du projet :
MITRE ATT&CK® est une base de connaissances accessible dans le monde entier sur les tactiques et techniques de l'adversaire, basée sur des observations du monde réel.
Si vous souhaitez en savoir plus sur ATT&CK, veuillez vous référer au cadre MITRE ATT&CK ici.
Vous pouvez faire correspondre la sortie de Capa dans les deux sections suivantes avec celle du framework MITRE ATT&CK. Je vais sauter cette partie dans cet article.
Enfin, dans la section Capacité, vous pouvez voir deux capacités spécifiques répertoriées :
enumerate files on Linux
write file on Linux
Comparez cela avec la nature du pwd programme, qui doit afficher le répertoire courant. Ici, cela correspond à la première capacité (rappelez-vous que tout est un fichier sous Linux). Qu'en est-il de la deuxième partie, qui dit fichier d'écriture ? Nous n'avons certainement pas écrit pwd sortie vers n'importe quel fichier. Cependant, rappelez-vous pwd doit écrire l'emplacement du répertoire actuel sur le terminal ; Sinon, comment la sortie sera-t-elle imprimée ? Si vous ne savez toujours pas comment cela fonctionne, exécutez la commande suivante et faites correspondre la sortie. Si vous n'êtes pas familier avec strace ou ce qu'il fait, j'ai un article qui en parle ici. Concentrez-vous sur écrire appel système vers la fin de l'article où le pwd l'exécutable doit écrire le chemin du répertoire (chaîne) sur 1 , qui signifie sortie standard. Dans notre cas, c'est le terminal.
$ strace -f /usr/bin/pwd
execve("/usr/bin/pwd", ["/usr/bin/pwd"], 0x7ffd7983a238 /* 49 vars */) = 0
brk(NULL)
<< snip >>
write(1, "/root/CAPA\n", 11/root/CAPA
) = 11
close(1) = 0
close(2) = 0
exit_group(0) = ?
+++ exited with 0 +++
Exécuter Capa sur différents utilitaires Linux
Maintenant que vous savez comment exécuter Capa, je vous recommande fortement de l'essayer sur divers utilitaires Linux quotidiens. Lorsque vous choisissez des services publics, essayez d'être aussi diversifié que possible. Par exemple, sélectionnez des utilitaires qui fonctionnent avec des systèmes de fichiers ou des commandes de stockage, tels que ls , mount , cat , echo , etc. Ensuite, passez aux utilitaires réseau, comme netstat , ss , telnet , etc., où vous trouverez les capacités réseau d'un exécutable. Étendez-le à des démons de programmes plus étendus comme sshd pour voir les capacités liées au chiffrement, suivies de systemd , bash , etc.
Un mot d'avertissement, ne soyez pas trop effrayé si vous voyez des règles qui correspondent à des logiciels malveillants pour ces utilitaires natifs. Par exemple, lors de l'analyse de systemd, Capa a montré des correspondances pour COMMAND AND CONTROL en fonction de la capacité à recevoir des données d'un réseau. Cette capacité pourrait être utilisée par des programmes authentiques pour des cas légitimes, tandis que des logiciels malveillants pourraient l'utiliser à des fins malveillantes.
Exécution en mode débogage
Si vous souhaitez voir comment Capa trouve toutes ces fonctionnalités dans un exécutable, fournissez le -d drapeau, qui affiche des informations supplémentaires sur l'écran qui pourraient aider à comprendre son fonctionnement interne. Utilisez ces données et recherchez des indices dans le code source sur GitHub.
$ ./capa -q /usr/sbin/sshd -dLa première chose à remarquer est que Capa enregistre les règles dans un répertoire temporaire et les lit à partir de là :
DEBUG:capa:reading rules from directory /tmp/_MEIKUG6Oj/rulesLa sortie de débogage montre qu'il a chargé diverses règles à partir de ce répertoire. À titre d'exemple, voyez comment il a tenté d'identifier le nom d'hôte d'une machine :
DEBUG:capa:loaded rule: 'get hostname' with scope: function
Avec ces informations, il est facile de rechercher la règle. Allez simplement dans les rules répertoire et grep pour le nom de règle spécifique comme dans l'exemple ci-dessous. La règle est indiquée dans un fichier .yml.
$ grep -irn "name: get hostname" *
rules/host-interaction/os/hostname/get-hostname.yml:3: name: get hostname
Vérifiez le -api sections où diverses API sont répertoriées. Capa recherche le gethostname Utilisation de l'API (sous Linux), et vous pouvez également voir l'équivalent Windows répertorié ici.
$ cat _MEIKUG6Oj/rules/host-interaction/os/hostname/get-hostname.yml
rule:
meta:
name: get hostname
namespace: host-interaction/os/hostname
<< snip >>
features:
- or:
- api: kernel32.GetComputerName
- api: kernel32.GetComputerNameEx
- api: GetComputerObjectName
- api: ws2_32.gethostname
- api: gethostname
Vous pouvez trouver plus d'informations sur cet appel système spécifique sous Linux en utilisant la page de manuel.
$ man 2 gethostname
GETHOSTNAME(2) Linux Programmer's Manual GETHOSTNAME(2)
NAME
gethostname, sethostname - get/set hostname
<< snip >>
Utilisation détaillée
Un autre bon moyen d'identifier l'API recherchée par Capa consiste à utiliser le mode verbeux, comme indiqué ci-dessous. Cet exemple simple affiche l'utilisation de opendir , readdir , et fwrite API :
$ ./capa -q /usr/bin/pwd -vv
enumerate files on Linux (2 matches)
<< snip >>
api: opendir @ 0x20052E8
api: readdir @ 0x2005369, 0x200548A
write file on Linux
<< snip >>
os: linux
or:
api: fwrite @ 0x2002CB5
Règles personnalisées
Comme avec d'autres bons outils, Capa vous permet de l'étendre en ajoutant vos propres règles. Cet indice a également été donné dans la sortie de débogage, si vous l'avez remarqué.
$ capa --signature ./path/to/signatures/ /path/to/executableRègles spécifiques uniquement
Vous pouvez également rechercher des règles spécifiques au lieu que Capa essaie de faire correspondre chaque règle. Faites cela en ajoutant le -t drapeau suivi du nom exact de la règle :
$ ./capa -t "create process on Linux" /usr/sbin/sshd -q -j
Affichez le nom de la règle à partir des fichiers .yml dans les rules annuaire. Par exemple :
$ grep name rules/host-interaction/process/create/create-process-on-linux.yml
name: create process on Linux
Format de sortie
Enfin, Capa permet la sortie au format JSON en utilisant le -j drapeau. Cet indicateur permet de consommer les informations rapidement et de faciliter l'automatisation. Cet exemple de commande nécessite que la commande jq soit installée :
$ ./capa -t "create process on Linux" /usr/sbin/sshd -q -j | jq .Récapitulez
Capa est un ajout précieux aux outils indispensables pour les exécutables ELF. Je dis bien nécessaire parce que nous voyons régulièrement des cas de logiciels malveillants Linux maintenant. Les outils sous Linux doivent rattraper leur retard pour faire face à ces menaces. Vous pouvez jouer avec Capa et l'essayer sur divers exécutables, mais aussi écrire vos propres règles et les ajouter en amont pour le bénéfice de la communauté.