quarta-feira, 18 de junho de 2014

These aren't the droids you are looking for: Android Backdoors

Nesta postagem eu vou mostrar como criar um backdoor simples para um dispositivo Android com o Metasploit e vou fazer uma pequena análise sobre o apk gerado.

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.

Gerando um Backdoor


Um backdoor (Reverse TCP) para Android pode ser facilmente gerado com o Metasploit. O msfvenom pode ser utilizado para gerar um apk malicioso (Ver Figura 01).
Figura 01: Msfvenom
Vou utilizar o adb para instalar o backdoor em um simulador (Ver Figura 02).

Figura 02: Utilizando Abd para instalar backdoor

Rodando o Backdoor


Uma vez instalado, o backdoor vai aparecer da seguinte maneira no dispostivo:

Figura 03: Backdoor no Simulador

Antes de executar o backdoor, você deve gerar um 'handler' no Metasploit para receber a conexão reversa realizada pelo apk malicioso (Ver Figura 04).

Figura 04: Criando Handler

Execute o backdoor no simulador (ou dispositivo) e veja uma sessão sendo aberta no Metasploit (Ver Figura 05)

Figura 05: Sessão Aberta

Analisando o Backdoor


Vamos agora dar uma olhada melhor no apk gerado pelo Metasploit e ver se conseguimos aprender algumas coisas com ele. 

Taxa de Detecção

Vamos primeiro começar dando uma verificada na taxa de detecção do apk malicioso. A figura 06 apresenta os resultados do VirusTotal para o backdoor.

Figura 06: VirusTotal

O apk gerado apresenta uma taxa de detecção significativa (14 entre 54). A lista completa de detecção pode ser visualizada em https://www.virustotal.com/en/file/ae2133416ecddbe53390b46f6708200a0d2b6515800dfe6823bf5d1b8789640e/analysis/1402957750/

AndroidManifest.xml


O próximo passo é verificar o arquivo AndroidManifest.xml localizado dentro do apk. A figura 07 apresenta algumas informações básicas como nome do pacote e permissões necessárias para o malware.

Figura 07: AndroidManifest.xml 01
A partir da figura 07, é possível verificar que o malware é identificado pelo nome de pacote "com.metasploit.stage" (bastante sugestivo hehe) e utiliza um grande número de permissões (Ex: INTERNET, SEND_SMS e CAMERA). O apk apresenta uma única Activity: ".MainActivity" (ver figura 08).

Figura 08: AndroidManifest.xml 02

Decompilação (Parte 01)


O próximo passo é decompilar o apk e analisar o código fonte da aplicação. A Figura 09 apresenta as classes presentes no apk. É possível verificar a presença de MainActivity (declarada no Manifest.xml) e mais 3 classes (BuildConfig, LoadStage e R).

Figura 09: Classes
Vamos começar analisando a classe MainActivity. A partir da figura 10, é possível verificar de que o método 'AsyncTask()' é chamado logo no momento de criação de MainActivity. O método 'reverseTCP()' é chamado por 'AsyncTask()'.

Figura 10: MainActivity
A figura 11 apresenta o método 'reverseTCP()' e algumas variáveis globais (LHOST e LPORT). O método 'reverseTCP' cria um socket (gerando uma conexão para LHOST) e chama a classe 'LoadStage'.

Figura 11: MainActivity 02

A classe 'LoadStage' apresenta 2 métodos interessantes: 
  • randomJarName: Cria uma String de 20 caracteres aleatórios que vai servir de nome para um arquivo '.jar'.
  • start: Cria um novo arquivo '.jar' () e baixa o conteúdo de um novo arquivo '.dex' pela rede. DexClassLoader e Reflection são utilizados para executar o novo arquivo '.dex' (ultimas 3 linhas do método 'start').   

Figura 12: LoadStage

Decompilação (Parte 02)


Nesta segunda parte vamos analisar o novo '.dex' gerado no dispositivo. A figura 13 apresenta os novos arquivos criados na pasta do aplicativo (observe os nomes aleatórios utilizados nos arquivos).

Figura 13: Novos arquivos gerados (jar e dex)
Eu encontrei um pequeno problema durante o processo de decompilação do arquivo '.dex' (ver figura 14). O arquivo na realidade trata-se de ser um '.odex' (tipo otimizado de '.dex').

Figura 14: Erro na decompilação (Arquivo 'odex')

Para decompilar um arquivo '.odex' vamos ter que tomar alguns passos:
  • Copiar os arquivos de '/system/framework' para a máquina local
    • "adb pull /system/framework/ /tmp/framework/"
  • Obter arquivos 'smali' utilizando o baksmali.jar
    • "java -jar baksmali-2.0.3.jar -a 15 -x /tmp/nome_aleatorio.dex -d /tmp/framework/ -o Backdoor"
  • Reconstruir o 'classes.dex' com smali.jar
    • "java -jar smali-2.0.3.jar -o classes.dex Backdoor/"

Decompilação (Parte 3)


Agora podemos analisar melhor o '.dex' baixado e executado pelo backdoor. O arquivo '.jar' agora é recriado sem problemas. A Figura 15 apresenta as classes presentes (Shell, Stage e StreamForwarder).

Figura 15: Classes 02
Os nomes dos pacotes são novamente bem sugestivos (hehe). A partir da figura 16, é possível verificar que a classe Shell cria um novo processo ('sh') e realiza uma śerie de 'redirecionamentos' para executar cada instrução recebida pelo atacante e retornar a resposta de cada comando executado.

Figura 16: Classe Shell

Conclusão


Nesta postagem eu falei um pouco sobre backdoors em Android (gerados pelo Metasploit) e fiz uma pequena análise sobre eles. O processo de decompilação pode ser reproduzido para outros tipos de malware. Por favor escrevam suas sugestões e comentários!

Obrigado :)

Keep Hacking!

sábado, 17 de maio de 2014

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).


sexta-feira, 9 de maio de 2014

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!

segunda-feira, 5 de maio de 2014

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. 



sábado, 12 de abril de 2014

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!

sexta-feira, 4 de abril de 2014

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!

quarta-feira, 26 de março de 2014

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.