Nuevo episodio cada martes · 16:00 CET · 10 AM ETEducación, no consejo financiero

Aprende Bitcoin con vídeos, laboratorios y fuentes citadas

Curso gratuito, en español, construido en abierto

Aprende Bitcoin haciendo, no solo leyendo.

Publicamos cada lección solo cuando está completa, con su vídeo y sus fuentes. Es gratis; si te sirve, al final de cada lección puedes apoyar el trabajo.

29lecciones publicadas
15.3horas de estudio
nadie mandatodos verificanmiles de nodos
Una red sin jefe: miles de nodos que verifican por su cuenta. Todo el curso parte de esa idea.

Cómo funciona cada lección

Explicación

Texto corto y con fuentes. Primero el problema, luego la solución.

Laboratorio

Código que ejecutas tú. La salida que ves en pantalla es de una ejecución real, no inventada.

Clip del podcast

Una conversación real que complementa el capítulo, en vertical y con subtítulos en español.

Examen

Preguntas con explicación. Marca la lección como completada y sigue tu progreso.

Créditos y método

Los textos, simuladores y laboratorios son originales. Los datos históricos y técnicos se apoyan en fuentes primarias que citamos al final de cada lección: el libro blanco de Bitcoin, los BIP y los BOLT, la documentación de Bitcoin Core y, en IA, la documentación de Anthropic, OWASP y artículos de investigación.

Libros y textos abiertos que consultamos (siempre citados, nunca copiados): Mastering Bitcoin (Antonopoulos y Harding, licencias Creative Commons), Mastering the Lightning Network (CC BY-SA 4.0), Learning Bitcoin from the Command Line (CC BY 4.0), las especificaciones BOLT (CC BY 4.0) y BIP, y los textos del Nakamoto Institute.

Lecturas recomendadas con derechos de autor: The Bitcoin Standard (Saifedean Ammous, Wiley) y Criptoria: de Turing a Nakamoto (Alfre Mancera, Prometea, 2024). Son obras comerciales: te recomendamos leerlas, pero este curso no copia ni resume su contenido.

El programa técnico salvadoreño NodeNation y el Diploma de Mi Primer Bitcoin (material abierto) nos sirvieron como mapa de temas. No copiamos sus textos. Los laboratorios en Python están ejecutados y su salida es real; los que dependen de un nodo, Docker o servicios externos están marcados con una nota de transparencia.

Educación, no consejo financiero, fiscal ni legal. Actualizado el 07/11/2026.

IA de cero a avanzado

Prueba de nivel

Nueve preguntas sobre lo que ya haces. Es una autoevaluación: te recomienda por dónde empezar. El examen final comprueba después lo aprendido.

Tu estudio

Mi progreso

Curso · ES

Bitcoin completo

Construido en abierto: publicamos cada lección cuando está completa, con su vídeo y sus fuentes.

bloque 1hash anteriorraíz Merklebloque 2hash anteriorraíz Merklebloque 3hash anteriorraíz Merklebloque 4hash anteriorraíz Merklecada bloque guarda el hash del anterior: cambiar uno rompe todos los siguientes
Un curso que crece lección a lección: de la idea cypherpunk a tu propio nodo.

3 módulos · 29 lecciones ·

Módulo 1Obligatorio

Introducción a Bitcoin

De Turing a Nakamoto: las ideas, las personas y el libro blanco

Antes de tocar una sola línea de código hay que entender por qué existe Bitcoin y qué problemas tuvieron que resolver otros antes. Este módulo es pura historia, contexto y lectura guiada: no hay laboratorios ni programación todavía. Cuando llegues a la parte técnica sabrás por qué cada pieza está donde está.

Al terminar sabrás

  • Explicar el problema del doble gasto con tus palabras
  • Contar la historia larga de la criptografía, de Turing a Nakamoto, con fechas y personas
  • Situar a Chaum, Back, Dai, Szabo y Finney en la línea que lleva a Bitcoin
  • Leer el libro blanco entero entendiendo cada sección
  • Saber qué NO promete el diseño original

Lecciones

  1. Los cypherpunks y el sueño del dinero digital22 min
  2. De Turing a Nakamoto: la historia larga24 min
  3. Los intentos que fallaron (y lo que enseñaron)20 min
  4. El libro blanco, sección por sección28 min
  5. Primeros años: de Satoshi a la comunidad22 min
  6. Lecturas canónicas con guía de debate30 min
Módulo 2Obligatorio

La tecnología de Bitcoin

Hashes, firmas, direcciones, transacciones y bloques, construidos a mano

Aquí dejas de creer y empiezas a comprobar. Cada pieza (hash, clave, firma, dirección, transacción, bloque) la implementas tú en Python sin dependencias y la contrastas con datos reales de la cadena. Si nunca has programado, empieza por el Taller 0: te lleva de la mano desde instalar Python hasta ejecutar tu primer laboratorio.

Al terminar sabrás

  • Instalar Python y ejecutar un programa desde la terminal
  • Calcular y verificar el hash del bloque génesis
  • Generar una clave pública y firmar y verificar con ECDSA
  • Derivar una dirección P2PKH y Bech32 desde una clave
  • Construir y firmar una transacción legacy
  • Verificar una prueba de Merkle

Lecciones

  1. Taller 0: tu primer programa en Python40 min
  2. Hashes: la huella digital de los datos24 min
  3. Campos finitos y curvas elípticas, desde cero40 min
  4. Claves y firmas digitales36 min
  5. Direcciones: de la clave a lo que compartes30 min
  6. Direcciones y checksums: cómo se detecta un error de copia30 min
  7. Transacciones: UTXO, entradas y salidas40 min
  8. SIGHASH: qué compromete una firma34 min
  9. Bloques, Merkle y la cadena36 min
  10. Cómo se ponen de acuerdo los nodos28 min
Módulo 8

Seguridad y autocustodia

Semillas, hardware, multisig, herencia y estafas

La mayor parte del riesgo real en Bitcoin no está en el protocolo sino en cómo guardas tus claves y en quién te engaña. Este módulo es práctico: modelo de amenazas, buenas costumbres y errores caros.

Al terminar sabrás

  • Construir tu modelo de amenazas
  • Entender semilla, BIP39, derivación y passphrase
  • Elegir entre hardware wallet, multisig y custodia
  • Preparar una herencia sin exponerte
  • Reconocer las estafas más comunes

Lecciones

  1. Modelo de amenazas: ¿de qué te proteges?30 min
  2. Semillas, BIP39 y derivación36 min
  3. Descriptores y carteras deterministas48 min
  4. Hardware wallets y verificación32 min
  5. PSBT: firmar sin conectar tu clave36 min
  6. Multisig y custodia colaborativa36 min
  7. Herencia y plan de contingencia30 min
  8. Estafas y ataques frecuentes36 min
  9. Coacción y ataques físicos: cuando el atacante está en tu puerta30 min
  10. Simulacro de recuperación: demuestra que tus copias funcionan36 min
  11. Elegir cartera: una tabla para decidir30 min
  12. Auditoría de tu custodia: 25 comprobaciones28 min
  13. Autocustodia: preguntas frecuentes y errores clásicos26 min

Lo que estamos construyendo ahora

Estos módulos salen en cuanto estén completos, con su vídeo. No los mostramos a medias.

Módulo 3En construcción

Minería de Bitcoin 1

Programa y ejecuta tu propio minero

Módulo 4En construcción

Minería de Bitcoin 2: tu propio nodo

Instala, ejecuta y entiende un nodo de Bitcoin

Módulo 5En construcción

Lightning Network

Canales, HTLC y pagos con un nodo y una API

Módulo 6En construcción

Protocolo a fondo

Script, SegWit, Taproot, comisiones y cómo cambia Bitcoin

Módulo 7En construcción

Minería industrial

Economía, halving, hardware, energía y el debate

Módulo 9En construcción

Privacidad

Qué revela tu actividad y cómo reducirlo

Módulo 10En construcción

Bitcoin para negocios

Cobrar, pagar, contabilizar y gestionar el riesgo

Módulo 11En construcción

Empresas de tesorería de Bitcoin

Cómo funcionan, qué prometen y dónde están los riesgos

Módulo 12En construcción

Ciencias sociales

Dinero, historia, economía, derecho y desarrollo

Módulo 13En construcción

La frontera

Qué se está construyendo ahora y cómo evaluarlo

Módulo 14En construcción

Lecciones de la historia

Los grandes fallos y ataques de Bitcoin, de Mt. Gox a 2026, y qué enseña cada uno

Módulo 15En construcción

Proyecto final y certificación

Tu cartera mínima, el examen y un diploma que cualquiera puede verificar

Inicio / Bitcoin completo / Módulo 1
Introducción a Bitcoin · lección 1 de 6 · 22 min

Los cypherpunks y el sueño del dinero digital

A principios de los noventa un grupo de criptógrafos y programadores creyó que la privacidad era una condición de la libertad en la era digital. Bitcoin nace de esa conversación.

1976Diffie yHellman1982Firmas ciegas1991Selladode tiempo1992Cypherpunks1997Hashcash2008Libro blancoNinguna pieza bastaba sola
Treinta años de ideas hasta el libro blanco: cada fecha añade una pieza.

Una lista de correo con ideas peligrosas

En septiembre de 1992 un pequeño grupo se reunió en la casa de Eric Hughes, en California: Timothy May, John Gilmore, Hughes y unas veinte personas más. Venían de la criptografía, de la programación y de las primeras empresas de internet. Hablaron de una cosa concreta: ¿qué pasa con la privacidad cuando todas las comunicaciones pasan por redes que otros controlan? Al poco tiempo montaron una lista de correo; la escritora Jude Milhon, que participaba en las reuniones, los bautizó cypherpunks (de cipher, cifrado, y cyberpunk). Hoy se conserva buena parte de aquellos mensajes en archivos públicos, y se pueden leer.

No eran un partido ni una empresa. Eran una conversación técnica con una idea moral detrás. En 1993 Hughes la resumió en A Cypherpunk's Manifesto: la privacidad no es secretismo, es poder decidir qué se muestra de uno mismo y a quién. En una sociedad abierta, decía, esa decisión no se la puede dar nadie: hay que construirla con criptografía. Y de ahí salía la consigna práctica, que se convirtió en lema del movimiento: cypherpunks write code, los cypherpunks escriben código. En vez de pedir permiso o esperar leyes favorables, construyes la herramienta y la publicas.

Antes, en 1988, Timothy May había escrito el Crypto Anarchist Manifesto, mucho más provocador: imaginaba un mundo donde el cifrado y los protocolos anónimos cambiarían la naturaleza de los gobiernos, las empresas y las transacciones. Hace falta leerlo con espíritu crítico (es un texto de ciencia ficción política, no una profecía), pero sirve para entender el clima: gente convencida de que unas pocas matemáticas bien aplicadas podían mover más poder que una ley.

Lo que ya habían construido

Los cypherpunks no empezaban de cero. Se apoyaban en una década de avances que habían cambiado el estado de la técnica:

  • Criptografía de clave pública (Diffie y Hellman, 1976; RSA, 1977): por primera vez dos personas que nunca se habían visto podían establecer un canal seguro o firmar un mensaje sin compartir antes un secreto.
  • PGP (Phil Zimmermann, 1991): correo cifrado para cualquiera, publicado en internet. El Gobierno de Estados Unidos investigó a Zimmermann por exportar “armas” (el cifrado fuerte estaba bajo las mismas reglas de exportación que los misiles). Lo publicó también en un libro impreso, que sí se podía exportar, y el caso se cerró en 1996.
  • Remailers anónimos: servidores que reenviaban mensajes quitando el remitente, basados en las “redes de mezcla” de David Chaum (1981).
  • Servidores de claves y redes de confianza: la idea de que la reputación se pudiera construir sin una autoridad central.

El dinero era el eslabón que faltaba. Sin una forma de pagar por internet que no pasara por intermediarios que lo vigilan todo, la privacidad quedaba a medias: podías cifrar tu correo, pero tu tarjeta delataba lo que comprabas. Y los intermediarios, además, podían cortar el pago.

Chaum: el primer dinero digital

David Chaum merece un lugar aparte. En 1982 propuso las firmas ciegas: un banco puede firmar una ficha sin ver su contenido, de modo que más tarde nadie puede enlazar esa ficha con quien la retiró. Es como firmar con bolígrafo un sobre con papel carbón dentro: la firma queda en el papel interior sin que el firmante vea lo escrito. Con esto fundó DigiCash (1989) y su sistema eCash: pagos digitales anónimos como el efectivo.

Técnicamente era brillante y resolvía la privacidad. Pero tenía una dependencia que sería su sentencia: una empresa central que emitía y validaba todo. Cuando los bancos que probaron el sistema dejaron de apoyarlo y la empresa no consiguió escala, DigiCash quebró en 1998. La lección que los cypherpunks extrajeron es una de las más importantes de la historia de Bitcoin: si hay un solo punto de control, hay un solo punto de fallo, técnico, económico o político.

El problema que nadie resolvía: el doble gasto

Un archivo digital se copia sin coste. Si una moneda es un archivo, ¿qué impide gastarla dos veces? La respuesta clásica era un tercero de confianza que lleve el libro de cuentas: un banco, un procesador de pagos, DigiCash. Todos los sistemas anteriores a 2008 hacían eso con más o menos ingenio. La pregunta de los cypherpunks, y el hueco que Bitcoin ocupó, es otra: ¿se puede acordar quién tiene qué entre desconocidos, sin un tercero al que haya que creer?

Dicho con un ejemplo cotidiano: si tienes un billete de 20 euros en el bolsillo, nadie tiene que “actualizar un registro” cuando te lo guardas. Pero si tienes 20 euros en una aplicación, alguien lleva la cuenta. El reto era conseguir la comodidad digital sin la dependencia del contable.

Ninguna de estas piezas bastaba sola. Casi todas trataban de crear escasez, pero ninguna conseguía consenso entre desconocidos sin un servidor de confianza. Esa fue la contribución de Satoshi Nakamoto: combinar las piezas de forma que el consenso saliera del propio incentivo económico.

Cómo estudiar esta historia

Hay dos maneras de contar esto: como una línea recta de genios que llevan a un destino inevitable, o como una serie de intentos con fallos, desacuerdos y casualidades. La segunda es más fiel y más útil. Cada propuesta fracasó por una razón concreta (un punto central, un coste que no escala, falta de incentivos) y cada fracaso dejó una lección que la siguiente aprovechó. Cuando en el siguiente módulo veas un bloque, una firma o un hash, intenta recordar de cuál de estas historias viene.

Qué te llevas

  • Bitcoin no apareció de la nada: es una combinación brillante de ideas con más de treinta años de historia.
  • La pregunta de fondo no es técnica sino política: ¿quién controla el libro de cuentas?
  • Los cypherpunks pensaban que la privacidad requiere criptografía, y que el código importa más que la petición de permiso.
  • Cuando alguien te diga “eso ya se había intentado”, tendrás razón al responder: sí, pero faltaba la parte del consenso.

Para pensar

Piensa en tres servicios que usas cada semana y que dependen de un único intermediario (tu banco, tu proveedor de correo, una plataforma de pagos). ¿Qué pasaría si uno de ellos decide, un día, no atenderte? Esa incomodidad es la que los cypherpunks querían resolver con código.

Comprueba lo aprendido

¿Qué problema impedía que el dinero digital existiera sin intermediario antes de Bitcoin?

¿Qué aportó Hashcash a Bitcoin?

¿Por qué fracasó DigiCash, a pesar de resolver la privacidad?

¿Qué quiere decir el lema “cypherpunks write code”?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 1
Introducción a Bitcoin · lección 2 de 6 · 24 min

De Turing a Nakamoto: la historia larga

Para entender por qué Bitcoin es lo que es, hay que mirar mucho más atrás que 2008: la historia de la criptografía y de la computación es también la historia de quién puede guardar un secreto y quién puede verificar una verdad.

-500Escítala1553Vigenère1936Turing1949Shannon1976Clave pública1991PGP2008Bitcoin2009Bloque 0Tres hilos: secreto, verificación y escasez
De los códigos de Esparta al bloque génesis: dos mil años en una línea.

Tres hilos que se trenzan

Bitcoin parece un invento súbito. En realidad es el punto donde se cruzan tres hilos de historia muy antiguos:

  1. Secreto: cómo comunicar algo a alguien sin que otros lo lean (cifrado).
  2. Verificación: cómo demostrar que algo es auténtico, o que alguien tiene derecho a hacerlo (firmas, sellos, pruebas).
  3. Escasez y acuerdo: cómo evitar que algo se copie o que dos personas den versiones distintas de la verdad (dinero, registros, consenso).

Los dos primeros avanzaron durante siglos con ayuda de las matemáticas. El tercero, el del dinero, había sido siempre un problema social: lo resolvían los monarcas, los bancos y los estados. La pregunta de Nakamoto fue si el tercero podía resolverse como los dos primeros: con matemática verificable en lugar de autoridad.

De la antigüedad a la imprenta

  • La escítala espartana (siglo V a. C.): una tira de cuero enrollada en un bastón de un diámetro concreto; solo quien tenía el mismo bastón podía leer el mensaje. Es una de las primeras formas conocidas de cifrado por transposición.
  • El cifrado César (siglo I a. C.): desplazar cada letra un número fijo de posiciones. Fácil de romper hoy, pero era suficiente cuando casi nadie sabía analizar frecuencias.
  • El análisis de frecuencias (al-Kindi, siglo IX): el filósofo árabe Abu Yusuf al-Kindi describió cómo romper cifrados de sustitución simple contando cuántas veces aparece cada letra. Por primera vez, el criptoanálisis se volvía método.
  • El cifrado de Vigenère (siglo XVI): usar una clave repetida para variar el desplazamiento. Se creyó indescifrable durante siglos, hasta que Kasiski (1863) y Babbage (hacia 1854) encontraron cómo atacarlo.

Una lección que se repite: la seguridad que depende de ocultar el método suele durar poco. Quien diseña un cifrado puede confiar en él mucho más tiempo si el método es público y solo la clave es secreta. Esa idea se formalizó en el siglo XIX como principio de Kerckhoffs, y sigue vigente: una buena criptografía no depende de que el diseño sea secreto.

Turing, Enigma y el nacimiento de la informática

En 1936 Alan Turing publicó On Computable Numbers, donde definió una máquina teórica (la “máquina de Turing”) capaz de ejecutar cualquier procedimiento que pueda describirse con pasos finitos. De ahí nace la idea de computación universal: un solo tipo de máquina que puede imitar a cualquier otra si se le da el programa adecuado. Es la base teórica de todos los ordenadores que existen.

Pocos años después, durante la Segunda Guerra Mundial, Turing trabajó en Bletchley Park en el análisis de la máquina Enigma, que usaba el ejército alemán para cifrar mensajes. Con el trabajo previo de criptógrafos polacos (Marian Rejewski y su equipo) y con el diseño de máquinas como la Bombe, los aliados lograron leer buena parte de esas comunicaciones. Las matemáticas tenían ya consecuencias militares y políticas enormes. Y las máquinas de cálculo, como el Colossus para otros cifrados alemanes, dejaban de ser curiosidades académicas.

Shannon: la criptografía se vuelve ciencia

En 1948 Claude Shannon publicó la teoría de la información: cómo medir cuánta información lleva un mensaje y cuánto ruido soporta. En 1949 publicó Communication Theory of Secrecy Systems, donde demostró que existe un cifrado perfectamente seguro (la libreta de un solo uso, one-time pad) siempre que la clave sea tan larga como el mensaje, verdaderamente aleatoria y nunca se reutilice. Al mismo tiempo mostró que ese sistema es poco práctico, y con eso dejó claro el problema que vendría: ¿cómo se reparten las claves?

1976: la clave pública

Durante dos décadas el principal obstáculo era el reparto de claves. Dos personas necesitaban encontrarse primero en persona (o confiar en un mensajero) para acordar un secreto. En 1976 Whitfield Diffie y Martin Hellman publicaron New Directions in Cryptography, con una idea radical: un intercambio de claves a través de un canal público sin compartir antes ningún secreto, y la propuesta de firmas digitales. Ralph Merkle había trabajado en ideas paralelas. En 1977 Rivest, Shamir y Adleman crearon RSA, la primera implementación práctica de cifrado y firma con clave pública.

Un dato histórico curioso: en el GCHQ británico, James Ellis, Clifford Cocks y Malcolm Williamson habían descubierto ideas equivalentes entre 1969 y 1974, pero eran secretas y no se supieron hasta 1997. Es un buen recordatorio de que las ideas matemáticas pueden descubrirse varias veces y que el secreto institucional retrasa el progreso colectivo.

Con las firmas digitales ya existía la herramienta que Bitcoin usa para cada pago: demostrar que tienes derecho a mover algo, sin revelar tu secreto. Lo estudiarás en el módulo 2 con curvas elípticas (una variante más eficiente propuesta en 1985 por Neal Koblitz y Victor Miller).

Hashes, árboles y sellos de tiempo

En paralelo se desarrollaba otra herramienta clave: las funciones hash, que convierten cualquier dato en una huella de tamaño fijo imposible de invertir y casi imposible de falsificar. En 1979 Ralph Merkle describió el árbol de hashes que lleva su nombre: una forma de demostrar que un dato forma parte de un conjunto enorme con muy poca información. En 1991 Stuart Haber y W. Scott Stornetta propusieron encadenar documentos mediante hashes con sellos de tiempo, para que nadie pudiera alterar el pasado sin que se notara; en 1993 añadieron los árboles de Merkle a la propuesta. Ya tienes dos de las piezas que formarán un bloque de Bitcoin.

Las “guerras criptográficas” de los noventa

Cuando internet se abrió al público, el Gobierno de Estados Unidos consideraba el cifrado fuerte un arma de guerra, regulado bajo las mismas reglas que las armas. En 1993 propuso el Clipper chip, un sistema de cifrado con una “puerta trasera” para las agencias. La comunidad técnica y las empresas se opusieron, y el caso Bernstein v. Estados Unidos (1996-1999) estableció que el código es una forma de expresión protegida. Hacia el año 2000 las restricciones de exportación se relajaron en gran medida. Esas batallas dieron legitimidad al movimiento cypherpunk: demostraron que publicar software criptográfico podía cambiar la ley.

De la teoría al dinero

En paralelo, varios intentos de dinero digital exploraban qué piezas faltaban:

  • DigiCash (1989-1998): privacidad sin escalabilidad, dependiente de una empresa.
  • e-gold (1996-2009): una moneda digital respaldada en oro, con millones de cuentas, pero centralizada; el gobierno estadounidense la acusó de facilitar el lavado de dinero y de operar sin licencia, y el servicio dejó de funcionar.
  • Hashcash (1997), b-money (1998) y Bit Gold (1998): las ideas conceptuales más cercanas a Bitcoin, sin implementar un sistema completo.

Mientras tanto, la década de 2000 trajo la burbuja puntocom, el auge de los pagos con tarjeta y una dependencia cada vez mayor de intermediarios para casi todo.

2008: Satoshi Nakamoto

En octubre de 2008, en plena crisis financiera, alguien con el seudónimo Satoshi Nakamoto envió a una lista de correo de criptografía el documento que combinaba todo lo anterior: firmas digitales para la propiedad, hashes y sellos de tiempo para el orden, prueba de trabajo para el consenso, y un incentivo económico para que los participantes actuaran de forma honesta. El 3 de enero de 2009 se minó el primer bloque. No se sabe quién es Satoshi. Lo que sí sabemos es que sus piezas tienen autoría y fecha y que puedes leerlas todas.

Qué te llevas

  • Bitcoin no inventó la criptografía ni los hashes: los combinó con una pieza nueva, el consenso por prueba de trabajo con incentivo.
  • Cada pieza viene de una historia con personas reales y fechas comprobables.
  • El principio de Kerckhoffs sigue vigente: el método es público y solo la clave es secreta. Bitcoin es código abierto desde el primer día.
  • Para profundizar en español con un relato más largo recomendamos Criptoria de Alfre Mancera; aquí te damos el mapa para que puedas decidir qué leer.

Comprueba lo aprendido

¿Qué problema atacó el artículo de Diffie y Hellman de 1976?

¿Qué demostró Shannon en 1949 sobre la libreta de un solo uso?

¿Qué aportó la propuesta de Haber y Stornetta (1991) al diseño de Bitcoin?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 1
Introducción a Bitcoin · lección 3 de 6 · 20 min

Los intentos que fallaron (y lo que enseñaron)

Entre 1989 y 2008 hubo al menos media docena de intentos serios de dinero digital. Estudiar por qué cayeron es la mejor manera de entender por qué Bitcoin se diseñó como se diseñó.

EmpresacentralUsuarios AUsuarios BUsuarios C
Un solo punto de control es un solo punto de fallo.

Un método para estudiar fracasos

Hay una pregunta útil que puedes hacerle a cualquier sistema de dinero: ¿qué tendría que fallar para que deje de funcionar? En los sistemas anteriores a Bitcoin la respuesta casi siempre es “una empresa, un servidor o un regulador”. Repasamos los más importantes con esa lente.

DigiCash (1989-1998)

  • Qué proponía: pagos anónimos con firmas ciegas.
  • Qué resolvía: la privacidad del pagador.
  • Por qué cayó: dependía de la empresa de Chaum, que debía firmar y validar todo, y de bancos que no lo adoptaron. Quebró en 1998 y cedió sus activos.
  • Qué heredó Bitcoin: la convicción de que la privacidad es parte del diseño y la lección de que un emisor único es una vulnerabilidad.

e-gold (1996-2009)

  • Qué proponía: una unidad de cuenta digital respaldada por oro físico.
  • Qué resolvía: pagos internacionales rápidos con un respaldo tangible. Llegó a tener millones de cuentas.
  • Por qué cayó: el emisor controlaba cuentas y reservas, y el gobierno de Estados Unidos lo acusó en 2007 de operar sin licencia de transmisor de dinero y de facilitar el lavado de dinero. Los responsables se declararon culpables en 2008 y el servicio dejó de funcionar con normalidad en los años siguientes.
  • Qué heredó Bitcoin: la prueba de que había demanda real por dinero digital global, y la lección de que cualquier punto central es un blanco legal y técnico.

Hashcash (1997) y la prueba de trabajo

Adam Back diseñó Hashcash como defensa contra el correo basura: para enviar un mensaje había que demostrar que se había dedicado un poco de cómputo a calcular un hash con ciertas características. Para un usuario normal el coste era trivial; para quien enviaba millones de correos, enorme. No era dinero, pero introdujo el patrón que Bitcoin reutiliza: un trabajo costoso de producir y barato de verificar.

b-money (1998) y Bit Gold (1998-2005)

Wei Dai propuso b-money en una nota breve: una red donde cada participante lleva su propia copia del libro de cuentas y el dinero se crea resolviendo problemas computacionales. Nick Szabo, por su parte, describió Bit Gold: pruebas de trabajo encadenadas y publicadas con sellos de tiempo, de forma que cada unidad creara “escasez digital incorruptible”. Ambas propuestas contienen casi todos los elementos de Bitcoin. Les faltaba un mecanismo robusto de acuerdo entre desconocidos que no confían entre sí (¿quién decide qué cadena vale?) y un incentivo que mantuviera honestos a los participantes. Ninguna llegó a implementarse como un sistema completo.

RPOW (2004)

Hal Finney, criptógrafo y desarrollador de PGP, creó las pruebas de trabajo reutilizables: un servidor intercambiaba una prueba de trabajo por una nueva, evitando el doble uso. Funcionaba, pero la seguridad dependía de la confianza en el servidor (con hardware seguro como apoyo). Finney sería uno de los primeros en descargar Bitcoin y recibir una transacción en 2009.

Lo que Bitcoin añadió

Mirando todo junto, Bitcoin no inventó cada pieza. Hizo cuatro cosas nuevas:

  1. Un acuerdo entre desconocidos sin servidor central: la cadena con más trabajo acumulado es la verdad.
  2. Un incentivo económico para participar: quien gasta energía en validar cobra una recompensa y comisiones.
  3. Una política monetaria fija en el código: un límite de 21 millones de unidades, conocido por todos.
  4. Un lanzamiento limpio: código abierto, sin premine anunciado por una empresa, y un creador que se retiró.

Comprueba lo aprendido

¿Qué patrón de Hashcash reutiliza Bitcoin?

¿Qué tenían en común DigiCash y e-gold que los hizo vulnerables?

¿Qué le faltaba a b-money y Bit Gold respecto a Bitcoin?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 1
Introducción a Bitcoin · lección 4 de 6 · 28 min

El libro blanco, sección por sección

Nueve páginas que cambiaron el dinero. Las leemos como se leen los clásicos: despacio, con la pregunta de qué problema resuelve cada párrafo.

FirmasSelladode tiempo#Prueba detrabajoRed de nodosIncentivoCada pieza resuelve el hueco que dejó la anterior
Las cinco piezas del libro blanco, en el orden en que se apoyan unas en otras.
nadie mandatodos verificanmiles de nodos
Nodos como una mesa redonda: nadie manda y todos verifican.

Contexto

El 31 de octubre de 2008, durante la crisis financiera, alguien con el seudónimo Satoshi Nakamoto envió a la lista de correo de criptografía el documento Bitcoin: A Peer-to-Peer Electronic Cash System. Tiene unas nueve páginas y doce secciones. Léelo tú mismo en bitcoin.org/bitcoin.pdf; aquí tienes la guía. El texto es breve, preciso y casi sin adornos: no habla de revolución, habla de un problema técnico concreto y de cómo resolverlo.

SecciónQué diceLo importante
1. IntroducciónEl comercio en línea depende de terceros de confianza, y eso añade costes y fraudeEl objetivo: pagos sin intermediario
2. TransaccionesUna moneda es una cadena de firmas digitalesCada dueño firma la transferencia al siguiente
3. Servidor de sellado de tiempoLos bloques se enlazan por hashOrden temporal verificable
4. Prueba de trabajoBuscar un nonce que dé un hash con ceros inicialesReescribir historia exige rehacer el trabajo
5. RedPasos: difundir, validar, construir, aceptarLa cadena más larga manda
6. IncentivoSubsidio por bloque y comisionesSer honesto sale más rentable que atacar
7. Recuperar espacioÁrboles de Merkle para podarNodos ligeros
8. Verificación simplificadaComprobar pagos sin descargar todoSPV
9. Combinar y dividir valorEntradas y salidas múltiplesModelo UTXO
10. PrivacidadClaves públicas anónimasUna clave nueva por transacción
11. CálculosProbabilidad de que un atacante alcance a la cadena honestaCae exponencialmente con las confirmaciones
12. ConclusiónUn sistema sin confianza

Sección 1: el problema

Satoshi empieza con una observación fría: el comercio por internet se apoya en instituciones financieras que actúan como terceros de confianza, y ese modelo “funciona suficientemente bien” para la mayoría de las operaciones, pero sufre de las debilidades inherentes de un modelo basado en confianza. Las transacciones totalmente irreversibles no existen, porque las instituciones no pueden evitar arbitrar disputas; esa posibilidad de reversión aumenta los costes; y los comerciantes deben desconfiar de sus clientes y pedir más datos de los necesarios. Hay una cantidad de fraude que se acepta como inevitable. Lo que se necesita, dice, es un sistema de pago electrónico basado en prueba criptográfica en lugar de confianza.

Secciones 2 y 3: firmas y sellos

La sección 2 define la moneda como “una cadena de firmas digitales”. Para pagar a alguien, firmas el hash de la transacción anterior y la clave pública del siguiente propietario. Quien recibe puede verificar la cadena de propiedad. El problema es que el receptor no puede saber si el dueño anterior ya había gastado la moneda en otro sitio, y la solución habitual era un tercero (una casa de moneda) que revisa cada transacción. Satoshi quiere quitar ese tercero. La respuesta es hacer que todas las transacciones sean públicas y que los participantes se pongan de acuerdo en un único historial. De ahí viene la sección 3: un servidor de sellado de tiempo distribuido que publica el hash de un bloque de elementos, de forma que cada sello incluya el anterior formando una cadena.

Sección 4: la prueba de trabajo

Para que el sellado de tiempo sea distribuido y no dependa de un servidor, se usa una prueba de trabajo al estilo Hashcash: buscar un valor (el nonce) que, al aplicar el hash al bloque, dé como resultado un hash que empiece por cierto número de ceros. El trabajo medio crece de forma exponencial con el número de ceros exigidos, pero verificarlo es un solo hash. Como cada bloque contiene el hash del anterior, para cambiar un bloque habría que rehacer el trabajo de ese bloque y de todos los posteriores. La prueba de trabajo resuelve además otro problema: quién decide. En una votación “una persona, un voto”, quien pueda crear muchas identidades falsas manipularía el resultado. La prueba de trabajo es “un procesador, un voto”: la cadena más larga representa la mayor cantidad de trabajo invertido, y esa es la decisión de la mayoría.

Sección 5: la red

Los pasos para ejecutar la red son sencillos: 1) las transacciones nuevas se difunden a todos los nodos; 2) cada nodo reúne las nuevas transacciones en un bloque; 3) cada nodo trabaja en encontrar una prueba de trabajo difícil para su bloque; 4) cuando un nodo la encuentra, difunde el bloque a todos; 5) los nodos aceptan el bloque solo si todas sus transacciones son válidas y no gastadas; 6) los nodos expresan su aceptación trabajando en el siguiente bloque, usando el hash del bloque aceptado como hash previo. Los nodos consideran correcta la cadena más larga y trabajan para extenderla. Si dos nodos difunden versiones distintas a la vez, trabajan sobre la primera que recibieron, pero guardan la otra; el empate se rompe cuando una de las ramas se hace más larga.

Sección 6: el incentivo

Por convención, la primera transacción de cada bloque es especial: crea unas monedas nuevas que pertenecen al creador del bloque. Eso añade un incentivo para que los nodos apoyen la red y es, además, una forma de distribuir monedas inicialmente, ya que no hay una autoridad que las emita. La adición constante de una cantidad fija de monedas nuevas es análoga a mineros de oro que gastan recursos para añadir oro a la circulación; aquí el recurso gastado es tiempo de CPU y electricidad. El incentivo también puede financiarse con comisiones por transacción, cuando el número de monedas alcance el límite. Satoshi añade un argumento sutil: un atacante con más potencia que el resto de la red tendría que elegir entre defraudar para recuperar sus pagos o usar su poder para generar monedas nuevas, y le resultaría más rentable seguir las reglas.

Secciones 7 a 10: eficiencia y privacidad

La sección 7 introduce los árboles de Merkle para que los nodos puedan descartar transacciones ya gastadas y ahorrar disco, dejando solo la raíz en la cabecera del bloque. La 8 describe la verificación simplificada de pagos (SPV): un usuario puede verificar un pago sin ejecutar un nodo completo, guardando solo las cabeceras de bloque y pidiendo a un nodo la rama de Merkle que enlaza la transacción con un bloque. La 9 explica por qué las transacciones tienen múltiples entradas y salidas, lo que permite combinar y dividir valor (el modelo de “monedas” de distinto valor que verás en el módulo 2). La 10 trata la privacidad: el modelo tradicional la protege limitando el acceso a la información a las partes y al tercero de confianza; aquí las transacciones son públicas, pero se mantiene la privacidad rompiendo el flujo de información en otro punto: las claves públicas son anónimas. Se ve “que alguien envía una cantidad a otro”, pero no quién es cada uno. Como cortafuegos adicional, se recomienda usar un par de claves nuevo para cada transacción.

Sección 11: la matemática del atacante

Satoshi modela la carrera entre la cadena honesta y la de un atacante como un camino aleatorio de “jugador arruinado”: cada bloque es un paso, y la probabilidad de que la cadena del atacante alcance a la honesta cae de forma exponencial con el número de bloques de ventaja. Incluye una tabla con valores de probabilidad.

Las tres ideas que sostienen todo

  1. La moneda es una cadena de firmas. Recibes una moneda con la firma de quien te la transfiere, y tú la transferirás firmando con tu clave. Lo que no puedes saber solo con firmas es si el dueño anterior ya la había gastado antes.
  2. El orden lo da el trabajo. Un sellado de tiempo distribuido, anclado en prueba de trabajo, hace que la historia más pesada sea la verdad aceptada. Para cambiar un bloque antiguo hay que rehacer todos los posteriores y además superar a los mineros honestos.
  3. El incentivo cierra el círculo. Un atacante con mayoría de potencia podría hacer trampas, pero Satoshi argumenta que le conviene más ser honesto: ganará más cobrando recompensas que destruyendo el valor de lo que posee.

Lo que el libro blanco NO dice

  • No usa la palabra “blockchain”. Habla de una cadena de bloques (chain of blocks) pero el término de marketing vino después.
  • No describe Lightning ni los scripts que hoy usamos. Esos detalles están en el código y en los BIP.
  • No promete anonimato: dice privacidad por seudónimos, y avisa de que si se descubre el dueño de una clave, el enlace con sus otras transacciones puede salir a la luz.
  • No define cuántos bitcoin habrá. El límite de 21 millones está en el código, no en el documento.
  • No habla de “minería” a escala industrial ni de ASIC: imagina nodos de CPU en ordenadores normales, “un procesador, un voto”.

El bloque génesis

El 3 de enero de 2009 se minó el primer bloque. En su transacción de recompensa (coinbase) hay un mensaje: “The Times 03/Jan/2009 Chancellor on brink of second bailout for banks”. Sirve a la vez de prueba de que el bloque no se minó antes de esa fecha y de declaración de intenciones. En el siguiente módulo comprobaremos su hash con tu propio código.

Cómo leerlo tú

Haz una primera lectura rápida de principio a fin (media hora). Después, una segunda lectura con papel: junto a cada sección, escribe con tus palabras qué problema resuelve y qué pasaría si faltara. Si puedes explicarlo a alguien que no sabe del tema en tres minutos, lo has entendido. Si te atascas en la sección 11, no pasa nada: es solo probabilidad, y la retomaremos con código.

Comprueba lo aprendido

¿Qué hace costoso reescribir un bloque antiguo?

¿Dónde está definido el límite de 21 millones?

En el libro blanco, ¿cómo se protege la privacidad si las transacciones son públicas?

¿Qué problema resuelve la prueba de trabajo, además de ordenar bloques?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 1
Introducción a Bitcoin · lección 5 de 6 · 22 min

Primeros años: de Satoshi a la comunidad

Entre 2009 y 2014 Bitcoin pasó de experimento a red global. Conocer esos hitos te ayuda a ver qué ha cambiado y qué no.

2009Génesis2010Pizza2011Silk Road2013Primeros ASIC2014Mt. GoxCada crisis dejó una lección que el curso retoma
Cinco años de un experimento que se convirtió en red.

Cronología comprobada

FechaHito
31 oct 2008Satoshi publica el libro blanco en la lista de criptografía
3 ene 2009Bloque génesis
9 ene 2009Satoshi publica Bitcoin 0.1
12 ene 2009Primera transacción entre personas: Satoshi envía 10 BTC a Hal Finney (bloque 170)
oct 2009Primer precio publicado: New Liberty Standard fija una cotización basada en el coste de electricidad
22 may 2010“Bitcoin Pizza Day”: 10.000 BTC por dos pizzas (Laszlo Hanyecz)
jul 2010Aparece Mt. Gox como bolsa; primer repunte de atención
dic 2010Satoshi se retira de la vida pública y cede el repositorio y la alerta a otros
feb 2011Silk Road abre; Bitcoin alcanza la paridad con el dólar
2013Chipre y la discusión sobre los depósitos; primeros ASIC de minería
feb 2014Mt. Gox suspende retiros y se declara en quiebra

2009-2010: arrancar sin gente

Durante el primer año el único usuario con interés real era un puñado de criptógrafos y programadores. Satoshi minaba de forma casi constante, y se calcula que acumuló más de un millón de bitcoin que nunca ha movido. Cuando Finney recibió los primeros 10 BTC, escribió en su cuenta de Twitter “Running bitcoin”. Los primeros contribuyentes (Finney, Martti Malmi, Gavin Andresen, entre otros) añadieron funciones, arreglaron errores y fundaron foros. El 22 de mayo de 2010 un programador pagó 10.000 BTC por dos pizzas. Es la primera compra documentada de un bien físico, y se celebra cada año.

Un incidente que enseñó mucho: agosto de 2010

El 15 de agosto de 2010 se descubrió que un bloque contenía una transacción que creaba 184.467.440.737 BTC de la nada, por un desbordamiento de enteros en la verificación de valores. En pocas horas se publicó una corrección de código, y la red adoptó la versión corregida, descartando ese bloque. Es una anécdota instructiva: el software cometió un error grave, y la comunidad lo arregló rápido porque había nodos que lo verificaban y desarrolladores que lo corrigieron. Lo contrario de un servidor opaco.

2011-2013: las primeras oleadas

En 2011 llegaron Silk Road, un mercado en la red Tor que usaba bitcoin y acabó cerrado por las autoridades en 2013, las primeras bolsas importantes y un aumento del precio y del interés mediático. En 2013 la crisis de Chipre (con un recorte a los depósitos bancarios) coincidió con otra oleada de interés. Aparecieron los primeros ASIC, chips diseñados solo para minar, y con ellos la minería se profesionalizó: los ordenadores domésticos dejaron de ser competitivos.

2014: Mt. Gox

En febrero de 2014 Mt. Gox, la bolsa que llegó a gestionar más de la mitad de las operaciones del mundo, suspendió los retiros y declaró la quiebra con unos 850.000 bitcoin (propios y de clientes) desaparecidos. Aquella pérdida fue enorme y dejó una frase que se repite desde entonces: not your keys, not your coins (si no controlas tus claves, no controlas tus monedas). El proceso de devolución a los acreedores se alargó durante años.

Lecciones que se repiten

  • Custodia: casi todas las pérdidas grandes (Mt. Gox y muchas más) vinieron de entregar las claves a un tercero. Lo veremos en el módulo de seguridad.
  • El proyecto es de todos: Satoshi desaparece, y el software sigue mejorando por consenso rugoso entre desarrolladores, mineros, empresas y usuarios que ejecutan nodos.
  • La adopción llega por oleadas, ligada a crisis de confianza (2008, 2013, 2020...).
  • Los errores se arreglan en público: el desbordamiento de 2010 es un ejemplo.

Para pensar

¿Qué cambia cuando el creador no puede ser presionado porque no se sabe quién es? Esa pregunta, sobre liderazgo y gobernanza, volverá en el módulo de protocolo.

Comprueba lo aprendido

¿Qué ocurrió el 12 de enero de 2009?

¿Qué enseñó el incidente de agosto de 2010 sobre el desbordamiento de enteros?

¿Cuál es la lección principal de Mt. Gox?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 1
Introducción a Bitcoin · lección 6 de 6 · 30 min

Lecturas canónicas con guía de debate

Siete textos que todo estudiante serio de Bitcoin acaba leyendo. No los resumimos para que no los leas: te damos preguntas para discutirlos en grupo o contigo mismo.

Manifiestos cypherpunkEnsayos de SzaboLibro blancoMastering Bitcoin
Una pila de lecturas: de la teoría al código.

Cómo usar esta lección

Lee uno por semana. Escribe tres líneas: qué afirma, qué supone y qué evidencia daría la razón al autor o se la quitaría. Si puedes, discútelo con alguien que piense distinto.

TextoAutor y añoPregunta para el debate
A Cypherpunk's ManifestoEric Hughes, 1993¿Qué parte de su definición de privacidad sigue cumpliéndose hoy y cuál no?
Shelling Out: The Origins of MoneyNick Szabo, 2002¿Por qué el dinero necesita ser difícil de falsificar “automáticamente”? ¿Se cumple en Bitcoin?
Trusted Third Parties Are Security HolesNick Szabo, 2001Piensa en tres terceros de confianza de tu vida financiera. ¿Qué pasaría si fallaran?
The Bullish Case for BitcoinVijay Boyapati, 2018El marco “coleccionable → reserva de valor → medio de cambio”: ¿qué evidencia lo apoya y cuál lo contradice?
Bitcoin is VeniceAllen Farrington, 2021¿Qué analogías históricas aguantan y cuáles son forzadas?
Bitcoin: A Peer-to-Peer Electronic Cash SystemSatoshi Nakamoto, 2008Relee la sección 12. ¿Qué prometió y qué no?
Mastering Bitcoin, cap. 1-2Antonopoulos y Harding¿Qué entenderías mejor si hicieras el ejercicio con tus propias manos?

Reglas de lectura crítica

  1. Separa hechos, interpretaciones y predicciones.
  2. Busca la mejor crítica de cada texto, escrita por alguien inteligente.
  3. Si un argumento te convence demasiado rápido, vuelve a leerlo.
  4. Anota qué evidencia cambiaría tu opinión. Si ninguna puede cambiarla, no es una opinión sino una creencia.

Textos con licencia abierta o de dominio público

Una buena noticia para estudiar Bitcoin: gran parte de la literatura técnica es libre. Estos son los que puedes leer, descargar y compartir (respetando la licencia de cada uno):

  • Mastering Bitcoin (Antonopoulos y Harding): el texto completo está en GitHub bajo licencia Creative Commons. Revisa la licencia de la edición que uses.
  • Mastering the Lightning Network (Antonopoulos, Osuntokun y Pickhardt): CC BY-SA 4.0.
  • Learning Bitcoin from the Command Line (Blockchain Commons): CC BY 4.0, ideal para practicar con un nodo.
  • Las especificaciones: los BIP de Bitcoin y los BOLT de Lightning son públicos y abiertos.
  • Los ensayos de Szabo, Hughes, May y los mensajes de Satoshi: publicados libremente por sus autores y reunidos en el Nakamoto Institute.
  • Textos clásicos de dominio público, que usaremos en el módulo de ciencias sociales: por ejemplo, Sobre el origen del dinero de Carl Menger.

Otros libros, como The Bitcoin Standard (Saifedean Ammous) o Criptoria (Alfre Mancera, en español), son obras comerciales con derechos de autor: no los copiamos ni los resumimos entero. Te recomendamos leerlos, comprarlos o pedirlos en una biblioteca, y contrastarlos con las fuentes primarias que te damos aquí.

Una rutina de ocho semanas

  1. Semana 1: Hughes (manifiesto) + May (manifiesto criptoanarquista).
  2. Semana 2: Szabo, Trusted Third Parties + Shelling Out.
  3. Semana 3: libro blanco, primera lectura.
  4. Semana 4: libro blanco con tus notas + Mastering Bitcoin cap. 1-2.
  5. Semana 5: Mastering Bitcoin cap. 3-4 (nodo y claves).
  6. Semana 6: Mastering Bitcoin cap. 5-6.
  7. Semana 7: un ensayo con el que no estés de acuerdo y su mejor réplica.
  8. Semana 8: escribe una página sobre “qué sigue sin estar resuelto en Bitcoin”.

Comprueba lo aprendido

¿Cuál es una buena práctica al leer un ensayo apasionado sobre Bitcoin?

¿Qué libro de la lista es de acceso libre y tiene una licencia Creative Commons, y se puede leer completo en GitHub?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 2
La tecnología de Bitcoin · lección 1 de 10 · 40 min

Taller 0: tu primer programa en Python

Si nunca has escrito código, este es tu punto de partida. En una hora tendrás Python instalado, sabrás usar la terminal y habrás ejecutado tu primer laboratorio. Todo lo que sigue en el curso depende de esto.

Archivo .pyPython loejecutaLees elresultadoUn laboratorio es solo eso: un archivo de texto con instrucciones
Tú escribes un archivo, Python lo ejecuta y tú compruebas el resultado.

Por qué programar para aprender Bitcoin

Se puede entender Bitcoin con dibujos y analogías, y eso es lo que has hecho hasta ahora. Pero hay un salto entre “creer que lo entiendes” y “haberlo comprobado”. Cuando calculas tú mismo el hash del bloque génesis o firmas un mensaje con una clave que generaste, dejas de depender de que alguien te lo explique. Eso es, además, el espíritu de Bitcoin: don't trust, verify (no confíes, verifica).

No necesitas ser programador. Los laboratorios están escritos para leerse como se lee una receta: cada línea hace una cosa pequeña y los comentarios te dicen cuál. Tu trabajo será ejecutarlos, leer la salida y modificar un valor para ver qué cambia. Eso ya es aprender a programar sin darte cuenta.

Qué es la terminal (y por qué no da miedo)

La terminal es una ventana donde, en lugar de hacer clic, escribes órdenes y el ordenador responde con texto. Es más antigua que los ratones y sigue siendo la forma más rápida y precisa de trabajar con programas. Para este curso solo necesitas cinco órdenes:

Orden (Mac y Linux)Orden (Windows PowerShell)Qué hace
pwdpwd o cdMuestra en qué carpeta estás
lsls o dirLista los archivos de la carpeta
cd nombrecd nombreEntra en la carpeta nombre
cd ..cd ..Sube a la carpeta anterior
mkdir nombremkdir nombreCrea una carpeta nueva

Cómo abrirla

  • macOS: pulsa Cmd + Espacio, escribe Terminal y pulsa Intro.
  • Windows 10/11: pulsa la tecla Windows, escribe PowerShell (o Terminal) y pulsa Intro.
  • Linux: normalmente Ctrl + Alt + T, o busca “Terminal” en tus aplicaciones.

Verás una línea con un cursor parpadeando. Esa línea se llama prompt. Todo lo que escribas aparecerá ahí y no se ejecuta hasta que pulses Intro.

Instalar Python

Python es el lenguaje de programación que usamos porque se lee casi como inglés. Necesitas la versión 3.8 o superior (las recientes, 3.11, 3.12 o 3.13, son perfectas).

macOS

  1. Abre python.org/downloads y descarga el instalador para macOS.
  2. Ábrelo y sigue los pasos (siguiente, siguiente, instalar).
  3. Abre una terminal nueva y escribe python3 --version. Debe responder algo como Python 3.12.4.

Alternativa si usas Homebrew: brew install python.

Windows

  1. Abre python.org/downloads y descarga el instalador para Windows.
  2. Importante: en la primera pantalla del instalador, marca la casilla “Add python.exe to PATH” antes de pulsar “Install Now”. Si te la saltas, la terminal no encontrará Python.
  3. Abre una PowerShell nueva y escribe py --version (o python --version). Debe responder con la versión.

Linux (Debian, Ubuntu y derivados)

sudo apt update
sudo apt install python3
python3 --version

En otras distribuciones usa tu gestor de paquetes (dnf install python3, pacman -S python).

Un editor para ver y cambiar el código

Necesitas un programa que abra archivos de texto plano (nada de Word, que añade formato y rompe los programas). Recomendamos Visual Studio Code: gratuito, resalta el código con colores y funciona en los tres sistemas. También sirven el Bloc de notas (Windows), TextEdit en modo texto plano (Mac) o gedit (Linux), con la salvedad de que no ayudan tanto.

Tu carpeta de trabajo

  1. En la terminal, crea una carpeta para el curso: mkdir labs-bitcoin.
  2. Entra en ella: cd labs-bitcoin.
  3. Comprueba que estás dentro con pwd. Debe terminar en labs-bitcoin.

Desde ahora, todos los laboratorios se guardan en esta carpeta. Algunos dependen de otros (el laboratorio de direcciones usa el de firmas): por eso es importante que estén todos juntos y con el nombre exacto que se indica en cada uno.

Tu primer programa

En VS Code (o tu editor), crea un archivo nuevo, escribe esto y guárdalo en labs-bitcoin con el nombre hola.py:

import hashlib

mensaje = "Hola, Bitcoin"
huella = hashlib.sha256(mensaje.encode()).hexdigest()

print("Mensaje:", mensaje)
print("Su huella SHA-256 es:", huella)

Qué hace cada línea:

  1. import hashlib carga la biblioteca de Python que sabe calcular hashes.
  2. mensaje = "Hola, Bitcoin" guarda un texto en una “caja” llamada mensaje.
  3. huella = ... convierte el texto a bytes (.encode()), calcula su SHA-256 y lo muestra en hexadecimal (.hexdigest()).
  4. Las dos líneas print escriben en la pantalla.

Ahora ejecútalo. En la terminal (dentro de labs-bitcoin):

python3 hola.py

En Windows usa py hola.py. Debe aparecer tu mensaje y una huella de 64 caracteres. Acabas de calcular un hash de Bitcoin. Prueba a cambiar “Hola” por “hola” (con minúscula), guarda y ejecuta otra vez: la huella cambia por completo.

Cómo ejecutar los laboratorios del curso

Cada laboratorio del curso tiene tres partes: una guía paso a paso, el código completo (despliega “Ver el código completo”) y la salida de una ejecución real. El método es siempre el mismo:

  1. Pulsa Copiar en el código.
  2. Pégalo en un archivo nuevo del editor y guárdalo con el nombre que dice la cabecera del laboratorio, dentro de labs-bitcoin.
  3. Ejecuta python3 nombre_del_archivo.py.
  4. Compara tu salida con la del curso. Si es igual (o igual salvo los números aleatorios que se indican), lo has hecho bien.
  5. Haz los experimentos de la sección “Prueba esto”.

Errores frecuentes y qué significan

Lo que vesQué significaCómo arreglarlo
python3: command not found o “no se reconoce como un comando”Python no está instalado o no está en el PATHReinstala marcando “Add to PATH” (Windows), o prueba python / py
No such file or directoryEstás en otra carpeta o el nombre del archivo está mal escritoUsa pwd y ls para ver dónde estás y qué hay
SyntaxErrorHay un error al escribir el código (comillas, paréntesis, sangría)Vuelve a copiar con el botón; usa un editor de texto plano
IndentationErrorLa sangría (los espacios al inicio de línea) está malNo mezcles tabuladores y espacios; copia el código tal cual
ModuleNotFoundErrorEl archivo importa otro que no está en la carpetaGuarda todos los laboratorios en la misma carpeta con su nombre exacto
NameErrorEscribiste el nombre de una variable distinto al que definisteRevisa mayúsculas y minúsculas: Mensaje y mensaje son distintos

Leer un error sin entrar en pánico

Cuando Python falla, escribe un mensaje largo. Lee solo las dos últimas líneas: la última dice el tipo de error y el motivo; la anterior, en qué línea del archivo ocurrió. Con eso casi siempre basta. Copiar el error en un buscador o en un asistente de IA también funciona: es una habilidad normal de los programadores profesionales, no una trampa.

Mapa de dependencias de los laboratorios

LaboratorioArchivoNecesita en la misma carpeta
Hash y cabecera del génesislab01_hash_y_cabecera.pynada
Campos finitoslab11_campos_finitos.pynada
Firmas ECDSAlab03_ecdsa_secp256k1.pynada
Direccioneslab04_direcciones.pylab03_ecdsa_secp256k1.py
Transacciónlab05_transaccion.pylab03 y lab04
SIGHASHlab12_sighash.pynada
Árbol de Merklelab06_merkle.pynada

Comprueba lo aprendido

¿Por qué no se debe usar Word para escribir los laboratorios?

Un laboratorio falla con ModuleNotFoundError: No module named 'lab03_ecdsa_secp256k1'. ¿Cuál es la causa más probable?

En Windows, ¿qué casilla hay que marcar al instalar Python?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 2
La tecnología de Bitcoin · lección 2 de 10 · 24 min

Hashes: la huella digital de los datos

Todo en Bitcoin se apoya en funciones hash. Si entiendes tres propiedades, entiendes por qué la cadena no se puede falsificar.

Datos decualquier tamaño#SHA-256Huella de 64caracteresMismo dato, misma huella; un bit distinto, otra huella
Un hash convierte datos de cualquier tamaño en una huella fija.

Una analogía antes de la técnica

Imagina un sello de lacre que se genera a partir del contenido de una carta: si cambias una sola palabra, el sello resultante es distinto. Nadie puede reconstruir la carta mirando el sello, pero cualquiera con la carta puede comprobar que el sello es el suyo. Una función hash es ese sello, calculado con matemáticas.

SHA-256 y sus propiedades

Una función hash toma datos de cualquier tamaño y devuelve una huella de tamaño fijo (256 bits en SHA-256, 64 caracteres hexadecimales). Las propiedades que Bitcoin necesita:

  1. Determinista: la misma entrada siempre da la misma huella.
  2. Efecto avalancha: cambiar un solo bit cambia ~la mitad de los bits de la salida.
  3. Resistente a preimagen: dado el hash, es inviable encontrar una entrada que lo produzca.
  4. Resistente a colisiones: es inviable encontrar dos entradas con el mismo hash.

Bitcoin usa doble SHA-256 (SHA256(SHA256(x))) para identificadores de bloques y transacciones, y HASH160 (RIPEMD160(SHA256(x))) para direcciones. Es una decisión de diseño de Satoshi, y un cinturón extra contra ciertos ataques de extensión de longitud.

Qué tan inviable es “inviable”

Un hash de 256 bits tiene 2²⁵⁶ salidas posibles, aproximadamente 10⁷⁷, un número comparable al de átomos en el universo observable. Para encontrar por casualidad una colisión haría falta del orden de 2¹²⁸ intentos, que ningún ordenador actual ni previsible puede dar. Para una preimagen (dado un hash, hallar su entrada) harían falta 2²⁵⁶. Por eso Bitcoin puede basarse en ellos sin necesidad de una autoridad.

Dos matices para no exagerar: SHA-1 (160 bits) sí se rompió en la práctica con una colisión pública en 2017; por eso las funciones antiguas se retiran. Y los hashes no protegen las entradas pequeñas y predecibles: si el dato es “1234”, un atacante puede probar todas las opciones. La seguridad depende de que el dato tenga suficiente entropía.

Pruébalo en 30 segundos

import hashlib
h = lambda b: hashlib.sha256(b).hexdigest()
print(h(b"Bitcoin"))
print(h(b"bitcoin"))   # una letra distinta -> huella totalmente distinta

Antes de ejecutar nada en Python, juega aquí: escribe en los dos cuadros y mira cuántos bits cambian de una huella a otra.

Compara las dos salidas: no se parecen en nada. Eso es el efecto avalancha. Para ejecutarlo, copia el código en un archivo hash.py dentro de tu carpeta labs-bitcoin y ejecuta python3 hash.py (en Windows, py hash.py).

Qué significan las letras y los números

Una huella como b4056df6691f8dc7... está escrita en hexadecimal: cada carácter representa 4 bits (los dígitos 0-9 y las letras a-f valen de 0 a 15). 64 caracteres hexadecimales son 256 bits. Cuando en Bitcoin se dice que un bloque “empieza por diez ceros”, significa que los primeros 40 bits del hash son cero, y eso ocurre solo una vez cada 2⁴⁰ intentos (más de un billón).

Doble hash y HASH160: por qué dos funciones

  • Doble SHA-256 se usa en identificadores de bloques y transacciones y en el checksum de las direcciones. Es robusto frente a ataques de extensión de longitud.
  • HASH160 acorta el resultado a 20 bytes y combina dos algoritmos distintos: si uno tuviera un fallo, el otro seguiría protegiendo. Esto hace las direcciones más cortas.

Por qué sirven para una cadena

Cada bloque guarda el hash del anterior. Si alguien cambia una transacción antigua, el hash de ese bloque cambia, el siguiente ya no “apunta” al bloque correcto y la cadena entera se rompe desde ahí. Para repararla, tendría que rehacer la prueba de trabajo de todos los bloques posteriores (lo veremos en el módulo de minería).

Un uso más: los compromisos

Los hashes sirven para comprometerse con un dato sin revelarlo. Si publicas el hash de tu predicción hoy y revelas la predicción mañana, todos pueden verificar que no la cambiaste. Bitcoin usa esta idea en direcciones (el hash de tu clave pública) y en Taproot. Lo verás en acción en los módulos siguientes.

Comprueba lo aprendido

Cambias una sola coma en una transacción antigua. ¿Qué pasa con la cadena?

¿Cuántos bits tiene un hash SHA-256?

¿Por qué un hash de un dato muy predecible (como un número de cuatro cifras) no protege ese dato?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 2
La tecnología de Bitcoin · lección 3 de 10 · 40 min

Campos finitos y curvas elípticas, desde cero

Antes de firmar con ECDSA hay que entender dónde se hace la matemática. Aquí la construyes con 60 líneas, con pruebas, en un campo tan pequeño que puedes comprobarlo a mano.

P2P4P8P16Pk·P se calcula rápido; deshacerlo, no
Duplicar y sumar: pocos pasos para llegar muy lejos.

Para qué necesitamos matemáticas nuevas

Con los hashes sabes huellar datos. Para firmar hace falta algo más: una operación que sea fácil en un sentido y prácticamente imposible en el otro, pero que además tenga estructura algebraica (se pueda sumar, multiplicar y comprobar). Las curvas elípticas ofrecen justo eso con claves muy cortas: 256 bits dan una seguridad que con RSA exigiría unos 3.000 bits.

Un campo finito

Un campo finito F<sub>p</sub> son los números 0, 1, …, p−1 (con p primo) donde sumas, restas, multiplicas y divides siempre obtienes otro número del mismo conjunto. Se hace “dando la vuelta” al reloj: en p = 223, 200 + 40 = 17.

Una forma de verlo: un reloj de 223 horas. Cuando te pasas de la última hora, vuelves a empezar. Que el número de horas sea primo garantiza que se pueda dividir (excepto por cero): todos los números distintos de cero tienen inverso multiplicativo.

La división es la clave: a / b = a · b^(p−2) porque, por el pequeño teorema de Fermat, b^(p−1) = 1.

Ejemplo a mano

El laboratorio te dirá que, en el reloj de 223 horas, 3 / 24 = 28. Compruébalo tú: dividir entre 24 significa que 24 × resultado debe valer 3 dentro del reloj.

  1. Multiplica: 24 × 28 = 672.
  2. Da vueltas al reloj: 672 = 3 × 223 + 3, es decir, sobran 3 después de 3 vueltas completas.
  3. Efectivamente, 24 × 28 ≡ 3 (mod 223). La división funciona.

Para calcular ese 28 el programa usa la fórmula de Fermat (a · b^(p−2)); tú no tienes que hacerlo a mano. Lo importante es la idea: dividir en un campo finito es multiplicar por una potencia grande, y siempre da un resultado exacto.

Una curva y sus puntos

La curva de Bitcoin es y² = x³ + 7 sobre F<sub>p</sub>. Los puntos (x, y) que cumplen la ecuación forman un grupo: puedes sumar dos puntos y obtener un tercero. Sumar un punto consigo mismo k veces (k·P) es fácil; deshacerlo (dado k·P y P, hallar k) es inviable con números grandes. Esa asimetría es toda la seguridad de las claves.

En el plano de los números reales la curva se ve como una línea suave. Para sumar dos puntos P y Q se traza la recta que los une, se busca el tercer punto donde la recta corta la curva y se toma su reflejo respecto al eje x. Sobre un campo finito la imagen se vuelve una nube de puntos dispersa, pero las fórmulas son las mismas.

Duplicar y sumar

Para calcular k·P con k de 256 bits no se suma P cuatro mil billones de billones de veces. Se hace con el método de duplicar y sumar: se escribe k en binario y se recorren sus bits, duplicando el punto en cada paso y sumándolo cuando el bit es 1. Eso son unas 256 duplicaciones y unas 128 sumas. Es lo que hace el método __rmul__ del laboratorio, en seis líneas.

Míralo moverse

En esta curva de juguete (223 números) puedes ver cómo salta el punto K = k·G cuando cambias k, y probar a adivinar k desde K:

Laboratorio 2.0

Laboratoriolab11_campos_finitos.py
Guía paso a paso para principiantes

Qué vas a hacer

Vas a ejecutar un programa que hace aritmética en un “reloj” de 223 posiciones y que suma puntos de una curva sobre ese reloj. Es la misma matemática que protege tus claves de Bitcoin, pero con un número tan pequeño que puedes comprobarlo a mano.

Antes de empezar

  • Tienes Python instalado y sabes abrir una terminal (si no, haz primero el Taller 0 de este módulo).
  • Crea una carpeta llamada labs-bitcoin y guarda este archivo dentro con el nombre exacto lab11_campos_finitos.py.

Paso a paso

  1. Abre la terminal y entra en la carpeta: cd labs-bitcoin (en Windows PowerShell funciona igual).
  2. Ejecuta el programa: python3 lab11_campos_finitos.py (en Windows: py lab11_campos_finitos.py).
  3. Compara tu salida con la que ves en “Salida de una ejecución real”. Tiene que ser idéntica: aquí no hay azar.
  4. Abre el archivo con un editor de texto (por ejemplo VS Code o el Bloc de notas) y busca la línea p = 223. Es el tamaño del reloj.

Cómo leer lo que sale

  • 3/24 = FE_223(28) significa que, dentro del reloj de 223, dividir 3 entre 24 da 28. Compruébalo: 24 × 28 = 672 y 672 dividido entre 223 deja resto 3. Funciona.
  • “El punto (47,71) tiene orden 21” significa que, si sumas ese punto consigo mismo 21 veces, vuelves al punto “infinito” (el cero del grupo). Es como dar vueltas a un circuito que tiene 21 paradas.
  • “Rechaza un punto fuera de la curva” demuestra que el programa comprueba la ecuación y² = x³ + 7 antes de aceptar un punto.

Prueba esto

  • Cambia p = 223 por p = 31 y ejecuta de nuevo. Fallará en alguna comprobación: ¿por qué? (Pista: los números 44, 33, etc. están pensados para el reloj de 223.)
  • Escribe al final del archivo print(5 * P) justo después de la línea donde se define P y mira qué punto sale.
  • Intenta encontrar a mano otro punto de la curva: elige una x, calcula x³ + 7 y mira si tiene raíz cuadrada.

Si algo falla

  • python3: command not found o “no se reconoce”: prueba con python o py. Si ninguno funciona, repasa la instalación del Taller 0.
  • No such file or directory: no estás en la carpeta correcta. Escribe pwd (Mac/Linux) o cd (Windows) para ver dónde estás y ls / dir para ver los archivos.
  • SyntaxError: el archivo se copió mal (por ejemplo, con comillas “curvas” en lugar de rectas). Vuelve a copiar con el botón Copiar y pega en un editor de texto plano.
Ver el código completo
"""Lab 2.0 - Campos finitos y curvas elípticas desde cero (antes de ECDSA). Solo estándar, con pruebas.
Un campo finito F_p: números 0..p-1 con suma, resta, producto y división módulo p (p primo)."""
class FE:
    def __init__(s, n, p): s.n, s.p = n % p, p
    def __add__(s, o): return FE(s.n + o.n, s.p)
    def __sub__(s, o): return FE(s.n - o.n, s.p)
    def __mul__(s, o): return FE(s.n * o.n, s.p)
    def __pow__(s, k): return FE(pow(s.n, k % (s.p - 1), s.p), s.p)           # Fermat: a^(p-1) = 1
    def __truediv__(s, o): return s * (o ** (s.p - 2))                           # a / b = a * b^(p-2)
    def __eq__(s, o): return s.n == o.n and s.p == o.p
    def __repr__(s): return f'FE_{s.p}({s.n})'

class Pt:
    """Punto de y^2 = x^3 + a x + b sobre F_p. None = infinito (el 'cero' del grupo)."""
    def __init__(s, x, y, a, b):
        s.x, s.y, s.a, s.b = x, y, a, b
        if x is not None and not (y*y == x*x*x + a*x + b): raise ValueError(f'({x},{y}) no está en la curva')
    def __eq__(s, o): return (s.x, s.y) == (o.x, o.y) and s.a == o.a
    def __add__(s, o):
        if s.x is None: return o
        if o.x is None: return s
        if s.x == o.x and s.y != o.y: return Pt(None, None, s.a, s.b)
        if s.x != o.x:
            m = (o.y - s.y) / (o.x - s.x)
        else:
            m = (FE(3, s.x.p) * s.x * s.x + s.a) / (FE(2, s.x.p) * s.y)
        x3 = m*m - s.x - o.x
        return Pt(x3, m*(s.x - x3) - s.y, s.a, s.b)
    def __rmul__(s, k):
        r, cur = Pt(None, None, s.a, s.b), s
        while k:
            if k & 1: r = r + cur
            cur = cur + cur; k >>= 1
        return r

if __name__ == '__main__':
    p = 223
    f = lambda n: FE(n, p)
    # Pruebas del campo
    assert f(44) + f(33) == f(77 % p) and f(9) - f(29) == f(203) and f(17) * f(13) == f(221)
    assert f(7) ** 3 == f(343 % p) and f(3) / f(24) == f(28)
    print('Aritmética de campo OK (p = 223): 3/24 =', f(3) / f(24))
    # Curva y^2 = x^3 + 7 sobre F_223
    a, b = f(0), f(7)
    P = Pt(f(47), f(71), a, b)
    orden = next(k for k in range(1, 400) if (k * P).x is None)
    print('El punto (47,71) tiene orden', orden, ' -> 21*(47,71) es el infinito:', (21 * P).x is None)
    print('2*(47,71) =', (2 * P).x, (2 * P).y, '| 8*(47,71) =', (8 * P).x, (8 * P).y)
    try: Pt(f(200), f(119), a, b)
    except ValueError as e: print('Rechaza un punto fuera de la curva:', e)
    print('Con p de 256 bits el mismo código es secp256k1: la seguridad viene del tamaño, no de otra matemática.')
Salida de una ejecución real
Aritmética de campo OK (p = 223): 3/24 = FE_223(28)
El punto (47,71) tiene orden 21  -> 21*(47,71) es el infinito: True
2*(47,71) = FE_223(36) FE_223(111) | 8*(47,71) = FE_223(116) FE_223(55)
Rechaza un punto fuera de la curva: (FE_223(200),FE_223(119)) no está en la curva
Con p de 256 bits el mismo código es secp256k1: la seguridad viene del tamaño, no de otra matemática.

Fíjate en que el punto (47, 71) tiene orden 21: sumado 21 veces vuelve al “infinito”. En secp256k1 el orden del punto generador es un número de 256 bits (el mismo N que usa el laboratorio de firmas). Para ese tamaño, probar todos los k llevaría más tiempo que la edad del universo.

Del juguete a secp256k1

Cambiar el campo pequeño por uno enorme transforma el mismo programa en el de Bitcoin. Los parámetros de secp256k1 son:

  • p = 2²⁵⁶ − 2³² − 977 (un primo especial, cerca de una potencia de dos, que facilita los cálculos).
  • Curva: y² = x³ + 7 (a = 0, b = 7).
  • G: un punto generador fijo, publicado en el estándar SEC 2.
  • N: el orden de G, un número primo de 256 bits (aproximadamente 1,16 × 10⁷⁷).

Tu clave privada es un número entre 1 y N−1. Tu clave pública es K = k · G. Eso es todo.

Comprueba lo aprendido

¿Por qué k·P es fácil de calcular y difícil de invertir?

¿Qué hace que en un campo finito siempre se pueda dividir (salvo por cero)?

Una clave privada de 256 bits y una RSA de 3.072 bits ofrecen seguridad parecida. ¿Qué ventaja tiene la curva elíptica?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 2
La tecnología de Bitcoin · lección 4 de 10 · 36 min

Claves y firmas digitales

Una firma prueba que alguien con la clave privada autorizó un mensaje, sin revelar la clave. Vamos a construir ECDSA sobre secp256k1 desde cero.

ClaveprivadaMensajeFirma (rs)Verifica conla públicaSolo quien tiene la clave privada puede producir la firma
La clave privada firma; la pública verifica. De una a otra solo se va en un sentido.
clave privada(secreta)k · Gclave pública(se comparte)firma (r, s)
La clave privada firma; la pública verifica. De una a otra solo se va en un sentido.

La idea

Tienes un número secreto grande, la clave privada k. Multiplicando k por un punto fijo G de una curva elíptica obtienes tu clave pública K = k·G. Ir de k a K es fácil; ir de K a k es inviable (problema del logaritmo discreto). La curva que usa Bitcoin se llama secp256k1: y² = x³ + 7 sobre un campo finito de unos 2²⁵⁶ elementos.

Una firma es un par (r, s) que cualquiera puede comprobar con la clave pública y el mensaje, y que solo pudo producir quien conoce k.

Cómo se genera una clave de verdad

Una clave privada es simplemente un número aleatorio de 256 bits entre 1 y N−1. Lo importante es la palabra aleatorio: si tu generador no es realmente impredecible, alguien podría reproducir tu clave. Casos reales: en 2013 se vaciaron carteras de Android porque el generador de números aleatorios de Java estaba mal implementado; en 2023 se descubrió un fallo similar en Milk Sad (Libbitcoin Explorer), que generaba claves con solo 32 bits de entropía. Conclusión: usa herramientas auditadas y, mejor aún, dispositivos de hardware o dados reales (lo veremos en el módulo de seguridad).

Cómo funciona ECDSA, paso a paso

Supongamos que tu clave privada es d, tu clave pública Q = d·G y el mensaje (su hash) es z.

  1. Elige un número aleatorio secreto k (el nonce) y calcula el punto R = k·G. Su coordenada x es r.
  2. Calcula s = k⁻¹ · (z + r·d) mod N.
  3. La firma es (r, s).

Para verificar con Q, z y (r, s): calculas w = s⁻¹, luego u₁ = z·w y u₂ = r·w, y el punto u₁·G + u₂·Q. Si su coordenada x coincide con r, la firma es válida. La razón es que u₁·G + u₂·Q = (z·w + r·w·d)·G = k·G = R: el verificador reconstruye el punto de la firma sin conocer ni d ni k.

Laboratorio 2.3: ECDSA desde cero

Laboratoriolab03_ecdsa_secp256k1.py
Guía paso a paso para principiantes

Qué vas a hacer

Vas a generar una clave pública a partir de una privada, firmar un mensaje, comprobar la firma y ver, con tus propios ojos, por qué reutilizar un número secreto (el nonce) destruye la seguridad. Todo con la curva real de Bitcoin, secp256k1.

Antes de empezar

  • Guarda el archivo como lab03_ecdsa_secp256k1.py en tu carpeta labs-bitcoin.
  • Necesitas Python 3.8 o superior (comprueba con python3 --version).
  • Este laboratorio es la base de los siguientes: los laboratorios 4 y 5 importan este archivo, así que debe estar en la misma carpeta.

Paso a paso

  1. En la terminal, entra en la carpeta labs-bitcoin.
  2. Ejecuta: python3 lab03_ecdsa_secp256k1.py.
  3. Mira las cuatro líneas de salida. La clave pública cambia solo si cambias la frase “clave de ejemplo: no la uses”; la firma también.
  4. Abre el archivo y busca la función sign. Verás que el nonce k se calcula con hmac a partir de la clave privada y del mensaje: así nunca se repite para mensajes distintos.

Cómo leer lo que sale

  • clave pública (66 caracteres hex): empieza por 02 o 03 y después vienen los 32 bytes de la coordenada x. Es lo que compartirías.
  • firma (r, s): dos números enormes. Cualquiera puede verificar con la clave pública que solo quien conoce la clave privada pudo producirlos.
  • ¿válida? True / ¿válida con otro mensaje? False: si cambias una sola letra del mensaje, la firma deja de valer. La firma está “pegada” al mensaje.
  • clave privada recuperada tras reutilizar k: True: el programa firma dos mensajes con el mismo k y, con álgebra de instituto, despeja la clave privada. Por eso un nonce repetido es fatal.

Prueba esto

  • Cambia el texto Pago 1 BTC a Alicia por otro. Verás una firma distinta y la verificación seguirá siendo True.
  • En la línea verify(pub, hashlib.sha256(b'Pago 100 BTC a Mallory').digest(), sig) cambia el texto por exactamente Pago 1 BTC a Alicia. ¿Qué cambia en la salida?
  • Cambia priv = 1 por priv = 2 en el primer assert y mira cómo salta un error de comprobación: es normal, el valor esperado era el de la clave 1.

Si algo falla

  • ModuleNotFoundError: solo ocurriría si renombraste el archivo. Los nombres deben ser idénticos.
  • TypeError: pow() 3rd argument cannot be negative: tu Python es anterior a 3.8. Actualízalo.
  • Tarda un par de segundos: es normal; se hacen multiplicaciones con números de 256 bits en Python puro.
  • No uses este código con dinero real. Es didáctico y no protege contra ataques de canal lateral.
Ver el código completo
"""Lab 2.3 - Firmas digitales desde cero: curva secp256k1, clave pública, ECDSA firmar/verificar.
Solo para aprender (no es constante en tiempo; NO uses este código con dinero real).
Ejecuta: python3 lab03_ecdsa_secp256k1.py"""
import hashlib, hmac

P  = 2**256 - 2**32 - 977
N  = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
G  = (0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
      0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)

def add(a, b):
    if a is None: return b
    if b is None: return a
    (x1, y1), (x2, y2) = a, b
    if x1 == x2 and (y1 + y2) % P == 0: return None
    m = (3*x1*x1) * pow(2*y1, -1, P) % P if a == b else (y2 - y1) * pow(x2 - x1, -1, P) % P
    x3 = (m*m - x1 - x2) % P
    return (x3, (m*(x1 - x3) - y1) % P)

def mul(k, pt=G):
    r = None
    while k:
        if k & 1: r = add(r, pt)
        pt = add(pt, pt); k >>= 1
    return r

def pubkey_compressed(priv):
    x, y = mul(priv)
    return bytes([2 + (y & 1)]) + x.to_bytes(32, 'big')

def sign(priv, msg32):
    z = int.from_bytes(msg32, 'big')
    # nonce determinista (estilo RFC 6979 simplificado): nunca reutilices un k
    k = int.from_bytes(hmac.new(priv.to_bytes(32, 'big'), msg32, hashlib.sha256).digest(), 'big') % N
    r = mul(k)[0] % N
    s = pow(k, -1, N) * (z + r * priv) % N
    if s > N // 2: s = N - s            # forma baja-S (BIP 62/146)
    return r, s

def verify(pub_pt, msg32, sig):
    r, s = sig; z = int.from_bytes(msg32, 'big')
    if not (1 <= r < N and 1 <= s < N): return False
    w = pow(s, -1, N)
    pt = add(mul(z*w % N), mul(r*w % N, pub_pt))
    return pt is not None and pt[0] % N == r

if __name__ == '__main__':
    priv = 1
    assert pubkey_compressed(priv).hex() == '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'
    priv = int.from_bytes(hashlib.sha256(b'clave de ejemplo: no la uses').digest(), 'big') % N
    pub = mul(priv)
    msg = hashlib.sha256(b'Pago 1 BTC a Alicia').digest()
    sig = sign(priv, msg)
    print('clave pública:', pubkey_compressed(priv).hex())
    print('firma (r,s)  :', hex(sig[0])[:18]+'...', hex(sig[1])[:18]+'...')
    print('¿válida?', verify(pub, msg, sig))
    print('¿válida con otro mensaje?', verify(pub, hashlib.sha256(b'Pago 100 BTC a Mallory').digest(), sig))
    # por qué reutilizar k es fatal: con dos firmas del mismo k se despeja la clave privada
    k = 12345; z1 = int.from_bytes(hashlib.sha256(b'a').digest(), 'big'); z2 = int.from_bytes(hashlib.sha256(b'b').digest(), 'big')
    r = mul(k)[0] % N
    s1 = pow(k, -1, N)*(z1 + r*priv) % N; s2 = pow(k, -1, N)*(z2 + r*priv) % N
    k_rec = (z1 - z2) * pow(s1 - s2, -1, N) % N
    priv_rec = (s1*k_rec - z1) * pow(r, -1, N) % N
    print('clave privada recuperada tras reutilizar k:', priv_rec == priv)
Salida de una ejecución real
clave pública: 02171e415edb314ad184385b77594b1c9928c849df72968ace389ba217814abdb4
firma (r,s)  : 0xf44e237a81d94cb3... 0x139e51ec41a389c4...
¿válida? True
¿válida con otro mensaje? False
clave privada recuperada tras reutilizar k: True

Fíjate en tres cosas del resultado:

  • La clave pública de la clave privada 1 es exactamente el punto generador G: el código lo comprueba con un assert.
  • Cambiar el mensaje invalida la firma.
  • Reutilizar el nonce k regala la clave privada. Con dos firmas hechas con el mismo k se despeja k y después la clave. No es teoría: ocurrió en 2010 con la PlayStation 3 de Sony y en 2013 con aplicaciones Android que generaban mal el aleatorio. Por eso las carteras serias usan nonces deterministas (RFC 6979) o firmas Schnorr.

ECDSA y Schnorr

Desde Taproot (noviembre de 2021) Bitcoin también admite firmas Schnorr (BIP 340). Son más simples, pesan menos (64 bytes) y permiten agregar firmas: varias personas pueden producir una sola firma que parece la de una persona. Es la base de multisig más barato y más privado.

ECDSASchnorr (BIP 340)
Tamaño de la firma71-72 bytes (DER)64 bytes
Agregación de clavesComplicadaNatural (MuSig2)
MaleabilidadRequiere normalizar SNo es maleable
En Bitcoin desde2009Taproot, nov. 2021

Para qué sirve todo esto en un pago

Cuando pagas, tu cartera firma con tu clave privada un resumen de la transacción. Los nodos, con tu clave pública (que va en la transacción o en el script), verifican la firma. Si es válida, saben que quien gasta esas monedas es quien tiene la clave, sin haberla visto jamás. Es la prueba de propiedad sin revelar el secreto.

Comprueba lo aprendido

¿Qué ocurre si firmas dos mensajes distintos con el mismo nonce k?

¿Qué necesita el verificador de una firma ECDSA?

¿Qué ventaja aportan las firmas Schnorr?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 2
La tecnología de Bitcoin · lección 5 de 10 · 30 min

Direcciones: de la clave a lo que compartes

Una dirección no es una cuenta: es una forma amigable de describir bajo qué condición se pueden gastar unos fondos.

Clavepública#SHA-256RIPEMD-160ChecksumDirecciónCada transformación hace la dirección más corta y más segura
De la clave pública a la dirección, con un checksum que detecta errores.

Del punto de la curva a la dirección

  1. Clave pública comprimida (33 bytes).
  2. HASH160 = RIPEMD160(SHA256(clave pública)) → 20 bytes.
  3. Codificación con checksum: Base58Check (direcciones que empiezan por 1) o Bech32 (empiezan por bc1q, SegWit v0) o Bech32m (bc1p, Taproot).

El checksum detecta errores de tecleo: si cambias un carácter, la dirección deja de ser válida en lugar de enviar tus fondos a otra parte.

Por qué comprimir la clave pública

Una clave pública es un punto (x, y) de 64 bytes. Pero dado x, la ecuación de la curva deja solo dos posibles valores de y (uno par, otro impar). Basta guardar x y un byte que diga si y es par (02) o impar (03). Resultado: 33 bytes en lugar de 65. Desde 2012 casi todas las carteras usan claves comprimidas porque ahorran espacio en cada transacción.

Por qué un hash de la clave y no la clave directamente

Poner el hash de la clave pública en la dirección tiene dos ventajas:

  • Más corta: 20 bytes en lugar de 33.
  • Más resistente: mientras no hayas gastado desde esa dirección, tu clave pública no es visible. Si en el futuro un ordenador cuántico pudiera derivar claves privadas a partir de claves públicas, las monedas en direcciones nunca usadas estarían más protegidas. (Es una razón más para no reutilizar direcciones, como verás en el módulo de privacidad.)

Base58Check y Bech32

Base58Check (la forma original de Satoshi) codifica los bytes con 58 símbolos, quitando los que se confunden (0, O, I, l). Añade un byte de versión al principio (por eso las direcciones empiezan por 1) y los cuatro primeros bytes de un doble SHA-256 como checksum.

Bech32 (BIP 173, 2017) usa 32 símbolos en minúsculas, un código de corrección BCH que puede localizar errores y un prefijo legible (bc para la red principal, tb para la de pruebas). Es más cómoda de leer por voz o de escanear en un código QR (el QR es más compacto). Bech32m (BIP 350) corrige una debilidad sutil de Bech32 y se usa a partir de Taproot.

Laboratorio 2.4: tus primeras direcciones

Laboratoriolab04_direcciones.py
Guía paso a paso para principiantes

Qué vas a hacer

Vas a transformar una clave pública en dos tipos de dirección de Bitcoin: una antigua (1…, Base58Check) y una moderna (bc1q…, Bech32). Verás qué pasos intermedios hay (SHA-256, RIPEMD-160 y un checksum).

Antes de empezar

  • Necesitas en la misma carpeta los archivos lab03_ecdsa_secp256k1.py y lab04_direcciones.py. El segundo usa funciones del primero.
  • Si tu Python no trae RIPEMD-160 (pasa en algunas instalaciones con OpenSSL 3), el programa usa una versión propia en Python puro. No tienes que hacer nada.

Paso a paso

  1. Entra en la carpeta con la terminal.
  2. Ejecuta: python3 lab04_direcciones.py.
  3. Verás tres líneas: el HASH160 de la clave pública, la dirección que empieza por 1 y la que empieza por bc1q.
  4. Comprueba que las dos direcciones salen de la misma clave, pero con distinta “envoltura”.

Cómo leer lo que sale

  • HASH160 es una huella de 20 bytes de tu clave pública. Es lo único que va en el script de la salida.
  • P2PKH (1…) añade un byte de versión y 4 bytes de checksum y lo escribe en Base58.
  • P2WPKH (bc1q…) usa Bech32: solo minúsculas, sin letras confusas y con un checksum más potente.
  • Los assert del final comprueban que las direcciones coinciden con los vectores de prueba publicados por la comunidad. Si no saltó ningún error, tu código es correcto.

Prueba esto

  • Cambia pubkey_compressed(1) por pubkey_compressed(2) (y quita o comenta los assert del final). Obtendrás las direcciones de la clave privada 2.
  • Cambia un carácter de una dirección en tu cuaderno y pregúntate: ¿qué parte del programa detectaría el error? (La respuesta: el checksum.)
  • Calcula también una dirección Taproot con bech32_addr('bc', 1, <32 bytes>); fíjate en que empieza por bc1p.

Si algo falla

  • ModuleNotFoundError: No module named 'lab03_ecdsa_secp256k1': falta el archivo del laboratorio 3 en la misma carpeta, o tiene otro nombre.
  • ValueError: unsupported hash type ripemd160: ya no debería ocurrir (hay respaldo), pero si guardaste una versión antigua del archivo, vuelve a copiar este.
  • Nunca envíes fondos a la dirección de la clave privada 1: es pública y hay robots que vacían esas direcciones.
Ver el código completo
"""Lab 2.4 - De clave privada a dirección: HASH160, Base58Check (P2PKH) y Bech32 (P2WPKH).
Ejecuta: python3 lab04_direcciones.py"""
import hashlib, sys, os
sys.path.insert(0, os.path.dirname(__file__))
from lab03_ecdsa_secp256k1 import pubkey_compressed

B58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'

def _ripemd160_py(data):
    """RIPEMD-160 en Python puro: solo se usa si tu Python (OpenSSL 3) ya no incluye ripemd160."""
    rol = lambda x, n: ((x << n) | (x >> (32 - n))) & 0xffffffff
    f = [lambda x, y, z: x ^ y ^ z, lambda x, y, z: (x & y) | (~x & z), lambda x, y, z: (x | ~y) ^ z,
         lambda x, y, z: (x & z) | (y & ~z), lambda x, y, z: x ^ (y | ~z)]
    K1 = [0, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E]; K2 = [0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0]
    R1 = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, 7,4,13,1,10,6,15,3,12,0,9,5,2,14,11,8, 3,10,14,4,9,15,8,1,2,7,0,6,13,11,5,12,
          1,9,11,10,0,8,12,4,13,3,7,15,14,5,6,2, 4,0,5,9,7,12,2,10,14,1,3,8,11,6,15,13]
    R2 = [5,14,7,0,9,2,11,4,13,6,15,8,1,10,3,12, 6,11,3,7,0,13,5,10,14,15,8,12,4,9,1,2, 15,5,1,3,7,14,6,9,11,8,12,2,10,0,4,13,
          8,6,4,1,3,11,15,0,5,12,2,13,9,7,10,14, 12,15,10,4,1,5,8,7,6,2,13,14,0,3,9,11]
    S1 = [11,14,15,12,5,8,7,9,11,13,14,15,6,7,9,8, 7,6,8,13,11,9,7,15,7,12,15,9,11,7,13,12, 11,13,6,7,14,9,13,15,14,8,13,6,5,12,7,5,
          11,12,14,15,14,15,9,8,9,14,5,6,8,6,5,12, 9,15,5,11,6,8,13,12,5,12,13,14,11,8,5,6]
    S2 = [8,9,9,11,13,15,15,5,7,7,8,11,14,14,12,6, 9,13,15,7,12,8,9,11,7,7,12,7,6,15,13,11, 9,7,15,11,8,6,6,14,12,13,5,14,13,13,7,5,
          15,5,8,11,14,14,6,14,6,9,12,9,12,5,15,8, 8,5,12,9,12,5,14,6,8,13,6,5,15,13,11,11]
    h = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]
    msg = data + b'\x80' + b'\0' * ((55 - len(data)) % 64) + (8 * len(data)).to_bytes(8, 'little')
    for off in range(0, len(msg), 64):
        X = [int.from_bytes(msg[off + 4*i: off + 4*i + 4], 'little') for i in range(16)]
        a1, b1, c1, d1, e1 = h; a2, b2, c2, d2, e2 = h
        for j in range(80):
            r = j // 16
            t = (rol((a1 + f[r](b1, c1, d1) + X[R1[j]] + K1[r]) & 0xffffffff, S1[j]) + e1) & 0xffffffff
            a1, e1, d1, c1, b1 = e1, d1, rol(c1, 10), b1, t
            t = (rol((a2 + f[4 - r](b2, c2, d2) + X[R2[j]] + K2[r]) & 0xffffffff, S2[j]) + e2) & 0xffffffff
            a2, e2, d2, c2, b2 = e2, d2, rol(c2, 10), b2, t
        t = (h[1] + c1 + d2) & 0xffffffff
        h = [t, (h[2] + d1 + e2) & 0xffffffff, (h[3] + e1 + a2) & 0xffffffff, (h[4] + a1 + b2) & 0xffffffff, (h[0] + b1 + c2) & 0xffffffff]
    return b''.join(x.to_bytes(4, 'little') for x in h)

def ripemd160(b):
    try: return hashlib.new('ripemd160', b).digest()
    except ValueError: return _ripemd160_py(b)       # Python con OpenSSL 3 sin RIPEMD-160
def hash160(b): return ripemd160(hashlib.sha256(b).digest())
def b58check(payload):
    chk = hashlib.sha256(hashlib.sha256(payload).digest()).digest()[:4]
    n = int.from_bytes(payload + chk, 'big'); s = ''
    while n: n, r = divmod(n, 58); s = B58[r] + s
    return '1' * (len(payload) - len(payload.lstrip(b'\0'))) + s

CH = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l'
def polymod(v):
    G = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]; c = 1
    for x in v:
        b = c >> 25; c = (c & 0x1ffffff) << 5 ^ x
        for i in range(5): c ^= G[i] if (b >> i) & 1 else 0
    return c
def hrp_exp(h): return [ord(x) >> 5 for x in h] + [0] + [ord(x) & 31 for x in h]
def convert(data, f, t):
    acc = bits = 0; out = []
    for v in data:
        acc = acc << f | v; bits += f
        while bits >= t: bits -= t; out.append(acc >> bits & (2**t - 1))
    if bits: out.append(acc << (t - bits) & (2**t - 1))
    return out
def bech32_addr(hrp, witver, prog):
    d = [witver] + convert(prog, 8, 5)
    const = 1 if witver == 0 else 0x2bc830a3          # bech32 vs bech32m (Taproot)
    pm = polymod(hrp_exp(hrp) + d + [0]*6) ^ const
    return hrp + '1' + ''.join(CH[x] for x in d + [(pm >> 5*(5-i)) & 31 for i in range(6)])

if __name__ == '__main__':
    pub = pubkey_compressed(1)
    h = hash160(pub)
    print('HASH160(pub)  :', h.hex())
    print('P2PKH (1...)  :', b58check(b'\x00' + h))
    print('P2WPKH (bc1q) :', bech32_addr('bc', 0, h))
    assert b58check(b'\x00' + h) == '1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH'
    assert bech32_addr('bc', 0, h) == 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4'
Salida de una ejecución real
HASH160(pub)  : 751e76e8199196d454941c45d1b3a323f1433bd6
P2PKH (1...)  : 1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH
P2WPKH (bc1q) : bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4

La dirección 1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH es la de la clave privada 1; la comunidad la usa como vector de prueba. Nunca envíes fondos a una clave privada conocida: robots vigilan esas direcciones y vacían cualquier saldo en segundos.

Los tipos más comunes hoy

PrefijoNombreQué es
1…P2PKHOriginal. Más caro en comisiones
3…P2SHCompatible con scripts; usado por SegWit envuelto y multisig antiguo
bc1q…P2WPKH / P2WSHSegWit nativo: comisiones más bajas
bc1p…P2TRTaproot: más privacidad y flexibilidad

Qué cartera usar y qué dirección recibir

Si usas una cartera moderna, probablemente te dará direcciones bc1q o bc1p. No tienes que elegir a mano: tu cartera sabe qué es mejor. Sí es útil saber que casi todos los servicios modernos aceptan Bech32, y que algunas plataformas antiguas aún no, en cuyo caso puedes pedir una dirección legacy o enviar primero a una intermedia propia.

Comprueba lo aprendido

¿Para qué sirve el checksum de una dirección?

¿Qué guarda una clave pública comprimida?

¿Qué prefijo tienen las direcciones Taproot?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 2
La tecnología de Bitcoin · lección 6 de 10 · 30 min

Direcciones y checksums: cómo se detecta un error de copia

Copiar una dirección con un error puede enviar tu dinero a la nada. Los formatos de dirección incluyen un checksum que lo evita. Aquí ves cómo funcionan los dos grandes sistemas.

Clave pública#Hash de 20 bytesChecksumDirecciónque compartes
Una dirección es un hash de la clave más una huella que detecta errores.

El problema

Una dirección es un texto largo. Si escribes una letra mal, el resultado puede parecer una dirección válida, pero nadie tendrá su clave. Por eso las direcciones llevan una huella: unos caracteres calculados a partir del resto. Si cambias uno, la huella no cuadra y tu cartera lo rechaza.

Base58Check (direcciones que empiezan por 1 o 3)

  1. Toma el prefijo de versión + el hash de 20 bytes.
  2. Calcula el doble SHA-256 y toma los 4 primeros bytes: es el checksum.
  3. Añade el checksum al final y codifica todo en Base58 (sin 0, O, I, l para evitar confusiones visuales).
  4. Detección: la probabilidad de que un error aleatorio pase inadvertido es ≈ 1 entre 4 300 millones (2³²).

Bech32 y Bech32m (direcciones bc1…)

  1. Se codifican los bits en grupos de 5 con un alfabeto de 32 caracteres, todo en minúsculas.
  2. Se calcula un código BCH de 6 caracteres que se añade al final.
  3. Ventajas: se detectan hasta 4 errores seguros en direcciones de ese tamaño, no distingue mayúsculas de minúsculas (cómodo para QR) y evita caracteres parecidos.
  4. Bech32m (BIP 350) corrige una debilidad menor de Bech32 y se usa en Taproot (bc1p…).

Qué ves en una dirección

ParteEjemplo (bc1q…)Significado
Prefijo bcRed principaltb en testnet, bcrt en regtest
Separador 1Fija el límite
Versión q o pq: SegWit v0, p: Taproot
Datos20-32 bytes de hash o clave
ChecksumÚltimos 6 caracteresDetecta errores

Qué no hace un checksum

No te protege de enviar a la dirección equivocada pero válida (por ejemplo, un atacante que cambia la dirección copiada por otra suya). Por eso verificas la dirección en la pantalla del dispositivo y haces una prueba pequeña.

Pruébalo

El laboratorio de direcciones de este módulo genera direcciones. Cambia una letra de una dirección bc1q… generada y comprueba que la validación la rechaza. Hazlo con otra letra y otra posición.

Comprueba lo aprendido

¿Qué hace el checksum de una dirección?

¿Un checksum protege de un virus que sustituye tu dirección por otra válida?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 2
La tecnología de Bitcoin · lección 7 de 10 · 40 min

Transacciones: UTXO, entradas y salidas

Bitcoin no lleva saldos por cuenta: lleva monedas sueltas que se gastan enteras. Entender esto explica las comisiones, el cambio y casi toda la privacidad.

Entrada de50 000 sats30 000 a Bob19 000 de cambio1 000 decomisión
Una entrada se gasta entera: pago, cambio y comisión salen de la diferencia.
UTXO de 50 00030 000 a Bob19 000 cambio1 000comisiónentradas − salidas = comisión
Una entrada se gasta entera: pago, cambio y comisión salen de la diferencia.

La prensa de monedas

Antes de leer, pulsa los pasos. Esta máquina funciona como una transacción: toma una moneda entera, la aplasta y fabrica monedas nuevas, y la balanza de la ventana comprueba que lo que entra siempre iguala lo que sale. Mueve después los dos controles de abajo (el pago y la tarifa). La tarifa se multiplica por el tamaño de la transacción (141 vB para una entrada y dos salidas SegWit nativas), no por el importe: pagar 0,01 BTC o 0,40 BTC cuesta lo mismo en comisión.

El modelo UTXO

Una transacción consume salidas anteriores (entradas) y crea salidas nuevas. Cada salida es una cantidad de satoshis más un script (condición de gasto). Las que no han sido gastadas son los UTXO.

Piensa en pagar con billetes: si tienes uno de 50 y debes 30, entregas el de 50 y recibes 20 de cambio. Con UTXO es igual: la entrada de 50 000 sats se destruye, se crea una salida de 30 000 para quien cobra y otra de 19 000 de cambio a ti. Los 1 000 sats que faltan son la comisión para el minero. No hay campo “comisión”: es la diferencia entre entradas y salidas.

Pruébalo con monedas

Construye tú una transacción: elige monedas, fija el pago y la comisión, firma, mina un bloque... y rómpela con los botones naranjas.

Por qué UTXO y no cuentas

Hay dos modelos para llevar un libro de cuentas digital: el de cuentas con saldo (como un banco, o Ethereum) y el de salidas no gastadas (Bitcoin). El de UTXO tiene ventajas importantes para un sistema sin confianza:

  • Verificación independiente: cada transacción se valida mirando solo las salidas que consume y las firmas. No hace falta recorrer un historial de la cuenta.
  • Paralelismo: las transacciones que gastan UTXO distintos son independientes y pueden validarse a la vez.
  • Privacidad por diseño: nada obliga a reutilizar identidades; puedes recibir cada pago en una dirección distinta.
  • Sin ataques de repetición de cuenta: un UTXO solo puede gastarse una vez: tras gastarse desaparece.

Anatomía

  • Versión y locktime (no se puede incluir en un bloque antes de cierta altura o fecha).
  • Entradas: referencia al UTXO (txid + índice de salida), script de desbloqueo y sequence (permite RBF).
  • Salidas: valor en satoshis y script de bloqueo.

Un satoshi es la unidad mínima: 1 BTC = 100.000.000 sats. Los valores se guardan como enteros, nunca decimales, para evitar errores de redondeo.

Laboratorio 2.2: construye y firma una transacción

Laboratoriolab05_transaccion.py
Guía paso a paso para principiantes

Qué vas a hacer

Vas a construir a mano una transacción de Bitcoin (la forma antigua, P2PKH), la vas a firmar y a medir su tamaño y su comisión. Después de este laboratorio, un txid dejará de ser un misterio.

Antes de empezar

  • Los archivos lab03_ecdsa_secp256k1.py, lab04_direcciones.py y lab05_transaccion.py deben estar en la misma carpeta.
  • No se envía nada a la red: es una transacción de práctica con una “moneda” inventada de 50 000 satoshis.

Paso a paso

  1. Ejecuta: python3 lab05_transaccion.py.
  2. Fíjate en la primera línea: tx (hex) es el principio de la transacción en bytes. Empieza por 01000000 (la versión 1 en little-endian), seguido de 01 (una entrada).
  3. Mira tamaño: 226 bytes. Es lo que ocupa la transacción serializada.
  4. Mira comisión: 50 000 − (30 000 + 19 000) = 1 000 sats, es decir, 4,4 satoshis por byte virtual.
  5. La última línea confirma que la firma es válida para el mensaje (el sighash) calculado.

Cómo leer lo que sale

  • txid: el hash doble de los bytes de la transacción, mostrado al revés (little-endian). Es su identificador único.
  • comisión: no existe un campo “comisión”; sale de restar el total de salidas al total de entradas.
  • firma válida: True: la firma se hizo sobre una versión especial de la transacción (con el script de la salida que se gasta puesto en la entrada). Es el motivo por el que, tras firmar, no puedes cambiar nada sin invalidarla.

Prueba esto

  • En la lista outs, cambia 19_000 por 1_000 y ejecuta. La comisión salta a 19 000 sats. Así se pierden fortunas por olvidar el cambio.
  • Cambia el valor 30_000 por 60_000. ¿Qué pasa con la comisión? (Pista: sale negativa: la transacción sería inválida porque crea dinero.)
  • Cambia priv_alice por otro número y mira cómo cambia el txid pero no el tamaño.

Si algo falla

  • ModuleNotFoundError: faltan los laboratorios 3 o 4 en la carpeta.
  • El txid no coincide con el de la salida del curso: la firma usa una clave de práctica y un nonce determinista; si cambiaste algo del código o de los números, el txid cambiará. No es un fallo.
Ver el código completo
"""Lab 2.2 - Construye, firma y verifica una transacción legacy (P2PKH) a mano. Solo estándar.
Ejecuta: python3 lab05_transaccion.py"""
import hashlib, struct, sys, os
sys.path.insert(0, os.path.dirname(__file__))
from lab03_ecdsa_secp256k1 import pubkey_compressed, sign, verify, mul, N
from lab04_direcciones import hash160

def dsha(b): return hashlib.sha256(hashlib.sha256(b).digest()).digest()
def varint(n):
    if n < 0xfd: return bytes([n])
    if n <= 0xffff: return b'\xfd' + struct.pack('<H', n)
    return b'\xfe' + struct.pack('<L', n)
def p2pkh_script(h160): return b'\x76\xa9\x14' + h160 + b'\x88\xac'   # DUP HASH160 <h> EQUALVERIFY CHECKSIG

def serialize(ins, outs, script_sigs=None, version=1, locktime=0):
    s = struct.pack('<L', version) + varint(len(ins))
    for i, (txid, vout, _) in enumerate(ins):
        ss = script_sigs[i] if script_sigs else b''
        s += bytes.fromhex(txid)[::-1] + struct.pack('<L', vout) + varint(len(ss)) + ss + b'\xff\xff\xff\xff'
    s += varint(len(outs))
    for value, spk in outs: s += struct.pack('<Q', value) + varint(len(spk)) + spk
    return s + struct.pack('<L', locktime)

def der(r, s):
    def i(x): b = x.to_bytes((x.bit_length() + 7)//8 or 1, 'big'); return (b'\0' + b) if b[0] & 0x80 else b
    body = b'\x02' + bytes([len(i(r))]) + i(r) + b'\x02' + bytes([len(i(s))]) + i(s)
    return b'\x30' + bytes([len(body)]) + body

def sighash_all(ins, outs, idx):
    # versión legacy: en la entrada que firmas pones el scriptPubKey que gastas; en las demás, vacío
    tmp = [(t, v, s) for (t, v, s) in ins]
    scripts = [(ins[i][2] if i == idx else b'') for i in range(len(ins))]
    s = struct.pack('<L', 1) + varint(len(ins))
    for i, (txid, vout, _) in enumerate(ins):
        s += bytes.fromhex(txid)[::-1] + struct.pack('<L', vout) + varint(len(scripts[i])) + scripts[i] + b'\xff\xff\xff\xff'
    s += varint(len(outs))
    for value, spk in outs: s += struct.pack('<Q', value) + varint(len(spk)) + spk
    return dsha(s + struct.pack('<LL', 0, 1))          # locktime + SIGHASH_ALL (1)

if __name__ == '__main__':
    priv_alice = 0xA11CE; pub = pubkey_compressed(priv_alice)
    spk_alice  = p2pkh_script(hash160(pub))
    prev_txid  = 'aa'*32                              # una UTXO inventada de 50 000 sats
    ins  = [(prev_txid, 0, spk_alice)]
    outs = [(30_000, p2pkh_script(hash160(b'\x02'+b'\x11'*32))),    # a Bob
            (19_000, spk_alice)]                                    # cambio; 1 000 sats de comisión
    h = sighash_all(ins, outs, 0)
    r, s = sign(priv_alice, h)
    sig = der(r, s) + b'\x01'
    script_sig = bytes([len(sig)]) + sig + bytes([len(pub)]) + pub
    raw = serialize(ins, outs, [script_sig])
    print('tx (hex):', raw.hex()[:96] + '...')
    print('tamaño  :', len(raw), 'bytes  | txid:', dsha(raw)[::-1].hex())
    print('comisión:', 50_000 - sum(v for v, _ in outs), 'sats  =', round((50_000 - sum(v for v,_ in outs))/len(raw), 1), 'sat/vB')
    print('firma válida:', verify(mul(priv_alice), h, (r, s)))
Salida de una ejecución real
tx (hex): 0100000001aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000006b483045022100...
tamaño  : 226 bytes  | txid: b917e55f5f48fb3fee32e76dc3b9c3732ab7312d72922dc7b65c32d7cf55f71b
comisión: 1000 sats  = 4.4 sat/vB
firma válida: True

Qué estás viendo:

  • Los bytes de una transacción real, serializados a mano, con su txid.
  • La firma se calcula sobre una versión especial de la transacción (sighash), no sobre la que viaja: por eso modificar una salida después de firmar la invalida.
  • La comisión sale de restar: 50 000 − (30 000 + 19 000) = 1 000 sats, unos 4,4 sat/vB para 226 bytes.

El script, en una frase

El script de bloqueo de una salida P2PKH (DUP HASH160 <hash> EQUALVERIFY CHECKSIG) dice: “quien lo gaste debe presentar una clave pública cuyo hash sea este y una firma válida de esa clave”. El script de desbloqueo de la entrada aporta justo eso (la firma y la clave). Los nodos ejecutan ambos y, si el resultado es “verdadero”, aceptan el gasto. Lo estudiarás en detalle en el módulo de protocolo.

Por qué SegWit cambió el cálculo

Desde 2017, los datos de firma (witness) pesan un cuarto en el cálculo de comisiones. Por eso una entrada P2WPKH es mucho más barata que una P2PKH. Lo practicarás en el módulo de protocolo con el laboratorio de comisiones.

Cuánto cuesta una transacción

La comisión no depende de cuánto envías, sino de cuánto espacio ocupa tu transacción en el bloque y de cuánta demanda haya en ese momento. Una transacción con muchas entradas pequeñas ocupa más y paga más, aunque muevas poco dinero. Por eso consolidar UTXO pequeños en épocas de comisiones bajas es una buena práctica de cartera.

Comprueba lo aprendido

Entradas por 50 000 sats, salidas por 30 000 + 19 000. ¿Cuál es la comisión?

Una transacción con 20 entradas pequeñas, ¿por qué paga más comisión que una con 1 entrada, aunque envíe lo mismo?

¿Qué es un UTXO?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 2
La tecnología de Bitcoin · lección 8 de 10 · 34 min

SIGHASH: qué compromete una firma

Cuando firmas, no tienes por qué comprometer toda la transacción. Elegir qué partes cubre la firma permite crear contratos sencillos, y también cometer errores graves.

ALLEntradasSalidasTodo protegidoNONEEntradasSin salidasCualquiera las cambia
El tipo de firma decide qué pasa si alguien toca la transacción.

La idea

La firma se calcula sobre un resumen (sighash) de la transacción. El tipo de sighash decide qué entra en ese resumen:

TipoCubre
SIGHASH_ALL (el normal)Todas las entradas y todas las salidas
SIGHASH_NONETodas las entradas, ninguna salida
SIGHASH_SINGLETodas las entradas y solo la salida del mismo índice
`…ANYONECANPAY`Solo tu entrada; otros pueden añadir entradas

Piensa en firmar un contrato con una frase como “acepto lo que figura en esta hoja”. Con ALL firmas sabiendo todo lo que hay en la hoja. Con NONE firmas una hoja en blanco para los pagos y confías en el que la completa.

Laboratorio 2.6

Laboratoriolab12_sighash.py
Guía paso a paso para principiantes

Qué vas a hacer

Vas a comprobar, con un modelo sencillo, qué parte de una transacción protege cada tipo de firma (ALL, NONE, SINGLE, ANYONECANPAY).

Antes de empezar

  • Solo necesitas este archivo: no usa ningún otro laboratorio.

Paso a paso

  1. Ejecuta: python3 lab12_sighash.py.
  2. Verás una tabla. Cada fila es un cambio que haría alguien malintencionado después de que Alicia firmara. Cada columna es un tipo de firma.
  3. INVALIDA significa que la firma deja de servir (protege contra ese cambio). valida significa que el cambio pasa sin romper la firma.

Cómo leer lo que sale

  • Con ALL, cualquier cambio rompe la firma: es el modo seguro y normal.
  • Con NONE, cambiar las salidas no rompe la firma: cualquiera puede desviar el dinero. Solo se usa en casos muy especiales.
  • Con SINGLE|ANYONECANPAY, otros pueden añadir entradas sin invalidar tu firma: sirve para colectas donde cada uno aporta su parte.

Prueba esto

  • Añade una cuarta fila a cambios que modifique t['outs'][0]['v'] (el valor) y mira qué columnas la detectan.
  • Cambia el nombre Bob por Carla en tx y comprueba que las filas de la tabla siguen dando el mismo patrón.

Si algo falla

  • Si ves una tabla con columnas desalineadas, no te preocupes: es solo formato. Usa un tipo de letra monoespaciado en tu terminal.
Ver el código completo
"""Lab 2.6 - SIGHASH: ¿qué partes de la transacción compromete una firma? Modelo simplificado y exacto en la idea.
ALL: todas las entradas y todas las salidas. NONE: entradas, ninguna salida. SINGLE: entradas y solo la salida del mismo índice.
ANYONECANPAY: solo la entrada que firmas (otros pueden añadir entradas)."""
import hashlib, json
def h(x): return hashlib.sha256(json.dumps(x, sort_keys=True).encode()).hexdigest()[:12]
def sighash(tx, idx, tipo, acp=False):
    ins = [tx['ins'][idx]] if acp else tx['ins']
    if tipo == 'ALL': outs = tx['outs']
    elif tipo == 'NONE': outs = []
    elif tipo == 'SINGLE': outs = [tx['outs'][idx]] if idx < len(tx['outs']) else []
    return h({'ins': ins, 'outs': outs})
tx = {'ins': ['utxoA:0', 'utxoB:1'], 'outs': [{'a': 'Bob', 'v': 30000}, {'a': 'Alicia', 'v': 19000}]}
base = {t: sighash(tx, 0, t) for t in ('ALL', 'NONE', 'SINGLE')}
def cambia(mod):
    t2 = json.loads(json.dumps(tx)); mod(t2); return t2
print('Alicia firma la entrada 0. ¿Se invalida la firma si alguien cambia...?')
cambios = {'la salida 0 (Bob 30000 -> Mallory)': lambda t: t['outs'][0].update(a='Mallory'),
           'la salida 1 (cambio)': lambda t: t['outs'][1].update(v=1),
           'añade una entrada nueva': lambda t: t['ins'].append('utxoC:0')}
print(f'{"cambio":38} ALL     NONE    SINGLE  SINGLE|ANYONECANPAY')
for nombre, mod in cambios.items():
    t2 = cambia(mod); fila = []
    for tipo in ('ALL', 'NONE', 'SINGLE'): fila.append('INVALIDA' if sighash(t2, 0, tipo) != base[tipo] else 'valida  ')
    fila.append('INVALIDA' if sighash(t2, 0, 'SINGLE', True) != sighash(tx, 0, 'SINGLE', True) else 'valida')
    print(f'{nombre:38} ' + ' '.join(f'{x:8}' for x in fila))
print('\nUso real: ANYONECANPAY|ALL = crowdfunding (cada uno aporta su entrada). NONE es peligrosa: cualquiera puede cambiar las salidas.')
Salida de una ejecución real
Alicia firma la entrada 0. ¿Se invalida la firma si alguien cambia...?
cambio                                 ALL     NONE    SINGLE  SINGLE|ANYONECANPAY
la salida 0 (Bob 30000 -> Mallory)     INVALIDA valida   INVALIDA INVALIDA
la salida 1 (cambio)                   INVALIDA valida   valida   valida  
añade una entrada nueva                INVALIDA INVALIDA INVALIDA valida  

Uso real: ANYONECANPAY|ALL = crowdfunding (cada uno aporta su entrada). NONE es peligrosa: cualquiera puede cambiar las salidas.

Lee la tabla de resultados por filas: con ALL, cualquier cambio invalida la firma. Con NONE, cualquiera puede cambiar las salidas sin invalidarla (peligrosísimo salvo para casos muy concretos). Con ANYONECANPAY, alguien puede añadir entradas, lo que sirve para un crowdfunding donde cada persona firma su aportación a una salida común.

Un ejemplo con historia: el crowdfunding sin confianza

Imagina que diez personas quieren pagar entre todas 1 BTC a una causa, pero solo si se reúnen los 10 aportes. Cada persona firma su propia entrada con SIGHASH_ALL | ANYONECANPAY sobre una salida común de 1 BTC: su firma dice “mi entrada paga esta salida”, y no le importa quién más contribuya. Quien recolecta ensambla la transacción con todas las firmas; si falta alguna, la suma de entradas no llega a la salida y la transacción es inválida, así que nadie pierde nada. (Es el patrón conocido como assurance contract.)

Usos reales y precauciones

  • Pago agrupado cooperativo: ANYONECANPAY|ALL.
  • Plantillas parcialmente firmadas en protocolos de intercambio.
  • Nunca firmes NONE ni SINGLE sin entender el contrato. Un servicio malicioso puede pedirte una firma que parece inocente.
  • Desde SegWit (BIP 143) y Taproot (BIP 341) el sighash también compromete los importes de las entradas, lo que evita ataques contra dispositivos de firma.

El error del “SINGLE” sin salida

Hay un caso célebre: si usas SIGHASH_SINGLE en una entrada cuyo índice es mayor que el número de salidas, el sighash heredado devuelve siempre el valor 1, y la firma vale para cualquier transacción. No es una vulnerabilidad cotidiana, pero es un buen ejemplo de por qué firmar “un poco” es más delicado que firmar todo. SegWit (BIP 143) cambió el algoritmo y ese caso dejó de funcionar como comodín.

Comprueba lo aprendido

¿Qué riesgo tiene firmar con SIGHASH_NONE?

¿Para qué sirve ALL | ANYONECANPAY?

¿Qué compromete SIGHASH_ALL?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 2
La tecnología de Bitcoin · lección 9 de 10 · 36 min

Bloques, Merkle y la cadena

Un bloque es una cabecera de 80 bytes más una lista de transacciones. Con esos 80 bytes se puede verificar una cadena entera.

Bloque 1hash previodatosBloque 2hash previodatosBloque 3hash previodatosBloque 4hash previodatosCadena de bloques = cadena de hashes
Cada bloque guarda el hash del anterior: cambiar uno rompe todos los siguientes.
bloque 1hash anteriorraíz Merklebloque 2hash anteriorraíz Merklebloque 3hash anteriorraíz Merklebloque 4hash anteriorraíz Merklecada bloque guarda el hash del anterior: cambiar uno rompe todos los siguientes
Cada bloque guarda el hash del anterior.

La cabecera

CampoBytesFunción
Versión4Señalización de cambios (BIP 9)
Hash del bloque anterior32Enlaza la cadena
Raíz de Merkle32Resume todas las transacciones
Marca de tiempo4Aprox. segundos Unix
Bits4Objetivo de dificultad, comprimido
Nonce4Lo que cambia el minero

Total: 80 bytes. Es lo único que se hashea para la prueba de trabajo, y por eso es suficiente para verificar la cadena sin leer las transacciones.

Rompe una cadena

Edita los datos de un bloque intermedio y observa cómo se rompen todos los siguientes:

Qué hay dentro del bloque

Después de la cabecera viene el número de transacciones y las transacciones mismas. La primera de todas es siempre la coinbase: una transacción sin entradas reales que crea las monedas de la recompensa y recoge las comisiones. El minero puede escribir en ella un mensaje (el del génesis cita The Times), y desde 2013 (BIP 34) debe incluir la altura del bloque. Un bloque de hoy tiene típicamente entre 1.500 y 4.000 transacciones y pesa hasta 4 millones de unidades de peso (unos 1-2 MB reales).

Laboratorio 2.1: verifica el bloque génesis

Laboratoriolab01_hash_y_cabecera.py
Guía paso a paso para principiantes

Qué vas a hacer

Vas a reconstruir la cabecera del bloque génesis (80 bytes) con los datos públicos, a calcular su hash doble y a comprobar que cumple la prueba de trabajo. Sin confiar en nadie.

Antes de empezar

  • Solo necesitas este archivo.

Paso a paso

  1. Ejecuta: python3 lab01_hash_y_cabecera.py.
  2. Mira cabecera (hex): 160 caracteres hexadecimales (80 bytes). Verás tu primera cabecera de bloque con tus propios ojos.
  3. Mira hash del bloque: empieza por diez ceros (0000000000).
  4. Mira objetivo: el número que el hash tenía que superar por abajo.
  5. ¿hash <= objetivo? True confirma que ese bloque cumple las reglas.

Cómo leer lo que sale

  • La raíz de Merkle del génesis (4a5e1e4b…) es en realidad el txid de su única transacción, la que contiene el famoso mensaje de The Times.
  • Los bytes están en little-endian: por eso en la cabecera aparece 3ba3edfd… (al revés) y en el código se usa [::-1] para darles la vuelta.
  • El assert del final garantiza que el hash obtenido es exactamente el del bloque génesis publicado.

Prueba esto

  • Cambia nonce = 2083236893 por nonce = 2083236894. El hash será totalmente distinto y la comprobación fallará. Ese es el efecto avalancha.
  • Cambia timestamp en una unidad y observa lo mismo.
  • Calcula cuántos ceros hexadecimales iniciales tiene el hash y compáralo con la línea ceros iniciales.

Si algo falla

  • AssertionError: has cambiado algún dato de la cabecera; vuelve a poner los originales.
Ver el código completo
"""Lab 2.1 - Lee el bloque génesis a mano: serializa la cabecera de 80 bytes y comprueba su prueba de trabajo.
Solo biblioteca estándar. Ejecuta: python3 lab01_hash_y_cabecera.py"""
import hashlib, struct

def dsha(b): return hashlib.sha256(hashlib.sha256(b).digest()).digest()

# Cabecera del bloque génesis (datos públicos)
version     = 1
prev_hash   = bytes(32)
merkle_root = bytes.fromhex('4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b')[::-1]  # se guarda en little-endian
timestamp   = 1231006505
bits        = 0x1d00ffff
nonce       = 2083236893

header = struct.pack('<L32s32sLLL', version, prev_hash, merkle_root, timestamp, bits, nonce)
assert len(header) == 80

def bits_to_target(bits):
    exp, mant = bits >> 24, bits & 0xffffff
    return mant * 256 ** (exp - 3)

h = dsha(header)[::-1]        # los hashes se muestran invertidos
target = bits_to_target(bits)
print('cabecera (hex):', header.hex())
print('hash del bloque:', h.hex())
print('objetivo      :', f'{target:064x}')
print('¿hash <= objetivo?', int.from_bytes(h, 'big') <= target)
print('ceros iniciales (hex):', len(h.hex()) - len(h.hex().lstrip('0')))
assert h.hex() == '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f'
Salida de una ejecución real
cabecera (hex): 0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c
hash del bloque: 000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f
objetivo      : 00000000ffff0000000000000000000000000000000000000000000000000000
¿hash <= objetivo? True
ceros iniciales (hex): 10

Acabas de comprobar con tu propio código que el hash del bloque génesis empieza por diez ceros hexadecimales y es menor que el objetivo de dificultad. No confías en nadie: lo has verificado.

El objetivo de dificultad (“bits”)

El campo bits codifica el objetivo en un formato compacto: un byte de exponente y tres de mantisa. El hash del bloque, leído como número, debe ser menor o igual que ese objetivo. Cuanto menor el objetivo, más difícil. El del génesis (0x1d00ffff) es la dificultad mínima 1. Hoy el objetivo es muchísimo menor: hacen falta unos 80 ceros en binario al principio. Lo trabajaremos en el módulo de minería.

Árbol de Merkle

Las transacciones se emparejan y se hashean por niveles hasta quedar un solo hash: la raíz. Una prueba de inclusión solo necesita los hashes hermanos del camino: log₂(n) hashes en lugar de n. Así, un teléfono puede comprobar que su pago está en un bloque sin descargarlo entero (SPV).

Laboratoriolab06_merkle.py
Guía paso a paso para principiantes

Qué vas a hacer

Vas a construir un árbol de Merkle con 7 “transacciones”, a generar una prueba de inclusión de solo 3 hashes y a ver una rareza histórica: dos listas distintas con la misma raíz.

Antes de empezar

  • Solo necesitas este archivo.

Paso a paso

  1. Ejecuta: python3 lab06_merkle.py.
  2. Lee la línea prueba de la tx 5 = 3 hashes (no 7): con solo 3 hashes se demuestra que la transacción 5 está en el bloque.
  3. Mira la línea ¿tx falsa en la misma posición? False: una transacción falsa no pasa la verificación.
  4. La última línea muestra que [a,b,c] y [a,b,c,c] producen la misma raíz. Es la vulnerabilidad CVE-2012-2459.

Cómo leer lo que sale

  • En un árbol de n hojas, la prueba necesita aproximadamente log₂(n) hashes. Con 4 000 transacciones, unos 12.
  • La rareza del último nodo duplicado ocurre cuando el número de hojas es impar: Bitcoin copia el último hash. Por eso los nodos rechazan bloques con transacciones repetidas.

Prueba esto

  • Cambia range(7) por range(16) y mira cuántos hashes necesita la prueba de la tx 5 (tendrían que ser 4).
  • Cambia proof(txs, 5) por proof(txs, 0) y comprueba que sigue siendo válida con verify(txs[0], p, root).

Si algo falla

  • Si cambias range(7) a un número muy grande (millones), tardará: no hace falta para aprender.
Ver el código completo
"""Lab 2.5 - Árbol de Merkle: raíz, prueba de inclusión (SPV) y la rareza del nodo duplicado."""
import hashlib
def dsha(b): return hashlib.sha256(hashlib.sha256(b).digest()).digest()

def merkle_root(hashes):
    lvl = list(hashes)
    while len(lvl) > 1:
        if len(lvl) % 2: lvl.append(lvl[-1])            # Bitcoin duplica el último si es impar
        lvl = [dsha(lvl[i] + lvl[i+1]) for i in range(0, len(lvl), 2)]
    return lvl[0]

def proof(hashes, idx):
    lvl, path = list(hashes), []
    while len(lvl) > 1:
        if len(lvl) % 2: lvl.append(lvl[-1])
        sib = idx ^ 1; path.append((lvl[sib], idx % 2))
        lvl = [dsha(lvl[i] + lvl[i+1]) for i in range(0, len(lvl), 2)]; idx //= 2
    return path

def verify(leaf, path, root):
    h = leaf
    for sib, is_right in path: h = dsha(sib + h) if is_right else dsha(h + sib)
    return h == root

if __name__ == '__main__':
    txs = [dsha(f'tx{i}'.encode()) for i in range(7)]
    root = merkle_root(txs)
    p = proof(txs, 5)
    print('raíz:', root[::-1].hex())
    print('prueba de la tx 5 =', len(p), 'hashes (no 7). ¿válida?', verify(txs[5], p, root))
    print('¿tx falsa en la misma posición?', verify(dsha(b'falsa'), p, root))
    # CVE-2012-2459: [a,b,c] y [a,b,c,c] dan la misma raíz
    a, b, c = txs[:3]
    print('mutabilidad: raíz([a,b,c]) == raíz([a,b,c,c])?', merkle_root([a,b,c]) == merkle_root([a,b,c,c]))
Salida de una ejecución real
raíz: cb9c5d0746aa71706465e856350da13c1801204587272b3990920ce00889ef6a
prueba de la tx 5 = 3 hashes (no 7). ¿válida? True
¿tx falsa en la misma posición? False
mutabilidad: raíz([a,b,c]) == raíz([a,b,c,c])? True

El último resultado es una advertencia histórica: duplicar el último nodo cuando hay número impar hace que [a,b,c] y [a,b,c,c] tengan la misma raíz. Se descubrió en 2012 (CVE-2012-2459) y se mitigó rechazando bloques con transacciones duplicadas.

Qué te asegura la cadena de bloques

  • Orden: cada bloque apunta al anterior, así que hay un único orden posible.
  • Inmutabilidad práctica: cambiar un bloque obliga a rehacer su trabajo y el de todos los posteriores.
  • Verificabilidad barata: con 80 bytes por bloque (unos 75 MB para toda la historia de cabeceras), un dispositivo ligero puede comprobar la cadena con más trabajo.

Comprueba lo aprendido

¿Cuántos hashes necesita una prueba de Merkle de una transacción en un bloque de 4 000 transacciones?

¿Qué es lo único que se hashea para la prueba de trabajo?

¿Qué es la transacción coinbase?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 2
La tecnología de Bitcoin · lección 10 de 10 · 28 min

Cómo se ponen de acuerdo los nodos

Miles de nodos independientes, sin jefe, acaban con el mismo libro de cuentas. Veamos cómo, y qué pasa cuando hay desacuerdos temporales.

MadridLimaTokioSan SalvadorOsloLagosnodos
Una red sin jefe: cada nodo verifica por su cuenta.
nadie mandatodos verificanmiles de nodos
Miles de nodos independientes acaban con el mismo libro de cuentas.

El ciclo de vida de un pago

  1. Tu cartera firma y envía la transacción a un nodo.
  2. Los nodos la validan (firmas, no gastada antes, scripts, reglas de relevo) y la reenvían. Mientras espera, está en la mempool.
  3. Un minero la incluye en un bloque candidato y busca la prueba de trabajo.
  4. Al aparecer un bloque válido, los nodos lo validan por completo y lo aceptan. Tu pago tiene 1 confirmación; cada bloque posterior suma una.

Qué comprueba un nodo cuando recibe una transacción

Antes de leer la lista, míralo funcionar: cada paquete pasa por seis puertas de verificación.

  • El formato es válido y no excede el tamaño permitido.
  • Cada entrada apunta a un UTXO que existe y no está gastado.
  • La suma de las salidas no supera la suma de las entradas.
  • Los scripts se ejecutan correctamente (las firmas son válidas).
  • Cumple las reglas de relevo (comisión mínima, tamaño de salidas, etc.).

Si falla cualquiera, la descarta y no la reenvía. Por eso una transacción inválida no se propaga: cada nodo es un portero que hace su propia comprobación.

Dos bloques a la vez

A veces dos mineros encuentran bloque casi al mismo tiempo. La red se divide un instante; el siguiente bloque decide: se adopta la cadena con más trabajo acumulado. El bloque perdedor queda huérfano (huérfano en terminología coloquial; técnicamente un bloque obsoleto). Por eso un pago con 0 o 1 confirmaciones es menos firme que uno con 6.

Una analogía: el coro sin director

Imagina un coro enorme sin director donde cada cantante oye a sus vecinos y ajusta su tono al de la mayoría. Aunque dos cantantes empiecen distinto, tras unos compases el coro entero canta lo mismo. En Bitcoin, el “tono” es la cadena con más trabajo, y el “oído” de cada nodo es su propia verificación de las reglas.

Quién decide las reglas

Los mineros no deciden las reglas; ordenan transacciones dentro de ellas. Los nodos (que usan los usuarios y las empresas) rechazan los bloques que las rompen. Es el motivo por el que, en la guerra del tamaño de bloque de 2017, el resultado dependió de lo que miles de nodos estuvieran dispuestos a aceptar. Lo desarrollamos en el módulo de protocolo.

Comprueba lo aprendido

¿Quién rechaza un bloque que rompe las reglas aunque tenga prueba de trabajo válida?

¿Por qué se espera a varias confirmaciones en un pago grande?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 8
Seguridad y autocustodia · lección 1 de 13 · 30 min

Modelo de amenazas: ¿de qué te proteges?

No hay una configuración perfecta para todos: depende de cuánto tienes, quién te conoce y qué pierdes si falla.

RoboPhishingMalwareCoacciónOlvidoSemilla perdidaSin herenciaCopia mal hecha
Dos formas de perder bitcoin: que te lo quiten o que tú no puedas acceder.

Cuatro preguntas

  1. ¿Qué quiero proteger? (monto, privacidad)
  2. ¿De quién? (estafadores, ladrones, familia, un Estado, ti mismo)
  3. ¿Qué pasa si fallo? (pérdida definitiva, robo, bloqueo)
  4. ¿Cuánto esfuerzo puedo mantener? La mejor seguridad es la que sabes repetir.

Las dos formas de perder bitcoin

PérdidaEjemploMitigación
RoboPhishing, malware, fuga de semillaHardware, verificación, separar secretos
Olvido/destrucciónPapel quemado, semilla sin copia, muerte sin planCopias redundantes, instrucciones, herencia

La mayoría de los usuarios piensa en robo y olvida el olvido. Estimaciones públicas sobre bitcoin “perdidos” son inciertas; desconfía de cifras muy redondas.

Ejercicio: tu modelo de amenazas en una página

Escribe en papel, en tres columnas:

ActivoAmenazaDefensa actual
Mi semillaIncendio, robo en casaCopia en metal en dos lugares
Mi móvilPhishing, SIM swap2FA con llave, sin SMS
Mi nodoPérdida de datosSemilla respaldada; los bloques no importan

Marca los huecos donde no tienes defensa. Ahí es donde empezar.

Niveles orientativos

  • Pequeño y para aprender: cartera móvil con tu semilla bien guardada.
  • Ahorro serio: cartera de hardware + copia de la semilla en un material resistente + passphrase opcional.
  • Patrimonio importante: multisig 2-de-3 con claves en lugares y dispositivos distintos, y un plan de herencia.

Un caso real: la custodia que falló

Entre 2014 y 2022 varias plataformas centralizadas (Mt. Gox, QuadrigaCX, FTX, entre otras) dejaron a sus clientes sin acceso a fondos, por fraude, errores o quiebra. Lo común no fue un fallo criptográfico: fue que las claves estaban en manos de un tercero y nadie podía verificar que existieran los fondos. La lección aplicable a cualquiera: si no controlas las claves, tu saldo es una promesa.

Comprueba lo aprendido

¿Cuál es el riesgo que más se subestima?

¿Qué tuvieron en común los casos de custodia fallida (Mt. Gox, FTX...)?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 8
Seguridad y autocustodia · lección 2 de 13 · 36 min

Semillas, BIP39 y derivación

Doce o veinticuatro palabras controlan todo. Entender qué son te quita miedo y errores.

#Entropíaaleatoria12 o 24 palabrasSemilla (PBKDF2)Árbol de claves
De la entropía a las palabras y de las palabras a todas tus claves.
12345678910111212 palabras en papel o metaltodas tus claves
Doce palabras de las que nace un árbol de claves.

De la entropía a las palabras (BIP39)

  1. Se genera entropía aleatoria de 128 o 256 bits.
  2. Se añade un checksum.
  3. Se convierte en 12 o 24 palabras de una lista de 2048.
  4. La semilla se obtiene aplicando PBKDF2-HMAC-SHA512 a las palabras (y a una passphrase opcional).

Con la semilla, BIP32 genera un árbol de claves ilimitado. Estándares de ruta: BIP44 (1…), BIP49 (3…), BIP84 (bc1q…) y BIP86 (bc1p…).

Las cuentas, con números

  • Una lista de 2048 palabras = 11 bits por palabra.
  • 12 palabras = 132 bits = 128 de entropía + 4 de checksum.
  • 24 palabras = 264 bits = 256 de entropía + 8 de checksum.
  • Posibles semillas de 12 palabras: 2¹²⁸ ≈ 3,4×10³⁸. Adivinarlas por azar es inviable.

El checksum detecta errores al transcribir: si te equivocas en una palabra, la cartera avisa. No sustituye una copia correcta.

La passphrase (“25.ª palabra”)

Es opcional. Cada passphrase crea una cartera distinta. Si la pierdes, los fondos son irrecuperables. Si un atacante roba las 24 palabras pero no la passphrase, no accede. Úsala solo si puedes guardarla con el mismo cuidado que la semilla.

Cómo guardar la semilla

MedioVentajaRiesgo
PapelBaratoFuego, agua, tiempo
Placa de metalResiste fuego e inundaciónCuesta más; hay que grabar bien
Dividir con Shamir (SLIP-39)Tolera la pérdida de partesComplejidad; exige entenderlo
Foto, nube, gestor de contraseñasCómodoNunca: es la forma de que te la roben

Guarda dos copias en lugares distintos y físicamente seguros. Y haz una recuperación de prueba antes de depositar una cantidad importante.

Comprueba lo aprendido

Alguien por chat te pide tus 12 palabras “para verificar tu cuenta”. ¿Qué haces?

¿Cuántos bits de entropía tiene una semilla de 12 palabras?

¿Por qué no se debe guardar la semilla en una foto en la nube?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 8
Seguridad y autocustodia · lección 3 de 13 · 48 min

Descriptores y carteras deterministas

Una cartera moderna es un árbol de claves que nace de una sola semilla. Los descriptores son la forma de decir exactamente qué direcciones pertenecen a esa cartera.

SemillaClave maestra y código de cadenaRuta m/84'/0'/0'Direcciones bc1q…
Una semilla, una ruta, una cuenta y todas sus direcciones.

BIP 32: el árbol

De la semilla sale una clave maestra y un código de cadena (HMAC-SHA512 con la cadena Bitcoin seed). De ahí se derivan hijas con índices. Los índices desde 2³¹ son endurecidos (hardened): no se pueden derivar solo con la clave pública, lo que limita el daño si se filtra una clave extendida.

Una analogía: el llavero infinito

Piensa en un llavero del que cuelgan llaveros, y de cada uno, más llaveros. Si conoces el llavero raíz (la semilla), puedes reconstruir todo el árbol. Si solo conoces una rama (la clave pública extendida), puedes ver las direcciones de esa rama sin poder gastarlas: es lo que usan las tiendas para generar una dirección nueva por cliente sin tener las claves privadas.

Rutas estándar

RutaDirecciónEstándar
m/44'/0'/0'1…BIP 44
m/49'/0'/0'3…BIP 49
m/84'/0'/0'bc1q…BIP 84
m/86'/0'/0'bc1p…BIP 86

Cada segmento significa algo: 84' = el propósito (SegWit nativo), 0' = la moneda (Bitcoin), 0' = la cuenta, y después 0/n para recibir y 1/n para el cambio.

Laboratorio 8.1: tu propia cartera HD

Laboratoriolab14_hd_wallet.py
Guía paso a paso para principiantes

Qué vas a hacer

Vas a convertir una semilla en una clave maestra y en claves hijas con el algoritmo de las carteras modernas (BIP 32), y vas a comprobar que tu resultado coincide con el vector de prueba oficial publicado en el estándar.

Antes de empezar

  • Guarda en la misma carpeta lab03_ecdsa_secp256k1.py, lab04_direcciones.py y lab14_hd_wallet.py. El último importa los otros dos.

Paso a paso

  1. Ejecuta: python3 lab14_hd_wallet.py.
  2. La primera línea muestra la clave privada extendida maestra (xprv9s21Zr...), derivada de la semilla 000102030405060708090a0b0c0d0e0f con HMAC-SHA512 y la cadena Bitcoin seed.
  3. La segunda línea muestra la clave hija m/0' (índice endurecido).
  4. Los assert del programa comparan ambas con las del estándar. Si no saltó ningún error, tu implementación es correcta.

Cómo leer lo que sale

  • xprv…: una clave privada extendida: contiene la clave y el código de cadena necesarios para derivar hijas.
  • Índice endurecido (0'): se deriva con la clave privada, de modo que una clave pública extendida no permite deducir las hijas endurecidas ni la clave del padre.
  • La semilla de este laboratorio es pública (un vector de prueba): nunca uses una semilla de ejemplo para guardar dinero real.

Prueba esto

  • Cambia la semilla por otra de 16 bytes y observa cómo cambian todas las claves (los assert fallarán porque comparan con el vector oficial).
  • Deriva otra hija: k2, c2 = child(k1, c1, 1) y muestra su xprv.
  • Calcula la clave pública de cualquier hija con pubkey_compressed(k2).hex() y la dirección con las funciones del laboratorio 4.

Si algo falla

  • ModuleNotFoundError: faltan los laboratorios 3 o 4 en la carpeta.
  • AssertionError: has modificado la semilla o una constante; vuelve a copiar el código original.
Ver el código completo
"""Lab 8.1 - Cartera determinista jerárquica (BIP32): de una semilla a claves hijas. Con el vector de prueba oficial."""
import hmac, hashlib, struct, sys, os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from lab03_ecdsa_secp256k1 import N, mul, pubkey_compressed
from lab04_direcciones import ripemd160
B58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
def b58check(b):
    chk = hashlib.sha256(hashlib.sha256(b).digest()).digest()[:4]; n = int.from_bytes(b + chk, 'big'); s = ''
    while n: n, r = divmod(n, 58); s = B58[r] + s
    return '1' * (len(b) - len(b.lstrip(b'\0'))) + s
def master(seed):
    I = hmac.new(b'Bitcoin seed', seed, hashlib.sha512).digest(); return int.from_bytes(I[:32], 'big'), I[32:]
def child(k, c, i):
    if i >= 0x80000000: data = b'\x00' + k.to_bytes(32, 'big') + struct.pack('>L', i)         # endurecida: usa la privada
    else: data = pubkey_compressed(k) + struct.pack('>L', i)                                    # normal: usa la pública
    I = hmac.new(c, data, hashlib.sha512).digest()
    return (int.from_bytes(I[:32], 'big') + k) % N, I[32:]
def xprv(k, c, depth=0, parent=b'\0'*4, idx=0):
    return b58check(bytes.fromhex('0488ade4') + bytes([depth]) + parent + struct.pack('>L', idx) + c + b'\x00' + k.to_bytes(32, 'big'))
if __name__ == '__main__':
    seed = bytes.fromhex('000102030405060708090a0b0c0d0e0f')                       # vector de prueba 1 de BIP32
    k, c = master(seed)
    print('master xprv :', xprv(k, c))
    assert xprv(k, c) == 'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi'
    k1, c1 = child(k, c, 0x80000000)                                                  # m/0'
    print("m/0' xprv   :", xprv(k1, c1, 1, ripemd160(hashlib.sha256(pubkey_compressed(k)).digest())[:4], 0x80000000))
    assert xprv(k1, c1, 1, ripemd160(hashlib.sha256(pubkey_compressed(k)).digest())[:4], 0x80000000).startswith('xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7')
    print("Paso a paso:  semilla -> HMAC-SHA512('Bitcoin seed') -> clave maestra + código de cadena -> hijas con índices.")
    print("Rutas estándar: m/44'/0'/0' (legacy), m/84'/0'/0' (bc1q), m/86'/0'/0' (bc1p). El apóstrofo = índice endurecido.")
    print('Con la clave pública extendida (xpub) se derivan direcciones SIN poder gastar: útil para tiendas y monitoreo.')
Salida de una ejecución real
master xprv : xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi
m/0' xprv   : xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7
Paso a paso:  semilla -> HMAC-SHA512('Bitcoin seed') -> clave maestra + código de cadena -> hijas con índices.
Rutas estándar: m/44'/0'/0' (legacy), m/84'/0'/0' (bc1q), m/86'/0'/0' (bc1p). El apóstrofo = índice endurecido.
Con la clave pública extendida (xpub) se derivan direcciones SIN poder gastar: útil para tiendas y monitoreo.

El laboratorio pasa el vector de prueba oficial de BIP 32: tu implementación produce exactamente la misma clave extendida que publica el estándar. Cuando una implementación coincide con el vector oficial, puedes confiar en que entiendes el algoritmo.

Descriptores

Un descriptor describe el script y las claves de una cartera, por ejemplo:

wpkh([a1b2c3d4/84h/0h/0h]xpub6.../0/*)#checksum
  • wpkh indica el tipo de salida (SegWit nativo).
  • Entre corchetes va la huella de la clave maestra y la ruta.
  • /0/ son las direcciones de recepción; /1/, las de cambio.
  • Bitcoin Core y otras carteras importan y exportan descriptores. Guárdalos junto a tus copias de la semilla (sobre todo en multisig).

Gap limit

Las carteras buscan direcciones usadas hasta encontrar un hueco de, por defecto, 20 sin uso. Si generas muchas direcciones que no usas, puede parecer que “falta saldo” al restaurar: hay que ampliar la búsqueda.

Qué guardar y qué no

Dato¿Secreto?¿Lo guardas?
Semilla (12/24 palabras)Sí, máximoSí, en papel o metal, varias copias
PassphraseSíSí, aparte de la semilla
Clave pública extendida (xpub)Privacidad (revela tus direcciones)Sí, para cartera de solo lectura
DescriptorPrivacidadSí, junto a las copias
Dirección de recepciónNoNo hace falta

Comprueba lo aprendido

¿Para qué sirve guardar el descriptor de una cartera?

¿Qué permite una clave pública extendida (xpub)?

¿Qué significa el apóstrofo en m/84'/0'/0'?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 8
Seguridad y autocustodia · lección 4 de 13 · 32 min

Hardware wallets y verificación

Una cartera de hardware mantiene tus claves privadas en un dispositivo aislado. Pero solo funciona si la compras y la usas bien.

Tu cartera preparala transacciónEl dispositivola firmaTú verificasla pantallaSe difunde
La clave nunca sale del dispositivo: el ordenador solo prepara y difunde.

Cómo funciona

El dispositivo firma dentro y solo exporta la firma. Tu ordenador o móvil prepara la transacción (PSBT, BIP 174) y el dispositivo muestra en su pantalla a quién envías y cuánto.

Elegir

  • Código abierto y auditado cuando sea posible.
  • Pantalla para verificar direcciones.
  • Compra solo al fabricante o a un distribuidor oficial. Un dispositivo trucado de segunda mano es un clásico.
  • Compatibilidad con carteras de escritorio que te permitan conectar tu nodo.

Costumbres

  1. Comprueba el sellado y las instrucciones del fabricante.
  2. Genera la semilla en el dispositivo, anótala en papel o metal.
  3. Haz una transacción de prueba pequeña, luego una recuperación de prueba (borra y restaura desde las palabras).
  4. Actualiza el firmware desde la fuente oficial.

Qué amenazas resuelve y cuáles no

Amenaza¿Protege el hardware?
Malware en tu ordenadorSí: la clave no sale del dispositivo
Phishing que te hace firmar algo que no entiendesNo: tú tienes que leer la pantalla
Robo del dispositivoParcial: el PIN limita, pero conviene una passphrase
Pérdida de la semillaNo: depende de tu copia
Cadena de suministro (dispositivo manipulado)Solo si compras bien y verificas

Entre los fabricantes está Blockstream (Jade), socio del podcast; el criterio de elección es el mismo para cualquier marca.

Comprueba lo aprendido

¿Por qué hacer una recuperación de prueba?

Un hardware wallet te muestra en pantalla una dirección distinta a la de tu ordenador. ¿Qué haces?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 8
Seguridad y autocustodia · lección 5 de 13 · 36 min

PSBT: firmar sin conectar tu clave

Una PSBT es una transacción a medio hacer que viaja entre aplicaciones y dispositivos. Permite firmar en un aparato aislado sin dar nunca la clave al ordenador.

CreadorActualizadorFirmanteCombinadorFinalizadorExtractor
Una PSBT pasa por seis roles hasta convertirse en una transacción lista.
cartera + nodoPSBTdispositivofirmafirmadaa la redla clave privada nunca sale del dispositivo
La clave privada no sale nunca del dispositivo.

Míralo con una cartera fría de código abierto

La Jade Plus de Blockstream es un buen ejemplo para entender el flujo, porque su firmware y su diseño son abiertos y se puede firmar solo con códigos QR, sin cable ni Bluetooth. Pulsa los pasos en orden (o deja que avancen solos). Después activa «Rompe la máquina»: un virus cambia la dirección en el teléfono y verás por qué la pantalla del dispositivo es la que manda.

Cómo es por fuera y por dentro (Jade Plus): mide 65 × 30 × 12 mm y la caja es de aluminio mecanizado. Por fuera: pantalla de 1,9 pulgadas (320 × 170), un botón frontal para confirmar, dos botones de navegación y uno de encendido en los cantos, un puerto USB-C y una cámara de 640 × 480 en la parte de atrás. Por eso en el paso 2 la cámara mira al teléfono y tú ves la pantalla, y en el paso 5 la Jade gira para enseñarle su QR. Por dentro, según la lista de piezas que Blockstream publica en GitHub (Jade Plus v0.3.1): un ESP32-S3 (8 MB de flash y 8 MB de PSRAM) que guarda la semilla cifrada y firma, un microcontrolador auxiliar STM32G030, la cámara GC0308 y una batería de 260 mAh. Las piezas y sus medidas salen de esa lista; su posición exacta en la figura es aproximada.

Los roles (BIP 174)

  1. Creador: arma la transacción sin firmas.
  2. Actualizador: añade la información necesaria (UTXO, rutas de derivación).
  3. Firmante: firma las entradas que puede.
  4. Combinador: junta las firmas de varios firmantes.
  5. Finalizador: construye los scripts finales.
  6. Extractor: produce la transacción lista para difundir.

Flujo típico con hardware

  1. Tu cartera de escritorio (conectada a tu nodo) crea la PSBT.
  2. La pasas al dispositivo por USB, tarjeta SD o QR.
  3. El dispositivo muestra destino e importe en su pantalla y firma.
  4. Vuelve a la cartera, que la finaliza y difunde.

En multisig

Cada firmante firma su copia y alguien combina. Las firmas pueden hacerse en días distintos y en lugares distintos.

Qué verificar en pantalla

  • Dirección de destino completa (no solo el principio).
  • Importe y comisión.
  • Que el cambio vuelve a una dirección tuya.

Una PSBT por dentro

Una PSBT es un archivo que empieza por cHNidP8 en base64 (los bytes psbt seguidos de 0xff). Contiene la transacción sin firmar y, para cada entrada, datos como el UTXO que gasta, las rutas de derivación y, tras firmar, las firmas parciales. Puedes verla con un decodificador como bitcoin-cli decodepsbt en tu nodo.

Un flujo seguro con aislamiento total (air-gap)

Con QR o tarjeta SD, el dispositivo de firma nunca se conecta a ningún ordenador. La PSBT entra y sale como imagen o archivo. Es el máximo aislamiento práctico: ni siquiera un fallo en el USB puede comprometerlo.

Comprueba lo aprendido

¿Quién añade las firmas de varios participantes en una PSBT multisig?

¿Qué es un flujo «air-gapped»?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 8
Seguridad y autocustodia · lección 6 de 13 · 36 min

Multisig y custodia colaborativa

Quien tiene una sola clave tiene un único punto de fallo. Con varias claves, el fallo de una no te arruina.

Fondos 2-de-3Clave en casaClave enel bancoClave conun familiar
Tres claves en tres lugares: con dos se gasta.
en casacaja de seguridadpersona de confianza2 de 3 para gastar
Tres claves en tres lugares; dos bastan para gastar.

2-de-3

Se crean tres claves y se necesitan dos para gastar. Ejemplo: una en tu casa, otra en una caja de seguridad, la tercera con un familiar o un servicio de custodia colaborativa que no puede gastar sin ti.

  • Si pierdes una, sigues pudiendo gastar con las otras dos.
  • Si roban una, no pueden gastar.

Cómo configurarlo

  1. Compra tres dispositivos distintos (idealmente de fabricantes distintos).
  2. Con una cartera de escritorio (Sparrow, Nunchuk...), crea un multisig 2-de-3 con las tres claves públicas extendidas.
  3. Guarda el descriptor de la cartera (qué claves y cómo) en varios sitios: sin él, las semillas no bastan para encontrar los fondos.
  4. Prueba con una cantidad pequeña.

Otras combinaciones

EsquemaProtege contraCoste
2-de-3Pérdida o robo de una claveModerado
3-de-5Pérdida de dos claves; colusión de dosMás fricción
1-de-2 con tiempoTú o un heredero, tras un plazoRequiere script con timelock

Costes y compromiso

Más complejidad, más fricción y, a veces, comisiones algo mayores. Con Taproot y MuSig2 el coste y la huella en cadena bajan.

Los errores más comunes en multisig

  • Perder el descriptor: con las tres semillas pero sin saber la estructura, recuperar es difícil.
  • Poner todas las claves en el mismo lugar: anula el propósito.
  • Usar el mismo fabricante y la misma vulnerabilidad en las tres claves.
  • No probar la recuperación.

Comprueba lo aprendido

¿Qué debes respaldar además de las semillas en un multisig?

En un 2-de-3, pierdes una clave. ¿Puedes seguir gastando?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 8
Seguridad y autocustodia · lección 7 de 13 · 30 min

Herencia y plan de contingencia

Si mañana no estás, ¿tu familia puede acceder? Es la pregunta incómoda que decide el destino de muchos bitcoin.

HoyDocumenta1 mesPrueba larecuperación1 añoRevisa el planSiempreActualizaLa mejor herencia es la que alguien puede ejecutar
Un plan de herencia con pasos que puedes dar hoy.

Principios

  • Que nadie pueda gastar sin ti en vida, pero que alguien pueda recuperar tras tu muerte.
  • Documenta qué hacer, no las claves en una carta.
  • Practica con una cantidad pequeña.

Opciones

  1. Instrucciones sin secretos: dónde está cada pieza y cómo reconstruirlo, con un abogado o un familiar de confianza.
  2. Multisig con una clave en manos de otra persona (o un servicio), más una cláusula de tiempo que permita un gasto alternativo.
  3. Timelocks: un camino de gasto que solo se abre si no se mueven los fondos durante meses.
  4. Divide y reparte secretos con esquemas probados (Shamir/SLIP-39, Codex32) en lugar de inventos caseros.

Un plan de ejemplo (sin secretos)

  1. Una carta que dice: «Tengo bitcoin. Está en una cartera multisig 2-de-3. Las claves están: una en [lugar A], otra en [lugar B], otra con [persona C]. El descriptor está en [lugar D]. Para recuperar, contactad con [persona de confianza] y descargad [software]. No compartáis estas instrucciones con nadie más.»
  2. Una lista de qué hacer, no cómo hacerlo en detalle, con una persona de confianza que conozca los pasos.
  3. Una recuperación de prueba cada año con una cantidad pequeña.

Errores frecuentes

  • No decir nada a nadie: la familia ni sabe que existe.
  • Dejar la semilla completa en un sobre en un cajón accesible a cualquiera.
  • Planes demasiado complicados que nadie podrá ejecutar.
  • No actualizarlo cuando cambias de dispositivo o de lugar.

Comprueba lo aprendido

¿Qué NO debe contener una carta de herencia?

¿Qué mejora un plan de herencia con el tiempo?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 8
Seguridad y autocustodia · lección 8 de 13 · 36 min

Estafas y ataques frecuentes

Casi todas las pérdidas importantes son ingeniería social, no criptografía rota.

Tu sentidocomúnMensajes y ofertasSolo lo legítimo
Tu mejor defensa es un filtro: desconfiar de la urgencia y verificar por otro canal.
EstafaCómo funcionaCómo evitarla
Soporte falsoTe piden la semilla “para ayudar”Nadie legítimo la pide
PhishingWeb clon de tu bolsa o carteraMarcadores, no enlaces de correos
Address poisoningUna transacción minúscula deja en tu historial una dirección parecida a la tuyaVerifica la dirección completa, no copies del historial
Malware del portapapelesCambia la dirección al pegarComprueba la dirección en la pantalla del hardware
Cambio de SIMRoban tu número para tomar tu cuenta2FA con app o llave, no SMS
“Inversión asegurada”Rendimientos garantizadosSi hay garantía alta, hay estafa
Romance + criptoTe enamoran y te llevan a una plataforma falsaNunca inviertas por consejo de alguien que solo conoces en línea
Extorsión físicaTe obligan a transferirNo presumas de tus fondos; usa multisig y retrasos

Costumbres que te protegen

  1. Sospecha de la urgencia.
  2. Verifica por un segundo canal.
  3. Compra y descarga solo de fuentes oficiales.
  4. Mantén separadas cartera de uso y ahorro.

Banderas rojas para memorizar

  • Garantizan rendimientos (la inversión legítima nunca los garantiza).
  • Presionan con plazos («solo hoy», «cuenta bloqueada»).
  • Piden la semilla, una clave o acceso remoto a tu ordenador.
  • Hablan de «oportunidades» con alguien que acabas de conocer.
  • Te piden primero enviar una pequeña cantidad para «desbloquear» más.
  • Usan enlaces acortados o dominios casi idénticos al oficial.

Qué hacer si te estafan

  1. No envíes más (las estafas suelen pedir «tasas» para liberar lo perdido).
  2. Documenta todo: capturas, direcciones, fechas.
  3. Denuncia a la policía y a la plataforma implicada.
  4. Cambia contraseñas y revisa tus cuentas.
  5. Desconfía de quienes te ofrecen «recuperar» tus fondos a cambio de un pago: suelen ser una segunda estafa.

Comprueba lo aprendido

Ves en tu historial una dirección casi idéntica a la tuya con 0,00000001 BTC. ¿Qué es?

Alguien te ofrece «recuperar» tus fondos perdidos a cambio de una tarifa. ¿Qué es probable?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 8
Seguridad y autocustodia · lección 9 de 13 · 30 min

Coacción y ataques físicos: cuando el atacante está en tu puerta

Casi todo el mundo se prepara contra virus y estafas. Pocos piensan en el caso en el que alguien te obliga a entregar tus bitcoin. Hablarlo antes es la mejor defensa.

Discreción: que no se sepa cuánto tienesFondos señuelo y PIN de coacciónMultisig con claves en sitios distintos
Defensa en capas contra la coacción: no ser visible, poder ceder algo y no poder entregarlo todo.

El modelo de amenaza que se olvida

A veces se le llama el ataque de la llave inglesa: es más barato presionar a una persona que romper la criptografía. No es un tema para asustarse, sino para diseñar: quién sabe qué tienes, dónde está y cuánto tiempo necesitaría alguien para llegar a todo.

Cuatro principios

  1. Discreción primero. El mejor ataque es el que no ocurre porque nadie sabía que existías. No presumas de tenencias, no pongas tu nombre en cuentas visibles y cuida lo que publica tu entorno.
  2. No dependas de un solo punto. Si una persona, un lugar y un dispositivo bastan para mover todo, un atacante solo necesita eso. Con un multisig 2-de-3 con claves en lugares y personas distintos hay que llegar a dos sitios.
  3. Un señuelo razonable. Una cartera “de uso” con una cantidad pequeña, creíble y ya expuesta, sirve para cumplir si pasa lo peor. Una passphrase distinta da una cartera oculta con otro contenido: el dispositivo no revela si existe otra.
  4. Tiempo. Los bloqueos con retraso (un timelock, o un servicio de custodia con espera) limitan lo que puedes entregar bajo presión: si necesitas esperar 48 horas, nadie puede forzarte a moverlo en 5 minutos.

PIN de coacción y funciones de seguridad

Algunos dispositivos permiten un PIN de coacción (duress PIN): lo introduces bajo presión y abre una cartera señuelo o borra los fondos visibles. Por ejemplo, la ficha oficial de la Jade Plus lista un PIN de coacción entre sus funciones. Comprueba siempre en la documentación vigente del fabricante qué hace exactamente cada función antes de confiar en ella.

Lo que no funciona

  • Mentir sobre algo verificable: si saben cuánto tienes, un señuelo escaso es una provocación.
  • Una nota con la semilla en el cajón junto al dispositivo: convierte el dispositivo en un adorno.
  • Prometer “no tengo acceso” si es falso: puede empeorar la situación.

Para un negocio o una familia

  • Documenta quién puede y quién no puede mover fondos, y que ninguna persona pueda hacerlo sola.
  • Reparte claves entre jurisdicciones o ciudades si el patrimonio lo justifica.
  • Ensaya el plan de contingencia (herencia, accidente) y mantén una lista de a quién llamar.

Comprueba lo aprendido

¿Cuál es la primera defensa frente a la coacción?

¿Por qué un multisig 2-de-3 con claves repartidas ayuda?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 8
Seguridad y autocustodia · lección 10 de 13 · 36 min

Simulacro de recuperación: demuestra que tus copias funcionan

Una copia de seguridad que no has restaurado es una esperanza. Este taller te guía para hacer un simulacro completo con dinero de prueba o cantidades mínimas, y te enseña a registrar el resultado.

Crea la carteraAnota la direccióny la huellaBorra eldispositivo o la appRestauray compara
Un ciclo de revisión: crear, borrar, restaurar, comparar, mejorar.

Por qué un simulacro

Los fallos más comunes aparecen al recuperar: palabras mal copiadas, una passphrase olvidada, un descriptor que faltaba, un dispositivo que ya no se actualiza. Hacerlo una vez con poco dinero te enseña lo que de otro modo aprenderías con mucho.

Antes de empezar

  • Una cartera nueva con una cantidad muy pequeña (lo que perderías sin dolor).
  • Papel y bolígrafo (o placa de metal) para la semilla, y un sitio de custodia ya pensado.
  • 60 minutos y ninguna prisa.

Paso a paso

  1. Crea la cartera y escribe la semilla a mano, nunca la fotografíes ni la escribas en el móvil.
  2. Anota la huella maestra (master fingerprint) y la primera dirección de recepción. Sirven de prueba de que has restaurado lo mismo.
  3. Envía una cantidad pequeña a esa dirección y espera a una confirmación.
  4. Borra la cartera (reinicia el dispositivo o desinstala la aplicación).
  5. Restaura con las palabras. Si usabas passphrase, escríbela exactamente igual (mayúsculas y espacios importan).
  6. Compara: huella, primera dirección y saldo. Si coinciden, la copia funciona.
  7. Gasta una pequeña parte hacia otra dirección tuya para probar la firma completa.

Qué registrar

PreguntaTu respuesta
¿Funcionó a la primera?Sí / No
¿Cuánto tardé?min
¿Qué dudas tuve?
¿Qué cambiaría en mi procedimiento?

Errores que verás

  • La dirección no coincide: una palabra está mal, o falta la passphrase, o la ruta de derivación es distinta.
  • El saldo es cero: estás en otra red (prueba, principal) o la cartera busca otro tipo de dirección.
  • No recuerdas la passphrase: sin ella los fondos son inaccesibles; esto es lo que se aprende con poco dinero.

Repetir con calendario

Haz un simulacro una vez al año y cuando cambies de dispositivo o de plan. Guarda una nota de “última prueba” con la fecha y el resultado.

Comprueba lo aprendido

¿Para qué sirve anotar la huella maestra y la primera dirección?

Si tras restaurar la primera dirección no coincide, ¿qué es lo más probable?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 8
Seguridad y autocustodia · lección 11 de 13 · 30 min

Elegir cartera: una tabla para decidir

No existe “la mejor cartera”. Existe la que encaja con tu cantidad, tu conocimiento y tus amenazas. Aquí tienes los criterios y una forma de decidir sin dejarte llevar por la publicidad.

Cartera de móvilCómoda para gastarMás expuesta a malwareDispositivo de hardwareClaves aisladasAlgo más de esfuerzo
Más cómoda o más segura: la elección depende de cuánto guardas y para qué.

Cinco tipos de cartera

TipoVentajasLimitacionesPara
Custodial (bolsa, app)Muy fácilNo tienes las clavesCantidades mínimas, aprender
Móvil no custodialCómoda para gastarExpuesta al móvilGasto diario
Escritorio (Sparrow, Specter, Bitcoin Core)Control total, conexión a tu nodoCurva de aprendizajeQuien quiere privacidad y detalle
Hardware walletClaves aisladas, firma en pantallaCoste, comprar bienAhorro
MultisigSin punto único de falloMás complejoCantidades grandes, empresas

Criterios para elegir un dispositivo

  1. Código abierto: el firmware se puede revisar. Ejemplo: la Jade Plus de Blockstream publica software y hardware abiertos.
  2. Cómo se firma: USB, Bluetooth o QR sin cables (air-gapped). Menos canales significa menos superficie de ataque.
  3. Pantalla suficiente para verificar dirección e importe.
  4. Compatibilidad con carteras de escritorio que acepten tu propio nodo (Sparrow, Specter, Bitcoin Core).
  5. Historial de seguridad y soporte: actualizaciones, comunidad, documentación.
  6. Compra al fabricante o a un distribuidor oficial.

Por ejemplo, la ficha de la Jade Plus señala cámara para firma por QR, compatibilidad con Blockstream Green, Sparrow y Specter, y funciones como PIN de coacción y firma sin estado (stateless). Contrasta siempre con la ficha vigente: los modelos y las funciones cambian.

Qué no es un criterio

  • El nombre más conocido.
  • El precio más bajo.
  • Una promesa de “inhackeable”: ningún dispositivo lo es; tu proceso (compra, copia, verificación) cuenta más.

Dos recetas

  • Principiante con poco: cartera móvil no custodial + una copia correcta de la semilla.
  • Ahorro serio: hardware wallet de código abierto + simulacro de recuperación + (si hay mucho) multisig 2-de-3.

Comprueba lo aprendido

¿Qué ventaja tiene firmar por QR frente a USB o Bluetooth?

¿Qué criterio debe pesar más que el nombre de la marca?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 8
Seguridad y autocustodia · lección 12 de 13 · 28 min

Auditoría de tu custodia: 25 comprobaciones

Una lista de comprobación convierte la seguridad en hábitos medibles. Recórrela una vez al año y deja constancia de lo que cambiarías.

ClavesCopiasOperacionesHerencia25 comprobaciones, una vez al año
Cuatro bloques: claves, copias, operaciones y herencia.

Claves (7)

  1. Tengo mi semilla escrita a mano y nunca digitalizada.
  2. Mi dispositivo lo compré al fabricante o distribuidor oficial.
  3. Verifiqué el sellado y el firmware al recibirlo.
  4. Si uso passphrase, sé dónde guardo la pista y quién más puede recordarla.
  5. Mi PIN es largo y no es una fecha obvia.
  6. Hay una cartera “de uso” separada de la de ahorro.
  7. Nadie más conoce dónde está todo.

Copias (6)

  1. Dos copias de la semilla en lugares distintos.
  2. Cada copia está protegida de agua y fuego (metal si es posible).
  3. Probé la restauración en un simulacro este año.
  4. Guardé el descriptor (en multisig es indispensable).
  5. Anoté la huella maestra de cada cartera.
  6. El entorno donde guardo una copia no depende de un solo familiar.

Operaciones (7)

  1. Verifico siempre la dirección en la pantalla del dispositivo.
  2. Pruebo con una cantidad pequeña antes de mover grandes importes.
  3. Actualizo el firmware desde fuentes oficiales y tras leer las notas.
  4. Mi ordenador tiene sistema al día y sin software pirata.
  5. Uso un navegador y una cuenta de correo con segundo factor sin SMS.
  6. Reviso mis permisos y extensiones del navegador.
  7. Sé reconocer las banderas rojas de estafa de la lección correspondiente.

Herencia y contingencia (5)

  1. Existe un documento para mis herederos que explica qué hacer, sin revelar secretos.
  2. Una persona de confianza sabe dónde buscar y a quién llamar.
  3. El plan funciona si yo no puedo hablar.
  4. Lo revisé este año.
  5. Los herederos saben que el bitcoin existe y que no es una estafa.

Cómo puntuarte

Cuenta tus “sí”: 21-25 es un buen nivel; 15-20, mejora un par de puntos esta semana; menos de 15, empieza por copias y simulacro, que son los que más pérdidas evitan.

Comprueba lo aprendido

¿Qué dos puntos evitan más pérdidas reales?

¿Por qué verificar la dirección en el dispositivo y no solo en el ordenador?

Fuentes y créditos

Inicio / Bitcoin completo / Módulo 8
Seguridad y autocustodia · lección 13 de 13 · 26 min

Autocustodia: preguntas frecuentes y errores clásicos

Las preguntas que más se repiten al empezar con autocustodia, y los errores que más pérdidas han causado.

ClavesCopiasHábitos
La autocustodia en tres capas: claves, copias y hábitos.

Preguntas

¿Dónde “está” mi bitcoin? En la cadena de bloques, no en tu cartera. Tu cartera guarda las claves que permiten gastarlo.

¿Qué pasa si pierdo mi dispositivo? Si tienes la semilla, compras otro dispositivo y restauras. Por eso la semilla es lo importante.

¿Qué pasa si alguien ve mi semilla? Puede gastar todo. Trátala como una llave maestra. Una passphrase añade una segunda protección.

¿Puedo guardar la semilla en una foto o en la nube? No. Cualquier copia digital abre un camino de ataque.

¿Una cartera nueva cada vez? Una cartera genera muchas direcciones desde la misma semilla; no hace falta cartera nueva para cada cobro.

¿Qué diferencia hay entre semilla y clave privada? La semilla genera todas las claves privadas de la cartera; una clave privada gobierna una dirección.

¿Qué es mejor, hardware wallet o multisig? No son excluyentes: la hardware wallet aísla la clave; el multisig reparte el riesgo entre varias.

¿Puedo recuperar bitcoin enviado a una dirección equivocada? Normalmente no. De ahí que se verifique la dirección en la pantalla del dispositivo y se haga una prueba pequeña.

Los cinco errores clásicos

  1. No probar la restauración. Descubren que la copia estaba mal justo cuando la necesitan.
  2. Copia única o en un solo lugar.
  3. Olvidar la passphrase o su pista.
  4. Caer en una estafa de “soporte” o de “recuperación”.
  5. Plan de herencia inexistente.

Lo que casi nunca falla

Un dispositivo comprado al fabricante, una copia de la semilla en metal en dos sitios, un simulacro de recuperación al año y una regla: nadie te pide nunca tus palabras.

Comprueba lo aprendido

¿Dónde está realmente tu bitcoin?

¿Qué hay que hacer si alguien te pide tus 24 palabras por “soporte”?

Fuentes y créditos