La corbeille ne suffit pas. Vraiment.

Quand vous supprimez un fichier sous Windows — même en vidant la corbeille, même en faisant Suppr direct; les données ne disparaissent pas physiquement du disque. Presque tout le monde le sais, Windows se contente de marquer l’espace comme « disponible pour réutilisation ». Les octets sont toujours là, intacts, jusqu’à ce qu’un autre fichier les écrase par hasard.

Résultat : avec des logiciels gratuits comme Recuva, PhotoRec, ou même Autopsy (Utilisé par les enquêteurs), n’importe qui peut récupérer vos photos, vos mots de passe enregistrés, vos documents bancaires, vos emails; en quelques minutes, sur un PC que vous venez de « formater ».

Ce guide vous donne la procédure professionnelle, entièrement avec les outils déjà présents dans Windows, pour rendre vos données irrécupérables; même avec un matériel forensique.

Comment fonctionnent les données sur un disque

Sur un HDD (disque dur mécanique)

Un HDD stocke les données sous forme de zones magnétisées sur des plateaux qui tournent. Supprimer un fichier efface juste son « adresse » dans le catalogue du disque (la MFT), mais la zone magnétique reste telle quelle. Il faut physiquement réécrire dessus pour que la donnée soit détruite.

Sur un SSD / NVMe / clé USB

Les SSD stockent les données dans des cellules flash. La logique est différente : les SSD ont un contrôleur interne qui décide où écrire physiquement. On ne peut pas forcer l’écriture sur une cellule précise depuis Windows. C’est pour ça qu’on utilise une astuce bien plus efficace : chiffrer d’abord, puis effacer.

Mode Rapide ou Mode Complet ?

La procédure existe en deux variantes. Pour la grande majorité des usages (revente d’un PC, don d’une clé USB, recyclage d’un disque externe), le Mode Rapide est largement suffisant.

Les couches d’effacement expliquées

Chaque script applique plusieurs couches indépendantes. Si l’une échoue pour une raison quelconque (droits, système de fichiers inhabituel…), les autres prennent le relai. Voici ce que fait par exemple le Mode Rapide HDD :

Quel script pour quel support ?

Étape par étape — du début à la fin

$LETTRE = « D » # Remplacer D par votre lettre

Est-ce que ça abîme les disques ?

Non. Les scripts ont été conçus pour être efficaces et respectueux du matériel.

HDD

Un disque dur mécanique est conçu pour tourner en continu pendant des dizaines de milliers d’heures. Quelques heures d’écriture intensive représentent une fraction négligeable de sa durée de vie.

SSD

Les SSD ont une limite d’écriture mesurée en TBW (TeraBytes Written). Un SSD de 500 GB supporte typiquement 150 à 300 TB écrits. Le Mode Rapide SSD écrit environ 1 à 2 fois la taille du disque. Sur 500 GB : 1 GB écrit sur 150 000 GB supportés = 0,001 % d’usure. Imperceptible.

Clés USB / Cartes SD

Ces supports ont une endurance plus faible. C’est pour ça que le Mode Rapide USB ne fait qu’un seul remplissage aléatoire; choix intentionnel pour préserver le support tout en garantissant l’effacement.

Ce que tout le monde se demande

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
LES SCRIPTS — GUIDE COMPLET PAS À PAS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Vous avez compris comment ça fonctionne. Voici maintenant les scripts complets à utiliser, dans l’ordre exact. Pas besoin de rien télécharger ni installer — tout est déjà dans Windows. Il suffit de copier-coller dans PowerShell.

⚠️ RÈGLE D’OR : Dans chaque script, il y a une seule ligne à modifier avant de lancer :
$LETTRE = « D »
Remplacez le D par la lettre de votre disque (que vous aurez notée à l’étape 1). Ne touchez à rien d’autre.

⛔ NE JAMAIS utiliser ces scripts sur le lecteur C: — c’est le disque Windows. Pour effacer C:, voir la section dédiée en bas de page.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
AVANT DE COMMENCER — OUVRIR POWERSHELL EN ADMINISTRATEUR
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Tous les scripts doivent être lancés dans PowerShell avec les droits administrateur. Sans ça, rien ne fonctionnera.

Voici comment faire :
→ Appuyer sur la touche Windows du clavier
→ Taper : PowerShell
→ Faire un clic droit sur « Windows PowerShell »
→ Cliquer « Exécuter en tant qu’administrateur »
→ Cliquer « Oui » si Windows demande une confirmation

Une fenêtre bleue ou noire s’ouvre — vous êtes prêt.

ℹ️ Comment copier-coller un script dans PowerShell :
Sélectionner tout le script → Ctrl+C pour copier → cliquer dans la fenêtre PowerShell → clic droit pour coller → appuyer sur Entrée.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ÉTAPE 1 — DÉTECTER VOS DISQUES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Commencez TOUJOURS par cette étape. Ce script analyse tous vos disques et vous dit exactement quel script utiliser pour chacun, ainsi que sa lettre de lecteur.

Ce qu’il fait :
✔ Identifie chaque disque (HDD, SSD, USB, carte SD)
✔ Indique quelle méthode appliquer (02A, 02B ou 02C)
✔ Liste les lettres de lecteur (D:, E:, F:…)
✔ Vérifie que vous êtes bien en administrateur

┌─────────────────────────────────────────────────────┐
│ SCRIPT 01 — DÉTECTION DES DISQUES │
│ Copier-coller en entier dans PowerShell │
└─────────────────────────────────────────────────────┘

Set-ExecutionPolicy Bypass -Scope Process -Force

Write-Host «  »
Write-Host « ############################################## » -ForegroundColor Cyan
Write-Host « # DETECTION DES SUPPORTS DE STOCKAGE # » -ForegroundColor Cyan
Write-Host « ############################################## » -ForegroundColor Cyan
Write-Host «  »

$disques = Get-PhysicalDisk | Sort-Object DeviceId

foreach ($d in $disques) {
$sizeGB = [math]::Round($d.Size / 1GB, 1)
$busType = $d.BusType
$mediaType = $d.MediaType

if ($mediaType -eq "HDD") {
    $methode = "SCRIPT 02A - Effacement HDD"
    $couleur = "Magenta"
} elseif ($mediaType -eq "SSD") {
    $methode = "SCRIPT 02B - Effacement SSD/NVMe"
    $couleur = "Blue"
} elseif ($busType -eq "USB") {
    $methode = "SCRIPT 02C - Effacement USB/Externe"
    $couleur = "Green"
} elseif ($busType -eq "SD") {
    $methode = "SCRIPT 02C - Effacement carte SD"
    $couleur = "Green"
} else {
    $methode = "SCRIPT 02A - Methode HDD par securite"
    $couleur = "Red"
}

Write-Host ""
Write-Host "  Disque : $($d.FriendlyName)" -ForegroundColor $couleur
Write-Host "    Type    : $mediaType"
Write-Host "    Bus     : $busType"
Write-Host "    Taille  : $sizeGB GB"
Write-Host "    --> $methode" -ForegroundColor $couleur

}

Write-Host «  »
Write-Host « === LETTRES DE LECTEUR === » -ForegroundColor Yellow
Get-Volume | Where-Object { $_.DriveLetter } |
Select-Object DriveLetter, FileSystemLabel, FileSystem,
@{N= »TailleGB »;E={[math]::Round($_.Size/1GB,2)}} |
Format-Table -AutoSize

$estAdmin = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
Write-Host «  »
if ($estAdmin) {
Write-Host  » OK : PowerShell tourne en ADMINISTRATEUR » -ForegroundColor Green
} else {
Write-Host  » ERREUR : Relancer PowerShell en administrateur ! » -ForegroundColor Red
}
Write-Host «  »
Write-Host  » –> Notez la lettre du disque a effacer avant de continuer. » -ForegroundColor Yellow
Write-Host  » –> Ne jamais effacer le lecteur C: (disque Windows) » -ForegroundColor Red

┌─────────────────────────────────────────────────────┐
│ FIN DU SCRIPT 01 │
└─────────────────────────────────────────────────────┘

Résultat attendu : le script affiche chaque disque avec son type et le script à utiliser. Notez la lettre de lecteur du disque que vous voulez effacer.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ÉTAPE 2A — EFFACEMENT HDD (Disque dur mécanique)
Mode Rapide · 4 couches · Durée estimée : 2 à 4h pour 500 GB
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

À utiliser uniquement si le script 01 a identifié votre disque comme HDD.

Ce qu’il fait dans l’ordre :
Couche 1 → Chiffrement BitLocker AES-256 (chaque secteur devient du bruit inutilisable)
Couche 2 → Formatage complet NTFS (détruit la clé BitLocker = données inaccessibles à jamais)
Couche 3 → cipher /w (3 sous-passes sur l’espace libre : zéros, 0xFF, aléatoire)
Couche 4 → Formatage final propre (disque prêt à l’emploi)

⚠️ AVANT DE LANCER : remplacer le « D » dans $LETTRE = « D » par votre lettre de lecteur.

┌─────────────────────────────────────────────────────┐
│ SCRIPT 02A — EFFACEMENT HDD MODE RAPIDE │
│ Copier-coller en entier dans PowerShell │
└─────────────────────────────────────────────────────┘

Set-ExecutionPolicy Bypass -Scope Process -Force

>>> MODIFIER UNIQUEMENT CETTE LIGNE — mettre votre lettre de lecteur <<<

$LETTRE = « D »

function Titre($t) { Write-Host «  »; Write-Host « ———- $t ———- » -ForegroundColor Cyan }
function OK($t) { Write-Host  » [OK] $t » -ForegroundColor Green }
function INFO($t) { Write-Host  » [INFO] $t » -ForegroundColor Yellow }
function ERREUR($t){ Write-Host  » [ERREUR] $t » -ForegroundColor Red }

Titre « VERIFICATION INITIALE »

$estAdmin = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
if (-not $estAdmin) { ERREUR « Pas en administrateur. Relancer PowerShell en admin. »; exit 1 }

$chemin = « ${LETTRE}:\ »
if (-not (Test-Path $chemin)) { ERREUR « Lecteur $LETTRE introuvable. Verifier la lettre. »; exit 1 }
if ($LETTRE -eq « C ») { ERREUR « INTERDIT : Ne jamais effacer C: avec ce script. »; exit 1 }

$vol = Get-Volume -DriveLetter $LETTRE
$tailleGB = [math]::Round($vol.Size / 1GB, 2)
$label = if ($vol.FileSystemLabel) { $vol.FileSystemLabel } else { « (sans nom) » }

Write-Host «  »
Write-Host  » Disque cible : $chemin ($label) » -ForegroundColor White
Write-Host  » Taille : $tailleGB GB » -ForegroundColor White
Write-Host  » Mode : RAPIDE HDD – 4 couches » -ForegroundColor Yellow
Write-Host «  »
Write-Host  » !!! CETTE OPERATION EST DEFINITIVEMENT IRREVERSIBLE !!! » -ForegroundColor Red
Write-Host «  »

$rep = Read-Host  » Tapez OUI en majuscules pour confirmer »
if ($rep -ne « OUI ») { INFO « Operation annulee. »; exit 0 }

$debut = Get-Date

Titre « COUCHE 1/4 – Chiffrement BitLocker AES-256 »
Write-Host  » Chiffrement en cours – chaque secteur devient du bruit aleatoire… » -ForegroundColor Gray
Write-Host  » (Si BitLocker est indisponible, le script continue sans lui) » -ForegroundColor Gray

$bitlockerOk = $false
try {
$blVol = Get-BitLockerVolume -MountPoint $LETTRE -ErrorAction Stop
if ($blVol.ProtectionStatus -eq « On ») {
OK « BitLocker deja actif sur ce volume »
$bitlockerOk = $true
} else {
Enable-BitLocker -MountPoint $LETTRE -EncryptionMethod XtsAes256
-SkipHardwareTest -RecoveryPasswordProtector
-ErrorAction Stop | Out-Null

    $timeout = 0
    do {
        Start-Sleep -Seconds 20
        $timeout += 20
        $status = Get-BitLockerVolume -MountPoint $LETTRE
        Write-Host "    Chiffrement : $($status.EncryptionPercentage)%" -ForegroundColor Gray
        if ($timeout -gt 14400) { break }
    } while ($status.VolumeStatus -ne "FullyEncrypted")

    if ($status.VolumeStatus -eq "FullyEncrypted") {
        OK "Chiffrement AES-256 complet - donnees deja inutilisables"
        $bitlockerOk = $true
    }
}

} catch {
INFO « BitLocker non disponible sur ce systeme – les couches suivantes compensent »
}

Titre « COUCHE 2/4 – Formatage complet NTFS »
Write-Host  » Ecriture sur toute la surface physique + destruction de la cle BitLocker… » -ForegroundColor Gray
Format-Volume -DriveLetter $LETTRE -FileSystem NTFS -NewFileSystemLabel « EFFACE » -Full -Confirm:$false -Force | Out-Null
OK « Formatage complet termine – cle BitLocker detruite definitivement »

Titre « COUCHE 3/4 – cipher /w (ecrasement espace libre – 3 sous-passes) »
Write-Host  » Cette etape peut durer plusieurs heures – ne pas fermer la fenetre ! » -ForegroundColor Gray
Write-Host  » Passes : zeros / 0xFF / aleatoire sur chaque secteur libre… » -ForegroundColor Gray
cipher /w:$chemin
OK « cipher /w termine »

Titre « COUCHE 4/4 – Formatage final propre »
Write-Host  » Derniere passe – disque pret a l’emploi… » -ForegroundColor Gray
Format-Volume -DriveLetter $LETTRE -FileSystem NTFS -NewFileSystemLabel « Disque » -Confirm:$false -Force | Out-Null
OK « Formatage final termine »

$duree = (Get-Date) – $debut
Write-Host «  »
Write-Host « ############################################## » -ForegroundColor Green
Write-Host « # EFFACEMENT HDD TERMINE # » -ForegroundColor Green
Write-Host « ############################################## » -ForegroundColor Green
Write-Host  » Disque : $LETTRE: ($tailleGB GB) » -ForegroundColor White
Write-Host  » Duree : $([math]::Round($duree.TotalMinutes,1)) minutes » -ForegroundColor White
Write-Host  » BitLocker : $bitlockerOk » -ForegroundColor White
Write-Host «  »
Write-Host  » –> Lancer maintenant le SCRIPT 03 (verification) » -ForegroundColor Yellow

┌─────────────────────────────────────────────────────┐
│ FIN DU SCRIPT 02A │
└─────────────────────────────────────────────────────┘

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ÉTAPE 2B — EFFACEMENT SSD / NVMe / M.2
Mode Rapide · 3 couches · Durée estimée : 30 à 90 min pour 500 GB
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

À utiliser uniquement si le script 01 a identifié votre disque comme SSD ou NVMe.

Ce qu’il fait dans l’ordre :
Couche 1 → Chiffrement BitLocker AES-256 (sur SSD : très rapide, uniquement l’espace utilisé)
Couche 2 → Formatage complet NTFS (détruit la clé = données inaccessibles définitivement)
Couche 3 → Formatage final propre (pas de cipher /w sur SSD pour préserver sa durée de vie)

⚠️ AVANT DE LANCER : remplacer le « D » dans $LETTRE = « D » par votre lettre de lecteur.
⚠️ Pour le disque C: (Windows), ne pas utiliser ce script — voir section dédiée en bas de page.

┌─────────────────────────────────────────────────────┐
│ SCRIPT 02B — EFFACEMENT SSD / NVMe MODE RAPIDE │
│ Copier-coller en entier dans PowerShell │
└─────────────────────────────────────────────────────┘

Set-ExecutionPolicy Bypass -Scope Process -Force

>>> MODIFIER UNIQUEMENT CETTE LIGNE — mettre votre lettre de lecteur <<<

$LETTRE = « D »

function Titre($t) { Write-Host «  »; Write-Host « ———- $t ———- » -ForegroundColor Cyan }
function OK($t) { Write-Host  » [OK] $t » -ForegroundColor Green }
function INFO($t) { Write-Host  » [INFO] $t » -ForegroundColor Yellow }
function ERREUR($t){ Write-Host  » [ERREUR] $t » -ForegroundColor Red }

Titre « VERIFICATION INITIALE »

$estAdmin = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
if (-not $estAdmin) { ERREUR « Pas en administrateur. Relancer PowerShell en admin. »; exit 1 }

$chemin = « ${LETTRE}:\ »
if (-not (Test-Path $chemin)) { ERREUR « Lecteur $LETTRE introuvable. Verifier la lettre. »; exit 1 }
if ($LETTRE -eq « C ») {
ERREUR « DISQUE SYSTEME DETECTE – Ne pas utiliser ce script sur C: »
Write-Host «  »
Write-Host  » Pour effacer C:, utiliser : » -ForegroundColor Yellow
Write-Host  » Parametres > Systeme > Recuperation > Reinitialiser ce PC » -ForegroundColor White
Write-Host  » Choisir : Supprimer tout > Nettoyage complet du lecteur » -ForegroundColor White
exit 1
}

$vol = Get-Volume -DriveLetter $LETTRE
$tailleGB = [math]::Round($vol.Size / 1GB, 2)
$label = if ($vol.FileSystemLabel) { $vol.FileSystemLabel } else { « (sans nom) » }

Write-Host «  »
Write-Host  » Disque cible : $chemin ($label) » -ForegroundColor White
Write-Host  » Taille : $tailleGB GB » -ForegroundColor White
Write-Host  » Mode : RAPIDE SSD – 3 couches » -ForegroundColor Yellow
Write-Host «  »
Write-Host  » !!! CETTE OPERATION EST DEFINITIVEMENT IRREVERSIBLE !!! » -ForegroundColor Red
Write-Host «  »

$rep = Read-Host  » Tapez OUI en majuscules pour confirmer »
if ($rep -ne « OUI ») { INFO « Operation annulee. »; exit 0 }

$debut = Get-Date

Titre « COUCHE 1/3 – Chiffrement BitLocker AES-256 »
Write-Host  » Sur SSD : chiffrement rapide de l’espace utilise uniquement… » -ForegroundColor Gray

$bitlockerOk = $false
try {
$blVol = Get-BitLockerVolume -MountPoint $LETTRE -ErrorAction Stop
if ($blVol.ProtectionStatus -eq « On ») {
OK « BitLocker deja actif sur ce volume »
$bitlockerOk = $true
} else {
Enable-BitLocker -MountPoint $LETTRE -EncryptionMethod XtsAes256
-SkipHardwareTest -UsedSpaceOnly
-RecoveryPasswordProtector `
-ErrorAction Stop | Out-Null

    $timeout = 0
    do {
        Start-Sleep -Seconds 10
        $timeout += 10
        $status = Get-BitLockerVolume -MountPoint $LETTRE
        Write-Host "    Chiffrement : $($status.EncryptionPercentage)%" -ForegroundColor Gray
        if ($timeout -gt 7200) { break }
    } while ($status.VolumeStatus -ne "FullyEncrypted")

    if ($status.VolumeStatus -eq "FullyEncrypted") {
        OK "Chiffrement AES-256 complet"
        $bitlockerOk = $true
    }
}

} catch {
INFO « BitLocker non disponible – le formatage complet prend le relais »
}

Titre « COUCHE 2/3 – Formatage complet NTFS »
Write-Host  » Destruction de la cle de chiffrement = donnees inaccessibles definitivement… » -ForegroundColor Gray
Format-Volume -DriveLetter $LETTRE -FileSystem NTFS -NewFileSystemLabel « EFFACE » -Full -Confirm:$false -Force | Out-Null
OK « Formatage complet termine – cle BitLocker detruite »

Titre « COUCHE 3/3 – Formatage final propre »
Write-Host  » SSD pret a l’emploi… » -ForegroundColor Gray
Format-Volume -DriveLetter $LETTRE -FileSystem NTFS -NewFileSystemLabel « Disque » -Confirm:$false -Force | Out-Null
OK « Formatage final termine »

$duree = (Get-Date) – $debut
Write-Host «  »
Write-Host « ############################################## » -ForegroundColor Green
Write-Host « # EFFACEMENT SSD TERMINE # » -ForegroundColor Green
Write-Host « ############################################## » -ForegroundColor Green
Write-Host  » Disque : $LETTRE: ($tailleGB GB) » -ForegroundColor White
Write-Host  » Duree : $([math]::Round($duree.TotalMinutes,1)) minutes » -ForegroundColor White
Write-Host  » BitLocker : $bitlockerOk » -ForegroundColor White
Write-Host «  »
Write-Host  » –> Lancer maintenant le SCRIPT 03 (verification) » -ForegroundColor Yellow

┌─────────────────────────────────────────────────────┐
│ FIN DU SCRIPT 02B │
└─────────────────────────────────────────────────────┘

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ÉTAPE 2C — EFFACEMENT CLÉ USB / CARTE SD / DISQUE EXTERNE
Mode Rapide · 3 couches · Durée estimée : 10 à 30 min
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

À utiliser pour les clés USB, cartes SD, microSD et disques durs externes.

Ce qu’il fait dans l’ordre :
Couche 1 → Formatage complet (écrit sur toute la surface physique du support)
Couche 2 → Remplissage aléatoire cryptographique (RNG) sur tout l’espace libre
Couche 3 → Formatage final propre (support prêt à l’emploi)

Le format (FAT32 ou exFAT) est choisi automatiquement selon la taille du support.

⚠️ AVANT DE LANCER : remplacer le « E » dans $LETTRE = « E » par votre lettre de lecteur.

┌─────────────────────────────────────────────────────┐
│ SCRIPT 02C — EFFACEMENT USB / CARTE SD / EXTERNE │
│ Copier-coller en entier dans PowerShell │
└─────────────────────────────────────────────────────┘

Set-ExecutionPolicy Bypass -Scope Process -Force

>>> MODIFIER UNIQUEMENT CETTE LIGNE — mettre votre lettre de lecteur <<<

$LETTRE = « E »

function Titre($t) { Write-Host «  »; Write-Host « ———- $t ———- » -ForegroundColor Cyan }
function OK($t) { Write-Host  » [OK] $t » -ForegroundColor Green }
function INFO($t) { Write-Host  » [INFO] $t » -ForegroundColor Yellow }
function ERREUR($t){ Write-Host  » [ERREUR] $t » -ForegroundColor Red }

Titre « VERIFICATION INITIALE »

$estAdmin = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
if (-not $estAdmin) { ERREUR « Pas en administrateur. Relancer PowerShell en admin. »; exit 1 }

$chemin = « ${LETTRE}:\ »
if (-not (Test-Path $chemin)) { ERREUR « Lecteur $LETTRE introuvable. Verifier que le support est branche. »; exit 1 }
if ($LETTRE -eq « C ») { ERREUR « Ne jamais effacer C: avec ce script. »; exit 1 }

$vol = Get-Volume -DriveLetter $LETTRE
$tailleGB = [math]::Round($vol.Size / 1GB, 2)
$label = if ($vol.FileSystemLabel) { $vol.FileSystemLabel } else { « (sans nom) » }

if ($tailleGB -le 32) { $fsCible = « FAT32 » } else { $fsCible = « exFAT » }

Write-Host «  »
Write-Host  » Support cible : $chemin ($label) » -ForegroundColor White
Write-Host  » Taille : $tailleGB GB » -ForegroundColor White
Write-Host  » Format final : $fsCible (choisi automatiquement) » -ForegroundColor White
Write-Host  » Mode : RAPIDE USB – 3 couches » -ForegroundColor Yellow
Write-Host «  »
Write-Host  » !!! CETTE OPERATION EST DEFINITIVEMENT IRREVERSIBLE !!! » -ForegroundColor Red
Write-Host «  »

$rep = Read-Host  » Tapez OUI en majuscules pour confirmer »
if ($rep -ne « OUI ») { INFO « Operation annulee. »; exit 0 }

$debut = Get-Date

Titre « COUCHE 1/3 – Formatage complet ($fsCible) »
Write-Host  » Ecriture sur toute la surface physique du support… » -ForegroundColor Gray
try {
Format-Volume -DriveLetter $LETTRE -FileSystem $fsCible -NewFileSystemLabel « EFFACE » -Full -Confirm:$false -Force | Out-Null
OK « Formatage complet termine »
} catch {
INFO « Formatage complet echoue, tentative en mode rapide… »
Format-Volume -DriveLetter $LETTRE -FileSystem $fsCible -NewFileSystemLabel « EFFACE » -Confirm:$false -Force | Out-Null
OK « Formatage termine »
}

Titre « COUCHE 2/3 – Remplissage aleatoire cryptographique »
Write-Host  » Ecriture de donnees aleatoires sur tout l’espace libre… » -ForegroundColor Gray
try {
$rng = [System.Security.Cryptography.RNGCryptoServiceProvider]::new()
$tmpFile = « $chemin_wipe.dat »
$libre = (Get-Volume -DriveLetter $LETTRE).SizeRemaining – 1MB

if ($libre -gt 0) {
    $stream = [System.IO.File]::OpenWrite($tmpFile)
    $bloc   = New-Object byte[] 4MB
    $ecrit  = 0

    while ($ecrit -lt $libre) {
        $rng.GetBytes($bloc)
        $aEcrire = [Math]::Min($bloc.Length, $libre - $ecrit)
        $stream.Write($bloc, 0, $aEcrire)
        $ecrit += $aEcrire
        if ($ecrit % 50MB -lt 4MB) {
            $pct = [math]::Round($ecrit / $libre * 100)
            Write-Host "    Progression : $pct%" -ForegroundColor Gray
        }
    }
    $stream.Close()
    Remove-Item $tmpFile -Force -ErrorAction SilentlyContinue
    OK "Remplissage aleatoire termine ($([math]::Round($libre/1GB,2)) GB ecrits)"
}

} catch {
INFO « Remplissage partiel (non bloquant – le formatage complet a deja efface l’essentiel) »
}

Titre « COUCHE 3/3 – Formatage final propre »
Write-Host  » Support pret a l’emploi… » -ForegroundColor Gray
Format-Volume -DriveLetter $LETTRE -FileSystem $fsCible -NewFileSystemLabel « USB » -Confirm:$false -Force | Out-Null
OK « Formatage final termine »

$duree = (Get-Date) – $debut
Write-Host «  »
Write-Host « ############################################## » -ForegroundColor Green
Write-Host « # EFFACEMENT USB TERMINE # » -ForegroundColor Green
Write-Host « ############################################## » -ForegroundColor Green
Write-Host  » Support : $LETTRE: ($tailleGB GB) » -ForegroundColor White
Write-Host  » Duree : $([math]::Round($duree.TotalMinutes,1)) minutes » -ForegroundColor White
Write-Host «  »
Write-Host  » –> Lancer maintenant le SCRIPT 03 (verification) » -ForegroundColor Yellow

┌─────────────────────────────────────────────────────┐
│ FIN DU SCRIPT 02C │
└─────────────────────────────────────────────────────┘

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ÉTAPE 3 — VÉRIFICATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

À lancer OBLIGATOIREMENT après chaque effacement. Ce script fait 5 tests automatiques et vous donne un verdict clair : effacement valide ou à relancer.

Ce qu’il vérifie :
Test 1 → Volume accessible et monté
Test 2 → Aucun fichier résiduel
Test 3 → Espace libre supérieur à 90 %
Test 4 → Intégrité du système de fichiers
Test 5 → Absence de fichiers cachés suspects

⚠️ AVANT DE LANCER : remplacer le « D » dans $LETTRE = « D » par votre lettre de lecteur.

┌─────────────────────────────────────────────────────┐
│ SCRIPT 03 — VÉRIFICATION POST-EFFACEMENT │
│ Copier-coller en entier dans PowerShell │
└─────────────────────────────────────────────────────┘

Set-ExecutionPolicy Bypass -Scope Process -Force

>>> MODIFIER UNIQUEMENT CETTE LIGNE — mettre votre lettre de lecteur <<<

$LETTRE = « D »

function Titre($t) { Write-Host «  »; Write-Host « ———- $t ———- » -ForegroundColor Cyan }
function OK($t) { Write-Host  » [PASS] $t » -ForegroundColor Green }
function ECHEC($t) { Write-Host  » [FAIL] $t » -ForegroundColor Red }
function INFO($t) { Write-Host  » [INFO] $t » -ForegroundColor Yellow }

$chemin = « ${LETTRE}:\ »
$score = 0

Write-Host «  »
Write-Host « ############################################## » -ForegroundColor Cyan
Write-Host « # VERIFICATION POST-EFFACEMENT # » -ForegroundColor Cyan
Write-Host « ############################################## » -ForegroundColor Cyan

if (-not (Test-Path $chemin)) {
Write-Host  » ERREUR : Lecteur $LETTRE introuvable. » -ForegroundColor Red
exit 1
}

$vol = Get-Volume -DriveLetter $LETTRE

Titre « TEST 1/5 – Volume accessible »
if (Test-Path $chemin) { OK « Volume $LETTRE: accessible et monte »; $score++ }
else { ECHEC « Volume $LETTRE: non accessible » }

Titre « TEST 2/5 – Aucun fichier residuel »
$items = Get-ChildItem -Path $chemin -Recurse -Force -ErrorAction SilentlyContinue
$nb = ($items | Measure-Object).Count
if ($nb -eq 0) {
OK « Volume vide – aucun fichier residuel detecte »
$score++
} else {
ECHEC « $nb element(s) encore present(s) sur le disque »
$items | Select-Object FullName | Format-Table -AutoSize
if ($nb -le 5) { INFO « Moins de 5 elements – probablement des residus systeme normaux »; $score++ }
}

Titre « TEST 3/5 – Espace libre superieur a 90% »
$pctLibre = [math]::Round(($vol.SizeRemaining / $vol.Size) * 100, 1)
$libreGB = [math]::Round($vol.SizeRemaining / 1GB, 2)
$totalGB = [math]::Round($vol.Size / 1GB, 2)
INFO « Taille totale : $totalGB GB »
INFO « Espace libre : $libreGB GB ($pctLibre %) »
if ($pctLibre -ge 90) { OK « Espace libre suffisant ($pctLibre %) »; $score++ }
elseif ($pctLibre -ge 80){ INFO « Acceptable ($pctLibre %) – le systeme de fichiers occupe un peu d’espace »; $score++ }
else { ECHEC « Espace libre insuffisant ($pctLibre %) – relancer l’effacement » }

Titre « TEST 4/5 – Integrite du systeme de fichiers »
try {
$sante = Repair-Volume -DriveLetter $LETTRE -Scan -ErrorAction Stop
if ($sante -eq « NoProblemsFound » -or $null -eq $sante) { OK « Aucune erreur detectee »; $score++ }
else { INFO « Resultat scan : $sante (peut etre normal apres effacement) »; $score++ }
} catch { INFO « Scan non execute (non bloquant) »; $score++ }

Titre « TEST 5/5 – Absence de fichiers caches suspects »
$caches = Get-ChildItem -Path $chemin -Force -Hidden -Recurse -ErrorAction SilentlyContinue |
Where-Object { $_.Name -notmatch « ^`$RECYCLE » -and $_.Name -notmatch « ^System Volume » }
$nbCaches = ($caches | Measure-Object).Count
if ($nbCaches -eq 0) { OK « Aucun fichier cache suspect detecte »; $score++ }
elseif ($nbCaches -le 3) { INFO « $nbCaches fichier(s) cache(s) – normal apres formatage »; $score++ }
else { ECHEC « Trop de fichiers caches ($nbCaches) – relancer l’effacement » }

Write-Host «  »
Write-Host « ############################################## » -ForegroundColor Cyan
Write-Host « # BILAN FINAL # » -ForegroundColor Cyan
Write-Host « ############################################## » -ForegroundColor Cyan
Write-Host  » Disque : $LETTRE: ($totalGB GB) » -ForegroundColor White
Write-Host  » Tests reussis : $score / 5″ -ForegroundColor White
Write-Host «  »

if ($score -eq 5) {
Write-Host  » RESULTAT : EFFACEMENT VALIDE » -ForegroundColor Green
Write-Host  » Le support est pret pour la revente ou le don. » -ForegroundColor Green
} elseif ($score -ge 4) {
Write-Host  » RESULTAT : ACCEPTABLE – Verifier les points en FAIL ci-dessus. » -ForegroundColor Yellow
} else {
Write-Host  » RESULTAT : INSUFFISANT – Relancer le script d’effacement. » -ForegroundColor Red
}

┌─────────────────────────────────────────────────────┐
│ FIN DU SCRIPT 03 │
└─────────────────────────────────────────────────────┘

Résultat attendu : 5/5 tests avec [PASS] en vert. Si c’est le cas, votre support est propre et irrécupérable. Si un test échoue, relancez le script d’effacement correspondant.

CAS PARTICULIER — EFFACER LE DISQUE C: (WINDOWS)

Il est impossible d’effacer le disque sur lequel Windows tourne depuis Windows lui-même — c’est comme essayer de scier la branche sur laquelle on est assis. Les scripts ci-dessus refusent d’ailleurs de s’exécuter sur C: pour cette raison.

La solution : utiliser l’outil de réinitialisation intégré à Windows. Il fait exactement la même chose que le Mode Rapide SSD — il chiffre le disque et supprime la clé.

Voici comment faire :
→ Ouvrir les Paramètres (touche Windows + I)
→ Système → Récupération
→ Cliquer sur « Réinitialiser ce PC »
→ Choisir « Supprimer tout »
→ Choisir « Nettoyage complet du lecteur » (pas le nettoyage rapide !)
→ Cliquer « Réinitialiser »

Windows chiffre et efface complètement le disque avant de se réinstaller. Durée : 30 à 60 minutes. Résultat : identique au Mode Rapide SSD de ce guide.

RÉCAPITULATIF COMPLET

Étape 0 → Ouvrir PowerShell en Administrateur (clic droit → Exécuter en tant qu’administrateur)
Étape 1 → Script 01 → Détecter les disques et noter la lettre de lecteur
Étape 2A → Script 02A → HDD mécanique — 4 couches — 2 à 4h pour 500 GB
Étape 2B → Script 02B → SSD / NVMe / M.2 — 3 couches — 30 à 90 min pour 500 GB
Étape 2C → Script 02C → USB / carte SD / disque externe — 3 couches — 10 à 30 min
Étape 3 → Script 03 → Vérification (5 tests automatiques — tous doivent afficher PASS)
Disque C → Paramètres → Système → Récupération → Réinitialiser ce PC → Nettoyage complet

Rappel : dans chaque script, la seule ligne à modifier est $LETTRE = « D »
Remplacer D par votre lettre de lecteur. Ne toucher à rien d’autre.