Como faço para auditar um executável para ter certeza de que ele não é malicioso?

Question

Eu queria saber se existe uma ferramenta ou uma técnica para executar um executável em um ambiente isolado, talvez em uma máquina virtual. Enquanto o programa está em execução, quero poder auditar o aplicativo, ou seja, ver tudo o que o executável está fazendo (acesso a arquivos e rede).

Ao fazê-lo, quero poder verificar se o executável é malicioso, ou seja, executa operações que não deveria (ler / escrever em ficheiros, ouvir / ligar a portas de rede, ...).

Eu não me importaria de algo com uma interface gráfica.

    

Answer 1

  

é uma ferramenta ou talvez uma máquina virtual para executar um executável dentro dele

Sim, isso se chama Virtualização de aplicativos .

O LXC (Linux Containers) é uma ferramenta comumente usada para configurar isso. Ele permite que você configure uma rede completamente separada para este aplicativo e o coloca em uma espécie de máquina virtual, muito parecida com um chroot. Isto é principalmente para fins de segurança (uma "cadeia"), não para auditar.

Acho que é um pouco fora do escopo da pergunta explicar os contêineres completos do LXC, bem como fazer uma auditoria exata. Abaixo está um pouco sobre como começar, no entanto.

  

Enquanto o programa está rodando, eu quero ver tudo o que o executável está fazendo (acesso a arquivos e rede).

Isso pode ser feito usando strace e eu fiz a mesma pergunta no Unix e Linux:

• Como monitoro arquivos abertos de um processo em tempo real? (também abrange rede)

Como respondeu lá, basicamente se trata

strace -t -e trace=open,close,read,getdents,write,connect,accept command-here

Importante: uma vez que você vê isso acontecendo, o dano já ocorreu.

Contêiner de aplicativos LXC

De este artigo . Tudo se resume a:

1. lxc-macvlan.conf arquivo de configuração:

   # example as found on /usr/share/doc/lxc/examples/lxc-macvlan.conf
   # Container with network virtualized using the macvlan device driver
   lxc.utsname = alpha
   lxc.network.type = macvlan
   lxc.network.flags = up
   lxc.network.link = eth0 # or eth2 or any of your NICs
   lxc.network.hwaddr = 4a:49:43:49:79:bd
   lxc.network.ipv4 = 0.0.0.0/24
   

2. Inicie usando lxc-execute :

   sudo lxc-execute -n bash-test2 -f lxc-macvlan.conf /bin/bash
   

Observe que o LXC oferece o tipo de contêiner do sistema e do aplicativo. Você está procurando por contêineres de aplicativos aqui.

    

Answer 2

O que você está procurando é uma ferramenta que mostra como um programa interage com o sistema (mais especificamente, com o kernel). Programas interagem com o sistema usando syscalls. Exemplos de syscalls são:

• open - usado para abrir um arquivo;
• read e write - usado para ler / escrever de / para um descritor de arquivo;
• connect - usado para conectar um soquete a um par;
• muitos, muitos outros (consulte man syscalls ).

O ponto é: syscalls podem ser rastreados usando ptrace(2) . Então, basicamente, você está procurando ferramentas construídas em torno de ptrace . Uma dessas ferramentas é strace(1) , que é um aplicativo terminal que recebe um comando como argumento e gera:

• o sistema chama o programa está chamando;
• os argumentos usados para fazer o syscalls;
• o resultado do syscalls.

A saída está em uma forma C. Aqui está um exemplo:

$ strace cat test
execve("/bin/cat", ["cat", "test"], [/* 55 vars */]) = 0
/* ... */
open("test", O_RDONLY)                 = 3
/* ... */
read(3, "hello\n", 32768)               = 6
write(1, "hello\n", 6)                  = 6
read(3, "", 32768)                      = 0
/* ... */

Lá você vê que cat test está abrindo um arquivo chamado test , lendo seu conteúdo ( hello ) e colocando-o na saída padrão.

strace pode produzir muita saída, por isso leia a man page ( man strace ), especialmente a documentação da saída -e , que permitirá que você veja apenas os syscalls nos quais está interessado.

Infelizmente, não tenho conhecimento de alternativas gráficas ou fáceis de usar. Se você quiser procurá-los, ptrace deve ser uma das suas palavras-chave de pesquisa.

Sobre o isolamento, existem muitas tecnologias por aí. Chroots, containers Linux (atualmente em desenvolvimento e incompletos), virtualização de software e paravirtualização são os mais utilizados. No entanto, este é um tópico muito grande para ser discutido. Sugiro que você abra uma nova pergunta se quiser mais detalhes.

    

Answer 3

Dê uma olhada no AppArmor . Você pode adicionar um perfil limitado a um executável e colocá-lo no modo "reclamar", onde as ações serão permitidas, mas registradas, o que, na minha opinião, atende às suas necessidades.

Mas note que isso não é suficiente. Um binário malicioso inteligente pode ser capaz de detectar que está sob observação e não realizar ações maliciosas, exceto quando não está sendo observado.

O AppArmor vai além disso e permite que um aplicativo permaneça restrito a apenas operações aprovadas. Aplicativos que acabam no Ubuntu Software Center fornecidos com os perfis do AppArmor.

    

Answer 4

Como você identificou, uma máquina virtual seria melhor para fornecer isolamento, especialmente se você tiver motivos para acreditar que um executável é malicioso em primeiro lugar. Mas mesmo isso não é perfeito, já que as vulnerabilidades na plataforma de virtualização (tanto de hardware quanto de software) podem ser exploradas por código mal-intencionado para serem quebradas. Veja um exemplo de uma vulnerabilidade de virtualização do mundo real: link

    

Answer 5

Você pode criar um instantâneo .

Os snaps são "confinados no sistema operacional e em outros aplicativos por meio de mecanismos de segurança, mas podem trocar conteúdo e funções com outros snaps de acordo com políticas refinadas controladas pelo usuário e pelos padrões do SO". (de link )

Eles fornecem mais isolamento, além do AppArmor, por exemplo, usando o seccomp também.

Além disso, um snap pode ser autocontido para fácil distribuição e atualizações atômicas em seu sistema.

    

Answer 6

Obrigado, as respostas foram muito úteis ...

Também encontrei isto: link

Qual é uma ferramenta muito interessante para analisar malware enquanto ele está em uma VM