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.
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.
| Méthode | Droits administrateur | Dates de branchement | Lettre et nom du volume | Fichiers copiés |
|---|---|---|---|---|
| Éditeur du registre, clé USBSTOR | Non pour la liste | Non : la sous-clé qui contient les dates est réservée au compte SYSTEM | À chercher à la main dans deux autres clés | Non |
| Gestionnaire de périphériques, périphériques cachés affichés | Non | Oui, un périphérique à la fois (onglet Détails) | Non | Non |
| Script Get-UsbHistory | Non | Oui, pour tous les supports d'un coup, avec l'historique du journal Partition/Diagnostic | Oui : dernière lettre et dernier nom connus | Non |
| Audit des supports amovibles (événement 4663) | Oui, pour lire le journal Sécurité | Non : il trace les accès aux fichiers | Non | En 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 :
- Lecture seule. Aucune écriture dans le registre, aucun changement de stratégie d'audit, aucun service installé, aucune connexion réseau. La seule écriture possible est le fichier CSV, et seulement si vous le demandez avec
-Csv. - Sans installation ni module. Il n'utilise que des commandes présentes dans Windows :
Get-PnpDevice,Get-PnpDeviceProperty,Get-WinEvent,Get-CimInstance, et des clés de registre ouvertes en lecture seule. Il fonctionne avec Windows PowerShell 5.1, livré avec Windows 10 et 11, et il est écrit pour tourner aussi sous PowerShell 7, que nous n'avons pas testé. - Lisible avant exécution. Environ 730 lignes, commentées en français, sans code compressé ni encodé.
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.
- Copiez le script. Dans la section Le script complet, sélectionnez tout le bloc de code et copiez-le (Ctrl+C).
- 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.
Vous préférez le Bloc-notes ? Collez le code, choisissez « Enregistrer sous », le type « Tous les fichiers », le nomcd $env:USERPROFILE Get-Clipboard -Raw | Set-Content -Path .\Get-UsbHistory.ps1 -Encoding UTF8Get-UsbHistory.ps1et 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. - Lancez-le. Dans la même fenêtre, tapez :
Le relevé prend quelques secondes (moins de 6 secondes sur notre poste de test).powershell -ExecutionPolicy Bypass -File .\Get-UsbHistory.ps1 - Gardez une trace si besoin. Ajoutez
-Csvsuivi 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
| Option | Effet |
|---|---|
-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. |
-Chronologie | Ajoute 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. |
-Detail | Affiche toutes les colonnes, support par support, au lieu du tableau résumé. |
-PassThru | Renvoie aussi des objets PowerShell, pour trier ou filtrer les résultats dans une autre commande. |
Get-Help .\Get-UsbHistory.ps1 -Full | Affiche 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 :
- Un lecteur de cartes SD a été installé pour la première fois le 24 septembre à 10 h 58 ; sa dernière arrivée date de 11 h 08 et son dernier retrait de 12 h 04. Sa dernière lettre connue est E: et son dernier nom de volume connu, « SD ».
- Une clé SanDisk a été branchée pour la première fois le 6 août et pour la dernière fois le 11 septembre à 22 h 22. Windows n'a pas de date de retrait pour elle. Sa lettre n'est plus connue : une lettre ne reste associée qu'au dernier support qui l'a reçue, et E: appartient aujourd'hui au lecteur de cartes.
- Le tableau principal ne donne que la première et la dernière date. La chronologie, elle, compte 21 arrivées de la clé SanDisk, réparties sur deux journées : le 6 août et le 11 septembre. Pour savoir si une clé a servi la semaine d'un départ, c'est cette vue qu'il faut regarder.
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.
| Colonne | Source dans Windows | Ce qu'elle indique | À savoir |
|---|---|---|---|
| Dernière arrivée | Propriété DEVPKEY_Device_LastArrivalDate | Le dernier branchement du support sur ce poste | Remplacée à chaque branchement : seule la dernière date est gardée |
| 1re installation | Propriété DEVPKEY_Device_FirstInstallDate | La première installation de ce support (ce numéro de série) sur ce poste | Elle 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 retrait | Propriété DEVPKEY_Device_LastRemovalDate | Le dernier retrait du support | Vide quand Windows n'a pas de date de retrait, comme pour la clé SanDisk de l'exemple |
| Présent | Proprié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 |
| Volume | WMI pour un support branché ; sinon registre MountedDevices et Windows Portable Devices | La dernière lettre de lecteur et le dernier nom de volume connus | Une 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èle | Nom du périphérique (FriendlyName) | Le fabricant et le modèle annoncés par le support | Les clés sans marque s'annoncent souvent « Generic Flash Disk » : fiez-vous alors au numéro de série |
| N° de série | Identifiant d'instance du périphérique | Ce qui distingue deux clés du même modèle | Si 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 |
| SerieUnique | Calculée par le script | « Oui » si le numéro de série vient du support lui-même, « Non (attribué par Windows) » sinon | Un numéro attribué par Windows ne suit pas la clé d'un poste à l'autre |
| IdInstance | Identifiant d'instance complet du périphérique | Le chemin Plug and Play du support, tel que Windows l'enregistre | Sert à retrouver l'entrée du support dans le registre et dans le Gestionnaire de périphériques |
| Type | Classe du périphérique | Clé ou disque, disque UASP, lecteur de cartes, lecteur CD/DVD, téléphone MTP | Le lecteur de cartes est reconnu à son nom : c'est une déduction |
| VidPid | Identifiant du périphérique USB parent | Les codes fabricant et produit USB, par exemple 0781:55A3 | Utile pour rapprocher le même modèle d'un poste à l'autre |
| Taille | Journal Partition/Diagnostic, sinon WMI | La capacité en milliards d'octets, proche de celle de l'étiquette | L'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, JournalDernier | Journal Microsoft-Windows-Partition/Diagnostic, événement 1006 | Le nombre d'arrivées encore inscrites dans le journal, la première et la dernière | Un même branchement peut produire plusieurs événements ; le journal est écrasé quand il est plein |
| MonteDansSessionDe | Registre MountPoints2 de chaque session ouverte | Les comptes dont la session a vu le volume | Sans droits administrateur, votre session seulement. Les comptes qui ne sont pas connectés au moment du relevé ne sont pas lus |
| Source | Calculée par le script | « Windows (Plug and Play) », ou « Journal seulement » quand Windows a oublié le support mais que le journal le garde | Ces 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.
| Source | Sans droits administrateur | En administrateur |
|---|---|---|
| Propriétés des périphériques (dates, présence) | Lisibles | Lisibles |
Registre MountedDevices et Windows Portable Devices | Lisibles : le groupe Utilisateurs a le droit de lecture | Lisibles |
| Journal Partition/Diagnostic | Lisible depuis une session ouverte sur le poste, pas depuis une connexion réseau | Lisible |
Registre MountPoints2 | Votre session seulement | Toutes les sessions ouvertes au moment du relevé |
Sous-clé Properties du registre (dates brutes) | Refusée | Refusé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.
- Les dates sont écrasées. Windows ne garde qu'une dernière arrivée et un dernier retrait par support. Le journal Partition/Diagnostic en conserve davantage, mais sa taille est plafonnée (16 Mo sur notre poste de test) : quand il est plein, les événements les plus anciens disparaissent. Sur notre poste, il remontait au 11 juillet 2026 ; sur un poste où l'on branche beaucoup de supports, il remonte moins loin.
- Les entrées peuvent disparaître. Désinstaller un périphérique dans le Gestionnaire de périphériques, passer un outil de nettoyage, réinstaller ou remastériser le poste efface ces traces ou les remet à zéro. Quand le journal se souvient d'un support que Windows a oublié, le script l'affiche avec la mention « [journal] ».
- Une liste vide ne prouve rien. Un utilisateur qui dispose des droits administrateur sur le poste peut effacer ces traces. L'absence de support signifie seulement qu'il n'en reste pas.
- Les numéros de série ne sont pas tous fiables. Une clé sans numéro reçoit un identifiant fabriqué par Windows, différent sur chaque poste. Un lecteur de cartes donne son propre numéro, pas celui de la carte insérée.
- Les téléphones en MTP sont mal couverts. Un téléphone branché en mode transfert de fichiers ne reçoit pas de lettre de lecteur. Le script le liste quand Windows l'a gardé (classe WPD), avec ses dates, mais sans lettre, sans taille et sans entrée dans le journal Partition/Diagnostic.
- Les disques externes perdent leur lettre. Windows décrit le plus souvent les disques durs et SSD externes par une signature de disque plutôt que par leur numéro de série : une fois qu'ils sont débranchés, le script ne retrouve pas leur dernière lettre.
- Les dates sont à l'heure locale du poste. Vérifiez l'horloge et le fuseau horaire du poste avant de les rapprocher d'autres journaux.
- Le script ne dit pas qui a branché la clé. La colonne MonteDansSessionDe donne un indice (les comptes dont la session a vu le volume), pas une preuve.
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
- Microsoft Learn, DEVPKEY_Device_FirstInstallDate, documentation des pilotes Windows, consultée le 14 octobre 2026.
- Microsoft Learn, Get-PnpDeviceProperty, module PnpDevice, consulté le 14 octobre 2026.
- Microsoft Learn, about_PowerShell_exe, Windows PowerShell 5.1, paramètre
-ExecutionPolicy, consulté le 14 octobre 2026. - Microsoft Learn, about_Execution_Policies, stratégies d'exécution et portée Process, consulté le 14 octobre 2026.
- Microsoft Learn, Monitor the use of removable storage devices, audit des supports amovibles (événements 4663 et 4656), Windows 10, consulté le 14 octobre 2026.
- NirSoft, USBDriveLog : journaux Partition/Diagnostic et Storsvc/Diagnostic, activés par défaut sur Windows 10 et 11, consulté le 14 octobre 2026.
- SSHack, relevés sur un poste de test Windows 11 Pro 26H2 le 14 octobre 2026 : droits du registre et du journal, sortie du script.