Comment exporter les clés de récupération BitLocker depuis Active Directory en utilisant PowerShell

Tout d'abord, vous devez vous assurer que le module PowerShell ActiveDirectory est disponible sur votre système. Ce module fait partie des Outils d'administration de serveur distant (RSAT).

Sur Windows 10/11, installez les outils RSAT en utilisant cette commande :

Add-WindowsCapability -Online -Name Rsat.ActiveDirectory.DS-LDS.Tools~~~~0.0.1.0

Sur Windows Server, le module est généralement installé par défaut. Vérifiez que le module est disponible :

Get-Module -ListAvailable -Name ActiveDirectory

Importez le module et testez la connectivité du domaine :

Import-Module ActiveDirectory
Get-ADDomain

Vérification : La commande Get-ADDomain devrait retourner les informations de votre domaine sans erreurs. Si vous voyez des détails de domaine comme DNSRoot et DomainMode, vous êtes prêt à continuer.

Créez un script PowerShell complet qui recherchera dans Active Directory les informations de récupération BitLocker. Ouvrez votre éditeur de texte préféré et créez un nouveau fichier appelé Export-BitLockerKeys.ps1 :

param(
    [string]$SearchBase = "",
    [string]$OutputPath = "C:\temp\BitLockerKeys.csv"
)

function Export-BitLockerKeys {
    param([string]$SearchBase, [string]$OutputPath)

    try {
        Write-Host "Démarrage de l'exportation des clés de récupération BitLocker..." -ForegroundColor Green

        # Assurez-vous que le répertoire de sortie existe
        $outputDir = Split-Path $OutputPath -Parent
        if (!(Test-Path $outputDir)) {
            New-Item -ItemType Directory -Path $outputDir -Force
            Write-Host "Répertoire de sortie créé : $outputDir" -ForegroundColor Yellow
        }

        # Configurer les paramètres de recherche
        $searchParams = @{
            Filter = "*"
            Properties = @('Name', 'DistinguishedName', 'OperatingSystem', 'LastLogonDate')
        }
        if ($SearchBase) { 
            $searchParams.SearchBase = $SearchBase
            Write-Host "Recherche dans OU : $SearchBase" -ForegroundColor Yellow 
        }

        # Obtenir tous les objets ordinateur
        $computers = Get-ADComputer @searchParams
        Write-Host "Trouvé $($computers.Count) objets ordinateur" -ForegroundColor Yellow

        $results = @()
        $counter = 0
        
        foreach ($computer in $computers) {
            $counter++
            Write-Progress -Activity "Traitement des ordinateurs" -Status "Traitement $($computer.Name)" -PercentComplete (($counter / $computers.Count) * 100)
            
            # Rechercher des objets d'informations de récupération BitLocker
            $recoveryInfo = Get-ADObject -Filter "objectClass -eq 'msFVE-RecoveryInformation'" -SearchBase $computer.DistinguishedName -Properties *
            
            if ($recoveryInfo) {
                foreach ($recovery in $recoveryInfo) {
                    $results += [PSCustomObject]@{
                        ComputerName = $computer.Name
                        RecoveryPassword = $recovery.'msFVE-RecoveryPassword'
                        RecoveryID = $recovery.'msFVE-RecoveryGuid'
                        CreationTime = $recovery.whenCreated
                        DistinguishedName = $computer.DistinguishedName
                        OperatingSystem = $computer.OperatingSystem
                        VolumeGUID = $recovery.'msFVE-VolumeGuid'
                        LastLogon = $computer.LastLogonDate
                    }
                }
            }
        }

        Write-Progress -Activity "Traitement des ordinateurs" -Completed

        if ($results.Count -gt 0) {
            $results | Export-Csv -Path $OutputPath -NoTypeInformation -Encoding UTF8
            Write-Host "Exportation terminée ! $($results.Count) clés de récupération exportées vers $OutputPath" -ForegroundColor Green
            Write-Host "Taille du fichier : $([math]::Round((Get-Item $OutputPath).Length / 1KB, 2)) KB" -ForegroundColor Cyan
        } else {
            Write-Host "Aucune clé de récupération BitLocker trouvée dans Active Directory." -ForegroundColor Yellow
        }
    } catch {
        Write-Error "Erreur lors de l'exportation : $($_.Exception.Message)"
    }
}

# Exécuter la fonction
Export-BitLockerKeys -SearchBase $SearchBase -OutputPath $OutputPath

Enregistrez ce script à un emplacement tel que C:\Scripts\Export-BitLockerKeys.ps1.

Vérification : Vérifiez que le fichier a été enregistré correctement en exécutant Get-Content C:\Scripts\Export-BitLockerKeys.ps1 | Select-Object -First 5 pour voir les premières lignes.

Avant d'exécuter le script, vous devez vous assurer que PowerShell peut l'exécuter. Vérifiez votre politique d'exécution actuelle :

Get-ExecutionPolicy

Si elle renvoie Restricted, vous devrez la changer. Définissez la politique d'exécution pour autoriser les scripts locaux :

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Alternativement, pour une approche plus restrictive, vous pouvez contourner la politique pour cette exécution de script spécifique :

PowerShell.exe -ExecutionPolicy Bypass -File "C:\Scripts\Export-BitLockerKeys.ps1"

Vérification : Exécutez à nouveau Get-ExecutionPolicy pour confirmer le changement de politique, ou testez avec un script simple comme Write-Host "Test" enregistré en tant que fichier .ps1.

Exécutez le script pour exporter les clés BitLocker de tout le domaine. Accédez à votre répertoire de scripts et exécutez :

cd C:\Scripts
.\Export-BitLockerKeys.ps1 -OutputPath "C:\Reports\BitLockerKeys_$(Get-Date -Format 'yyyyMMdd_HHmmss').csv"

Cette commande va :

• Rechercher dans tout le domaine des objets ordinateurs
• Extraire les informations de récupération BitLocker pour chaque ordinateur
• Créer un fichier CSV horodaté dans le répertoire Reports

Surveillez la progression pendant que le script traite chaque ordinateur. Pour les grands domaines, cela peut prendre plusieurs minutes.

Vérification : Vérifiez que le fichier CSV a été créé et contient des données :

$csvFile = Get-ChildItem "C:\Reports\BitLockerKeys_*.csv" | Sort-Object LastWriteTime -Descending | Select-Object -First 1
Import-Csv $csvFile.FullName | Select-Object -First 5 | Format-Table

Vous devriez voir des colonnes pour ComputerName, RecoveryPassword, RecoveryID, CreationTime, et d'autres champs.

Pour une meilleure organisation et performance, vous pouvez cibler des UO spécifiques au lieu de tout le domaine. Tout d'abord, identifiez le nom distingué de votre UO cible :

Get-ADOrganizationalUnit -Filter "Name -like '*Workstations*'" | Select-Object Name, DistinguishedName

Exécutez le script en ciblant une UO spécifique :

.\Export-BitLockerKeys.ps1 -SearchBase "OU=Workstations,OU=Computers,DC=yourdomain,DC=com" -OutputPath "C:\Reports\BitLocker_Workstations.csv"

Vous pouvez également cibler plusieurs UO en exécutant le script plusieurs fois avec différents paramètres SearchBase :

# Exporter depuis l'UO Workstations
.\Export-BitLockerKeys.ps1 -SearchBase "OU=Workstations,DC=yourdomain,DC=com" -OutputPath "C:\Reports\BitLocker_Workstations.csv"

# Exporter depuis l'UO Laptops
.\Export-BitLockerKeys.ps1 -SearchBase "OU=Laptops,DC=yourdomain,DC=com" -OutputPath "C:\Reports\BitLocker_Laptops.csv"

Vérification : Comparez le nombre de résultats entre les exportations à l'échelle du domaine et spécifiques à une UO :

$workstationsCount = (Import-Csv "C:\Reports\BitLocker_Workstations.csv").Count
Write-Host "Workstations OU: $workstationsCount recovery keys found" -ForegroundColor Green

Une fois que vous avez votre exportation CSV, il est important d'analyser les données pour en vérifier l'exhaustivité et l'exactitude. Chargez le CSV et effectuez une analyse de base :

$bitlockerData = Import-Csv "C:\Reports\BitLockerKeys_20260316_143022.csv"

# Afficher les statistiques récapitulatives
Write-Host "Total des clés de récupération exportées : $($bitlockerData.Count)" -ForegroundColor Green
Write-Host "Ordinateurs uniques avec des clés : $($bitlockerData | Select-Object ComputerName -Unique | Measure-Object).Count" -ForegroundColor Cyan

# Afficher les ordinateurs avec plusieurs clés de récupération (plusieurs disques ou rotations de clés)
$multipleKeys = $bitlockerData | Group-Object ComputerName | Where-Object {$_.Count -gt 1}
if ($multipleKeys) {
    Write-Host "Ordinateurs avec plusieurs clés de récupération : $($multipleKeys.Count)" -ForegroundColor Yellow
    $multipleKeys | Select-Object Name, Count | Format-Table
}

# Vérifier les créations récentes de clés (30 derniers jours)
$recentKeys = $bitlockerData | Where-Object {[DateTime]$_.CreationTime -gt (Get-Date).AddDays(-30)}
Write-Host "Clés de récupération créées au cours des 30 derniers jours : $($recentKeys.Count)" -ForegroundColor Magenta

Valider le format du mot de passe de récupération (doit être de 48 chiffres en 8 groupes de 6) :

# Vérifier les mots de passe de récupération correctement formatés
$invalidPasswords = $bitlockerData | Where-Object {$_.RecoveryPassword -notmatch '^\d{6}-\d{6}-\d{6}-\d{6}-\d{6}-\d{6}-\d{6}-\d{6}$'}
if ($invalidPasswords) {
    Write-Warning "Trouvé $($invalidPasswords.Count) entrées avec un format de mot de passe de récupération invalide"
    $invalidPasswords | Select-Object ComputerName, RecoveryPassword | Format-Table
}

Vérification : Vérifiez quelques entrées en recherchant manuellement un ordinateur dans Active Directory Users and Computers et en comparant la clé de récupération.

Améliorez votre reporting BitLocker avec un filtrage et un formatage avancés. Créez un script de rapport complet :

# Génération avancée de rapport BitLocker
$bitlockerData = Import-Csv "C:\Reports\BitLockerKeys_20260316_143022.csv"

# Créer un rapport sommaire
$summaryReport = @{
    'Total des clés de récupération' = $bitlockerData.Count
    'Ordinateurs uniques' = ($bitlockerData | Select-Object ComputerName -Unique).Count
    'Systèmes Windows 11' = ($bitlockerData | Where-Object {$_.OperatingSystem -like "*Windows 11*"}).Count
    'Systèmes Windows 10' = ($bitlockerData | Where-Object {$_.OperatingSystem -like "*Windows 10*"}).Count
    'Clés créées cette année' = ($bitlockerData | Where-Object {[DateTime]$_.CreationTime -gt (Get-Date -Month 1 -Day 1)}).Count
}

# Afficher le sommaire
$summaryReport.GetEnumerator() | Sort-Object Name | Format-Table -AutoSize

# Trouver les ordinateurs sans connexions récentes (systèmes potentiellement inactifs)
$staleComputers = $bitlockerData | Where-Object {
    $_.LastLogon -and [DateTime]$_.LastLogon -lt (Get-Date).AddDays(-90)
} | Select-Object ComputerName, LastLogon, OperatingSystem | Sort-Object LastLogon

if ($staleComputers) {
    Write-Host "Ordinateurs avec des clés BitLocker mais sans connexion depuis 90+ jours : $($staleComputers.Count)" -ForegroundColor Yellow
    $staleComputers | Export-Csv "C:\Reports\BitLocker_StaleComputers.csv" -NoTypeInformation
}

# Créer des exports filtrés par OS
$windows11Keys = $bitlockerData | Where-Object {$_.OperatingSystem -like "*Windows 11*"}
$windows10Keys = $bitlockerData | Where-Object {$_.OperatingSystem -like "*Windows 10*"}

if ($windows11Keys) {
    $windows11Keys | Export-Csv "C:\Reports\BitLocker_Windows11.csv" -NoTypeInformation
    Write-Host "Systèmes Windows 11 exportés : $($windows11Keys.Count) clés" -ForegroundColor Green
}

if ($windows10Keys) {
    $windows10Keys | Export-Csv "C:\Reports\BitLocker_Windows10.csv" -NoTypeInformation
    Write-Host "Systèmes Windows 10 exportés : $($windows10Keys.Count) clés" -ForegroundColor Green
}

Vérification : Vérifiez que les fichiers CSV filtrés ont été créés et contiennent les données attendues :

Get-ChildItem "C:\Reports\BitLocker_*.csv" | Select-Object Name, Length, LastWriteTime | Format-Table

Configurez les exportations automatisées des clés BitLocker à l'aide du Planificateur de tâches Windows pour des rapports réguliers. Tout d'abord, créez un script wrapper qui inclut la journalisation :

# Enregistrez sous C:\Scripts\Scheduled-BitLockerExport.ps1
$logPath = "C:\Logs\BitLockerExport.log"
$reportPath = "C:\Reports\Scheduled"

# Assurez-vous que les répertoires existent
if (!(Test-Path "C:\Logs")) { New-Item -ItemType Directory -Path "C:\Logs" -Force }
if (!(Test-Path $reportPath)) { New-Item -ItemType Directory -Path $reportPath -Force }

# Commencez la journalisation
Start-Transcript -Path $logPath -Append

try {
    Write-Host "Démarrage de l'exportation programmée de BitLocker à $(Get-Date)" -ForegroundColor Green
    
    # Exécutez l'exportation
    $outputFile = "$reportPath\BitLocker_Weekly_$(Get-Date -Format 'yyyyMMdd').csv"
    & "C:\Scripts\Export-BitLockerKeys.ps1" -OutputPath $outputFile
    
    # Nettoyez les anciens rapports (conservez les 4 dernières semaines)
    Get-ChildItem $reportPath -Filter "BitLocker_Weekly_*.csv" | 
        Where-Object {$_.LastWriteTime -lt (Get-Date).AddDays(-28)} | 
        Remove-Item -Force
    
    Write-Host "Exportation programmée terminée avec succès" -ForegroundColor Green
} catch {
    Write-Error "Échec de l'exportation programmée : $($_.Exception.Message)"
} finally {
    Stop-Transcript
}

Créez la tâche planifiée à l'aide de PowerShell :

# Créez une tâche planifiée pour l'exportation hebdomadaire de BitLocker
$action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-ExecutionPolicy Bypass -File 'C:\Scripts\Scheduled-BitLockerExport.ps1'"
$trigger = New-ScheduledTaskTrigger -Weekly -DaysOfWeek Monday -At "02:00AM"
$principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -LogonType ServiceAccount -RunLevel Highest
$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable

Register-ScheduledTask -TaskName "BitLocker Recovery Key Export" -Action $action -Trigger $trigger -Principal $principal -Settings $settings -Description "Exportation hebdomadaire des clés de récupération BitLocker depuis Active Directory"

Vérification : Vérifiez que la tâche a été créée et testez-la manuellement :

Get-ScheduledTask -TaskName "BitLocker Recovery Key Export" | Format-List
Start-ScheduledTask -TaskName "BitLocker Recovery Key Export"

# Vérifiez le fichier journal après quelques minutes
Get-Content "C:\Logs\BitLockerExport.log" -Tail 10