quarta-feira, 5 de março de 2014

Para o infinito e além: Backdoors Criptografados


Neste post eu vou estar falando sobre algumas ideias que tive durante a realização de diferentes projetos de Pentest (extendendo uma ideia apresentada em um dos meus posts anteriores¹). 

Observação:

O conteúdo apresentado nesta postagem deve ser reproduzido apenas em um ambiente no qual você possui autorização para a realização de testes de segurança.

Introdução:

A ideia principal é poder evadir a detecção de AV através de algumas técnicas criativas. Eu vou estar apresentando 2 técnicas eficientes para execução de backdoors em Python:
  1. Backdoors criptografados
  2. Stagers criptografados

Backdoors criptografados

 

A primeira técnica envolve criptografar o conteúdo (instruções) de um determinado backdoor em Python. Esta tarefa pode ser realizada através dos seguintes componentes:
  • Biblioteca Pycrypto
    • Utilizada para criptografar o conteudo de um arquivo fonte com um algoritmo de criptografia simétrica de nossa escolha (ex: DES ou AES).
  • Codificação Base64
    • Transforma código criptografado em ASCII (para poder colocar no código fonte do novo arquivo criado).
  • Função exec()
    • Executar em tempo real o conteudo original do backdoor após a sua decifragem.
A Figura 1 apresenta um exemplo de um backdoor simples criado em Python:

Figura 01: Backdoor Simples em Python

Vamos agora criar uma ferramenta (vamos chamar de backdoor_encrypter) para realizar as seguintes tarefas:
  1. Obter o conteúdo original do backdoor
  2. Criptografar o contéudo (vamos utilizar o algoritmo AES)
  3. Codificar as instruções criptografadas (vamos utilizar codificação em Base64)
  4. Salvar instruções codificadas em um novo arquivo '.py'
 A Figura 02 apresenta a função de criptografia do backdoor_encrypter:

Figura 02: Método de criptografia

A Figura 03 apresenta a função principal para a criação do backdoor criptografado.

Figura 03: Método principal (Criação do backdoor criptografado)

O novo arquivo criado vai seguir os passos abaixo:
  1. Decodificar as instruções em base64
  2. Decifrar o resultado do passo 1
  3. Executar as instruções decifradas (resultado do passo 2)  com exec()
A Figura 04 apresenta o visual do novo backdoor criptografado!

Figura 04: Backdoor Criptografado

Stagers criptografados


A segunda técnica pode ser vista como uma 'evolução' da primeira técnica. Na primeira técnica temos ainda um problema: o payload encontra-se no backdoor (mesmo que ainda criptografado). Podemos solucionar esse problema através da seguinte abordagem:
  1. Criar um cliente TCP (utilizando sockets)
  2. Contactar o servidor
  3. Receber o payload pela rede (Payload = Base64(AES(Backdoor)))
  4. Decriptografar o payload
  5. Executar o payload (em texto claro) com exec()
A Figura 05 apresenta o novo backdoor executado pela vítima (realizando download do payload criptografado):


Figura 05: Backdoor (Download de Payload criptografado)
 
Agora temos que criar um servidor para receber a conexão do backdoor cliente e enviar o payload criptografado de volta para a vítima. Vamos pegar o backdoor_encrypter.py e lhe adicionar algumas funcionalidades. A Figura 06 apresenta a nova cara do script backdoor_encrypter.py

Figura 06: Servidor (Envia payload criptografado para vítima)

Conclusão


Nesta postagem eu apresentei algumas técnicas para evasão de AV utilizando Python (Backdoors criptografados e Stagers Criptografados). Todos os scripts estão disponíveis em:

https://github.com/pasknel/hacking-com-tapioca/tree/master/Backdoors

Por favor escrevam suas sugestões e comentários!

Obrigado :)

Keep Hacking!


¹ http://hackingcomtapioca.blogspot.com.br/2014/01/python-backdoors-1-linha.html

Nenhum comentário:

Postar um comentário