Índice
  1. 1. Qué es Codex32 y por qué existe
  2. 2. Anatomía de una cadena Codex32
  3. 3. El checksum BCH: qué corrige y qué no
  4. 4. Shamir en Codex32: cómo se reparte la semilla
  5. 5. Codex32 en Coldcard: MS1, CW1 y CX1
  6. 6. Codex32 frente a SLIP-39 y BIP-39
  7. 7. Cómo montar un backup Codex32 paso a paso
  8. 8. Límites, riesgos y modelo de amenaza
  9. 9. ¿Para quién tiene sentido (y para quién no)?
  10. Preguntas frecuentes
  11. Artículos relacionados
  12. Fuentes y referencias
En resumen

  • Codex32 (BIP-93) codifica una semilla maestra BIP-32 en una cadena base32 de 48 caracteres para 128 bits (74 para 256 bits), con un checksum BCH que detecta hasta 8 errores y corrige 4 sustituciones.
  • Incluye Shamir Secret Sharing: entre 2 y 9 shares con umbral de 2 a 9; cualquier umbral reconstruye la semilla y una sola share no revela nada. El estándar permite hasta 31 shares; Coldcard implementa de 2 a 9.
  • Coldcard lo soporta desde el firmware 5.6.3 (Mk4/Mk5) y 1.5.3Q (Q), con tres formatos: MS1 (semilla BIP-32), CW1 (palabras BIP-39) y CX1 (clave extendida, incluida la cartera con passphrase).
  • No es un sustituto universal de BIP-39: BIP-93 sigue en estado Draft, no admite passphrase y las shares no son interoperables con SLIP-39. Úsalo como backup metálico compacto o esquema Shamir en Coldcard, y prueba siempre la recuperación.

Codex32 es un formato para guardar la semilla de un monedero Bitcoin en una cadena corta de caracteres, con un checksum que permite detectar y corregir errores de transcripción. No es una wallet ni un algoritmo de firma: es una forma de codificar el secreto y, opcionalmente, de repartirlo entre varias shares mediante un esquema de Shamir. Lo define el BIP-93, un documento firmado por Leon Olsson Curr, Pearlwort Sneed y Andrew Poelstra que sigue en estado Draft.

Su atractivo es fácil de explicar: una semilla de 128 bits cabe en 48 caracteres, se puede grabar en una placa metálica sin lista de palabras y su checksum se puede verificar a mano. Para quien busca un backup duradero, compacto y resistente a un error de copia, Codex32 abre una tercera vía entre la frase BIP-39 y las shares SLIP-39. Coldcard lo implementó en octubre de 2026, y eso lo ha convertido en algo más que una propuesta teórica.

Este artículo explica qué hay dentro de una cadena Codex32, cómo funciona su checksum, cómo se reparte la semilla, qué formatos usa Coldcard y en qué casos merece la pena frente a las alternativas que ya conocemos.

1. Qué es Codex32 y por qué existe

BIP-93 nació en 2023 con una motivación concreta: guardar la semilla maestra de un monedero BIP-32 de forma compacta, verificable y apta para computación manual. Sus autores buscaban un formato que se pudiera leer, escribir, dictar y comprobar sin depender de una lista de 2048 palabras ni de un ordenador. De ahí la elección de base32, un alfabeto sin mayúsculas mezcladas, y de un código BCH de corrección de errores.

El estándar comparte objetivo con SLIP-39 y con BIP-39, pero no es ninguno de los dos. De BIP-39 hereda la idea de codificar una semilla para almacenarla; de SLIP-39, la posibilidad de dividirla en shares. Lo que aporta es un formato de longitud fija, un checksum más potente y la posibilidad de hacer las cuentas con lápiz y papel.

Hay un matiz importante desde el principio: Codex32 codifica la semilla maestra BIP-32, no la entropía BIP-39. Es una diferencia técnica con consecuencias prácticas. Una frase BIP-39 se convierte en semilla mediante PBKDF2-HMAC-SHA512; Codex32 guarda directamente el resultado. Por eso una cadena Codex32 no es una frase mnemónica y no se puede importar en cualquier wallet.

2. Anatomía de una cadena Codex32

Una cadena Codex32 se parece a una dirección bech32. Empieza por el prefijo legible ms, sigue con el separador 1 y después un bloque de datos con cinco partes: el umbral, un identificador de cuatro caracteres, el índice de share, el payload y el checksum. Todo el conjunto debe estar en mayúsculas o en minúsculas, nunca mezclado.

Parte Qué contiene Ejemplo
ms + 1 Prefijo legible y separador ms1
Umbral 0 para un secreto sin dividir; 2–9 para shares 0 o 2
Identificador Cuatro caracteres bech32 que distinguen un conjunto de shares de otro test
Índice s para el secreto completo; otra letra para una share s o A
Payload La semilla o la share codificada en grupos de 5 bits 26 caracteres para 128 bits
Checksum 13 caracteres de código BCH (15 en cadenas largas) 4nzvca9cmczlw

Las longitudes están fijadas por el tamaño de la semilla. Para 128 bits la cadena completa tiene 48 caracteres; para 160, 192, 224 y 256 bits son 54, 61, 67 y 74. BIP-93 añade un formato largo de 127 caracteres y checksum de 15 para semillas de 512 bits, el máximo que permite BIP-32.

Un ejemplo público del propio BIP ayuda a verlo. La cadena ms10testsxxxxxxxxxxxxxxxxxxxxxxxxxx4nzvca9cmczlw contiene el prefijo ms1, umbral 0, identificador test, índice s, un payload de 26 caracteres y el checksum 4nzvca9cmczlw. Decodificada, corresponde a la semilla 318c6318c6318c6318c6318c6318c631. Es un vector de prueba: no debe usarse para custodiar fondos.

Para las shares el índice deja de ser s y pasa a ser una letra del alfabeto bech32, como A, C o D. El identificador y el umbral se repiten en todas las shares del mismo conjunto; si no coinciden, no se pueden combinar. La cadena de ejemplo MS12NAMEA320ZYXWVUTSRQPNMLKJHGFEDCAXRPP870HKKQRM es una share con umbral 2, identificador NAME e índice A.

3. El checksum BCH: qué corrige y qué no

El checksum es la parte que hace especial a Codex32. Son 13 caracteres calculados con un código BCH sobre el alfabeto bech32. El diseño garantiza la detección de cualquier error que cambie hasta ocho símbolos en cadenas de hasta 93 símbolos, con una probabilidad de fallo inferior a 3 entre 1020 para errores aleatorios. Además, puede corregir hasta cuatro sustituciones de caracteres, ocho erasures (caracteres ilegibles) o trece erasures consecutivas.

Esa capacidad de corrección es útil en el mundo físico. Si alguien transcribe una placa metálica y confunde una B con un 8, una O con un 0 o una I con una l, el checksum puede señalar el problema y, en muchos casos, proponer la cadena correcta. BIP-93 recomienda que la implementación muestre la corrección y pida confirmación al usuario, no que la aplique en silencio.

Hay dos límites que conviene grabarse. El primero: el checksum protege contra errores accidentales, no contra un adversario que construya una cadena maliciosa. El segundo: una corrección automática no es una prueba de que la semilla sea la correcta; solo indica que la cadena es válida. Coldcard detecta los errores, pero no corrige automáticamente: muestra el fallo y deja que el usuario revise la copia.

El checksum tampoco sustituye a la verificación del backup. Una cadena puede pasar el checksum y corresponder a una semilla distinta de la que crees, si la copia se alteró de forma coherente. La prueba definitiva sigue siendo recuperar la cartera y comprobar la huella y una dirección conocida, como se explica más abajo.

4. Shamir en Codex32: cómo se reparte la semilla

BIP-93 incluye un esquema de Shamir Secret Sharing sobre el campo de 32 elementos que usa bech32. La idea es la de siempre: se construye un polinomio de grado k−1 cuyo término independiente es el secreto; cada share es un punto del polinomio. Con k puntos se interpola y se recupera el secreto; con menos, no hay información suficiente para determinarlo.

El estándar permite repartir el secreto en hasta 31 shares, con un umbral entre 2 y 9. Coldcard limita la implementación a entre 2 y 9 shares, con un umbral entre 2 y el total. En un 2-de-3 se generan tres shares y dos cualesquiera reconstruyen la semilla; una sola no revela nada. En un 3-de-5 se necesitan tres de cinco, lo que tolera la pérdida de dos.

La interpolación se hace sobre las cadenas completas, no solo sobre el payload. Eso permite que el identificador, el umbral y el índice formen parte de la codificación y que las shares derivadas mantengan un checksum válido. También explica por qué no se pueden mezclar shares de conjuntos distintos: aunque el checksum sea válido, el resultado no será la semilla original.

Codex32 no soporta reparto multinivel ni passphrase dentro del propio estándar. Es una decisión de diseño para mantener el formato simple y apto para cálculo manual. Quien necesite grupos jerárquicos o una passphrase que cifre el secreto tendrá que usar SLIP-39 o las extensiones de Coldcard que veremos a continuación.

5. Codex32 en Coldcard: MS1, CW1 y CX1

Coldcard incorporó Codex32 en el firmware 5.6.3 para Mk4 y Mk5, y 1.5.3Q para el Q, publicado el 1 de octubre de 2026. La implementación va más allá del BIP: además de MS1, añade dos prefijos propios para dividir carteras que ya existen sin mover los fondos ni cambiar de semilla.

Formato Qué codifica Longitud Qué recupera
MS1 Semilla maestra BIP-32 en bruto 48 (128 bits), 74 (256) o 127 (512) La semilla BIP-32; no admite passphrase BIP-39
CW1 Entropía de 12, 18 o 24 palabras BIP-39 en inglés 48, 61 o 74 Las palabras originales; la passphrase se guarda y se aplica aparte
CX1 Clave privada extendida, incluida la cartera con passphrase activa 127 La clave y el chain code; no recupera palabras ni passphrase

La diferencia entre ellos importa. MS1 es el formato estándar de BIP-93 y guarda la semilla maestra. CW1 es una extensión de Coldcard que codifica la entropía de las palabras BIP-39: al recuperar, devuelve las palabras y puedes aplicar tu passphrase como siempre. CX1 es otra extensión que guarda material de clave extendida; si divides una cartera con passphrase activa, las shares recuperan esa cartera directamente, sin pedir la passphrase, pero no contienen las palabras originales.

El flujo de Coldcard es coherente con esa distinción. Puedes generar una cartera Codex32 nueva (128 o 256 bits) desde el menú Codex32, importar un secreto completo con índice S, dividir la cartera activa con Shamir Split, recuperar con Shamir Recover, derivar shares nuevas con Derive Shares y calcular un checksum con Calculate Checksum. La división no mueve bitcoin ni invalida la semilla original: la cartera sigue siendo la misma; lo que cambia es cómo la respaldas.

Coldcard no conserva el conjunto de shares después de dividir. Hay que registrar cada share antes de salir de la pantalla, compararla con la copia y repetir la operación con cada una. Las exportaciones por QR, NFC, MicroSD o disco virtual son texto plano: no están cifradas. La regla operativa es guardar menos shares que el umbral en cualquier ubicación, tarjeta o dispositivo.

6. Codex32 frente a SLIP-39 y BIP-39

Las tres propuestas resuelven problemas distintos. BIP-39 es el estándar de facto para frases mnemónicas; SLIP-39 añade Shamir con palabras; Codex32 apuesta por cadenas compactas con corrección de errores. Esta tabla resume las diferencias que más afectan al usuario.

BIP-39 SLIP-39 Codex32 (BIP-93)
Formato 12, 18 o 24 palabras Shares de 20 o 33 palabras Cadena base32 de 48, 54, 61, 67, 74 o 127 caracteres
Checksum 4 u 8 bits; detecta, no corrige RS1024; detecta hasta tres palabras BCH de 13 caracteres; corrige 4 sustituciones y 8 erasures
Shamir No Sí, con grupos multinivel Sí, un solo nivel; hasta 31 shares, umbral 2–9
Passphrase Sí, PBKDF2 Sí, cifra el secreto maestro No en el estándar; CW1 y CX1 en Coldcard
Interoperabilidad Muy alta Trezor y varias wallets Coldcard para MS1, CW1 y CX1; MS1 empieza a aparecer en otras herramientas
Cálculo manual No No Sí, por diseño

La comparación con SLIP-39 es la más directa porque ambos son esquemas Shamir. SLIP-39 trabaja con 1.024 palabras y shares de 20 o 33 palabras; Codex32 trabaja con 32 caracteres y cadenas de longitud fija. SLIP-39 admite grupos y passphrase; Codex32 no. SLIP-39 está implantado en Trezor y otras wallets; Codex32, hoy, está mucho más concentrado en Coldcard.

Las shares de uno y otro no son convertibles entre sí porque usan campos distintos. BIP-93 lo dice expresamente: se puede convertir una semilla SLIP-39 a Codex32, pero no sus shares. Tampoco recomienda la conversión: si quieres cambiar de esquema, genera una semilla nueva y mueve los fondos. Es la opción limpia y evita arrastrar una configuración híbrida que ninguna wallet entiende.

Frente a BIP-39, la diferencia es de filosofía. BIP-39 es universal y legible; Codex32 es compacto y verificable. Si tu prioridad es que cualquier wallet del mercado pueda restaurar tu backup, BIP-39 sigue ganando. Si tu prioridad es un backup metálico pequeño, con corrección de errores y posibilidad de Shamir, Codex32 es más adecuado.

7. Cómo montar un backup Codex32 paso a paso

El siguiente procedimiento asume un Coldcard con firmware 5.6.3 o 1.5.3Q y una cartera ya existente. La lógica se traslada a cualquier implementación que soporte MS1, aunque los menús cambian.

  1. Actualiza y verifica el firmware. Descarga solo desde la página oficial de Coldcard, comprueba el hash SHA-256 y la firma PGP antes de instalar. Un firmware manipulado puede generar shares válidas para una semilla que no es la tuya.
  2. Decide el tamaño. 128 bits equivalen a una frase de 12 palabras y caben en 48 caracteres; 256 bits equivalen a 24 palabras y ocupan 74. Para un backup a largo plazo, 256 bits dan más margen; para uso habitual, 128 bits siguen siendo suficientes.
  3. Genera o importa el secreto. Si creas una cartera nueva, elige Codex32 > Generate y aporta entropía con dados, monedas o mezcla de teclas. Coldcard combina tu aportación con su TRNG y sus elementos seguros. Si ya tienes una cartera, actívala y usa Shamir Split; Coldcard elegirá MS1, CW1 o CX1 según el tipo de cartera.
  4. Registra la cadena completa. Incluye prefijo, umbral, identificador, índice, payload y checksum. Coldcard la muestra en grupos de cuatro caracteres; cópiala en orden y pasa el cuestionario de verificación si generaste una cartera nueva.
  5. Divide en shares. Elige el número de shares (2–9) y el umbral (2 hasta el total). Para un 2-de-3, cualquier dos shares recuperan; para un 3-de-5, tres de cinco. Un umbral igual al total no deja margen para perder una share.
  6. Guarda cada share por separado. Menos shares que el umbral en cada ubicación, dispositivo o tarjeta. El metal es mejor que el papel para el largo plazo; una placa grabada con 48 caracteres es manejable. No fotografíes las shares ni las guardes en un gestor de contraseñas sin cifrar.
  7. Prueba la recuperación. Recupera como semilla temporal o en un segundo Coldcard, usando exactamente las copias que vas a guardar. Comprueba la huella y una dirección de recepción conocida, con la misma red, tipo de dirección y ruta de derivación. Que la huella coincida no basta.
  8. Repite la prueba con cada share. Haz que cada share que vayas a conservar participe en una recuperación correcta. Si una share está mal copiada, el checksum puede detectarlo, pero la prueba de recuperación es la que confirma que el conjunto es el tuyo.
  9. Conserva el secreto original. Dividir no invalida la semilla completa ni los backups anteriores. Guarda el secreto original en un lugar seguro y separado; si lo pierdes y no alcanzas el umbral, no hay recuperación.
  10. Documenta el procedimiento. Deja instrucciones para tus herederos o custodios: qué es una share, cuántas hacen falta, dónde están y cómo se recuperan. Un backup técnicamente perfecto que nadie sabe usar es un backup perdido.

Un ejemplo de distribución para un 2-de-3: la share A en una caja de seguridad, la C en una placa metálica en casa y la D en casa de un familiar de confianza. Ninguna ubicación tiene dos shares, así que un robo o un incendio no compromete el umbral. Si se pierde una, las otras dos siguen recuperando; si se pierden dos, el conjunto ya no sirve.

8. Límites, riesgos y modelo de amenaza

Codex32 no es una bala de plata. El primero de sus límites es la madurez: BIP-93 sigue en Draft y su implementación más completa es la de Coldcard. Las extensiones CW1 y CX1 no forman parte del estándar, así que una share CW1 o CX1 solo se recupera en firmware o software que las soporte expresamente. Si guardas una share durante años, conviene comprobar que seguirá siendo legible en el futuro.

El segundo límite es la passphrase. MS1 no la admite: si usas una passphrase BIP-39, tienes que dividir la cartera de palabras (CW1) y guardar la passphrase por separado, o dividir la cartera con passphrase activa (CX1) y aceptar que las shares recuperan esa cartera sin pedir la passphrase. Las dos opciones son válidas, pero no son equivalentes: CW1 conserva la posibilidad de aplicar otras passphrases a las mismas palabras; CX1 recupera una cartera concreta y no las palabras.

El tercero es conceptual: Codex32 reparte una única clave, no varias. Al reconstruir el secreto, la clave completa vuelve a existir en un solo dispositivo. Eso no es multisig. Si quieres que cada gasto requiera varias firmas independientes, necesitas un esquema multisig con claves separadas y un descriptor; Shamir solo protege el respaldo, no la autorización de gasto.

El cuarto es físico. Las shares son texto plano: una foto, una transcripción o un papel mal guardado las expone. El checksum detecta errores accidentales, pero no impide que alguien copie una share. La defensa es la misma de siempre: separación geográfica, menos shares que el umbral por ubicación, metal en lugar de papel y discreción sobre la existencia del backup. La coerción y el robo con acceso físico siguen siendo un vector real, como en cualquier esquema de autocustodia.

El quinto es la interoperabilidad. Si mañana quieres restaurar en otra marca, MS1 tiene más posibilidades que CW1 o CX1, pero el ecosistema aún es pequeño. Antes de confiar tu patrimonio a un formato, comprueba que existe al menos una segunda implementación capaz de leerlo y que has probado la recuperación con ella. Y no conviertas shares entre esquemas: BIP-93 desaconseja la conversión y las shares de SLIP-39 no son compatibles.

9. ¿Para quién tiene sentido (y para quién no)?

Codex32 encaja bien en tres perfiles. El primero, quien ya tiene un Coldcard y quiere un backup metálico compacto: 48 caracteres caben en una placa pequeña y el checksum permite verificar la copia sin encender el dispositivo. El segundo, quien quiere Shamir sin depender de una lista de palabras y valora poder comprobar el checksum a mano. El tercero, quien necesita separar shares entre custodios y prefiere cadenas cortas, fáciles de transcribir y de revisar.

No encaja en otros tres. Quien solo tiene Trezor o Ledger y no piensa cambiar de dispositivo: SLIP-39 o BIP-39 siguen siendo las opciones soportadas. Quien necesita un esquema multisig con autorización distribuida: Codex32 no lo sustituye. Y quien quiere una solución universal, con passphrase integrada y soporte en cualquier wallet: hoy BIP-39 es más práctico, aunque no tenga corrección de errores.

También hay un perfil que debería esperar: el usuario que no ha probado nunca una recuperación. Codex32 añade pasos y formatos; si no tienes claras las diferencias entre MS1, CW1 y CX1, empieza por una BIP-39 con passphrase bien probada y pasa a Codex32 cuando entiendas el flujo. La seguridad no viene del formato más exótico, sino de la recuperación que puedes ejecutar sin dudar.

Preguntas frecuentes

¿Codex32 sustituye a BIP-39?

No. BIP-39 es un estándar de frases mnemónicas con soporte casi universal; Codex32 es un formato compacto para semillas BIP-32 con Shamir opcional. Sirven para lo mismo —guardar la semilla—, pero no son intercambiables en cualquier wallet. Si necesitas que cualquier dispositivo restaure tu backup, BIP-39 sigue siendo la opción más segura.

¿Puedo convertir mi frase BIP-39 a Codex32?

Coldcard puede dividir la cartera de palabras con CW1, que codifica la entropía de las palabras y las devuelve al recuperar. Convertir una frase BIP-39 a MS1 exige derivar la semilla de 512 bits y no es reversible; BIP-93 no lo recomienda. Si quieres cambiar de esquema, genera una semilla nueva y mueve los fondos.

¿Qué pasa si pierdo una share?

En un 2-de-3, las otras dos siguen recuperando. Si tienes el umbral, puedes derivar una share nueva con Derive Shares y sustituir la perdida. Si pierdes más shares de las que permite el umbral, el conjunto ya no se puede reconstruir y tendrás que recurrir al secreto original o a otro backup.

¿El checksum corrige los errores automáticamente?

BIP-93 permite corregir hasta cuatro sustituciones, pero recomienda pedir confirmación al usuario. Coldcard detecta el error y no lo corrige automáticamente. Aunque la cadena sea válida, la prueba definitiva es recuperar la cartera y comparar la huella y una dirección conocida.

¿Es seguro un backup de 48 caracteres?

48 caracteres codifican 128 bits de entropía, el equivalente a una frase de 12 palabras. Es suficiente para la mayoría de usuarios; para un patrimonio alto o a muy largo plazo, 74 caracteres y 256 bits dan más margen. La seguridad depende de la calidad de la entropía y de la custodia, no de la longitud del texto.

¿Puedo usar una passphrase BIP-39 con Codex32?

MS1 no la admite. Con Coldcard puedes dividir la cartera de palabras (CW1) y guardar la passphrase aparte, o dividir la cartera con passphrase activa (CX1), que recupera esa cartera sin pedir la passphrase pero no conserva las palabras. Elige según quieras recuperar las palabras o una cartera concreta.

Veredicto

Codex32 es la propuesta más interesante de los últimos años para backup físico: 48 caracteres, checksum que corrige errores y Shamir sin listas de palabras. En Coldcard ya es usable y resuelve bien el backup metálico y el reparto entre custodios. Pero sigue siendo un estándar Draft, muy dependiente de un fabricante y sin passphrase integrada. Úsalo si valoras compacidad y verificación manual, y prueba la recuperación con las copias exactas que vas a guardar. Si necesitas interoperabilidad universal, BIP-39 o SLIP-39 siguen siendo la apuesta conservadora.

Comparar con el esquema Shamir SLIP-39 2-de-3 →

Artículos relacionados

Fuentes y referencias

  1. BIP-93 — codex32: Checksummed SSSS-aware BIP32 seeds (Draft): https://github.com/bitcoin/bips/blob/master/bip-0093.mediawiki
  2. BIP-32 — Hierarchical Deterministic Wallets: https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
  3. BIP-39 — Mnemonic code for generating deterministic keys: https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki
  4. BIP-173 — Base32 address format for native v0-16 witness outputs (alfabeto bech32): https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki
  5. SLIP-0039 — Shamir’s Secret-Sharing for Mnemonic Codes: https://github.com/satoshilabs/slips/blob/master/slip-0039.md
  6. COLDCARD Documentation — Codex32 & Shamir Secret Sharing: https://coldcard.com/docs/codex32/
  7. Coinkite Blog — COLDCARD Firmware 5.6.3 & 1.5.3Q: Codex32 and Shamir Backups (1 de octubre de 2026): https://blog.coinkite.com/coldcard-firmware-563-153q/
  8. Coinkite Blog — Codex32 and Shamir Backups on COLDCARD: https://blog.coinkite.com/shamir-backups-without-a-new-wallet/
  9. Blockstream Research — codex32: a paper computer for Shamir’s Secret Sharing over the Bech32 alphabet: https://github.com/BlockstreamResearch/codex32
  10. python-codex32 — implementación de referencia en Python: https://github.com/BenWestgate/python-codex32
  11. The Secret Codex32 — cuaderno ilustrado sobre el estándar: https://secretcodex32.com/docs/2023-03-07–color.pdf
  12. Lista bitcoin-dev — discusión de la propuesta Codex32 (febrero de 2023): https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2023-February/021469.html
  13. Coldcard Firmware — documentación técnica de Codex32: https://github.com/Coldcard/firmware/blob/master/docs/codex32.md
  14. Coldcard — página oficial de descargas y verificación de firmware: https://coldcard.com/downloads/all
O

Oliba

Oliba es el pseudónimo de Miguel Lozano del Moral, responsable de Atium. Estudia Diseño y Desarrollo de Videojuegos y escribe sobre autocustodia, hardware wallets, entropía y OPSEC desde hace casi cinco años.

Deja tu comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *