Comment forcer le changement de mot de passe pour tous les utilisateurs dans Microsoft 365 en utilisant PowerShell

Tout d'abord, vous devez installer le module SDK Microsoft Graph PowerShell, qui remplace le module MSOnline obsolète. Ouvrez PowerShell en tant qu'administrateur et exécutez la commande d'installation.

Install-Module Microsoft.Graph -Repository PSGallery -AllowClobber -Force

L'installation peut prendre plusieurs minutes car elle télécharge plusieurs sous-modules. Si une invite apparaît concernant l'installation à partir d'un dépôt non fiable, tapez 'Y' pour continuer.

Vérification : Vérifiez la version du module installé :

Get-Module Microsoft.Graph -ListAvailable | Select-Object Name, Version

Vous devriez voir le module Microsoft.Graph répertorié avec le numéro de version actuel.

Établissez une connexion à Microsoft Graph avec les autorisations nécessaires pour modifier les politiques de mot de passe des utilisateurs. Le scope User.ReadWrite.All fournit l'accès requis pour mettre à jour les paramètres de mot de passe des utilisateurs.

Connect-MgGraph -Scopes "User.ReadWrite.All"

Cette commande ouvrira une fenêtre de navigateur pour l'authentification. Connectez-vous avec votre compte administrateur Microsoft 365 et consentez aux autorisations demandées.

Vérification : Confirmez votre connexion et vos autorisations :

Get-MgContext | Select-Object Account, Scopes

La sortie devrait montrer votre compte authentifié et le scope User.ReadWrite.All dans la liste des autorisations.

Avant d'exécuter des opérations en masse, testez le processus sur un seul compte utilisateur. Cela aide à vérifier vos autorisations et à comprendre le flux du processus.

$UserPrincipalName = "testuser@yourdomain.com"
Update-MgUser -UserId $UserPrincipalName -PasswordProfile @{
    ForceChangePasswordNextSignIn = $true
}

Remplacez 'testuser@yourdomain.com' par l'adresse e-mail réelle de l'utilisateur. Cette commande définit le drapeau ForceChangePasswordNextSignIn sur true, obligeant l'utilisateur à changer son mot de passe lors de la prochaine connexion.

Vérification : Vérifiez si l'exigence de changement de mot de passe a été appliquée :

Get-MgUser -UserId $UserPrincipalName -Property "UserPrincipalName,PasswordProfile" |
Select-Object UserPrincipalName, @{Name="MustChangePassword";Expression={$_.PasswordProfile.ForceChangePasswordNextSignIn}}

La sortie devrait afficher 'True' dans la colonne MustChangePassword, confirmant que le paramètre a été appliqué avec succès.

Avant de forcer le changement de mot de passe pour tous les utilisateurs, récupérez la liste complète des utilisateurs et préparez votre environnement pour un traitement en masse. Cette étape vous aide à comprendre l'ampleur de l'opération.

$AllUsers = Get-MgUser -All -Property "UserPrincipalName,DisplayName,AccountEnabled"
$TotalUsers = $AllUsers.Count
Write-Host "Total users found: $TotalUsers" -ForegroundColor Cyan

Cette commande récupère tous les utilisateurs avec les propriétés essentielles. Le paramètre -All garantit que vous obtenez chaque utilisateur, pas seulement les 100 premiers (limite par défaut).

Filtrer uniquement les utilisateurs actifs :

$ActiveUsers = $AllUsers | Where-Object {$_.AccountEnabled -eq $true}
Write-Host "Active users: $($ActiveUsers.Count)" -ForegroundColor Green

Vérification : Affichez un échantillon d'utilisateurs pour révision :

$ActiveUsers | Select-Object UserPrincipalName, DisplayName | Select-Object -First 5

Étape critique : Créez une liste d'exclusion pour les comptes administratifs afin d'éviter de vous verrouiller hors du système. Ceci est essentiel pour maintenir l'accès pendant et après l'opération de changement de mot de passe.

# Définir les comptes administratifs à exclure
$AdminAccounts = @(
    "admin@yourdomain.com",
    "globaladmin@yourdomain.com",
    "serviceaccount@yourdomain.com"
)

# Filtrer les comptes administratifs
$UsersToUpdate = $ActiveUsers | Where-Object {
    $_.UserPrincipalName -notin $AdminAccounts
}

Write-Host "Utilisateurs à mettre à jour après exclusions : $($UsersToUpdate.Count)" -ForegroundColor Yellow
Write-Host "Comptes admin exclus : $($AdminAccounts.Count)" -ForegroundColor Red

Personnalisez le tableau $AdminAccounts avec les adresses email des comptes administratifs de votre organisation. Cela empêche de forcer accidentellement des changements de mot de passe sur des comptes de service critiques.

Vérification : Vérifiez la liste d'exclusion :

Write-Host "Comptes exclus :" -ForegroundColor Red
$AdminAccounts | ForEach-Object { Write-Host "  - $_" -ForegroundColor Red }

Exécutez maintenant l'opération de changement de mot de passe en masse avec une gestion complète des erreurs et un suivi des progrès. Ce script traite chaque utilisateur individuellement et fournit un retour d'information détaillé.

# Initialiser les compteurs
$SuccessCount = 0
$ErrorCount = 0
$ProcessedCount = 0
$TotalToProcess = $UsersToUpdate.Count

# Traiter chaque utilisateur avec gestion des erreurs
ForEach ($User in $UsersToUpdate) {
    try {
        Update-MgUser -UserId $User.UserPrincipalName -PasswordProfile @{
            ForceChangePasswordNextSignIn = $true
        }
        $SuccessCount++
        Write-Host "✓ Mis à jour avec succès : $($User.UserPrincipalName)" -ForegroundColor Green
    }
    catch {
        $ErrorCount++
        Write-Host "✗ Échec de la mise à jour $($User.UserPrincipalName) : $($_.Exception.Message)" -ForegroundColor Red
    }
    
    $ProcessedCount++
    $PercentComplete = [math]::Round(($ProcessedCount / $TotalToProcess) * 100, 2)
    Write-Progress -Activity "Forcing Password Changes" -Status "Processing $($User.UserPrincipalName)" -PercentComplete $PercentComplete
    
    # Ajouter un petit délai pour éviter le throttling
    Start-Sleep -Milliseconds 500
}

Write-Host "`nOpération terminée :" -ForegroundColor Cyan
Write-Host "  Succès : $SuccessCount" -ForegroundColor Green
Write-Host "  Erreurs : $ErrorCount" -ForegroundColor Red
Write-Host "  Total traité : $ProcessedCount" -ForegroundColor Cyan

Vérification : Vérifiez un échantillon aléatoire d'utilisateurs mis à jour :

$SampleUsers = $UsersToUpdate | Get-Random -Count 3
$SampleUsers | ForEach-Object {
    $User = Get-MgUser -UserId $_.UserPrincipalName -Property "UserPrincipalName,PasswordProfile"
    [PSCustomObject]@{
        UserPrincipalName = $User.UserPrincipalName
        MustChangePassword = $User.PasswordProfile.ForceChangePasswordNextSignIn
    }
}

Pour une sécurité renforcée, vous pouvez forcer les changements de mot de passe tout en attribuant simultanément des mots de passe temporaires. Cela garantit que les utilisateurs obtiennent de nouvelles informations d'identification immédiatement et doivent les changer lors de la prochaine connexion.

# Fonction pour générer des mots de passe temporaires sécurisés
function New-TempPassword {
    param([int]$Length = 12)
    $Characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*'
    $Password = -join ((1..$Length) | ForEach {$Characters[(Get-Random -Maximum $Characters.Length)]})
    return $Password
}

# Tableau pour stocker les résultats
$PasswordResults = @()

# Traiter les utilisateurs avec l'attribution de mot de passe temporaire
ForEach ($User in $UsersToUpdate) {
    try {
        $TempPassword = New-TempPassword
        Update-MgUser -UserId $User.UserPrincipalName -PasswordProfile @{
            Password = $TempPassword
            ForceChangePasswordNextSignIn = $true
        }
        
        $PasswordResults += [PSCustomObject]@{
            UserPrincipalName = $User.UserPrincipalName
            DisplayName = $User.DisplayName
            TempPassword = $TempPassword
            Status = "Success"
            Timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
        }
        
        Write-Host "✓ Mot de passe mis à jour pour : $($User.UserPrincipalName)" -ForegroundColor Green
    }
    catch {
        $PasswordResults += [PSCustomObject]@{
            UserPrincipalName = $User.UserPrincipalName
            DisplayName = $User.DisplayName
            TempPassword = "N/A"
            Status = "Failed: $($_.Exception.Message)"
            Timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
        }
        Write-Host "✗ Échec de la mise à jour du mot de passe pour $($User.UserPrincipalName)" -ForegroundColor Red
    }
    
    Start-Sleep -Milliseconds 500
}

Exporter les résultats en CSV :

$ExportPath = "C:\Temp\PasswordReset-$(Get-Date -Format 'yyyyMMdd-HHmmss').csv"
$PasswordResults | Export-Csv -Path $ExportPath -NoTypeInformation
Write-Host "Résultats exportés vers : $ExportPath" -ForegroundColor Cyan

Pour des changements de mot de passe ciblés, vous pouvez traiter des utilisateurs spécifiques à partir d'un fichier CSV. Cette approche est utile lorsque vous devez forcer des changements de mot de passe pour des départements, groupes ou incidents de sécurité spécifiques.

Tout d'abord, créez un fichier CSV avec la structure suivante :

UserPrincipalName,DisplayName,Department
user1@yourdomain.com,John Doe,IT
user2@yourdomain.com,Jane Smith,HR
user3@yourdomain.com,Bob Johnson,Finance

Enregistrez ceci sous le nom 'users.csv' dans le répertoire C:\Temp\. Ensuite, traitez les utilisateurs :

# Importer les utilisateurs depuis le CSV
$CSVPath = "C:\Temp\users.csv"
if (Test-Path $CSVPath) {
    $UsersFromCSV = Import-Csv $CSVPath
    Write-Host "Importé $($UsersFromCSV.Count) utilisateurs depuis le CSV" -ForegroundColor Cyan
    
    # Traiter chaque utilisateur depuis le CSV
    $CSVResults = @()
    $UsersFromCSV | ForEach-Object {
        try {
            Update-MgUser -UserId $_.UserPrincipalName -PasswordProfile @{
                ForceChangePasswordNextSignIn = $true
            }
            
            $CSVResults += [PSCustomObject]@{
                UserPrincipalName = $_.UserPrincipalName
                DisplayName = $_.DisplayName
                Department = $_.Department
                Status = "Succès"
                ProcessedTime = Get-Date
            }
            
            Write-Host "✓ Mis à jour : $($_.UserPrincipalName)" -ForegroundColor Green
        }
        catch {
            $CSVResults += [PSCustomObject]@{
                UserPrincipalName = $_.UserPrincipalName
                DisplayName = $_.DisplayName
                Department = $_.Department
                Status = "Échec : $($_.Exception.Message)"
                ProcessedTime = Get-Date
            }
            Write-Host "✗ Échec : $($_.UserPrincipalName)" -ForegroundColor Red
        }
        
        Start-Sleep -Milliseconds 300
    }
    
    # Afficher le résumé
    $SuccessfulCSV = ($CSVResults | Where-Object {$_.Status -eq "Succès"}).Count
    $FailedCSV = ($CSVResults | Where-Object {$_.Status -ne "Succès"}).Count
    
    Write-Host "`nRésumé du traitement CSV :" -ForegroundColor Cyan
    Write-Host "  Réussi : $SuccessfulCSV" -ForegroundColor Green
    Write-Host "  Échoué : $FailedCSV" -ForegroundColor Red
}
else {
    Write-Host "Fichier CSV non trouvé à $CSVPath" -ForegroundColor Red
}

Vérification : Exporter les résultats CSV pour la documentation :

$CSVResults | Export-Csv -Path "C:\Temp\CSV-PasswordReset-Results-$(Get-Date -Format 'yyyyMMdd-HHmmss').csv" -NoTypeInformation

Après avoir terminé les opérations de changement de mot de passe, vérifiez les résultats et générez des rapports complets à des fins de documentation et de conformité.

# Vérifier les exigences de changement de mot de passe pour tous les utilisateurs traités
$VerificationResults = @()

Write-Host "Vérification des exigences de changement de mot de passe..." -ForegroundColor Cyan

$UsersToUpdate | ForEach-Object {
    try {
        $UserDetails = Get-MgUser -UserId $_.UserPrincipalName -Property "UserPrincipalName,DisplayName,PasswordProfile,LastPasswordChangeDateTime"
        
        $VerificationResults += [PSCustomObject]@{
            UserPrincipalName = $UserDetails.UserPrincipalName
            DisplayName = $UserDetails.DisplayName
            MustChangePassword = $UserDetails.PasswordProfile.ForceChangePasswordNextSignIn
            LastPasswordChange = $UserDetails.LastPasswordChangeDateTime
            VerificationTime = Get-Date
            Status = if ($UserDetails.PasswordProfile.ForceChangePasswordNextSignIn) { "Verified" } else { "Not Set" }
        }
    }
    catch {
        $VerificationResults += [PSCustomObject]@{
            UserPrincipalName = $_.UserPrincipalName
            DisplayName = "Unknown"
            MustChangePassword = "Error"
            LastPasswordChange = "Unknown"
            VerificationTime = Get-Date
            Status = "Verification Failed: $($_.Exception.Message)"
        }
    }
}

# Générer des statistiques de synthèse
$TotalVerified = $VerificationResults.Count
$RequireChange = ($VerificationResults | Where-Object {$_.MustChangePassword -eq $true}).Count
$NotSet = ($VerificationResults | Where-Object {$_.MustChangePassword -eq $false}).Count
$Errors = ($VerificationResults | Where-Object {$_.Status -like "*Failed*"}).Count

Write-Host "`nRésumé de la vérification :" -ForegroundColor Cyan
Write-Host "  Nombre total d'utilisateurs vérifiés : $TotalVerified" -ForegroundColor White
Write-Host "  Nécessitent un changement de mot de passe : $RequireChange" -ForegroundColor Green
Write-Host "  Non défini : $NotSet" -ForegroundColor Yellow
Write-Host "  Erreurs de vérification : $Errors" -ForegroundColor Red

Générer un rapport complet :

# Exporter le rapport de vérification détaillé
$ReportPath = "C:\Temp\PasswordChange-VerificationReport-$(Get-Date -Format 'yyyyMMdd-HHmmss').csv"
$VerificationResults | Export-Csv -Path $ReportPath -NoTypeInformation

Write-Host "`nRapport détaillé exporté vers : $ReportPath" -ForegroundColor Cyan

# Afficher les utilisateurs qui ne nécessitent toujours pas de changement de mot de passe (problèmes potentiels)
$ProblematicUsers = $VerificationResults | Where-Object {$_.MustChangePassword -eq $false}
if ($ProblematicUsers.Count -gt 0) {
    Write-Host "`nUtilisateurs ne nécessitant pas de changement de mot de passe (révision nécessaire) :" -ForegroundColor Yellow
    $ProblematicUsers | Select-Object UserPrincipalName, Status | Format-Table -AutoSize
}

Commande de vérification finale :

# Vérification rapide d'un échantillon aléatoire
Get-MgUser -All -Property "UserPrincipalName,PasswordProfile" | 
Where-Object {$_.PasswordProfile.ForceChangePasswordNextSignIn -eq $true} | 
Select-Object UserPrincipalName, @{Name="RequiresPasswordChange";Expression={$_.PasswordProfile.ForceChangePasswordNextSignIn}} | 
Select-Object -First 10