Analysis
Locate keyslot12 and access Trusted OS (Tegra firmware)
- Analysis:
- Inspected firmware image, parsed GPT-like layout, identified TOS/eks offsets, parsed EKS structure and located TOS/TA code regions.
- Conclusion:
- Keyslot layout and EKS format confirmed; EKS is sealed (unit fused) so keyslot12 accessible only via Trusted OS runtime; RCM can be forced by PMC SCRATCH0 bit (
Tools: todo_write, run_sandbox, web_search, write_file, edit_file
Run it yourselfQuiero saber donde se encuentra la keyslot12. Y saber como puedo acceder al Trusted OS. Pero confirma donde esta.
Voy a analizar el archivo para confirmar qué es y dónde están esas piezas. Primero un triage básico.
Es un binario de 64 MiB que file no reconoce. Miro la cabecera y escaneo firmas.
La cabecera no es reconocible (bloque de ~0x100 bytes con alta entropía seguido de ceros), pero en el interior hay ELF ARM, device trees y datos comprimidos. Profundizo: mapa de entropía y búsqueda de cadenas clave.
¡Buen hallazgo! Ya aparecen las pistas clave: tegrabl_* (bootloader NVIDIA), Failed to load TOS, Preparing TLK params failed, failed to clear SE keyslot %d. Es firmware NVIDIA Tegra (T186/TX2 por clk-tegra186.c). Ahora mapeo la estructura completa del archivo.
La imagen ya revela su naturaleza: hay una tabla GPT (backup en el último sector, 0x3fffe00), dos copias del bootloader nvtboot/CBoot (~0x18A000), y lo que parece el Trusted OS (Trusty/TLK) en ~0xE88000-0xF40000 (strings trusty_app_get_keyslot_from_index, platform_register_aes_keyslots). Voy a parsear la tabla de particiones GPT para confirmar las ubicaciones exactas.
Error de longitud del formato, lo corrijo:
La tabla GPT tiene entradas inconsistentes (la partición BMP excede el tamaño del flash), así que voy a identificar el contenido por firmas reales, partición por partición. También reviso la partición eks (Encryption Key Set) y la zona del Trusted OS.
La tabla GPT no coincide con el contenido real (muchas particiones están a 0xFF mientras los binarios están en otros offsets). Voy a mapear con precisión dónde hay datos reales y de qué son.
La estructura real ya está clara: binarios A/B redundantes, un blob de 4 KiB repetido 16 veces (BCT), y una zona con el Trusted OS. Ahora voy a localizar en el código las referencias a keyslots para confirmar el número 12, y a identificar la imagen del TOS.
Los add que referencian esas cadenas están en la zona 0xE80000-0xF40000, no junto a las copias de 0x180000. Necesito ver si es la misma imagen o una imagen distinta (TOS). Comparo y miro la cabecera.
La imagen en 0xE80000 tiene cabecera "GSHV" y contiene el gestor de keyslots de Trusty. Hay dos copias (delta 0x400000). Ahora voy a parsear los device trees (dos pequeños de 825 bytes dentro de la imagen, y otros mayores) buscando nodos de keyslots/TOS, y examino los ELF embebidos.
Los FDT de 825 bytes son configuraciones de "quickboot" (MB1 de Tegra186). Los ELF de 32 bits con segment ARM-EXIDX encajan con Trusty. Ahora identifico las cabeceras de cada imagen embebida y busco magias NVIDIA adicionales.
¡Ahora todo encaja! Cada imagen lleva cabecera GSHV (o NVDA el MB1), hay un BOOT_IMAGE! (kernel) en 0x1780000, y el bootloader de 0x180000 prepara TLK (el Trusted OS). Ahora viene la parte clave: desensamblar el código de keyslots en el bootloader y en el TOS.
Error calling tool 'run_sandbox': Failed to start sandbox: Function 'start' exceeded timeout of 30.0 seconds.
Error calling tool 'run_sandbox': Could not get a usable sandbox within 45s. The command was not run, so retrying it is safe.
El sandbox tuvo un problema temporal. Reintento:
El bootloader puede ser ARM32 o usar pools literales con otra base. Compruebo qué arquitectura es y busco referencias u32:
El cálculo del offset de página debía usar el inicio del payload (+0x18). Corrijo y repito el escaneo en ambas imágenes:
Sin referencias en el bootloader con ese cálculo. Miro directamente el código para determinar la arquitectura del bootloader y de la imagen del TOS:
La imagen del TOS (0xE80000+) es ARM64 confirmado. El bootloader en 0x180000 parece tener más cabecera. Inspecciono la estructura de cabecera de ambas imágenes:
La imagen del bootloader parece tener un prefijo firmado/cifrado. Busco pools literales con el VA de la cadena para deducir la base de carga:
La estructura de cabecera parece ser +0x2DC hasta el payload (el primer prólogo A64 del TOS está en +0x2DC). Verifico desensamblando ahí y escaneando las referencias con el low12 correcto:
¡El bootloader es ARM32 (Cortex-R5/BPMP)! Los bytes xx009fe5 son ldr rX,[pc,#imm] de ARM32. Repito el escaneo de pools literales con el low12 correcto (0x126) para ARM32:
No hay punteros u32 absolutos — probablemente el código usa movw/movt o está alineado de otra forma. Desensamblo como ARM32 y busco movw con las direcciones de las cadenas:
El código ARM32 en 0x1802DC es válido (configuración MMU de arranque). Busco ahora los punteros a cadenas en los pools probando ambas hipótesis de base y listando todos los valores grandes:
El código es Thumb-2. Para resolver la ambigüedad de la base del payload, hago una búsqueda por fuerza bruta del desplazamiento que maximice las referencias coherentes a las cadenas conocidas en ambas imágenes:
La búsqueda por fuerza bruta es demasiado ruidosa. Cambio de estrategia: obtengo la lista completa de cabeceras de imagen y desensamblo directamente las zonas donde se agrupan las referencias al gestor de keyslots del TOS:
El código ARM64 confirma estructuras reales. Antes de seguir, verifico dos hechos externos: la asignación del SBK al keyslot 12 en Tegra y la identidad del formato de contenedor ("GSHV"/"BOOT_IMAGE!"):
Datos externos confirmados: en Jetson TX2 (T186) keyslot 12 = KEK1 (KEK0→13, KEK2→11) según la tabla oficial de NVIDIA, y el EKB/EKS alimenta slots que el TOS limpia tras el arranque. Ahora recupero la base de carga de MB2 con un método de diferencias de punteros, para poder desensamblar el código que limpia keyslots:
Los candidatos son pares Thumb falsos. Pruebo rangos de VA típicos (0x400xxxxx BPMP, 0x500xxxxx, 0x600xxxxx, 0x800xxxxx, 0xC00xxxxx) para punteros que caigan en la zona de strings de MB2:
Escaneo solo los valores realmente alcanzados por instrucciones Thumb ldr rX,[pc,#imm] y busco el clúster de punteros a rodata:
¡Clúster fuerte en 0x5200xxxx con 220 punteros! Eso indica que MB2 está enlazado en VA≈0x52000000. Verifico los punteros exactos a las cadenas de keyslot/TOS:
Ajusto la base: uso solo los valores del clúster 0x5200xxxx (probables punteros reales) contra las cadenas conocidas:
¡Resuelto! K=0x51e7fe70 — la imagen MB2 está enlazada en VA 0x52000000 (payload en file 0x18014C). Todas las referencias cuadran. Ahora desensamblo la función que limpia keyslots y la función load_tos:
¡Hallazgo clave! La función de MB2 en 0x181D70 limpia los keyslots SE 6,7,8,9 en un bucle y después el 14, con el error failed to clear SE keyslot %d. Los slots 11–13 (KEK2/KEK1/KEK0) no los toca — los reserva para el TOS. Ahora verifico en el TOS (ARM64) qué keyslots registra el "TZ world" — las referencias adrp+add son independientes de la base:
Faltaron los casos de immlo=2,3 (bytes superiores 0xD0/0xF0). Corrijo:
Dos referencias reales. Desensamblo la función que registra/verifica keyslots del "TZ world" (0xF18B3C) y la que consulta keyslots de TAs (0xF103B8):
La función de MB2 queda clara. Última verificación: qué nombre de partición usa MB2 para cargar el TOS, y qué hay en el blob BCT inicial (¿contiene el EKB?):
¡Perfecto! MB2 confirma el flujo completo: carga la partición EKS (magic NVEKSP, con validación CRC) → copia claves de EKS a los keyslots SE → carga el TOS (TLK) → limpia keyslots 6-9 y 14. Y la partición eks NO está vacía (44.632 bytes con datos). Busco el blob EKS real:
¡Ahí está! Los blobs EKS están en 0x1700000 y 0x1740000 (par A/B), con magic NVEKSP en +0x194. Es el almacén cifrado de claves que MB2 copia a los keyslots SE. Extraigo la estructura del EKS y localizo la función que lo parsea:
La cabecera EKS está clara (NVEKSP + tamaño 0x250 + hash). Ahora desensamblo las tres funciones clave: la que limpia un keyslot (0x184DB8), la que valida el número de slot (0x184E7C) y la que copia claves del EKS (0x1825b4):
La función 0x184E7C escribe claves en los registros SE (aperture BPMP 0x3AD8800) y rechaza slots > 3; la de limpieza (0x184DB8) valida slots 0–15. Veo la última pieza: el parser de entradas del EKS (0x1825b4) que decide en qué keyslot va cada clave:
La función que copia claves del EKS es 0x1829B8. Última pieza:
Ya tengo el cuadro completo. Escribo el informe al workspace y resumo:
Listo. Te confirmo lo que hay en Nvidia.BIN con evidencia (informe completo en informe_Nvidia.BIN.md):
Qué es el archivo
Es un volcado de 64 MiB del flash de arranque de un NVIDIA Tegra X2 (T186, familia Jetson TX2) — no del X1/Switch. Lo confirman los strings tegrabl_*, clk-tegra186.c, la GPT con particiones TX2 (BCT, mb1, mb2, cpu-bootloader, secure-os, eks, bpmp-fw, sc7…) y el bootloader MB2 enlazado en VA 0x52000000 que desensamblé como Thumb-2.
Keyslot12 — dónde está (confirmado)
No está dentro del archivo: es hardware. "Keyslot 12" es el slot nº12 de claves AES del Security Engine (SE) del chip. En T186, según la documentación oficial de NVIDIA, keyslot 12 = KEK1 (clave de fusible; KEK0=13, KEK2=11). Lo que sí hay en el archivo es el código y los datos que lo gestionan:
| Ubicación | Qué es |
|---|---|
0x180000 (MB2, VA 0x52000000) | 0x184DB8 borra keyslots (valida 0–15); 0x184E7C escribe claves en los registros SE; 0x181D70 limpia los slots 6,7,8,9 y 14 antes de saltar al TOS (deja 10–13, los slots KEK, para el TOS) |
0x1700000 y 0x1740000 (par A/B) | EKS, el almacén cifrado de claves con magic NVEKSP — aquí está la materia que MB2 copia a los keyslots (está cifrada con claves derivadas de fusibles, ilegible sin el dispositivo) |
0xF22950–0xF236B8 (en el TOS) | gestor de keyslots de Trusty: platform_register_aes_keyslots, SE keyslot %d owned by some other TA, trusty_app_get_keyslot_from_index |
La clave del slot 12 (KEK1) se quema en fusibles; su único reflejo en flash es el blob cifrado del EKS. Ojo: si leíste "keyslot 12" en material del Switch (T210), allí el BootROM usa SBK=slot 14 y SSK=15 — la numeración depende del chip.
Trusted OS — dónde está y cómo acceder (confirmado)
- Está en el archivo: TLK/Trusty en
0xE80000–0xF91000, con copia redundante en0x1280000(delta 0x400000). Incluye el kernel TLK (ARM64, desensamblado con éxito), los TAs de usuario como ELF ARM32 (0xF265D0,0xF9292C,0xF9DC88), hypercalls NVGPU y la validación de paramsNVTOSP. La GPT lo declara comosecure-osen 0x578000, pero ese hueco está a 0xFF — el layout real es el que puse arriba. - En el arranque: BootROM → MB1 → MB2 carga EKS → copia claves a los SE keyslots → carga el TOS en el carveout TrustZone con params
NVTOSP→ limpia keyslots → el TOS queda residente en el mundo seguro. - Cómo acceder: corre en TrustZone; desde Linux se comunica por SMC/IPC (en Jetson/Trusty:
/dev/trusty+ endpoints tipc — no hay "login"). Para debug real necesitas JTAG seguro habilitado por fusible. Para análisis estático con este dump:dd if=Nvidia.BIN of=tos_tlk.bin skip=$((0xE80000)) count=$((0x111000))y desensamblarlo como ARM64 (las cabeceras de cada imagen van cifradas con AES, el código no).
Si me dices de qué dispositivo salió el volcado o para qué lo necesitas (extraer claves, emular, portar), puedo profundizar en la parte que te interese.
Necesito extraer las claves, es un sistema de mercedes ntg6
Entendido — Mercedes NTG6 (MBUX) encaja perfectamente: esas unidades usan NVIDIA Parker/Tegra X2 (T186) y el contenedor GSHV/BOOT_IMAGE! es específico del OEM. Antes de decirte qué claves se pueden extraer y cuáles no, verifico tres cosas en el dump: si las imágenes están cifradas con SBK o solo firmadas, qué hay dentro del BOOT_IMAGE!, y qué strings de Mercedes/Harman hay.
Confirmado el origen: strings "NTG6", "Daimler" y "harman" en el dump (Harman fabrica NTG6). Ahora lo decisivo para tu objetivo: determinar si las imágenes están cifradas o solo firmadas/comprimidas (eso decide si las claves son necesarias para leer el firmware):
Dos hallazgos clave que cambian el panorama:
- El kernel (BOOT_IMAGE) NO está cifrado — contiene literales en claro (
nvidia,tegra186-camera-ivc-prot,/tegra/t186) → está solo comprimido (LZ4) y firmado. De hecho, casi todo el firmware está firmado pero sin cifrar. - Dentro del TOS hay un TA de Mercedes "NTG6_SA" (Secure Authentication) con
STORED_APP_PIN_DATA,PKCS5_PBKDF2_HMAC_SHA1,PBKDF2_Hash+ salt — es el módulo de PIN/acceso.
Localizo los ELF de los TAs y extraigo todos los componentes a archivos:
Los TAs identificados: 6 apps Trusty, y el NTG6_SA (PIN/auth) es el ELF en 0xF9DC88. Ahora extraigo todos los componentes a archivos en el workspace:
Todo extraído en extraido/ (8.6 MiB, con manifest.json + SHA256). Ahora la respuesta honesta sobre "extraer las claves" en una NTG6:
La realidad de las claves en esta unidad
Las claves que de verdad importan NO están en el archivo — están en los fusibles del Tegra. Es el diseño de NVIDIA: SBK, KEK0, KEK1 (keyslot 12) y KEK2 se cargan del fuse-bank al Security Engine durante el arranque y el software no puede leerlas de vuelta; solo se usan dentro del chip para derivar (AES-ECB con vector fijo + KDF NIST SP 800-108). Ningún dump de flash contiene esas claves, nunca.
Lo que sí encontré, con evidencia:
| Elemento | ¿Dónde? | ¿Extraíble del dump? |
|---|---|---|
| Firmware completo (MB2, BPMP-FW, TOS/TLK, kernel, TAs) | carvado en extraido/ | ✅ Sí — no está cifrado, solo firmado (el kernel tiene literales LZ4 en claro; el TOS es ARM64 plano) |
| Claves de usuario (EKB) | eks_A/B.bin (NVEKSP) | ❌ Cifradas con clave derivada de KEK2 (fusible) |
Blob cifrado de 261 KiB (0x280000/0x500000) | carvado | ❌ Cifrado |
| Clave pública RSA (verificar imágenes) | en las firmas GSHV | ✅ Se puede derivar de las firmas (no sirve para firmar) |
| Clave privada de firma (Mercedes/Harman) | solo en el OEM | ❌ No está en el dispositivo |
| SBK / KEK0 / KEK1(slot 12) / KEK2 | fusibles → SE | ❌ Imposible por software |
Es decir: para leer y analizar todo el firmware no necesitas ninguna clave — ya te lo he extraído. Las claves solo serían necesarias para descifrar el EKS o re-firmar imágenes modificadas, y eso exige claves de fusible/OEM.
Rutas reales si necesitas esas claves
- Ataque por hardware: el BootROM del Tegra X2 es vulnerable a voltage glitching (investigación pública: arXiv:2108.06131, "The Forgotten Threat of Voltage Glitching on Nvidia Tegra X2"). Es el único camino conocido para sacar claves del SE sin las claves OEM.
- JTAG seguro: si el fusible de debug estuviera habilitado (no lo está en unidades de producción).
- PIN de acceso: si lo que buscas es el PIN (no claves criptográficas), encontré el TA NTG6_SA (
extraido/ta_ntg6_sa.bin): guardaSTORED_APP_PIN_DATAcon PBKDF2-HMAC-SHA1 + salt — el hash almacenado estaría en otra zona del flash (posiblemente la región esparsa0x1F80000+o BMP). PBKDF2-SHA1 es localmente rompible si localizamos el registro. Asumo que se trata de tu propia unidad.
Nota de alcance: estas claves protegen el firmware del sistema multimedia; nada que ver con inmovilizador/arranque del vehículo.
¿Siguiente paso? Puedo: (a) localizar dónde está el STORED_APP_PIN_DATA en el dump y analizar el TA NTG6_SA a fondo, (b) descomprimir el kernel LZ4, o (c) derivar la clave pública RSA de las firmas GSHV. ¿Por cuál empiezo?
Quiero que encuentres la keyslot 12 o la manera de llegar a ella
Voy a darle la caza en serio: localizar en el código dónde se programa/accede el keyslot 12 del SE (los registros concretos) y qué caminos existen para llegar a él. Actualizo el plan:
La primitiva SE queda clara: los comandos van por un mailbox en 0x3AC02BC/0x3AC02C0 (interfaz de comandos del Security Engine vía coprocesador) y el índice de keyslot es un parámetro del comando. Ahora busco todos los llamadores de las primitivas SE y si alguno usa el slot 12, más la base de registros SE en el TOS:
Corrijo el error de sintaxis y afino la búsqueda en el TOS (incluye registros de 32 bits y movk con desplazamiento distinto):
En MB2 los accesos a keyslots solo ocurren vía sus primitivas (índice = parámetro); el #12 que apareció era un ID de carveout, no de keyslot. El TOS no construye constantes SE — recibirá el mapa de registros por DTB. Verifico si el DTB embebido tiene el nodo se@ con la dirección física:
El filtro no encontró nada; busco más ampliamente en las 2134 entradas del DTB:
He terminado la cacería. Esto es lo que hay, todo verificado por desensamblado sobre tu dump:
Dónde está el keyslot 12
No existe como dato en el flash — existe como hardware y como código que lo invoca:
-
Hardware: keyslot nº12 del Security Engine del Tegra X2. En T186 contiene la clave de fusible KEK1 (KEK0→slot 13, KEK2→slot 11, según la tabla oficial de NVIDIA). El BootROM la carga desde los fusibles al arrancar y el SE impide leerla de vuelta.
-
En el firmware (lo que encontré en el código):
- MB2 habla con el SE por una interfaz de comandos vía mailbox (
SE_op @0x183CC4, escribe en0x3AC02BC/0x3AC02C0) y tiene las primitivasclear_keyslot @0x184DB8(valida slots 0–15) ywrite_key_SE @0x184E7C(registros del SE en la aperture BPMP0x3AD8800). - El número de keyslot es un parámetro del comando — no hay un "12" escrito en el código. Comprobé todos los llamadores: MB2 escribe claves del EKS en los slots 0–3 y limpia 6–9 y 14 antes de saltar al TOS.
- Los slots 10–13 (KEK2/KEK1=12/KEK0) los deja programados a propósito para el Trusted OS, que administra su propiedad (
platform_register_aes_keyslots,SE keyslot %d owned by some other TA) y los expone a las TAs vía SMC/hwkey. - El
movs r0,#12que apareció en MB2 resultó ser un ID de carveout de SC7 (falso positivo — lo descarté).
- MB2 habla con el SE por una interfaz de comandos vía mailbox (
La manera de llegar a ella — las rutas reales
| Ruta | Resultado |
|---|---|
| Desde Linux (mundo normal) | Solo puedes derivar con el slot vía SMC→TOS→hwkey (AES-ECB con vector fijo). El SE nunca devuelve la clave cruda — es su mecanismo de protección |
| Meter código propio en el boot chain | Bloqueado: cada imagen GSHV/NVDA lleva verificación SHA+AES de cabecera y firma RSA; para alterar el flash necesitas la clave privada de Mercedes/Harman, que no está en el dispositivo |
| Ataque por hardware | La única vía pública demostrada para leer keyslots de fusible en esta familia: voltage glitching contra el BootROM del Tegra X2 — paper revisado y publicado (arXiv:2108.06131, con montaje, equipo y proceso documentados sobre hardware TX2). Es trabajo de laboratorio serio |
| Vía OEM | Mercedes/Harman tiene el provisioning por unidad (SBK/KEK) — la vía legítima |
| Si tu objetivo real son las claves de usuario (EKS) | Están en extraido/eks_A.bin pero cifradas con una clave derivada de KEK2 (fusible) → misma dependencia |
En resumen: el keyslot 12 se alcanza en tiempo de arranque solo desde el mundo seguro, y su contenido solo sale del chip con un ataque por fallo de hardware o con las claves del OEM. Para analizar el resto del firmware no necesitas ninguna clave — ya está todo extraído en extraido/ y documentado en informe_Nvidia.BIN.md.
Si tu objetivo final es el PIN de la unidad (no claves criptográficas), la vía más corta es el TA ta_ntg6_sa.bin (PBKDF2-HMAC-SHA1 + salt) localizando el registro STORED_APP_PIN_DATA en el flash — dime si vas por ahí y lo rastreamos.
Explicame los metodos Desde Linux (mundo normal) y via OEM.
Tengo accceso root en el mundo normal
Buena base: con root en el mundo normal podemos mapear exactamente qué interfaces existen en esta unidad. Antes de explicarte, verifico en el firmware qué servicios Trusty exponen los TAs y qué driver Trusty lleva el kernel:
El kernel tiene literales que sobreviven (formato lz4-legacy, sin magic) y encontré un TA de secure storage con "storage master key". Descomprimo el kernel para confirmar qué interfaces expone el kernel hacia el TOS:
El LZ4-legacy no casa en esos offsets — hago un último barrido de magias de compresión dentro del BOOT_IMAGE y cierro este apartado:
Ya tengo el cuadro completo. Te explico ambos métodos a fondo, siempre anclado a lo que hay en tu unidad concreta (no en teoría).
Método 1: Desde Linux (mundo normal), con root
Por qué root no basta por sí solo
La cadena es: Linux (A57, mundo normal) → SMC/hypercall → Trusted OS (TLK/Trusty en TrustZone) → Security Engine. El SE y sus keyslots (el 12 = KEK1) viven en el espacio seguro; el interconnect de T186 bloquea el acceso no-seguro a esos registros cuando el TOS está residente. Root = control total de Linux, no del mundo seguro. Todo lo que toque el SE pasará por el TOS, y el TOS decide a quién deja acceder.
Lo que ya confirmé en tu firmware (evidencia, no suposición)
- El TOS tiene un gestor de keyslots con control de propiedad por cliente:
platform_register_aes_keyslots,AES keyslot %d not assigned to client TA,AES keyslot %d not assigned to TZ world,SE keyslot %d owned by some other TA,trusty_app_get_keyslot_from_index. O sea: hay una interfaz SMC/IPC con ACLs por TA. - Hay 6 TAs residentes. Los identificables:
ta_ntg6_sa.bin(PIN con PBKDF2-HMAC-SHA1), un TA de secure storage con "storage master key" (get_storage_key,can't get storage master key), y varios con OpenSSL/PKI. - El kernel va comprimido (contenedor
BOOT_IMAGE!: type=7, ver=0x12, cabecera 0x200, payload 0x29108B sin cifrar — literales visibles). No he podido descomprimirlo aún (no es LZ4-legacy estándar), así que no puedo confirmar si expone/dev/trusty.
Pasos concretos con root (exploración en el dispositivo)
dmesg | grep -iE "trusty|tlk|tee|smc|hwkey"
ls /sys/bus/platform/devices/ | grep -iE "trusty|tee"
ls /dev/trusty* ; ls /dev | grep -iE "nvhost|se|smc|tipc"
mount debugfs; ls /sys/kernel/debug/trusty/ # aquí el TOS anuncia sus servicios TIPC
- Si aparece el bus Trusty/TIPC (
/dev/trusty+ endpoints): los servicios anunciados se abren como nodos. El servicio clave sería un hwkey (protocolo público en L4T: comandos DERIVE/GEN — jamás EXPORT). - Si no hay TIPC: con ejecución de código en kernel (módulo o kexec, según config) puedes emitir SMC crudos y enumerar los function-IDs del TOS (vimos hypercalls
nvg_*en las strings). Un módulo mínimo consmc #0y x0–x7 sirve para sondear. - El experimento concreto con el keyslot 12: si un servicio hwkey acepta peticiones, pedir un DERIVE contra los slots 11/12/13 con el vector fijo por defecto de NVIDIA (
FV = 0xbad66eb4484983684b992fe54a648bb8), y con la clave derivada intentar el descifrado deleks_A.bin(KDF NIST SP800-108, labels "ekb"/"encryption" y "ekb"/"authentication"). Expectativa honesta: el gestor de keyslots tiene pinta de rechazar los slots KEK para clientes del mundo normal ("not assigned to client TA") — pero verificarlo en tu unidad es barato y definitivo. - Lo que no ocurrirá: exportar la clave cruda del slot 12. Ninguna interfaz del mundo normal la expone; el SE bloquea las lecturas de keyslots (NVIDIA obliga a limpiarlos tras el uso precisamente porque el software no puede volver a leerlos).
Resumen del método: root te da visibilidad total del flash y del TOS, acceso a los TAs (incluido el de PIN), y un canal de derivación si el TOS te lo permite. La clave cruda del slot 12 no sale por esta vía.
Método 2: Vía OEM
Cómo funciona el provisioning (esto es lo que "crea" el keyslot 12)
- En fábrica, Harman/Daimler generan claves por unidad: SBK (cifrado de imágenes de arranque), KEK0/KEK1/KEK2 (los slots 13/12/11 del SE) y la user key que acaba empaquetada dentro del EKB/EKS. Se graban en fusibles OTP.
- Cada binario se firma con la clave privada RSA del OEM; el hash de la pública se quema en fusibles. Por eso cualquier flash modificado no arranca sin esa clave.
- Los valores por unidad quedan en la base de datos de provisioning del OEM, ligados al número de serie del módulo/VIN.
Qué te da y qué no
- Las herramientas de ingeniería/servicio (Xentry/DTS y el backend de flashing) llevan las claves por unidad dentro del backend — permiten reprogramar la unidad con imágenes firmadas, pero no te entregan la clave (la operación de firma ocurre en su infraestructura).
- La clave privada RSA jamás sale del entorno del OEM.
Canales legítimos reales
- Servicio oficial Mercedes: reflasheo oficial; casos especiales se tratan internamente con el OEM.
- Programa de security research de Mercedes-Benz (responsible disclosure / investigación colaborativa): la vía formal para que un investigador obtenga material de ingeniería o unidades de prueba.
- Harman como tier-1 fabricante: vía de ingeniería si hay caso de producto.
Para un particular, la vía OEM no es algo que puedas "ejecutar" — es un proceso contractual, no técnico. Es además la única fuente legítima del valor real de KEK1 fuera del chip.
Comparativa directa
| Desde Linux (root) | Vía OEM | |
|---|---|---|
| Alcanza | Derivar con el slot (si hwkey acepta), todo el firmware, TAs, hash de PIN | Reprogramación oficial con imágenes firmadas |
| Contenido del slot 12 | No exportable; derivación probablemente denegada por ACL | El valor existe en el backend, no se entrega |
| Requisito | root (+ kernel module para SMC crudos) | Caso oficial / contrato |
Si quieres, el siguiente paso útil es: descomprimir el kernel (para confirmar si existe /dev/trusty/hwkey y qué servicios anuncia el TOS) y/o que me pases la salida de los comandos dmesg | grep -i trusty y ls /sys/kernel/debug/trusty/ de tu unidad para diseñar el experimento de derivación contra los slots 11/12/13. ¿Por cuál seguimos?
existe algun comando para entrar en el modo trusted?
Buena pregunta — y la respuesta corta es importante: no existe "entrar" al mundo seguro como quien entra a un shell. Te lo explico y te doy lo que sí existe. Primero verifico dos cosas en el firmware: la tabla de funciones SMC que expone el TOS (su dispatcher tiene ~45 entradas que localicé antes) y otro intento de descomprimir el kernel para saber qué canal trae tu unidad:
Verificado. Aquí está la respuesta completa:
No: no existe un "comando" para entrar al modo trusted — y es importante entender por qué
El mundo seguro no es un modo en el que te quedas, es una API a la que llamas. Cada interacción es una llamada SMC: el CPU entra al TOS, ejecuta la función y vuelve a Linux en microsegundos. No hay shell, no hay sesión, no hay "consola trusted". Y el "comando" real — la instrucción smc #0 — solo puede ejecutarla el kernel (EL1 no seguro); desde userspace genera excepción. Por eso, con root el acceso se materializa siempre a través de un driver o un módulo de kernel.
Los canales que puede tener tu unidad (en orden de probabilidad)
1. Driver Trusty (TIPC) — /dev/trusty-ipc-devN — el estándar en T186 con Trusty. Los servicios que el TOS anuncia aparecen como nodos. Diagnóstico:
dmesg | grep -iE 'trusty|tlk|tee|smc'
ls -l /dev/trusty* /dev/tlkm 2>/dev/null
ls /sys/kernel/debug/trusty/ 2>/dev/null # servicios TIPC anunciados
zcat /proc/config.gz | grep -iE 'TRUSTY|TLK|TEGRA_SE'
2. Driver TLK de NVIDIA — /dev/tlkm — NVIDIA tuvo ambos stacks en T186; si existe, su ioctl habla con el TOS.
3. SMC crudo desde kernel — el "comando" real. Si no hay canal, un módulo mínimo:
// smc_probe.c — invoca smc #0 con FID y args desde /dev
static long ioctl(struct file *f, unsigned int cmd, unsigned long arg) {
struct arm_smccc_res res;
struct { u32 fid; u64 a[5]; } req;
copy_from_user(&req, (void __user *)arg, sizeof(req));
arm_smccc_smc(req.fid, req.a[0], req.a[1], req.a[2], req.a[3], req.a[4], 0, 0, &res);
copy_to_user((void __user *)arg, &res, sizeof(res));
return 0;
}
Con eso puedes barrer la API del TOS: he extraído del firmware su dispatcher — 45 funciones SMC (índices 0x00–0x2C, tabla en 0xEA06F4 de la imagen del TOS, handlers en 0xE9127C+offset). La base del FID sale del driver del kernel; con ambos datos tienes el mapa completo de llamadas válidas.
4. Lo que NO es "trusted mode" (por si te lo cruzas): RCM (recuperación USB del BootROM), el recovery de MB2 por UART ni fastboot — son modos del boot chain normal, no del mundo seguro.
Qué te daría "entrar" (expectativas honestas)
| Canal | Qué obtienes |
|---|---|
| Servicios TIPC / dispatcher SMC | Llamadas a los 43 handlers: el TA de PIN (NTG6_SA), el TA de secure storage (master key del almacenamiento), derivaciones de keyslots |
| Slots 11/12/13 (KEK) | Solo derivación, y sujeta a las ACL del gestor (not assigned to client TA) — la clave cruda no sale por diseño |
| "Un shell dentro del TOS" | No existe |
Pendiente que desbloquea todo esto: descomprimir el kernel (el payload de BOOT_IMAGE! no es LZ4-legacy estándar — sigo con ello), porque ahí se ve con exactitud qué driver trae tu unidad y la base de FIDs del dispatcher. Si me pasas la salida de los comandos de diagnóstico de arriba desde tu unidad, te digo en qué canal estás y diseñamos la prueba contra el dispatcher. ¿Avanzamos por ahí?
Y algun comando para entrar en el modo RCM?
RCM es otra cosa distinta del mundo seguro — te explico qué es, cómo se entra de verdad, y qué alternativas software tienes en esta unidad. Antes verifico un detalle interesante que vi en el dump: MB2 tiene strings de "recovery boot chain" y la GPT declara una partición BMP (bootloader message) — miro si hay una cadena de recuperación/recovery en el flash:
Confirmado con evidencia del dump: tu unidad es la board nvidia,t186-vcm31-cuba (Mercedes NTG6, árbol Yocto ntg6src/build-yocto-tegra-t18x-swpf), y sí existe una "cadena de arranque de recuperación" — MB2 tiene Resetting device for recovery boot chain y en el flash hay imágenes BOOT_IMAGE! con CBoot dentro que dicen going to trigger recovery (0x209B000). Con eso, la respuesta:
¿Hay un comando para entrar en RCM? — No, y hay que entender por qué
RCM no es un modo del sistema operativo: es el BootROM esperando por USB justo tras el reset. Como el SO ni siquiera existe todavía, no puede haber un reboot --rcm. Se entra de dos maneras:
| Método | Cómo |
|---|---|
| Hardware (strap) | Un pin/strap de recuperación asertado durante el power-on (en la placa NTG6 suele ser un punto de test, no un botón) |
| Fallo de arranque | Si el BootROM no encuentra/valida BCT+MB1 en ningún dispositivo, cae en RCM (el clásico "bloquear el eMMC al reset") |
Una vez dentro, la unidad aparece por USB como dispositivo NVIDIA APX (VID 0955) y se habla con él mediante tegraflash.py/nvflash (L4T) o tegrarcm.
Y la advertencia que importa en tu caso: esta unidad está fused (producción). En Tegra fused, RCM solo acepta imágenes firmadas por el OEM — no es una puerta a ejecución arbitraria de código. Te serviría para recuperar/reflashear con los binarios firmados de Mercedes, no para extraer claves.
Lo que SÍ puedes hacer desde Linux con root en esta unidad (más prometedor que RCM)
Como vimos, tu firmware tiene un mecanismo propio de "cadena de recuperación" disparado por software:
1. Buscar quién escribe el flag de recovery — la unidad debe tener un servicio de actualización/recuperación que lo activa:
systemctl list-units | grep -iE "update|recovery|ota|swdl"
grep -rE "recovery|boot_chain|BCB" /etc/systemd/system /usr/bin 2>/dev/null | head
2. Leer/escribir el registro de boot-control en el flash — la región 0x1F80000+ del dump tiene un patrón de registros 1KB que encaja con la partición BMP (bootloader message) de la GPT. Con root: localiza la partición BMP en /dev/mmcblk* o /dev/mtd*, saca una copia antes de tocarla, y busca el bloque de control (slot activo, reintentos, flag recovery). Escribir ese flag + reboot te metería en la cadena de recuperación OEM (firmada, pero un entorno distinto al principal).
3. Viaje clásico por PMC (a prueba y error): módulo de kernel que escribe el scratch de reset del PMC y hace warm-reset — en Tegra algunas plataformas honran un "reboot to recovery/RCM" por ahí. En tu unidad depende de cómo lo configuró MB1, es testeable pero no garantizado.
Recomendación de orden
- Primero la cadena de recuperación OEM por software (bandera en BMP + reboot) — es lo más cercano a un "comando para entrar" que existe, y está claramente soportado por tu firmware.
- RCM por hardware (strap/punto de test) solo si quieres la vía del BootROM — con la expectativa de que solo aceptará binarios firmados por Mercedes.
- El mundo seguro sigue siendo lo mismo: se invoca por SMC, no se "entra".
Si me pasas la salida de los comandos del punto 1 y el volcado de la partición BMP de tu unidad (dd if=/dev/mmcblkXpY | sha256sum + primeros 4 KB en hex), te decodifico el bloque de control y te digo exactamente qué campo escribir para el reboot en recovery. ¿Vamos por ahí?
sh-3.2# systemctl list-units | grep -iE "update|recovery|ota|swdl" swdl.mount loaded active mounted /swdl audio_swdl.service loaded active running Audio SWDL swupdateinstaller.service loaded active running SWUpdate Installer swupdateinventory.service loaded active running SWUpdate Inventory swupdatemanager.service loaded active running SWUpdate Manager swupdateomadm.service loaded active running SWUpdate OmaDMService swupdatepartitionmounter.service loaded active running SWUpdate Partition Mounter swupdatevupagent.service loaded active running SWUpdate VupAgent systemd-update-utmp.service loaded active exited Update UTMP about System Boot/Shutdown swdl.slice loaded active active Software Download Slice swdl.target loaded active active swdl.target sh-3.2# grep -rE "recovery|boot_chain|BCB" /etc/systemd/system /usr/bin 2>/dev/null | head
/etc/systemd/system/mnt-share.mount:After=onoffmmb.service patholife-recovery.service /etc/systemd/system/patholife-recovery.service:Description=Patho Life recovery /etc/systemd/system/sysinit.target.wants/patholife-recovery.service:Description=Patho Life recovery /etc/systemd/system/sysinit.target.wants/encrypted-var-partition.service:After=dev-disk-by\x2dpartlabel-VAR.device patholife-recovery.service patholife-normalflash-recovery.service local-fs.target tos_daemon.service /etc/systemd/system/sysinit.target.wants/encrypted-var-partition.service:Wants=patholife-recovery.service patholife-normalflash-recovery.service local-fs.target tos_daemon.service /etc/systemd/system/sysinit.target.wants/patholife-normalflash-recovery.service:Description=Patho Life normal-flash recovery /etc/systemd/system/sysinit.target.wants/pers-setup.service:After=pasbackupdaemon.service patholife-recovery.service /etc/systemd/system/sysinit.target.wants/pers-setup.service:Requires=pasbackupdaemon.service patholife-recovery.service /etc/systemd/system/encrypted-var-partition.service:After=dev-disk-by\x2dpartlabel-VAR.device patholife-recovery.service patholife-normalflash-recovery.service local-fs.target tos_daemon.service /etc/systemd/system/encrypted-var-partition.service:Wants=patholife-recovery.service patholife-normalflash-recovery.service local-fs.target tos_daemon.service sh-3.2#
Muy buen resultado — ese output cambia el mapa. Te interpreto lo que significa y te doy el siguiente lote de comandos, priorizado.
Lo que revela tu salida
1. La joya: tos_daemon.service. Mira la línea de encrypted-var-partition.service:
After=... patholife-recovery.service patholife-normalflash-recovery.service local-fs.target tos_daemon.service
tos_daemones el puente userspace ↔ Trusted OS de tu unidad. Yencrypted-var-partition(una partición/varcifrada, partlabelVAR) espera a ese daemon — es decir: el /var cifrado se descifra con claves gestionadas por el Trusted OS. Casi seguro vía el TA de "storage master key" que encontramos en el firmware (get_storage_key,can't get storage master key).- Esto también responde tu pregunta anterior: el "canal trusted" de esta unidad probablemente no es
/dev/trusty, sino este daemon propio de Harman haciendo SMCs.
2. El stack SWUpdate (swupdatemanager, swupdateinstaller, swupdatepartitionmounter, swupdatevupagent, swupdateomadm, montado en /swdl) es el framework OTA que escribe las particiones y probablemente arma el flag de la cadena de recuperación (lo del "recovery boot chain" de MB2). Es la vía software para un reboot especial.
3. Ojo, no te confundas: patholife-recovery.service y patholife-normalflash-recovery.service no son la cadena de arranque de recuperación — son reparación de datos de persistencia ("PathoLife" = capa de personalización de Harman, junto con pasbackupdaemon/PERS). Eso no toca el boot chain.
Siguiente lote de comandos (por prioridad)
# 1) EL PUENTE AL TRUSTED OS — lo más importante
systemctl cat tos_daemon.service
# y cuando veas qué binario ejecuta:
ls -l <binario>; strings <binario> | grep -iE "smc|ioctl|/dev/|hwkey|keyslot|derive" | head -40
# 2) Cómo se cifra /var
systemctl cat encrypted-var-partition.service
blkid | grep -i var; ls -l /dev/disk/by-partlabel/
# 3) El framework OTA y su partición de descarga
systemctl cat swupdatemanager.service swupdateinstaller.service swupdatepartitionmounter.service
ls -laR /swdl | head -50
cat /swdl/sw-description* 2>/dev/null | head -80
# 4) Confirmar el canal al mundo seguro
ls -l /dev/trusty* /dev/tlkm /dev/nvhost-* 2>/dev/null
dmesg | grep -iE "trusty|tlk|tee|smc|hwkey" | head -30
# 5) Mapa real de particiones en el eMMC (para ver A/B, recovery, BMP)
cat /proc/partitions; ls /dev/disk/by-partlabel/
Qué esperamos de cada uno
| Hallazgo | Para qué sirve |
|---|---|
Binario de tos_daemon | Nos dice el mecanismo exacto (¿SMC directo? ¿nodo /dev/X? ¿FIDs que usa?) → es la puerta al dispatcher de 43 funciones y a las derivaciones de keyslots |
sw-description + scripts SWUpdate | Cómo escribe el flag de recovery → replicarlo a mano para el reboot en la cadena de recuperación |
partlabel | El layout A/B real del eMMC (dónde están kernel-A/B, recovery, BMP) para volcar el bloque de boot-control |
dmesg//dev | Confirma si existe TIPC o si todo va por el daemon |
Empieza por el punto 1 — con el binario de tos_daemon (y sus strings) tendremos la puerta exacta al Trusted OS de tu unidad, que es lo que hemos estado persiguiendo con el dispatcher de 45 funciones del TOS. Pásame el output y sigo desde ahí.
(Cómo siempre: antes de tocar cualquier partición o flag — dd de respaldo primero, todo lo demás es de solo lectura.)
[[1;34m# /etc/systemd/system/tos_daemon.service[[0m [Unit]
After=dev-tlk_device.device backup.mount Wants=dev-tlk_device.device backup.mount
Description=tos_daemon_service assists secure storage TA with FS operations. Documentation= DefaultDependencies=no
[Service] #the line below is for E20 only - to ensure the storage daemon access ExecStartPre=/bin/chmod 0755 /backup #final solution E21 below, delete the line above after activation #ExecStartPre=setfacl -m "g:keystore:rx" /backup
ExecStartPre=/bin/mkdir -p -m 0770 /backup/data ExecStartPre=/bin/touch /backup/data/softrpmb_dev ExecStartPre=/bin/chmod 0660 /backup/data/softrpmb_dev /dev/tlk_device ExecStartPre=/bin/chgrp -h keystore /dev/tlk_device /dev/mmcblk0rpmb /backup/data /backup/data/softrpmb_dev
ACL
ExecStartPre=/usr/bin/setfacl -m d:g:keystore:rw /backup/data
CAP
Type=simple ExecStart=/usr/bin/tos_storage_daemon --storagedir /backup/data TimeoutStartSec = 0
[Install] WantedBy=sysinit.target
~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ](streamdown:incomplete-link)
¡Bingo! Ese unit file responde la pregunta que llevábamos varias rondas persiguiendo. Te interpreto cada pieza:
Lo que acabas de confirmar
| Pista | Significado |
|---|---|
/dev/tlk_device | Tu unidad usa el driver TLK de NVIDIA (no TIPC de Trusty). Ese nodo de caracteres es el canal NS→mundo seguro: el kernel expone ioctls sobre él para hablar con el TOS. Esto es la puerta que buscábamos |
/dev/mmcblk0rpmb | La partición RPMB real del eMMC (almacenamiento a prueba de manipulación) |
/backup/data/softrpmb_dev | "Soft RPMB" — un fichero normal que emula RPMB. El almacenamiento seguro tiene un espejo respaldado por fichero → se puede leer como bytes con root |
/usr/bin/tos_storage_daemon | Es el proxy de sistema de ficheros para el secure-storage TA: el TA corre en el mundo seguro y le pide operaciones FS que el daemon ejecuta en Linux |
grupo keystore | ACL: solo ese grupo toca /dev/tlk_device, el RPMB y /backup/data — con root estás dentro |
Y encaja con lo que extrajimos del TOS: el dispatcher de 45 handlers (tabla en 0xEA06F4) es precisamente la tabla de SMCs que el TLK driver invoca (el TLK usa un FID tipo REQUEST_SMC que reenvía a esa tabla por índice). Entre los handlers están los de keyslots (platform_register_aes_keyslots, SE keyslot %d owned by some other TA, trusty_app_get_keyslot_from_index) — es decir, el canal para usar el keyslot 12 como oráculo de derivación probablemente ya está abierto por este dispositivo.
Siguientes comandos (en orden)
# 1) El fichero de soft-RPMB: cópialo YA (es el almacenamiento seguro cifrado)
ls -la /backup /backup/data
cp /backup/data/softrpmb_dev /tmp/ && sha256sum /backup/data/softrpmb_dev
ls -l /dev/tlk_device /dev/mmcblk0rpmb
# 2) Descubrir los ioctls exactos que usa el canal TLK (la forma más fiable):
strace -f -e trace=ioctl -o /tmp/tos.strace /usr/bin/tos_storage_daemon --storagedir /backup/data
# (deja correr 3-5 segundos, luego Ctrl+C; el daemon real ya estará corriendo, este es otro proceso)
grep -E "tlk|0x" /tmp/tos.strace | head -40
# 3) Constancias del driver TLK en el kernel
dmesg | grep -iE "tlk|tos" | head -30
zcat /proc/config.gz 2>/dev/null | grep -iE "TLK|TRUSTY"
cat /proc/devices | grep -iE "tlk"
# 4) Qué hace el daemon (strings nos dan los comandos que habla con el TA)
strings /usr/bin/tos_storage_daemon | grep -iE "smc|tlk|ioctl|keyslot|derive|storage|rpmb" | head -40
Qué haremos con eso
- Con los números de ioctl del strace (paso 2) sabemos la ABI exacta del canal — y te preparo un cliente mínimo en C (o Python+ctypes) para
/dev/tlk_device. - Con el cliente, barrer los 45 handlers del dispatcher y localizar el de derivación AES con keyslot: pedir operaciones con el slot 12 (KEK1) usando vectores que controlemos → oráculo de KEK1 (la clave cruda no sale, pero sus derivaciones sí — que es lo único que hace falta para descifrar lo que el sistema cifra con ella).
- Con la derivación de los slots 11/12/13 (FV por defecto de NVIDIA
0xbad66eb4...y variantes) intentar descifrareks_A.biny el contenido del soft-RPMB. - El
softrpmb_devque copiaste en el paso 1 es el contenedor cifrado del storage — junto con el TA de storage (ta_154k.bin) podremos entender su formato.
Nota importante: el daemon de storage es necesario para que monte la /var cifrada — el strace del paso 2 levanta una segunda instancia, si te da conflicto, paréalo con systemctl stop tos_daemon momentáneamente (y vuelve a arrancarlo después), o mejor: extrae los ioctls leyendo el binario con objdump -d /usr/bin/tos_storage_daemon | grep -B2 -A2 ioctl.
Pásame el output del strace (o de las strings) y el hash/tamaño del softrpmb_dev, y te escribo el cliente para el canal TLK con la tabla de los 45 handlers ya mapeada desde el firmware.
sh-3.2# ls -la /backup /backup/data /backup: total 74233 drwxrwxr-x 5 root root 1024 May 12 2024 . drwxr-xr-x 23 root root 4096 Nov 23 2020 .. -rw-rw---- 1 patho system 75980800 May 12 2024 UDX.backup drwxrwx--- 2 root keystore 4096 Jan 1 1970 data drwx------ 2 root root 12288 May 3 2019 lost+found drwxrwx--- 3 root root 1024 Jan 1 00:00 opt -rw-rw---- 1 hsys system 0 Feb 14 2020 setup_done -rw-rw---- 1 hsys system 4672 Jan 1 00:00 tos_data.bck
/backup/data: total 162 drwxrwx--- 2 root keystore 4096 Jan 1 1970 . drwxrwxr-x 5 root root 1024 May 12 2024 .. -rw-r----- 1 sysuser01 keystore 0 Jan 1 00:01 0000000000000000 -rw-r----- 1 sysuser01 keystore 1536 Jan 1 00:01 0000000000000001 -rw-r----- 1 sysuser01 keystore 8960 Jan 1 00:01 0000000000000002 -rw-r----- 1 sysuser01 keystore 1536 Jan 1 00:01 0000000000000003 -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:00 0000000000000004 -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 0000000000000005 -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:00 0000000000000006 -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 0000000000000007 -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:00 0000000000000008 -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 0000000000000009 -rw-r----- 1 sysuser01 keystore 2048 Jan 1 00:01 000000000000000a -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:01 000000000000000b -rw-r----- 1 sysuser01 keystore 0 Jan 1 00:00 000000000000000c -rw-r----- 1 sysuser01 keystore 0 Jan 1 00:00 000000000000000d -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:00 000000000000000e -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 000000000000000f -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:00 0000000000000010 -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 0000000000000011 -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:00 0000000000000012 -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 0000000000000013 -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:00 0000000000000014 -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 0000000000000015 -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:00 0000000000000016 -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 0000000000000017 -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:00 0000000000000018 -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 0000000000000019 -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:00 000000000000001a -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 000000000000001b -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:00 000000000000001c -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 000000000000001d -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:00 000000000000001e -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 000000000000001f -rw-r----- 1 sysuser01 keystore 2048 Jan 1 00:00 0000000000000020 -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 0000000000000021 -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:09 0000000000000022 -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:09 0000000000000023 -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:09 0000000000000024 -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:09 0000000000000025 -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:00 0000000000000026 -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 0000000000000027 -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:09 0000000000000028 -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:09 0000000000000029 -rw-r----- 1 sysuser01 keystore 0 Jan 1 00:00 000000000000002a -rw-r----- 1 sysuser01 keystore 0 Jan 1 00:00 000000000000002b -rw-r----- 1 sysuser01 keystore 2048 Jan 1 00:00 000000000000002c -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 000000000000002d -rw-r----- 1 sysuser01 keystore 2048 Feb 14 2020 000000000000002e -rw-r----- 1 sysuser01 keystore 512 Feb 14 2020 000000000000002f -rw-r----- 1 sysuser01 keystore 1024 Apr 18 2024 0000000000000030 -rw-r----- 1 sysuser01 keystore 512 Apr 18 2024 0000000000000031 -rw-r----- 1 sysuser01 keystore 1024 Apr 18 2024 0000000000000032 -rw-r----- 1 sysuser01 keystore 512 Apr 18 2024 0000000000000033 -rw-r----- 1 sysuser01 keystore 1024 Apr 18 2024 0000000000000034 -rw-r----- 1 sysuser01 keystore 512 Apr 18 2024 0000000000000035 -rw-r----- 1 sysuser01 keystore 1024 Jan 1 00:00 0000000000000036 -rw-r----- 1 sysuser01 keystore 512 Jan 1 00:00 0000000000000037 -rw-r----- 1 sysuser01 keystore 2048 Sep 22 2023 0000000000000038 -rw-r----- 1 sysuser01 keystore 512 Sep 22 2023 0000000000000039 -rw-r----- 1 sysuser01 keystore 0 Feb 14 2020 000000000000003a -rw-r----- 1 sysuser01 keystore 0 Feb 14 2020 000000000000003b -rw-r----- 1 sysuser01 keystore 1024 Feb 14 2020 000000000000003c -rw-r----- 1 sysuser01 keystore 512 Feb 14 2020 000000000000003d -rw-r----- 1 sysuser01 keystore 2048 Mar 14 2024 000000000000003e -rw-r----- 1 sysuser01 keystore 512 Mar 14 2024 000000000000003f -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 0000000000000040 -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 0000000000000041 -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 0000000000000042 -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 0000000000000043 -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 0000000000000044 -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 0000000000000045 -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 0000000000000046 -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 0000000000000047 -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 0000000000000048 -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 0000000000000049 -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 000000000000004a -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 000000000000004b -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 000000000000004c -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 000000000000004d -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 000000000000004e -rw-r----- 1 sysuser01 keystore 0 Jan 1 1970 000000000000004f -rw-rw---- 1 root keystore 0 Jan 1 00:00 softrpmb_dev sh-3.2# cp /backup/data/softrpmb_dev /tmp/ && sha256sum /backup/data/softrpmb_dev e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/softrpmb_dev sh-3.2# ls -l /dev/tlk_device /dev/mmcblk0rpmb brw-rw---- 1 root keystore 179, 16 Jan 1 00:00 /dev/mmcblk0rpmb crw-rwx--- 1 root keystore 10, 60 Jan 1 00:00 /dev/tlk_device sh-3.2# strace -f -e trace=ioctl -o /tmp/tos.strace /usr/bin/tos_storage_daemon --storagedir /backup/data sh: strace: command not found sh-3.2# grep -E "tlk|0x" /tmp/tos.strace | head -40 grep: /tmp/tos.strace: No such file or directory sh-3.2# dmesg | grep -iE "tlk|tos" | head -30 sh-3.2# sh-3.2# zcat /proc/config.gz 2>/dev/null | grep -iE "TLK|TRUSTY"
Trusty
CONFIG_TRUSTY=y CONFIG_TRUSTY_FIQ=y CONFIG_TRUSTY_FIQ_ARM64=y CONFIG_TRUSTY_LOG=y CONFIG_TRUSTY_VIRTIO=y CONFIG_TRUSTY_VIRTIO_IPC=y sh-3.2# cat /proc/devices | grep -iE "tlk" sh-3.2# strings /usr/bin/tos_storage_daemon | grep -iE "smc|tlk|ioctl|keyslot|derive|storage|rpmb" | head -40 ioctl RPMB_READ RPMB_WRITE --storagedir no storagedir specified tlk_device can't configure storage buffer IOCTL_GET_NEW_REQ returned %d RPMB_WRITE: MMC ioctl failed: %s RPMB_READ: MMC ioctl failed: %s /dev/mmcblk0rpmb /data/softrpmb_dev tos_storage_daemon sh-3.2#
Excelente progreso — tres revelaciones importantes en esa salida:
/backup/data/son los objetos de secure storage en claro (nombres0000...0000–004f) — ysoftrpmb_devestá vacío (hashe3b0c442...= 0 bytes): el storage de tu unidad va por ficheros proxy + RPMB real, no por soft-RPMB. Esos ficheros los puedes leer con root AHORA (propietariosysuser01, modo 0640)./dev/tlk_device= misc (10:60) y el kernel llevaCONFIG_TRUSTY=y+TRUSTY_VIRTIO_IPC— el stack TLK/Trusty de NVIDIA está activo.- El daemon habla con el driver vía
IOCTL_GET_NEW_REQ(modelo NVIDIA "Secure Storage Daemon": el TA pide ops por shared memory, el daemon las sirve sobre RPMB/ficheros).
Voy a buscar los números de ioctl exactos del driver TLK en el código fuente del kernel L4T (es público), para escribirte el cliente:
He encontrado la ABI completa del driver — es el protocolo OTE (Open Trusted Environment) de NVIDIA, documentado en el kernel público de L4T. Puntos clave confirmados:
- Ioctls de
/dev/tlk_device(magic't'):OPEN_CLIENT_SESSION(0x10),CLOSE_CLIENT_SESSION(0x11),LAUNCH_OPERATION(0x14), y elSS_CMD(0x30) con sub-comandosGET_NEW_REQ/REQ_COMPLETE— exactamente elIOCTL_GET_NEW_REQque vimos en el daemon. - FIDs SMC del TOS:
TLK_SMC_REQUEST=0xFFFF1000,GET_MORE=0xFFFF1001,ANSWER=0xFFFF1002,OPEN_SESSION=0xFFFF1004,CLOSE_SESSION=0xFFFF1005. - Modelo: sesiones por UUID de TA + operaciones con parámetros (INT/MEM, RO/RW). El TA de keyslots es accesible por ahí.
Preparo el cliente y un script para localizar los UUIDs de los TAs en tu unidad:
Antes de cerrar, busco UUIDs y nombres de "scheme" dentro de los TAs que extraje del TOS — para mapear qué UUID corresponde a cada TA:
El TA de storage confirma dos esquemas: "HW RPMB" y "SW RPMB" — y tus objetos de storage están en /backup/data/ como ficheros. Cierro con el plan completo.
Lo que ya tienes (verificado)
- Los objetos de secure storage son ficheros legibles —
0000000000000000–004f(512/1024/2048 bytes c/u, uno de 8960). Elsoftrpmb_devestá vacío: el esquema activo es el proxy FS + RPMB real. Con root puedes copiarlos todos ahora mismo. - La ABI del canal es el protocolo OTE de NVIDIA (público en el kernel L4T):
- Ioctls en
/dev/tlk_device:OPEN_CLIENT_SESSION(0x10),CLOSE_CLIENT_SESSION(0x11),LAUNCH_OPERATION(0x14),SS_CMD(0x30 → GET_NEW_REQ/REQ_COMPLETE, lo que usa tu daemon). - FIDs hacia el TOS:
0xFFFF1000–0xFFFF1005(REQUEST/GET_MORE/ANSWER/OPEN_SESSION/CLOSE_SESSION). - Modelo: sesión por UUID de TA → operación con command_id + parámetros INT/MEM (RO/RW).
- Ioctls en
- El dispatcher de 45 comandos que extraje del TOS es muy probablemente la tabla de comandos del servicio de keyslots/plataforma — accesible por ese canal.
Herramientas que te acabo de dejar en extraido/
| Fichero | Qué es |
|---|---|
ote_client.h | Cabecera con la ABI OTE completa (structs, ioctls, tipos de parámetro) |
te_tool.c | Cliente: open <uuid> / call <uuid> <cmd> i:val m:fichero M:len / close — compila en la unidad (cc -O2 -o te_tool te_tool.c) para que los números de ioctl salgan correctos según su arquitectura |
find_uuids.sh | Localiza en tu unidad qué procesos tienen /dev/tlk_device abierto y los UUIDs ASCII incrustados en los clientes |
Comandos a ejecutar en la unidad (orden dado)
# 1) Copia de seguridad del storage (antes de nada)
mkdir /tmp/ss && cp /backup/data/0* /tmp/ss/
# 2) Hexdumps para analizar (pásamelos)
xxd /backup/data/0000000000000001 | head -16
xxd /backup/data/0000000000000002 | head -24 # el de 8960 bytes
xxd /backup/data/000000000000000e | head -8
xxd /dev/mmcblk0rpmb | head -8 # RPMB real (si devuelve datos legibles)
# 3) Ejecuta el scanner de UUIDs
sh find_uuids.sh
# 4) Compilador disponible?
which cc gcc clang || echo "sin compilador"
Qué buscamos con cada cosa
- Los hexdumps (paso 2) me dirán si los objetos están cifrados o en claro. Si el TA usa "get_storage_key" para cifrarlos, será entropía alta; si algún objeto (p.ej. el material del PIN de NTG6_SA,
STORED_APP_PIN_DATA= PBKDF2+salt) está en claro, ahí puede estar la clave ya. - Los UUIDs (paso 3): cada TA tiene su UUID (binario en los clientes Linux, no en los TAs). Con el UUID correcto +
te_toolabrimos sesión contra el TA criptográfico y barrer sus comandos. - El objetivo del canal: con sesión al TA de keyslots, usar el slot 12 (KEK1) como oráculo de derivación (AES-ECB con vector que controlemos) → con esa derivada intentar descifrar
eks_A.bin(KDF SP800-108, FV por defecto de NVIDIA como hipótesis). Las ACL del TOS (not assigned to client TA) pueden frenarnos — pero ahora lo comprobamos empíricamente en 2 minutos en lugar de congelarnos ante la teoría.
Pásame los hexdumps del paso 2 y la salida del find_uuids.sh, y sigo el análisis desde aquí: formato de los objetos (lo reverseo contra ta_154k.bin), y mapeo de comandos del TA criptográfico para la prueba del keyslot 12.
sh-3.2# xxd /backup/data/0000000000000001 | head -16 sh: xxd: command not found
xxd no está en la unidad — usa una de estas alternativas (todas típicas de BusyBox/BusyBox-like):
# 1) Comprueba qué tienes disponible:
command -v xxd hexdump od base64 busybox
# 2) Hexdump con las alternativas (cualquiera de estas):
hexdump -C /backup/data/0000000000000001 | head -16
od -A x -t x1z /backup/data/0000000000000001 | head -16
busybox hexdump -C /backup/data/0000000000000001 | head -16
# 3) Si nada de eso existe, transferencia sin pérdida con base64 (yo lo decodifico aquí):
base64 /backup/data/0000000000000001
Lo que necesito que me pegues (en orden de valor)
# a) huellas de TODOS los objetos (identificación rápida):
sha256sum /backup/data/0*
# b) base64 (o hexdump) de estos concretos:
base64 /backup/data/0000000000000001 # 1536 B
base64 /backup/data/0000000000000002 # 8960 B — el más grande
base64 /backup/data/000000000000000e # 1024 B
base64 /backup/data/000000000000002c # 2048 B
base64 /backup/data/000000000000002e # 2048 B, fecha Feb-2020 (factory)
base64 /dev/mmcblk0rpmb 2>/dev/null | head -40 # RPMB real (probablemente denegado sin clave)
Con el (a) ya puedo clasificar qué objetos son idénticos/vacíos; con los (b) determino si el storage está cifrado con la storage master key (entropía alta) o en claro — y si hay suerte, algún objeto es directamente el STORED_APP_PIN_DATA del TA NTG6_SA o material de claves de usuario.
También te siguen esperando (del plan anterior):
sh find_uuids.sh # UUIDs de TAs y quién tiene /dev/tlk_device abierto
which cc gcc clang # para compilar te_tool.c en la unidad
Pega lo que salga y sigo desde aquí.
sh-3.2# sha256sum /backup/data/0* e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/0000000000000000 6389fb75cfb060acc3e687355a330906491e1898504861b2a2d020554a9814a9 /backup/data/0000000000000001 4318a7270c1fa452f09be4323e755319caa25cc5b83437adda31097a853fc937 /backup/data/0000000000000002 5ea9bd36a9a832a992ded81f25344e081eb7e073c265034b2c71e8fdf6e62c66 /backup/data/0000000000000003 9e10ce4a1abf9016da637d0c1c76e2f4283a8e3cf128e3fc0c9b59f844af8bc2 /backup/data/0000000000000004 3b502239abf31d98b042f24469e85bd6ab4fc52a8a80bf394394f67f41da66b4 /backup/data/0000000000000005 073b1fd98c75ca655e3ae105db3843140e76181287039e1013bd8b27287468b3 /backup/data/0000000000000006 0f73fc0236bde2ec5f34087b8d0a8444146471e30463d56873a68072637322c4 /backup/data/0000000000000007 ecb05f5569049e20d070406ee66300f8e058e42d7797e72ea8c48c0d743476d8 /backup/data/0000000000000008 c018c012e0e83259c03a36d99d928d27ae3caf1406d9984174befcbf10c0f868 /backup/data/0000000000000009 2bd47683e428c96f0aee8e024b3da133abd37e242d7547c5bdf0c8ad522a1694 /backup/data/000000000000000a 2ee8987fbd61f06e767d05473675aa7dc98f52ef55bb1294b6cf79425b53c2e2 /backup/data/000000000000000b e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/000000000000000c e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/000000000000000d c7059d701e8c3b771f91a9586db9957b66caaa7d1984aad3a2943587bd0fddd4 /backup/data/000000000000000e 6fd7161e060408ec8fbdb4becd74091963171d9208b97a98a7020907ed07cfe0 /backup/data/000000000000000f 996cbba8f4b69908302adc3b8987bcdfebf6a5229b673c2b4c32a8b3b8a7d4ab /backup/data/0000000000000010 ade958bc6842f85e2d1bb27431825d0bc064d2eaad63b4215ce99deea9e9ecdb /backup/data/0000000000000011 b5cc9e51f9a7ac4b9df969bfeeddaf089f542cf01ff5daa1d39fdd6b4da13886 /backup/data/0000000000000012 0ea7b0124df93971505a1fbb3bae6ea0d0cff57099989a8c8b71377457642a21 /backup/data/0000000000000013 67ef7d5c64d97466ed5cc08aeccf7e4e2793e5acae6c820c18de24312bbff15d /backup/data/0000000000000014 b90b35f7456fab29e476df7c91b6d8adff2a84ed6933763d9d9d59ffb8ce6457 /backup/data/0000000000000015 dc3c39ec1bbab51546cf9fc8329e424b4c7d69a93c1d591ebb30b044c5c8b6c2 /backup/data/0000000000000016 fa94bc5bb3a3e949c0afce325fa5b750fc1421ef91edb960956956accbe59531 /backup/data/0000000000000017 414f4de900c1d7981966af49027ccc2fe39258b6398c66b749cafed685a36086 /backup/data/0000000000000018 26ef6d571b89489a5bba62d49582c16e6283233e1a25a0bda96f8f9d902b532e /backup/data/0000000000000019 8bfb54c8c522ae56974f441e054b712ed5ef040e035780bbdfdc420a8c2f415b /backup/data/000000000000001a 53a417bf8bf500945f6d0e7406736c096991aa98705f716f4c1d577f2c375e18 /backup/data/000000000000001b 2cbc3ea32916039d79013c6d930b907e302e2cfbad21f8f8c4cbf51323e1796e /backup/data/000000000000001c 2ad83e19e99fef59f392c59d29550feeb2274b7bdf09a24d2626357cb80bc23a /backup/data/000000000000001d c05ea28d9803f1d3d25b7b057171c35455ab098af22eb373de1e50ee1af093fd /backup/data/000000000000001e d5e4aeb9f70176fadd90567bc6d5ae1d600b6f561cce6eed1eca4cbbcc8adb32 /backup/data/000000000000001f ea6965ce951b7f4d32bff712577ea3e85e83107f4824f378a8bf3ce0326017c2 /backup/data/0000000000000020 dda3a43b5c17df93f06047305d18df85ba7f9481c83665a89efb854f3e0a7ef8 /backup/data/0000000000000021 ad1041ccd1b5734467769358136afa1efb2e6c61f5b3b6f8e76cabb4da405027 /backup/data/0000000000000022 5e752c7b4946c4ab6eaac4b2eeb69314e5abb09414d91c0e33ecaecf7fdcf151 /backup/data/0000000000000023 25ada9b1b704fae633647fbcf6032884a5ab3a1abd807e373da6a58a9622c1bc /backup/data/0000000000000024 8ce4464d36d6f6801cf088502f0446661d1674c7bde98e49e9c072a5f635b806 /backup/data/0000000000000025 5931dd647c24d1d25e279cd33b9264d66520ba49134cb01fe32b6f6d986b7bff /backup/data/0000000000000026 8df3ae151c3c353bc6e1087823df818e2392902243cffbfb09a7b643e46229a7 /backup/data/0000000000000027 7d6eb5c54199be06ffa384712b4e81de58238b9f28f7e50f14a9337f8fa0548e /backup/data/0000000000000028 9ff8780a90af13cb7672616ae0a99020f5f451090775607c430f7ef10f82e789 /backup/data/0000000000000029 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/000000000000002a e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/000000000000002b 39c88f2d9fedb9219dfdd160f60be98f2a048eddeca7bd80029fa2243fdb2d55 /backup/data/000000000000002c b1cfe5aa3ac2487a46e5b211fe407cedee6131ab41dfdc0dbbed4c1381625070 /backup/data/000000000000002d a006eb2da4ce4cb722079de7020e4051736d6d4cb8fbbbeed775aaf873d2edb0 /backup/data/000000000000002e 4ebad45241fda766d55c78f3cb347761ed1ce181a90d3441738197ee792fd9a2 /backup/data/000000000000002f 6fc5c4d9805567b76f5dfd528159bcc763af02294366945fe379bcbb7902d782 /backup/data/0000000000000030 274de452e462b80650aa9cb7f5bb6714ae4bd1c72ad9ae8177ff4a2ca4d24904 /backup/data/0000000000000031 f68c10279c1e9f17af461a731a5e769ca21b3e6711f6bd9d91affbbde4c5609f /backup/data/0000000000000032 823ccabece11c66997c6ffa11bf8f6f747e4f219e9053aa598d65c88e5a947d0 /backup/data/0000000000000033 ceb758c4c1a5c04c20d5599d6050c5fcdb443f568c4e667873abfb7496abf9ee /backup/data/0000000000000034 4a2d92d764c56017409e2c6e3c7bde36f0f7a7d9b580b1d1735c8a1ea75cd70c /backup/data/0000000000000035 903d91642d7d64379e5203e71e9b17bbe75c2cc10ebd8b40a9a63ff143696a98 /backup/data/0000000000000036 27c1e9ec001456f8dd125952dc2e59edc5d30be8dbec07a3e062bfedd4525837 /backup/data/0000000000000037 baf780093b739c9774928b0a16dda35bbc3ba9a5bb5cd43a21a421b0ab9f1044 /backup/data/0000000000000038 4504ed83914bd42979c700db042dae81541c19f88c7b8a573cd1b4d2700ee396 /backup/data/0000000000000039 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/000000000000003a e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/000000000000003b 14089e7840cb94d24e4fe9fb0259ad465d1b2e57d0f7dc8704c05511ab5b8a4c /backup/data/000000000000003c 7eae51001762e873ee653c251dd9d61ce9690847ef20e799c380b5bb04f556b8 /backup/data/000000000000003d 3e193ff0b56a2113f9a163dbe518fcd4904853ff664f4e31382a3d843f3e75c3 /backup/data/000000000000003e a055738eed584ab5fe5dd1591d39bef0a77866a7ee83d0b5e981030901a3d929 /backup/data/000000000000003f e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/0000000000000040 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/0000000000000041 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/0000000000000042 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/0000000000000043 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/0000000000000044 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/0000000000000045 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/0000000000000046 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/0000000000000047 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/0000000000000048 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/0000000000000049 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/000000000000004a e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/000000000000004b e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/000000000000004c e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/000000000000004d e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/000000000000004e e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 /backup/data/000000000000004f
Perfecto — ya tengo la radiografía: todos los objetos no vacíos son distintos (cada uno contenido único), y los vacíos (0x00, 0x0c-0x0d, 0x2a-0x2b, 0x3a-0x3b, y el bloque 0x40–0x4f) son ranuras libres — el bloque de 16 al final parece un pool pre-creado (típico para intentos/registros del TA de PIN).
Ahora falta el contenido. Como no hay xxd, prueba estas alternativas — cualquiera me sirve (copia-paste directo):
# Opción 1 (busybox suele traerlo):
hexdump -C /backup/data/0000000000000001 | head -20
# Opción 2:
od -A x -t x1z /backup/data/0000000000000001 | head -20
# Opción 3 (sin pérdida, yo lo decodifico aquí):
base64 /backup/data/0000000000000001
Y un truco para saber si están cifrados SIN volcar nada
Si el contenido es aleatorio/criptográfico, gzip no comprime nada; si es texto/estructura, sí:
for f in 0000000000000001 0000000000000002 000000000000000e 000000000000002c 000000000000002e 0000000000000038; do
o=$(wc -c < /backup/data/$f)
c=$(gzip -c /backup/data/$f 2>/dev/null | wc -c)
echo "$f original=$o gzip=$c"
done
strings /backup/data/0000000000000002 | head -10
strings /backup/data/0000000000000001 | head -6
Interpretación que haremos: gzip≈original → cifrado con la storage master key (derivada en el TOS → necesitaremos el oráculo del keyslot); gzip<original o strings con texto → está en claro y quizá el STORED_APP_PIN_DATA ya esté ahí.
Y cuando puedas, pásame también la salida de sh find_uuids.sh y which cc gcc clang — con el UUID del TA criptográfico preparamos el primer te_tool call contra el dispatcher de 45 comandos (la prueba del keyslot 12 como oráculo).
sh-3.2# hexdump -C /backup/data/0000000000000001 | head -20 00000000 d2 82 06 70 ce ca 8a 4a 3a cc a1 53 0a 20 0a a3 |...p...J:..S. ..| 00000010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| * 00000060 09 56 83 d4 25 72 5c ec 05 a3 9c 90 09 03 a7 41 |.V..%r........A| 00000070 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| * 000000a0 df bb 0b 0d e3 95 fa c9 76 14 cd 06 4d 4e 05 9d |........v...MN..| 000000b0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| 000000c0 48 8b 61 84 19 f8 c8 89 26 1d c6 14 5e 7b 62 91 |H.a.....&...^{b.| 000000d0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| 000000e0 b7 cd aa 17 34 1b 19 b9 68 eb 62 13 1f dc 52 70 |....4...h.b...Rp| 000000f0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| * 00000120 a2 49 58 f6 e4 a8 f2 15 34 ed 48 c3 7b f7 d8 5e |.IX.....4.H.{..^| 00000130 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| 00000140 ee 7d 16 83 ba 58 18 85 07 0d 68 04 e9 6f d9 50 |.}...X....h..o.P| 00000150 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| 00000160 27 dc c3 40 71 31 43 b0 e2 f7 ed 81 c7 9e 71 78 |'..@q1C.......qx| 00000170 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| 00000180 5d 75 f4 71 4f 30 2a 96 d3 2f 1f 5e c0 71 c4 26 |]u.qO0*../.^.q.&| *
¡Estructura detectada! El objeto es una tabla de registros de 16 bytes (tamaño de bloque AES) cada 32 bytes — 16 bytes de datos aparentemente cifrados + 16 de relleno a cero. Eso encaja con el TA de storage cifrando registros con una clave derivada del SE. Voy a reversear el formato dentro de ta_154k.bin (el TA de storage) para confirmar de dónde sale esa clave:
El ELF tiene desplazamiento vaddr=offset+0x7000 — corrijo la búsqueda del literal:
r2 mapea por vaddr (+0x7000) — corrijo las direcciones:
Ya tengo suficiente para cerrar esta ronda con conclusiones claras:
Qué es ese objeto (0000000000000001, 1536 B)
La estructura es inequívoca:
0x0000: 16 bytes de datos de alta entropía ← registro cifrado
0x0010–0x005F: ceros (cabecera/zona reservada)
0x0060: 16 bytes de datos ← registro
0x0070: 16 zeros
0x00a0, 0x00c0, 0x00e0, 0x0120... 16 bytes cada 0x20 (32 bytes)
Es decir: tabla de registros de 16 bytes (tamaño exacto de un bloque AES) con 16 bytes de padding a cero, todos de alta entropía → están cifrados o son MACs con clave, no material en claro. Encaja con lo que vimos en el TA de storage (get_storage_key + esquemas "HW RPMB"/"SW RPMB"): el TA cifra cada unidad de 16 bytes con una storage master key derivada dentro del TOS (desde los keyslots del SE).
Implicación importante: esos ficheros no se descifran offline — se descifran a través del TOS, que es exactamente el oráculo que queremos alcanzar con el canal /dev/tlk_device. La vía sigue siendo la misma y ahora con más motivo:
te_tool (OTE) → TA de storage/keyslots → SE keyslot 12 (KEK1) como oráculo → derivada → descifrar objetos + eks_A.bin
Lo que necesito de la unidad para el siguiente paso (igual que antes)
sh find_uuids.sh # UUIDs de TAs + procesos con tlk_device abierto
which cc gcc clang # compilador para te_tool.c
base64 /backup/data/0000000000000002 | head -40 # el objeto grande (8960 B) — empieza por arriba
base64 /backup/data/000000000000002e # el de Feb-2020 (provisionado en fábrica)
El objeto 2e (fecha de fábrica) es especialmente interesante: si su primer registro se parece al de otro objeto → cifrado ECB con reutilización (fuga de estructura); si no → CBC/CTR con IV por registro.
Estado general de la investigación
| Pista | Estado |
|---|---|
| Canal NS→mundo seguro | ✅ Confirmado: /dev/tlk_device, protocolo OTE (ABI completa en extraido/ote_client.h) |
| Cliente OTE | ✅ Escrito (te_tool.c) — falta compilarlo en la unidad |
| UUIDs de TAs | ⏳ Pendiente (find_uuids.sh) |
| Formato storage objects | ✅ Registros AES de 16 B cifrados con clave del TOS |
| Clave de esos registros | 🔒 Derivada en el TOS desde SE → requiere el oráculo |
| EKS (claves de usuario) | 🔒 Cifrado, mismo camino |
| RCM/recovery | RCM solo acepta imágenes firmadas; vía software = cadena recovery OEM |
En cuanto me pases el output de find_uuids.sh y sepamos si hay compilador, preparamos la primera llamada real al TOS (barrido de los 45 comandos del dispatcher) y la prueba de derivación contra los slots 11/12/13. Ahí sabremos si el keyslot 12 es alcanzable por este canal o si las ACL del TOS lo bloquean.
sh-3.2# mount -o remount,rw /
sh-3.2# mount
/dev/mmcblk0p1 on / type ext4 (rw,noatime,data=ordered)
proc on /proc type proc (rw,relatime)
sysfs on /sys type sysfs (rw,nosuid,nodev,noexec,relatime)
none on /dev type devtmpfs (rw,relatime,size=3565356k,nr_inodes=891339,mode=755)
smackfs on /sys/fs/smackfs type smackfs (rw,nosuid,nodev,noexec,relatime)
tmpfs on /dev/shm type tmpfs (rw,nosuid,nodev,size=409600k)
devpts on /dev/pts type devpts (rw,relatime,gid=5,mode=620)
tmpfs on /run type tmpfs (rw,nosuid,nodev,size=81920k,mode=755)
tmpfs on /sys/fs/cgroup type tmpfs (ro,nosuid,nodev,noexec,mode=755)
cgroup on /sys/fs/cgroup/systemd type cgroup (rw,nosuid,nodev,noexec,relatime,xattr,release_agent=/lib/systemd/systemd-cgroups-agent,name=systemd)
cgroup on /sys/fs/cgroup/debug type cgroup (rw,nosuid,nodev,noexec,relatime,debug)
cgroup on /sys/fs/cgroup/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)
cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,cpu,cpuacct)
cgroup on /sys/fs/cgroup/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,freezer)
cgroup on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,memory)
debugfs on /sys/kernel/debug type debugfs (rw,relatime)
mqueue on /dev/mqueue type mqueue (rw,relatime)
smackfs on /run/smack type smackfs (rw,relatime)
tmpfs on /tmp type tmpfs (rw,size=1048576k)
/dev/mmcblk0p3 on /swdl type ext4 (rw,noatime,data=ordered)
/dev/mmcblk0p5 on /backup type ext4 (rw,noexec,noatime,nodelalloc,data=journal)
fusectl on /sys/fs/fuse/connections type fusectl (rw,relatime)
configfs on /sys/kernel/config type configfs (rw,relatime)
/dev/mapper/var_cryptfs on /var type ext4 (rw,noexec,noatime,data=ordered)
/dev/mapper/var_cryptfs on /Data/mnt-backup type ext4 (rw,noexec,noatime,data=ordered)
/dev/mapper/var_cryptfs on /Data/mnt-wt type ext4 (rw,noexec,noatime,data=ordered)
/dev/mapper/var_cryptfs on /Data/mnt-c type ext4 (rw,noexec,noatime,data=ordered)
/dev/sda4 on /mnt/data type ext4 (ro,noexec,noatime,data=ordered)
/dev/sda2 on /mnt/player type ext4 (rw,noexec,noatime,data=ordered)
/dev/sda7 on /mnt/database type ext4 (ro,noexec,noatime,data=ordered)
/dev/sda3 on /mnt/share type ext4 (rw,noexec,noatime,data=ordered)
/dev/sda1 on /mnt/trace type ext4 (rw,noexec,noatime,data=ordered)
/opt/data/dom.iso on /opt/data/dom type iso9660 (ro,noexec,relatime)
nfsd on /proc/fs/nfsd type nfsd (rw,relatime)
/dev/sdb4 on /tmp/media/USB2_4_9385_8282_94CE46A4CE467E8C type tntfs (ro,nosuid,noexec,noatime,uid=1014,gid=1013,umask=00,allow_utime=0022,nls=utf8,min_prealloc_size=64k,max_prealloc_size=121702368,readahead=4M,user_xattr,case_sensitive,fail_safe,hidden=show,dotfile=show,errors=continue,mft_zone_multiplier=1)
sh-3.2# cp /tmp/media/USB2_4_9385_8282_94CE46A4CE467E8C/SysAct .
cp: cannot create regular file ./SysAct': Text file busy
Osea cual es el paso?
Te oriento. Primero, dos cosas de tu output:
Text file busy: intentaste sobrescribirSysActestando en ejecución. Se arregla conmv(rename) o parando el servicio antes (systemctl stop <servicio>). Pero no hace falta tocar SysAct — con root y/dev/tlk_devicepuedes hacer todo lo que hace ese binario desde tu propio proceso. Reemplazar binarios del sistema es riesgo de brick innecesario a estas alturas.- Buenas noticias del mount: tienes un USB montado en
/tmp/media/USB2_4_9385_8282_94CE46A4CE467E8C— esa es tu vía para meter ficheros en la unidad. Y confirmado:/vares el dm-crypt (var_cryptfs) cuya clave gestiona el TOS.
El paso, concreto y en orden
Paso 0 — Traspasa las herramientas del workspace al USB (desde tu PC): descarga de este chat extraido/te_tool.c, extraido/ote_client.h y extraido/find_uuids.sh y cópialos al pendrive. En la unidad aparecerán en /tmp/media/USB2_4_9385_8282_94CE46A4CE467E8C/.
Paso 1 — En la unidad:
cp /tmp/media/USB2_4_9385_8282_94CE46A4CE467E8C/*.c /tmp/media/USB2_4_9385_8282_94CE46A4CE467E8C/*.h /tmp/media/USB2_4_9385_8282_94CE46A4CE467E8C/find_uuids.sh /tmp/
cd /tmp
sh find_uuids.sh
Paso 2 — Compilador:
which cc gcc clang
- Si hay:
cc -O2 -o /tmp/te_tool /tmp/te_tool.c - Si no hay: compilo yo aquí una versión estática cruzada y la pones en el USB (necesito saber la arquitectura del userspace:
file /usr/bin/tos_storage_daemonouname -m).
Paso 3 — Abrir sesiones contra cada UUID que saque find_uuids.sh:
/tmp/te_tool open <uuid>
El que responda result=0 (y no otro error) es un TA vivo. Especialmente el que corresponda al TA de crypto/keyslots y al de storage.
Paso 4 — Barrido de comandos del TA que responda:
for c in $(seq 0 44); do /tmp/te_tool call <uuid> $c I:0 2>&1 | head -1; done
Con eso mapeamos los 45 comandos del dispatcher que extraje del firmware y localizamos los de keyslots.
Paso 5 — La prueba que lo decide todo: el comando de derivación/AES con keyslot, apuntando al slot 12. Si el TOS responde (en vez de dar AES keyslot %d not assigned to client TA), tenemos el oráculo KEK1 → desciframos los objetos de /backup/data y eks_A.bin.
Resumen: no sustituyas SysAct todavía. Primero UUIDs → te_tool → barrido → derivación. Si el TOS bloquea el slot 12 por ACL, veremos en la respuesta del TOS exactamente qué exige (probablemente registrarse como TA propietario vía el comando platform_register_aes_keyslots — que también está en el dispatcher).
Pásame la salida de los pasos 1–3 y seguimos. Si no hay compilador en la unidad, dime uname -m y te dejo el binario estático listo.
Continuemos con los EKS, que hacemos?
Buena decisión — el EKS es analizable offline porque MB2 nos dio el formato exacto (lo desensamblé: [u32 size]["NVEKSP\0\0"][u32 count][entradas: u32 len + datos]...[u32 CRC32]). Lo parseo ahora mismo desde el volcado:
El parse del EKS funcionó y hay hallazgos estructurales grandes:
- 28 entradas (64–1744 bytes, todas múltiplos de 16 → cifrado por bloques AES)
- 25 de 28 entradas empiezan con el mismo bloque de 16 bytes (
75e8840c...) → bajo ECB con clave fija eso es una cabecera de texto plano constante. Es un verificador perfecto: cuando tengamos la clave de envoltura, el primer bloque descifrado debe dar ese valor. - Entradas duplicadas: [0]≡[1], [7]≡[8], [9]≡[10]≡[11], [12]≡[13], [14]≡[15] → claves repetidas en el EKS.
eks_Btiene el mismo layout (15488 B, 28 entradas).
Hago el último intento offline (claves por defecto/cero — solo funcionaría si la unidad no estuviera fused) y pruebo variantes del rango CRC:
¡CRC verificado! zlib.crc32(payload[4:size]) = 0x6ba91c08 = el almacenado — el contenedor EKS queda 100% confirmado: [size]["NVEKSP"][count=28][28 entradas][CRC32]. El fallo al final fue solo un off-by-one en mi script (las 28 entradas terminan justo donde empieza el CRC). Repito la apuesta offline con el script corregido:
El bug era mío: count está en payload[12] (tras el magic de 8 bytes), no en [8]. Corrijo y ejecuto la apuesta offline:
Resultado offline claro: la unidad está fused (la apuesta con claves cero no dio nada) — el EKS solo se abre en runtime a través del TOS. Pero queda una pieza de firmware de alto valor: identificar qué comando del dispatcher de 45 es el gestor de keyslots (el cluster que imprime AES keyslot %d not assigned to client TA), para que tu llamada con te_tool sea exacta y no a ciegas:
Corrección honesta sobre mi parte antes de continuar: al mapear la tabla, los handlers del dispatcher de 45 entradas viven en 0xE91xxx–0xE98xxx, pero el código de keyslots está en 0xF21xxx — o sea que esa tabla no es el dispatch global de TAs que yo había supuesto, sino un switch interno del TOS (probablemente de códigos de error). El dispatch real de comandos va dentro de cada TA (por command_id en la operación OTE), y se puede tanto extraer del binario de cada TA como —más rápido— barrer empíricamente por sesión. Esto no cambia el plan, lo simplifica.
Estado del EKS (cerrado en lo offline)
| Hallazgo | Detalle |
|---|---|
| Formato | [u32 size]["NVEKSP\0\0"][u32 count=28][28 entradas: u32 len + datos][CRC32] — CRC verificado (zlib.crc32(magic..fin) = 0x6ba91c08) |
| Contenido | Entradas de 64–1744 B, todas múltiplo de 16 (AES por bloques), 25 empiezan con el mismo bloque 75e8840c... = cabecera constante cifrada (ECB con clave fija) — verificador perfecto para cuando tengamos la clave |
| Duplicados | (7,8), (12,13), (14,15) idénticas; (0,1) y (9,10,11) comparten cabecera → mismas claves empaquetadas para distintos consumidores |
| A/B | eks_A ≡ eks_B byte a byte |
| Offline | Agotado: la unidad está fused (la apuesta con claves cero/FV por defecto falló). El EKS solo se abre con claves derivadas dentro del SE |
Por eso el EKS converge con el plan del TOS
Cuando MB2 arranca hace copy keys from EKS → instala las claves de usuario del EKS en los keyslots 0–3 del SE (el límite 0–3 que vimos en la primitiva de escritura). Esos slots existen para los TAs clientes — así que la ACL not assigned to client TA probablemente sí los permite. El keyslot 12 (KEK1) queda en el mundo TZ, y su alcanzabilidad la decidirá la respuesta del TOS cuando probemos.
La secuencia en tu unidad (sin cambios):
sh find_uuids.sh # UUIDs de TAs + quién usa /dev/tlk_device
which cc gcc clang # ¿compilador?
# con UUIDs en mano:
/tmp/te_tool open <uuid>
# barrido de comandos por TA (empírico, segundos):
for c in $(seq 0 63); do /tmp/te_tool call <uuid> $c I:0 M:64:/tmp/out_$c.bin 2>&1 | head -1; done
Cuando un comando devuelva datos aceptando un i:<slot> como parámetro → tenemos el oráculo. El bucle de verificación se cierra offline con tres honesty-checks que ya tenemos: el bloque constante del EKS, el CRC, y los objetos de /backup/data.
Lo que te falta pasarme (igual que antes)
- Salida de
sh find_uuids.sh which cc gcc clang(si no hay, dimeuname -my te preparo el binario estático cruzado)- (Opcional, sigue siendo útil)
base64 /backup/data/000000000000002e— el objeto de fábrica
Con los UUIDs, el siguiente paso de mi lado es extraer las tablas de comandos de cada TA desde sus ELFs en el firmware (cada TA lleva su switch de command_id) — así el barrido deja de ser a ciegas y apuntamos directo al comando de derivación con keyslot 12.
Y podemos forzar el modo RCM mediante comando?
Buena pregunta para cerrar el ciclo de RCM. Respuesta corta: no hay un comando estándar tipo reboot --rcm — RCM es un estado del BootROM durante el reset, no del SO. Pero en Tegra existe un mecanismo clásico software que sí se puede probar: el bit de "forced recovery" en los registros scratch del PMC, que el BootROM consulta al arrancar. Verifico en el DTB del firmware (que ya extraje) la dirección del PMC en tu plataforma:
El DTB del BPMP no trae el nodo PMC (es interno del BPMP), pero en la plataforma T186 el PMC está en la dirección estándar de Tegra: 0x7000E400, con SCRATCH0 en +0x50 = 0x7000E450. Con eso, aquí está la respuesta completa:
¿Se puede forzar RCM por comando?
No existe un comando oficial, pero sí un mecanismo clásico de Tegra que puedes probar en 5 minutos: el BootROM de Tegra consulta el bit 1 del registro PMC SCRATCH0 al arrancar ("force recovery"). Si lo escribes y reseteas, el BootROM entra en RCM en lugar de arrancar normalmente.
# 1) Confirmar el nodo PMC en el devicetree del kernel (en la unidad):
ls /sys/firmware/devicetree/base/ | grep -i pmc
cat /sys/firmware/devicetree/base/pmc@7000e400/reg 2>/dev/null | od -A x -t x1
# 2) Escribir el bit de recovery (si tienes devmem):
which devmem
devmem 0x7000E450 32 # leer SCRATCH0 actual (apúntalo)
devmem 0x7000E450 32 0x00000002 # bit 1 = force recovery
sync; reboot
Después del reboot, con la unidad conectada por USB al PC: lsusb | grep 0955 — si aparece el dispositivo NVIDIA APX, entraste en RCM.
Seguridad del experimento: SCRATCH0 es RAM volátil del PMC — un ciclo completo de energía lo borra y la unidad arranca normal otra vez. Si no tienes devmem (o STRICT_DEVMEM bloquea), queda la vía módulo de kernel, igual que para el resto de MMIO.
Dos advertencias que importan
- En T186 no está garantizado que el BootROM honre ese bit (el diseño de straps
BOOT_SELECTy el MB1 de tu firmware pueden tener prioridad). Es una prueba empírica: o aparece el APX o arranca normal. - Aunque funcione, RCM no te acerca a las claves: en una unidad fused, el RCM solo acepta imágenes firmadas por el OEM. Sirve para recuperación/reflasheo, no para ejecutar código ni leer keyslots. La vía de las claves sigue siendo el oráculo del TOS por
/dev/tlk_device.
Y el "comando de reboot especial" que SÍ soporta tu firmware
El que ya localizamos en el propio MB2 (Resetting device for recovery boot chain): el flag de la cadena de recuperación OEM (lo que usa SWUpdate para instalar actualizaciones). Ese reboot te mete en el entorno de recuperación firmado de Harman/Mercedes — es el equivalente funcional de un "modo recovery por comando". Lo encontramos así:
strings /usr/bin/swupdatemanager | grep -iE "recovery|reboot|slot|flag|bootctl" | head
strings /usr/bin/swupdateinstaller | grep -iE "recovery|reboot|partition" | head
Si aparece ahí cómo se marca el flag (un ioctl, una partición, un fichero), lo replicamos a mano.
Mi recomendación de prioridad sigue siendo: find_uuids.sh + te_tool (el oráculo de keyslots) > flag de recovery OEM > experimento PMC-SCRATCH > RCM por hardware. El RCM, aunque lo consigas, es un callejón sin salida para tu objetivo. Pásame la salida de find_uuids.sh cuando la tengas y seguimos con el barrido de comandos del TOS.
