Cómo saber el USB ID de hardware desde PowerShell y otras herramientas

Si alguna vez has conectado un USB y tu equipo ha empezado a hacer cosas raras, o Windows te ha escupido un mensaje de error misterioso, probablemente el problema esté ligado al identificador de hardware (Hardware ID) del dispositivo USB. Saber localizar ese ID desde PowerShell y otras herramientas integradas en Windows es una habilidad que te puede ahorrar muchos dolores de cabeza, sobre todo en entornos empresariales donde no se permite instalar software de terceros.

Además, en muchas empresas es obligatorio controlar qué dispositivos USB se conectan, registrar sus IDs y tener trazabilidad por motivos de seguridad y cumplimiento normativo. Desde evitar fugas de información hasta frenar la entrada de malware por un pendrive infectado, todo pasa por identificar bien cada dispositivo. Aquí vas a ver, con bastante detalle, cómo funciona el HWID, cómo obtener el USB ID con PowerShell y otras herramientas, y cómo usar esa información tanto para diagnosticar problemas como para automatizar el rastreo de dispositivos.

Qué es el Hardware ID (HWID) y por qué te debería importar

El Hardware ID o HWID es un identificador digital único asociado a cada componente físico de tu equipo: placa base, disco, tarjeta gráfica, adaptadores de red, controladoras USB, etc. A menudo se le llama “huella digital” del dispositivo, porque sirve para diferenciarlo del resto incluso cuando dos equipos son aparentemente iguales.

En un PC típico, el sistema operativo combina los HWID de varios componentes principales para construir una identidad global de la máquina. Esa identidad es crucial para cosas como las licencias de software que se atan a un equipo concreto, el seguimiento de activos de IT y muchos procesos de seguridad que necesitan asegurarse de que un programa solo se ejecuta en hardware autorizado.

Este identificador no se inventa Windows porque sí: cada pieza de hardware lleva su propio ID grabado en el firmware (por ejemplo, en la EEPROM del dispositivo). El sistema operativo lo lee, y a partir de esa información genera cadenas de identificador que luego aparecen en el Administrador de dispositivos, en PowerShell o en comandos como wmic.

Cuando instalas el sistema operativo por primera vez, Windows toma una instantánea de esa configuración de hardware y genera un conjunto de identificadores vinculados a esa máquina. Si después cambias algo grande, como una placa base, el conjunto de HWID puede cambiar lo suficiente como para que se active de nuevo la verificación de licencias o incluso que se requiera reactivación del sistema en algunos productos.

Cómo se construye el identificador de un dispositivo USB

En el caso de los dispositivos USB, el HWID se deriva de un descriptor muy concreto: el descriptor de dispositivo USB (USB_DEVICE_DESCRIPTOR). Es una estructura de datos que todo dispositivo USB debe proporcionar y que describe sus características básicas: clase, versión de USB soportada, fabricante, producto, etc.

Dentro de ese descriptor hay dos campos clave: idVendor e idProduct. El primero identifica al fabricante (Vendor ID o VID), y el segundo al modelo concreto del producto (Product ID o PID). Con esos valores, Windows construye las cadenas tipo USB\VID_XXXX&PID_YYYY… que luego ves como “Hardware Ids” en el Administrador de dispositivos.

Por ejemplo, una webcam USB de Microsoft puede tener algo como idVendor = 0x045E (Microsoft) y idProduct = 0x0728. Ese par de valores, junto al número de versión del dispositivo (bcdDevice) y otros campos, se combinan para formar los hardware IDs y compatible IDs con los que Windows empareja el driver correcto.

El campo bcdUSB del descriptor indica la versión de la especificación USB a la que se ajusta el dispositivo (por ejemplo, 0x0200 para USB 2.0). Esto ayuda a la pila de controladores USB a saber cómo comunicarse con el dispositivo, qué velocidades soporta y qué opciones de configuración tiene disponibles.

Un detalle importante es que un dispositivo USB no debe cambiar la información de su descriptor mientras esté conectado, ni siquiera cuando cambie de estado de energía. Lo que sí puede ocurrir es que muestre distinta información si se conecta a alta velocidad frente a velocidad completa, pero eso se decide en el momento de la conexión.

Desde el lado de los controladores, el host obtiene este descriptor mediante una transferencia de control GET_DESCRIPTOR dirigida al dispositivo. En Windows, los drivers en modo kernel (KMDF/UMDF/WDM) pueden solicitar formalmente ese descriptor a través de URBs (bloques de solicitud USB) o API del framework, pero eso ya es terreno de desarrollo de drivers, no de administración vía PowerShell.

Ver el Hardware ID USB con herramientas gráficas de Windows

Antes de meternos en PowerShell, conviene recordar que Windows ofrece varias formas gráficas muy directas de ver los HWID de cualquier dispositivo. Son especialmente útiles cuando solo necesitas identificar un aparato concreto.

1. Administrador de dispositivos

La forma más rápida, sin escribir ni una línea de código, es usar el Administrador de dispositivos de Windows. Es válido para cualquier tipo de hardware, incluidos dispositivos USB de almacenamiento, impresoras, webcams, etc.

• Abre el Administrador de dispositivos con Win + X y eligiendo “Administrador de dispositivos”, o buscando “devmgmt.msc”.
• Localiza el componente, por ejemplo en “Controladoras de bus serie universal” o “Unidades de disco” si es un pendrive.
• Haz clic derecho sobre el dispositivo problemático y entra en Propiedades.
• Ve a la pestaña Detalles.
• En el desplegable “Propiedad”, selecciona Id. de hardware (Hardware Ids).

Verás una lista de cadenas; la más específica suele incluir VID, PID y a veces el número de serie o SUBSYS. Esas cadenas son las que luego puedes usar en scripts o búsquedas de drivers, copiándolas tal cual.

2. Símbolo del sistema con WMIC

Si prefieres una opción en consola pero aún no quieres tocar PowerShell, puedes tirar de wmic (en versiones modernas está deprecado, pero todavía lo encontrarás en muchos equipos):

wmic path win32_pnpentity get name, deviceid

Este comando muestra todos los dispositivos Plug and Play y sus DeviceID, que son precisamente los IDs de hardware que nos interesan. Luego puedes filtrar visualmente o volcar la salida a un fichero y procesarla.

3. Aplicaciones de terceros (cuando se permite)

En entornos donde sí está permitido, es habitual utilizar herramientas como CPU-Z, Speccy o HWiNFO para obtener una radiografía completa del sistema, incluidos HWID de muchos componentes. Sin embargo, en muchas empresas esa opción está vetada, así que PowerShell se convierte en la navaja suiza aceptada por políticas de seguridad.

Obtener el USB ID de hardware desde PowerShell

PowerShell incluye cmdlets muy potentes para ver y filtrar información sobre dispositivos Plug and Play. A efectos de HWID, el más interesante es Get-PnpDevice, aunque también se siguen usando clases WMI antiguas en algunos scripts heredados.

Listar hardware IDs con Get-PnpDevice

Para ver los identificadores de todos los dispositivos activos del sistema puedes usar:

Get-PnpDevice -PresentOnly | Select-Object -Property Name,InstanceId

Este comando devuelve una tabla con el nombre amigable del dispositivo y su InstanceId. Ese InstanceId es precisamente la cadena de hardware ID (o muy cercana) que luego puedes relacionar con errores, eventos del sistema o búsquedas de drivers.

Si quieres centrarte solo en dispositivos PCI, por ejemplo, podrías filtrar con:

Get-PnpDevice | Where-Object { $_.InstanceId -match ‘^PCI’ } | Select-Object FriendlyName, InstanceId

Y para los dispositivos USB, puedes usar un filtro similar sobre la cadena de InstanceId, cambiando el prefijo:

Get-PnpDevice | Where-Object { $_.InstanceId -like ‘USB\VID_*’ } | Select-Object FriendlyName, InstanceId

Casos reales: identificar un USB problemático por su ID

Un escenario muy habitual es el siguiente: tu PC se cuelga, miras el Visor de eventos y te encuentras una referencia a un dispositivo tipo «USB\VID_1F75&PID_0917\8&31abfd78&0&3». Recorres el Administrador de dispositivos buscando ese ID y no hay manera de saber qué es concretamente.

Ejemplo práctico: En esas situaciones, es muy útil usar PowerShell para cruzar la información. Por ejemplo, puedes intentar localizar cualquier PnP device cuyo InstanceId empiece por ese patrón:

Get-PnpDevice -InstanceId ‘USB\VID_1F75*’

Si esto no devuelve nada (a veces pasa si el dispositivo ya no está conectado), puedes consultar el historial de dispositivos USB mediante WMI o, cuando esté permitido, con herramientas como USBDeview que muestran todos los dispositivos que alguna vez se conectaron, incluyendo fechas y puertos.

Ver propiedades: En el caso de que obtengas resultados, puedes ampliarlos con:

Get-PnpDevice -InstanceId ‘USB\VID_1F75*’ | Get-PnpDeviceProperty

Esto debería listar todas las propiedades PnP asociadas al dispositivo, aunque si el dispositivo no está presente o hay algún problema de permisos, podrías recibir resultados vacíos o parciales. Para exportar la información a un CSV, la idea sería:

Get-PnpDevice -InstanceId ‘USB\VID_1F75*’ | Get-PnpDeviceProperty | Export-Csv -Path ‘DevDetails.csv’ -NoTypeInformation

Si el CSV aparece vacío, casi siempre significa que ningún dispositivo coincide con el filtro en ese momento o que el cmdlet no pudo leer las propiedades (por permisos o porque el dispositivo no responde).

Ver dispositivos USB de almacenamiento conectados con WMI

Otro caso típico es querer saber qué pendrives o discos USB hay conectados en este momento. Un atajo clásico en PowerShell es apoyarse en la clase WMI Win32_DiskDrive filtrando por tipo de interfaz:

Get-WmiObject Win32_DiskDrive | Where-Object { $_.InterfaceType -eq ‘USB’ }

Si quieres algo más legible y exportable, puedes proyectar solo los campos relevantes con un PSCustomObject:

Get-WmiObject Win32_DiskDrive | Where-Object { $_.InterfaceType -eq ‘USB’ } | ForEach-Object {
[PSCustomObject]@{
DeviceID = $_.DeviceID
Model = $_.Model
Serial = (Get-WmiObject Win32_PhysicalMedia | Where-Object { $_.Tag -eq $_.DeviceID }).SerialNumber
}
}

Aquí, cada objeto personalizado muestra el identificador del dispositivo, el modelo y el número de serie físico (cuando el fabricante lo expone correctamente). Esta es una base muy útil para scripts de inventario y rastreo.

Monitorizar y registrar automáticamente dispositivos USB con PowerShell

En entornos corporativos es muy habitual que el departamento de IT quiera un registro centralizado de todos los dispositivos USB que se conectan a cada máquina: qué dispositivo fue, cuándo se conectó, desde qué equipo, etc. Esto ayuda a detectar dispositivos no autorizados, investigar incidentes de seguridad y cumplir con políticas internas.

Una forma flexible de hacerlo sin licencias adicionales es montar un script de PowerShell que recoja la información relevante de cada dispositivo USB y la envíe a un servidor central a través de una API REST. A partir del ejemplo anterior con WMI, el esquema sería algo como:

Get-WmiObject Win32_DiskDrive | Where-Object { $_.InterfaceType -eq «USB» } | ForEach-Object {
[PSCustomObject]@{
DeviceID = $_.DeviceID
Model = $_.Model
Serial = (Get-WmiObject Win32_PhysicalMedia | Where-Object { $_.Tag -eq $_.DeviceID }).SerialNumber
}
} | ConvertTo-Json | Invoke-RestMethod -Uri «http://servidorcentral/api/usblog» -Method Post

Este bloque recoge todos los discos cuyo interfaz es USB, prepara objetos con los datos clave y los serializa a JSON. Luego, con Invoke-RestMethod, envía ese JSON a un endpoint HTTP en tu servidor de registros. A partir de ahí, la imaginación (y los requisitos de seguridad) mandan: puedes añadir el nombre del equipo, el usuario de sesión, la fecha y hora exactas, etc.

Para una monitorización continua, el script se suele combinar con el Programador de tareas de Windows para que se ejecute al inicio del sistema o al iniciar sesión, o bien se puede crear un servicio que vigile eventos del sistema relacionados con conexiones USB y dispare el envío en tiempo real.

Crear una API REST sencilla para registrar los datos USB

Para recibir los datos que envía el script de PowerShell necesitas un pequeño servidor web con una ruta preparada para aceptar peticiones POST con JSON. Una forma muy rápida de hacerlo es usando Python con Flask, que permite levantar un endpoint con pocas líneas.

La idea básica es esta:

from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route(‘/api/usblog’, methods=[‘POST’])
def log_usb_data():
data = request.get_json()
if not data:
return jsonify({«error»: «No se enviaron datos»}), 400
with open(«usb_log.txt», «a») as log_file:
log_file.write(f»{data}\n»)
return jsonify({«message»: «Datos recibidos correctamente»}), 200
if __name__ == ‘__main__’:
app.run(host=’0.0.0.0′, port=5000)

Con esto, cada llamada desde tus scripts de PowerShell acabará añadiendo una línea con los datos del dispositivo USB al archivo usb_log.txt. Evidentemente, en un despliegue real querrás enviar esos datos a una base de datos, añadir autenticación, cifrar el tráfico con HTTPS, etc., pero como punto de partida es más que suficiente.

Requisitos: Los pasos básicos para ponerlo en marcha serían:

• Instalar Flask con pip install flask en tu servidor Python.
• Guardar el código en un server.py y lanzarlo con python server.py.
• Configurar la URL en los scripts de PowerShell para que apunten a http://IP_DEL_SERVIDOR:5000/api/usblog.

A partir de ahí, cualquier equipo que tenga permiso para contactar con ese servidor podrá enviar su inventario de dispositivos USB de forma periódica o bajo demanda.

Programar scripts USB en el arranque de Windows

Para que todo este sistema sea práctico, es importante que el script de PowerShell se lance automáticamente sin que nadie tenga que acordarse de ejecutarlo. Windows ofrece dos caminos muy usados: Programador de tareas y carpeta de Inicio.

Usar el Programador de tareas

Configuración rápida: Con el Programador de tareas (Task Scheduler) puedes configurar la ejecución en respuesta a distintos eventos del sistema:

• Abre el Programador de tareas y elige “Crear tarea”.
• En la pestaña “General”, da un nombre como “Rastreo USB” y marca “Ejecutar con los privilegios más altos”.
• En “Desencadenadores”, añade uno para “Al iniciar el sistema” o “Al iniciar sesión”, según te interese.
• En “Acciones”, selecciona “Iniciar un programa” y apunta a powershell.exe con parámetros tipo -NoProfile -ExecutionPolicy Bypass -File «C:\ruta\script.ps1».
• Guarda y comprueba que la tarea queda habilitada.

Con esto te aseguras de que el monitoreo arranca cada vez que se inicia el equipo y de que el script puede acceder a toda la información necesaria, siempre que cuente con los permisos adecuados.

Usar la carpeta de Inicio con un .bat

Otra opción más simple, aunque menos granular, es crear un .bat que llame a PowerShell y colocarlo en la carpeta de Inicio del usuario:

powershell.exe -NoProfile -ExecutionPolicy Bypass -File «C:\ruta\del\script.ps1»

Guardas eso como, por ejemplo, rastreo_usb.bat, y lo copias en:

%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup

En cuanto el usuario inicie sesión, Windows ejecutará ese .bat y, con él, el script de PowerShell. Es una solución útil para entornos pequeños o cuando no quieres complicarte con el Programador de tareas.

Rastrear dispositivos USB en ordenadores remotos con PowerShell

En muchas redes corporativas, el problema no es solo saber qué USB se conecta a tu propio equipo, sino tener una visión global de los dispositivos conectados en múltiples ordenadores. Cuando no se pueden usar agentes de terceros, la combinación de PowerShell Remoting y WMI sigue siendo una vía muy válida.

Un ejemplo habitual de script para listar dispositivos USB en varios equipos sería algo así:

$computer = «COMPUTER1″,»COMPUTER2″,»COMPUTER3»
$namespace = «root\CIMV2»
Get-WmiObject -Class Win32_USBControllerDevice -ComputerName $computer -Namespace $namespace |
ForEach-Object { [wmi]($_.Dependent) } |
Sort-Object Manufacturer,Description,DeviceID |
Format-Table -GroupBy Manufacturer Description,Service,DeviceID |
Out-File -Append -FilePath C:\USB\usblist.txt

La idea es: consultar en cada ordenador remoto la relación controlador USB-dispositivo, resolver la propiedad Dependent a una instancia WMI real y luego volcar la información ordenada a un archivo de texto. Si el archivo se queda vacío, hay que revisar permisos, accesibilidad remota, firewall y, por supuesto, la sintaxis del script (espacios o comillas mal cerradas son un clásico).

Con una buena estructura de este tipo de script, puedes lograr un inventario consolidado de dispositivos USB por equipo, agrupados por fabricante y descripción, sin depender de software ajeno.

Uso del USB ID para buscar y mantener drivers

Más allá de la parte de seguridad, conocer y manejar los Hardware ID es clave para encontrar controladores (drivers) adecuados, especialmente cuando Windows no acierta con el genérico o tras una actualización del sistema que deja un dispositivo “muerto”.

Patrón jerárquico: Los IDs de este tipo suelen seguir un patrón jerárquico, sobre todo en dispositivos PCI/PCIe:

• VEN_XXXX identifica el fabricante del chip.
• DEV_XXXX indica el modelo concreto del dispositivo.
• SUBSYS_XXXXXXXX detalla variantes de ensamblador, región, etc.

Para USB, nos encontramos con cadenas tipo USB\VID_XXXX&PID_YYYY y, a veces, con el número de serie. Cuando un dispositivo no funciona tras un cambio en Windows, copiar el HWID exacto e introducirlo en el buscador del fabricante o en bases de datos especializadas es una forma muy precisa de dar con el driver correcto, incluso para hardware antiguo.

Herramientas como Snappy Driver Installer Origin o soluciones comerciales de gestión de controladores suelen basarse precisamente en estos identificadores para emparejar dispositivo-driver con precisión. También existen motores de búsqueda locales capaces de rastrear entre cientos de archivos .inf usando los HWID incrustados en su interior, lo que viene genial cuando tienes una biblioteca de drivers descargados pero no recuerdas cuál corresponde a qué.

Un truco útil para los más organizados es mantener una hoja de cálculo con columnas para VEN, DEV, SUBSYS, descripción y ruta del driver. Con funciones como MID() en Excel puedes extraer esos campos automáticamente de la cadena de HWID, y a la larga eso te ahorra muchas horas de prueba y error cuando te enfrentas a hardware poco documentado.

Herramientas complementarias para trabajar con IDs USB

Aunque el foco aquí está en lo que puedes hacer con PowerShell y utilidades integradas en Windows, conviene conocer algunas herramientas auxiliares —sobre todo si en tu entorno sí se permite instalarlas— que facilitan el trabajo con dispositivos USB.

USB Device Viewer (USBView) de Microsoft

Microsoft ofrece de forma gratuita la utilidad USB Device Viewer (USBView), incluida en el Windows Driver Kit. Proporciona una vista en árbol de todos los controladores y dispositivos USB presentes en el sistema, y muestra idVendor, idProduct y otros campos del descriptor de dispositivo de una forma muy clara.

Pasos: Los pasos básicos son:

• Instalar el paquete correspondiente del Windows Driver Kit y localizar USBView.exe (normalmente en la ruta de depuradores, por ejemplo, Debuggers\x64).
• Ejecutarlo y seleccionar el dispositivo USB en el árbol de la izquierda.
• Consultar en el panel derecho los campos idVendor e idProduct, junto con el resto del descriptor.

Si estás desarrollando drivers, por ejemplo con VISA Driver Development Wizard, estos datos son imprescindibles para indicar al driver qué dispositivos debe manejar según su VID y PID.

Bases de datos online de IDs USB

Cuando no tienes físicamente el dispositivo a mano pero conoces su nombre o parte de su identificador, también puedes recurrir a bases de datos públicas de IDs USB. En este tipo de sitios puedes buscar por modelo, marca o incluso por fragmentos de VID/PID, y te devuelven los valores oficiales de Vendor ID y Product ID registrados para ese dispositivo.

Esto es especialmente útil cuando tienes un HWID parcial, o Windows solo da una descripción genérica, y necesitas confirmar qué VID/PID le corresponde antes de buscar un controlador compatible o de aplicar una política de bloqueo de dispositivos por ID.

Al final, manejar con soltura los USB ID y el resto de identificadores de hardware te convierte en una especie de “detective del sistema”: puedes rastrear qué dispositivo provocó un cuelgue, qué pendrive se conectó a qué equipo y cuándo, o por qué un driver ha dejado de cargar tras una actualización. Con PowerShell como herramienta central, combinado con el Administrador de dispositivos, WMI, alguna utilidad especializada y, si hace falta, un pequeño servidor Flask, tienes todo lo que necesitas para vigilar y controlar el ecosistema USB de tu entorno sin depender de soluciones de terceros pesadas ni de suposiciones poco fiables.