python-haystack forense de memória ################################

Início Rápido:

Guia de uso rápido <docs/Haystack_basic_usage.ipynb>_ na pasta docs/.

Haystack-reverse CLI <docs/Haystack_reverse_CLI.ipynb>_ na pasta docs/.

Mais documentação <http://python-haystack.readthedocs.io/en/latest/>_

Introdução:

python-haystack é uma framework de análise de heap, focada na busca e engenharia reversa de estruturas C na memória alocada.

A primeira função/API é a função SEARCH. Ela oferece a capacidade de buscar por tipos de registros conhecidos em um dump de memória de processo ou na memória de um processo vivo.

A segunda função/API é a função REVERSE na extensão python-haystack-reverse <https://github.com/trolldbois/python-haystack-reverse>_ Ela tem como objetivo auxiliar um analista na engenharia reversa dos tipos de registros de memória presentes no heap de um processo. Foca na reconstrução e classificação de estruturas C clássicas a partir da memória. Tenta recriar definições de tipos.

Scripts e formato do manipulador de memória:

Existem alguns pontos de entrada para lidar com o formato do seu dump de memória.

Pasta de dump de memória produzida por `haystack-live-dump`

haystack-find-heap permite mostrar detalhes sobre o HEAP do Windows.
haystack-search CLI de busca
haystack-show CLI de exibição para um tipo de registro específico em um endereço específico

Você pode usar as seguintes URLs para designar seu manipulador/dump de memória:

dir:///path/to/my/haystack/fump/folder para usar o formato de dump do haystack
dmp:///path/to/my/minidump/file para usar o formato minidump (microsoft?)
frida://name_or_pid_of_process_to_attach_to usar frida para acessar a memória de um processo vivo
live://name_or_pid_of_process_to_attach_to usar ptrace em um processo vivo
rekall:// carregar uma imagem rekall
volatility:// carregar uma imagem volatility
cuckoo:// carregar um dump de memória produzido pelo Cuckoo (beta pode precisar de patch)

Como obter um dump de memória:

No Windows, o mais direto é obter um Minidump. O conjunto de ferramentas Microsoft Sysinternals fornece um CLI (procdump.exe) ou uma GUI (Process Explorer). Usando um deles (com a opção de dump de memória completo) você produzirá um arquivo que pode ser usado com a lista de pontos de entrada haystack-minidump-xxx.

Embora tecnicamente você possa usar muitas ferramentas de terceiros, o haystack realmente precisa de informações de mapeamento de memória para funcionar. Então há uma ferramenta de dump incluída haystack-live-dump:

.. code-block:: bash

# haystack-live-dump <pid> myproc.dump

Para processos vivos

haystack-live-dump captura um dump de memória de processo para uma pasta (formato haystack)

Para um dump de memória do Rekall

haystack-rekall-dump despeja um processo específico para um dump de processo haystack

Para um dump de memória do Volatility

haystack-volatility-dump despeja um processo específico para um dump de processo haystack

Você pode facilmente reproduzir o formato do dump, é uma pasta/arquivo contendo cada mapa de memória em um arquivo separado:

conteúdo da memória em um arquivo nomeado pelos seus endereços de início/fim ( 0x000700000-0x000800000 )
arquivo 'mappings' contendo metadados de mapeamentos de memória. ( mappings )

Ou você pode codificar uma implementação de haystack.abc.IMemoryMapping para seu formato favorito.

Caso contrário, se você já tem um dump de memória do sistema do Volatility ou Rekall, você pode usar as famílias de pontos de entrada haystack-rekall-xxx ou haystack-volatility-xxx para extrair a memória de um processo específico em um arquivo.

Verificando atributos do Heap do Windows:

O ponto de entrada haystack-find-heap permite mostrar detalhes sobre o HEAP do Windows. Ele deve suportar:

Windows XP 32 bits
Windows XP 64 bits
Windows 7 32 bits
Windows 7 64 bits

e mostrar detalhes do frontend Look Aside List (LAL) e Low Fragmentation Heap (LFH).

Você pode se surpreender ao ver que, às vezes, um único processo pode misturar os dois tipos de HEAP (32 e 64).

Buscar por estruturas conhecidas:

Para buscar por um registro específico, você primeiro precisará definir esse tipo de registro. Um [guia de uso rápido](docs/Haystack basic usage.ipynb) está disponível para abordar os passos básicos para ir de um arquivo C Header a uma definição Python ctypes. Ou você pode fazer isso sozinho, com registros Python ctypes tradicionais.

A API de busca está disponível através da família de scripts haystack-xxx-search mas também em uma API para que você possa incorporar essa busca em seu próprio código.

Em resumo, a busca do haystack irá iterar sobre cada offset da memória do programa para tentar encontrar um offset 'válido' para aquele tipo de registro específico.

A validade do registro é determinada por restrições de tipo, tais como:

o campo ponteiro deve ter valores de espaço de endereço válidos
restrições de tipo definidas pelo usuário (veja a seção 'Arquivo de restrições' abaixo)
etc..

.. code-block:: bash

$ python haystack/cli.py dir:///home/user/project/python-haystack/test/src/test-ctypes6.32.dump ctypes6_gen32.struct_usual

Arquivo de restrições:

As seguintes restrições são suportadas:

IgnoreMember: O valor deste campo será ignorado. Útil para ignorar campos de ponteiro.
NotNull: O valor deste campo não deve ser 0.
RangeValue(x,y): o campo deve ter um valor entre x e y.
PerfectMatch('hello world'): o campo (uma string) deve corresponder a 'hello world'
[1,2,3]: Uma lista de valores que o campo deve ter
[1, RangeValue(12,16), 42]: O valor do campo deve ser 1, 12-16 ou 42.

Exemplo:

.. code-block:: python

[struct_name]
myfield: [1,0xff]
ptr_field: NotNull

Você pode dar uma olhada em haystack/allocators/win32/winxpheap32.constraints, onde as restrições de um HEAP do Windows XP x32 estão definidas.

Obviamente, quanto mais restrições, melhores serão os resultados.

Definição dinâmica de restrições:

Você também pode criar restrições mais complexas usando código Python implementando uma classe haystack.abc.interface.IRecordTypeDynamicConstraintsValidator e alimentando-a para ModuleConstraints.set_dynamic_constraints

Exemplo de linha de comando:

O repositório sslsnoop precisa de uma atualização para ser compatível com versões > v0.30 - pendente

Por exemplo, isso irá despejar as estruturas session_state + estruturas filhas apontadas como um objeto Python com o qual podemos brincar. Vamos supor que temos um cliente ou servidor ssh como pid 4042:

.. code-block:: bash

$ sudo haystack-live-search --pickled 4042 sslsnoop.ctypes_openssh.session_state search > instance.pickled
$ sudo haystack-live-search --pickled 4042 sslsnoop.ctypes_openssh.session_state refresh 0xb8b70d18 > instance.pickled
$ sudo haystack-live-search --pickled <pid> <your ctypes Structure> search

Interface Gráfica do Usuário:

Isso não está funcionando no momento

Há também uma tentativa de uma Interface Gráfica python-haystack-gui <https://github.com/trolldbois/python-haystack-gui>_

Exemplo de API Python:

Veja o guia de uso rápido <docs/Haystack_basic_usage.ipynb>_

Como definir suas próprias estruturas:

A maneira mais fácil é usar ctypeslib para gerar registros ctypes a partir de cabeçalhos C.

Ou defina seu registro ctypes Python manualmente.

Exemplos de extensões:

@ veja sslsnoop no repositório Pypi. As estruturas openssl e nss são geradas.

@ veja ctypes-kernel no meu github. Estruturas do kernel Linux são geradas a partir de uma árvore de kernel compilada. (VMM é um saco)

FAQ não tão frequentes:

O que ele faz?:

A funcionalidade básica é buscar na memória de um processo por um registro C específico.

A funcionalidade estendida de engenharia reversa visa reverter estruturas a partir da análise de memória/heap.

Como ele sabe que as estruturas são válidas?:

Você adiciona algumas restrições nos valores esperados dos campos do registro. Ponteiros são sempre restringidos ao espaço de memória válido.

De onde vem a ideia?:

passe-partout <http://www.hsc.fr/ressources/breves/passe-partout.html.fr>_ originalmente. Desde que comecei em março de 2011, descobri vários outros trabalhos relacionados anteriores. A maioria deles está na pasta docs/.

Outros trabalhos relacionados são mona.py da Immunity, algumas coisas da Mandiant...

Em resumo, provavelmente isso não é uma ideia original. Mas ainda assim, não consegui encontrar uma biblioteca independente operacional para extração de memória ao vivo para meu PoC sslsnoop, então....

Trabalho relacionado <https://github.com/trolldbois/python-haystack/wiki/State-of-art-reference>_