Llave de seguridad USB con IA: guía y riesgos reales

Portada de llave de seguridad USB con IA mostrando la placa Microchip PIC32CM LS00 encendida y el texto ¿Realmente segura?

Construir una llave de seguridad USB con IA a partir de una placa de desarrollo industrial es totalmente viable en una sola tarde, pero confiarle tus contraseñas reales sin auditar el código en C es un error crítico. En este proyecto transformé una tarjeta Microchip PIC32CM LS00 Curiosity Nano+ Touch en un dispositivo USB HID para Linux que solo inyecta credenciales al detectar un patrón táctil secreto.

Lo más revelador del experimento no fue lograr que el sistema operativo reconociera la placa como un teclado físico en cuestión de horas. El verdadero aprendizaje estuvo en analizar qué hicieron por debajo agentes como Codex y Antigravity al estructurar el aislamiento por hardware con ARM TrustZone, y descubrir las brechas de seguridad que la inteligencia artificial pasa por alto cuando prioriza que el código compile a la primera.

El origen del proyecto: del IoTDay al muro de MPLAB en VS Code

Este experimento nació tras asistir al IoTDay, donde el equipo de Microchip me entregó un par de tarjetas de evaluación. Acostumbrado a trabajar con arquitecturas como ESP32, RP2040 o Arduino en mis proyectos de hardware y microcontroladores, nunca me había metido de lleno en el ecosistema industrial de Microchip.

De las dos placas recibidas, mi atención se fue directo a la placa de evaluación PIC32CM LS00 Curiosity Nano+ Touch. Sobre el papel, sus especificaciones pedían a gritos un proyecto de seguridad física:

  • Procesador: ARM Cortex-M23 de 32 bits de bajo consumo.
  • Seguridad en silicio: Soporte nativo para aislamiento por hardware mediante ARM TrustZone.
  • Interfaz física: Panel táctil capacitivo integrado directamente en el PCB.
  • Conectividad dual: Dos puertos USB independientes (uno para depuración y otro conectado directo al microcontrolador).
Placa Microchip PIC32CM LS00 Curiosity Nano+ Touch con panel capacitivo y doble puerto USB
La placa PIC32CM LS00 Curiosity Nano+ Touch integra un sensor capacitivo y doble puerto USB ideal para pruebas HID.

La fricción de configurar el toolchain desde cero

Mi meta para el primer día era el clásico “Hola Mundo” del hardware: hacer parpadear el LED integrado. En plataformas de prototipado rápido eso toma cinco minutos, pero decidí estrenar las nuevas extensiones de MPLAB Tools VS Code en mi estación de trabajo en lugar del IDE tradicional MPLAB X.

Ahí me topé con el primer muro técnico. En microcontroladores de corte industrial no basta con instalar una extensión y presionar compilar: tienes que enlazar manualmente el compilador XC32, descargar los Device Family Packs (DFP) específicos del silicio y definir cómo se comunica el depurador embebido PKOB Nano con los registros del chip.

Tras un buen rato atascado entre rutas de compilación y archivos de configuración sin escribir una sola línea útil en C, cambié de enfoque. Utilicé OpenAI Codex para generar la estructura base del proyecto y destrabar la configuración del compilador.

En pocos minutos el LED estaba parpadeando, pero me dejó una sensación agridulce. Por un lado, tenía un binario funcionando cuyo proceso de arranque no dominaba al cien por ciento; por otro, dejar una placa con superficie táctil y seguridad criptográfica haciendo parpadear un LED era desperdiciar el silicio.

Cómo diseñar una llave de seguridad USB con IA usando Antigravity

Con el entorno de compilación ya operativo, abrí mi entorno en Antigravity con las herramientas de MPLAB cargadas y le propuse a su agente de programación un reto de varias capas. Si ya había usado asistentes para automatizar flujos de programación con IA en Linux, quería comprobar hasta dónde llegaba un agente autónomo diseñando firmware embebido complejo.

El requerimiento técnico que le definí al agente combinaba tres subsistemas físicos trabajando en simultáneo:

  1. Emulación USB HID (Human Interface Device): La placa debía presentarse ante el sistema operativo como un teclado estándar a través de su puerto USB secundario.
  2. Máquina de estados táctil: El bus USB debía permanecer en silencio absoluto hasta que el usuario introdujera una secuencia exacta de toques sobre el sensor capacitivo.
  3. Particionado con ARM TrustZone: La validación del patrón táctil y la cadena secreta debían residir en la región segura del microcontrolador, aisladas del stack USB general.
Estructura del proyecto en Antigravity con MPLAB Tools mostrando los módulos Secure y Non-Secure
Árbol del proyecto generado por el agente separando la lógica de validación y la interfaz de comunicación USB.

En cuestión de minutos, el agente generó la arquitectura modular del proyecto, resolvió las dependencias de los periféricos y dejó listo el binario para flashear mientras yo iteraba las pruebas físicas en mesa.

Arquitectura técnica: los 3 pilares debajo del capó

Para evaluar si esta llave de seguridad USB con IA tiene sentido a nivel de ingeniería, hay que desglosar cómo interactúan sus tres componentes principales dentro del microcontrolador PIC32CM LS00.

1. Doble puerto USB y protocolo USB HID

Una gran ventaja de la familia Curiosity Nano+ es su separación física de buses. El primer conector (Debug USB) pasa por el depurador de la placa para programar la memoria flash y abrir consolas seriales, mientras que el segundo conector (Target USB) va cableado directo a los pines de datos del microcontrolador.

Al implementar la especificación oficial de la clase USB HID en el puerto Target, el firmware envía reportes de teclado estándar (Keycodes). Esto elimina la necesidad de programar o instalar controladores adicionales: cualquier distribución Linux, Windows o macOS lo detecta al instante como un periférico de entrada genérico.

2. Máquina de estados en el sensor táctil capacitivo

En lugar de depender de un pulsador mecánico propenso a toques accidentales en la mochila, el firmware muestrea las variaciones de capacitancia en la superficie táctil de la placa. Internamente opera mediante una máquina de estados finitos con tres fases bien definidas:

  • Estado ESPERANDO (Idle): El periférico USB está enumerado en Linux, pero el buffer de salida está bloqueado y no emite ningún paquete.
  • Estado VALIDANDO (Sampling): Al detectar el primer toque, el temporizador registra los intervalos y el orden de la secuencia introducida por el dedo.
  • Estado AUTORIZADO (Dispatch): Si el patrón coincide con la firma esperada, se solicita la liberación del payload y se inyectan los caracteres por el bus USB.

3. Aislamiento por hardware con ARM TrustZone

En un microcontrolador clásico, todo el firmware corre en un espacio de memoria plano: un fallo o desbordamiento en el driver USB permitiría leer cualquier constante guardada en la memoria. La arquitectura ARM TrustZone para procesadores Cortex-M resuelve esto dividiendo el silicio en dos mundos aislados por hardware:

  • Dominio Seguro (Secure World): Almacena el patrón de desbloqueo, la lógica de validación táctil y la cadena de caracteres protegida.
  • Dominio No Seguro (Non-Secure World): Ejecuta la pila de comunicación USB HID y la lógica general de la aplicación sin acceso directo a las direcciones de memoria segura.

La comunicación entre ambos mundos solo puede ocurrir a través de puntos de entrada estrictamente definidos conocidos como Non-Secure Callable (NSC). En C para arquitecturas ARMv8-M, una puerta de enlace segura hacia el dominio no seguro utiliza el atributo del compilador cmse_nonsecure_entry de la siguiente forma:

/* Ejemplo de punto de entrada Non-Secure Callable (NSC) en ARMv8-M */
#include <arm_cmse.h>
#include <stdint.h>
#include <stdbool.h>

/* [COMPLETAR: firma exacta de la función generada en tu archivo tz_gateway.c] */
bool __attribute__((cmse_nonsecure_entry)) tz_verify_touch_and_get_token(uint8_t *out_buf, size_t max_len) {
    if (!secure_touch_sequence_is_valid()) {
        return false;
    }
    /* Valida que el puntero de destino pertenezca realmente a la RAM No Segura */
    if (cmse_check_pointed_object(out_buf, CMSE_NONSECURE | CMSE_MPU_READWRITE) == NULL) {
        return false;
    }
    secure_copy_credentials(out_buf, max_len);
    return true;
}

Este bloque ilustra cómo el atributo cmse_nonsecure_entry actúa como compuerta controlada y por qué es obligatorio usar la intrínseca cmse_check_pointed_object para evitar que el código no seguro engañe al dominio seguro pasándole un puntero que apunte a direcciones restringidas.

Protocolo de prueba en Linux: verificando el dispositivo HID

Para comprobar el comportamiento real fuera del entorno de depuración, desconecté el cable del puerto Debug y conecté la placa exclusivamente por el puerto Target USB a mi estación con Fedora Linux. Para la prueba cargué una credencial ficticia de demostración.

Prueba en vivo de la llave USB táctil conectada a Linux inyectando texto tras la secuencia capacitiva
Prueba en entorno real: tras validar el patrón táctil, la placa inyecta la cadena de prueba como un teclado USB.

Cuando conectas un periférico USB HID propio en Linux, lo primero es auditar cómo lo enumera el kernel revisando los eventos del bus y la tabla de dispositivos de entrada. Puedes verificarlo desde la terminal con estos comandos:

# 1. Monitorear en tiempo real los mensajes del kernel al conectar el puerto Target USB
sudo dmesg --follow | grep -iE "usb|hid|input"

# 2. Comprobar el identificador Vendor:Product (VID:PID) reportado por el firmware
lsusb

# 3. Listar los periféricos registrados como teclados en el subsistema de entrada
grep -E "Name|Handlers|EV=" /proc/bus/input/devices

El primer comando confirma que el subsistema HID del kernel de Linux asocia la placa al driver usbhid sin errores de descriptor; el segundo muestra el par [COMPLETAR: VID:PID configurado en tu proyecto MPLAB] en el bus, y el tercero verifica su registro como interfaz de teclado (kbd).

Durante el protocolo de prueba validé tres comportamientos físicos:

  1. Enumeración limpia: Reconocimiento inmediato al conectar el cable sin requerir reglas udev personalizadas.
  2. Silencio en reposo: Con un editor de texto abierto y el cursor activo, dejé la placa conectada sin tocar el panel; hubo cero pulsaciones fantasma o ruido eléctrico en el canal.
  3. Disparo por secuencia: Al ejecutar el patrón de toques sobre el área capacitiva, el microcontrolador liberó la secuencia de prueba y la escribió a máxima velocidad en pantalla.

Auditoría de realidad: ¿es realmente segura una llave de seguridad USB con IA?

Ver que una placa que horas antes ni siquiera compilaba ahora interactúa por hardware con Linux es sumamente satisfactorio, sobre todo si buscas integrarla en tu flujo de seguridad y autenticación en servidores Linux. Sin embargo, que un prototipo funcione no significa que sea seguro para almacenar contraseñas de producción.

Advertencia técnica: Un agente de inteligencia artificial optimiza su respuesta para que el proyecto compile sin errores y cumpla el requerimiento funcional visible, no para blindar el modelo de amenazas criptográficas del silicio.

Al revisar con lupa lo que implica generar una llave de seguridad USB con IA, identifiqué cuatro puntos críticos que separan un prototipo funcional de un dispositivo verdaderamente seguro:

Vector de auditoría Lo que entrega la IA por defecto Lo que exige una auditoría real
Aislamiento TrustZone Separación lógica en carpetas Secure y Non-Secure Bloqueo estricto en registros IDAU/MPU y bits de fusibles (Fuses)
Almacenamiento Flash Cadena secreta declarada como constante en texto plano Cifrado en reposo con clave derivada de hardware y protección de lectura
Higiene de memoria RAM Buffers temporales que permanecen en SRAM tras el envío Limpieza explícita (Zeroization) inmune a optimizaciones del compilador
Canal de transmisión Emulación de teclado USB HID enviando caracteres estáticos Protocolo desafío-respuesta (FIDO2/U2F) contra keyloggers

1. Configuración real de TrustZone vs. separación en carpetas

Que tu proyecto en MPLAB tenga un directorio llamado secure y otro non_secure no garantiza aislamiento real si los registros del controlador de atribución de implementación (IDAU) y la unidad de protección de memoria (MPU) dejan permisos permisivos. Además, si el puerto de depuración SWD sigue abierto en los bits de configuración (Fuses), cualquiera con acceso físico al conector Debug podría volcar la memoria.

2. Almacenamiento en memoria Flash y cifrado en reposo

Los agentes de IA suelen declarar las contraseñas o tokens como un simple arreglo const char[] dentro del código fuente para salir del paso. Si inspeccionas el binario compilado con herramientas como strings o objdump, la clave aparece legible en texto plano lista para ser extraída de un volcado de Flash.

3. Limpieza de buffers temporales en la memoria RAM

Cuando el dominio seguro autoriza el envío y copia temporalmente los caracteres al buffer de transmisión USB, esos bytes quedan residentes en la memoria SRAM incluso después de enviarse el paquete. Si usas un memset() convencional al final de la función, el compilador en niveles de optimización altos (-O2 o -O3) puede eliminarlo por considerarlo código muerto (“dead store optimization”).

En una auditoría de código en C de bajo nivel, debes forzar el borrado seguro de la memoria RAM utilizando punteros volatile antes de salir de la rutina de transmisión:

/* Función de limpieza segura en RAM que el compilador no puede optimizar ni omitir */
#include <stddef.h>
#include <stdint.h>

void secure_zero_memory(void *v, size_t n) {
    volatile uint8_t *p = (volatile uint8_t *)v;
    while (n--) {
        *p++ = 0;
    }
}

Al calificar el puntero con volatile, obligas al compilador XC32 a generar las instrucciones reales de escritura de ceros en cada dirección de la SRAM inmediatamente después de que el periférico USB vacía el buffer.

4. La limitación intrínseca de un teclado USB HID

Por último, existe una limitación de diseño que ningún blindaje en el microcontrolador puede evitar por sí solo: el dispositivo inyecta una cadena de caracteres estática como si la teclearas a mano. Si conectas esta placa en una computadora comprometida con un keylogger por software, el malware capturará la contraseña en el instante en que se dispare la secuencia táctil.

Por esta razón, mientras que los teclados de macros y controladores USB personalizados usan HID por comodidad, las llaves criptográficas comerciales implementan protocolos de desafío-respuesta (como FIDO2/WebAuthn), donde la clave privada jamás abandona el chip y cada inicio de sesión genera una firma matemática única.

Preguntas frecuentes sobre crear una llave de seguridad USB con IA

¿Es seguro usar una llave de seguridad USB con IA para guardar contraseñas reales?

No sin antes realizar una auditoría completa del código en C y de los registros del microcontrolador. Los agentes de IA generan estructuras funcionales rápidamente, pero suelen almacenar cadenas en texto plano en la memoria Flash y omitir el bloqueo de lectura por hardware.

¿Qué diferencia hay entre una llave USB HID casera y una llave FIDO2 como YubiKey?

Una llave basada únicamente en teclado USB HID inyecta una cadena de texto estática que puede ser interceptada por un keylogger en el equipo host. En cambio, una llave FIDO2 ejecuta un protocolo criptográfico de desafío-respuesta donde la clave privada nunca sale del elemento seguro.

¿Qué aporta ARM TrustZone en el microcontrolador PIC32CM LS00?

ARM TrustZone divide el hardware del procesador Cortex-M23 en dos regiones aisladas: un entorno Seguro (Secure) y otro No Seguro (Non-Secure). Bien configurado, impide que un fallo en el stack de comunicación USB pueda leer la memoria donde residen las credenciales y la validación táctil.

¿Se necesitan drivers en Linux para usar el PIC32CM LS00 como teclado USB?

No necesitas instalar ningún controlador adicional. Al programar el puerto Target USB bajo el estándar oficial USB HID, el kernel de Linux lo reconoce de forma nativa e inmediata como un dispositivo de entrada estándar.

¿Se puede programar la placa PIC32CM LS00 directamente desde Visual Studio Code?

Sí, mediante el paquete oficial de extensiones MPLAB de Microchip para Visual Studio Code. Aunque requiere configurar el compilador XC32 y los paquetes de dispositivo (DFP), permite compilar y depurar sin depender del clásico MPLAB X IDE.

¿Qué precauciones de código en C debo revisar tras generar firmware con IA?

Debes verificar cuatro puntos críticos: que los límites de memoria IDAU/MPU en TrustZone estén activos, que los punteros de entrada se validen con cmse_check_pointed_object, que los buffers sensibles en RAM se limpien usando punteros volatile y que el puerto de depuración quede protegido.

El punto de partida: velocidad de IA con criterio de ingeniería

La inteligencia artificial es una herramienta extraordinaria para derribar la barrera de entrada de un ecosistema complejo como MPLAB en una sola tarde y llevar una idea desde un simple LED hasta un prototipo funcional. Pero la IA te da velocidad de ejecución, nunca criterio de seguridad: comprender qué pasa en los registros del silicio y en el código en C sigue siendo nuestra responsabilidad.

Este prototipo es apenas la primera fase. El siguiente paso será meterme a fondo en el código de bajo nivel para auditar los permisos de TrustZone, cifrar el almacenamiento y blindar la placa sin depender a ciegas de ningún agente.

Si quieres ver las pruebas reales en mesa, el comportamiento del sensor táctil y cómo se dispara la inyección HID en vivo, reproduce el video al inicio de este artículo y suscríbete al canal de YouTube Human Technology. Además, únete a nuestra comunidad de Telegram para compartir ideas sobre qué otro proyecto o auditoría te gustaría ver con estas placas de Microchip.