Mini-Curso: Pentest em IPv6

Pessoal!

Estou aqui divulgando o meu mini-curso de "Pentest em IPv6". Neste curso vamos ver a metodologia de um Pentest sendo aplicada para cenários de redes IPv6. Os tópicos do mini-curso:

1. Introdução 
2. Scanning em redes IPv6
3. Exploitation em redes IPv6
4. Post-Exploitation em redes IPv6

Vai ser um mini-curso de nível "Intermediário/Avançado" por isso eu recomendo o curso para aqueles que ja tem conhecimento de redes (vamos trabalhar muito com cabeçalhos e geração de pacotes) e programação (vamos criar nossas próprias ferramentas para alguns ataques).

O mini-curso vai estar ocorrendo dentro do envento "4º Sábado com TIC". O evento vai ser realizado no dia 31/05/2014. O banner do evento vai aqui embaixo para maiores informações (Obs: O mini-curso vai ser PAGO entretanto as palestras do evento serão grátis).

Análise de Malware 01: ZitMo (Android)

Hoje eu vou estar fazendo uma pequena análise sobre o ZitMo (também conhecido como ZeuS-in-the-Mobile). O ZitMo é um malware para Android e foi desenvolvido com o objetivo de roubar mensagens de SMS do dispositivo da vítima (vamos ver como isso funciona). O arquivo '.apk' pode ser encontrado na URL abaixo:

http://www.mediafire.com/?jvds225lczxrv7o (senha: infected)

Detecção

Podemos verificar algumas detecções iniciais mandando o arquivo '.apk' para o VirusTotal. A figura 01 apresenta a quantidade de anti-vírus que detectaram o arquivo como sendo malicioso.

Figura 01: Taxa de Detecção

A partir da figura 02, é possível verificar de que alguns anti-vírus identificam o arquivo como sendo Zitmo (Ex: Kaspersky) e outros identificam como sendo 'Android/Spy' (Ex: McAfee).

Figura 02: Lista de AVs

 

Informações Básicas

Vamos dar uma olhada no arquivo 'AndroidManifest.xml' e obter algumas informações básicas sobre o malware. A Figura 03 apresenta o início do arquivo 'AndroidManifest.xml'.

Figura 03: Verificando permissões

 É possivel verificar que o malware necessita de 3 permissões:

• RECEIVE_SMS: Acesso às mensagens de SMS recebidas
• INTERNET: Acesso à internet
• READ_PHONE_STATE: Acesso de leitura ao estado do dispositivo

A figura 04 apresenta mais informações sobre o 'AndroidManifest.xml'.

Figura 04: Verificando activities e receivers

A partir da figura 04, é possível verificar de que a aplicação apresenta uma única Activity (identificado como ".Activation") e um broadcast receiver (identificado como ".SmsReceiver"). Tambem é possível constatar de que o receiver utilizado responde às mensagens de SMS recebidas.

Instalando o Apk no Simulador

Vamos agora instalar o malware no simulador (disponível no ADT). A instalação pode ser realizada facilmente com a ferramenta 'adb' da seguinte forma:

• adb install 'arquivo.apk'

A figura 05 apresenta o malware instalado no simulador. Percebam de que o malware se apresenta ao usuário como 'Trusteer Rapport'.

Figura 05: Malware instalado

A figura 06 apresenta o malware sendo executado (uma única Activity).

Figura 06: Malware sendo executado

Decompilando o código

Vamos decompilar o malware para podermos ter mais informações sobre o seu funcionamento interno. A Figura 07 apresenta as classes presentes na aplicação (6 ao total). 

Figura 07: Decompilação (Classes)

 Classe SmsReceiver

A partir da figura 04, foi possível constatar de que o malware possui um Broadcast Receiver (implementado na classe SmsReceiver). A classe SmsReceiver recebe eventos de mensagens de SMS e encaminha elas para a classe MainService (ver figura 08).

Figura 08: Classe SmsReceiver

Classe MainService

A classe MainService é chamada por SmsReceiver e encaminha as mensagens de SMS recebidas para uma Thread (SmsBlockerThread). A figura 09 apresenta um trecho da classe MainService.

Figura 09: Classe MainService

Thread SmsBlockerThread

 

SmsBlockerThread realiza algumas ações nas mensagens recebidas:

1. Extração de informação: A Thread retira informações sensíveis da mensagem de SMS. As variáveis 'str1' e 'str2' contém respectivamente a orígem e conteúdo da mensagem. A variável 'str3' apresenta o IMEI do dispositivo.
2. Envio de informações: Os dados roubados são encaminhados para o método 'postRequest' da classe ServerSession (esta classe é responsável por enviar os dados para um servidor remoto).

Figura 10: SmsBlockThread

Classe ServerSession

Na classe ServerSession podemos constatar alguns pontos:

1. Localização do servidor remoto: O método 'initUrl' retorna uma String com a localização do servidor remoto (para onde as informações da vítima são enviadas)
2. Envio das mensagens: As informações roubadas são enviadas através do método postRequest (DefaultHttpClient é utilizado para realizar a requisição HTTP [Variável 'localHttpPost']).

Figura 11: Classe ServerSession

Conclusão

Nesta postagem eu fiz uma pequena análise sobre o ZitMo (ZeuS-in-the-Mobile). Eu devo estar apresentado mais algumas análises de malware no blog. Por favor escrevam suas sugestões e comentários!

Obrigado :)

Keep Hacking!

Palestra: OWASP Chapter Recife 2014

Pessoal!

Mais uma vez eu estou aqui divulgando uma de minhas palestras. A palestra vai ser dia 10 de Maio la no OWASP Chapter Recife 2014! Eu estarei falando sobre evasão de antivírus (vou estar apresentando algumas técnicas e ferramentas que acabei desenvolvendo durante alguns projetos de Pentest realizados). O banner do evento vai aqui em baixo para maiores informações. 

My Heart Bleeds For You: Analisando OpenSSL Bug

A não ser que você esteja vivendo em uma caverna pelos ultimos dias, é muito provavel que você ja tenha ouvido falar sobre uma nova vulnerabilidade identificada no OpenSSL (referenciada como CVE-2014-0160). Nesta postagem eu vou estar analisando esta vulnerabilidade e também alguns códigos de PoC que ja podem ser encontrados publicamente disponíveis.

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.

SSL: Heartbeat message

Nós precisamos começar falando sobre um tipo específico de mensagem utilizada pelo SSL: Heartbeat message. A vulnerabilidade do OpenSSL ocorre exatamente  na maneira pela qual esta mensagem é tratada. Vamos começar analisando a estrutura desse tipo de mensagem.

O 'Heartbeat' é definido no RFC 6520 e apresenta a seguinte estrutura:

Figura 01: Mensagem 'Heartbeat' (RFC 6520)

A mensagem é formada por 4 campos:

1. Campo 'type': Tipo da mensagem (requisição ou resposta)
2. Campo 'payload_length': Tamanho do payload
3. Campo 'payload': Payload da mensagem (dados arbitrários)
4. Campo 'padding': Bytes extras de padding

Analisando o Bug 

A vulnerabilidade encontra-se em d1_both.c (função dtls1_process_heartbeat) do OpenSSL. O código é chamado durante o processamento de requisições heartbeat (A Figura 02 apresenta o código vulnerável).

Figura 02: Código vulnerável (d1_both.c)

O tamanho de um buffer é definido a partir da variável 'payload' (do tipo unsigned int). Esta variável apresenta o valor do campo 'payload_length' do cabeçalho da mensagem de requisição heartbeat. É importante notar de que não existe nenhuma verificação sobre o valor (tamanho) presente na variável payload.

Analisando os primeiros PoC

Nesta seção eu vou estar analisando um dos código que eu encontrei disponíveis publicamente para download (https://gist.githubusercontent.com/takeshixx/10107280/raw/8052d8479ad0c6150464748d639b0f5e877e8c37/hb-test.py).

Este código cria uma conexão para um determinado alvo e envia 2 pacotes (variáveis 'hello' e 'hb'). Eu criei um pequeno script (utilizando scapy) para recriar os pacotes (especialmente o 'hb') para podermos analisar melhor no wireshark (Ver figura 03).

Figura 03: Recriando pacotes para análise

O meu pequeno script recriou os pacotes originais e salvou eles em um arquivo (heartbleed.pcap). A Figura 04 apresenta a análise dos pacotes no wireshark.

Figura 04: Analisando requisição heartbeat

É importante notar que a requisição heartbeat apresenta um valor de 16384 (0x4000) no campo 'payload_length' mas não apresenta payload na mensagem! O valor de 'payload_length' vai ser utilizado para definir o tamanho do buffer na função dtls1_process_heartbeat (d1_both.c). Como não existe payload, o buffer vai ser completado com valores na memória do processo. 

Explorando a vulnerabilidade

Vamos agora rodar o script contra um servidor vulnerável (utilizei um serviço com SSL na minha própria máquina virtual para fazer o teste). A Figura 05 apresenta o script em execução.

Figura 05: Explorando a vulnerabilidade

Através da figura 05, é possível ver o pedaço de um dump de memória do processo (o qual mostra o Token de acesso utilizado por um usuário da aplicação alvo). O meu serviço estava rodando TLS 1.0 por isso eu tive que trocar os bytes "03 02" (TLS 1.1) dos pacotes 'hello' e 'hb' para "03 01" (vocês podem fazer essa troca manualmente no script).

Conclusão

Nesta postagem eu fiz uma análise sobre a vulnerabilidade CVE-2014-0160 encontrada no OpenSSL. Vocês podem utilizar estas informações para verificar se os seus servidores estão vulneráveis a este tipo de ataque.

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

Obrigado :)

Keep Hacking!

DNS Brute Force

Nesta postagem eu vou estar falando um pouco sobre enumeração de DNS através de Brute Force. Eu vou estar apresentando um pequeno script para automatizar o processo de enumeração de subdominios usando Python (pra variar hehe).

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.

Pegando a Wordlist

Para realizar este ataque vamos precisar de uma wordlist com nomes comuns de subdomínios. Uma boa lista de subdomínios pode ser encontrada em http://ethicalhack3r.co.uk/files/fuzzing/subdomains.txt (ver Figura 1).

Figura 1: Lista de Subdomínios

Criando a Ferramenta

 

Vamos criar um pequeno script para automatizar o processo de enumeração DNS (Vamos chamar ele de DnsBrute). O script tem que ser capaz de realizar uma requisição DNS para cada subdominio da wordlist. Vamos utilizar threads para poder agilizar o processo de enumeração.  

O script apresenta um método 'consulta' que realiza as requisições DNS. A variável lista (do tipo Queue) é utilizada pelas threads como base de dados para as requisições realizadas. Enquanto a lista não estiver vazia, a thread gera uma requisição para cada subdomínio presente na lista. A Figura 2 apresenta a implementação das requisições DNS.

Figura 2: Método consulta()

Eu também criei um pequeno menu para o script (ver Figura 3)

Figura 3: DnsBrute.py

Agora podemos utilizar a ferramenta para enumerar os subdomínios de um determinado domínio alvo. A Figura 4 apresenta um exemplo  de execução do script e as respostas obtidas.

Figura 4: DnsBryte.py em execução

Conclusão

Nesta postagem eu apresentei um pequeno script para enumeração de subdomínios através de uma abordagem de Brute Force. O script encontra-se disponível para download em:

 

https://github.com/pasknel/hacking-com-tapioca/blob/master/DNS/DnsBrute.py

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

Obrigado :)

Keep Hacking!

Malware Wars: Analisando Malware no Ciber Espaço (Palestra)

Pessoal!

Eu estou divulgando mais uma palestra minha no evento 'Sábado com TIC'! O nome da palestra é "Malware Wars: Analisando Malware no Ciber Espaço". Esta edição do evento vai ser neste sábado (29/03) la na Unifor (Auditório 1 - Bloco A). A minha palestra vai ser a primeira do evento (09:00). O evento é grátis mas é necessário se inscrever através de e-mail. O banner do evento vai aqui em baixo para maiores informações.

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