Índice
- 1. Qué es el firmware cerrado y por qué contradice la autocustodia
- 2. Por qué existe el código cerrado: Secure Elements y NDA
- 3. Qué puede ir mal cuando no puedes auditar el firmware
- 4. Código abierto no basta: compilaciones reproducibles
- 5. Cómo lo abordan los principales fabricantes
- 6. Qué puedes verificar tú y qué nunca podrás
- 7. Capas de seguridad que no dependen del fabricante
- Preguntas frecuentes
- Artículos relacionados
- Fuentes y referencias
- El firmware cerrado sustituye la verificación por confianza implícita: no puedes auditar el código que genera tu semilla, muestra tus direcciones y firma tus transacciones.
- Parte de la documentación de los Secure Elements está sujeta a NDA —así lo reconoce Ledger con STMicroelectronics—, lo que limita de forma estructural la auditabilidad; la certificación EAL no equivale a transparencia.
- El código abierto no basta: solo una compilación reproducible demuestra que el binario instalado coincide con el código publicado.
- Mitiga con capas independientes del fabricante: multisig heterogénea, firma air-gapped con PSBT, entropía propia y passphrase.
El firmware cerrado es el punto exacto en el que la autocustodia de bitcoin deja de ser verificable: el código que genera tu semilla, muestra tus direcciones y decide qué firmas no puede ser auditado por nadie salvo el fabricante. Este artículo explica qué implica confiar en firmware propietario, por qué los Secure Elements fuerzan esa opacidad y qué herramientas existen para recuperar una confianza verificable en la práctica.
La máxima que sostiene la autocustodia —don’t trust, verify— se aplica con naturalidad a la red, pero se rompe con facilidad en el hardware. Cuando usas un monedero físico, todo lo que ves en su pantalla y todo lo que sale firmado lo produce un microprograma. Si ese programa es opaco, la verificación se sustituye por una promesa comercial.
No se trata de demonizar el código propietario: se trata de medir qué puede y qué no puede comprobarse, y de diseñar la custodia para que ningún fabricante sea un punto único de fallo.
1. Qué es el firmware cerrado y por qué contradice la autocustodia
El firmware es el programa que se ejecuta dentro del monedero físico. Sus tareas son críticas: generar la semilla según el estándar BIP-39, derivar las claves, mostrar en pantalla las direcciones y los datos de cada transacción y construir las firmas. «Cerrado» significa que el código fuente no está publicado, o que partes esenciales de él no pueden revisarse por terceros.
Conviene distinguir dos modelos de confianza, porque son radicalmente distintos:
- Confianza verificable: el código fuente es público, puede auditarse y —si además la compilación es reproducible— el binario instalado puede compararse con ese código. La garantía es matemática: un hash que coincide o no coincide.
- Confianza implícita: la garantía de que no hay una puerta trasera es una afirmación del fabricante, o una auditoría privada cuyos detalles no puedes comprobar. Funciona hasta que deja de funcionar, y entonces es tarde.
Un matiz importante antes de seguir: «abierto» y «verificable» no son sinónimos. Publicar el código en un repositorio no demuestra qué binario corre de verdad en el dispositivo; esa brecha es el tema central de la sección 4.
También importa la cadena de arranque. En dispositivos como los de Trezor, el software se organiza en capas —boardloader, bootloader y firmware— que se verifican unas a otras antes de ejecutarse. Si cualquier capa de esa cadena fuera opaca o manipulable, todo lo que se construye encima quedaría comprometido.
2. Por qué existe el código cerrado: Secure Elements y NDA
El firmware cerrado no es un capricho comercial; tiene dos causas técnicas concretas. La primera es la protección física. Un microcontrolador de uso general no está diseñado para resistir ataques de canal lateral, inyección de fallos o decapsulación del chip. Por eso muchos fabricantes integran un Secure Element: un circuito endurecido pensado para guardar secretos y resistir manipulación física.
La segunda causa es contractual. Ledger lo explica en su documentación: su acuerdo con STMicroelectronics, el proveedor del chip, le impide legalmente publicar el código de bajo nivel que habla con los bloques de hardware del Secure Element. El resultado es un sistema operativo solo parcialmente revisable: el dispatcher de comandos está publicado, pero la capa que toca el silicio no.
El problema de fondo es que el NDA convierte el componente más crítico del dispositivo en una caja negra permanente. No importa cuánto código se publique alrededor: la parte que custodia los secretos nunca podrá auditarse. Como consecuencia, la decisión de usar ese chip obliga a aceptar una opacidad estructural, no temporal. La restricción, eso sí, no es universal: Trezor afirma que eligió el OPTIGA Trust M (V3) para sus Safe 3 y Safe 5, entre otras razones, porque su documentación no exige NDA y puede revisarse públicamente.
Las alternativas existen y son distintas en cada fabricante:
- Trezor mantiene el firmware totalmente abierto y, a partir del Safe 3, añade un Secure Element como periférico —el OPTIGA Trust M (V3) de Infineon, un chip con certificación Common Criteria EAL6+— en lugar de ejecutar la lógica de firma dentro de él. Profundizamos en el análisis del Secure Element del Trezor Safe 3.
- Coldcard publica su firmware en GitHub y usa dos Secure Elements de fabricantes distintos —un Microchip ATECC608 y un Maxim DS28C36B— de modo que la semilla queda cifrada con AES y su clave se reparte entre el microcontrolador y los dos chips: para extraerla hay que comprometer los tres. Además limita los intentos de PIN a 13.
- BitBox02 usa el chip seguro (ATECC608B) solo para endurecer la contraseña del dispositivo; todas las operaciones criptográficas —derivación BIP-32 y firma— se ejecutan en el microcontrolador con código abierto auditable.
El silicio puede ser cerrado; la lógica de firma no debería serlo. El Secure Element es una defensa legítima contra el atacante físico. El riesgo aparece cuando, además del silicio, se cierra el código que decide qué se firma.
Sobre las certificaciones: el esquema Common Criteria evalúa un producto contra un Security Target definido por el solicitante, no contra un baremo universal de calidad. Un nivel EAL alto certifica resistencia frente a ataques declarados en ese documento; no certifica que el código sea auditable ni que no contenga funciones no declaradas. Common Criteria tampoco es la única vía: en marzo de 2019 Ledger anunció que el Nano S se convertía en la primera wallet hardware certificada del mercado, con el sello CSPN de la agencia francesa ANSSI, un esquema de certificación de primer nivel distinto del Common Criteria.

3. Qué puede ir mal cuando no puedes auditar el firmware
Los riesgos del firmware cerrado no son hipótesis académicas; son clases de ataque bien documentadas en los propios modelos de amenaza de la industria.
Entropía débil o adulterada
La semilla BIP-39 se genera con entre 128 y 256 bits de entropía, y a partir de ella se deriva la semilla maestra con PBKDF2-HMAC-SHA512 y 2048 iteraciones. Si el firmware sesga en secreto el generador aleatorio, las claves parecen aleatorias pero pertenecen a un subconjunto que el atacante puede barrer por fuerza bruta. Sin acceso al código, esa reducción del espacio de claves es indetectable hasta que el robo ocurre.
Actualizaciones firmadas maliciosas
El firmware define las reglas de acceso a las claves. Una actualización legítimamente firmada por el fabricante puede cambiar esas reglas y añadir funciones de extracción. El modelo de amenazas de BitBox lo plantea con crudeza: un Estado o una organización criminal podría forzar la firma de firmware malicioso dirigido a un único usuario. Su mitigación es que el bootloader muestre el hash del firmware en cada arranque y que ese hash sea comparable con una compilación determinista.
Lo que ves no es lo que firmas
La pantalla del dispositivo la dibuja el firmware. Si está comprometido, puede mostrar una dirección de destino correcta mientras firma en segundo plano una transacción que envía los fondos a otra parte. El principio what you see is what you sign solo se sostiene si confías en el código que pinta la pantalla; con firmware cerrado, esa confianza es ciega por definición.
Exfiltración por canales encubiertos
Un firmware malicioso puede filtrar la clave privada dentro de las propias firmas, sesgando los nonces de ECDSA de forma que solo el atacante pueda leer el secreto. La contramedida es el protocolo anti-klepto, que obliga al firmante a demostrar que el nonce se derivó del mensaje y de un compromiso verificable, y no de un canal secreto. El BitBox02 lo implementa para firmas ECDSA; su documentación aclara que no cubre Schnorr ni Taproot.
Cadena de suministro
Fábrica, transporte y servidores de actualización son tres fases donde un binario cerrado puede sustituirse por otro malicioso sin que el usuario tenga forma de compararlo con nada. Con firmware reproducible, una sustitución deja de coincidir con el hash; sin él, es invisible.
4. Código abierto no basta: compilaciones reproducibles
Publicar el código en GitHub no demuestra que el binario instalado provenga de ese código. Entre el fuente y el firmware hay un compilador, un toolchain y un entorno de compilación: piezas que pueden alterar el resultado, ser manipuladas o introducir diferencias inocentes que impiden la comparación.
El proyecto Reproducible Builds define la solución: un conjunto de prácticas que crean un camino verificable e independiente desde el código fuente hasta el binario. Una compilación es reproducible cuando, a partir del mismo código y del mismo entorno, cualquiera obtiene un binario idéntico bit a bit. Ese binario puede compararse con el distribuido mediante su hash SHA-256.
El caso de Trezor es el mejor documentado. Su guía de builds reproducibles fija el entorno con Nix, uv y Cargo, ofrece un script basado en Docker que compila con un único comando y explica cómo comparar el resultado con el firmware oficial: el binario oficial difiere del local solo en la firma, así que se ponen a cero esos bytes y se comparan los hashes. Si coinciden, el firmware distribuido proviene del código publicado.
BitBox02 ofrece una ruta equivalente: firmware construible de forma determinista, releases verificables por la comunidad y la opción de que el bootloader muestre el hash del firmware instalado en cada arranque.
Dónde queda Ledger en este mapa: su sistema operativo no es verificable de forma reproducible en su totalidad, porque parte del código no es público. Ledger compensa esa brecha con auditorías de un laboratorio externo antes de cada release y con el genuine check que verifica la autenticidad del dispositivo y de su sistema operativo. Es una garantía procedimental sólida, pero no sustituye a la garantía matemática: el usuario sigue sin poder comprobar por sí mismo qué ejecuta su dispositivo.
5. Cómo lo abordan los principales fabricantes
La transparencia de cada ecosistema se resume en cuatro preguntas: ¿el firmware es público?, ¿qué papel juega el Secure Element?, ¿el binario es verificable de forma reproducible? y ¿qué queda cerrado?
| Fabricante | Firmware | Secure Element | Verificación | Lo que queda cerrado |
|---|---|---|---|---|
| Trezor | Abierto (trezor-firmware en GitHub) | Desde Safe 3: Optiga Trust M (V3), certificado EAL6+ | Builds reproducibles documentados; comparación de hash SHA-256 | El firmware interno del propio chip seguro |
| Ledger | OS parcialmente revisable; apps, SDK y la aplicación de escritorio abiertos | Secure Element de STMicroelectronics | Auditoría externa antes de cada release; genuine check | La capa de bajo nivel del SE (NDA) |
| Coldcard | Abierto (Coldcard/firmware en GitHub) | Doble SE: ATECC608 + DS28C36B | Código fuente público; semilla cifrada repartida entre tres chips | El interior de los dos Secure Elements |
| BitBox02 | Abierto | ATECC608B, solo para proteger la contraseña | Builds deterministas; hash en el arranque; anti-klepto | El firmware del chip seguro |
| SeedSigner | Abierto, proyecto DIY | Ninguno: Raspberry Pi Zero air-gapped | Todo el stack es auditable; sin certificación formal | Nada |
La comparativa completa de arquitecturas entre dos de estos enfoques está en Coldcard Mk4 vs Trezor Safe 3. El patrón general es claro: quien no publica el código de firma compensa con auditorías y certificaciones; quien lo publica puede además ofrecer verificación reproducible.
6. Qué puedes verificar tú y qué nunca podrás
Separar lo verificable de lo no verificable evita dos errores simétricos: creer que un wallet cerrado es una caja negra absoluta, o creer que un wallet abierto es transparente por completo.
Puedes verificar:
- El binario, si el fabricante documenta builds reproducibles: compilas el código publicado, comparas el hash con el firmware instalado y obtienes una respuesta binaria.
- El hash del firmware en el arranque del dispositivo, cuando el bootloader lo permite, como opción de configuración en BitBox02.
- Los datos de cada transacción antes de firmar: el formato PSBT definido en BIP-174 incluye toda la información necesaria y está pensado para que el firmante pueda estar desconectado y revisar qué firma. Con flujos PSBT y pantallas verificables, el riesgo de firma ciega se reduce al mínimo.
- La entropía de tu semilla: puedes añadir tiradas de dados —Coldcard documenta la generación de semillas con 256 bits de entropía por dados— de modo que un generador interno comprometido no pueda predecir tu clave. Enlazamos la metodología en la auditoría de entropía BIP-39.
No podrás verificar nunca:
- El interior del Secure Element: su diseño, su firmware interno y sus posibles debilidades quedan bajo el NDA del fabricante del chip, incluso en los wallets más transparentes.
- Las auditorías privadas: puedes leer sus conclusiones, no repetir el procedimiento.
- Las declaraciones comerciales sobre seguridad que no vayan acompañadas de código o de documentación técnica comprobable.
La conclusión práctica: la verificabilidad no es una propiedad binaria del dispositivo, sino una ruta concreta —código, entorno de compilación, hash y comparación— que cada usuario puede recorrer o delegar en verificadores independientes.
7. Capas de seguridad que no dependen del fabricante
Ninguna verificación elimina todo el riesgo, y el Secure Element siempre será una zona de confianza residual. Por eso la mitigación más eficaz es estructural: que ningún fabricante, por sí solo, pueda firmar una transacción válida.
- Multisig heterogénea: un esquema 2-de-3 con dispositivos de fabricantes, arquitecturas y firmwares distintos exige que dos implementaciones independientes se comprometan a la vez. Un firmware malicioso en un solo dispositivo no basta para mover fondos. Véase el diseño completo en multisig 2 de 3 para empresas.
- Air-gap y PSBT: eliminar USB y Bluetooth en favor de QR o microSD reduce la superficie de ataque y permite inspeccionar el payload antes de firmarlo, conforme al flujo definido en BIP-174.
- Passphrase BIP-39: aunque el firmware filtrara la semilla mnemónica, sin la passphrase el atacante no alcanza la cartera real; cada passphrase deriva una cartera válida, lo que además da negación plausible.
- Shamir (SLIP-39): repartir el secreto en shares con umbral —el estándar SLIP-39 define shares de 20 o 33 palabras para secretos de 128 o 256 bits— limita el daño si un dispositivo o una ubicación queda comprometido durante la configuración. Empezamos por el esquema básico en Shamir 2 de 3.
Combinadas, estas capas convierten la pregunta de «¿confío en este fabricante?» en «¿pueden comprometerme dos fabricantes, dos arquitecturas y dos procesos de verificación a la vez?». Esa es la diferencia entre confianza implícita y confianza verificable aplicada al conjunto de la custodia.
Preguntas frecuentes
¿Qué es el firmware cerrado de un monedero hardware?
Es el programa interno del dispositivo cuyo código fuente no es público, o lo es solo en parte. Como ese programa genera la semilla, muestra las direcciones y produce las firmas, su opacidad obliga a confiar en el fabricante sin poder comprobar qué hace realmente el dispositivo.
¿Es el firmware de Ledger de código cerrado?
En parte. Ledger publica su aplicación de escritorio y móvil, el SDK seguro, las apps embebidas y el dispatcher de comandos del sistema operativo, pero la capa de bajo nivel del Secure Element permanece cerrada por el acuerdo de confidencialidad con STMicroelectronics. La propia empresa lo describe como una elección entre abrir todo el sistema y usar un chip menos seguro.
¿Puedo verificar el firmware de mi Trezor o BitBox02 sin ser programador?
Sí, con algo de paciencia. Trezor documenta un script de Docker que compila el firmware con un comando y explica cómo comparar el hash con el binario oficial; BitBox02 permite mostrar el hash del firmware en cada arranque y publica releases verificables por la comunidad. No necesitas escribir código, solo seguir los pasos documentados.
¿Un Secure Element certificado EAL6+ elimina el problema de la confianza?
No. La certificación Common Criteria acredita resistencia frente a ataques físicos declarados en un Security Target concreto; no hace el código auditable ni demuestra la ausencia de funciones no declaradas. Un chip certificado protege contra el atacante con destornillador y osciloscopio, no contra el fabricante del propio firmware.
Prioriza dispositivos con código fuente público y compilación reproducible documentada: son los únicos cuyo firmware puedes comparar, no solo creer. Si usas hardware con partes cerradas, compensa con multisig heterogénea y entropía propia. El firmware cerrado no es un fallo en sí mismo; lo es no poder verificarlo.
Artículos relacionados
- Coldcard Mk4: firma air-gapped por QR
- Mitigación de ataques de glitching
- El ataque de los 5 dólares
- Billeteras ocultas y negación plausible
- Shamir 3 de 5: custodia compartida
Fuentes y referencias
- BIP-39: Mnemonic code for generating deterministic keys — https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki
- BIP-174: Partially Signed Bitcoin Transaction Format — https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki
- SLIP-0039: Shamir’s Secret-Sharing for Mnemonic Codes (SatoshiLabs) — https://github.com/satoshilabs/slips/blob/master/slip-0039.md
- Proyecto Reproducible Builds — https://reproducible-builds.org/
- Trezor Firmware: documentación oficial de builds reproducibles — https://docs.trezor.io/trezor-firmware/common/reproducible-build.html
- Trezor Knowledge Base: Security & safety in Trezor (cadena boardloader-bootloader-firmware) — https://trezor.io/es/learn/security-privacy/how-trezor-keeps-you-safe/security-safety-in-trezor
- Trezor Knowledge Base: Secure Elements in Trezor Safe devices (OPTIGA Trust M (V3), certificación CC EAL6+, documentación sin NDA) — https://trezor.io/learn/security-privacy/how-trezor-keeps-you-safe/secure-elements-in-trezor-safe-devices
- Repositorio oficial trezor-firmware — https://github.com/trezor/trezor-firmware
- Documentación del Optiga en trezor-firmware — https://github.com/trezor/trezor-firmware/blob/master/docs/core/misc/optiga.md
- Ledger Academy: Is Ledger Open Source? — https://www.ledger.com/academy/topics/ledgersolutions/is-ledger-open-source
- Ledger: anuncio de la certificación del Nano S, la primera wallet hardware certificada (CSPN de la ANSSI, 2019) — https://www.ledger.com/setting-a-new-standard-ledger-nano-s-becomes-the-first-and-only-certified-hardware-wallet-on-the-market
- Documentación oficial de Coldcard: Advanced Topics — https://coldcard.com/docs/advanced-topics/
- Coldcard: documentación técnica del doble Secure Element (ATECC608 + DS28C36B) — https://github.com/Coldcard/firmware/blob/master/docs/secure-elements.md
- Coldcard: guía de generación de semilla con dados (256 bits de entropía) — https://coldcard.com/docs/paranoid/
- Repositorio oficial del firmware de Coldcard — https://github.com/Coldcard/firmware
- BitBox Support: What stops the maker of the hardware wallet from stealing my coins? — https://support.bitbox.swiss/en_US/was-hindert-den-hersteller-der-hardware-wallet-meine-coins-zu-stehlen
- BitBox02: modelo de amenazas oficial (anti-klepto, builds deterministas, hash en arranque) — https://bitbox.swiss/bitbox02/threat-model/
- SeedSigner: repositorio oficial (firmador air-gapped sobre Raspberry Pi Zero) — https://github.com/SeedSigner/seedsigner
- Common Criteria Portal (esquema de certificación ISO/IEC 15408) — https://www.commoncriteriaportal.org/
- Bitcoin Optech: tema Multisignature — https://bitcoinops.org/en/topics/multisignature/
