VigiDoc un produit SSHack

Outil gratuit

Historique des clés USB sous Windows : un script PowerShell gratuit pour lister les clés branchées

Quelles clés USB ont été branchées sur ce poste, et quand ? Get-UsbHistory répond en une commande, sans rien installer ni rien modifier. Ce script gratuit est écrit par SSHack, cabinet de sécurité offensive et éditeur de VigiDoc, pour les administrateurs, RSSI et dirigeants de PME qui doivent répondre vite à cette question.

Par l'équipe SSHack · Publié le · Mis à jour le · environ 16 minutes de lecture (hors script)

En bref

Pour voir l'historique des clés USB d'un poste Windows, enregistrez le script gratuit Get-UsbHistory.ps1 et lancez powershell -ExecutionPolicy Bypass -File .\Get-UsbHistory.ps1 : il liste chaque clé, disque ou carte mémoire déjà branché, avec son modèle, son numéro de série, sa première installation, sa dernière arrivée et son dernier retrait. Le script est en lecture seule, ne demande ni installation ni module, et fonctionne sans droits administrateur (testé sur Windows 11). Il ne montre pas les fichiers copiés sur ces clés, car Windows ne les enregistre pas par défaut.

Ce que le script affiche

Windows garde une trace de chaque support de stockage USB qu'il a reconnu : une entrée créée à la première connexion, des dates tenues à jour à chaque branchement, la dernière lettre de lecteur attribuée, le nom du volume. Ces informations existent sur tous les postes, mais elles sont dispersées entre les propriétés des périphériques, plusieurs clés du registre et un journal d'événements. Get-UsbHistory les rassemble dans un seul tableau, du support le plus récemment branché au plus ancien.

Il couvre les clés USB, les disques durs et SSD externes (y compris ceux qui utilisent UASP, un protocole USB plus rapide qui les fait apparaître comme des disques SCSI), les lecteurs de cartes mémoire, les lecteurs CD/DVD USB et les téléphones vus en mode transfert de fichiers (MTP).

Il regroupe plusieurs vérifications décrites pas à pas dans notre guide Comment savoir si un salarié a copié des fichiers sur une clé USB : la liste du registre USBSTOR, les dates de branchement, l'événement 1006, les lettres de lecteur et les sessions. Il ne lit ni le fichier setupapi.dev.log, ni les raccourcis récents, ni le journal Sécurité : ces vérifications restent à faire à la main, en suivant le guide.

Ce que l'on obtient selon la méthode
MéthodeDroits administrateurDates de branchementLettre et nom du volumeFichiers copiés
Éditeur du registre, clé USBSTORNon pour la listeNon : la sous-clé qui contient les dates est réservée au compte SYSTEMÀ chercher à la main dans deux autres clésNon
Gestionnaire de périphériques, périphériques cachés affichésNonOui, un périphérique à la fois (onglet Détails)NonNon
Script Get-UsbHistoryNonOui, pour tous les supports d'un coup, avec l'historique du journal Partition/DiagnosticOui : dernière lettre et dernier nom connusNon
Audit des supports amovibles (événement 4663)Oui, pour lire le journal SécuritéNon : il trace les accès aux fichiersNonEn partie, et seulement si l'audit a été activé avant les faits

Le script prend trois engagements, que vous pouvez vérifier en le lisant :

Lancer le script en 4 étapes

Le site ne distribue pas de fichier .ps1 à télécharger : le code est affiché en entier, plus bas, pour que vous puissiez le lire avant de l'utiliser.

  1. Copiez le script. Dans la section Le script complet, sélectionnez tout le bloc de code et copiez-le (Ctrl+C).
  2. Enregistrez-le dans un fichier. Ouvrez Windows PowerShell (menu Démarrer, tapez « PowerShell »), sans droits administrateur. Les deux commandes ci-dessous se placent dans votre dossier personnel, puis écrivent le contenu du presse-papiers dans Get-UsbHistory.ps1, en UTF-8 avec BOM : c'est l'encodage qui préserve les accents dans Windows PowerShell 5.1.
    cd $env:USERPROFILE
    Get-Clipboard -Raw | Set-Content -Path .\Get-UsbHistory.ps1 -Encoding UTF8
    Vous préférez le Bloc-notes ? Collez le code, choisissez « Enregistrer sous », le type « Tous les fichiers », le nom Get-UsbHistory.ps1 et l'encodage « UTF-8 avec BOM ». Si le fichier est enregistré sans BOM, le script s'exécute quand même, mais il affiche un avertissement et les accents sortent déformés.
  3. Lancez-le. Dans la même fenêtre, tapez :
    powershell -ExecutionPolicy Bypass -File .\Get-UsbHistory.ps1
    Le relevé prend quelques secondes (moins de 6 secondes sur notre poste de test).
  4. Gardez une trace si besoin. Ajoutez -Csv suivi d'un chemin pour enregistrer toutes les colonnes dans un fichier qui s'ouvre dans Excel, par exemple -Csv .\usb.csv.

Ce que fait le paramètre -ExecutionPolicy Bypass

La stratégie d'exécution de PowerShell décide si un script peut se lancer. Sur un poste Windows où aucune stratégie n'est définie, c'est le mode Restricted qui s'applique : les commandes tapées une à une passent, les fichiers de script sont refusés. Le paramètre -ExecutionPolicy Bypass lève ce blocage pour la seule session PowerShell ouverte par la commande.

Selon la documentation de Microsoft, ce paramètre fixe la stratégie de la nouvelle session, la garde dans la variable d'environnement $Env:PSExecutionPolicyPreference de ce processus, et ne modifie pas la stratégie enregistrée dans le registre. Quand la fenêtre se ferme, il n'en reste rien : la configuration du poste n'a pas changé.

Deux précautions

Une stratégie imposée par GPO reste prioritaire : si votre organisation exige des scripts signés, la commande échouera et il faudra signer le script avec votre certificat interne. Surtout, Microsoft rappelle que la stratégie d'exécution n'est pas une barrière de sécurité. La seule vraie précaution, pour ce script comme pour tout autre, est de le lire avant de le lancer.

Les options

Paramètres de Get-UsbHistory.ps1
OptionEffet
-Csv <chemin>Enregistre toutes les colonnes dans un fichier CSV (séparateur point-virgule, UTF-8 avec BOM, lisible par Excel). C'est la seule écriture du script.
-ChronologieAjoute chaque arrivée et chaque retrait encore présents dans le journal Partition/Diagnostic, du plus ancien au plus récent. Avec -Csv, la chronologie part dans un second fichier.
-DetailAffiche toutes les colonnes, support par support, au lieu du tableau résumé.
-PassThruRenvoie aussi des objets PowerShell, pour trier ou filtrer les résultats dans une autre commande.
Get-Help .\Get-UsbHistory.ps1 -FullAffiche l'aide intégrée, en français, avec les exemples ; sous la stratégie Restricted, lancez d'abord powershell -ExecutionPolicy Bypass.

Pour lire aussi les sessions des autres utilisateurs connectés au poste, ouvrez Windows PowerShell avec « Exécuter en tant qu'administrateur ». Ce n'est pas nécessaire pour le reste du relevé.

Un exemple de résultat

Voici la sortie réelle du script, obtenue le 14 octobre 2026 sur notre poste de test (Windows 11 Pro, version 26H2), lancé sans élévation avec l'option -Chronologie. Le nom du poste et une partie des numéros de série sont masqués, et la chronologie, qui compte 55 lignes, est coupée.

PS> powershell -ExecutionPolicy Bypass -File .\Get-UsbHistory.ps1 -Chronologie

Supports USB vus par le poste POSTE-TEST (relevé du 14/10/2026 14:38)

Dernière arrivée 1re installation Dernier retrait  Présent Volume Modèle              N° de série
---------------- ---------------- ---------------  ------- ------ ------              -----------
24/09/2026 11:08 24/09/2026 10:58 24/09/2026 12:04 Non     E: SD  Generic- SD/MMC     A000001XXXXXA8D3
11/09/2026 22:22 06/08/2026 16:25 -                Non     USB    USB SanDisk 3.2Gen1 00002801XXXXXXXX0610

Toutes les colonnes : relancez avec -Detail ou exportez avec -Csv <chemin>.
Chronologie (journal Partition/Diagnostic, du plus ancien au plus récent)

Date                Événement Modèle              N° de série          Taille
----                --------- ------              -----------          ------
06/08/2026 16:25:28 Arrivée   USB SanDisk 3.2Gen1 00002801XXXXXXXX0610 123,0 Go
06/08/2026 16:26:06 Retrait   USB SanDisk 3.2Gen1 00002801XXXXXXXX0610
[... 39 lignes coupées ...]
11/09/2026 17:45:09 Arrivée   USB SanDisk 3.2Gen1 00002801XXXXXXXX0610 123,0 Go
11/09/2026 18:11:21 Retrait   USB SanDisk 3.2Gen1 00002801XXXXXXXX0610
11/09/2026 18:12:45 Arrivée   USB SanDisk 3.2Gen1 00002801XXXXXXXX0610 123,0 Go
11/09/2026 18:13:28 Retrait   USB SanDisk 3.2Gen1 00002801XXXXXXXX0610
11/09/2026 18:13:42 Arrivée   USB SanDisk 3.2Gen1 00002801XXXXXXXX0610 123,0 Go
11/09/2026 18:13:56 Retrait   USB SanDisk 3.2Gen1 00002801XXXXXXXX0610
11/09/2026 20:44:43 Arrivée   USB SanDisk 3.2Gen1 00002801XXXXXXXX0610 123,0 Go
11/09/2026 20:54:11 Retrait   USB SanDisk 3.2Gen1 00002801XXXXXXXX0610
11/09/2026 21:15:23 Arrivée   USB SanDisk 3.2Gen1 00002801XXXXXXXX0610 123,0 Go
11/09/2026 22:20:29 Arrivée   USB SanDisk 3.2Gen1 00002801XXXXXXXX0610 123,0 Go
11/09/2026 22:22:14 Arrivée   USB SanDisk 3.2Gen1 00002801XXXXXXXX0610 123,0 Go
24/09/2026 10:58:41 Arrivée   Generic- SD/MMC     A000001XXXXXA8D3     127,9 Go
24/09/2026 11:08:50 Arrivée   Generic- SD/MMC     A000001XXXXXA8D3     127,9 Go
24/09/2026 12:04:17 Retrait   Generic- SD/MMC     A000001XXXXXA8D3

Arrivée = support visible (taille connue) ; Retrait = support retiré ou lecteur vide.
Un même branchement peut produire plusieurs lignes : lisez-les comme des indices.
Sources lues

Source                                           Etat
------                                           ----
Périphériques Plug and Play (Get-PnpDevice)      lu : 98 périphérique(s) examiné(s)
Registre MountedDevices (lettres)                lu : 2 lettre(s) reliée(s) à un périphérique
Registre Windows Portable Devices (noms)         lu : 2 nom(s) de volume
Registre MountPoints2 (votre session)            lu : 5 volume(s)
Registre MountPoints2 (autres sessions ouvertes) non lu : droits administrateur requis
Journal Partition/Diagnostic (événement 1006)    lu : 55 événement(s) USB, journal conservé depuis le 11/07/2026
WMI Win32_DiskDrive (supports branchés)          lu : 1 disque(s) branché(s)

Lancé sans droits administrateur : seule la colonne MonteDansSessionDe se limite à votre propre session.
Si une source indique « accès refusé », relancez PowerShell en tant qu'administrateur.
Les dates sont à l'heure locale de ce poste. Windows ne garde que la dernière arrivée et le dernier retrait.

À retenir : ce script montre les supports USB branchés sur ce poste, PAS les fichiers copiés dessus.
Windows n'enregistre pas les copies de fichiers par défaut : sans audit activé avant les faits
(événement 4663) ou outil dédié, la liste des fichiers copiés n'existe pas sur le poste.
En savoir plus : https://vigidoc.me/guides/copie-fichiers-cle-usb/

Ce que l'on peut en tirer :

Ce que veut dire chaque colonne

Les sept premières lignes du tableau ci-dessous correspondent au tableau résumé ; les suivantes apparaissent avec -Detail et dans le fichier CSV.

Les colonnes, leur source dans Windows et leurs pièges
ColonneSource dans WindowsCe qu'elle indiqueÀ savoir
Dernière arrivéePropriété DEVPKEY_Device_LastArrivalDateLe dernier branchement du support sur ce posteRemplacée à chaque branchement : seule la dernière date est gardée
1re installationPropriété DEVPKEY_Device_FirstInstallDateLa première installation de ce support (ce numéro de série) sur ce posteElle ne change pas avec les mises à jour de pilote, mais repart de zéro si l'entrée du périphérique a été supprimée
Dernier retraitPropriété DEVPKEY_Device_LastRemovalDateLe dernier retrait du supportVide quand Windows n'a pas de date de retrait, comme pour la clé SanDisk de l'exemple
PrésentPropriété DEVPKEY_Device_IsPresent« Oui » si le support est branché au moment du relevéPour un support branché, la lettre et le nom affichés sont ceux du moment
VolumeWMI pour un support branché ; sinon registre MountedDevices et Windows Portable DevicesLa dernière lettre de lecteur et le dernier nom de volume connusUne lettre ne pointe que vers le dernier support qui l'a reçue. Pour un disque dur externe débranché, la lettre reste souvent inconnue
ModèleNom du périphérique (FriendlyName)Le fabricant et le modèle annoncés par le supportLes clés sans marque s'annoncent souvent « Generic Flash Disk » : fiez-vous alors au numéro de série
N° de sérieIdentifiant d'instance du périphériqueCe qui distingue deux clés du même modèleSi le deuxième caractère est « & », le numéro a été fabriqué par Windows et ne suit pas la clé d'un poste à l'autre. Pour un lecteur de cartes, c'est le numéro du lecteur, pas celui de la carte
SerieUniqueCalculée par le script« Oui » si le numéro de série vient du support lui-même, « Non (attribué par Windows) » sinonUn numéro attribué par Windows ne suit pas la clé d'un poste à l'autre
IdInstanceIdentifiant d'instance complet du périphériqueLe chemin Plug and Play du support, tel que Windows l'enregistreSert à retrouver l'entrée du support dans le registre et dans le Gestionnaire de périphériques
TypeClasse du périphériqueClé ou disque, disque UASP, lecteur de cartes, lecteur CD/DVD, téléphone MTPLe lecteur de cartes est reconnu à son nom : c'est une déduction
VidPidIdentifiant du périphérique USB parentLes codes fabricant et produit USB, par exemple 0781:55A3Utile pour rapprocher le même modèle d'un poste à l'autre
TailleJournal Partition/Diagnostic, sinon WMILa capacité en milliards d'octets, proche de celle de l'étiquetteL'Explorateur affiche moins (environ 114 Go pour 123 Go), car il compte en puissances de 2. Pour un lecteur de cartes, c'est la taille de la carte
ArriveesJournal, JournalPremier, JournalDernierJournal Microsoft-Windows-Partition/Diagnostic, événement 1006Le nombre d'arrivées encore inscrites dans le journal, la première et la dernièreUn même branchement peut produire plusieurs événements ; le journal est écrasé quand il est plein
MonteDansSessionDeRegistre MountPoints2 de chaque session ouverteLes comptes dont la session a vu le volumeSans droits administrateur, votre session seulement. Les comptes qui ne sont pas connectés au moment du relevé ne sont pas lus
SourceCalculée par le script« Windows (Plug and Play) », ou « Journal seulement » quand Windows a oublié le support mais que le journal le gardeCes supports sont marqués « [journal] » dans le tableau résumé

Microsoft documente la propriété DEVPKEY_Device_FirstInstallDate. Les deux autres propriétés de date sont définies dans le kit de développement Windows (fichier devpkey.h) sans page de documentation dédiée : sur notre poste de test, leurs valeurs correspondent à la seconde près aux événements du journal Partition/Diagnostic.

Avec ou sans droits administrateur

Le script n'a pas besoin d'être lancé en administrateur. Il passe par l'interface Plug and Play de Windows, qui fournit les dates des périphériques à un utilisateur standard, alors que la sous-clé du registre où elles sont rangées est réservée au compte SYSTEM. Quand une source lui est refusée, il l'indique dans le bloc « Sources lues » et continue avec les autres.

Ce que chaque source exige (relevé sur notre poste de test Windows 11)
SourceSans droits administrateurEn administrateur
Propriétés des périphériques (dates, présence)LisiblesLisibles
Registre MountedDevices et Windows Portable DevicesLisibles : le groupe Utilisateurs a le droit de lectureLisibles
Journal Partition/DiagnosticLisible depuis une session ouverte sur le poste, pas depuis une connexion réseauLisible
Registre MountPoints2Votre session seulementToutes les sessions ouvertes au moment du relevé
Sous-clé Properties du registre (dates brutes)RefuséeRefusée aussi (compte SYSTEM seulement) : le script n'en a pas besoin
Journal Sécurité (événements 4663 et 6416)RefuséLisible, mais le script ne le lit pas

Les limites à connaître

Ce relevé est un point de départ. Avant d'en tirer une conclusion, gardez en tête ce qu'il ne peut pas voir.

Et les fichiers copiés ?

C'est la question qui suit presque toujours : la clé a été branchée, mais qu'a-t-on copié dessus ? Sur un poste Windows réglé par défaut, cette liste n'existe pas. La documentation de Microsoft sur l'audit des supports amovibles le dit clairement : un événement est enregistré à chaque tentative de copie, de déplacement ou d'enregistrement vers un support amovible lorsque ce paramètre de stratégie est configuré. Il faut donc l'avoir activé avant les faits, et accepter le volume de journaux qu'il produit.

D'autres traces, comme les raccourcis récents ou les listes de raccourcis (Jump Lists) des applications, peuvent montrer qu'un fichier a été ouvert depuis la clé, pas qu'il y a été copié. Notre guide Comment savoir si un salarié a copié des fichiers sur une clé USB détaille ce que prouvent ces traces, et surtout ce qu'elles ne prouvent pas.

Si la question se pose à l'occasion d'un départ, lancez le script dès l'annonce, avant que le journal ne soit écrasé, exportez le résultat en CSV et rangez-le avec les autres éléments de la checklist sécurité des 30 derniers jours. Et si vous vous demandez s'il vaut mieux interdire les clés que les tracer, le guide Bloquer ou tracer les clés USB ? aide à trancher selon votre activité.

Le script complet

Version 1.0.0 du 14 octobre 2026, publiée par SSHack sous licence MIT (le texte de la licence figure en fin de script). Pour l'enregistrer et le lancer, suivez les étapes de la section Lancer le script en 4 étapes.

<#
.SYNOPSIS
    Liste les supports de stockage USB (clés, disques, cartes mémoire) déjà branchés sur ce poste Windows.

.DESCRIPTION
    Get-UsbHistory rassemble les traces que Windows conserve sur les supports USB branchés sur le poste :
    modèle, numéro de série, date de première installation, de dernière arrivée et de dernier retrait,
    présence actuelle, dernière lettre de lecteur et dernier nom de volume connus, taille, et arrivées
    encore visibles dans le journal Microsoft-Windows-Partition/Diagnostic.

    Le script est en LECTURE SEULE : il n'écrit rien dans le registre, ne modifie aucune stratégie
    d'audit, n'installe rien et n'ouvre aucune connexion réseau. La seule écriture possible est le
    fichier CSV, et seulement si vous utilisez le paramètre -Csv.

    Il fonctionne sans droits administrateur sur Windows 10 et 11 (testé sur Windows 11). Lancé en administrateur, il lit en
    plus les sessions ouvertes des autres utilisateurs (colonne MonteDansSessionDe).

    IMPORTANT : le script montre les supports branchés, pas les fichiers copiés dessus.
    Windows n'enregistre pas les copies de fichiers par défaut.

.PARAMETER Csv
    Chemin du fichier CSV à créer (séparateur point-virgule, UTF-8 avec BOM : s'ouvre dans Excel).
    Toutes les colonnes y figurent. Un fichier existant du même nom est remplacé.

.PARAMETER Chronologie
    Affiche aussi chaque arrivée et chaque retrait de support encore présents dans le journal
    Microsoft-Windows-Partition/Diagnostic (événement 1006), du plus ancien au plus récent.
    Un même branchement peut y laisser plusieurs lignes : ce sont des indices, pas un compteur exact.
    Avec -Csv, la chronologie est exportée dans un second fichier, suffixé « -chronologie ».

.PARAMETER Detail
    Affiche toutes les colonnes, support par support, au lieu du tableau résumé.

.PARAMETER PassThru
    Renvoie aussi les résultats sous forme d'objets PowerShell, pour les trier ou les filtrer.

.EXAMPLE
    powershell -ExecutionPolicy Bypass -File .\Get-UsbHistory.ps1

    Affiche le tableau des supports USB, du plus récemment branché au plus ancien.

.EXAMPLE
    powershell -ExecutionPolicy Bypass -File .\Get-UsbHistory.ps1 -Csv C:\Temp\usb.csv

    Affiche le tableau et enregistre toutes les colonnes dans C:\Temp\usb.csv.

.EXAMPLE
    powershell -ExecutionPolicy Bypass -File .\Get-UsbHistory.ps1 -Chronologie

    Ajoute la liste de toutes les arrivées et de tous les retraits encore présents dans le journal.

.NOTES
    Nom      : Get-UsbHistory.ps1
    Auteur   : SSHack (https://sshack.me), éditeur du logiciel VigiDoc
    Version  : 1.0.0
    Date     : 2026-10-14
    Licence  : MIT (texte complet en fin de fichier)
    Testé    : Windows 11 Pro 26H2, Windows PowerShell 5.1, sans élévation

    Sources lues (toutes en lecture) :
    - Get-PnpDevice et Get-PnpDeviceProperty : DEVPKEY_Device_FirstInstallDate,
      DEVPKEY_Device_LastArrivalDate, DEVPKEY_Device_LastRemovalDate, DEVPKEY_Device_IsPresent ;
    - registre HKLM\SYSTEM\MountedDevices : dernière lettre de lecteur connue ;
    - registre HKLM\SOFTWARE\Microsoft\Windows Portable Devices\Devices : dernier nom de volume connu ;
    - registre ...\Explorer\MountPoints2 des sessions ouvertes : comptes dont la session a vu le volume ;
    - journal Microsoft-Windows-Partition/Diagnostic, événement 1006 : arrivées, retraits, taille ;
    - WMI Win32_DiskDrive : lettre, nom et taille des supports branchés en ce moment.

.LINK
    https://vigidoc.me/guides/historique-cle-usb-powershell/
#>

#Requires -Version 5.1

[CmdletBinding()]
param(
    [string]$Csv,
    [switch]$Chronologie,
    [switch]$Detail,
    [switch]$PassThru
)

# ---------------------------------------------------------------------------------------------
# 0. Vérifications préalables
# ---------------------------------------------------------------------------------------------

# Enregistré sans BOM, ce fichier est lu en ANSI par Windows PowerShell 5.1 et les accents
# s'affichent mal. Le test ci-dessous le détecte (message volontairement écrit sans accent).
if ('é'.Length -ne 1) {
    Write-Warning "Fichier enregistre sans BOM UTF-8 : les accents s'afficheront mal. Reenregistrez-le en 'UTF-8 avec BOM'."
}

$Invariant = [Globalization.CultureInfo]::InvariantCulture
$Identite  = [Security.Principal.WindowsIdentity]::GetCurrent()
$EstAdmin  = (New-Object Security.Principal.WindowsPrincipal($Identite)).IsInRole(
                 [Security.Principal.WindowsBuiltInRole]::Administrator)

# Bilan des sources lues, affiché à la fin
$Bilan = New-Object System.Collections.Generic.List[object]

# ---------------------------------------------------------------------------------------------
# 1. Fonctions utilitaires (aucune n'écrit quoi que ce soit)
# ---------------------------------------------------------------------------------------------

function Add-Bilan {
    param([string]$Source, [string]$Etat)
    $Bilan.Add([pscustomobject]@{ Source = $Source; Etat = $Etat })
}

# Traduit une erreur en motif lisible, en repérant les refus d'accès
function Get-MotifErreur {
    param($Erreur)
    $e = $Erreur.Exception
    while ($null -ne $e) {
        if ($e -is [System.Security.SecurityException] -or $e -is [System.UnauthorizedAccessException]) {
            return 'accès refusé : relancez PowerShell en tant qu''administrateur'
        }
        $e = $e.InnerException
    }
    return ('illisible : ' + $Erreur.Exception.Message)
}

# Ramène un identifiant de périphérique à une forme comparable d'une source à l'autre :
# « USBSTOR\DISK&VEN_X&PROD_Y\123&0 » (Plug and Play), « _??_USBSTOR#Disk&Ven_X&Prod_Y#123&0#{...} »
# (MountedDevices) et « SWD#WPDBUSENUM#_??_USBSTOR#... » (Windows Portable Devices) donnent la même clé.
function ConvertTo-Cle {
    param([string]$Texte)
    if ([string]::IsNullOrWhiteSpace($Texte)) { return '' }
    $t = $Texte.Trim([char]0).Trim().ToUpperInvariant()
    $t = $t -replace '^SWD[\\#]WPDBUSENUM[\\#]', ''
    $t = $t -replace '^(_\?\?_|\\\?\?\\|\\\\\?\\)', ''
    $t = $t -replace '#\{[0-9A-F-]{36}\}$', ''
    return ($t -replace '[\\/#]', '#')
}

# Numéro de série tiré de l'identifiant d'instance. Un « & » en deuxième position signale un
# identifiant fabriqué par Windows : le support n'a pas de numéro de série unique.
function Get-InfosSerie {
    param([string]$IdInstance)
    $dernier = ($IdInstance -split '\\')[-1]
    $serie   = $dernier -replace '&\d+$', ''      # USBSTOR ajoute « &0 » (numéro d'unité logique)
    $unique  = -not ($dernier.Length -gt 1 -and $dernier[1] -eq '&')
    return [pscustomobject]@{ Serie = $serie; Unique = $unique }
}

function Get-VidPid {
    param([string]$Id)
    if ($Id -match 'VID_([0-9A-F]{4})&PID_([0-9A-F]{4})') { return ('{0}:{1}' -f $Matches[1], $Matches[2]).ToUpperInvariant() }
    return ''
}

# « Kingston DataTraveler 3.0 USB Device » devient « Kingston DataTraveler 3.0 »
function Get-ModeleLisible {
    param([string]$Nom)
    if ([string]::IsNullOrWhiteSpace($Nom)) { return '' }
    $n = ($Nom -replace '\s+', ' ').Trim()
    return ($n -replace ' (USB|SCSI) (Disk )?Device$', '')
}

function Get-TypeSupport {
    param([string]$Id, [string]$Classe, [string]$Modele)
    if ($Classe -eq 'WPD')   { return 'Téléphone ou appareil MTP' }
    if ($Classe -eq 'CDROM') { return 'Lecteur CD/DVD USB' }
    if ($Modele -match 'SD/MMC|Card.?Reader|Multi.?Card|SDXC|micro ?SD|CF.?Card|xD-Picture') { return 'Lecteur de cartes' }
    if ($Id -like 'SCSI\*')  { return 'Disque USB (UASP)' }
    return 'Clé ou disque USB'
}

function Format-Date {
    param($Date, [string]$Modele = 'dd/MM/yyyy HH:mm')
    if ($Date -is [datetime] -and $Date.Year -gt 1601) { return $Date.ToString($Modele, $Invariant) }
    return ''
}

function Limit-Texte {
    param([string]$Texte, [int]$Max)
    if ([string]::IsNullOrEmpty($Texte)) { return '-' }
    if ($Texte.Length -le $Max) { return $Texte }
    return $Texte.Substring(0, $Max - 3) + '...'
}

function Format-Taille {
    param([UInt64]$Octets)
    if ($Octets -eq 0) { return '' }
    return ('{0:N1} Go' -f ($Octets / 1e9))
}

# Lit une sous-clé de HKLM ou HKU avec .NET (et non le lecteur HKLM:, qui prendrait le « / » de
# « SD/MMC » pour un séparateur). Ouverture en lecture seule.
function Open-CleRegistre {
    param([Microsoft.Win32.RegistryKey]$Racine, [string]$Chemin)
    return $Racine.OpenSubKey($Chemin, $false)
}

# ---------------------------------------------------------------------------------------------
# 2. Inventaire des périphériques connus de Windows
# ---------------------------------------------------------------------------------------------

$ClesPnp = @(
    'DEVPKEY_Device_FriendlyName',
    'DEVPKEY_Device_FirstInstallDate',
    'DEVPKEY_Device_LastArrivalDate',
    'DEVPKEY_Device_LastRemovalDate',
    'DEVPKEY_Device_Parent',
    'DEVPKEY_Device_IsPresent'
)

$Candidats = New-Object System.Collections.Generic.List[object]
$ModePnp = $true
try {
    $tous = @(Get-PnpDevice -ErrorAction Stop)
    foreach ($d in $tous) {
        $id = [string]$d.InstanceId
        if ($id -like 'USBSTOR\*' -or
            ($d.Class -eq 'DiskDrive' -and $id -like 'SCSI\*') -or
            ($d.Class -eq 'WPD' -and $id -like 'USB\*')) {
            $Candidats.Add([pscustomobject]@{ Id = $id; Classe = [string]$d.Class; Nom = [string]$d.FriendlyName })
        }
    }
    Add-Bilan 'Périphériques Plug and Play (Get-PnpDevice)' ('lu : {0} périphérique(s) examiné(s)' -f $tous.Count)
} catch {
    # Voie de secours : lecture directe de la clé USBSTOR (sans les dates, réservées au compte SYSTEM)
    $ModePnp = $false
    Add-Bilan 'Périphériques Plug and Play (Get-PnpDevice)' ((Get-MotifErreur $_) + ' ; lecture directe du registre USBSTOR')
    try {
        $usbstor = Open-CleRegistre ([Microsoft.Win32.Registry]::LocalMachine) 'SYSTEM\CurrentControlSet\Enum\USBSTOR'
        if ($null -ne $usbstor) {
            foreach ($famille in $usbstor.GetSubKeyNames()) {
                $kf = $usbstor.OpenSubKey($famille, $false)
                foreach ($inst in $kf.GetSubKeyNames()) {
                    $ki = $kf.OpenSubKey($inst, $false)
                    $classe = 'DiskDrive'
                    if ($famille -like 'CdRom*') { $classe = 'CDROM' }
                    $Candidats.Add([pscustomobject]@{ Id = ('USBSTOR\{0}\{1}' -f $famille, $inst).ToUpperInvariant(); Classe = $classe; Nom = [string]$ki.GetValue('FriendlyName') })
                    $ki.Close()
                }
                $kf.Close()
            }
            $usbstor.Close()
        }
        Add-Bilan 'Registre Enum\USBSTOR (secours)' ('lu : {0} support(s)' -f $Candidats.Count)
    } catch {
        Add-Bilan 'Registre Enum\USBSTOR (secours)' (Get-MotifErreur $_)
    }
}

# ---------------------------------------------------------------------------------------------
# 3. Dernière lettre connue (MountedDevices) : une lettre ne pointe que vers un seul support,
#    celui qui l'a reçue en dernier. Les disques USB « fixes » y sont décrits par une signature
#    binaire, non reliée ici à leur numéro de série : leur lettre reste alors inconnue.
# ---------------------------------------------------------------------------------------------

$LettreParCle  = @{}
$VolumesParCle = @{}
try {
    $md = Open-CleRegistre ([Microsoft.Win32.Registry]::LocalMachine) 'SYSTEM\MountedDevices'
    if ($null -eq $md) { throw 'clé absente' }
    foreach ($nom in $md.GetValueNames()) {
        $octets = $md.GetValue($nom)
        if (-not ($octets -is [byte[]]) -or $octets.Length -le 24) { continue }
        $texte = [Text.Encoding]::Unicode.GetString($octets).Trim([char]0)
        if ($texte -notmatch '^(_\?\?_|\\\?\?\\)') { continue }
        $cle = ConvertTo-Cle $texte
        if ($nom -match '^\\DosDevices\\([A-Za-z]:)$') {
            $LettreParCle[$cle] = $Matches[1].ToUpperInvariant()
        } elseif ($nom -match '^\\\?\?\\Volume(\{[0-9A-Fa-f-]{36}\})$') {
            if (-not $VolumesParCle.ContainsKey($cle)) { $VolumesParCle[$cle] = New-Object System.Collections.Generic.List[string] }
            $VolumesParCle[$cle].Add($Matches[1].ToLowerInvariant())
        }
    }
    $md.Close()
    Add-Bilan 'Registre MountedDevices (lettres)' ('lu : {0} lettre(s) reliée(s) à un périphérique' -f $LettreParCle.Count)
} catch {
    Add-Bilan 'Registre MountedDevices (lettres)' (Get-MotifErreur $_)
}

# ---------------------------------------------------------------------------------------------
# 4. Dernier nom de volume connu (Windows Portable Devices)
# ---------------------------------------------------------------------------------------------

$NomParCle = @{}
try {
    $wpd = Open-CleRegistre ([Microsoft.Win32.Registry]::LocalMachine) 'SOFTWARE\Microsoft\Windows Portable Devices\Devices'
    if ($null -ne $wpd) {
        foreach ($n in $wpd.GetSubKeyNames()) {
            $k = $wpd.OpenSubKey($n, $false)
            if ($null -eq $k) { continue }
            $fn = [string]$k.GetValue('FriendlyName')
            if ($fn) { $NomParCle[(ConvertTo-Cle $n)] = $fn }
            $k.Close()
        }
        $wpd.Close()
        Add-Bilan 'Registre Windows Portable Devices (noms)' ('lu : {0} nom(s) de volume' -f $NomParCle.Count)
    } else {
        Add-Bilan 'Registre Windows Portable Devices (noms)' 'clé absente'
    }
} catch {
    Add-Bilan 'Registre Windows Portable Devices (noms)' (Get-MotifErreur $_)
}

# ---------------------------------------------------------------------------------------------
# 5. Sessions qui ont vu le volume (MountPoints2). Sans droits administrateur : votre session
#    seulement. En administrateur : toutes les sessions ouvertes en ce moment. Les comptes
#    déconnectés ne sont pas lus (il faudrait charger leur ruche, donc écrire dans le registre).
# ---------------------------------------------------------------------------------------------

$SessionsParVolume = @{}
function Read-MountPoints2 {
    param([Microsoft.Win32.RegistryKey]$Ruche, [string]$Compte)
    $mp = Open-CleRegistre $Ruche 'Software\Microsoft\Windows\CurrentVersion\Explorer\MountPoints2'
    if ($null -eq $mp) { return 0 }
    $n = 0
    foreach ($g in $mp.GetSubKeyNames()) {
        if ($g -match '^\{[0-9A-Fa-f-]{36}\}$') {
            $g = $g.ToLowerInvariant()
            if (-not $SessionsParVolume.ContainsKey($g)) { $SessionsParVolume[$g] = New-Object System.Collections.Generic.List[string] }
            if (-not $SessionsParVolume[$g].Contains($Compte)) { $SessionsParVolume[$g].Add($Compte) }
            $n++
        }
    }
    $mp.Close()
    return $n
}

$CompteCourant = '{0}\{1}' -f $env:USERDOMAIN, $env:USERNAME
try {
    $n = Read-MountPoints2 ([Microsoft.Win32.Registry]::CurrentUser) $CompteCourant
    Add-Bilan 'Registre MountPoints2 (votre session)' ('lu : {0} volume(s)' -f $n)
} catch {
    Add-Bilan 'Registre MountPoints2 (votre session)' (Get-MotifErreur $_)
}
if ($EstAdmin) {
    $autres = 0
    $refus  = 0
    foreach ($sid in [Microsoft.Win32.Registry]::Users.GetSubKeyNames()) {
        if ($sid -notmatch '^S-1-5-21-[\d-]+$' -or $sid -eq $Identite.User.Value) { continue }
        try {
            # Nom du compte lu dans la ruche elle-même : aucune requête vers un contrôleur de domaine
            $compte = $sid
            $ve = Open-CleRegistre ([Microsoft.Win32.Registry]::Users) "$sid\Volatile Environment"
            if ($null -ne $ve) {
                $u = [string]$ve.GetValue('USERNAME')
                if ($u) { $compte = '{0}\{1}' -f $ve.GetValue('USERDOMAIN'), $u }
                $ve.Close()
            }
            $ruche = Open-CleRegistre ([Microsoft.Win32.Registry]::Users) $sid
            [void](Read-MountPoints2 $ruche $compte)
            $ruche.Close()
            $autres++
        } catch {
            $refus++
        }
    }
    Add-Bilan 'Registre MountPoints2 (autres sessions ouvertes)' ('lu : {0} session(s), {1} refus' -f $autres, $refus)
} else {
    Add-Bilan 'Registre MountPoints2 (autres sessions ouvertes)' 'non lu : droits administrateur requis'
}

# ---------------------------------------------------------------------------------------------
# 6. Journal Microsoft-Windows-Partition/Diagnostic, événement 1006 (Windows 10 et 11).
#    Chaque événement décrit l'état du disque à un instant : taille > 0 quand le support devient
#    visible (arrivée), taille = 0 au retrait ou quand un lecteur de cartes est vide. Un même
#    branchement peut produire plusieurs événements : ce sont des indices, pas un compteur exact.
#    Le journal a une taille limitée : les événements les plus anciens sont écrasés.
# ---------------------------------------------------------------------------------------------

$Journal = New-Object System.Collections.Generic.List[object]
$JournalLisible = $false
$NomJournal = 'Microsoft-Windows-Partition/Diagnostic'
try {
    $evts = @(Get-WinEvent -LogName $NomJournal -FilterXPath '*[System[EventID=1006]]' -ErrorAction Stop)
    $JournalLisible = $true
    foreach ($ev in $evts) {
        # Tri rapide : on ne décode que les événements dont le parent est un périphérique USB
        $estUsb = $false
        foreach ($p in $ev.Properties) {
            if ($p.Value -is [string] -and $p.Value -like 'USB\VID_*') { $estUsb = $true; break }
        }
        if (-not $estUsb) { continue }
        $champs = @{}
        foreach ($donnee in ([xml]$ev.ToXml()).Event.EventData.Data) { $champs[[string]$donnee.Name] = [string]$donnee.InnerText }
        $capacite = [UInt64]0
        [void][UInt64]::TryParse($champs['Capacity'], [ref]$capacite)
        $evenement = 'Retrait'
        if ($capacite -gt 0) { $evenement = 'Arrivée' }
        $modele = (('{0} {1}' -f $champs['Manufacturer'], $champs['Model']) -replace '\bNULL\b', '' -replace '\s+', ' ').Trim()
        $Journal.Add([pscustomobject]@{
            Date       = $ev.TimeCreated
            Evenement  = $evenement
            Modele     = $modele
            Serie      = ([string]$champs['SerialNumber']).Trim()
            Parent     = [string]$champs['ParentId']
            CleParent  = ConvertTo-Cle $champs['ParentId']
            Capacite   = $capacite
        })
    }
    $plusAncien = $null
    try { $plusAncien = (Get-WinEvent -LogName $NomJournal -Oldest -MaxEvents 1 -ErrorAction Stop).TimeCreated } catch { }
    $depuis = ''
    if ($plusAncien) { $depuis = ', journal conservé depuis le ' + (Format-Date $plusAncien 'dd/MM/yyyy') }
    Add-Bilan 'Journal Partition/Diagnostic (événement 1006)' ('lu : {0} événement(s) USB{1}' -f $Journal.Count, $depuis)
} catch {
    if ($_.FullyQualifiedErrorId -like 'NoMatchingEventsFound*') {
        $JournalLisible = $true
        Add-Bilan 'Journal Partition/Diagnostic (événement 1006)' 'lu : aucun événement'
    } elseif ($_.FullyQualifiedErrorId -like 'NoMatchingLogsFound*') {
        Add-Bilan 'Journal Partition/Diagnostic (événement 1006)' 'absent (Windows 10 ou 11 requis)'
    } else {
        Add-Bilan 'Journal Partition/Diagnostic (événement 1006)' (Get-MotifErreur $_)
    }
}

# ---------------------------------------------------------------------------------------------
# 7. Supports branchés en ce moment : lettre, nom et taille réels (WMI, lecture seule)
# ---------------------------------------------------------------------------------------------

$PresentParCle = @{}
try {
    foreach ($disque in @(Get-CimInstance -ClassName Win32_DiskDrive -ErrorAction Stop)) {
        $lettres = New-Object System.Collections.Generic.List[string]
        $noms    = New-Object System.Collections.Generic.List[string]
        foreach ($part in @(Get-CimAssociatedInstance -InputObject $disque -ResultClassName Win32_DiskPartition -ErrorAction SilentlyContinue)) {
            foreach ($vol in @(Get-CimAssociatedInstance -InputObject $part -ResultClassName Win32_LogicalDisk -ErrorAction SilentlyContinue)) {
                $lettres.Add([string]$vol.DeviceID)
                if ($vol.VolumeName) { $noms.Add([string]$vol.VolumeName) }
            }
        }
        $taille = [UInt64]0
        if ($disque.Size) { $taille = [UInt64]$disque.Size }
        $PresentParCle[(ConvertTo-Cle $disque.PNPDeviceID)] = [pscustomobject]@{
            Lettres = ($lettres -join ' ')
            Noms    = ($noms -join ' / ')
            Taille  = $taille
        }
    }
    Add-Bilan 'WMI Win32_DiskDrive (supports branchés)' ('lu : {0} disque(s) branché(s)' -f $PresentParCle.Count)
} catch {
    Add-Bilan 'WMI Win32_DiskDrive (supports branchés)' (Get-MotifErreur $_)
}

# ---------------------------------------------------------------------------------------------
# 8. Assemblage : une ligne par support
# ---------------------------------------------------------------------------------------------

$Resultats = New-Object System.Collections.Generic.List[object]
$ParentsRattaches = @{}

# Événements du journal qui concernent un support donné (par parent USB, sinon par numéro de série)
function Get-EvenementsDuSupport {
    param([string]$CleParent, [string]$Serie, [bool]$SerieUnique)
    $liste = @()
    if ($CleParent) { $liste = @($Journal | Where-Object { $_.CleParent -eq $CleParent }) }
    if ($liste.Count -eq 0 -and $SerieUnique -and $Serie.Length -ge 6) {
        $liste = @($Journal | Where-Object { $_.Serie -eq $Serie })
    }
    return ,$liste
}

foreach ($c in $Candidats) {
    $prop = @{}
    if ($ModePnp) {
        try {
            foreach ($p in @(Get-PnpDeviceProperty -InstanceId $c.Id -KeyName $ClesPnp -ErrorAction Stop)) {
                # Une propriété absente (ex. : jamais retiré) revient sans champ Data
                $valeur = $null
                if ($p.PSObject.Properties['Data']) { $valeur = $p.Data }
                $prop[[string]$p.KeyName] = $valeur
            }
        } catch { }
    }
    $parent = [string]$prop['DEVPKEY_Device_Parent']

    # Un disque SCSI n'est retenu que s'il est branché derrière un port USB (protocole UASP)
    if ($c.Id -like 'SCSI\*' -and $parent -notlike 'USB\*') { continue }

    $nom = [string]$prop['DEVPKEY_Device_FriendlyName']
    if (-not $nom) { $nom = $c.Nom }
    $modele = Get-ModeleLisible $nom

    # Numéro de série : celui de l'instance, sinon celui du périphérique USB parent
    $infos = Get-InfosSerie $c.Id
    if (-not $infos.Unique -and $parent -like 'USB\VID*') {
        $infosParent = Get-InfosSerie $parent
        if ($infosParent.Unique) { $infos = $infosParent }
    }

    $cle       = ConvertTo-Cle $c.Id
    $cleParent = ConvertTo-Cle $parent
    $present   = ($prop['DEVPKEY_Device_IsPresent'] -eq $true)

    # Journal : nombre d'arrivées, première et dernière
    $evs = Get-EvenementsDuSupport $cleParent $infos.Serie $infos.Unique
    foreach ($e in $evs) { $ParentsRattaches[$e.CleParent] = $true }
    $arrivees = @($evs | Where-Object { $_.Evenement -eq 'Arrivée' } | Sort-Object Date)
    $nbJournal = ''
    if ($JournalLisible) { $nbJournal = $arrivees.Count }
    $journalPremier = $null; $journalDernier = $null; $capacite = [UInt64]0
    if ($arrivees.Count -gt 0) {
        $journalPremier = $arrivees[0].Date
        $journalDernier = $arrivees[-1].Date
        $capacite       = $arrivees[-1].Capacite
    }

    # Lettre, nom de volume et taille
    $lettre = ''; $nomVolume = ''
    if ($present -and $PresentParCle.ContainsKey($cle)) {
        $lettre    = $PresentParCle[$cle].Lettres
        $nomVolume = $PresentParCle[$cle].Noms
        if ($capacite -eq 0) { $capacite = $PresentParCle[$cle].Taille }
    }
    if (-not $lettre -and $LettreParCle.ContainsKey($cle)) { $lettre = $LettreParCle[$cle] }
    if (-not $nomVolume -and $NomParCle.ContainsKey($cle)) { $nomVolume = $NomParCle[$cle] }
    if (-not $nomVolume -and $NomParCle.ContainsKey($cleParent)) { $nomVolume = $NomParCle[$cleParent] }

    # Comptes dont la session a vu l'un des volumes de ce support
    $comptes = New-Object System.Collections.Generic.List[string]
    if ($VolumesParCle.ContainsKey($cle)) {
        foreach ($g in $VolumesParCle[$cle]) {
            if ($SessionsParVolume.ContainsKey($g)) {
                foreach ($x in $SessionsParVolume[$g]) { if (-not $comptes.Contains($x)) { $comptes.Add($x) } }
            }
        }
    }

    $serieUnique = 'Non (attribué par Windows)'
    if ($infos.Unique) { $serieUnique = 'Oui' }
    $presentTexte = 'Non'
    if ($present) { $presentTexte = 'Oui' } elseif (-not $ModePnp) { $presentTexte = '?' }

    $Resultats.Add([pscustomobject]@{
        Type                 = Get-TypeSupport $c.Id $c.Classe $modele
        Modele               = $modele
        NumeroSerie          = $infos.Serie
        SerieUnique          = $serieUnique
        VidPid               = Get-VidPid $(if ($parent) { $parent } else { $c.Id })
        PremiereInstallation = $prop['DEVPKEY_Device_FirstInstallDate']
        DerniereArrivee      = $prop['DEVPKEY_Device_LastArrivalDate']
        DernierRetrait       = $prop['DEVPKEY_Device_LastRemovalDate']
        Present              = $presentTexte
        Lettre               = $lettre
        NomVolume            = $nomVolume
        Taille               = Format-Taille $capacite
        ArriveesJournal      = $nbJournal
        JournalPremier       = $journalPremier
        JournalDernier       = $journalDernier
        MonteDansSessionDe   = ($comptes -join ', ')
        Source               = 'Windows (Plug and Play)'
        IdInstance           = $c.Id
    })
}

# Supports présents dans le journal mais plus connus de Windows (entrée supprimée depuis)
$orphelins = @($Journal | Where-Object { -not $ParentsRattaches.ContainsKey($_.CleParent) } | Group-Object CleParent)
foreach ($groupe in $orphelins) {
    $evs = @($groupe.Group | Sort-Object Date)
    $arrivees = @($evs | Where-Object { $_.Evenement -eq 'Arrivée' })
    $retraits = @($evs | Where-Object { $_.Evenement -eq 'Retrait' })
    $infos = Get-InfosSerie $evs[-1].Parent
    $derniereArrivee = $null; $premiereArrivee = $null; $capacite = [UInt64]0
    if ($arrivees.Count -gt 0) {
        $premiereArrivee = $arrivees[0].Date
        $derniereArrivee = $arrivees[-1].Date
        $capacite        = $arrivees[-1].Capacite
    }
    $dernierRetrait = $null
    if ($retraits.Count -gt 0) { $dernierRetrait = $retraits[-1].Date }
    $serie = $evs[-1].Serie
    if (-not $serie) { $serie = $infos.Serie }
    $serieUnique = 'Non (attribué par Windows)'
    if ($infos.Unique) { $serieUnique = 'Oui' }
    $Resultats.Add([pscustomobject]@{
        Type                 = Get-TypeSupport '' 'DiskDrive' $evs[-1].Modele
        Modele               = $evs[-1].Modele
        NumeroSerie          = $serie
        SerieUnique          = $serieUnique
        VidPid               = Get-VidPid $evs[-1].Parent
        PremiereInstallation = $null
        DerniereArrivee      = $derniereArrivee
        DernierRetrait       = $dernierRetrait
        Present              = 'Non'
        Lettre               = ''
        NomVolume            = ''
        Taille               = Format-Taille $capacite
        ArriveesJournal      = $arrivees.Count
        JournalPremier       = $premiereArrivee
        JournalDernier       = $derniereArrivee
        MonteDansSessionDe   = ''
        Source               = 'Journal seulement (entrée Windows supprimée)'
        IdInstance           = $evs[-1].Parent
    })
}

# Tri : du plus récemment branché au plus ancien
$Resultats = @($Resultats | Sort-Object -Descending -Property @{ Expression = {
    $d = $_.DerniereArrivee
    if (-not ($d -is [datetime])) { $d = $_.JournalDernier }
    if ($d -is [datetime]) { $d } else { [datetime]::MinValue }
} })

# ---------------------------------------------------------------------------------------------
# 9. Affichage
# ---------------------------------------------------------------------------------------------

Write-Host ''
Write-Host ('Supports USB vus par le poste {0} (relevé du {1})' -f $env:COMPUTERNAME, (Get-Date).ToString('dd/MM/yyyy HH:mm', $Invariant)) -ForegroundColor Cyan

if ($Resultats.Count -eq 0) {
    Write-Host ''
    Write-Host 'Aucun support de stockage USB trouvé sur ce poste.' -ForegroundColor Green
    Write-Host 'Soit aucun support n''y a été branché, soit ses traces ont été supprimées (nettoyage, réinstallation).'
} elseif ($Detail) {
    $Resultats | Select-Object Type, Modele, NumeroSerie, SerieUnique, VidPid,
        @{ n = 'PremiereInstallation'; e = { Format-Date $_.PremiereInstallation } },
        @{ n = 'DerniereArrivee';      e = { Format-Date $_.DerniereArrivee } },
        @{ n = 'DernierRetrait';       e = { Format-Date $_.DernierRetrait } },
        Present, Lettre, NomVolume, Taille, ArriveesJournal,
        @{ n = 'JournalPremier'; e = { Format-Date $_.JournalPremier } },
        @{ n = 'JournalDernier'; e = { Format-Date $_.JournalDernier } },
        MonteDansSessionDe, Source, IdInstance | Format-List | Out-Host
} else {
    $Resultats | Select-Object `
        @{ n = 'Dernière arrivée'; e = { Limit-Texte (Format-Date $_.DerniereArrivee) 16 } },
        @{ n = '1re installation'; e = { Limit-Texte (Format-Date $_.PremiereInstallation) 16 } },
        @{ n = 'Dernier retrait';  e = { Limit-Texte (Format-Date $_.DernierRetrait) 16 } },
        @{ n = 'Présent';          e = { $_.Present } },
        @{ n = 'Volume';           e = { Limit-Texte (('{0} {1}' -f $_.Lettre, $_.NomVolume).Trim()) 14 } },
        @{ n = 'Modèle';           e = {
            $m = $_.Modele
            if ($_.Type -like 'Téléphone*') { $m = $m + ' [MTP]' }
            if ($_.Source -like 'Journal*') { $m = $m + ' [journal]' }
            Limit-Texte $m 24 } },
        @{ n = 'N° de série';      e = { Limit-Texte $_.NumeroSerie 20 } } |
        Format-Table -AutoSize | Out-Host
    Write-Host 'Toutes les colonnes : relancez avec -Detail ou exportez avec -Csv <chemin>.' -ForegroundColor DarkGray
}

# Chronologie des arrivées et retraits encore présents dans le journal
$LignesChrono = @($Journal | Sort-Object Date)
if ($Chronologie) {
    Write-Host ''
    Write-Host 'Chronologie (journal Partition/Diagnostic, du plus ancien au plus récent)' -ForegroundColor Cyan
    if ($LignesChrono.Count -eq 0) {
        Write-Host 'Aucun événement USB dans le journal (journal vide, illisible ou déjà écrasé).'
    } else {
        $LignesChrono | Select-Object `
            @{ n = 'Date';        e = { Format-Date $_.Date 'dd/MM/yyyy HH:mm:ss' } },
            @{ n = 'Événement';   e = { $_.Evenement } },
            @{ n = 'Modèle';      e = { Limit-Texte $_.Modele 30 } },
            @{ n = 'N° de série'; e = { Limit-Texte $_.Serie 22 } },
            @{ n = 'Taille';      e = { Format-Taille $_.Capacite } } | Format-Table -AutoSize | Out-Host
        Write-Host 'Arrivée = support visible (taille connue) ; Retrait = support retiré ou lecteur vide.' -ForegroundColor DarkGray
        Write-Host 'Un même branchement peut produire plusieurs lignes : lisez-les comme des indices.' -ForegroundColor DarkGray
    }
}

# Export CSV : seule écriture du script, et seulement sur demande
if ($Csv) {
    try {
        $chemin = $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($Csv)
        $dossier = Split-Path -Path $chemin -Parent
        if ($dossier -and -not (Test-Path -LiteralPath $dossier -PathType Container)) {
            throw ('le dossier {0} n''existe pas' -f $dossier)
        }
        $encodage = 'UTF8'
        if ($PSVersionTable.PSVersion.Major -ge 6) { $encodage = 'utf8BOM' }
        $Resultats | Select-Object Type, Modele, NumeroSerie, SerieUnique, VidPid,
            @{ n = 'PremiereInstallation'; e = { Format-Date $_.PremiereInstallation 'yyyy-MM-dd HH:mm:ss' } },
            @{ n = 'DerniereArrivee';      e = { Format-Date $_.DerniereArrivee 'yyyy-MM-dd HH:mm:ss' } },
            @{ n = 'DernierRetrait';       e = { Format-Date $_.DernierRetrait 'yyyy-MM-dd HH:mm:ss' } },
            Present, Lettre, NomVolume, Taille, ArriveesJournal,
            @{ n = 'JournalPremier'; e = { Format-Date $_.JournalPremier 'yyyy-MM-dd HH:mm:ss' } },
            @{ n = 'JournalDernier'; e = { Format-Date $_.JournalDernier 'yyyy-MM-dd HH:mm:ss' } },
            MonteDansSessionDe, Source, IdInstance |
            Export-Csv -LiteralPath $chemin -Delimiter ';' -NoTypeInformation -Encoding $encodage
        Write-Host ('Export CSV : {0}' -f $chemin) -ForegroundColor Green
        if ($Chronologie) {
            $cheminChrono = [IO.Path]::Combine([IO.Path]::GetDirectoryName($chemin),
                [IO.Path]::GetFileNameWithoutExtension($chemin) + '-chronologie' + [IO.Path]::GetExtension($chemin))
            $LignesChrono | Select-Object `
                @{ n = 'Date';        e = { Format-Date $_.Date 'yyyy-MM-dd HH:mm:ss' } },
                Evenement, Modele,
                @{ n = 'NumeroSerie'; e = { $_.Serie } },
                @{ n = 'Taille';      e = { Format-Taille $_.Capacite } },
                @{ n = 'IdParent';    e = { $_.Parent } } |
                Export-Csv -LiteralPath $cheminChrono -Delimiter ';' -NoTypeInformation -Encoding $encodage
            Write-Host ('Export CSV : {0}' -f $cheminChrono) -ForegroundColor Green
        }
    } catch {
        Write-Warning ('Export CSV impossible : ' + $_.Exception.Message)
    }
}

# Bilan des sources et droits
Write-Host ''
Write-Host 'Sources lues' -ForegroundColor Cyan
$Bilan | Format-Table -AutoSize -Wrap | Out-Host
if ($EstAdmin) {
    Write-Host 'Lancé en administrateur : les sessions ouvertes des autres utilisateurs ont aussi été lues.'
} else {
    Write-Host 'Lancé sans droits administrateur : seule la colonne MonteDansSessionDe se limite à votre propre session.'
    Write-Host 'Si une source indique « accès refusé », relancez PowerShell en tant qu''administrateur.'
}
Write-Host 'Les dates sont à l''heure locale de ce poste. Windows ne garde que la dernière arrivée et le dernier retrait.'

Write-Host ''
Write-Host 'À retenir : ce script montre les supports USB branchés sur ce poste, PAS les fichiers copiés dessus.' -ForegroundColor Yellow
Write-Host 'Windows n''enregistre pas les copies de fichiers par défaut : sans audit activé avant les faits' -ForegroundColor Yellow
Write-Host '(événement 4663) ou outil dédié, la liste des fichiers copiés n''existe pas sur le poste.' -ForegroundColor Yellow
Write-Host 'En savoir plus : https://vigidoc.me/guides/copie-fichiers-cle-usb/' -ForegroundColor Yellow
Write-Host ''

if ($PassThru) { $Resultats }

<#
Licence MIT

Copyright (c) 2026 SSHack

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or
substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#>

Le script montre les clés branchées ; VigiDoc montre ce qui a été copié dessus

Get-UsbHistory dit quelle clé a été branchée et quand. VigiDoc ajoute ce que Windows ne garde pas : pour chaque clé ou disque USB inséré (lettre, nom, taille, numéro de série), la liste des fichiers copiés ou écrasés sur le support, avec l'heure, et une copie chiffrée de chaque fichier sur votre propre serveur. Des mots-clés que vous choisissez déclenchent une alerte dans le Dashboard, sans rien bloquer.

VigiDoc ne voit que ce qui se passe après son installation, et il ne suit que les supports qui reçoivent une lettre de lecteur (clés, disques et SSD externes), pas les téléphones branchés en MTP. C'est donc avant le prochain départ qu'il faut l'installer : l'essai de 30 jours démarre dès l'installation du serveur, sans licence à demander.

Questions fréquentes

Comment voir l'historique des clés USB branchées sur un PC Windows ?

Enregistrez le script gratuit Get-UsbHistory.ps1, puis lancez-le dans Windows PowerShell avec l'option -ExecutionPolicy Bypass. Il liste chaque support USB connu du poste avec son modèle, son numéro de série et ses dates de première installation, de dernière arrivée et de dernier retrait. Sans script, le Gestionnaire de périphériques montre les mêmes dates, un périphérique à la fois, une fois les périphériques cachés affichés.

Le script montre-t-il les fichiers copiés sur la clé ?

Non. Windows n'enregistre pas les copies de fichiers vers une clé USB par défaut : il faut avoir activé l'audit des supports amovibles avant les faits, ou utiliser un outil dédié. Le script montre quelles clés ont été branchées et quand, ce qui permet de cibler la suite de l'enquête.

Faut-il être administrateur pour lancer le script ?

Non. Sur notre poste de test Windows 11, toutes les sources utilisées par le script sont lisibles par une session sans élévation, dates comprises. Lancé en administrateur, il lit en plus les sessions des autres utilisateurs connectés, pour indiquer quels comptes ont vu chaque volume.

L'option -ExecutionPolicy Bypass est-elle risquée ?

Elle ne modifie pas la configuration du poste : elle s'applique seulement à la session PowerShell ouverte par la commande et disparaît à sa fermeture. Elle autorise en revanche l'exécution du script sans contrôle de signature, d'où la règle de base : lire un script avant de le lancer. Une stratégie imposée par GPO reste prioritaire.

Pourquoi une clé que je sais avoir branchée n'apparaît-elle pas ?

Son entrée a pu être supprimée : désinstallation du périphérique, outil de nettoyage, réinstallation ou remastérisation du poste. Le journal Partition/Diagnostic, que le script lit aussi, a pu être écrasé s'il était plein. Enfin, un téléphone branché en mode transfert de fichiers n'est pas une clé : il apparaît comme appareil MTP, sans lettre de lecteur.

Le résultat peut-il servir de preuve contre un salarié ?

C'est un indice technique : il montre qu'un support a été branché, pas ce qui a été copié ni qui l'a fait. Exportez-le en CSV avec la date du relevé et faites-vous conseiller par un avocat avant tout usage. Le contrôle des postes suppose aussi l'information préalable des salariés et une démarche proportionnée (Code du travail, recommandations de la CNIL).

Sources