Si Linux es su entorno de trabajo principal, es posible que esté familiarizado con el formato ejecutable y vinculable (ELF), el principal formato de archivo utilizado para ejecutables, bibliotecas, volcados de núcleo y más, en Linux. He escrito artículos que cubren las herramientas nativas de Linux para comprender los binarios ELF, comenzando con cómo se construyen los binarios ELF, seguido de algunos consejos generales sobre cómo analizar los binarios ELF. Si no está familiarizado con ELF y los ejecutables en general, le sugiero que lea estos artículos primero.
Presentamos Capa
Capa es un proyecto de código abierto de Mandiant (una empresa de ciberseguridad). En palabras del propio proyecto, capa detecta capacidades en archivos ejecutables . Aunque el objetivo principal de Capa son los ejecutables desconocidos y posiblemente maliciosos, los ejemplos de este artículo ejecutan Capa en las utilidades diarias de Linux para ver cómo funciona la herramienta.
Dado que la mayoría del malware está basado en Windows, las versiones anteriores de Capa solo admitían el formato de archivo PE, un formato ejecutable dominante de Windows. Sin embargo, a partir de la versión 3.0.0, se agregó soporte para archivos ELF (gracias a Intezer).
Más recursos de Linux
- Hoja de trucos de los comandos de Linux
- Hoja de trucos de comandos avanzados de Linux
- Curso en línea gratuito:Descripción general técnica de RHEL
- Hoja de trucos de red de Linux
- Hoja de trucos de SELinux
- Hoja de trucos de los comandos comunes de Linux
- ¿Qué son los contenedores de Linux?
- Nuestros últimos artículos sobre Linux
¿Qué son las capacidades?
¿Qué significa el concepto de capacidades significa realmente, especialmente en el contexto de los archivos ejecutables? Los programas o software satisfacen ciertas necesidades informáticas o resuelven un problema. Para simplificar las cosas, nuestros requisitos pueden variar desde encontrar un archivo, leer/escribir en un archivo, ejecutar un programa, registrar algunos datos en un archivo de registro, abrir una conexión de red, etc. Luego usamos un lenguaje de programación de nuestra elección con instrucciones específicas para cumplir con estas tareas y compilar el programa. El binario o los ejecutables resultantes realizan estas tareas en nombre del usuario, por lo que el ejecutable resultante es capaz de llevar a cabo las tareas anteriores.
Mirando el código fuente, es fácil identificar qué hace un programa o cuál es su intención. Sin embargo, una vez que el programa se compila como ejecutable, el código fuente se convierte a lenguaje de máquina y ya no forma parte del ejecutable resultante (a menos que se compile con información de depuración). Todavía podemos darle algún sentido mirando las instrucciones de ensamblaje equivalentes respaldadas por algún conocimiento de la API de Linux (glibc/llamadas al sistema), sin embargo, es difícil. Existen herramientas como descompiladores que intentan convertir el ensamblado en un pseudocódigo de lo que podría haber sido el código fuente original. Sin embargo, no es una coincidencia uno a uno, y es solo un intento de mejor esfuerzo.
¿Por qué otra herramienta?
Si tenemos varias herramientas nativas de Linux para analizar binarios, ¿por qué necesitamos otra? Las herramientas existentes ayudan a los desarrolladores a solucionar y depurar problemas que pueden surgir durante el desarrollo. A menudo son el primer paso para el análisis inicial de binarios desconocidos, sin embargo, no son suficientes.
A veces, lo que se necesita no es un desensamblado largo o un pseudocódigo largo, sino solo un resumen rápido de las capacidades que se ven en el binario según el uso de la API. A menudo, los binarios maliciosos y el malware emplean algunas técnicas anti-análisis o anti-reversión que inutilizan estas herramientas nativas.
La audiencia principal de Capa son los investigadores de malware o seguridad que a menudo se encuentran con binarios desconocidos para los cuales el código fuente no está disponible. Necesitan identificar si es malware o un ejecutable benigno. Un primer paso inicial es averiguar qué puede hacer el ejecutable antes de pasar al análisis dinámico. Esto se puede hacer con algunos conjuntos de reglas predefinidos que se comparan con un marco popular (que exploramos a continuación). Las herramientas nativas de Linux no fueron diseñadas para tales usos.
Conseguir Capa
Descargue un programa Capa Linux preconstruido desde aquí. Debe usar v3.0.0 o superior. Capa está programado en Python, sin embargo, el programa descargado no es un .py archivo que el intérprete de Python puede ejecutar. En cambio, es un ejecutable ELF que se ejecuta directamente desde la línea de comandos de 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
Opciones de la línea de comandos
Capa viene con una variedad de opciones de línea de comando. Este artículo visita algunos de ellos, comenzando con el contenido de ayuda:
$ ./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 >>
$
Use este comando para verificar si la versión requerida de Capa (v3 y superior) se está ejecutando:
$ ./capa --version
capa v3.0.2-0-gead8a83
La salida de Capa y el marco MITRE ATT&CK
La salida de Capa puede ser un poco abrumadora, así que primero ejecútela en una utilidad simple, como pwd . El pwd El comando en Linux imprime el directorio de trabajo actual y es un comando común. Tenga en cuenta que pwd podría ser un shell incorporado para usted (sin un ejecutable separado) según la distribución que esté utilizando. Identifique su ruta usando el which comando primero y luego proporcione la ruta completa a Capa. Aquí hay un ejemplo:
$ 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 |
+------------------------------------------------------+------------------------------------------------------+
Ejecuta Capa con el -f elf argumento para decirle que el ejecutable a analizar está en formato de archivo ELF. Esta opción puede ser necesaria para binarios desconocidos; sin embargo, Capa es perfectamente capaz de detectar el formato por sí solo y hacer el análisis, por lo que puedes omitir esta opción si lo requieres. Al principio, verá un mensaje de carga/coincidencia cuando Capa carga sus reglas desde el backend y luego analiza el ejecutable y compara esas reglas con él. Omita mostrar esto agregando -q opción a todos los comandos.
La salida de Capa se divide en varias secciones. La primera sección identifica de forma única el binario utilizando su hash md5, sha1 o sha256 seguido del sistema operativo, el formato de archivo y la información de arquitectura. Esta información suele ser fundamental cuando se trata de ejecutables. En las siguientes secciones, Capa utiliza la táctica y técnica ATT&CK para igualar las capacidades.
MITRE ATT&CK se describe mejor en las propias palabras del proyecto:
MITRE ATT&CK® es una base de conocimiento accesible a nivel mundial de tácticas y técnicas del adversario basadas en observaciones del mundo real.
Si desea obtener más información sobre ATT&CK, consulte el marco MITRE ATT&CK aquí.
Puede hacer coincidir la salida de Capa en las siguientes dos secciones con la del marco MITRE ATT&CK. Omitiré esta parte de este artículo.
Finalmente, en la sección Capacidad, puede ver dos capacidades específicas enumeradas:
enumerate files on Linux
write file on Linux
Compare esto con la naturaleza del pwd programa, que necesita mostrar el directorio actual. Aquí coincide con la primera capacidad (recuerde que el concepto de todo es un archivo en Linux). ¿Qué pasa con la segunda parte, que dice archivo de escritura ? Ciertamente no hemos escrito pwd salida a cualquier archivo. Sin embargo, recuerda pwd necesita escribir la ubicación del directorio actual en el terminal; ¿De qué otra manera se imprimirá la salida? Si aún no está seguro de cómo funciona esto, ejecute el siguiente comando y haga coincidir la salida. Si no está familiarizado con strace o lo que hace, tengo un artículo que lo cubre aquí. Centrarse en la escribir llamada al sistema hacia el final del artículo donde el pwd ejecutable necesita escribir la ruta del directorio (cadena) a 1 , que significa salida estándar. En nuestro caso, ese es el 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 +++
Ejecutar Capa en diferentes utilidades de Linux
Ahora que sabe cómo ejecutar Capa, le recomiendo que lo pruebe en varias utilidades de Linux del día a día. Al elegir los servicios públicos, intente ser lo más diverso posible. Por ejemplo, seleccione utilidades que funcionen con sistemas de archivos o comandos de almacenamiento, como ls , mount , cat , echo , etc. A continuación, vaya a las utilidades de red, como netstat , ss , telnet , etc., donde encontrará las capacidades de red de un ejecutable. Extiéndalo a demonios de programas más extensos como sshd para ver las capacidades relacionadas con la criptografía, seguido de systemd , bash , etc.
Una palabra de precaución, no se asuste demasiado si ve reglas que coinciden con el malware para estas utilidades nativas. Por ejemplo, al analizar systemd, Capa mostró coincidencias para COMANDO Y CONTROL basadas en la capacidad de recibir datos de una red. Esta capacidad podría ser utilizada por programas genuinos para casos legítimos, mientras que el malware podría usarla con fines maliciosos.
Ejecución en modo de depuración
Si desea ver cómo Capa encuentra todas estas capacidades en un ejecutable, proporcione el -d bandera, que muestra información adicional en la pantalla que podría ayudar a comprender su funcionamiento interno. Usa estos datos y busca pistas en el código fuente en GitHub.
$ ./capa -q /usr/sbin/sshd -dLo primero que hay que notar es que Capa guarda las reglas en un directorio temporal y las lee desde allí:
DEBUG:capa:reading rules from directory /tmp/_MEIKUG6Oj/rulesLa salida de depuración muestra que cargó varias reglas de este directorio. Como ejemplo, vea cómo intentó identificar el nombre de host de una máquina:
DEBUG:capa:loaded rule: 'get hostname' with scope: function
Con esta información, es fácil buscar la regla. Simplemente ve a las rules directorio y grep para el nombre de la regla específica como en el siguiente ejemplo. La regla se establece en un archivo .yml.
$ grep -irn "name: get hostname" *
rules/host-interaction/os/hostname/get-hostname.yml:3: name: get hostname
Compruebe la -api secciones donde se enumeran varias API. Capa busca el gethostname Uso de API (en Linux), y también puede ver el equivalente de Windows enumerado allí.
$ 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
Puede encontrar más información sobre esta llamada de sistema específica en Linux utilizando la página de manual.
$ man 2 gethostname
GETHOSTNAME(2) Linux Programmer's Manual GETHOSTNAME(2)
NAME
gethostname, sethostname - get/set hostname
<< snip >>
Uso detallado
Otra buena manera de identificar qué API está buscando Capa es usar el modo detallado, como se muestra a continuación. Este ejemplo simple muestra el uso de opendir , readdir y 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
Reglas personalizadas
Como ocurre con otras buenas herramientas, Capa te permite ampliarlo añadiendo tus propias reglas. Esta sugerencia también se proporcionó en la salida de depuración, si se dio cuenta.
$ capa --signature ./path/to/signatures/ /path/to/executableSolo reglas específicas
También puede buscar reglas específicas en lugar de que Capa intente hacer coincidir todas las reglas. Haga esto agregando -t indicador seguido del nombre exacto de la regla:
$ ./capa -t "create process on Linux" /usr/sbin/sshd -q -j
Mostrar el nombre de la regla de los archivos .yml dentro de las rules directorio. Por ejemplo:
$ grep name rules/host-interaction/process/create/create-process-on-linux.yml
name: create process on Linux
Formato de salida
Finalmente, Capa permite la salida en formato JSON usando -j bandera. Esta bandera ayuda a consumir la información rápidamente y ayuda a la automatización. Este comando de ejemplo requiere que el comando jq esté instalado:
$ ./capa -t "create process on Linux" /usr/sbin/sshd -q -j | jq .Resumir
Capa es una valiosa adición a las herramientas tan necesarias para los ejecutables ELF. Yo digo muy necesario porque vemos regularmente casos de malware de Linux ahora. Las herramientas en Linux deben ponerse al día para hacer frente a estas amenazas. Puedes jugar con Capa y probarlo en varios ejecutables, y también escribir tus propias reglas y agregarlas aguas arriba para el beneficio de la comunidad.