Authentification et mots de passe
Exercices corrigés

def evaluer_mot_de_passe(mot_de_passe):
    """Évalue la force d'un mot de passe"""
    score = 0
    details = []
    
    # Longueur
    if len(mot_de_passe) >= 12:
        score += 2
        details.append("✓ Longueur suffisante (≥12 caractères)")
    elif len(mot_de_passe) >= 8:
        score += 1
        details.append("⚠ Longueur moyenne (8-11 caractères)")
    else:
        details.append("✗ Trop court (<8 caractères)")
    
    # Majuscules
    if any(c.isupper() for c in mot_de_passe):
        score += 1
        details.append("✓ Contient des majuscules")
    else:
        details.append("✗ Pas de majuscules")
    
    # Minuscules
    if any(c.islower() for c in mot_de_passe):
        score += 1
        details.append("✓ Contient des minuscules")
    else:
        details.append("✗ Pas de minuscules")
    
    # Chiffres
    if any(c.isdigit() for c in mot_de_passe):
        score += 1
        details.append("✓ Contient des chiffres")
    else:
        details.append("✗ Pas de chiffres")
    
    # Caractères spéciaux
    caracteres_speciaux = "!@#$%^&*()_+-=[]{}|;:,.<>?"
    if any(c in caracteres_speciaux for c in mot_de_passe):
        score += 1
        details.append("✓ Contient des caractères spéciaux")
    else:
        details.append("✗ Pas de caractères spéciaux")
    
    # Évaluation finale
    if score >= 5:
        resultat = "Très fort"
    elif score >= 3:
        resultat = "Fort"
    elif score >= 2:
        resultat = "Moyen"
    else:
        resultat = "Faible"
    
    return resultat, score, details

# Exemple d'utilisation
mdp = "MotDePasse!2023"
niveau, score, details = evaluer_mot_de_passe(mdp)
print(f"Niveau: {niveau} (Score: {score}/6)")
for detail in details:
    print(detail)

import hashlib
import time
import secrets

class SystemeAuthentification:
    def __init__(self):
        self.utilisateurs = {}
        self.codes_temporaires = {}
    
    def enregistrer_utilisateur(self, identifiant, mot_de_passe):
        """Enregistre un nouvel utilisateur"""
        hash_mdp = hashlib.sha256(mot_de_passe.encode()).hexdigest()
        self.utilisateurs[identifiant] = hash_mdp
        print(f"Utilisateur {identifiant} enregistré avec succès")
    
    def authentification_etape1(self, identifiant, mot_de_passe):
        """Première étape : authentification par mot de passe"""
        if identifiant not in self.utilisateurs:
            return False, "Utilisateur inconnu"
        
        hash_saisi = hashlib.sha256(mot_de_passe.encode()).hexdigest()
        if hash_saisi == self.utilisateurs[identifiant]:
            # Générer un code temporaire
            code = secrets.token_hex(3)[:6].upper()
            self.codes_temporaires[identifiant] = {
                'code': code,
                'timestamp': time.time()
            }
            print(f"Code MFA envoyé à l'utilisateur {identifiant}")
            return True, "Code MFA envoyé"
        else:
            return False, "Mot de passe incorrect"
    
    def authentification_etape2(self, identifiant, code_saisi):
        """Deuxième étape : vérification du code MFA"""
        if identifiant not in self.codes_temporaires:
            return False, "Aucun code en attente"
        
        info_code = self.codes_temporaires[identifiant]
        
        # Vérifier l'expiration (5 minutes)
        if time.time() - info_code['timestamp'] > 300:
            del self.codes_temporaires[identifiant]
            return False, "Code expiré"
        
        if code_saisi.upper() == info_code['code']:
            # Supprimer le code après utilisation
            del self.codes_temporaires[identifiant]
            return True, "Authentification réussie"
        else:
            return False, "Code incorrect"

# Exemple d'utilisation
auth = SystemeAuthentification()
auth.enregistrer_utilisateur("alice", "MotDePasse!2023")

# Étape 1
succes, message = auth.authentification_etape1("alice", "MotDePasse!2023")
print(message)

if succes:
    # Étape 2 (simulée)
    code_utilisateur = input("Entrez le code MFA : ")
    succes2, message2 = auth.authentification_etape2("alice", code_utilisateur)
    print(message2)

import hashlib
import secrets
import bcrypt

class GestionHachage:
    @staticmethod
    def hacher_sha256(mot_de_passe, sel=None):
        """Hachage avec SHA-256"""
        if sel is None:
            sel = secrets.token_hex(16)
        
        mot_de_passe_avec_sel = mot_de_passe + sel
        hache = hashlib.sha256(mot_de_passe_avec_sel.encode()).hexdigest()
        return hache, sel
    
    @staticmethod
    def hacher_bcrypt(mot_de_passe):
        """Hachage avec bcrypt (recommandé pour les mots de passe)"""
        sel = bcrypt.gensalt()
        hache = bcrypt.hashpw(mot_de_passe.encode(), sel)
        return hache.decode()
    
    @staticmethod
    def verifier_bcrypt(mot_de_passe, hache_stocke):
        """Vérification avec bcrypt"""
        return bcrypt.checkpw(mot_de_passe.encode(), hache_stocke.encode())
    
    @staticmethod
    def comparer_algorithmes():
        """Comparaison des algorithmes de hachage"""
        mot_de_passe = "MotDePasse!2023"
        
        # SHA-256
        hache_sha, sel_sha = GestionHachage.hacher_sha256(mot_de_passe)
        print(f"SHA-256: {hache_sha[:20]}...")
        print(f"Sel SHA: {sel_sha}")
        
        # Bcrypt
        hache_bcrypt = GestionHachage.hacher_bcrypt(mot_de_passe)
        print(f"Bcrypt: {hache_bcrypt[:20]}...")
        
        # Vérification
        verification = GestionHachage.verifier_bcrypt(mot_de_passe, hache_bcrypt)
        print(f"Vérification réussie: {verification}")

# Comparaison des algorithmes
GestionHachage.comparer_algorithmes()

import hashlib
import time
from datetime import datetime, timedelta

class GestionMotsDePasse:
    def __init__(self):
        self.utilisateurs = {}  # {identifiant: {'mot_de_passe': hache, 'historique': [], 'date_modification': timestamp}}
        self.politique = {
            'longueur_minimale': 12,
            'exiger_majuscules': True,
            'exiger_chiffres': True,
            'exiger_caracteres_speciaux': True,
            'delai_expiration': 90,  # jours
            'historique_taille': 5,
            'tentatives_max': 3,
            'delai_verrouillage': 300  # secondes
        }
    
    def valider_mot_de_passe(self, mot_de_passe):
        """Valide un mot de passe selon la politique"""
        erreurs = []
        
        if len(mot_de_passe) < self.politique['longueur_minimale']:
            erreurs.append(f"Longueur insuffisante (minimum {self.politique['longueur_minimale']} caractères)")
        
        if self.politique['exiger_majuscules'] and not any(c.isupper() for c in mot_de_passe):
            erreurs.append("Doit contenir au moins une majuscule")
        
        if self.politique['exiger_chiffres'] and not any(c.isdigit() for c in mot_de_passe):
            erreurs.append("Doit contenir au moins un chiffre")
        
        if self.politique['exiger_caracteres_speciaux']:
            caracteres_speciaux = "!@#$%^&*()_+-=[]{}|;:,.<>?"
            if not any(c in caracteres_speciaux for c in mot_de_passe):
                erreurs.append("Doit contenir au moins un caractère spécial")
        
        return len(erreurs) == 0, erreurs
    
    def changer_mot_de_passe(self, identifiant, ancien_mot_de_passe, nouveau_mot_de_passe):
        """Change le mot de passe d'un utilisateur"""
        if identifiant not in self.utilisateurs:
            return False, "Utilisateur inconnu"
        
        utilisateur = self.utilisateurs[identifiant]
        
        # Vérifier l'ancien mot de passe
        ancien_hache = hashlib.sha256(ancien_mot_de_passe.encode()).hexdigest()
        if ancien_hache != utilisateur['mot_de_passe']:
            return False, "Ancien mot de passe incorrect"
        
        # Valider le nouveau mot de passe
        est_valide, erreurs = self.valider_mot_de_passe(nouveau_mot_de_passe)
        if not est_valide:
            return False, f"Mauvais format: {'; '.join(erreurs)}"
        
        # Vérifier qu'il n'a pas déjà été utilisé
        hache_nouveau = hashlib.sha256(nouveau_mot_de_passe.encode()).hexdigest()
        if hache_nouveau in utilisateur['historique']:
            return False, "Mot de passe déjà utilisé récemment"
        
        # Mettre à jour
        utilisateur['mot_de_passe'] = hache_nouveau
        utilisateur['historique'].append(hache_nouveau)
        
        # Garder uniquement les derniers mots de passe dans l'historique
        if len(utilisateur['historique']) > self.politique['historique_taille']:
            utilisateur['historique'] = utilisateur['historique'][-self.politique['historique_taille']:]
        
        utilisateur['date_modification'] = time.time()
        
        return True, "Mot de passe changé avec succès"
    
    def est_expire(self, identifiant):
        """Vérifie si le mot de passe est expiré"""
        if identifiant not in self.utilisateurs:
            return False
        
        utilisateur = self.utilisateurs[identifiant]
        date_modification = utilisateur.get('date_modification', 0)
        expiration_limite = time.time() - (self.politique['delai_expiration'] * 24 * 3600)
        
        return date_modification < expiration_limite

# Exemple d'utilisation
gestion = GestionMotsDePasse()
gestion.utilisateurs['alice'] = {
    'mot_de_passe': hashlib.sha256('AncienMotDePasse!2022'.encode()).hexdigest(),
    'historique': [hashlib.sha256('AncienMotDePasse!2022'.encode()).hexdigest()],
    'date_modification': time.time() - (100 * 24 * 3600)  # Il y a 100 jours
}

succes, message = gestion.changer_mot_de_passe('alice', 'AncienMotDePasse!2022', 'NouveauMotDePasse!2023')
print(message)

import time
import hashlib
import threading
import queue

class SystemeProtectionAvance:
    def __init__(self):
        self.utilisateurs = {}
        self.compteur_tentatives = {}
        self.heures_verrouillage = {}
        self.adresses_ip = {}  # Pour limiter par IP
        self.tentatives_max = 3
        self.delai_verrouillage = 300  # 5 minutes
        self.tentatives_max_ip = 10  # par heure
        self.delai_ip = 3600  # 1 heure
        self.file_attente = queue.Queue()
        self.lock = threading.Lock()
    
    def ajouter_utilisateur(self, identifiant, mot_de_passe):
        """Ajoute un utilisateur avec son mot de passe haché"""
        self.utilisateurs[identifiant] = hashlib.sha256(mot_de_passe.encode()).hexdigest()
    
    def est_verrouille_ip(self, adresse_ip):
        """Vérifie si l'adresse IP est verrouillée"""
        with self.lock:
            if adresse_ip not in self.adresses_ip:
                return False
            
            ip_info = self.adresses_ip[adresse_ip]
            if time.time() - ip_info['heure_derniere'] < self.delai_ip:
                return ip_info['tentatives'] >= self.tentatives_max_ip
            else:
                # Réinitialiser le compteur après le délai
                del self.adresses_ip[adresse_ip]
                return False
    
    def est_verrouille_utilisateur(self, identifiant):
        """Vérifie si l'utilisateur est verrouillé"""
        with self.lock:
            if identifiant in self.heures_verrouillage:
                heure_verrouillage = self.heures_verrouillage[identifiant]
                if time.time() - heure_verrouillage < self.delai_verrouillage:
                    return True
                else:
                    # Délai écoulé, réinitialiser
                    del self.heures_verrouillage[identifiant]
                    self.compteur_tentatives[identifiant] = 0
                    return False
            return False
    
    def authentifier(self, identifiant, mot_de_passe, adresse_ip):
        """Système d'authentification avec protection avancée"""
        # Vérifier l'IP
        if self.est_verrouille_ip(adresse_ip):
            return False, "Adresse IP bloquée pour tentatives excessives"
        
        # Vérifier le verrouillage de l'utilisateur
        if self.est_verrouille_utilisateur(identifiant):
            return False, "Compte verrouillé temporairement"
        
        # Vérifier si le mot de passe est correct
        hache_saisi = hashlib.sha256(mot_de_passe.encode()).hexdigest()
        if identifiant in self.utilisateurs and self.utilisateurs[identifiant] == hache_saisi:
            # Réinitialiser les tentatives en cas de succès
            with self.lock:
                if identifiant in self.compteur_tentatives:
                    del self.compteur_tentatives[identifiant]
                if adresse_ip in self.adresses_ip:
                    del self.adresses_ip[adresse_ip]
            return True, "Authentification réussie"
        else:
            # Gérer les tentatives échouées
            with self.lock:
                # Compter la tentative pour l'utilisateur
                if identifiant not in self.compteur_tentatives:
                    self.compteur_tentatives[identifiant] = 0
                self.compteur_tentatives[identifiant] += 1
                
                # Compter la tentative pour l'IP
                if adresse_ip not in self.adresses_ip:
                    self.adresses_ip[adresse_ip] = {'tentatives': 0, 'heure_derniere': time.time()}
                self.adresses_ip[adresse_ip]['tentatives'] += 1
                self.adresses_ip[adresse_ip]['heure_derniere'] = time.time()
                
                if self.compteur_tentatives[identifiant] >= self.tentatives_max:
                    self.heures_verrouillage[identifiant] = time.time()
                    return False, f"Trop de tentatives, compte verrouillé pour {self.delai_verrouillage//60} minutes"
                
                tentatives_restantes = self.tentatives_max - self.compteur_tentatives[identifiant]
                return False, f"Mauvais mot de passe, {tentatives_restantes} tentatives restantes"

# Exemple d'utilisation
systeme = SystemeProtectionAvance()
systeme.ajouter_utilisateur("alice", "MotDePasse!2023")

# Test d'authentification
resultat, message = systeme.authentifier("alice", "MauvaisMotDePasse", "192.168.1.1")
print(message)