dynmx Protótipo

dynmx (pronuncia-se dinâmica) é uma abordagem de deteção baseada em assinaturas para características comportamentais de malware usando sequências de chamadas de API do Windows. De forma simplificada, pode pensar no dynmx como uma espécie de YARA para rastreios de chamadas de API (os chamados function logs) provenientes de sandboxes de malware. Portanto, a base de dados para a abordagem de deteção não são as próprias amostras de malware analisadas estaticamente, mas sim dados gerados durante uma análise dinâmica da amostra de malware numa sandbox de malware. Atualmente, o dynmx suporta function logs das seguintes sandboxes de malware:

VMRay (function log, formato baseado em texto e XML)
CAPEv2 (ficheiro report.json)
Cuckoo (ficheiro report.json)

A abordagem de deteção é descrita em detalhe na dissertação de mestrado Signature-Based Detection of Behavioural Malware Features with Windows API Calls. Este projeto é a implementação protótipo desta abordagem e foi desenvolvido no âmbito da dissertação de mestrado. As assinaturas são definidas manualmente por analistas de malware na DSL de assinaturas dynmx e podem ser detetadas em function logs com a ajuda desta ferramenta. As funcionalidades e a sintaxe da DSL de assinaturas dynmx também podem ser encontradas na dissertação de mestrado. Além disso, pode encontrar assinaturas dynmx de exemplo no repositório dynmx-signatures. Para além de detetar características de malware com base em chamadas de API, o dynmx pode extrair recursos do SO utilizados pelo malware (o chamado Access Activity Model). Estes recursos são extraídos examinando as chamadas de API e reconstruindo operações sobre recursos do SO. Atualmente, os recursos do SO das categorias sistema de ficheiros, registo e rede são considerados no modelo.

Exemplo

Na secção seguinte, são mostrados exemplos para a deteção de características de malware e para a extração de recursos.

Deteção

Para este exemplo, escolhemos a amostra de malware com o hash SHA-256 c0832b1008aa0fc828654f9762e37bda019080cbdd92bd2453a05cfb3b79abb3. De acordo com MalwareBazaar, a amostra pertence à família de malware Amadey. Existe um relatório de análise da VMRay público desta amostra, que também fornece o function log rastreado pela VMRay. Este function log será a nossa base de dados para a deteção.

Se quisermos saber se a amostra de malware utiliza uma técnica de injeção chamada Process Hollowing, podemos tentar detetar a seguinte assinatura dynmx no function log.```yaml dynmx_signature: meta: name: process_hollow title: Process Hollowing description: Detection of Process hollowing malware feature detection: proc_hollow: # Create legit process in suspended mode - api_call: ["CreateProcess[AW]", "CreateProcessInternal[AW]"] with: - argument: "dwCreationFlags" operation: "flag is set" value: 0x4 - return_value: "return" operation: "is not" value: 0 store: - name: "hProcess" as: "proc_handle" - name: "hThread" as: "thread_handle" # Injection of malicious code into memory of previously created process - variant: - path: # Allocate memory with read, write, execute permission - api_call: ["VirtualAllocEx", "VirtualAlloc", "(Nt|Zw)AllocateVirtualMemory"] with: - argument: ["hProcess", "ProcessHandle"] operation: "is" value: "$(proc_handle)" - argument: ["flProtect", "Protect"] operation: "is" value: 0x40 - api_call: ["WriteProcessMemory"] with: - argument: "hProcess" operation: "is" value: "$(proc_handle)" - api_call: ["SetThreadContext", "(Nt|Zw)SetContextThread"] with: - argument: "hThread" operation: "is" value: "$(thread_handle)" - path: # Map memory section with read, write, execute permission - api_call: "(Nt|Zw)MapViewOfSection" with: - argument: "ProcessHandle" operation: "is" value: "$(proc_handle)" - argument: "AccessProtection" operation: "is" value: 0x40 # Resume thread to run injected malicious code - api_call: ["ResumeThread", "(Nt|Zw)ResumeThread"] with: - argument: ["hThread", "ThreadHandle"] operation: "is" value: "$(thread_handle)" condition: proc_hollow as sequence

Com base na assinatura, podemos encontrar algumas funcionalidades DSL que tornam o *dynmx* poderoso:
* Definição de sequências de chamadas de API com caminhos alternativos
* Correspondência de nomes de funções de chamada de API com expressões regulares
* Correspondência de valores de argumentos e retorno com vários operadores
* Armazenamento de variáveis, por exemplo, para rastrear handles na sequência de chamadas de API
* Definição de uma condição de detecção com operadores booleanos (`AND`, `OR`, `NOT`)

Se executarmos o *dynmx* com a assinatura mostrada acima contra a função da amostra `c0832b1008aa0fc828654f9762e37bda019080cbdd92bd2453a05cfb3b79abb3`, obtemos a seguinte saída indicando que a assinatura foi detectada.```
$ python3 dynmx.py detect -i 601941f00b194587c9e57c5fabaf1ef11596179bea007df9bdcdaa10f162cac9.json -s process_hollow.yml


    |
  __|         _  _    _  _  _
 /  |  |   | / |/ |  / |/ |/ |  /\/
 \_/|_/ \_/|/  |  |_/  |  |  |_/ /\_/
          /|
          \|
            
 Ver. 0.5 (PoC), by 0x534a


[+] Parsing 1 function log(s)
[+] Loaded 1 dynmx signature(s)
[+] Starting detection process with 1 worker(s). This probably takes some time...

[+] Result
process_hollow	c0832b1008aa0fc828654f9762e37bda019080cbdd92bd2453a05cfb3b79abb3.txt

Podemos entrar em mais detalhes definindo o formato de saída para detail. Agora, podemos ver a sequência exata de chamadas de API que foi detectada no log da função. Além disso, podemos ver que a assinatura foi detectada no processo 51f0.exe.``` $ python3 dynmx.py -f detail detect -i 601941f00b194587c9e57c5fabaf1ef11596179bea007df9bdcdaa10f162cac9.json -s process_hollow.yml

__| _ _ _ _ _ / | | | / |/ | / |/ |/ | // _/|/ _/|/ | |/ | | |_/ /_/ /| |

Ver. 0.5 (PoC), by 0x534a

[+] Parsing 1 function log(s) [+] Loaded 1 dynmx signature(s) [+] Starting detection process with 1 worker(s). This probably takes some time...

[+] Result Function log: c0832b1008aa0fc828654f9762e37bda019080cbdd92bd2453a05cfb3b79abb3.txt Signature: process_hollow Process: 51f0.exe (PID: 3768) Number of Findings: 1 Finding 0 proc_hollow : API Call CreateProcessA (Function log line 20560, index 938) proc_hollow : API Call VirtualAllocEx (Function log line 20566, index 944) proc_hollow : API Call WriteProcessMemory (Function log line 20573, index 951) proc_hollow : API Call SetThreadContext (Function log line 20574, index 952) proc_hollow : API Call ResumeThread (Function log line 20575, index 953)

### Recursos
Para extrair os recursos do SO acessados a partir de um log de função, podemos simplesmente executar o comando *dynmx* `resources` no log de função. Um exemplo da saída detalhada é mostrado abaixo para a amostra com a soma hash SHA-256 `601941f00b194587c9e57c5fabaf1ef11596179bea007df9bdcdaa10f162cac9`. Este é um relatório de sandbox CAPE que faz parte do [Avast-CTU Public CAPEv2 Dataset](https://github.com/avast/avast-ctu-cape-dataset).```
$ python3 dynmx.py -f detail resources --input 601941f00b194587c9e57c5fabaf1ef11596179bea007df9bdcdaa10f162cac9.json


    |
  __|         _  _    _  _  _
 /  |  |   | / |/ |  / |/ |/ |  /\/
 \_/|_/ \_/|/  |  |_/  |  |  |_/ /\_/
          /|
          \|

 Ver. 0.5 (PoC), by 0x534a


[+] Parsing 1 function log(s)
[+] Processing function log(s) with the command 'resources'...

[+] Result
Function log: 601941f00b194587c9e57c5fabaf1ef11596179bea007df9bdcdaa10f162cac9.json (/Users/sijansen/Documents/dev/dynmx_flogs/cape/Public_Avast_CTU_CAPEv2_Dataset_Full/extracted/601941f00b194587c9e57c5fabaf1ef11596179bea007df9bdcdaa10f162cac9.json)
	Process: 601941F00B194587C9E5.exe (PID: 2008)
		Filesystem:
			C:\Windows\SysWOW64\en-US\SETUPAPI.dll.mui (CREATE)
			API-MS-Win-Core-LocalRegistry-L1-1-0.dll (EXECUTE)
			C:\Windows\SysWOW64\ntdll.dll (READ)
			USER32.dll (EXECUTE)
			KERNEL32.dll (EXECUTE)
			C:\Windows\Globalization\Sorting\sortdefault.nls (CREATE)
		Registry:
			HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\OLEAUT (READ)
			HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Setup (READ)
			HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Setup\SourcePath (READ)
			HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion (READ)
			HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\DevicePath (READ)
			HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Internet Settings (READ)
			HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Internet Settings\DisableImprovedZoneCheck (READ)
			HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\CurrentVersion\Internet Settings (READ)
			HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\CurrentVersion\Internet Settings\Security_HKLM_only (READ)
	Process: 601941F00B194587C9E5.exe (PID: 1800)
		Filesystem:
			C:\Windows\SysWOW64\en-US\SETUPAPI.dll.mui (CREATE)
			API-MS-Win-Core-LocalRegistry-L1-1-0.dll (EXECUTE)
			C:\Windows\SysWOW64\ntdll.dll (READ)
			USER32.dll (EXECUTE)
			KERNEL32.dll (EXECUTE)
			[...]
			C:\Users\comp\AppData\Local\vscmouse (READ)
			C:\Users\comp\AppData\Local\vscmouse\vscmouse.exe:Zone.Identifier (DELETE)
		Registry:
			HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\OLEAUT (READ)
			HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Setup (READ)
			[...]
	Process: vscmouse.exe (PID: 900)
		Filesystem:
			C:\Windows\SysWOW64\en-US\SETUPAPI.dll.mui (CREATE)
			API-MS-Win-Core-LocalRegistry-L1-1-0.dll (EXECUTE)
			C:\Windows\SysWOW64\ntdll.dll (READ)
			USER32.dll (EXECUTE)
			KERNEL32.dll (EXECUTE)
			C:\Windows\Globalization\Sorting\sortdefault.nls (CREATE)
		Registry:
			HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\OLEAUT (READ)
			HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Setup (READ)
			HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Setup\SourcePath (READ)
			HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion (READ)
			HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\DevicePath (READ)
			HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Internet Settings (READ)
			HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Internet Settings\DisableImprovedZoneCheck (READ)
			HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\CurrentVersion\Internet Settings (READ)
			HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\CurrentVersion\Internet Settings\Security_HKLM_only (READ)
	Process: vscmouse.exe (PID: 3036)
		Filesystem:
			C:\Windows\SysWOW64\en-US\SETUPAPI.dll.mui (CREATE)
			API-MS-Win-Core-LocalRegistry-L1-1-0.dll (EXECUTE)
			C:\Windows\SysWOW64\ntdll.dll (READ)
			USER32.dll (EXECUTE)
			KERNEL32.dll (EXECUTE)
			C:\Windows\Globalization\Sorting\sortdefault.nls (CREATE)
			C:\ (READ)
			C:\Windows\System32\uxtheme.dll (EXECUTE)
			dwmapi.dll (EXECUTE)
			advapi32.dll (EXECUTE)
			shell32.dll (EXECUTE)
			C:\Users\comp\AppData\Local\vscmouse\vscmouse.exe (CREATE,READ)
			C:\Users\comp\AppData\Local\iproppass\iproppass.exe (DELETE)
			crypt32.dll (EXECUTE)
			urlmon.dll (EXECUTE)
			userenv.dll (EXECUTE)
			wininet.dll (EXECUTE)
			wtsapi32.dll (EXECUTE)
			CRYPTSP.dll (EXECUTE)
			CRYPTBASE.dll (EXECUTE)
			ole32.dll (EXECUTE)
			OLEAUT32.dll (EXECUTE)
			C:\Windows\SysWOW64\oleaut32.dll (EXECUTE)
			IPHLPAPI.DLL (EXECUTE)
			DHCPCSVC.DLL (EXECUTE)
			C:\Users\comp\AppData\Roaming\Microsoft\Network\Connections\Pbk\_hiddenPbk\ (CREATE)
			C:\Users\comp\AppData\Roaming\Microsoft\Network\Connections\Pbk\_hiddenPbk\rasphone.pbk (CREATE,READ)
		Registry:
			HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\OLEAUT (READ)
			HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Setup (READ)
			[...]
		Network:
			24.151.31.150:465 (READ)
			http://24.151.31.150:465 (READ,WRITE)
			107.10.49.252:80 (READ)
			http://107.10.49.252:80 (READ,WRITE)

Com base na saída mostrada e nos recursos acessados, podemos deduzir algumas características do malware:

No processo 601941F00B194587C9E5.exe (PID 1800), o Identificador de Zona do arquivo C:\Users\comp\AppData\Local\vscmouse\vscmouse.exe é excluído
Algumas DLLs são carregadas dinamicamente
O processo vscmouse.exe (PID: 3036) conecta-se aos endpoints de rede http://24.151.31.150:465 e http://107.10.49.252:80

Os recursos acessados são interessantes para identificar indicadores de detecção baseados em host e rede. Além disso, os recursos podem ser usados em assinaturas dynmx. Um exemplo popular é a detecção de mecanismos de persistência no Registro.``` dynmx_signature: meta: name: run_keys_persistence title: Run Keys Persistence description: Detection of persistence based on Registry Run Keys detection: run_keys: - resource: category: "registry" access_operations: ["write"] with: - attribute: "location" operation: "regex" value: "^(HKEY_CURRENT_USER|HKEY_LOCAL_MACHINE)\\Software\\Microsoft\\Windows\\CurrentVersion\\(Run|RunOnce|RunOnceEx)\\" startup_folders_keys: - resource: category: "registry" access_operations: ["write"] with: - attribute: "location" operation: "regex" value: "^(HKEY_CURRENT_USER|HKEY_LOCAL_MACHINE)\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\(Shell Folders|User Shell Folders)\\" condition: run_keys as simple or startup_folders_keys as simple

## Instalação
Para usar o software, o Python 3.9 deve estar disponível no sistema alvo. Além disso, os seguintes pacotes Python precisam ser instalados:
* `anytree`,
* `lxml`,
* `pyparsing`,
* `PyYAML`,
* `six` e
* `stringcase`

Para instalar os pacotes, execute o comando `pip3` mostrado abaixo. É recomendado usar um ambiente virtual Python em vez de instalar os pacotes em todo o sistema.```
pip3 install -r requirements.txt

Uso

Para usar o protótipo, basta executar o ponto de entrada principal dynmx.py. As informações de uso podem ser visualizadas com o parâmetro de linha de comando -h, conforme mostrado abaixo.``` $ python3 dynmx.py -h usage: dynmx.py [-h] [--format {overview,detail}] [--show-log] [--log LOG] [--log-level {debug,info,error}] [--worker N] {detect,check,convert,stats,resources} ...

Detect dynmx signatures in dynamic program execution information (function logs)

optional arguments: -h, --help show this help message and exit --format {overview,detail}, -f {overview,detail} Output format --show-log Show all log output on stdout --log LOG, -l LOG log file --log-level {debug,info,error} Log level (default: info) --worker N, -w N Number of workers to spawn (default: number of processors - 2)

sub-commands: task to perform

{detect,check,convert,stats,resources} detect Detects a dynmx signature check Checks the syntax of dynmx signature(s) convert Converts function logs to the dynmx generic function log format stats Statistics of function logs resources Resource activity derived from function log

Em geral, como mostrado na saída, vários parâmetros de linha de comando relacionados ao tratamento de logs, ao formato de saída para resultados ou multiprocessamento podem ser definidos. Além disso, um comando precisa ser escolhido para executar uma tarefa específica. Observe que o número de workers só afeta comandos que fazem uso de multiprocessamento. Atualmente, esses são os comandos `detect` e `convert`. 

Os comandos têm parâmetros específicos de linha de comando que podem ser explorados passando o parâmetro `-h` ao comando, por exemplo, para o comando `detect` como mostrado abaixo.```
$ python3 dynmx.py detect -h
usage: dynmx.py detect [-h] --sig SIG [SIG ...] --input INPUT [INPUT ...] [--recursive] [--json-result JSON_RESULT] [--runtime-result RUNTIME_RESULT] [--detect-all]

optional arguments:
  -h, --help            show this help message and exit
  --recursive, -r       Search for input files recursively
  --json-result JSON_RESULT
                        JSON formatted result file
  --runtime-result RUNTIME_RESULT
                        Runtime statistics file formatted in CSV
  --detect-all          Detect signature in all processes and do not stop after the first detection

required arguments:
  --sig SIG [SIG ...], -s SIG [SIG ...]
                        dynmx signature(s) to detect
  --input INPUT [INPUT ...], -i INPUT [INPUT ...]
                        Input files

Como utilizador do dynmx, pode decidir como a saída é estruturada. Se escolher mostrar o log na consola definindo o parâmetro --show-log, a saída consiste em duas secções (ver listagem abaixo). O log é mostrado primeiro e depois os resultados do comando utilizado. Por predefinição, o log não é mostrado na consola nem escrito num ficheiro de log (que pode ser definido usando o parâmetro --log). Devido ao multiprocessamento, as entradas no ficheiro de log não estão necessariamente em ordem cronológica.```

__| _ _ _ _ _ / | | | / |/ | / |/ |/ | // _/|/ _/|/ | |/ | | |_/ /_/ /| |

Ver. 0.5 (PoC), by 0x534a

[+] Log output 2023-06-27 19:07:38,068+0000 [INFO] (main) [PID: 13315] []: Start of dynmx run [...] [+] End of log output

[+] Result [...]

O nível de detalhe da saída do resultado pode ser definido usando o parâmetro de linha de comando `--output-format`, que pode ser definido como `overview` para um resultado de alto nível ou `detail` para um resultado detalhado. Por exemplo, se você definir o formato de saída como `detail`, os resultados de detecção exibidos no console conterão as chamadas de API e recursos exatos que causaram a detecção. O formato de saída overview indicará apenas qual assinatura foi detectada em qual log de função.

## Exemplos de Linhas de Comando
Detecção de uma assinatura *dynmx* em um log de função com um processo de trabalho```
python3 dynmx.py -w 1 detect -i "flog.txt" -s dynmx_signature.yml

Conversão de um log de função para o formato de log de função genérico do dynmx``` python3 dynmx.py convert -i "flog.txt" -o /tmp/

Verificar uma assinatura (apenas verificações básicas de sanidade)```
python3 dynmx.py check -s dynmx_signature.yml

Obtenha uma lista detalhada dos recursos utilizados por uma amostra de malware com base no log de função (modelo de atividade de acesso)``` python3 dynmx.py -f detail resources -i "flog.txt"

## Resolução de Problemas
Por favor, considere que esta ferramenta é uma prova de conceito que foi desenvolvida em paralelo à escrita da tese de mestrado. Portanto, a qualidade do código nem sempre é a melhor e podem existir bugs e erros. Tentei tornar a ferramenta o mais robusta possível dentro do prazo disponível.

A melhor forma de resolver erros é ativar o log (no console e/ou em um arquivo de log) e definir o nível de log como `debug`. Os manipuladores de exceção devem escrever erros detalhados no log, o que pode ajudar na resolução de problemas.

dynmx

Mais Populares

dynmx Protótipo

Exemplo

Deteção

Uso