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

Bank Phishing: The Fulerage Never Ends!

Nesta postagem eu vou estar descrevendo uma pequena análise realizada em cima de um e-mail de phishing que eu recebi recentemente (Espero que isso sirva de ajuda para futuras análises de phishing e páginas maliciosas para os leitores do blog)..

Análise inicial do e-mail

 

A figura abaixo apresenta a mensagem original de phishing.

Figura 01: Mensagem Original

Já da para perceber pela figura 01 que este e-mail se trata de um phishing voltado para clientes de um determinado banco. A partir do conteúdo da mensagem, podemos ver que a mesma apresenta um link para endereço o qual não pertence ao banco (ver figura 02).

Figura 02: Link de origem

Analisando o link de origem

Através da figura 02 é possível ver o endereço do link da mensagem:

http://spaces.isu.edu.tw/~lawedu/media/system/images/sex5/?cliente=[E-MAIL]

O servidor 'spaces.isu.edu.tw' está localizado no endereço IP '140.133.46.51'. Através de um simples 'whois' nós podemos obter algumas informações sobre o endereço de origem do link (ver figura 03).

Figura 03: Whois

Vamos agora realizar uma requisição para o link citado sendo que com um endereço de e-mail diferente para o parâmetro 'cliente' (ver figura 04).

Figura 04: Acessando o servidor malicioso

Através da Figura 04 é possível ver que o servidor 'spaces.isu.edu.tw' realiza um redirecionamento da nossa requisição para 'www.prfprinting.ir' (localizado no servidor 144.76.219.88). Depois de uma pequena busca, eu acabei descobrindo que o servidor 'www.prfprinting.ir' foi previamente invadido e um webshell foi instalado por um atacante (ver figura 05).

Figura 05: Obtendo informações sobre o servidor

Analisando o conteúdo da página

 

Neste momento vamos analisar o conteúdo devolvido pelo servidor 'www.prfprinting.ir'. Três arquivos '.php' (topo, body e rodape) fazem parte da página retornada pelo servidor (ver Figura 06).  

Figura 06: Página principal do servidor

Depois de analisar um pouco cada um dos três arquivos '.php', eu percebi a presença de código javascript obfuscado em 'topo.php' e 'body.php'. O arquivo 'body.php' apresenta alguns pontos mais importantes para a análise do ataque: funções suspeitas e o arquivo 'cmds.js'.

Funções suspeitas

O arquivo 'body.php' apresenta algumas funções suspeitas: fCheck, cxk e puxaDados (ver figuras 07 e 08).

Figura 07: Funções puxaDados e cxk

Figura 08: Função fCheck

Arquivo cmds.js

 

A página 'body.php' importa um arquivo 'cmds.js' (ver figura 09)

Figura 09: Importando 'cmds.js

O início do arquivo 'cmd.js' é apresentado na figura 10.

Figura 10: arquivo cmd.js

As figuras 11 e 12 apresentam as funções cxk, puxaDados e fCheck (É importante notar que certas partes das funções puxaDados e fCheck estão obfuscadas!).

Figura 11: Funções cxk e puxaDados

Figura 12: Função fCheck

A função fCheck recebe dois parâmetros de entrada: 'ppl' e 'action'. A função realiza diversos 'ifs' comparando o conteúdo da variável 'action' com diversos valores (ex: 'ggc', 'sen' e 'wtv'). Vamos focar em uma dessas comparações (eu vou selecionar 'sen' (Mesmo valor presente na figura 08!)). A figura 13 apresenta a parte do código no qual o valor de 'action' é comparado com 'sen'.

Figura 13: Função fCheck (checando ifs)

A partir da figura 12, é possível constatar de que partes do código da função fCheck estãos obfuscados. Vamos deobfuscar estas partes para ter uma ideia melhor do que ocorre durante esta função. As figuras 14 e 15 apresentam os 'pedaços' de códigos antes e depois da deobfuscação.

Figura 14: Código Obfuscado

Figura 15: Código Deobfuscado

A partir da Figura 15, podemos ver uma variável 'sen' sendo criada a partir do elemento 'campo_s_se_1522_0922'. Esta variável contém a senha utilizada pelo usuário na página de phishing. A função verifica se a variável 'sen' tem 6 ou mais caracteres. A variável 'varsend' é formada por:

varsend = 'altera=senha&senhae=' + sen.value

A função 'enviaDados' é chamada com 2 parâmetros:

1. ppl = Endereço IP da vítima
2. varsend = 'altera=senha&senhae=' + sen.value

Função enviaDados

 

Vamos ver agora de que forma os dados do usuário são enviados para o atacante. Vamos continuar ainda nesse exemplo da senha do usuário. A função 'enviaDados' é apresentada na Figura 16.

Função 16: Função 'enviaDados' (Obfuscada)

A função 'enviaDados' apresenta uma parte de seu código obfuscada. Vamos agora deobfuscar esta seção do código (ver Figura 17).

Figura 17: Função 'enviaDados' (Deobfuscada)

A função 'enviaDados' cria uma requisição POST para o endereço 'http://www.prfprinting.ir/atendimento.online/components/com_user/user/plugin/index.php' enviando a senha da vítima através do parâmetro 'senhae'.

Conclusão

Nesta postagem eu apresentei uma análise básica de um e-mail de phishing contra clientes de um determinado banco. O phishing análisado obtinha dados dos clientes (como senha) e enviava estes dados para uma URL específica do servidor 'www.prfprinting.ir'. Os arquivos maliciosos do servidor  'www.prfprinting.ir' foram removidos recentemente (provavelmente pelos responsáveis do servidor). Por favor escrevam suas sugestões e comentários!

Obrigado :)

Keep Hacking!

All your routers are belong to us: Atacando OSPF (Parte 1)

Nesta postagem eu vou estar falando um pouco sobre possíveis ataques contra o protocolo OSPF (Open Shortest Path First). Estarei focando nesta primeira parte na coleta de tráfego OSPF e ataques contra os métodos de autenticação utilizados pelo protocolo.

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

O OSPF é um protocolo importante utilizado para facilitar a troca de informações de roteamento entre roteadores. Para realizar os ataques, vamos primeiro analisar os tipos de mensagens utilizadas pelo protocolo:

1. Hello: Mensagem inicial utilizada por um roteador na descoberta de roteadores vizinhos em uma rede local.
   
2. Database Description: Estas mensagens contém informações sobre a topologia de um AS (Autonomous System)
3. Link State Request: Mensagem utilizada para realizar um pedido de informações para atualização de rotas.
4. Link State Update: Mensagens de atualizações enviadas em resposta à uma requisição Link State Request.
5. Link State Acknowledgment: Mensagem de confirmação (para o Link State Update).

 O protocolo OSPF permite que todos os tipos de mensagens possam ser autenticadas através de diferentes métodos (descritos mais adiante). A análise dos cabeçalhos das mensagens OSPF torna-se importante para entender como podemos atacar estes métodos de autenticação.

Formato de Mensagens:

O cabeçalho de uma mensagem OSPF costuma ter 8 campos (um total de 24 bytes):

• Version: Versão do protocolo
• Type: Tipo de mensagem OSPF (descrito na introdução)
• Packet Length: Tamanho da mensagem (incluindo o cabeçalho)
• Router ID: Identificador do roteador que gerou a mensagem.
• Area ID: Identificador da área a qual a mensagem pertence.
• Checksum: Código checksum da mensagem
• AuType: Tipo de autenticação utilizado pela mensagem
• Authentication: Campo utilizado para autenticação da mensagem (conteúdo do campo vai depender do tipo de autenticação utilizado).

Vamos focar no campos AuType e Authentication!

Figura 01: Cabeçalho OSPF

Método de autenticação 01: Autenticação nula

O primeiro método de autenticação utilizado pelo protocolo é uma autenticação nula (ou simplesmente a falta de autenticação hehe). Neste método o campo AuType apresenta um valor 0 e o campo Authentication encontra-se vazio. A figura 02 apresenta um exemplo de mensagem OSPF com autenticação nula.

Figura 02: Autenticação Nula

Método de autenticação 02: Autenticação simples

O segundo método de autenticação utilizado pelo protocolo apresenta a utilização de uma senha para trocar de mensagens OSPF. Neste método o campo AuType apresenta o valor 1, enquanto que o campo Authentication apresenta a senha em texto claro! A figura 03 apresenta um exemplo de mensagem OSPF com autenticação simples.

Figura 03: Autenticação Simples

Método de autenticação 03: Autenticação com criptografia

O terceiro método utiliza funções de hash para a autenticação de mensagem OSPF. Neste método o campo AuType apresenta o valor 2, enquanto que o campo Authentication apresenta um valor hash em MD5 (construção do hash é descrito a seguir).  A figura 04 apresenta um exemplo de mensagem OSPF autenticada através de criptografia.

Figura 04: Autenticação com criptografia

Construção do Hash

O hash presente no método de autenticação 03 é criado da seguinte forma:

1. Mensagem OSPF é gerada normalmente (checksum deve ser igual zero).
2. A senha secreta (em texto claro) deve ter tamanho igual a 16 bytes. Caso o tamanho da senha seja menor que 16, bytes nulos (0x00) são adicionados no final da senha. Caso contrário, apenas os primeiros 16 bytes da senha secreta devem ser utilizados.
3. Hash = MD5(Mensagem OSPF + senha secreta de 16 bytes).

Atacando OSPF: Criando um sniffer

Para iniciar os ataques, precisamos primeiro criar um sniffer para a coleta de tráfego OSPF. Eu vou utilizar a biblioteca Scapy para criar um sniffer em Python (como de costume hehe!). Os testes apresentados nesta postagem foram realizados em uma VM do Kali Linux 1.0.6 (antigo BackTrack).

A biblioteca Scapy não apresenta o suporte à mensagens OSPF  por padrão. Por isso, precisamos pegar uma extensão disponível publicamente para a coleta e manipulação de mensagens OSPF (extensão disponivel para download em http://bb.secdev.org/scapy/raw/300258ace1bc7e50a5c6e159d2919f474149d8ba/scapy/contrib/ospf.py).

A primeira parte da criação do sniffer é gerar um método para a filtragem de pacotes OSPF (o qual pode ser facilmente realizado através da classe OSPF_Hdr). A figura 05 apresenta uma maneira de realizar a filtragem de mensagens OSPF.

Figura 05: Filtrando pacotes

A segunda parte do script envolve a verificação do tipo de autenticação utilizado pela mensagem OSPF capturada. A figura 06 apresenta um exemplo de função para a verificação do tipo de autenticação.

Figura 06: Verificando o tipo de autenticação

A terceira parte é responsável por realizar um ataque de dicionário contra o hash encontrado no pacote coletado. A figura 7 apresenta um exemplo de criação de hash a partir de uma determinada wordlist.

Figura 07: Quebra de senha (Hash MD5)

As figuras abaixo apresentam o resultado do script rodando em 3 cenários possíveis de autenticação (autenticação nula, autenticação simples e autenticação com criptografia).

Figura 08: Autenticação Nula

 

Figura 09: Autenticação Simples

Figura 10: Autenticação com Criptografia

O script encontra-se para download no GitHub:
https://raw2.github.com/pasknel/hacking-com-tapioca/master/OSPF/ospf_crack.py

Conclusão

Nesta postagem foram apresentados alguns ataques contra o protocolo OSPF. Os métodos de autenticação utilizados nas mensagens OSPF podem ser atacados através da coleta de pacotes e ataques de força-bruta/dicionário. Por favor escrevam suas sugestões e comentários!

Obrigado :)

Keep Hacking!

Palestra: Pentest em Web Services (Video)

Pessoal,

Ai vai o vídeo da palestra "Pentest em Web Services" para quem perdeu o evento (1º Sábado com TIC). O evento foi bem legal e teve um bom número de pessoas assistindo as palestras. Já estou planejando a minha próxima palestra deste semestre e alguns workshops (acho que deve ser ainda nesse trimestre). Obrigado e deixem seus comentários.