Zo vindt u de VID, PID, SCSI-leverancier en productinformatie van een USB-stick in Windows

Er is iets bijzonder bevredigends aan het aansluiten van een USB-apparaat op een Windows-computer en het vrijwel onmiddellijk zien verschijnen. Windows identificeert de hardware, laadt het juiste stuurprogramma, wijst het opslagapparaat een stationsletter toe en binnen één of twee seconden is de USB-stick klaar voor gebruik.

De meeste gebruikers hoeven nooit na te denken over wat er tijdens die paar seconden precies gebeurt. Voor ontwikkelaars, IT-beheerders, hardwaretechnici en iedereen die software schrijft die met USB-apparaten communiceert, roept dat automatische proces echter een belangrijke vraag op: waar haalt Windows de informatie vandaan waarmee het apparaat wordt geïdentificeerd?

Een USB-stick kan meer dan één identiteit rapporteren. Op USB-niveau rapporteert het apparaat een Vendor ID, meestal VID genoemd, en een Product ID, meestal PID genoemd. Nadat Windows het apparaat als USB-massaopslag heeft herkend, kan het opslagapparaat ook een SCSI Vendor-tekenreeks, een SCSI Product-tekenreeks en een productrevisie rapporteren.

Die waarden houden verband met elkaar omdat ze hetzelfde fysieke apparaat beschrijven, maar ze komen niet uit dezelfde bron. Ze zijn niet onderling uitwisselbaar en verwijzen niet altijd naar dezelfde fabrikant of dezelfde productnaam.

Windows 10 biedt verschillende manieren om deze informatie te bekijken of op te halen. Sommige methoden zijn bedoeld voor iemand die achter de computer zit. Andere zijn geschikter voor scripts, inventarisatiesystemen, diagnostische software of toepassingen die USB-opslagapparaten automatisch moeten herkennen.

USB VID en PID tegenover SCSI-leverancier en product

Voordat we naar de verschillende Windows-methoden kijken, is het handig om de twee betrokken identiteiten te begrijpen.

De USB Vendor ID en Product ID zijn afkomstig uit de USB-descriptors van het apparaat. Deze waarden worden gerapporteerd wanneer het USB-apparaat voor het eerst wordt aangesloten en Windows met het USB-enumeratieproces begint.

Een typische USB-hardware-id kan er als volgt uitzien:

USB\VID_090C&PID_1000&REV_1100
USB\VID_090C&PID_1000

In dit voorbeeld zijn de waarden:

USB VID = 090C
USB PID = 1000

De VID is bedoeld om de USB-leverancier te identificeren, terwijl de PID een product of productfamilie identificeert die door die leverancier is toegewezen. Beide waarden zijn hexadecimale getallen.

Nadat Windows heeft vastgesteld dat het aangesloten apparaat een USB Mass Storage-apparaat is, communiceert Windows ermee via de opdrachtenlaag voor opslag. Een standaard SCSI Inquiry-antwoord kan een Vendor-tekenreeks, Product-tekenreeks en Revision-tekenreeks bevatten.

Een hardware-id voor het opslagapparaat kan er als volgt uitzien:

USBSTOR\Disk&Ven_Generic&Prod_Flash_Disk&Rev_8.07

In dit voorbeeld zijn de waarden:

SCSI Vendor   = Generic
SCSI Product  = Flash Disk
SCSI Revision = 8.07

De USB VID en PID zijn numerieke identificatiecodes die tijdens de USB-enumeratie worden gebruikt. De velden SCSI Vendor en Product zijn teksttekenreeksen die via de opslaginterface worden gerapporteerd. Een apparaatfabrikant kan de ene identiteit veranderen zonder noodzakelijkerwijs ook de andere te wijzigen.

Daarom kan een USB-stick een USB VID rapporteren die bij de fabrikant van de controller hoort, terwijl in het veld SCSI Product een commerciële productnaam, een klantnaam of iets algemeens zoals “USB Flash Disk” wordt weergegeven.

Hoe Windows de twee apparaatidentiteiten opbouwt

De eenvoudigste manier om het proces voor te stellen is als twee fasen. Windows identificeert eerst de aangesloten USB-hardware. Vervolgens identificeert Windows het opslagapparaat dat via die USB-verbinding werkt.

De USB VID en PID komen tijdens de eerste fase beschikbaar. De velden SCSI Vendor, Product en Revision worden beschikbaar nadat het stuurprogramma voor USB-massaopslag is geladen en Windows het opslagapparaat heeft opgevraagd.

Dit verschil helpt ook verklaren waarom Windows een USB-apparaat kan onthouden nadat het is losgekoppeld. Zoals besproken in ons artikel over waarom Windows een geschiedenis van eerder aangesloten USB-apparaten bewaart, slaat Windows informatie op die tijdens de apparaatenumeratie is verzameld, zodat de hardware de volgende keer opnieuw kan worden herkend en beheerd.

Waarom zou iemand beide soorten informatie nodig hebben?

Voor eenvoudige probleemoplossing kunnen de USB VID en PID voldoende zijn. Voor apparaatinventarisatie, productie, diagnostiek of softwareontwikkeling geeft het verzamelen van beide identiteiten echter een completer beeld.

Een inventarisatietoepassing kan de USB VID en PID gebruiken om apparaten op hardwareplatform te groeperen, terwijl de SCSI Vendor- en Product-tekenreeksen aan de gebruiker worden getoond. Een productiehulpprogramma kan controleren of een ondersteunde USB-controller is aangesloten voordat een bewerking wordt uitgevoerd. Een diagnostisch programma kan alle identificatiecodes vastleggen, zodat resultaten van verschillende apparaten later met elkaar kunnen worden vergeleken.

Digitale forensische hulpmiddelen kunnen de identificatiecodes verzamelen als onderdeel van een apparaatrecord. USB-validatiesoftware kan de identiteit die door het apparaat wordt gerapporteerd vergelijken met het gedrag dat tijdens tests wordt waargenomen. Dat kan nuttig zijn, omdat de naam, capaciteit en prestaties die door een USB-apparaat worden geclaimd niet noodzakelijk bewijzen welke hardware er werkelijk in zit.

Hetzelfde principe geldt voor gegevensintegriteit. Identificatiegegevens vertellen ons wat het apparaat beweert te zijn, terwijl tests laten zien hoe het zich werkelijk gedraagt. Ons artikel waarin wordt uitgelegd waarom USB-gegevensverificatie soms een stroomcyclus moet omvatten, behandelt een vergelijkbaar verschil tussen informatie die onmiddellijk wordt gerapporteerd en informatie die pas wordt bewezen nadat het apparaat is losgekoppeld en opnieuw aangesloten.

Methode 1: Windows Apparaatbeheer gebruiken

Apparaatbeheer is de eenvoudigste plaats om te beginnen, omdat hiervoor geen opdrachtregel, scripts of programmeerwerk nodig zijn. Het belangrijke detail is dat de USB-identiteit en de opslagidentiteit meestal onder twee verschillende apparaatvermeldingen worden weergegeven.

De USB VID en PID vinden

Open Apparaatbeheer en vouw het gedeelte Universal Serial Bus-controllers uit. Zoek het USB-apparaat voor massaopslag dat bij de USB-stick hoort, klik er met de rechtermuisknop op en selecteer Eigenschappen.

Selecteer het tabblad Details en kies Hardware-id’s in de vervolgkeuzelijst Eigenschap.

Apparaatbeheer
→ Universal Serial Bus-controllers
→ USB-apparaat voor massaopslag
→ Eigenschappen
→ Details
→ Hardware-id's

Een typisch resultaat kan er als volgt uitzien:

USB\VID_090C&PID_1000&REV_1100
USB\VID_090C&PID_1000

De vier tekens na VID_ vormen de USB Vendor ID. De vier tekens na PID_ vormen de USB Product ID.

De SCSI-leverancier en het SCSI-product vinden

Ga terug naar Apparaatbeheer en vouw Schijfstations uit. Zoek de USB-stick, klik er met de rechtermuisknop op en selecteer Eigenschappen. Open opnieuw het tabblad Details en selecteer Hardware-id’s.

Apparaatbeheer
→ Schijfstations
→ USB-stick
→ Eigenschappen
→ Details
→ Hardware-id's

Het resultaat kan er ongeveer als volgt uitzien:

USBSTOR\Disk&Ven_Generic&Prod_Flash_Disk&Rev_8.07

Windows heeft de waarden opgemaakt als een Plug-and-Play-hardware-id:

Ven_Generic     = SCSI Vendor
Prod_Flash_Disk = SCSI Product
Rev_8.07        = SCSI Revision

Apparaatbeheer is een uitstekende keuze wanneer u één apparaat handmatig onderzoekt. De beperking is dat het koppelen van de juiste vermelding voor USB-massaopslag aan de juiste vermelding onder Schijfstations verwarrend kan worden wanneer er meerdere USB-sticks tegelijk zijn aangesloten.

Methode 2: PowerShell gebruiken

PowerShell is een betere keuze wanneer de informatie herhaaldelijk moet worden verzameld, in een rapport moet worden weergegeven of van meerdere computers moet worden opgehaald. Windows 10 bevat PowerShell en de Plug-and-Play-cmdlets die nodig zijn voor eenvoudige apparaatinspectie.

Aanwezige USB-apparaten met een VID en PID weergeven

Open PowerShell en voer de volgende opdracht uit:

Get-PnpDevice -PresentOnly |
Where-Object {
    $_.InstanceId -match '^USB\\VID_'
} |
Select-Object FriendlyName, Class, InstanceId

De uitvoer bevat apparaatinstantie-id’s die er ongeveer als volgt uitzien:

USB\VID_090C&PID_1000\1234567890

In het volgende voorbeeld worden de VID en PID in afzonderlijke kolommen geplaatst:

Get-PnpDevice -PresentOnly |
Where-Object {
    $_.InstanceId -match '^USB\\VID_'
} |
ForEach-Object {
    if ($_.InstanceId -match 'VID_([0-9A-F]{4})&PID_([0-9A-F]{4})') {
        [PSCustomObject]@{
            DeviceName = $_.FriendlyName
            VID        = $matches[1]
            PID        = $matches[2]
            InstanceId = $_.InstanceId
        }
    }
}

Dit is nuttig omdat een lange Windows-tekenreeks voor een apparaatinstantie wordt omgezet in een overzichtelijker resultaat met de apparaatnaam, VID en PID.

USB-opslaginformatie weergeven

De volgende PowerShell-opdracht vraagt de Windows-klasse voor schijfstations op en filtert de resultaten op USB-opslagapparaten:

Get-CimInstance Win32_DiskDrive |
Where-Object {
    $_.InterfaceType -eq 'USB' -or
    $_.PNPDeviceID -like 'USBSTOR*'
} |
Select-Object DeviceID,
              Manufacturer,
              Model,
              FirmwareRevision,
              PNPDeviceID

Een resultaat kan er als volgt uitzien:

DeviceID        : \\.\PHYSICALDRIVE2
Manufacturer    : Generic
Model           : Flash Disk USB Device
FirmwareRevision: 8.07
PNPDeviceID     : USBSTOR\DISK&VEN_GENERIC&PROD_FLASH_DISK&REV_8.07...

De velden Manufacturer en Model kunnen handig zijn, maar ze worden niet door ieder USB-opslagapparaat op een consistente manier ingevuld. De PNPDeviceID geeft vaak de duidelijkste weergave van de Vendor-, Product- en Revision-waarden die Windows heeft ontvangen.

PowerShell is een van de beste algemene opties, omdat er geen gecompileerde toepassing voor nodig is. Het moeilijkere gedeelte is het koppelen van een apparaatvermelding op USB-niveau aan de bijbehorende fysieke schijf wanneer meerdere apparaten zijn aangesloten. Een geavanceerder script kan de bovenliggende en onderliggende apparaatrelaties van Windows volgen om die koppeling tot stand te brengen.

Methode 3: WMI of de WMIC-opdracht gebruiken

Windows Management Instrumentation, meestal afgekort tot WMI, wordt al vele jaren gebruikt om informatie over hardware en het besturingssysteem op te halen. Veel Windows 10-computers bevatten ook het oudere WMIC-opdrachtregelprogramma.

WMIC is nuttig voor snelle tests en voor het onderhouden van oudere scripts, hoewel PowerShell en CIM over het algemeen betere keuzes zijn voor nieuwe ontwikkelingen.

USB-schijfinformatie weergeven met WMIC

Open de Opdrachtprompt en voer het volgende uit:

wmic diskdrive get DeviceID,InterfaceType,Manufacturer,Model,FirmwareRevision,PNPDeviceID

Voer de volgende opdracht uit om het resultaat te beperken tot schijfstations die een USB-interface gebruiken:

wmic diskdrive where "InterfaceType='USB'" get DeviceID,Manufacturer,Model,FirmwareRevision,PNPDeviceID

Een typisch resultaat kan er ongeveer als volgt uitzien:

DeviceID             Manufacturer  Model                  FirmwareRevision
\\.\PHYSICALDRIVE2   Generic       Flash Disk USB Device  8.07

De kolom PNPDeviceID kan een langere waarde bevatten:

USBSTOR\DISK&VEN_GENERIC&PROD_FLASH_DISK&REV_8.07\...

Plug-and-Play-vermeldingen doorzoeken op USB VID- en PID-waarden

De volgende WMIC-opdracht doorzoekt Plug-and-Play-apparaten op vermeldingen die een USB VID bevatten:

wmic path Win32_PnPEntity where "PNPDeviceID like 'USB%%VID_%%'" get Name,PNPDeviceID

De dubbele procenttekens worden door WMIC binnen de query als jokertekens gebruikt.

WMIC is mogelijk niet aanwezig of ingeschakeld op iedere nieuwere Windows-installatie en Microsoft verplaatst administratieve scripts steeds meer richting PowerShell. Voor een Windows 10-hulpprogramma of een bestaand bedrijfsscript kan WMI echter nog steeds nuttige informatie leveren.

Methode 4: De Windows SetupAPI gebruiken

Software die in C of C++ is geschreven, kan via de SetupAPI informatie over Windows Plug-and-Play-apparaten ophalen. Dit is een praktische aanpak voor desktoptoepassingen die USB-apparaten automatisch moeten ontdekken, zonder dat de gebruiker zelf door Apparaatbeheer hoeft te bladeren.

Een volledige SetupAPI-toepassing omvat foutafhandeling, dynamische buffers, verwerking van apparaateigenschappen en het opruimen van gebruikte bronnen. Het volgende verkorte voorbeeld toont de belangrijkste Windows-aanroepen die hierbij betrokken zijn.

Een verzameling apparaatinformatie maken

#include <windows.h>
#include <setupapi.h>

HDEVINFO deviceInfoSet = SetupDiGetClassDevsW(
    nullptr,
    L"USB",
    nullptr,
    DIGCF_ALLCLASSES | DIGCF_PRESENT
);

Hiermee wordt een verzameling apparaatinformatie gemaakt met de USB-apparaten die momenteel in de computer aanwezig zijn.

De apparaatvermeldingen doorlopen

SP_DEVINFO_DATA deviceInfoData{};
deviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);

for (
    DWORD index = 0;
    SetupDiEnumDeviceInfo(
        deviceInfoSet,
        index,
        &deviceInfoData
    );
    ++index
) {
    // Haal hier de apparaateigenschappen op.
}

De eigenschap Hardware-id lezen

WCHAR hardwareIds[4096]{};
DWORD requiredSize = 0;

if (SetupDiGetDeviceRegistryPropertyW(
        deviceInfoSet,
        &deviceInfoData,
        SPDRP_HARDWAREID,
        nullptr,
        reinterpret_cast<PBYTE>(hardwareIds),
        sizeof(hardwareIds),
        &requiredSize
    )) {

    // Zoek in hardwareIds naar:
    // VID_xxxx
    // PID_xxxx
}

De geretourneerde eigenschap voor de hardware-id kan één of meer door null-tekens gescheiden tekenreeksen bevatten. Een USB-apparaatvermelding kan bijvoorbeeld de volgende identificatiecode bevatten:

USB\VID_090C&PID_1000&REV_1100

De toepassing kan die tekenreeks doorzoeken op de velden VID_ en PID_ en de vier daaropvolgende hexadecimale tekens uitlezen.

Wanneer de toepassing klaar is, moet de verzameling apparaatinformatie worden vrijgegeven:

SetupDiDestroyDeviceInfoList(deviceInfoSet);

SetupAPI is krachtig, maar er is een belangrijk detail: Windows vertegenwoordigt het USB-apparaat en de fysieke schijf als afzonderlijke knooppunten in de apparaatstructuur. Het ophalen van de USB VID en PID is relatief eenvoudig. Het koppelen van die waarden aan de juiste schijf, stationsletter en SCSI-identiteit kan vereisen dat de bovenliggende en onderliggende apparaatrelaties worden doorlopen.

Dit is een van de redenen waarom een commerciële diagnostische toepassing doorgaans meer code nodig heeft dan een korte demonstratie doet vermoeden. De afzonderlijke eigenschappen zijn beschikbaar, maar het echte werk bestaat uit het correct samenvoegen van alle informatie tot één apparaatrecord.

Methode 5: Het opslagapparaat rechtstreeks opvragen

Een Windows-toepassing kan een fysieke schijf opvragen door het apparaat te openen en een IOCTL_STORAGE_QUERY_PROPERTY-verzoek te verzenden. Deze methode is nuttig voor het ophalen van opslaginformatie zoals Vendor, Product, Revision, serienummer en bustype.

In het onderstaande voorbeeld wordt PhysicalDrive2 geopend. Het werkelijke nummer van de fysieke schijf is afhankelijk van de computer en van welk USB-apparaat wordt onderzocht.

De fysieke schijf openen

HANDLE drive = CreateFileW(
    L"\\\\.\\PhysicalDrive2",
    GENERIC_READ,
    FILE_SHARE_READ | FILE_SHARE_WRITE,
    nullptr,
    OPEN_EXISTING,
    0,
    nullptr
);

if (drive == INVALID_HANDLE_VALUE) {
    // Verwerk de fout.
}

De opslagquery voorbereiden

STORAGE_PROPERTY_QUERY query{};
query.PropertyId = StorageDeviceProperty;
query.QueryType  = PropertyStandardQuery;

De query naar Windows verzenden

BYTE buffer[4096]{};
DWORD bytesReturned = 0;

BOOL result = DeviceIoControl(
    drive,
    IOCTL_STORAGE_QUERY_PROPERTY,
    &query,
    sizeof(query),
    buffer,
    sizeof(buffer),
    &bytesReturned,
    nullptr
);

De geretourneerde opslagdescriptor interpreteren

if (result) {
    auto descriptor =
        reinterpret_cast<STORAGE_DEVICE_DESCRIPTOR*>(buffer);

    const char* vendor =
        descriptor->VendorIdOffset
            ? reinterpret_cast<const char*>(
                buffer + descriptor->VendorIdOffset
              )
            : "";

    const char* product =
        descriptor->ProductIdOffset
            ? reinterpret_cast<const char*>(
                buffer + descriptor->ProductIdOffset
              )
            : "";

    const char* revision =
        descriptor->ProductRevisionOffset
            ? reinterpret_cast<const char*>(
                buffer + descriptor->ProductRevisionOffset
              )
            : "";

    const char* serial =
        descriptor->SerialNumberOffset
            ? reinterpret_cast<const char*>(
                buffer + descriptor->SerialNumberOffset
              )
            : "";
}

De tekenreeksen worden niet rechtstreeks in het vaste gedeelte van de structuur opgeslagen. In plaats daarvan bevat de structuur byte-offsets die verwijzen naar de locaties van die tekenreeksen binnen de geretourneerde buffer.

Wanneer u klaar bent met de handle van de fysieke schijf, sluit u deze:

CloseHandle(drive);

Een geslaagde opslagquery kan informatie opleveren die er ongeveer als volgt uitziet:

Vendor   = Generic
Product  = Flash Disk
Revision = 8.07
Serial   = 1234567890
Bus Type = USB

Deze methode staat dichter bij het opslagapparaat dan het lezen van een beschrijvende naam uit Apparaatbeheer of het opvragen van een in het register opgeslagen waarde. De USB VID en PID worden echter niet automatisch geretourneerd. De toepassing moet de fysieke schijf nog steeds koppelen aan het bovenliggende USB-apparaat en de USB-hardware-id afzonderlijk ophalen, meestal via SetupAPI of de Windows Configuration Manager-functies.

Welke Windows-methode moet u gebruiken?

Er bestaat geen enkele methode die voor iedere situatie de beste keuze is. De juiste keuze hangt ervan af of het doel handmatige inspectie, scripting, softwareontwikkeling of apparaatanalyse op laag niveau is.

Open de vergelijking van Windows-methoden voor USB-identificatie

Methode	USB VID/PID	SCSI Vendor/Product	Programmeren vereist	Beste toepassing
Apparaatbeheer	Ja	Ja	Nee	Eén apparaat handmatig onderzoeken
PowerShell	Ja	Ja	Lichte scripting	Inventarisatie en herhaalbare rapporten
WMI of WMIC	Ja	Ja	Lichte scripting	Oudere systemen en bestaande scripts
SetupAPI	Ja	Via apparaatkoppeling	Ja	Windows-toepassingen en USB-hulpprogramma’s
Opslagquery	Niet rechtstreeks	Ja	Ja	Diagnostiek en rechtstreekse opslaginformatie

Voor iemand die één USB-stick controleert, is Apparaatbeheer meestal voldoende. Voor beheerders die informatie van veel computers verzamelen, is PowerShell waarschijnlijk het beste uitgangspunt. Voor softwareontwikkelaars die een Windows-hulpprogramma bouwen, biedt SetupAPI in combinatie met een query voor opslageigenschappen de meest volledige aanpak.

Is het Windows-register nog een andere methode?

Windows slaat informatie over USB-enumeratie op in het register en het is mogelijk om daar zowel USB-vermeldingen als USB-opslagvermeldingen te vinden.

Vermeldingen voor USB-apparaten zijn doorgaans te vinden onder:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USB

Vermeldingen voor USB-opslag zijn doorgaans te vinden onder:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR

Deze locaties zijn nuttig voor probleemoplossing en historische analyse, maar het register moet niet worden verward met de oorspronkelijke bron van de informatie. Windows maakt deze vermeldingen aan en werkt ze bij nadat het USB-apparaat al is geïnventariseerd en de opslaginterface al is opgevraagd.

De oorspronkelijke USB VID en PID komen uit de USB-descriptors. De oorspronkelijke Vendor-, Product- en Revision-waarden voor opslag komen uit het Inquiry-antwoord van het opslagapparaat. In het register legt Windows de resultaten vast voor later gebruik.

Registermachtigingen kunnen rechtstreekse toegang voor software bovendien onhandig maken. Wanneer een toepassing alleen informatie nodig heeft over apparaten die momenteel zijn aangesloten, zijn de ondersteunde Windows-apparaat-API’s meestal een betere keuze.

Waarom de USB- en SCSI-namen mogelijk niet overeenkomen

Het is logisch om te verwachten dat iedere identificatiecode dezelfde fabrikantnaam weergeeft. In de praktijk worden USB-sticks echter opgebouwd uit verschillende lagen hardware en firmware, en iedere laag kan iets anders rapporteren.

Een bedrijf dat USB-sticks onder een winkelmerk verkoopt, kan een controller van een andere fabrikant inkopen. De USB VID kan de leverancier van de controller identificeren of het bedrijf dat verantwoordelijk is voor de firmware, terwijl het veld SCSI Product de commerciële merknaam kan bevatten. In andere gevallen blijven de SCSI-tekenreeksen volledig algemeen.

Een apparaat kan bijvoorbeeld het volgende rapporteren:

USB VID      = 090C
USB PID      = 1000
SCSI Vendor  = Generic
SCSI Product = Flash Disk

Een andere USB-stick kan het volgende rapporteren:

USB VID      = 0951
USB PID      = 1666
SCSI Vendor  = Kingston
SCSI Product = DataTraveler 3.0

Geen van beide indelingen bewijst automatisch dat het product echt is. Deze identificatiecodes zijn nuttig voor identificatie en onderlinge koppeling, maar het zijn waarden die door de firmware worden gerapporteerd. Een voldoende aangepast of nagemaakt apparaat kan alle waarden rapporteren die erin zijn geprogrammeerd.

Dit is een belangrijk onderscheid voor ontwikkelaars die software voor apparaatvalidatie bouwen. Identificatiewaarden moeten worden vastgelegd, maar mogen capaciteitstests, schrijf- en leesverificatie, prestatietests of andere vormen van gedragsanalyse niet vervangen.

Een praktisch apparaatrecord

Voor software die USB-sticks inventariseert of test, kan een bruikbaar apparaatrecord uit meer dan vier velden bestaan.

USB VID
USB PID
USB Revision
USB Serial Number
SCSI Vendor
SCSI Product
SCSI Revision
Storage Serial Number
Physical Drive Number
Drive Letter
Reported Capacity
Bus Type
Connection Speed

Niet iedere USB-stick levert iedere waarde. Serienummers kunnen ontbreken, dubbel voorkomen of op USB- en opslagniveau verschillend worden gerapporteerd. Fabrikanttekenreeksen kunnen leeg zijn. Productnamen kunnen algemeen zijn. De software moet rekening houden met onvolledige informatie, in plaats van ervan uit te gaan dat ieder veld altijd beschikbaar is.

De sterkste aanpak is om de beschikbare identificatiecodes te verzamelen, de oorspronkelijke waarden te bewaren en die waarden vervolgens te koppelen aan de prestatie-, capaciteits- of verificatieresultaten die de toepassing produceert.

Nog één punt voordat u verdergaat

Windows 10 biedt verschillende betrouwbare manieren om de VID, PID, SCSI Vendor- en SCSI Product-informatie van een USB-stick te vinden. Apparaatbeheer geeft snel een handmatig antwoord. PowerShell en WMI bieden toegang via scripts. SetupAPI geeft Windows-toepassingen toegang tot de Plug-and-Play-apparaatstructuur, terwijl een rechtstreekse query voor opslageigenschappen informatie ophaalt die bij de fysieke schijf hoort.

De belangrijkste les is dat een USB-opslagapparaat meer dan één identiteit heeft. De USB VID en PID komen uit de USB-enumeratielaag. De waarden SCSI Vendor, Product en Revision komen uit de opslaglaag. Wanneer u slechts op één plaats kijkt, krijgt u mogelijk slechts de helft van de informatie.

Zodra dat onderscheid duidelijk is, beginnen de ogenschijnlijk tegenstrijdige namen die Windows toont logisch te worden. Het apparaat verandert niet noodzakelijk van identiteit. Windows toont eenvoudigweg informatie die uit twee verschillende onderdelen van dezelfde hardware is verzameld.