<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="es">
    <title>BlackMesa Labs</title>
    <subtitle>Notas de ingeniería: lo que construimos, lo que rompimos, lo que aprendimos.</subtitle>
    <link href="https://mesa.black/es/feed.xml" rel="self"/>
    <link href="https://mesa.black/es/"/>
    <updated>2026-11-01T01:00:00+01:00</updated>
    <id>https://mesa.black/es/</id>
    <author>
        <name>Jérôme Nadaud</name>
        <uri>https://github.com/jnadaud</uri>
    </author>
        <entry>
        <title>No se puede asegurar Luhn. Por eso tu tarjeta tiene un CVV.</title>
        <link href="https://mesa.black/es/no-se-puede-asegurar-luhn/"/>
        <id>https://mesa.black/es/no-se-puede-asegurar-luhn/</id>
        <updated>2026-11-01T01:00:00+01:00</updated>
        <summary>La fórmula de Luhn se ha explicado mil veces. Lo que se explica menos es que no protege de nada, que hacerla «más segura» es un error de categoría, y que el sector de los pagos lo entendió ya en los años noventa. También comprobamos qué ve nuestra propia herramienta cuando un código la usa como cerradura: nada. Está corregido, en parte, y esto es lo que queda.</summary>        <content type="html">&lt;p&gt;El último dígito de un número de tarjeta no forma parte del número de cuenta. Es un dígito de control, calculado sobre los otros quince con una &lt;a href=&quot;https://es.wikipedia.org/wiki/Algoritmo_de_Luhn&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;fórmula&lt;/a&gt; que Hans Peter Luhn, ingeniero de IBM, patentó en 1960. Está en los números de tarjeta, en los IMEI de los teléfonos y en cada identificador de empresa francés (SIREN y SIRET).&lt;/p&gt;
&lt;p&gt;Cabe en tres líneas. Empezando por la derecha, se duplica un dígito de cada dos; cuando el doble pasa de 9, se le resta 9; se suma todo. El número es válido si la suma es múltiplo de 10. &lt;code&gt;79927398713&lt;/code&gt; pasa, &lt;code&gt;79927398712&lt;/code&gt; no.&lt;/p&gt;
&lt;p&gt;Este texto parte de una idea que se oye a menudo, y que también tuvimos nosotros: ya que todo el mundo conoce la fórmula, ¿por qué no endurecerla? Cambiar su «modo cripto», ponerle una clave, convertirla en algo seguro. La respuesta corta es que no se puede, y el motivo es más útil que la propia fórmula.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-luhn-hace-de-verdad&quot;&gt;Lo que Luhn hace de verdad&lt;/h2&gt;
&lt;p&gt;Luhn no protege un número. Protege contra un error de tecleo: una persona que copia dieciséis dígitos de una tarjeta, por teléfono o en un teclado. Para ese trabajo es muy bueno, y lo comprobamos en lugar de copiarlo:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;detecta &lt;strong&gt;cualquier error en un solo dígito&lt;/strong&gt;;&lt;/li&gt;
&lt;li&gt;detecta &lt;strong&gt;cualquier inversión de dos dígitos vecinos, salvo &lt;code&gt;09&lt;/code&gt; ↔ &lt;code&gt;90&lt;/code&gt;&lt;/strong&gt;;&lt;/li&gt;
&lt;li&gt;se le escapan algunos «errores gemelos», cuando dos dígitos iguales se sustituyen por otros dos iguales: &lt;code&gt;22&lt;/code&gt; ↔ &lt;code&gt;55&lt;/code&gt;, &lt;code&gt;33&lt;/code&gt; ↔ &lt;code&gt;66&lt;/code&gt;, &lt;code&gt;44&lt;/code&gt; ↔ &lt;code&gt;77&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Es todo lo que se le pide. La fórmula no contiene ningún secreto: cualquiera la calcula, y es a propósito, porque es el formulario de pago el que tiene que poder decir «debe de haberse equivocado» antes de enviar nada.&lt;/p&gt;
&lt;p&gt;Para un adversario, la consecuencia es inmediata. Un número al azar pasa el control &lt;strong&gt;una vez de cada diez&lt;/strong&gt; (en cien mil sorteos, contamos un 10,2 %). Y quince dígitos elegidos siempre tienen un decimosexto que los hace válidos: basta con hacer la cuenta. Una protección que uno mismo puede calcular no protege de nada.&lt;/p&gt;
&lt;h2 id=&quot;por-qué-no-se-puede-endurecer&quot;&gt;Por qué no se puede endurecer&lt;/h2&gt;
&lt;p&gt;Supongamos que sustituimos la aritmética de Luhn por una función que recibe una clave secreta. El dígito de control pasa a ser imposible de calcular sin la clave: deseo concedido. Pero lo que hemos construido tiene nombre: es un &lt;strong&gt;&lt;a href=&quot;https://es.wikipedia.org/wiki/C%C3%B3digo_de_autenticaci%C3%B3n_de_mensaje&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;código de autenticación de mensajes&lt;/a&gt;&lt;/strong&gt;, un MAC. Y un MAC se juzga por su longitud.&lt;/p&gt;
&lt;p&gt;Un dígito decimal son 3,3 bits. Un adversario que no conoce la clave acierta el dígito una vez de cada diez, exactamente como antes. Hemos añadido una clave que gestionar, rotar y proteger, y la probabilidad de falsificación no se ha movido ni un ápice.&lt;/p&gt;
&lt;p&gt;Para alcanzar la seguridad que se espera de un MAC moderno, 128 bits, harían falta &lt;strong&gt;39 dígitos de control&lt;/strong&gt;. Un número de tarjeta no tiene ni uno libre: el formato lo fija la norma ISO/IEC 7812, y los terminales y formularios de todo el mundo lo esperan tal cual. El presupuesto de seguridad de un identificador se cuenta en dígitos, y el de este es cero.&lt;/p&gt;
&lt;p&gt;El problema, por tanto, no es que Luhn sea «débil». Hace perfectamente otra cosa. Proteger contra un accidente y proteger contra un adversario son dos oficios distintos, y el primero no es una versión rebajada del segundo.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-hizo-el-sector-en-su-lugar&quot;&gt;Lo que hizo el sector en su lugar&lt;/h2&gt;
&lt;p&gt;El sector de los pagos se hizo la misma pregunta, y respondió dejando a Luhn en paz y poniendo la seguridad al lado.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;El &lt;a href=&quot;https://es.wikipedia.org/wiki/C%C3%B3digo_de_seguridad_de_tarjetas_de_cr%C3%A9dito&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;CVV&lt;/a&gt; es exactamente el «Luhn con clave» que buscábamos.&lt;/strong&gt; Los tres dígitos del dorso de la tarjeta los calcula el banco emisor, con un par de claves secretas (en &lt;a href=&quot;https://es.wikipedia.org/wiki/Triple_DES&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;3DES&lt;/a&gt;, dentro de un módulo de seguridad hardware), sobre el número, la fecha de caducidad y un código de servicio. Sin la clave, no se pueden calcular. Es un MAC.&lt;/p&gt;
&lt;p&gt;Y tiene el defecto que acabamos de describir: tres dígitos, apenas 10 bits. Uno entre mil. Lo que lo hace utilizable no es la criptografía, sino todo lo que lo rodea. El banco bloquea la tarjeta tras unos pocos intentos fallidos, y las normas &lt;a href=&quot;https://es.wikipedia.org/wiki/PCI_DSS&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;PCI DSS&lt;/a&gt; prohíben guardar el CVV después de la autorización. Cuando esas condiciones fallan, tres dígitos no aguantan: en 2016, investigadores de la Universidad de Newcastle demostraron que repartiendo los intentos entre cientos de comercios en línea, que no se comunican entre sí, se encontraba el CVV de una tarjeta en cuestión de segundos.&lt;/p&gt;
&lt;p&gt;La lección es la misma que con Luhn, un paso más allá: &lt;strong&gt;un MAC demasiado corto solo es seguro mientras alguien cuente los intentos&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;El sector lo entendió tan bien que acabó jugando con la otra variable. Desde mediados de los años 2010, algunos bancos ofrecen tarjetas con &lt;strong&gt;CVV dinámico&lt;/strong&gt;: una pequeña pantalla en el dorso muestra un código que cambia a intervalos regulares, y las aplicaciones bancarias hacen lo mismo con las tarjetas virtuales. El código sigue teniendo tres dígitos. Nadie intentó alargarlo, porque el formato no lo permite. Se acortó su vida. Un CVV adivinado en cien comercios no sirve de nada si ha cambiado antes de que termine el ataque, y un CVV robado junto con el resto de la tarjeta caduca solo. Es el principio de los &lt;a href=&quot;https://es.wikipedia.org/wiki/Autenticaci%C3%B3n_con_contrase%C3%B1a_de_un_solo_uso&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;códigos de un solo uso&lt;/a&gt; de nuestras aplicaciones de autenticación: cuando un secreto no puede alargarse, se le hace morir pronto.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;La tokenización es la otra respuesta.&lt;/strong&gt; Cuando Apple Pay o Google Pay registran una tarjeta, el teléfono no recibe el número real. Recibe un token emitido por la red, con forma de número de tarjeta, Luhn incluido, para que terminales y formularios lo acepten sin cambiar nada. El token no vale nada fuera del dispositivo y del contexto para los que se emitió. El cifrado que preserva el formato (FF1, normalizado por el NIST en el SP 800-38G) hace un trabajo parecido: cifra un número de dieciséis dígitos en otro número de dieciséis dígitos.&lt;/p&gt;
&lt;p&gt;En ambos casos, Luhn sigue siendo lo que es: un control de tecleo sobre un número, ya sea real, token o cifrado. La seguridad vive en otra parte, en una clave, un módulo hardware y un contador de intentos.&lt;/p&gt;
&lt;p&gt;Una precisión sobre la computación cuántica, ya que es nuestro tema habitual: nada de esto depende de ella. Un MAC se basa en una clave compartida, que un ordenador cuántico solo debilita marginalmente. Un CVV no necesita un ordenador cuántico para ser adivinado, necesita un comercio que no cuente los intentos.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-ve-nuestra-herramienta&quot;&gt;Lo que ve nuestra herramienta&lt;/h2&gt;
&lt;p&gt;&lt;a href=&quot;https://github.com/mesa-black/sablier&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;Sablier&lt;/a&gt; lee un repositorio y anota toda la criptografía que encuentra en él. La pregunta natural era, por tanto: ¿qué dice de un código que usa un control de tecleo como cerradura? Escribimos un proyecto de cuatro archivos para saberlo, y ejecutamos sobre él la versión publicada, la 0.11.1, sin cambiar nada.&lt;/p&gt;
&lt;p&gt;Los cuatro archivos:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;un vale aceptado solo por su dígito de control de Luhn, y abonado con 50 €;&lt;/li&gt;
&lt;li&gt;un enlace de restablecimiento de contraseña «firmado» con &lt;code&gt;crc32()&lt;/code&gt;, y un token de autenticación verificado con &lt;code&gt;hash(&#039;crc32b&#039;, …)&lt;/code&gt;;&lt;/li&gt;
&lt;li&gt;el mismo enlace, firmado correctamente con &lt;code&gt;hash_hmac(&#039;sha256&#039;, …)&lt;/code&gt; y una clave secreta, como testigo;&lt;/li&gt;
&lt;li&gt;números de tarjeta guardados con &lt;code&gt;openssl_encrypt(…, &#039;des-ede3-cbc&#039;, …)&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;El informe:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;  . — 4 archivos leídos, 3 hallazgos, 0.0 s
  declaración: ninguna (duraciones por defecto)

    ROTO HOY                 1
    CONFORME                 1
    PROBABLEMENTE FUERA DE TEMA 1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;El 3DES se encuentra y se clasifica como roto, el &lt;a href=&quot;https://es.wikipedia.org/wiki/HMAC&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;HMAC&lt;/a&gt; se encuentra y se clasifica como conforme. El vale, el enlace firmado con CRC y el token verificado con CRC &lt;strong&gt;no aparecen en ninguna parte&lt;/strong&gt;. Y sin embargo son los tres únicos lugares del proyecto donde un desconocido puede obtener algo que no le pertenece.&lt;/p&gt;
&lt;p&gt;Los motivos eran precisos, y estaban todos en el código:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Un Luhn escrito a mano no tiene firma.&lt;/strong&gt; Es un bucle, una multiplicación por dos y un módulo 10. No hay ninguna llamada de biblioteca que reconocer, y nunca lo habíamos intentado.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Ninguna regla buscaba &lt;code&gt;crc32()&lt;/code&gt;.&lt;/strong&gt; Es una función de PHP, fácil de localizar, y a nadie se le había ocurrido.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;hash(&#039;crc32b&#039;, …)&lt;/code&gt; se veía y luego se descartaba.&lt;/strong&gt; La regla que lee &lt;code&gt;hash()&lt;/code&gt; encontraba la llamada, buscaba &lt;code&gt;crc32b&lt;/code&gt; en su catálogo, no lo encontraba, y aplicaba una regla escrita precisamente contra los falsos positivos: &lt;em&gt;un algoritmo que no conocemos no nos corresponde juzgarlo.&lt;/em&gt; Y sin embargo la línea contiene &lt;code&gt;$authToken&lt;/code&gt;, una de las palabras que, en otra parte del mismo archivo, devuelven un hallazgo al rojo.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;La palabra «checksum» hacía callar a la herramienta.&lt;/strong&gt; Sigue en la lista de indicios que señalan un identificador y no un control de seguridad. Un &lt;code&gt;md5()&lt;/code&gt; sobre un token de restablecimiento, en una función llamada &lt;code&gt;checksum&lt;/code&gt;, sale por tanto como «probablemente fuera de tema». En este caso concreto la conclusión se sostiene, porque las colisiones de MD5 no sirven de nada contra la huella de un token aleatorio. Pero el razonamiento es falso: la herramienta lo clasificó con las claves de caché porque leyó el nombre de la función, no porque entendiera lo que protege.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Hay algo peor que el silencio. Cada informe de Sablier termina con una sección «Lo que este informe no ha mirado», porque un inventario que calla sus ángulos muertos fabrica una falsa seguridad. Esa sección hablaba de los servicios gestionados, de los HSM, de las imágenes, del YAML. &lt;strong&gt;No hablaba de las sumas de control.&lt;/strong&gt; El lector de ese informe tenía todos los motivos para creer que sus enlaces de restablecimiento se habían revisado.&lt;/p&gt;
&lt;p&gt;No es un tropiezo puntual, es la consecuencia de una decisión que seguimos defendiendo. Las listas que hacen callar a la herramienta se construyeron a partir de una medición: veinte repositorios públicos, ochenta y nueve hallazgos clasificados como «rotos», ochenta y dos de los cuales eran claves de caché, nombres de archivo o identificadores. Sin ellas, los siete hallazgos reales se ahogaban. Con ellas, en treinta y un repositorios, solo quedan tres rojos falsos de veintiuno. Pero una lista que hace callar a la herramienta ante una palabra necesita la regla inversa, la que detecta cuándo esa palabra designa precisamente lo que se protege, y para «checksum» esa regla no existía.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-dice-ahora-la-herramienta&quot;&gt;Lo que dice ahora la herramienta&lt;/h2&gt;
&lt;p&gt;El hallazgo que faltaba no era «CRC32 está roto». &lt;a href=&quot;https://es.wikipedia.org/wiki/Verificaci%C3%B3n_de_redundancia_c%C3%ADclica&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;CRC32&lt;/a&gt; no está roto: hace muy bien aquello para lo que existe, comprobar que un archivo no se ha dañado por el camino. Ese hallazgo sería falso, y ese tipo de error enseña al lector a dejar de creer en los rojos. El hallazgo correcto trata del &lt;strong&gt;uso&lt;/strong&gt;, y es el que Sablier imprime desde la 0.12.0:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;ROTO HOY&lt;/strong&gt; — &lt;code&gt;src/ResetLink.php:8&lt;/code&gt;
Una suma de control protege contra un accidente, no contra alguien: no tiene clave y cualquiera puede recalcularla. El plazo era ayer.
&lt;em&gt;Sustitución: HMAC-SHA-256 con una clave secreta, comparado con &lt;code&gt;hash_equals()&lt;/code&gt;&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Sobre el mismo proyecto de cuatro archivos, el informe pasa de tres hallazgos a seis:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;  . — 4 archivos leídos, 6 hallazgos, 0.0 s
  declaración: ninguna (duraciones por defecto)

    ROTO HOY                 4
    CONFORME                 1
    PROBABLEMENTE FUERA DE TEMA 1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Las tres sumas de control del enlace de restablecimiento y del token están en rojo, el 3DES también. El enlace firmado con una clave sigue conforme.&lt;/p&gt;
&lt;p&gt;La regla es deliberadamente estrecha. Un &lt;code&gt;crc32()&lt;/code&gt; solo se señala si está junto a algo que un desconocido querría falsificar: un token, un enlace de restablecimiento, una contraseña, un secreto, una firma, un vale, leído en la línea, en el nombre de la función y en el nombre del archivo. En cualquier otro sitio se queda callado: verificar una descarga, repartir sesiones entre servidores o calcular un ETag es exactamente para lo que sirve una suma de control. La prueba que acompaña la corrección contiene esos tres usos, y falla si alguno se pone en rojo. Sin ella, habríamos sustituido un silencio por ruido.&lt;/p&gt;
&lt;p&gt;Lo que no está corregido es el propio Luhn. El vale aceptado por su dígito de control sigue sin aparecer: un bucle, un doble y un módulo no se distinguen de un cálculo ordinario, y reconocerlo por su forma es un proyecto aparte. Mientras tanto, el informe lo dice, en la sección de ángulos muertos, con todas las letras:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Las sumas de control (CRC32, Adler-32) solo se señalan junto a un token, un enlace o un secreto. Un dígito de control de Luhn o un módulo escritos a mano nunca: nada los distingue de un cálculo ordinario, y un código que acepta un número por su dígito de control no aparece aquí.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Luhn no necesita que lo aseguren. Necesita que dejemos de pedirle que lo sea, y que una herramienta que dice hacer inventario lo diga cuando no sabe ver a alguien haciéndolo.&lt;/p&gt;
</content>
    </entry>
        <entry>
        <title>Nombramos la rama. El commit acabó en main.</title>
        <link href="https://mesa.black/es/nombramos-la-rama/"/>
        <id>https://mesa.black/es/nombramos-la-rama/</id>
        <updated>2026-10-20T02:00:00+02:00</updated>
        <summary>En un repositorio GitOps, main es producción. Una noche de octubre llegaron allí manifiestos que nadie había aprobado, con una etiqueta de imagen que no existía, sin que nadie hubiera escrito «main». Dos ajustes de Git, razonables cada uno, y un comando correcto en cualquier otro sitio.</summary>        <content type="html">&lt;p&gt;En un repositorio GitOps no hay botón de «desplegar». Argo CD lee la rama &lt;code&gt;main&lt;/code&gt; de k3s-stack, nuestro repositorio de infraestructura (privado), y hace converger el clúster hacia lo que contiene. Empujar a &lt;code&gt;main&lt;/code&gt; es poner en producción. Ese es todo el interés del modelo, y por eso todo pasa por una rama, se revisa y luego se fusiona.&lt;/p&gt;
&lt;p&gt;El 19 de octubre a la 01:00, un commit llegó directamente a &lt;code&gt;main&lt;/code&gt;: los manifiestos del pequeño servicio que muestra al lector el intercambio de claves que su navegador acaba de negociar. Nadie los había aprobado. Y su imagen llevaba una etiqueta provisional, escrita a la espera de que la CI construyera la real:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-yaml&quot;&gt;images:
  - name: ghcr.io/mesa-black/handshake
    newTag: TO-BE-SET-AFTER-THE-FIRST-BUILD
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Argo CD hizo exactamente lo que se le pide: desplegó. El pod se quedó en &lt;code&gt;ImagePullBackOff&lt;/code&gt; nueve minutos, hasta que la CI escribió la etiqueta real a las 23:09 UTC. Nada grave esta vez: un servicio nuevo al que nadie llamaba todavía. Pero nadie había escrito &lt;code&gt;git push origin main&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id=&quot;el-comando-que-se-escribió&quot;&gt;El comando que se escribió&lt;/h2&gt;
&lt;p&gt;La rama se creó en un worktree, a partir de la rama remota, y luego se empujó nombrándola explícitamente. En esencia:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;git worktree add -b feat/handshake ../k3s-handshake origin/HEAD
# … commit …
git push -u origin feat/handshake
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Lo escribió el agente de código con el que trabajamos, y es el comando correcto en casi todas las configuraciones. No lo era en la nuestra, porque se cruzan dos ajustes.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;El primero es un valor por defecto de Git.&lt;/strong&gt; Una rama creada a partir de una rama remota (&lt;code&gt;origin/main&lt;/code&gt;, u &lt;code&gt;origin/HEAD&lt;/code&gt;, que apunta a ella) la sigue automáticamente: es &lt;code&gt;branch.autoSetupMerge&lt;/code&gt;, activado por defecto. Nuestra &lt;code&gt;feat/handshake&lt;/code&gt; tenía, pues, &lt;code&gt;main&lt;/code&gt; como rama de seguimiento, sin que nadie lo pidiera.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;El segundo es una elección, en nuestro &lt;code&gt;~/.gitconfig&lt;/code&gt;:&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-ini&quot;&gt;[push]
    default = upstream
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Con &lt;code&gt;upstream&lt;/code&gt;, &lt;code&gt;git push&lt;/code&gt; envía la rama actual a su rama de seguimiento. Es un ajuste legítimo, pensado para flujos en los que una rama local tiene otro nombre que la rama a la que alimenta. Con una rama que sigue a &lt;code&gt;main&lt;/code&gt;, empuja a &lt;code&gt;main&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Hasta aquí, nada sorprendente: es lo que dice la documentación para &lt;code&gt;git push&lt;/code&gt; sin argumentos. La sorpresa está en otro sitio.&lt;/p&gt;
&lt;h2 id=&quot;incluso-nombrando-la-rama&quot;&gt;Incluso nombrando la rama&lt;/h2&gt;
&lt;p&gt;Esperábamos que nombrar la rama, &lt;code&gt;git push -u origin feat/handshake&lt;/code&gt;, se impusiera al ajuste. No es así. Lo reprodujimos en un repositorio desechable, con Git 2.54, creando cada vez una rama desde &lt;code&gt;origin/main&lt;/code&gt;:&lt;/p&gt;
&lt;div class=&quot;scroll&quot;&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;code&gt;push.default&lt;/code&gt;&lt;/th&gt;
&lt;th&gt;&lt;code&gt;git push&lt;/code&gt;&lt;/th&gt;
&lt;th&gt;&lt;code&gt;git push -u origin mi-rama&lt;/code&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;simple&lt;/code&gt;, el valor por defecto de Git&lt;/td&gt;
&lt;td&gt;se niega, y explica por qué&lt;/td&gt;
&lt;td&gt;crea &lt;code&gt;mi-rama&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;current&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;crea la rama&lt;/td&gt;
&lt;td&gt;crea &lt;code&gt;mi-rama&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;upstream&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;empuja a main&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;empuja a main&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;p&gt;Con &lt;code&gt;upstream&lt;/code&gt;, un destino ausente del comando se sustituye por la rama de seguimiento, incluso cuando se ha escrito el nombre de la rama de origen. El nombre escrito indica qué se envía, no adónde llega. Solo un destino escrito por completo cambia el resultado:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;git push -u origin HEAD:refs/heads/feat/handshake   # sí crea la rama
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;El script, para comprobarlo sin nosotros:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-sh&quot;&gt;#!/bin/sh
# Una rama creada desde origin/main, empujada nombrándola.
set -e
d=$(mktemp -d) &amp;amp;&amp;amp; cd &amp;quot;$d&amp;quot;
git init -q --bare -b main remote.git
git clone -q remote.git clone 2&amp;gt;/dev/null &amp;amp;&amp;amp; cd clone
git commit -q --allow-empty -m init &amp;amp;&amp;amp; git push -q origin main
git switch -q -c mi-rama origin/main
git commit -q --allow-empty -m &amp;quot;mi-rama&amp;quot;
git -c push.default=upstream push -q -u origin mi-rama
git --git-dir=../remote.git for-each-ref --format=&#039;%(refname:short)&#039; refs/heads
# muestra «main» sola: la rama no existe, el commit está en main
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&quot;por-qué-es-peor-en-un-repositorio-gitops&quot;&gt;Por qué es peor en un repositorio GitOps&lt;/h2&gt;
&lt;p&gt;En un repositorio de aplicación, este push habría puesto un commit sin revisar en &lt;code&gt;main&lt;/code&gt;. Molesto, reparable, y la CI probablemente habría protestado antes de llegar a producción.&lt;/p&gt;
&lt;p&gt;En un repositorio GitOps no hay ningún paso intermedio. El commit es el despliegue. Sin revisión, sin fusión, y en nuestro caso ni siquiera imagen: el controlador aplicó un manifiesto que hacía referencia a una etiqueta que aún no existía. El error no se ve en Git, donde todo parece normal. Se ve en el clúster.&lt;/p&gt;
&lt;p&gt;Y tampoco se ve en el terminal. El push tiene éxito, sin aviso. La salida sí menciona &lt;code&gt;-&amp;gt; main&lt;/code&gt;, en una línea que nadie lee tras un push que ha funcionado.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-cambiamos&quot;&gt;Lo que cambiamos&lt;/h2&gt;
&lt;p&gt;Tres reglas, ahora escritas en las instrucciones del agente tanto como en las nuestras:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Crear las ramas desde &lt;code&gt;main&lt;/code&gt; local, no desde &lt;code&gt;origin/main&lt;/code&gt;.&lt;/strong&gt; Una rama creada desde una rama local no sigue nada: &lt;code&gt;git worktree add -b feat/x ../x main&lt;/code&gt;, o &lt;code&gt;--no-track&lt;/code&gt; si se parte de todos modos de la remota.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Empujar con un destino explícito:&lt;/strong&gt; &lt;code&gt;git push -u origin HEAD:refs/heads/feat/x&lt;/code&gt;. Es más largo, y es la única forma que da el mismo resultado diga lo que diga &lt;code&gt;push.default&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Comprobar &lt;code&gt;origin/main&lt;/code&gt; después de cada push de rama:&lt;/strong&gt; &lt;code&gt;git log origin/main -1&lt;/code&gt;. Si el último commit es el nuestro, ya está en producción.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;No cambiamos &lt;code&gt;push.default&lt;/code&gt;. El ajuste sirve en otros sitios, y cambiarlo solo habría arreglado nuestro equipo. La regla protege también al agente, que comparte la misma configuración.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-todavía-falta&quot;&gt;Lo que todavía falta&lt;/h2&gt;
&lt;p&gt;La verdadera barrera no está en el puesto de trabajo. Está en el servidor: una regla de GitHub que rechace los push directos a &lt;code&gt;main&lt;/code&gt; y exija una pull request, con una excepción para la clave de despliegue de la CI, que escribe las etiquetas de imagen.&lt;/p&gt;
&lt;p&gt;Hoy, la rama &lt;code&gt;main&lt;/code&gt; de k3s-stack no está protegida: ninguna regla sobre la rama. Todo lo anterior depende, pues, de la disciplina de quien empuja, humano o agente. Es lo próximo que hay que corregir, y lo escribimos aquí para que no se quede en una intención.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-dio-de-sí&quot;&gt;Lo que dio de sí&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Un push&lt;/strong&gt; a &lt;code&gt;main&lt;/code&gt;, a la 01:00, que ningún comando había pedido en esos términos.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Nueve minutos&lt;/strong&gt; de un pod en &lt;code&gt;ImagePullBackOff&lt;/code&gt; en producción, en un servicio al que nadie llamaba todavía.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Dos ajustes&lt;/strong&gt; implicados: &lt;code&gt;branch.autoSetupMerge&lt;/code&gt;, por defecto, y &lt;code&gt;push.default = upstream&lt;/code&gt;, por elección.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Un descubrimiento:&lt;/strong&gt; con &lt;code&gt;upstream&lt;/code&gt;, nombrar la rama no cambia el destino.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Tres reglas&lt;/strong&gt; de trabajo, y una protección de rama todavía por poner.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;buenas-prácticas&quot;&gt;Buenas prácticas&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;En un repositorio donde &lt;code&gt;main&lt;/code&gt; es producción, proteger &lt;code&gt;main&lt;/code&gt; en el servidor antes que nada. Una consigna protege a quien la conoce; una regla en el servidor protege a todos.&lt;/li&gt;
&lt;li&gt;Escribir el destino de un push completo (&lt;code&gt;HEAD:refs/heads/…&lt;/code&gt;) en los scripts y en las instrucciones de un agente: es la única forma independiente de la configuración local.&lt;/li&gt;
&lt;li&gt;Crear las ramas de trabajo desde la rama local, para que no sigan nada por accidente.&lt;/li&gt;
&lt;li&gt;Después de un push, leer la línea que dice adónde llegó, o comprobar la rama remota.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;puntos-de-atención&quot;&gt;Puntos de atención&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Un comando correcto solo lo es en una configuración.&lt;/strong&gt; &lt;code&gt;git push -u origin mi-rama&lt;/code&gt; es correcto casi en todas partes. Un agente que lo aprendió en otro sitio lo escribirá en tu equipo, con tu &lt;code&gt;~/.gitconfig&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Un ajuste heredado no aparece en ninguna revisión.&lt;/strong&gt; &lt;code&gt;push.default = upstream&lt;/code&gt; vive en la configuración global, no en el repositorio. Nada lo señala hasta que ha producido su efecto.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Que un push tenga éxito no dice adónde llegó.&lt;/strong&gt; Git no avisa cuando el destino difiere del nombre escrito. La única huella es la línea &lt;code&gt;-&amp;gt; main&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Quien responde es quien tiene la configuración.&lt;/strong&gt; El agente escribió el comando, pero fue nuestro equipo el que lo envió a &lt;code&gt;main&lt;/code&gt;. Lo escribíamos hace unos días: &lt;a href=&quot;/es/quien-responde/&quot;&gt;un agente puede hacerlo todo, no puede responder de lo que hizo&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;
</content>
    </entry>
        <entry>
        <title>Tu documento y su firma no viajan juntos</title>
        <link href="https://mesa.black/es/dos-urls/"/>
        <id>https://mesa.black/es/dos-urls/</id>
        <updated>2026-10-14T02:00:00+02:00</updated>
        <summary>Un artefacto firmado publicado en la web son al menos dos recursos HTTP. El verificador los descarga por separado, y nada garantiza que procedan de la misma generación. Cuando no es así, la verificación falla exactamente igual que ante una falsificación. Este es el mecanismo, lo que rompe y las tres formas de cerrarlo.</summary>        <content type="html">&lt;p&gt;Publicas un documento firmado. El lector ejecuta el comando que imprimiste, y responde:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;message imprint mismatch
Verification: FAILED
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Esa respuesta tiene dos causas posibles. Una es que alguien ha modificado tu documento. La otra es que ha descargado tu documento de ayer y tu sello de hoy.&lt;/p&gt;
&lt;p&gt;Nada, en el mensaje, las distingue.&lt;/p&gt;
&lt;h2 id=&quot;dos-ficheros-dos-recursos-dos-vidas-útiles&quot;&gt;Dos ficheros, dos recursos, dos vidas útiles&lt;/h2&gt;
&lt;p&gt;Un artefacto firmado en la web nunca es un fichero. Son &lt;strong&gt;al menos dos recursos HTTP independientes&lt;/strong&gt;: el documento y la firma separada que lo acompaña. A menudo tres, cuando se añade un sello de tiempo. En nuestro caso, cinco: un informe, su firma y tres atestaciones de fecha.&lt;/p&gt;
&lt;p&gt;El verificador los obtiene con peticiones separadas. Cada una pasa por su propia caché del navegador, su propio proxy, su propia CDN, y cada una sale con su propia frescura. &lt;strong&gt;Nada en el protocolo los trata como un conjunto.&lt;/strong&gt; No existe un «tráeme estos cinco ficheros tal como estaban en el mismo instante».&lt;/p&gt;
&lt;p&gt;Es evidente en cuanto se dice. No lo es en absoluto cuando se publica.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-hace-http-cuando-no-se-le-dice-nada&quot;&gt;Lo que hace HTTP cuando no se le dice nada&lt;/h2&gt;
&lt;p&gt;Si no pones &lt;code&gt;Cache-Control&lt;/code&gt;, la caché no renuncia. Adivina. La RFC 9111, sección 4.2.2, dice exactamente esto:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;em&gt;A cache MAY assign a heuristic expiration time when an explicit time is not specified, employing algorithms that use other field values (such as the Last-Modified time) to estimate a plausible expiration time.&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Y más adelante:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;em&gt;If the response has a Last-Modified header field, caches are encouraged to use a heuristic expiration value that is no more than some fraction of the interval since that time. A typical setting of this fraction might be 10%.&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Un diez por ciento de la edad del documento. Un informe publicado hace diez días se considera, por tanto, fresco durante un día entero, sin que nadie pregunte nada al servidor. Un informe publicado hace tres meses, durante más de una semana.&lt;/p&gt;
&lt;p&gt;Y no es un ajuste que hayas elegido: es lo que ocurre &lt;strong&gt;a falta&lt;/strong&gt; de ajuste. El silencio no es neutro.&lt;/p&gt;
&lt;h2 id=&quot;por-qué-este-fallo-es-más-grave-que-los-demás&quot;&gt;Por qué este fallo es más grave que los demás&lt;/h2&gt;
&lt;p&gt;Una entrada de blog servida desde la caché es una molestia. Aquí se combinan tres cosas.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;El documento lleva la huella de su propio contenido.&lt;/strong&gt; Es el principio: el informe imprime la huella de sus hallazgos, y es esa la que se compara con el sello. Un documento caducado lleva una huella caducada.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Y el lector no tiene los dos ficheros en el mismo estado.&lt;/strong&gt; Aquí es fácil equivocarse, y nos equivocamos al escribir este párrafo: uno imagina que los recursos tienen duraciones de frescura distintas. En nuestro sitio tienen exactamente la misma: el despliegue les da el mismo &lt;code&gt;Last-Modified&lt;/code&gt;, y por tanto la misma ventana heurística, al segundo.&lt;/p&gt;
&lt;p&gt;La asimetría está en otro sitio, y es &lt;strong&gt;de comportamiento&lt;/strong&gt;: el lector ya ha visitado la página, así que está en su caché. Nunca ha descargado el sello, así que no lo tiene. La primera petición sale de la caché, la segunda va al servidor. Dos generaciones, por el simple hecho de que una página se lee varias veces y una firma se verifica una sola.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Y el mensaje de error es el mismo que para una falsificación.&lt;/strong&gt; Esa es la cuestión. En &lt;a href=&quot;/es/cuando/&quot;&gt;la entrada de la semana pasada&lt;/a&gt;, explicábamos por qué &lt;code&gt;openssl ts -verify&lt;/code&gt; confunde dos situaciones que no tienen nada que ver: una cadena de certificados que no sabe construir y un sello que atestigua otro documento. He aquí una tercera, que va al mismo cajón: &lt;strong&gt;dos ficheros perfectamente auténticos, pero no de la misma generación.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;El lector ve &lt;code&gt;FAILED&lt;/code&gt;. Concluye lo que cualquiera concluiría.&lt;/p&gt;
&lt;h2 id=&quot;medido-en-nuestra-casa&quot;&gt;Medido en nuestra casa&lt;/h2&gt;
&lt;p&gt;Lo encontramos en nuestro propio sitio, y vale la pena contar cómo: un lector señaló que el inventario publicado mostraba todavía una versión que habíamos sustituido. El servidor, en cambio, devolvía la nueva: &lt;code&gt;curl&lt;/code&gt; lo mostraba en una línea.&lt;/p&gt;
&lt;p&gt;La tentación es responder «vacía tu caché». Es cierto, y es una mala respuesta: la causa estaba en nuestra casa. Nuestros artefactos firmados no llevaban &lt;strong&gt;ningún&lt;/strong&gt; &lt;code&gt;Cache-Control&lt;/code&gt;, solo un &lt;code&gt;Last-Modified&lt;/code&gt;. La heurística hacía exactamente lo que describe la RFC.&lt;/p&gt;
&lt;p&gt;Nadie salió perjudicado: la diferencia estaba en un número de versión y no en la huella, así que la verificación pasaba de todos modos. Pero fue suerte, no diseño: si los hallazgos hubieran cambiado, un lector concienzudo habría concluido que nuestro sello estaba roto.&lt;/p&gt;
&lt;h2 id=&quot;no-es-un-problema-de-blog&quot;&gt;No es un problema de blog&lt;/h2&gt;
&lt;p&gt;El mecanismo no depende de nada específico nuestro. Allí donde se publica un artefacto firmado con su firma al lado, la misma desincronización es posible:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;un &lt;strong&gt;SBOM&lt;/strong&gt; y su firma, en una release de GitHub o en un registro de artefactos;&lt;/li&gt;
&lt;li&gt;una &lt;strong&gt;atestación de procedencia&lt;/strong&gt; (SLSA, in-toto) servida junto a la imagen que describe;&lt;/li&gt;
&lt;li&gt;un &lt;strong&gt;bundle de sigstore&lt;/strong&gt;, cuyo &lt;code&gt;.sigstore&lt;/code&gt; es una segunda petición;&lt;/li&gt;
&lt;li&gt;un &lt;strong&gt;manifiesto de release&lt;/strong&gt; y su &lt;code&gt;SHA256SUMS.asc&lt;/code&gt;;&lt;/li&gt;
&lt;li&gt;cualquier &lt;strong&gt;sello RFC 3161&lt;/strong&gt; depositado junto al documento que fecha.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Y empeora con cada capa que se apila. Una CDN guarda su propia copia, con su propia duración, y no purga necesariamente los cinco ficheros en el mismo instante. Un espejo de paquetes se resincroniza por lotes. Cuantos más intermediarios, más larga es la ventana durante la cual tus recursos son de generaciones distintas.&lt;/p&gt;
&lt;h2 id=&quot;tres-formas-de-cerrarlo-y-lo-que-cuestan&quot;&gt;Tres formas de cerrarlo, y lo que cuestan&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;1. Prohibir usar sin preguntar.&lt;/strong&gt; &lt;code&gt;Cache-Control: no-cache&lt;/code&gt; en la familia de URL que lleva los artefactos firmados. El nombre engaña: no prohíbe almacenar, solo servir sin revalidar. El coste real es un &lt;code&gt;304 Not Modified&lt;/code&gt;, unos cientos de bytes, y el beneficio es que un lector ya no puede comparar dos generaciones.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# lo que dice ahora el servidor, en /audit/*
cache-control: no-cache

# y lo que cuesta la revalidación
curl -s -o /dev/null -w &#039;%{http_code}\n&#039; -H &amp;quot;If-None-Match: $ETAG&amp;quot; …
304
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Es el remedio más barato y más inmediato. Es el que aplicamos.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;2. Llevar la huella en la URL.&lt;/strong&gt; Un fichero llamado &lt;code&gt;report-8ecb829c.html&lt;/code&gt; no puede estar caducado: si el contenido cambia, el nombre cambia, y por tanto la dirección cambia. Una caché que te sirve la URL antigua te sirve el documento antiguo, lo cual es correcto, y verificable, porque su huella está en su nombre.&lt;/p&gt;
&lt;p&gt;Es más sólido que el punto 1, y más caro: los enlaces cambian con cada publicación, y hay que mantener accesibles las versiones antiguas o aceptar enlaces rotos. Resérvalo para los artefactos que se archivan, no para los que se vuelven a publicar.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;3. Imprimir la huella en el documento.&lt;/strong&gt; Este no sustituye a los otros dos, los hace diagnosticables. Si el informe muestra la huella que cubre, el verificador puede comparar &lt;strong&gt;tres&lt;/strong&gt; valores en lugar de dos: el que anuncia el documento, el que atestigua el sello y el que se recalcula.&lt;/p&gt;
&lt;p&gt;Y la combinación por fin distingue los casos:&lt;/p&gt;
&lt;div class=&quot;scroll&quot;&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;lo que se observa&lt;/th&gt;
&lt;th&gt;lo que es&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;el documento anuncia A, el sello atestigua A, el recálculo da A&lt;/td&gt;
&lt;td&gt;todo va bien&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;el documento anuncia A, el sello atestigua B&lt;/td&gt;
&lt;td&gt;los dos ficheros no coinciden. Casi siempre una copia caducada: vuelve a cargarlo todo, sin caché, antes de pensar en otra cosa&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;el documento anuncia A, el sello atestigua A, el recálculo da B&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;ahí&lt;/strong&gt; alguien ha modificado el documento&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;p&gt;Tres líneas que convierten un &lt;code&gt;FAILED&lt;/code&gt; mudo en tres diagnósticos separados.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-dice-de-una-herramienta-de-verificación&quot;&gt;Lo que dice de una herramienta de verificación&lt;/h2&gt;
&lt;p&gt;Es la misma lección que con los cuatro estados de un sello de tiempo, y se generaliza: &lt;strong&gt;una herramienta que verifica debe distinguir las razones del fallo, no solo constatar el fallo.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;«Estos dos ficheros no son de la misma generación» y «este documento ha sido modificado» piden gestos opuestos. El primero se arregla volviendo a cargar. El segundo es un incidente. Confundirlos es o bien lanzar una alerta por un problema de caché, o bien, mucho peor, archivar una falsificación real entre las rarezas de red y pasar a otra cosa.&lt;/p&gt;
&lt;p&gt;Por eso también hay que probar el comando de verificación &lt;strong&gt;desde una máquina que no sea la tuya&lt;/strong&gt;, y a ser posible desde un contenedor vacío. El equipo que produjo el artefacto tiene todas las versiones correctas en local; es precisamente el único lugar donde el fallo es invisible.&lt;/p&gt;
&lt;h2 id=&quot;buenas-prácticas&quot;&gt;Buenas prácticas&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Trata el documento, su firma y su sello como un conjunto&lt;/strong&gt;, ya que HTTP nunca lo hará por ti. Si solo vas a hacer una cosa, que sea esta.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Pon un &lt;code&gt;Cache-Control&lt;/code&gt; explícito en los artefactos firmados.&lt;/strong&gt; No poner nada no es neutro: la RFC permite a la caché adivinar, y adivina.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Imprime la huella en el propio documento.&lt;/strong&gt; Cuesta una línea y permite distinguir una copia caducada de una falsificación.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Verifica desde otro sitio.&lt;/strong&gt; Un contenedor vacío, otra máquina, otra red. El origen no reproduce el fallo que provoca.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Si archivas en lugar de volver a publicar, pon la huella en el nombre del fichero.&lt;/strong&gt; Una URL direccionada por su contenido no puede servir una versión caducada.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;puntos-de-atención&quot;&gt;Puntos de atención&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;no-cache&lt;/code&gt; y &lt;code&gt;no-store&lt;/code&gt; no dicen lo mismo. El primero permite guardar y obliga a revalidar; el segundo prohíbe guardar. Para un artefacto público basta el primero, y el segundo desperdicia ancho de banda sin aportar nada.&lt;/li&gt;
&lt;li&gt;Tu CDN tiene su propia política, que puede sobrevivir a la del origen. Compruébalo en el cable, desde fuera, y no en tu fichero de configuración.&lt;/li&gt;
&lt;li&gt;Purgar una caché fichero por fichero vuelve a abrir la ventana: durante la purga, los recursos son de generaciones distintas. Purga toda la familia de una vez, o deja que la revalidación haga el trabajo.&lt;/li&gt;
&lt;li&gt;Un verificador que descarga sus ficheros con unos minutos de diferencia puede caer en pleno despliegue. Es raro, es real, y es otro fallo más que parece una falsificación.&lt;/li&gt;
&lt;/ul&gt;
</content>
    </entry>
        <entry>
        <title>Un agente puede hacerlo todo. No puede responder de lo que hizo.</title>
        <link href="https://mesa.black/es/quien-responde/"/>
        <id>https://mesa.black/es/quien-responde/</id>
        <updated>2026-10-12T02:00:00+02:00</updated>
        <summary>Dónde acaba el desarrollo, dónde empieza la operación, y quién decide cuando una IA escribe la mitad de ambos. La respuesta no está en las herramientas ni en el organigrama: está en la reversibilidad, y el derecho europeo ya la ha escrito para la ciberseguridad. Esta es la línea, y lo que exige en la práctica.</summary>        <content type="html">&lt;p&gt;La pregunta «dónde está la frontera entre el desarrollo y la operación» está mal planteada desde hace diez años, y los agentes de código la han vuelto francamente inservible. Porque seguimos respondiéndola con herramientas — quién escribe el Terraform, quién lleva la guardia, quién tiene acceso a producción — cuando la única respuesta que se sostiene está en otra parte.&lt;/p&gt;
&lt;p&gt;Solo hay una frontera, y separa &lt;strong&gt;aquello de lo que se puede volver&lt;/strong&gt; de aquello de lo que no se vuelve.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-la-frontera-no-es&quot;&gt;Lo que la frontera no es&lt;/h2&gt;
&lt;p&gt;No está en las herramientas. Decir que el desarrollo acaba en el &lt;code&gt;git push&lt;/code&gt; y la operación empieza en el despliegue no tiene sentido en una cadena donde el mismo archivo describe la aplicación y la infraestructura que la sostiene, donde el mismo pipeline construye la imagen y la pone en producción.&lt;/p&gt;
&lt;p&gt;No está en los títulos. «DevOps» resolvió un problema de organización renombrándolo: se fusionaron dos equipos que se pasaban la pelota, lo cual fue un progreso, y de ahí concluimos que la frontera había desaparecido. No ha desaparecido. Se ha desplazado &lt;strong&gt;dentro de cada persona&lt;/strong&gt;, que escribe por la mañana el código que despliega por la tarde, y que debe por tanto arbitrar sola lo que una organización arbitraba por ella.&lt;/p&gt;
&lt;p&gt;Y no está en los permisos. Quién puede conectarse a producción es una consecuencia de la frontera, no su definición. Se reparten permisos porque se ha decidido quién responde de qué — no al revés.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-sí-es-tres-naturalezas-no-tres-grados&quot;&gt;Lo que sí es: tres naturalezas, no tres grados&lt;/h2&gt;
&lt;p&gt;Un cambio pertenece a una de tres categorías, y confundirlas es el origen de la mayoría de los incidentes que se cuentan después.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Reversible y barato.&lt;/strong&gt; Fusionar una rama, desplegar detrás de un indicador, añadir un índice, subir un escalón el número de réplicas. La vuelta atrás es un comando, cuesta minutos, y su coste se conoce &lt;em&gt;de antemano&lt;/em&gt;. Esta categoría no necesita ceremonia: la ceremonia cuesta aquí más que el error.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Reversible y caro.&lt;/strong&gt; Una migración de esquema con transformación de datos, un cambio de proveedor, un cambio de formato de un artefacto que otros consumen. Se puede volver, pero la vuelta es en sí misma un proyecto, con sus propios riesgos. Aquí la ceremonia se justifica: una ventana, una copia de seguridad verificada — verificada, no supuesta — y alguien mirando.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Irreversible.&lt;/strong&gt; Borrar datos, rotar una clave que cifra un histórico, publicar. Sí, publicar: no se despublica, se añade una corrección encima. Un paquete empujado a un registro público, un artículo en línea, una declaración presentada ante una autoridad — lo que salió, salió.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;La frontera está entre la segunda y la tercera&lt;/strong&gt;, y no tiene nada que ver con los oficios. Un &lt;code&gt;DELETE&lt;/code&gt; sin &lt;code&gt;WHERE&lt;/code&gt; escrito por un desarrollador y un purgado de bucket lanzado por un operador son el mismo acontecimiento.&lt;/p&gt;
&lt;h2 id=&quot;dónde-encaja-un-agente--por-la-misma-regla&quot;&gt;Dónde encaja un agente — por la misma regla&lt;/h2&gt;
&lt;p&gt;Aquí el razonamiento se vuelve útil, porque no exige una regla especial para la IA.&lt;/p&gt;
&lt;p&gt;Un agente de código es excelente en la primera categoría. Lee más archivos de los que un humano abrirá jamás, no se aburre, no se salta el paso tedioso, y mide allí donde nosotros habríamos leído una documentación. Prohibirle esa categoría por principio es rechazar una ganancia real por un temor mal colocado.&lt;/p&gt;
&lt;p&gt;En la segunda, prepara y no decide. La distinción es operativa, no simbólica: produce el script de migración, el plan de vuelta atrás y la lista de lo que se rompe — y un humano lee los tres antes de que nada se mueva.&lt;/p&gt;
&lt;p&gt;En la tercera, no decide nunca. Y la razón no es la competencia.&lt;/p&gt;
&lt;p&gt;La experiencia, en cambio, sí cuenta — pero en otro sitio, y la distinción merece sostenerse. Lo que le falta a un agente no es saber ejecutar una rotación de clave: es haber visto una salir mal. La experiencia no sirve para decidir una vez que se está en la tercera categoría; sirve para &lt;strong&gt;reconocer que se está en ella&lt;/strong&gt;, antes de actuar, cuando nada en el comando lo anuncia. Un agente no tiene cicatrices, tiene un corpus — y un corpus contiene los incidentes que otros han contado, no los que uno ha pagado.&lt;/p&gt;
&lt;p&gt;Por eso clasificar en tres categorías no es un trámite administrativo: es el lugar donde la experiencia humana entra realmente en la cadena. Pero ni siquiera un agente que clasificara perfectamente podría decidir — y esta vez la razón no debe nada a las capacidades.&lt;/p&gt;
&lt;h2 id=&quot;el-derecho-ya-lo-ha-zanjado-y-más-claramente-que-nuestros-debates&quot;&gt;El derecho ya lo ha zanjado, y más claramente que nuestros debates&lt;/h2&gt;
&lt;p&gt;Existe un texto que responde a la pregunta «¿puede una máquina sostener una decisión?», y no es teórico. La Directiva (UE) 2022/2555 — NIS 2 — dedica su artículo 20 a la gobernanza, en estos términos:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;em&gt;management bodies of essential and important entities approve the cybersecurity risk-management measures taken by those entities in order to comply with Article 21, oversee its implementation and can be held liable for infringements by the entities of that Article&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Y en el párrafo siguiente:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;em&gt;members of the management bodies of essential and important entities are required to follow training&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Tres verbos, y cada uno pesa. &lt;strong&gt;Aprobar&lt;/strong&gt;: hay un acto de aceptación, distinto de la producción de la medida. &lt;strong&gt;Supervisar&lt;/strong&gt;: la aceptación no se agota en el momento de la firma. &lt;strong&gt;Poder ser considerado responsable&lt;/strong&gt;: la consecuencia tiene un destinatario con nombre.&lt;/p&gt;
&lt;p&gt;Es el tercero el que zanja la cuestión de la IA, y la zanja sin que nadie necesite una opinión sobre lo que pueden los modelos. No se puede considerar responsable a un agente. No tiene nada que perder, ninguna obligación de formación que cumplir, y ninguna existencia jurídica sobre la que una sanción pueda morder. No es un juicio sobre su calidad: es una observación sobre la estructura.&lt;/p&gt;
&lt;p&gt;La obligación de formación dice lo mismo por el otro lado. El legislador no exige que la empresa disponga de una competencia — exige que &lt;strong&gt;quienes aprueban&lt;/strong&gt; entiendan lo que aprueban. A un agente no se le forma en la responsabilidad. Se forma a alguien para que sepa lo que asume.&lt;/p&gt;
&lt;h2 id=&quot;la-firma-es-el-caso-de-prueba&quot;&gt;La firma es el caso de prueba&lt;/h2&gt;
&lt;p&gt;Todo esto se vuelve concreto en el momento en que hay que firmar algo.&lt;/p&gt;
&lt;p&gt;Una firma criptográfica no dice «esto se ha producido correctamente». Dice: &lt;strong&gt;alguien responde de esto.&lt;/strong&gt; Es una atribución de responsabilidad, no un certificado de calidad — y por eso precisamente es la prueba correcta de la frontera.&lt;/p&gt;
&lt;p&gt;Tres consecuencias prácticas, todas derivadas de esa única frase.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;La clave privada nunca toca al agente.&lt;/strong&gt; No por desconfianza hacia un proveedor concreto: porque una clave que un agente puede usar es una clave que firma sin que nadie haya asumido nada. En nuestros informes de inventario la clave se construye sobre la marcha, firma, y se destruye — solo existe durante un gesto humano.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;El agente propone, el humano firma.&lt;/strong&gt; El agente prepara el cambio, ejecuta las comprobaciones, muestra lo que hace, y se detiene. La autorización es un acto separado, de alguien que puede responder de él. No es una formalidad: es el «aprobar» del artículo 20, implementado.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;El commit no lleva coautor máquina.&lt;/strong&gt; Este sorprende, y es el más importante. Un pie de página que atribuye un commit a una herramienta parece transparente y produce el efecto contrario: diluye. Si una decisión se discute dentro de dos años, «coescrito con un asistente» no señala a nadie a quien se pueda preguntar. &lt;strong&gt;Una firma que nombra una herramienta no nombra a nadie.&lt;/strong&gt; La transparencia sobre el uso de agentes va en la documentación y en las prácticas — no en el campo que sirve para saber con quién hablar.&lt;/p&gt;
&lt;h2 id=&quot;para-qué-está-realmente-el-punto-de-control-humano&quot;&gt;Para qué está realmente el punto de control humano&lt;/h2&gt;
&lt;p&gt;Hay un malentendido extendido: que se pone una validación humana porque se supone que el agente es incompetente. Es falso, y creerlo lleva a colocar la validación en el sitio equivocado.&lt;/p&gt;
&lt;p&gt;Un agente se equivoca menos de lo que se teme en aquello que sabe verificar. Se equivoca de otra manera. Tres modos de fallo merecen nombrarse, porque no se parecen a la incompetencia y no se ven en una revisión de código ordinaria.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;La prueba que fija el defecto.&lt;/strong&gt; Cuando la misma cadena produce el artefacto y la prueba que lo guarda, la prueba puede codificar el estado observado en lugar del estado querido. Un control que verifica que un documento muestra la versión que mostraba ayer pasa perfectamente, durante meses, garantizando exactamente el fallo. Es peor que no tener prueba: fabrica confianza.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;La velocidad, que convierte un error recuperable en un error propagado.&lt;/strong&gt; Un humano que se equivoca en un comando destructivo se da cuenta en el comando siguiente. Una cadena automatizada ya ha encadenado quince pasos. El error es el mismo; su radio no. Es la velocidad, y no la exactitud, lo que justifica el punto de parada.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;El estado que no existe para el agente.&lt;/strong&gt; Este lo hemos aprendido a nuestra costa, y merece contarse precisamente porque no parece un descuido.&lt;/p&gt;
&lt;p&gt;Un agente razona sobre lo que el repositorio registra. Lo que no está commiteado no existe en su modelo de lo que es recuperable — y el gesto más natural para deshacer un ensayo, &lt;code&gt;git checkout &amp;lt;archivo&amp;gt;&lt;/code&gt;, restaura la última versión commiteada &lt;strong&gt;sobrescribiendo todo lo que no lo estaba&lt;/strong&gt;. Dos veces en la misma sesión, comprobando que un control rechazaba bien lo que debía rechazar, rompimos un archivo a propósito, confirmamos que el control se daba cuenta, y luego deshicimos el ensayo de esa forma. La prueba pasó. El trabajo no commiteado se fue con ella — una vez un archivo de documentación, otra un README reescrito de arriba abajo.&lt;/p&gt;
&lt;p&gt;Un humano duda ante un comando destructivo porque recuerda haber trabajado dos horas sin commitear. El agente no tiene ese recuerdo: tiene un índice de git, y el índice no contiene lo que uno acaba de escribir. No es un fallo de atención, es una diferencia de modelo — y es estable, así que uno puede protegerse.&lt;/p&gt;
&lt;p&gt;Dos consecuencias prácticas, y la segunda es contraintuitiva. &lt;strong&gt;Antes de romper algo a propósito para poner a prueba un control, haga una copia fuera del repositorio&lt;/strong&gt; — un &lt;code&gt;cp&lt;/code&gt; a &lt;code&gt;/tmp&lt;/code&gt; basta, y &lt;code&gt;git checkout&lt;/code&gt; no es un botón de deshacer. Y &lt;strong&gt;commitee pronto&lt;/strong&gt;, no por disciplina de historial, sino para que lo que acaba de hacer &lt;strong&gt;exista&lt;/strong&gt; para la máquina que le ayuda.&lt;/p&gt;
&lt;p&gt;De ahí una regla sencilla: &lt;strong&gt;la validación humana se coloca donde la recuperación se vuelve difícil, no donde se duda de la competencia.&lt;/strong&gt; El resto del tiempo cuesta más de lo que aporta, y un equipo que valida todo acaba por no leer nada.&lt;/p&gt;
&lt;h2 id=&quot;qué-aporta-un-revisor-y-qué-exige&quot;&gt;Qué aporta un revisor, y qué exige&lt;/h2&gt;
&lt;p&gt;Si la contribución humana consiste en clasificar y después responder, ¿a qué se parece concretamente? No a una revisión de código ordinaria.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Los errores de un agente no parecen errores.&lt;/strong&gt; Los de un principiante sí: no compila, es visiblemente falso, se ve en diagonal. Un agente produce código que funciona, acompañado de un comentario seguro que explica por qué es correcto. Una línea que extrae una huella funciona perfectamente en un Mac y falla bajo Linux, porque el &lt;code&gt;tr&lt;/code&gt; de GNU lee tres caracteres como un rango. Una prueba que verifica que un documento sigue mostrando la versión de ayer pasa durante meses — garantizando el defecto. No son fallos de principiante: son fallos que &lt;strong&gt;sobreviven a una revisión&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;Lo cual los hace más difíciles de revisar, no menos. Y es lo contrario de la intuición que tenemos al contratar.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Lo que exige del revisor no es saber, es un hábito:&lt;/strong&gt; rechazar una explicación que no se sigue. «¿Qué quiere decir eso exactamente?» no cuesta ninguna experiencia y funciona muy bien sobre una máquina cuya producción es fluida por construcción. Una palabra de jerga interna que se había colado en tres traducciones de una documentación cayó así — no gracias a una lectura experta, gracias a alguien que se negó a entender.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Lo que un corpus no contiene.&lt;/strong&gt; Puedo preguntarle a un agente por qué murió PHP 6, y la respuesta será correcta: Unicode en todas partes, una reescritura hundida bajo su propia ambición, un número de versión que acabamos saltándonos. Pero yo lo &lt;em&gt;esperé&lt;/em&gt;. Durante años, construyendo encima planes que nunca sirvieron. No es el mismo conocimiento: uno es un relato, el otro es una factura pagada. Un corpus contiene los incidentes que otros han contado — no aquellos que uno recuerda porque los vivió.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Y la pregunta de verdad: un desarrollador que llega ahora y lo hace todo con IA, ¿qué da?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Lo que no adquirirá no es la sintaxis. Es la memoria de las consecuencias, y el mecanismo es preciso: la herramienta suprime exactamente la fricción que producía el aprendizaje. Tres horas con un mensaje de error es como se acaba sabiendo qué quiere decir ese mensaje de verdad. Resuelto en treinta segundos, el defecto está corregido y no se ha aprendido nada.&lt;/p&gt;
&lt;p&gt;Hay que ser honesto: cada generación ha dicho esto de la abstracción anterior. El recolector de basura iba a producir desarrolladores que ya no entendieran la memoria, los frameworks gente incapaz de escribir una consulta, Stack Overflow una generación de copistas. Aun así hay una diferencia esta vez, y es estructural: &lt;strong&gt;las abstracciones anteriores retiraban trabajo de implementación dejando el diagnóstico intacto.&lt;/strong&gt; Esta retira el diagnóstico. Y es el diagnóstico lo que fabrica el juicio, que es exactamente lo que se le pide a un revisor.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Pero la conclusión no es «hacen falta veinticinco años».&lt;/strong&gt; La cualidad necesaria para revisar una IA no es la antigüedad, es la negativa a dejarse impresionar. La antigüedad es la forma más común de adquirirla, no la única. Un junior que nunca acepta una explicación que no sigue hace un verdadero trabajo de revisión desde hoy; un senior que lee en diagonal porque «tiene buena pinta» no hace ninguno. Es un hábito antes que un nivel — y un hábito se enseña, que es la única buena noticia de esta sección.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Queda una asimetría que hay que decir, porque es incómoda.&lt;/strong&gt; Le hicimos la pregunta al agente con el que se escribió este texto, pidiéndole franqueza en lugar de amabilidad. Su respuesta, tal cual:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;«Tú puedes trabajar sin mí, más despacio. Yo no puedo trabajar sin alguien que sepa cuándo me equivoco. La dependencia no va en los dos sentidos con la misma fuerza, y un artículo que pretendiera lo contrario sería halagador y falso.»&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Es exactamente eso. Organizar una cadena como una asociación entre iguales es equivocarse sobre la naturaleza de lo que se ha comprado: un ejecutor muy rápido, que necesita que le digan dónde mirar.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-se-gana-cuando-el-reparto-es-justo&quot;&gt;Lo que se gana cuando el reparto es justo&lt;/h2&gt;
&lt;p&gt;Un agente bien empleado no solo escribe código más rápido: mide donde nosotros habríamos leído. Tres ejemplos de nuestra propia cadena, elegidos porque tienen la misma forma — una afirmación de documentación que no sobrevive a una medición.&lt;/p&gt;
&lt;p&gt;Un archivo anunciado como reproducible no lo era: &lt;code&gt;git archive&lt;/code&gt; sí da los mismos bytes bajo dos versiones de git, pero &lt;code&gt;gzip -n&lt;/code&gt; no uniformiza dos implementaciones de deflate — la de Apple y la de GNU comprimen el mismo tar de forma distinta. La promesa era cierta del flujo sin comprimir, falsa del archivo.&lt;/p&gt;
&lt;p&gt;Un comando de verificación publicado en todas partes falla en la mitad de las distribuciones, porque &lt;code&gt;/etc/ssl/certs/ca-certificates.crt&lt;/code&gt; es una convención de Debian que no existe ni en Fedora, ni en Rocky, ni en openSUSE — y un &lt;code&gt;-CAfile&lt;/code&gt; apuntando a un archivo ausente responde &lt;code&gt;Verification: FAILED&lt;/code&gt;, exactamente como una falsificación.&lt;/p&gt;
&lt;p&gt;Un testigo de sellado de tiempo lleva su propia cadena de certificados, y LibreSSL — el &lt;code&gt;openssl&lt;/code&gt; que viene con macOS — no la lee. El mismo mensaje de error, una causa radicalmente distinta.&lt;/p&gt;
&lt;p&gt;Ninguna de esas tres cosas se encuentra leyendo. Las tres se encuentran ejecutando el mismo comando sobre ocho objetivos, que es exactamente el tipo de tarea tediosa, repetitiva y sin gloria que un agente hace sin cansarse — y sobre la que un humano, honestamente, habría extrapolado a partir de dos casos.&lt;/p&gt;
&lt;h2 id=&quot;buenas-prácticas&quot;&gt;Buenas prácticas&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Clasifique los cambios por reversibilidad, no por oficio.&lt;/strong&gt; Tres categorías bastan, y es la frontera entre la segunda y la tercera la que merece un procedimiento.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Dé la primera categoría a los agentes, sin ceremonia.&lt;/strong&gt; Poner ahí una validación humana cuesta más que el error que evita, y gasta la atención que necesitará en otro sitio.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Haga de la aprobación un acto distinto de la producción.&lt;/strong&gt; El artículo 20 de NIS 2 lo convierte en obligación para las entidades afectadas; es buena práctica para todos los demás.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Mantenga la clave privada fuera del alcance del agente.&lt;/strong&gt; Una clave que un automatismo puede usar firma sin que nadie haya asumido nada.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;No atribuya un commit a una herramienta.&lt;/strong&gt; Ponga el uso de agentes en su documentación, no en el campo que sirve para saber a quién preguntar.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Coloque los puntos de parada sobre la recuperabilidad&lt;/strong&gt;, no sobre el nivel de confianza. El buen criterio es «cuánto cuesta la vuelta atrás», no «¿me fío de lo que ha producido esto?».&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;puntos-de-vigilancia&quot;&gt;Puntos de vigilancia&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Una prueba producida por la misma cadena que el artefacto puede fijar el defecto en lugar de detectarlo. Haga escribir la prueba y el código en pasadas separadas, y compruebe que una prueba nueva falla antes de creerla.&lt;/li&gt;
&lt;li&gt;«Aprobar» no es «hacer clic». Una validación dada sin leer es peor que la ausencia de validación: crea una traza que dice lo contrario de lo que pasó.&lt;/li&gt;
&lt;li&gt;La reversibilidad es una propiedad del sistema, no de la intención. Una vuelta atrás que nunca se ha ejecutado no es una vuelta atrás, es una hipótesis.&lt;/li&gt;
&lt;li&gt;Publicar es irreversible, también internamente. Un informe enviado, una declaración presentada, un paquete empujado: la corrección se añade, no sustituye.&lt;/li&gt;
&lt;li&gt;Y la frontera se mueve. Un cambio reversible hoy se vuelve irreversible el día en que otro depende de lo que produce. Es una revisión que rehacer, no una clasificación que grabar.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;cómo-se-escribió-este-texto&quot;&gt;Cómo se escribió este texto&lt;/h2&gt;
&lt;p&gt;Se redactó en diálogo con un agente de código, y el reparto fue el que este artículo describe. El agente produjo los borradores, leyó la directiva en su texto oficial en lugar de en un resumen, y verificó cada una de las mediciones citadas arriba. El resto — reconocer que una afirmación olía mal — no se delega, y tres pasajes de este texto vienen directamente de ahí.&lt;/p&gt;
&lt;p&gt;La sección sobre la experiencia no existía: nació de un desacuerdo sobre una sola frase. La jerga caída en tres traducciones cayó porque alguien se negó a entender una palabra. Y una explicación sobre la caché de un navegador, plausible y falsa — los recursos habrían tenido ventanas de frescura distintas — no sobrevivió a la verificación: todos llevaban exactamente la misma cabecera, al segundo.&lt;/p&gt;
&lt;p&gt;Este texto se escribió por tanto en colaboración con una inteligencia artificial, y no lleva cofirma máquina. Las dos cosas van juntas: lo útil para un lector es saber cómo se ha fabricado un texto — lo anterior lo dice — no leer el nombre de una herramienta junto al de alguien que puede responder de él.&lt;/p&gt;
</content>
    </entry>
        <entry>
        <title>Criptografía: le hicimos nuestra única pregunta a un directivo real. No entendió nada.</title>
        <link href="https://mesa.black/es/criptografia-nuestra-unica-pregunta/"/>
        <id>https://mesa.black/es/criptografia-nuestra-unica-pregunta/</id>
        <updated>2026-10-08T02:00:00+02:00</updated>
        <summary>Nuestra herramienta lee un proyecto, dice hasta cuándo aguantará cada protección, y pide a la empresa una sola cosa. Esto es lo que produce, y lo que pasó cuando le hicimos esa pregunta a alguien que no es informático: tres sesiones, tres fracasos, y 986 palabras que leer para responder a dos preguntas.</summary>        <content type="html">&lt;p&gt;Casi todo lo que protege hoy los datos de una empresa se apoya en cálculos fáciles en un sentido e impracticables en el otro. Un ordenador cuántico lo bastante potente hará posible el camino de vuelta, y los Estados han fijado fechas: los métodos actuales se desaconsejarán hacia 2030 y se prohibirán hacia 2035.&lt;/p&gt;
&lt;p&gt;No es un problema para 2035, y ese es el punto que casi todo el mundo pasa por alto. Un adversario no necesita esperar: le basta con &lt;strong&gt;copiar hoy&lt;/strong&gt; una copia de seguridad o un flujo, y guardarla hasta el día en que pueda abrirla. Es decir: un dato cifrado esta mañana que deba seguir siendo confidencial más allá de 2035 ya está perdido — cambiar de método más tarde protegerá lo que venga después, no a él.&lt;/p&gt;
&lt;p&gt;&lt;a href=&quot;https://github.com/mesa-black/sablier&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;Sablier&lt;/a&gt; es nuestra herramienta para poner esa frase en cifras sobre un proyecto real. Este texto cuenta lo que produce, y luego el fracaso de lo único que pide a un humano.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-hace-la-herramienta&quot;&gt;Lo que hace la herramienta&lt;/h2&gt;
&lt;p&gt;Lee un repositorio — sin ejecutar nada, sin enviar nada — y anota cada lugar donde el código cifra, firma o resume algo: llamadas a bibliotecas, claves y certificados presentes en el árbol, configuración de servidor, scripts de despliegue, dependencias declaradas, y la infraestructura cuando está escrita en Terraform. Después cruza ese inventario con el tiempo que cada categoría de datos debe seguir siendo confidencial, y devuelve un veredicto por lugar.&lt;/p&gt;
&lt;p&gt;Lanzada sobre un proyecto de ejemplo, esto es lo que da:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;  /proyecto — 3 archivos leídos, 7 hallazgos, 0.0 s
  declaración: /proyecto/sablier.json

    COMPROMETIDO             1
    ROTO HOY                 1
    VIGILAR                  2
    CONFORME                 2
    PROBABLEMENTE NO CRIPTO  1

  → /proyecto/r.html
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Cinco categorías, y dos que cuentan. Este es el hallazgo rojo, tal como lo escribe el informe:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;COMPROMETIDO&lt;/strong&gt; — &lt;code&gt;deploy/backup.sh:3&lt;/code&gt;
Cifrado hoy, a conservar confidencial hasta 2036 — es decir 1 año después de la caducidad de RSA. Una captura hecha ahora será legible.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Y el que no tiene nada que ver con lo cuántico, porque un inventario que solo habla de 2035 se pierde lo que está roto desde hace veinte años:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;ROTO HOY&lt;/strong&gt; — &lt;code&gt;src/Tokens.php:17&lt;/code&gt;
Roto clásicamente, al margen de lo cuántico. El plazo era ayer.
&lt;em&gt;referencias CVE-2005-4900&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Un inventario que no concluye nada se archiva en una carpeta, así que el informe decide y ordena. El primer punto del plan nunca es «migrar»:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Decidir qué pasa con los datos ya emitidos.&lt;/strong&gt; Es la decisión que nadie toma, y viene antes de la migración. Los dominios afectados están protegidos por un algoritmo que no aguantará hasta el final de su duración de confidencialidad: lo que ya se cifró y transmitió está fuera del alcance de un parche. Tres salidas, y hay que elegir una explícitamente — volver a cifrar el stock existente, rotar las claves y reemitir lo que pueda reemitirse, o dejar por escrito que se acepta el riesgo. Migrar sin resolver esto protege los datos futuros y deja los antiguos expuestos sin que nadie lo haya decidido.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;También sabe leer una fuga al revés. Con una fecha de compromiso, deja de razonar sobre lo que un adversario cosechará: cuenta lo que ya está en sus manos, y cuánto tiempo sigue haciendo daño.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Después de la fuga del 29/07/2026&lt;/strong&gt; — Lo que salió ya está en manos de alguien. La única protección que queda es el algoritmo, y tiene fecha de fin.
&lt;em&gt;backups&lt;/em&gt; — confidencialidad pedida: 10 años, es decir hasta 2036. El algoritmo que la protege caduca en 2035. 1 año de lo robado pasará a ser legible, y ninguna migración lo alcanza.
&lt;em&gt;session tokens&lt;/em&gt; — protegido por criptografía a la que lo cuántico no alcanza. Nada pasa a ser legible por ese lado.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;El informe existe en dos versiones: una técnica, leída junto a un editor, y un documento de auditoría numerado que separa los hechos de la opinión, para la pieza que se presenta ante un tercero. Ambos imprimen lo que no miraron, porque un inventario que oculta sus puntos ciegos fabrica falsa seguridad. Todo corre en la máquina de quien lanza el comando: ningún dato sale, el código es MIT, y &lt;a href=&quot;https://github.com/mesa-black/sablier/tree/main/examples&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;los informes de ejemplo&lt;/a&gt; están en el repositorio.&lt;/p&gt;
&lt;h2 id=&quot;lo-único-que-no-puede-adivinar&quot;&gt;Lo único que no puede adivinar&lt;/h2&gt;
&lt;p&gt;Uno de los veredictos anteriores dice «a conservar confidencial hasta 2036». Ese 2036 no viene del código. Viene de una duración que alguien declaró: diez años para esas copias de seguridad.&lt;/p&gt;
&lt;p&gt;Es el eje de toda la herramienta, y ningún software puede adivinarlo. Una sesión de conexión dura horas, una factura diez años, un contrato treinta — y nada de eso es un hecho técnico. Así que la herramienta lo pregunta, en una sola pregunta, a alguien que conoce el negocio: &lt;em&gt;¿cuánto tiempo debe esto seguir siendo secreto?&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;Un texto escrito para este blog a principios de octubre terminaba con una frase incómoda: todas las herramientas de este campo, la nuestra incluida, suponen que la duración de confidencialidad de los datos es un hecho &lt;em&gt;obtenible&lt;/em&gt;, y nadie parece haber comprobado que una empresa real sepa enunciarla. Cerraba admitiendo que esa conclusión tampoco había sido validada con nadie.&lt;/p&gt;
&lt;p&gt;Ese texto nunca salió — estaba programado para el 2 de octubre y lo retiramos el día anterior, junto con otro, por razones que no caben aquí. Su última línea, en cambio, se mantuvo.&lt;/p&gt;
&lt;p&gt;Lo fue esta semana. Tres veces, con el directivo de una empresa que usa nuestras herramientas a diario. El resultado cabe en una frase, la suya:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;«Lo siento pero esto es jerga para mí, no sé qué quiere decir, no entiendo las frases. En resumen, estoy perdido.»&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;No es un problema de pedagogía, y no es un problema suyo. Es una medida sobre el instrumento, y se podía contar.&lt;/p&gt;
&lt;h2 id=&quot;la-medida&quot;&gt;La medida&lt;/h2&gt;
&lt;p&gt;Para plantear esa pregunta a distancia, la herramienta produce un archivo HTML autónomo: sin servidor, sin red, se abre, se responde, se devuelve un bloque de JSON. Pensado para las salas donde una entrevista en directo no puede entrar — una red cerrada, una máquina a la que nadie puede conectarse.&lt;/p&gt;
&lt;p&gt;En el tercer intento conté lo que ese archivo daba a leer antes de poder responder. &lt;strong&gt;986 palabras.&lt;/strong&gt; Para siete temas y dos preguntas por tema. Con la palabra &lt;em&gt;huella&lt;/em&gt; cinco veces, y &lt;em&gt;algoritmo&lt;/em&gt;, &lt;em&gt;plazo&lt;/em&gt;, &lt;em&gt;régimen&lt;/em&gt;, &lt;em&gt;declaración&lt;/em&gt;, &lt;em&gt;fontanería&lt;/em&gt; en el camino.&lt;/p&gt;
&lt;p&gt;El detalle que importa: &lt;strong&gt;la mayor parte de esas 986 palabras se había escrito el mismo día&lt;/strong&gt;, corrigiendo los dos fracasos anteriores. En cada pasada había añadido un párrafo por honestidad — lo que la herramienta no puede saber, por qué se hace esta pregunta, de dónde viene esta fecha, qué implica la respuesta. Cada uno defendible por separado. Todos juntos, un documento que nadie fuera del campo atraviesa.&lt;/p&gt;
&lt;p&gt;La prosa llega un párrafo justificado a la vez. Por eso no se ve.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-decían-de-verdad-las-respuestas&quot;&gt;Lo que decían de verdad las respuestas&lt;/h2&gt;
&lt;p&gt;La segunda sesión había producido un archivo de respuestas. Parecía completo: siete temas, siete respuestas, ninguna casilla vacía. Llegó con un comentario — «no he entendido nada» — y es leyéndolo línea por línea como aparece el problema real.&lt;/p&gt;
&lt;p&gt;Siete temas, &lt;strong&gt;la misma duración siete veces&lt;/strong&gt;: cinco años. Ninguna conservación legal declarada. Ninguna justificación escrita. Ningún nombre que dijera quién se comprometía. 182 segundos en total, con el tiempo por tema hundiéndose: 20,8 s, 36,1, 16,8, 15,9, 23,8, &lt;strong&gt;8,9&lt;/strong&gt;, 10,6.&lt;/p&gt;
&lt;p&gt;Los siete botones ofrecidos iban de 0 a 30 años. Cinco era el del medio.&lt;/p&gt;
&lt;p&gt;Y ese cinco uniforme es demostrablemente falso en al menos dos puntos. El dominio que llamó «REX» es &lt;strong&gt;contenido publicado&lt;/strong&gt;: su duración de confidencialidad es cero por construcción. El que llamó «Facturation» lleva diez años de archivo contable obligatorio — respondido cinco, con «conservación legal: 0» justo al lado.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Una parte sí funcionó.&lt;/strong&gt; Renombró los siete temas con sus palabras: Login, Facturation, Information, REX, Profile, Sécurité, Paramètres. Es exactamente la tarea que se le pedía, y la hizo. El vocabulario de los &lt;em&gt;datos&lt;/em&gt; no era el bloqueo. El de las &lt;em&gt;duraciones&lt;/em&gt; sí.&lt;/p&gt;
&lt;p&gt;Y las dos últimas preguntas del formulario — «una pregunta que esperaba y no se le hizo», «una palabra que no entendió» — volvieron vacías. 7,8 segundos en esa pantalla. Quien no entiende no rellena el campo donde decirlo.&lt;/p&gt;
&lt;h2 id=&quot;por-qué-es-peor-que-ninguna-respuesta&quot;&gt;Por qué es peor que ninguna respuesta&lt;/h2&gt;
&lt;p&gt;Ese archivo no estaba vacío. Era &lt;strong&gt;plausible&lt;/strong&gt;. Y la herramienta, al importarlo, mostraba «7 respuestas recuperadas», escribía una declaración, y no decía nada más.&lt;/p&gt;
&lt;p&gt;Una declaración, en esta herramienta, es lo que compromete a una persona con una cifra: el informe de auditoría imprime junto a cada duración quién la declaró y cuándo. Convertir siete pulsaciones del botón del medio en una declaración fechada fabrica exactamente la falsa seguridad que el proyecto pasa el tiempo denunciando en otros sitios. Mejor ninguna declaración que una blanqueada.&lt;/p&gt;
&lt;p&gt;Así que el modo de fallo peligroso de una herramienta así no es «la persona no sabe responder». Es «la persona produce algo que parece una respuesta».&lt;/p&gt;
&lt;h2 id=&quot;las-seis-correcciones&quot;&gt;Las seis correcciones&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;Los temas se nombran por su lugar, ya no por la criptografía que contienen.&lt;/strong&gt; Los temas se agrupaban por familia de algoritmos, lo que hace que un tema solo pudiera &lt;em&gt;nombrarse&lt;/em&gt; por una familia: preguntábamos cuánto tiempo «cifrado de clave pública» y «huellas de contenido» debían seguir siendo confidenciales. Son mecanismos, no datos. Peor, el único tema que él habría sabido tratar — cinco directorios de negocio — había quedado aplastado dentro de uno de ellos.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Las duraciones pasaron a ser consecuencias.&lt;/strong&gt; Ya no hay botones 0/1/3/5/10/20/30, sino cuatro frases: &lt;em&gt;es público, o sin consecuencia&lt;/em&gt; / &lt;em&gt;nos incomodaría, hasta que pasara&lt;/em&gt; / &lt;em&gt;un cliente podría reprochárnoslo, o irse&lt;/em&gt; / &lt;em&gt;nos lo reprocharían durante años, o acabaría en los tribunales&lt;/em&gt;. La aritmética es tarea de la herramienta.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Y esas frases se anclan en la historia del proyecto.&lt;/strong&gt; Allí donde el repositorio sabe cuándo empezó — la fecha de autor más antigua de su registro git — las opciones nombran años vividos: &lt;em&gt;lo que escribíamos en 2023 seguiría siendo incómodo&lt;/em&gt;, &lt;em&gt;incluso lo que escribíamos en 2019, al principio&lt;/em&gt;. La opción más larga vale entonces la edad del proyecto, no una cifra redonda. Nadie estima bien siete años hacia delante; todo el mundo sabe decir si las facturas del primer año siguen contando.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;986 palabras pasaron a 235, y un test falla por encima de 260.&lt;/strong&gt; Un presupuesto, no una relectura: nada más detecta una prosa que llega de párrafo en párrafo. Un segundo test falla si una palabra del oficio vuelve al camino del lector. Todo lo retirado sigue escrito — en el informe de auditoría, leído por quien debe pesar las cifras, no por quien aporta una. Yo confundía a los dos lectores.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Una pregunta entera desapareció: el régimen regulatorio.&lt;/strong&gt; Nadie fuera del campo elige entre NIST IR 8547, CNSA 2.0 y una posición de la ANSSI. La pregunta imprimía cinco líneas de siglas — y luego plazos de 2030 y 2035 justo debajo del año que la persona acababa de dar como fin de vida de la aplicación. Es la elección del auditor, en un archivo versionado, y la herramienta se lo recuerda cuando se queda en el valor por omisión.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;La herramienta señala ahora una respuesta uniforme.&lt;/strong&gt; Duraciones todas idénticas, ninguna justificación, nadie nombrado: lo dice, nombra las cifras, y recuerda que un contenido publicado y diez años de contabilidad no comparten duración. Señala, no se niega — juzgar si esas respuestas valen algo pertenece a quien dirigió la sesión.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-nos-negamos-a-hacer&quot;&gt;Lo que nos negamos a hacer&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;Rellenar la respuesta por anticipado.&lt;/strong&gt; Era la corrección más tentadora: proponer una duración por categoría y pedir una confirmación. Un sí/no sobre una propuesta concreta es cognitivamente mucho más fácil que producir una duración.&lt;/p&gt;
&lt;p&gt;Es también la forma más segura de obtener una declaración que nadie leyó. Un lector cansado acepta lo que hay en la casilla, y la casilla acaba firmada. El campo que nombra el dato ya no viene rellenado en absoluto, por la misma razón: llegaba con una familia de algoritmos, y rellenarlo con el nombre del directorio — «Entity» — no habría sido mejor.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-ha-dado&quot;&gt;Lo que ha dado&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Una hipótesis compartida por todo el campo, puesta a prueba&lt;/strong&gt;: una empresa no sabe enunciar espontáneamente la duración de confidencialidad de sus datos. No «todavía no»: no como se la preguntábamos.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Un modo de fallo con nombre&lt;/strong&gt;: la respuesta plausible. Un formulario que no obliga a pensar produce cifras, no información.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Tres fracasos con la misma persona&lt;/strong&gt;, que es una medida del instrumento y no de ella.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;751 palabras retiradas&lt;/strong&gt; de un documento que había escrito creyendo ser honesto.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;buenas-prácticas&quot;&gt;Buenas prácticas&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Medir el documento antes de reescribirlo. «Demasiado técnico» es una impresión; 986 palabras y &lt;em&gt;huella&lt;/em&gt; cinco veces es un defecto que se corrige.&lt;/li&gt;
&lt;li&gt;Poner un presupuesto donde la deriva es lenta. Un test que cuenta palabras detecta lo que ninguna relectura detecta, porque cada párrafo añadido es defendible en el momento en que se añade.&lt;/li&gt;
&lt;li&gt;Separar a los lectores. Las reservas de una herramienta honesta van al informe, leído por quien pesa las cifras — no al formulario, rellenado por quien aporta una.&lt;/li&gt;
&lt;li&gt;Pedir una consecuencia cuando se quiere una duración. La gente sabe lo que le costaría; no sabe convertirlo en años.&lt;/li&gt;
&lt;li&gt;Mirar los tiempos por pregunta. La curva descendente dice que se perdió a la persona, y lo dice antes que ella.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;puntos-de-vigilancia&quot;&gt;Puntos de vigilancia&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Una muestra de uno.&lt;/strong&gt; Un directivo, una empresa, un campo. Las seis correcciones se justifican por una observación, no por un estudio.&lt;/li&gt;
&lt;li&gt;Los títulos de los temas siguen siendo palabras de código — «Billing», «Entity». Traducirlas a vocabulario de negocio exigiría inventar lo que la herramienta no sabe; muestra el lugar y pide el nombre.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;El archivo autónomo no se hizo para esto.&lt;/strong&gt; Existe para las redes cerradas, no para alguien solo frente a su correo. Tres fracasos seguidos dicen sobre todo que usamos el instrumento pensado para una sala aislada allí donde una conversación de veinte minutos, al lado, habría reformulado en voz alta lo que ninguna frase escrita alcanza.&lt;/li&gt;
&lt;li&gt;Nada garantiza que el cuarto intento pase. Lo que está garantizado es que sabremos medirlo.&lt;/li&gt;
&lt;/ul&gt;
</content>
    </entry>
        <entry>
        <title>Una firma prueba quién y qué. Nunca cuándo.</title>
        <link href="https://mesa.black/es/cuando/"/>
        <id>https://mesa.black/es/cuando/</id>
        <updated>2026-10-08T02:00:00+02:00</updated>
        <summary>El campo «firmado el» de un documento firmado sale de su propio reloj. La firma lo cubre, así que no se puede modificar después — y sí elegir antes. Antedatar no cuesta nada, y una cadena de firmas tampoco lo arregla. La respuesta son cuatro gestos, se comprueba con el openssl de serie, y se reparte entre varias jurisdicciones por treinta y dos bytes.</summary>        <content type="html">&lt;p&gt;Un informe firmado responde a dos preguntas: &lt;strong&gt;qué clave firmó&lt;/strong&gt; y &lt;strong&gt;qué hallazgos firmó&lt;/strong&gt;. Se suele tomar como respuesta a una tercera, que no está ahí.&lt;/p&gt;
&lt;p&gt;El campo &lt;code&gt;signed_at&lt;/code&gt; sí existe, y la firma lo cubre — no se puede modificar después sin romper el sello. Pero se lee del reloj de la máquina que firma. El suyo. &lt;strong&gt;Antedatar un documento firmado no cuesta absolutamente nada&lt;/strong&gt;: basta con firmar con el reloj que se quiera.&lt;/p&gt;
&lt;p&gt;Y el encadenamiento no lo remedia. Un informe que nombra la huella del que reemplaza es un buen rastro de auditoría — mientras las claves las tenga otra persona. Si las tiene usted, puede reconstruir la cadena entera en orden, y se verificará perfectamente.&lt;/p&gt;
&lt;p&gt;Entonces: ¿qué aspecto tiene una fecha que no se puede discutir?&lt;/p&gt;
&lt;h2 id=&quot;la-respuesta-en-cuatro-gestos&quot;&gt;La respuesta, en cuatro gestos&lt;/h2&gt;
&lt;p&gt;Cabe en una frase: &lt;strong&gt;se saca la fecha de casa.&lt;/strong&gt; En detalle, cuatro gestos, y ninguno exige confiar en nosotros.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Hacer atestiguar una huella por un tercero&lt;/strong&gt;, no el documento. Salen treinta y dos bytes, nada más. Ese tercero no tiene interés alguno en sus conclusiones, y eso es lo que da valor a su firma.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Elegir un tercero cuya raíz ya sea pública&lt;/strong&gt;, para que su lector verifique con el &lt;code&gt;openssl&lt;/code&gt; de serie y nada que venga de usted.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Comparar la huella antes de hablar de confianza.&lt;/strong&gt; Es una comparación de hashes; no necesita certificado, ni raíz, ni permiso.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Conservar la atestación más antigua&lt;/strong&gt;, y volver a atestiguar mientras aguante el esquema que la firma.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Lo que se obtiene es preciso, y conviene enunciarlo con precisión: &lt;em&gt;esta huella existía &lt;strong&gt;a más tardar&lt;/strong&gt; en esta fecha, según alguien que no es usted.&lt;/em&gt; Es un &lt;strong&gt;límite superior&lt;/strong&gt; — y es exactamente la forma de la afirmación «habíamos inventariado antes del 31 de diciembre de 2026».&lt;/p&gt;
&lt;p&gt;El resto de este artículo explica por qué cada uno de los cuatro gestos es necesario, lo que cuesta, y dónde se detiene.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-hace-exactamente-una-autoridad-de-sellado-de-tiempo&quot;&gt;Lo que hace exactamente una autoridad de sellado de tiempo&lt;/h2&gt;
&lt;p&gt;RFC 3161. Usted le envía &lt;strong&gt;una huella&lt;/strong&gt;, nunca el documento. Treinta y dos bytes. Le devuelve un testigo firmado que dice que esa huella le fue presentada en ese instante.&lt;/p&gt;
&lt;p&gt;Ese es todo el mecanismo, y toda su elegancia: &lt;strong&gt;una autoridad puede atestiguar una fecha sin que se le diga qué está fechando.&lt;/strong&gt; Nada de su código, de sus nombres de archivo o de sus hallazgos sale de la máquina — una huella no se puede invertir.&lt;/p&gt;
&lt;p&gt;La autoridad, además, no tiene ningún interés en sus conclusiones, y eso es precisamente lo que da valor a su firma.&lt;/p&gt;
&lt;h2 id=&quot;qué-hacemos-atestiguar-y-por-qué-esa-elección&quot;&gt;Qué hacemos atestiguar, y por qué esa elección&lt;/h2&gt;
&lt;p&gt;Tres candidatos: el archivo, la firma, o la huella de los hallazgos. Atestiguamos &lt;strong&gt;la huella&lt;/strong&gt;, por una razón que cabe en un comando.&lt;/p&gt;
&lt;p&gt;Está impresa en el informe. Así que cualquiera comprueba la fecha sin tocar nunca nuestra herramienta:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;openssl ts -verify -digest 8ecb829ccc278ef7ab3138f56e07ee13319cbb72ce1dabbfc58ee7b4d6b670b5 \
  -in report.html.tsr -CAfile &amp;lt;almacén de certificados&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Forma simplificada, para mostrar la mecánica. Ese &lt;code&gt;-CAfile&lt;/code&gt; es la trampa más costosa de todo este artículo, y la sección «¿y en qué máquina?» más abajo da la versión que funciona en todas partes.&lt;/p&gt;
&lt;p&gt;Ningún archivo que canonicalizar, ningún orden de campos que acordar, ningún formato nuestro. &lt;code&gt;openssl ts -verify -digest&lt;/code&gt; acepta una huella hexadecimal directamente.&lt;/p&gt;
&lt;p&gt;Y sobrevive a una clave efímera. Cuando un informe lo firma un par creado solo para él y luego destruido, la clave ya no existe — la fecha atestiguada sí.&lt;/p&gt;
&lt;p&gt;También por eso el testigo es &lt;strong&gt;un archivo aparte&lt;/strong&gt;, en DER crudo junto a la firma: es exactamente lo que lee el comando &lt;code&gt;openssl ts&lt;/code&gt; de serie. Un artefacto que solo se abre con nuestra herramienta no es una prueba, es una promesa.&lt;/p&gt;
&lt;h2 id=&quot;la-trampa-openssl-ts--verify-no-responde-a-la-pregunta-que-se-cree&quot;&gt;La trampa: &lt;code&gt;openssl ts -verify&lt;/code&gt; no responde a la pregunta que se cree&lt;/h2&gt;
&lt;p&gt;Esta es la parte que exigió medir en lugar de leer.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;openssl ts -verify&lt;/code&gt; se detiene ante una cadena de certificados que no sabe construir — &lt;strong&gt;antes&lt;/strong&gt; de haber comparado la huella. Consecuencia: dos situaciones radicalmente distintas vuelven con el mismo mensaje de error.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;em&gt;«No consigo subir hasta una raíz de confianza»&lt;/em&gt; — la autoridad es autofirmada, o falta un intermedio. No es una falsificación.&lt;/li&gt;
&lt;li&gt;&lt;em&gt;«Este testigo atestigua otro documento»&lt;/em&gt; — eso sí es grave.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Con una autoridad autofirmada, las dos muestran &lt;code&gt;Verification: FAILED&lt;/code&gt;. Lo comprobamos pasando a propósito una huella equivocada: la misma respuesta que para la correcta.&lt;/p&gt;
&lt;p&gt;La corrección consiste en &lt;strong&gt;comparar la huella uno mismo, primero&lt;/strong&gt;, leyéndola en el testigo. Es una comparación de hashes: no necesita certificado, ni raíz, ni confianza. Solo después llega la cuestión de la cadena.&lt;/p&gt;
&lt;p&gt;Lo que da cuatro estados, no dos:&lt;/p&gt;
&lt;div class=&quot;scroll&quot;&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;estado&lt;/th&gt;
&lt;th&gt;qué significa&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;verificada&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;la firma de la autoridad aguanta, hasta una raíz de confianza de esta máquina&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;cadena no verificada&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;la huella sí corresponde a este documento; no se pudo construir ninguna cadena. Autoridad autofirmada o intermedio ausente — no es una falsificación&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;inválida&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;el testigo atestigua otra huella, o fue modificado&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;no comprobable aquí&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;no hay openssl, o no hay almacén de certificados&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;p&gt;Confundirlos convierte un certificado raíz ausente en una acusación de falsedad. O, mucho peor, lo contrario.&lt;/p&gt;
&lt;h2 id=&quot;qué-autoridad-es-una-decisión-no-un-valor-por-defecto&quot;&gt;¿Qué autoridad? Es una decisión, no un valor por defecto&lt;/h2&gt;
&lt;p&gt;No pusimos ninguna autoridad por defecto en la herramienta. Quién atestigua sus fechas es una decisión del mismo orden que el régimen normativo que adopta — un valor por defecto la tomaría por usted, en una jurisdicción que no eligió.&lt;/p&gt;
&lt;p&gt;Esto es lo que da la medición, sobre autoridades gratuitas:&lt;/p&gt;
&lt;div class=&quot;scroll&quot;&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;autoridad&lt;/th&gt;
&lt;th&gt;resultado&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Certum / Asseco&lt;/strong&gt; (Polonia, UE)&lt;/td&gt;
&lt;td&gt;verificada con el almacén del sistema, RSA-4096&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;GlobalSign&lt;/strong&gt; (Bélgica, UE)&lt;/td&gt;
&lt;td&gt;verificada con el almacén del sistema, RSA-3072&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;DigiCert&lt;/strong&gt; (Estados Unidos)&lt;/td&gt;
&lt;td&gt;verificada con el almacén del sistema, RSA-4096&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Sectigo (Reino Unido)&lt;/td&gt;
&lt;td&gt;un testigo cuyo firmante openssl no logra resolver&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;FreeTSA (Alemania)&lt;/td&gt;
&lt;td&gt;autofirmada: hay que entregar su raíz para que alguien compruebe&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;TSA federal belga&lt;/td&gt;
&lt;td&gt;autofirmada también&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;timestamp.apple.com&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;responde, pero con cadena autofirmada y política declarada &lt;code&gt;1.2.3&lt;/code&gt; — no es un servicio público&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;p&gt;El criterio que decide no es la notoriedad, es &lt;strong&gt;la raíz pública&lt;/strong&gt;: un lector comprueba con el openssl de serie y nada que venga de usted. En cuanto hay que adjuntar un certificado raíz a su documento, su prueba viaja con una pieza que usted mismo suministra — lo que le quita buena parte del sentido.&lt;/p&gt;
&lt;h2 id=&quot;solo-ha-movido-la-confianza-de-sitio&quot;&gt;«Solo ha movido la confianza de sitio»&lt;/h2&gt;
&lt;p&gt;Esta es la objeción seria, y hay que tomarla en su versión fuerte: &lt;em&gt;ha sustituido «crea en mi reloj» por «crea en el reloj de Certum». El problema no está resuelto, ha cambiado de dirección.&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;En parte es justa. Estas son las tres razones por las que el desplazamiento no es neutro, y lo que queda cuando se admiten.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;1. Cambia la forma de la afirmación.&lt;/strong&gt; Su &lt;code&gt;signed_at&lt;/code&gt; es una fecha que usted elige. El testigo es un límite que pone otra persona. Para antedatar ya no basta con ajustar un reloj: hace falta que una autoridad emita un testigo falso, o que usted fabrique uno — es decir, que rompa RSA-4096. Se ha pasado de un gesto gratuito a un ataque.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;2. Los intereses no son los mismos.&lt;/strong&gt; La autoridad no sabe qué está fechando: solo ve una huella. No tiene por tanto ninguna manera de favorecer una conclusión sobre otra, y toda su actividad se basa en que su firma signifique algo. Antedatar para usted es arriesgar todo su oficio en su archivo. Para una autoridad cualificada eIDAS esas obligaciones están auditadas, y es precisamente por eso que su raíz está en los almacenes de certificados.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;3. Y sobre todo: esa confianza se divide.&lt;/strong&gt; Una autoridad sigue siendo un único punto de confianza. Pero nada, en RFC 3161, impide presentar la &lt;strong&gt;misma huella a varias autoridades&lt;/strong&gt; — solo ven esos treinta y dos bytes, no tienen nada que coordinar, y ninguna necesita saber que no está sola. Lo hicimos con la huella del inventario de este sitio, presentando la misma huella a tres de ellas:&lt;/p&gt;
&lt;div class=&quot;scroll&quot;&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;autoridad&lt;/th&gt;
&lt;th&gt;jurisdicción&lt;/th&gt;
&lt;th&gt;fecha atestiguada&lt;/th&gt;
&lt;th&gt;testigo publicado&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Certum / Asseco&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Polonia (UE)&lt;/td&gt;
&lt;td&gt;6 oct. 2026 21:58 UTC&lt;/td&gt;
&lt;td&gt;&lt;code&gt;report.html.tsr&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;GlobalSign&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Bélgica (UE)&lt;/td&gt;
&lt;td&gt;8 oct. 2026 02:19 UTC&lt;/td&gt;
&lt;td&gt;&lt;code&gt;report.html.2.tsr&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;DigiCert&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Estados Unidos&lt;/td&gt;
&lt;td&gt;8 oct. 2026 02:19 UTC&lt;/td&gt;
&lt;td&gt;&lt;code&gt;report.html.3.tsr&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;p&gt;Esos tres archivos están en línea junto al informe, y los tres se verifican con la receta de más abajo. El coste marginal de una autoridad es una petición HTTP: una autoridad solo ve treinta y dos bytes, no tiene nada que coordinar, y no necesita saber que no está sola.&lt;/p&gt;
&lt;p&gt;Las fechas difieren, y es el mecanismo mostrándose: Certum tiene la atestación más antigua de estos hallazgos y la conserva — las otras dos se añadieron el día en que escribimos este artículo. &lt;strong&gt;Lo que se gana es preciso, y merece serlo&lt;/strong&gt;: cada autoridad pone un límite &lt;em&gt;independiente&lt;/em&gt;. Así que la fecha defendible &lt;strong&gt;sin conceder confianza a un solo operador&lt;/strong&gt; es la más tardía de las tres, el 8 de octubre; la defendible &lt;strong&gt;confiando en Certum&lt;/strong&gt; es el 6. Falsificar la más antigua ya no desliga este documento de una fecha: las otras dos lo limitan por sí solas.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Lo que queda, y hay que decirlo.&lt;/strong&gt; Un testigo da un límite superior, nunca uno inferior: atestigua que esos hallazgos existían &lt;em&gt;a más tardar&lt;/em&gt; en esa fecha, y nunca dirá que no existían antes. Si su necesidad va en el otro sentido — probar una anterioridad que se le discute — no es la herramienta.&lt;/p&gt;
&lt;p&gt;Y nadie atestigua retroactivamente. Una autoridad no firmará hoy una fecha de la semana pasada, y en eso está todo el interés. El corolario es incómodo: &lt;strong&gt;la fecha hay que pedirla en el momento en que se produce el documento.&lt;/strong&gt; Un sellado de tiempo que hay que acordarse de ir a buscar es un sellado que nadie hace — que es la única razón por la que este mecanismo pertenece a la herramienta que produce el informe, y no a un procedimiento.&lt;/p&gt;
&lt;h2 id=&quot;hacerlo-en-su-casa-hoy-sin-nosotros&quot;&gt;Hacerlo en su casa, hoy, sin nosotros&lt;/h2&gt;
&lt;p&gt;Nada de esto necesita nuestra herramienta. Cuatro comandos, &lt;code&gt;openssl&lt;/code&gt; y &lt;code&gt;curl&lt;/code&gt;, sobre cualquier artefacto que quiera poder fechar — un SBOM, un informe de auditoría, un paquete de versión, un acta.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 1. la huella de lo que quiere fechar
openssl dgst -sha256 -r artefacto.json | cut -d&#039; &#039; -f1
7643cc3ff2957a137b15c509382463efe5fe29c26a14224009462266adf77672

# 2. la petición — «-cert» pide a la autoridad que incluya su certificado,
#    sin lo cual nadie podrá verificar sin pedírselo a usted
openssl ts -query -digest 7643cc3f… -sha256 -cert -out sellado.tsq

# 3. enviarla. Salen 69 bytes, vuelve un testigo de 6 kB
curl -s -H &#039;Content-Type: application/timestamp-query&#039; \
  --data-binary @sellado.tsq http://time.certum.pl &amp;gt; sellado.tsr

# 4. la verificación — es el comando que lanzará su lector. Las primeras
#    líneas encuentran su almacén de certificados y la cadena que el testigo
#    ya lleva; la sección «¿y en qué máquina?» explica por qué
O=$(openssl version -d | sed &#039;s/.*&amp;quot;\(.*\)&amp;quot;/\1/&#039;)
for f in &amp;quot;$O/cert.pem&amp;quot; &amp;quot;$O/certs/ca-certificates.crt&amp;quot; /etc/ssl/ca-bundle.pem; do
  [ -f &amp;quot;$f&amp;quot; ] &amp;amp;&amp;amp; CA=&amp;quot;$f&amp;quot; &amp;amp;&amp;amp; break
done
openssl ts -reply -in sellado.tsr -token_out -out token.der
openssl pkcs7 -inform DER -in token.der -print_certs -out chain.pem

openssl ts -verify -digest 7643cc3f… -in sellado.tsr \
  -CAfile &amp;quot;$CA&amp;quot; -untrusted chain.pem
Verification: OK
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Guarde el &lt;code&gt;.tsr&lt;/code&gt; junto al artefacto e imprima la huella en el documento. Eso es todo: su lector no necesita ni a usted, ni un formato propio, ni una biblioteca.&lt;/p&gt;
&lt;p&gt;Para leer lo que dice un testigo — la fecha, y la huella que atestigua:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;openssl ts -reply -in sellado.tsr -text | grep &#039;^Time stamp&#039;
Time stamp: Oct  7 20:50:11 2026 GMT

openssl ts -reply -in sellado.tsr -text \
  | awk &#039;/^Message data:/{f=1;next} /^[A-Za-z]/{f=0} f&#039; \
  | sed -E &#039;s/^ *[0-9a-f]{4} - //; s/   .*$//&#039; | tr -dc &#039;0-9a-f&#039;
7643cc3ff2957a137b15c509382463efe5fe29c26a14224009462266adf77672
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Esa última línea es la respuesta práctica a la trampa descrita arriba: compara la huella &lt;strong&gt;sin pedir nada a nadie&lt;/strong&gt;, y funciona incluso cuando la cadena de certificados no se construye.&lt;/p&gt;
&lt;p&gt;Una nota sobre el &lt;code&gt;tr -dc &#039;0-9a-f&#039;&lt;/code&gt;, porque ilustra el resto del artículo mejor que cualquier párrafo: primero habíamos escrito &lt;code&gt;tr -d &#039; -\n&#039;&lt;/code&gt;, que funciona perfectamente en un Mac. El &lt;code&gt;tr&lt;/code&gt; de GNU lee esos tres caracteres como un &lt;strong&gt;rango&lt;/strong&gt;, del espacio al salto de línea, lo encuentra invertido, y se niega. Lo descubrimos reproduciendo este artículo en un contenedor Debian vacío antes de publicarlo. Todos los comandos de esta página pasaron por ahí.&lt;/p&gt;
&lt;p&gt;Con una autoridad de raíz pública, &lt;code&gt;openssl ts -verify&lt;/code&gt; hace la distinción por sí solo — modificamos el documento y relanzamos el comando:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;message imprint mismatch
Verification: FAILED
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Un mensaje claro y específico, que no se obtiene con una autoridad autofirmada. Es el argumento más concreto para elegir una cuya raíz ya esté en los almacenes de certificados.&lt;/p&gt;
&lt;p&gt;En &lt;a href=&quot;https://github.com/mesa-black/sablier&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;Sablier&lt;/a&gt;, todo esto cabe en una opción — &lt;code&gt;--timestamp=&amp;lt;url&amp;gt;&lt;/code&gt; — porque una buena práctica que hay que acordarse de hacer a mano es una buena práctica que nadie hace. La opción se repite, o acepta una lista separada por comas, y cada autoridad recibe la misma huella:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sablier scan . --sign=sablier.key \
  --timestamp=http://time.certum.pl,http://timestamp.digicert.com
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Cada testigo va a su propia ranura — &lt;code&gt;report.html.tsr&lt;/code&gt;, &lt;code&gt;report.html.2.tsr&lt;/code&gt;, en el orden en que se nombraron las autoridades — y la ranura pertenece a la autoridad de una ejecución a la siguiente: la que hoy estaba inalcanzable deja su ranura vacía en lugar de desplazar a las demás y hacerles perder su anterioridad. &lt;code&gt;sablier verify&lt;/code&gt; recorre las ranuras en vez de leer la primera, porque un lector al que se le han entregado tres atestaciones y un comando que verifica una habría verificado un tercio de lo que tiene, y concluido sobre la totalidad.&lt;/p&gt;
&lt;p&gt;Pero los testigos producidos son archivos ordinarios, verificables con los mismos comandos, por alguien que nunca ha instalado la herramienta.&lt;/p&gt;
&lt;p&gt;Y puede probarlo ahora mismo, sobre un documento real: el inventario criptográfico de este sitio se publica con su firma y su testigo.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;curl -sO https://mesa.black/audit/report.html
curl -sO https://mesa.black/audit/report.html.tsr

O=$(openssl version -d | sed &#039;s/.*&amp;quot;\(.*\)&amp;quot;/\1/&#039;)
for f in &amp;quot;$O/cert.pem&amp;quot; &amp;quot;$O/certs/ca-certificates.crt&amp;quot; /etc/ssl/ca-bundle.pem; do
  [ -f &amp;quot;$f&amp;quot; ] &amp;amp;&amp;amp; CA=&amp;quot;$f&amp;quot; &amp;amp;&amp;amp; break
done
openssl ts -reply -in report.html.tsr -token_out -out token.der
openssl pkcs7 -inform DER -in token.der -print_certs -out chain.pem

openssl ts -verify \
  -digest 8ecb829ccc278ef7ab3138f56e07ee13319cbb72ce1dabbfc58ee7b4d6b670b5 \
  -in report.html.tsr -CAfile &amp;quot;$CA&amp;quot; -untrusted chain.pem
Verification: OK
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Los otros dos testigos están al lado — &lt;code&gt;report.html.2.tsr&lt;/code&gt; y &lt;code&gt;report.html.3.tsr&lt;/code&gt;, GlobalSign y DigiCert — y se verifican con el mismo comando cambiando el nombre del archivo. La sección siguiente explica por qué este bloque tiene seis líneas en lugar de una.&lt;/p&gt;
&lt;p&gt;La huella está impresa en el &lt;a href=&quot;/audit/report.html&quot;&gt;informe&lt;/a&gt; mismo, y la fecha que obtendrá es el 6 de octubre de 2026 a las 21:58 UTC — la primera vez que estos hallazgos fueron atestiguados, y no la última vez que republicamos la página.&lt;/p&gt;
&lt;h2 id=&quot;y-en-qué-máquina-el-comando-que-todo-el-mundo-publica-es-falso&quot;&gt;¿Y en qué máquina? El comando que todo el mundo publica es falso&lt;/h2&gt;
&lt;p&gt;Esta es la parte que no vimos venir, y que exigió una serie de mediciones en lugar de una lectura de documentación.&lt;/p&gt;
&lt;p&gt;El comando que se encuentra en todas partes para verificar un testigo RFC 3161 es este:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;openssl ts -verify -digest &amp;lt;huella&amp;gt; -in sellado.tsr \
  -CAfile /etc/ssl/certs/ca-certificates.crt
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Contiene dos suposiciones falsas.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;El almacén de certificados no está en ese sitio.&lt;/strong&gt; &lt;code&gt;ca-certificates.crt&lt;/code&gt; es una convención de Debian. En Fedora, en Rocky, en openSUSE, ese archivo no existe — y cuando &lt;code&gt;-CAfile&lt;/code&gt; apunta a un archivo ausente, &lt;code&gt;openssl ts -verify&lt;/code&gt; no dice «ese archivo no existe»: responde &lt;code&gt;Verification: FAILED&lt;/code&gt;. Su lector concluye que su testigo es malo.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Y el testigo lleva su cadena, pero no todo el mundo la lee.&lt;/strong&gt; Un testigo pedido con &lt;code&gt;-cert&lt;/code&gt; contiene los certificados que suben hasta la raíz — lo comprobamos, el nuestro lleva tres. OpenSSL 3 los usa. LibreSSL, es decir el &lt;code&gt;openssl&lt;/code&gt; que viene con macOS, no los usa y responde:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Verify error:unable to get local issuer certificate
Verification: FAILED
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;El mismo mensaje de error. La misma conclusión equivocada para el lector.&lt;/p&gt;
&lt;p&gt;Así que buscamos una receta que funcione en todas partes, y la medimos sobre ocho objetivos:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 1. el almacén de certificados de su openssl, donde esté
O=$(openssl version -d | sed &#039;s/.*&amp;quot;\(.*\)&amp;quot;/\1/&#039;)
for f in &amp;quot;$O/cert.pem&amp;quot; &amp;quot;$O/certs/ca-certificates.crt&amp;quot; /etc/ssl/ca-bundle.pem; do
  [ -f &amp;quot;$f&amp;quot; ] &amp;amp;&amp;amp; CA=&amp;quot;$f&amp;quot; &amp;amp;&amp;amp; break
done

# 2. la cadena que el testigo ya lleva, extraída para entregarla explícitamente
openssl ts -reply -in report.html.tsr -token_out -out token.der
openssl pkcs7 -inform DER -in token.der -print_certs -out chain.pem

# 3. la verificación
openssl ts -verify -digest &amp;lt;huella&amp;gt; -in report.html.tsr \
  -CAfile &amp;quot;$CA&amp;quot; -untrusted chain.pem
&lt;/code&gt;&lt;/pre&gt;
&lt;div class=&quot;scroll&quot;&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;objetivo&lt;/th&gt;
&lt;th&gt;openssl&lt;/th&gt;
&lt;th&gt;almacén encontrado&lt;/th&gt;
&lt;th&gt;resultado&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Debian 13&lt;/td&gt;
&lt;td&gt;OpenSSL 3.5.7&lt;/td&gt;
&lt;td&gt;&lt;code&gt;/usr/lib/ssl/cert.pem&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;OK&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Ubuntu 24.04&lt;/td&gt;
&lt;td&gt;OpenSSL 3.0.13&lt;/td&gt;
&lt;td&gt;&lt;code&gt;/usr/lib/ssl/cert.pem&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;OK&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Alpine 3.22&lt;/td&gt;
&lt;td&gt;OpenSSL 3.5.9&lt;/td&gt;
&lt;td&gt;&lt;code&gt;/etc/ssl/cert.pem&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;OK&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fedora 42&lt;/td&gt;
&lt;td&gt;OpenSSL 3.2.6&lt;/td&gt;
&lt;td&gt;&lt;code&gt;/etc/pki/tls/cert.pem&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;OK&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Rocky 9&lt;/td&gt;
&lt;td&gt;OpenSSL 3.5.8&lt;/td&gt;
&lt;td&gt;&lt;code&gt;/etc/pki/tls/cert.pem&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;OK&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;openSUSE Leap 15.6&lt;/td&gt;
&lt;td&gt;OpenSSL 3.1.4&lt;/td&gt;
&lt;td&gt;&lt;code&gt;/etc/ssl/ca-bundle.pem&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;OK&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;macOS + Homebrew&lt;/td&gt;
&lt;td&gt;OpenSSL 3.6.0&lt;/td&gt;
&lt;td&gt;&lt;code&gt;/opt/homebrew/etc/openssl@3/cert.pem&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;OK&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;macOS, openssl de Apple&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;LibreSSL 3.3.6&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;/private/etc/ssl/cert.pem&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;OK&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;p&gt;&lt;code&gt;openssl version -d&lt;/code&gt; da el directorio contra el que se compiló ese binario concreto, lo que cubre seis casos de ocho; openSUSE guarda su paquete en otro sitio, de ahí la tercera entrada del bucle. Y &lt;code&gt;-untrusted chain.pem&lt;/code&gt; no cambia nada donde no era necesario — que es lo que permite tener &lt;strong&gt;una&lt;/strong&gt; receta en lugar de una por sistema.&lt;/p&gt;
&lt;p&gt;Es ahora la que imprime el informe, con la nota que explica los tres pasos. Porque una prueba que solo se puede verificar en la distribución de quien la produjo no es una prueba portable, y un lector cuyo comando falla no aprende que su distribución es distinta: aprende que nuestro sello está roto.&lt;/p&gt;
&lt;h2 id=&quot;el-límite-impreso-en-el-documento&quot;&gt;El límite, impreso en el documento&lt;/h2&gt;
&lt;p&gt;Una autoridad de sellado de tiempo firma con RSA o con ECDSA. Es decir, exactamente lo que un inventario post-cuántico clasifica como vulnerable.&lt;/p&gt;
&lt;p&gt;Una herramienta que dedica cuarenta páginas a explicar que las firmas caducan no se concede una excepción para aquella de la que depende. Así que el informe lo escribe junto a la fecha:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Lo que el testigo no prueba: nada más allá de RSA-4096, el esquema que lo firma. Una fecha que se quiera oponer más tarde debe volver a atestiguarse mientras ese esquema aguante.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Un sellado de tiempo es una prueba para un litigio en los próximos años. No para 2040.&lt;/p&gt;
&lt;h2 id=&quot;la-trampa-de-diseño-la-atestación-más-antigua-es-la-única-que-vale&quot;&gt;La trampa de diseño: la atestación más antigua es la única que vale&lt;/h2&gt;
&lt;p&gt;Esta merece enunciarse porque se coge al revés con mucha naturalidad.&lt;/p&gt;
&lt;p&gt;Un sitio que republica su inventario pide de buena gana un testigo nuevo en cada publicación. Es el gesto que parece más limpio — y &lt;strong&gt;destruye la prueba&lt;/strong&gt; que se quería construir.&lt;/p&gt;
&lt;p&gt;Porque la única afirmación que cuenta es: &lt;em&gt;estos hallazgos existían &lt;strong&gt;a más tardar&lt;/strong&gt; en esta fecha.&lt;/em&gt; Aplastar la primera atestación con una más reciente borra exactamente eso. Uno acaba con un documento que prueba que existía esta mañana, cuando lo que quería probar es que existía en octubre.&lt;/p&gt;
&lt;p&gt;La regla que se deriva es corta: &lt;strong&gt;el sello no se mueve mientras los hallazgos no se muevan.&lt;/strong&gt; Un testigo que ya atestigua esta huella se conserva; una huella distinta pide uno nuevo. Lo mismo con la firma: volver a firmarla idéntica produce un eslabón de cadena que une una huella consigo misma, es decir ruido disfrazado de historia.&lt;/p&gt;
&lt;h2 id=&quot;por-qué-ahora&quot;&gt;Por qué ahora&lt;/h2&gt;
&lt;p&gt;La hoja de ruta coordinada del grupo de cooperación NIS, del 23 de junio de 2025, convierte el inventario criptográfico en un &lt;em&gt;First Step&lt;/em&gt; con plazo el &lt;strong&gt;31 de diciembre de 2026&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;«Habíamos inventariado antes del plazo» es una afirmación sobre una fecha. Es el único argumento que nos convenció de añadir todo lo anterior: sin un tercero, esa frase no vale más que la palabra de quien la pronuncia — y el campo que la lleva sale de su reloj.&lt;/p&gt;
&lt;h2 id=&quot;buenas-prácticas&quot;&gt;Buenas prácticas&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;No confunda «firmado el» con «fechado».&lt;/strong&gt; El primero sale de su reloj, el segundo de un tercero sin interés alguno en sus conclusiones.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Haga atestiguar una huella, no un archivo.&lt;/strong&gt; Se imprime en el documento, se comprueba con un comando estándar, y sobrevive a una clave destruida.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Compare la huella del testigo antes de plantear la cuestión de la confianza.&lt;/strong&gt; Es una comparación de hashes, no necesita ningún certificado — y sin ella, «cadena no verificable» y «este testigo habla de otra cosa» se parecen.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Elija una autoridad con raíz pública&lt;/strong&gt;, o su prueba viajará con una pieza que usted mismo suministra.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Pruebe el comando de verificación en otra máquina que la suya.&lt;/strong&gt; La ruta del almacén de certificados y el &lt;code&gt;openssl&lt;/code&gt; instalado varían, y los dos fallan con el mismo &lt;code&gt;Verification: FAILED&lt;/code&gt; que un testigo falso.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Conserve la atestación más antigua.&lt;/strong&gt; Pedir un testigo en cada publicación borra lo único que establecía.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Divida la confianza si lo que está en juego lo justifica.&lt;/strong&gt; La misma huella puede ir a dos o tres autoridades de jurisdicciones distintas, por una petición HTTP más cada una. La fecha defendible sin confiar en nadie en particular es entonces la más tardía de la lista.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Pida la fecha en el momento de producir el documento.&lt;/strong&gt; Nadie la atestiguará retroactivamente — es el interés del mecanismo, y su restricción.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;puntos-de-vigilancia&quot;&gt;Puntos de vigilancia&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Una cadena de firmas sostenida por una sola clave no es un rastro de auditoría: se reconstruye entera, en orden, y se verifica.&lt;/li&gt;
&lt;li&gt;Un sellado de tiempo se apoya en una firma clásica. Hay que volver a atestiguarlo mientras el esquema aguante, y decirlo en el documento en lugar de dejar creer en una prueba eterna.&lt;/li&gt;
&lt;li&gt;La huella sale de la máquina. No revela nada, pero si su documento promete que nada sale, esa promesa pasa a ser «nada sale, salvo si pide un sellado de tiempo» — y eso debe ser una opción explícita, nunca un valor por defecto.&lt;/li&gt;
&lt;li&gt;Un testigo que hay que acompañar del certificado raíz de la autoridad es una prueba a medias portable.&lt;/li&gt;
&lt;li&gt;Un sellado de tiempo limita por arriba, nunca por abajo. Nunca probará que un documento no existía antes de la fecha atestiguada, y presentar un límite superior como una fecha exacta es el tipo de aproximación que se vuelve en contra delante de alguien atento.&lt;/li&gt;
&lt;/ul&gt;
</content>
    </entry>
        <entry>
        <title>«Decimos lo que hacemos»: tres veces en dos días, este blog dijo algo falso.</title>
        <link href="https://mesa.black/es/decimos-lo-que-hacemos/"/>
        <id>https://mesa.black/es/decimos-lo-que-hacemos/</id>
        <updated>2026-10-06T02:00:00+02:00</updated>
        <summary>Una firma que no cubría la página que sellaba. Tres huellas donde el documento prometía una. Un artículo citado como publicado que nunca salió. Cada una encontrada haciendo lo que la frase describía, y así es como — porque la transparencia no es una intención, es un dispositivo.</summary>        <content type="html">&lt;p&gt;«Decimos lo que hacemos y hacemos lo que decimos» es una frase que se lee en muchísimos sitios, y escribirla no cuesta nada. Solo se vuelve interesante allí donde las dos mitades se separan — y siempre se separan, porque una afirmación se escribe una vez y el código sigue moviéndose.&lt;/p&gt;
&lt;p&gt;Así que la pregunta útil no es «¿somos transparentes?». Es: &lt;strong&gt;¿mediante qué dispositivo se detecta una frase falsa, y en cuánto tiempo?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Aquí están las tres últimas, todas del 5 y 6 de octubre, todas impresas por nuestras propias herramientas.&lt;/p&gt;
&lt;h2 id=&quot;1-una-firma-que-no-cubre-la-página-que-sella-y-nunca-la-cubrirá&quot;&gt;1. Una firma que no cubre la página que sella, y nunca la cubrirá&lt;/h2&gt;
&lt;p&gt;Este sitio publica ahora su propio inventario criptográfico, producido por &lt;a href=&quot;https://github.com/mesa-black/sablier&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;Sablier&lt;/a&gt; y firmado. El enlace está en la cabecera de cada página, el archivo &lt;code&gt;.sig&lt;/code&gt; está al lado, y cuatro comandos bastan para comprobarlo sin nosotros.&lt;/p&gt;
&lt;p&gt;Al añadir ese informe le escribimos una frase: &lt;em&gt;«el informe no ha cambiado desde que se firmó»&lt;/em&gt;.&lt;/p&gt;
&lt;p&gt;Una hora después, la comprobación de extremo a extremo — descargar el informe desde el sitio, su firma desde el sitio, la declaración desde GitHub, y verificar — devolvió esto:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;signature valide, Ed25519 et post-quantique
  + ML-DSA-65 : vérifiée
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Después &lt;strong&gt;modificamos una palabra en el informe&lt;/strong&gt; y relanzamos el mismo comando. La misma respuesta: válida.&lt;/p&gt;
&lt;p&gt;La frase era falsa, y era el peor tipo de falso: invitaba a un lector a confiar en unos bytes que la firma no toca. La causa es estructural y ningún mecanismo la repara — &lt;strong&gt;un informe muestra su propia firma, así que no puede contenerla.&lt;/strong&gt; El HTML se escribe después de que el bloque exista, y firmar los bytes renderizados sería circular.&lt;/p&gt;
&lt;p&gt;Lo que se firma es la huella de los &lt;em&gt;hallazgos&lt;/em&gt;, que es lo correcto: dos renderizados del mismo inventario, en dos idiomas, deben dar el mismo valor. La única forma de atar una página a esa huella es repetir el análisis sobre la misma fuente y comparar — y &lt;strong&gt;un repositorio público es precisamente lo que hace posible ese recálculo&lt;/strong&gt;. Eso pasó a ser la instrucción impresa, antes de la frase que dice qué establece la firma.&lt;/p&gt;
&lt;h2 id=&quot;2-tres-huellas-donde-el-documento-prometía-una&quot;&gt;2. Tres huellas donde el documento prometía una&lt;/h2&gt;
&lt;p&gt;La corrección anterior añadió al informe la frase que faltaba: &lt;em&gt;«dos renderizados del mismo inventario, en dos idiomas, dan el mismo valor»&lt;/em&gt;.&lt;/p&gt;
&lt;p&gt;Al día siguiente, una pregunta sencilla — &lt;em&gt;si leo en español, ¿el enlace no debería apuntar a la auditoría en español?&lt;/em&gt; — nos llevó a generar el informe en los tres idiomas. Las huellas salieron así:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fr  1839cd93…      en  abb8b217…      es  0e5b2727…
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Tres valores, bajo un párrafo que prometía uno. Dos causas, una de ellas seria.&lt;/p&gt;
&lt;p&gt;La pequeña: la etiqueta de un dominio &lt;em&gt;no declarado&lt;/em&gt; está traducida — «non déclaré», «undeclared», «no declarado» — y entraba en el cálculo.&lt;/p&gt;
&lt;p&gt;La grande: la sonda de red fabricaba sus hallazgos con frases traducidas, y el identificador de un hallazgo se calcula a partir de ese texto. Así que el mismo servidor producía un identificador distinto por idioma.&lt;/p&gt;
&lt;p&gt;Por qué es peor que un desacuerdo de huella: ese identificador es lo que acepta un hallazgo — lo que escribe, en un archivo versionado, «vimos ese, y esta es la razón por la que lo dejamos». Un identificador que cambia con el idioma significa que &lt;strong&gt;una decisión registrada en francés deja de aplicarse en silencio a un análisis lanzado en inglés&lt;/strong&gt;. Nada lo habría señalado: el hallazgo simplemente reaparece, sin su decisión.&lt;/p&gt;
&lt;p&gt;En todo lo demás de esa herramienta, la prueba de un hallazgo es una línea de código fuente — intraducible por naturaleza. Desde la sonda es ahora el hecho que devolvió el apretón de manos, y la frase que lo explica vive en un campo aparte, como en todos los demás detectores.&lt;/p&gt;
&lt;h2 id=&quot;3-un-artículo-citado-como-publicado-y-nunca-salido&quot;&gt;3. Un artículo citado como publicado, y nunca salido&lt;/h2&gt;
&lt;p&gt;El texto programado para el 8 de octubre — aún sin salir cuando se escriben estas líneas — se abría con: &lt;em&gt;«El 2 de octubre, un texto publicado aquí terminaba con una frase incómoda…»&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;Ese texto nunca salió. Estaba escrito, programado para el 2 de octubre, y lo retiramos el día anterior junto con otro. Comprobado: ausente del sitemap, ausente de las cuatro versiones subidas al servidor, y su URL responde 404.&lt;/p&gt;
&lt;p&gt;Un lector que hubiera seguido la referencia no habría encontrado nada — el peor error posible en un artículo cuyo tema es comprobar lo que se afirma. La frase dice ahora lo que pasó: escrito, programado, retirado la víspera, y su última línea se mantuvo. &lt;strong&gt;La retirada forma parte de la historia en lugar de estorbarla.&lt;/strong&gt;&lt;/p&gt;
&lt;h2 id=&quot;lo-que-las-tres-tienen-en-común&quot;&gt;Lo que las tres tienen en común&lt;/h2&gt;
&lt;p&gt;Ninguna se encontró releyendo. Las tres se encontraron &lt;strong&gt;haciendo lo que la frase describía&lt;/strong&gt;: alterar un informe publicado para ver si la firma se daba cuenta, generar el documento en los tres idiomas, seguir la propia referencia.&lt;/p&gt;
&lt;p&gt;Es el único método que funciona, y tiene un nombre menos noble que «transparencia»: &lt;strong&gt;comprobar en lugar de suponer&lt;/strong&gt;. El mismo error ocurrió dos veces en el utillaje durante esos dos días, de una forma aún más tonta — una comprobación que preguntaba por un código de estado en lugar de por un contenido. El servidor de desarrollo de PHP responde &lt;code&gt;200&lt;/code&gt; con la página de inicio para una ruta que no existe, así que nuestro control informaba «en línea» de un artículo que había sido reconstruido fuera de existencia. &lt;strong&gt;Un código de estado no es una verificación.&lt;/strong&gt;&lt;/p&gt;
&lt;h2 id=&quot;el-dispositivo-ahora&quot;&gt;El dispositivo, ahora&lt;/h2&gt;
&lt;p&gt;Una frase falsa no se corrige prometiendo estar más atento. Se corrige haciendo automático su desmentido.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Un presupuesto de palabras.&lt;/strong&gt; El cuestionario de entrevista había llegado a 986 palabras de texto que leer para responder a dos preguntas por tema. Ahora son 235, y un test falla por encima de 260. Un segundo falla si una palabra del oficio vuelve al camino del lector. Porque la prosa llega de párrafo justificado en párrafo justificado, y nada más la detecta.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Tests sobre la afirmación&lt;/strong&gt;, no sobre el código: tres idiomas dan una huella; tres idiomas dan un identificador; ninguna ruta de archivo aparece ante la persona entrevistada; un informe sin firmar no afirma nada de lo que una firma probaría.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Artefactos repetibles.&lt;/strong&gt; El informe de este sitio, su firma y la declaración que designa la clave son públicos. El comando de verificación está impreso dentro del documento, y lo que establece — igual que lo que no establece — justo debajo.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Retiradas asumidas.&lt;/strong&gt; Dos artículos escritos, programados y después retirados la víspera. El mecanismo de publicación se corrigió en la misma pasada: una versión fechada que ningún artículo reclama ya se elimina del servidor, porque si no se serviría el día previsto con el texto retirado dentro.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;lo-que-decidimos-no-medir&quot;&gt;Lo que decidimos no medir&lt;/h2&gt;
&lt;p&gt;La transparencia sirve también para decir lo que no se hace, y por qué.&lt;/p&gt;
&lt;p&gt;Este sitio &lt;strong&gt;no cuenta sus visitas&lt;/strong&gt;. No hay ningún registro de acceso: comprobado, cero líneas de petición registradas. Un contador honesto es posible — el registro de Caddy, la dirección IP eliminada en origen, ningún dato personal conservado — pero contaría &lt;em&gt;peticiones&lt;/em&gt;, no personas, y los robots inflarían la cifra. Un contador que anuncia «visitantes» contando peticiones es exactamente la falsa seguridad que el resto de este trabajo rechaza. Así que no.&lt;/p&gt;
&lt;p&gt;Tampoco tiene &lt;strong&gt;comentarios&lt;/strong&gt;. Harían falta un ejecutable en el servidor, una base de datos, moderación, antispam y el almacenamiento del nombre de otras personas — cinco cosas por cuya ausencia se define este sitio. En su lugar, una dirección al final de cada artículo. Cuesta una línea y filtra sola: quien se toma la molestia de escribir tiene algo que decir.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-ha-dado&quot;&gt;Lo que ha dado&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Tres afirmaciones falsas corregidas en dos días&lt;/strong&gt;, cada una con el test que falla si vuelve.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Un defecto serio encontrado de rebote&lt;/strong&gt;: decisiones de auditoría que se desvinculaban en silencio de su hallazgo según el idioma de ejecución.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Dos comprobaciones reescritas&lt;/strong&gt; porque medían un código de estado en lugar de un contenido.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Cero líneas de comunicación añadidas.&lt;/strong&gt; No hay una página de «nuestros compromisos» en este sitio, y no la habrá.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;buenas-prácticas&quot;&gt;Buenas prácticas&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Hacer lo que la frase describe, de verdad, una vez. Alterar el archivo firmado, generar en tres idiomas, seguir el propio enlace: ahí es donde caen las afirmaciones, no en la relectura.&lt;/li&gt;
&lt;li&gt;Escribir primero lo que una garantía &lt;strong&gt;no&lt;/strong&gt; cubre. Es la mitad que todo el mundo olvida, y es la que fabrica la confianza mal puesta.&lt;/li&gt;
&lt;li&gt;Convertir cada promesa cumplida en un test que falle cuando deje de cumplirse. Una afirmación sin desmentido automático es una afirmación que un día será falsa sin que nadie lo sepa.&lt;/li&gt;
&lt;li&gt;Verificar un contenido, nunca un código de estado.&lt;/li&gt;
&lt;li&gt;Decir lo que se ha retirado. Una retirada explicada cuesta un párrafo; un agujero en un historial público cuesta la confianza que se intentaba construir.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;puntos-de-vigilancia&quot;&gt;Puntos de vigilancia&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Un dispositivo no es una virtud.&lt;/strong&gt; Nada de lo anterior garantiza la próxima frase. Solo garantiza que una afirmación ya probada no se degradará en silencio.&lt;/li&gt;
&lt;li&gt;Los tres errores de este texto se encontraron en dos días porque alguien &lt;strong&gt;estaba usando&lt;/strong&gt; esas herramientas ese día. Una herramienta que no se usa conserva sus afirmaciones falsas indefinidamente, y ningún test se escribe en nuestro lugar.&lt;/li&gt;
&lt;li&gt;Publicar los propios errores tiene un coste que conviene nombrar: a quien lee deprisa le parece amateurismo. Lo hacemos igualmente, porque la alternativa — corregir en silencio — protege al autor y deja al lector con la versión falsa.&lt;/li&gt;
&lt;/ul&gt;
</content>
    </entry>
        <entry>
        <title>Nuestra capa de dominio solo contiene excepciones. A propósito.</title>
        <link href="https://mesa.black/es/nuestro-dominio-solo-contiene-excepciones/"/>
        <id>https://mesa.black/es/nuestro-dominio-solo-contiene-excepciones/</id>
        <updated>2026-10-04T02:00:00+02:00</updated>
        <summary>Nueve contextos, veintinueve comandos, un único manejador de consultas, cero puertos. Qué conservamos de DDD y de la arquitectura hexagonal, qué rechazamos, y los cinco puntos por donde la infraestructura cruza igualmente la frontera. Esto no es DDD purista, es time to market.</summary>        <content type="html">&lt;p&gt;Los artículos sobre arquitectura hexagonal muestran casi siempre el mismo esquema: un círculo en el centro, puertos alrededor, adaptadores fuera y una flecha que apunta hacia dentro. Ninguno enseña nunca qué contiene la carpeta &lt;code&gt;Domain/&lt;/code&gt; seis meses después.&lt;/p&gt;
&lt;p&gt;Aquí está la nuestra. Nueve contextos y, en total, doce archivos de dominio: nueve excepciones, dos enumeraciones, un rol. Cero interfaces. Cero agregados. Cero objetos de valor. Llamar a eso capa de negocio sería mentir, y de eso trata exactamente este artículo.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-conservamos-la-c-de-cqrs-no-la-q&quot;&gt;Lo que conservamos: la C de CQRS, no la Q&lt;/h2&gt;
&lt;p&gt;La configuración del bus declara tres canales con una semántica explícita:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-yaml&quot;&gt;default_bus: command.bus
buses:
    command.bus:            # un comando muta el estado, exactamente un manejador
        default_middleware: { enabled: true, allow_no_handlers: false }
    query.bus:              # una consulta devuelve un valor, un único manejador
        default_middleware: { enabled: true, allow_no_handlers: false }
    event.bus:              # un evento de dominio: 0..n suscriptores
        default_middleware: { enabled: true, allow_no_handlers: true }
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;El recuento real a día de hoy: &lt;strong&gt;veintinueve manejadores de comando, uno solo de consulta.&lt;/strong&gt; El bus de consultas existe, está configurado y está casi vacío.&lt;/p&gt;
&lt;p&gt;No es deuda de migración, es una conclusión. Un comando merece su ceremonia porque aporta tres cosas que antes no teníamos: un nombre de intención (&lt;code&gt;ChangeCompanySubscriptionPlan&lt;/code&gt; no es &lt;code&gt;setSubscriptionPlan&lt;/code&gt;), la garantía de que existe exactamente un sitio que lo ejecuta — &lt;code&gt;allow_no_handlers: false&lt;/code&gt; falla al arrancar, no en producción — y una frontera de transacción evidente, la del manejador.&lt;/p&gt;
&lt;p&gt;Una lectura no aporta nada de eso. Su forma la dicta la pantalla que la muestra: esta página necesita estas siete columnas, unidas así, ordenadas de esta manera. Pasar eso por un bus no añade ninguna regla, añade una capa y traslada el SQL de un archivo a otro. Así que leemos a través de los repositorios de Doctrine, directamente, y sin pedir perdón por ello.&lt;/p&gt;
&lt;p&gt;Un detalle que importa más de lo que parece: &lt;code&gt;default_bus: command.bus&lt;/code&gt;. Un &lt;code&gt;dispatch()&lt;/code&gt; sin más es un comando. El valor por defecto es el canal que muta el estado, es decir, el único que nunca quieres ver saliendo por el canal equivocado.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-rechazamos-la-inversión-de-dependencias&quot;&gt;Lo que rechazamos: la inversión de dependencias&lt;/h2&gt;
&lt;p&gt;Es el corazón del hexágono en la literatura: el dominio declara interfaces, la infraestructura las implementa, la flecha de dependencia apunta hacia dentro. No lo hicimos. Aquí va un manejador entero, sin cortes:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;#[AsMessageHandler(bus: &#039;command.bus&#039;)]
final readonly class ChangeCompanySubscriptionPlanHandler
{
    public function __construct(
        private EntityManagerInterface $entityManager,
        private LoggerInterface $logger,
    ) {}

    public function __invoke(ChangeCompanySubscriptionPlanCommand $command): void
    {
        $company = $this-&amp;gt;entityManager-&amp;gt;find(Company::class, Ulid::fromString($command-&amp;gt;companyId));
        if (!$company instanceof Company) {
            throw CompanyNotFoundException::withId($command-&amp;gt;companyId);
        }
        // …
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;EntityManagerInterface&lt;/code&gt; como dependencia directa. De treinta y ocho manejadores, &lt;strong&gt;veinticuatro&lt;/strong&gt; dependen de él. La entidad &lt;code&gt;Company&lt;/code&gt; viene de &lt;code&gt;App\Entity&lt;/code&gt;, compartida por todos los contextos. No hay repositorio abstracto, ni puerto, ni modelo de dominio distinto de la tabla.&lt;/p&gt;
&lt;p&gt;Dos observaciones sobre ese ejemplo, porque dicen más que el esquema.&lt;/p&gt;
&lt;p&gt;Primera: el comando transporta &lt;code&gt;string $companyId&lt;/code&gt;, no un objeto de valor &lt;code&gt;CompanyId&lt;/code&gt;. No es pereza: el mensaje tiene que poder serializarse para el transporte asíncrono. La frontera del bus impone la forma del mensaje — infraestructura dictando la firma de lo que llamamos dominio, desde la primera línea.&lt;/p&gt;
&lt;p&gt;Segunda: &lt;code&gt;Ulid::fromString(...)&lt;/code&gt;. El identificador del dominio existe en dos formas según se transporte o se consulte con él, y esa conversión es una restricción del almacenamiento, no del negocio.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-la-frontera-compra-de-todos-modos&quot;&gt;Lo que la frontera compra de todos modos&lt;/h2&gt;
&lt;p&gt;Una cosa, exactamente una, y vale su precio: &lt;strong&gt;el acoplamiento entre contextos se volvió visible en la lista de importaciones.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;El manejador anterior vive en &lt;code&gt;App\Billing&lt;/code&gt;. Importa &lt;code&gt;App\Company\Domain\Exception\CompanyNotFoundException&lt;/code&gt;. Esa sola importación dice que la facturación depende del contexto Empresa, y lo dice en la cabecera del archivo, en una línea, sin ningún diagrama que mantener al día. El grafo de dependencias entre contextos se obtiene con un &lt;code&gt;grep&lt;/code&gt; sobre los &lt;code&gt;use&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Es modesto. Comparado con una base donde todo vive en &lt;code&gt;App\Service&lt;/code&gt;, es la diferencia entre «suponemos que está acoplado» y «aquí está exactamente dónde». Ese beneficio es lo que compramos, y nada más.&lt;/p&gt;
&lt;h2 id=&quot;los-cinco-puntos-por-donde-cruza-la-infraestructura&quot;&gt;Los cinco puntos por donde cruza la infraestructura&lt;/h2&gt;
&lt;p&gt;Esto es lo que ningún esquema enseña: los sitios donde Doctrine decide la forma de una operación de negocio. Son fugas reales, todas presentes hoy en el código.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;1. La regla de negocio escrita en dos dialectos.&lt;/strong&gt; Nuestra política para mantener a las empresas internas fuera de las cifras comerciales cabe en un predicado. Existe en dos versiones, porque algunos caminos de lectura son SQL nativo por rendimiento y otros son DQL:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;public static function sql(string $alias = &#039;c&#039;): string  // consultas nativas
{ return ($alias !== &#039;&#039; ? $alias.&#039;.&#039; : &#039;&#039;).&#039;excluded_from_stats = false&#039;; }

public static function dql(string $alias = &#039;c&#039;): string  // consultas del ORM
{ return $alias.&#039;.excludedFromStats = false&#039;; }
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Una regla, dos escrituras, por culpa del lenguaje de consulta. La divergencia es de un carácter — &lt;code&gt;excluded_from_stats&lt;/code&gt; frente a &lt;code&gt;excludedFromStats&lt;/code&gt; — así que resulta invisible en una lectura rápida, y no hay ninguna prueba que fallara si una de las dos se desviara.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;2. El filtro ambiental.&lt;/strong&gt; El filtro de borrado lógico de Doctrine es estado global mutable. Una consulta que busca un identificador único no encuentra nada mientras el índice único sí lo sigue reteniendo. La salida es desactivar el filtro y volver a ponerlo:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$filters = $this-&amp;gt;em-&amp;gt;getFilters();
$wasEnabled = $filters-&amp;gt;isEnabled(&#039;softdeleteable&#039;);
if ($wasEnabled) { $filters-&amp;gt;disable(&#039;softdeleteable&#039;); }
$existing = $repo-&amp;gt;findOneBy([&#039;slug&#039; =&amp;gt; $slug]);
if ($wasEnabled) { $filters-&amp;gt;enable(&#039;softdeleteable&#039;); }
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Una «consulta de negocio» cuyo resultado depende de un estado ambiental no es una función. No es un defecto de Doctrine — el filtro hace exactamente lo que le pedimos — pero impide razonar sobre el código de aplicación sin saber en qué modo se ejecuta.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;3. El orden de escritura dentro de la unidad de trabajo.&lt;/strong&gt; Reemplazar las traducciones de un contenido parece una sola operación: quitar las antiguas, añadir las nuevas, guardar. Dentro de un único &lt;code&gt;flush()&lt;/code&gt;, Doctrine ejecuta los &lt;code&gt;INSERT&lt;/code&gt; antes que los &lt;code&gt;DELETE&lt;/code&gt; de huérfanos, y la restricción de unicidad sobre &lt;code&gt;(feedback_id, locale)&lt;/code&gt; revienta. Hay que partir la operación en dos guardados sucesivos.&lt;/p&gt;
&lt;p&gt;Dicho de otro modo: la forma de la operación aplicativa no la fija el negocio, sino la planificación interna del ORM. Ningún puerto habría protegido de eso, porque la restricción no vive ni en el dominio ni en el adaptador: vive en el orden de ejecución que los une.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;4. El alias de unión que trunca en silencio.&lt;/strong&gt; Filtrar sobre una asociación ya unida con &lt;code&gt;fetch&lt;/code&gt; restringe además la colección hidratada: crees que filtras filas y estás amputando el objeto devuelto. El filtrado necesita su propia segunda unión:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$qb-&amp;gt;innerJoin(&#039;f.industries&#039;, &#039;i_filter&#039;)      // alias distinto del de fetch
   -&amp;gt;andWhere(&#039;i_filter.id IN (:industries)&#039;);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;El fallo es invisible: la consulta devuelve las entidades correctas, con colecciones incompletas. Es semántica de infraestructura, en mitad de lo que parece una regla de búsqueda.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;5. El tipo del identificador.&lt;/strong&gt; Los identificadores viajan como ULID, se comparan en RFC 4122 dentro de las consultas, y olvidar la conversión produce un resultado vacío en lugar de un error. Un puerto habría desplazado la conversión; no la habría eliminado.&lt;/p&gt;
&lt;h2 id=&quot;la-regla-de-migración&quot;&gt;La regla de migración&lt;/h2&gt;
&lt;p&gt;Queda la pregunta que mata las reescrituras: ¿qué hacemos con el código existente, escrito como servicios clásicos de Symfony?&lt;/p&gt;
&lt;p&gt;Nada, mientras nadie lo toque. La política está escrita: &lt;strong&gt;CQRS para las escrituras y lecturas nuevas; el código existente migra solo bajo demanda.&lt;/strong&gt; Nunca una reescritura masiva en nombre de la homogeneidad.&lt;/p&gt;
&lt;p&gt;Porque la homogeneidad no es un resultado de negocio. Reescribir un servicio que funciona para que se parezca a sus vecinos produce riesgo sin producir valor, y es exactamente el tipo de trabajo que se justifica solo, indefinidamente, porque su criterio de parada es estético.&lt;/p&gt;
&lt;h2 id=&quot;esto-no-es-ddd-purista-es-time-to-market&quot;&gt;Esto no es DDD purista, es time to market&lt;/h2&gt;
&lt;p&gt;Hay que nombrar la razón de verdad, porque todo lo anterior se lee de otra manera una vez puesta sobre la mesa.&lt;/p&gt;
&lt;p&gt;Ya hemos escrito aquí que &lt;a href=&quot;/es/el-codigo-que-no-escribimos/&quot;&gt;la funcionalidad más barata es la que no se construye&lt;/a&gt;. Un puerto es una funcionalidad. Un agregado también, un objeto de valor también, una capa anticorrupción también. Cada uno cuesta escribirlo, cuesta leerlo a quien llegue después, y cuesta mantenerlo mientras el código siga vivo. Una abstracción no es gratis por ser inmaterial.&lt;/p&gt;
&lt;p&gt;La pregunta útil no es, por tanto, «¿esto es DDD correcto?». Es: ¿qué compra esta abstracción hoy y qué se limita a aplazar? Un repositorio detrás de una interfaz compra la posibilidad de cambiar de almacenamiento — no vamos a dejar PostgreSQL. Compra también pruebas sin base de datos, y eso sí es un beneficio real: es el único argumento que quizá nos haga pagar la factura algún día.&lt;/p&gt;
&lt;p&gt;Lo que hicimos en su lugar cabe en una frase: entregar, y conservar solo las fronteras que se pagan solas. El bus de comandos cuesta tres archivos y sirve el mismo día. Los puertos cuestan una capa entera y quizá sirvan, más adelante, a un equipo que todavía no existe.&lt;/p&gt;
&lt;p&gt;El riesgo de esta postura es conocido, y escribirlo forma parte del precio: se parece muchísimo a la pereza. La diferencia está en un solo detalle — sabemos nombrar lo que no construimos, y por qué.&lt;/p&gt;
&lt;p&gt;Y lo asumimos. Estas decisiones son nuestras, no accidentes que descubriríamos al releer. Las corregimos cuando podemos y cuando tenemos tiempo: el día en que una molestia se vuelve real y medible, no el día en que un artículo de arquitectura nos explica que son incorrectas. Una deuda escrita, fechada y argumentada no es una deuda negada: es la única que uno es capaz de devolver en el momento adecuado.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-dio-de-sí&quot;&gt;Lo que dio de sí&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Nueve contextos con nombre&lt;/strong&gt;, cuyo acoplamiento mutuo se lee en las importaciones y no en un diagrama caducado.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Veintinueve comandos&lt;/strong&gt;, cada uno con un nombre de intención, un manejador único garantizado en el arranque y una frontera de transacción evidente.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Un único manejador de consultas&lt;/strong&gt;, asumido: las lecturas pasan por los repositorios.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Doce archivos de dominio&lt;/strong&gt; — nueve excepciones, dos enumeraciones, un rol — es decir, ninguna regla de negocio realmente aislada de Doctrine.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Cero reescrituras&lt;/strong&gt; del código clásico existente, que sigue funcionando al lado.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;buenas-prácticas&quot;&gt;Buenas prácticas&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Tratar cada abstracción como una funcionalidad: tiene que decir qué compra hoy, no qué permitiría algún día.&lt;/li&gt;
&lt;li&gt;Adoptar las piezas por separado. El bus de comandos aporta algo sin el resto; los puertos, los agregados y los objetos de valor son compras distintas, cada una con su factura.&lt;/li&gt;
&lt;li&gt;Elegir el valor por defecto más estricto: el bus por defecto es el que muta el estado, y la ausencia de manejador hace fallar el arranque en lugar de la producción.&lt;/li&gt;
&lt;li&gt;Usar los espacios de nombres como detector de acoplamiento y no como barrera: no protegen de nada, hacen visible.&lt;/li&gt;
&lt;li&gt;Escribir la regla de migración con su criterio de parada. Sin él, «homogeneizar la arquitectura» es un trabajo infinito.&lt;/li&gt;
&lt;li&gt;Mirar qué contiene realmente &lt;code&gt;Domain/&lt;/code&gt; antes de decir que se hace DDD. El recuento es instructivo.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;puntos-de-vigilancia&quot;&gt;Puntos de vigilancia&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;La carpeta no es la frontera.&lt;/strong&gt; Crear &lt;code&gt;Domain/&lt;/code&gt;, &lt;code&gt;Application/&lt;/code&gt;, &lt;code&gt;Infrastructure/&lt;/code&gt; da una sensación reconfortante de avance medible, y medir una arquitectura por su número de carpetas es la forma más segura de no obtener ninguna de las garantías que sugieren.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Veinticuatro de treinta y ocho manejadores dependen del &lt;code&gt;EntityManager&lt;/code&gt;&lt;/strong&gt;: ninguno puede probarse con un repositorio en memoria. La batería de pruebas necesita una base de datos real. Es un coste, está asumido, no es gratis.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Las entidades compartidas de Doctrine son el acoplamiento real&lt;/strong&gt;, y es invisible en el árbol de carpetas. El día en que dos contextos quieran que la misma tabla diverja, ese será el muro, no la ausencia de puertos.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Una regla de negocio duplicada en dos dialectos de consulta acabará divergiendo&lt;/strong&gt;, y hoy nada lo detectaría. Es la deuda más concreta de todo lo anterior.&lt;/li&gt;
&lt;/ul&gt;
</content>
    </entry>
        <entry>
        <title>Éramos nuestro propio mejor cliente. Era un fallo.</title>
        <link href="https://mesa.black/es/nuestro-propio-mejor-cliente/"/>
        <id>https://mesa.black/es/nuestro-propio-mejor-cliente/</id>
        <updated>2026-09-30T02:00:00+02:00</updated>
        <summary>Nuestra empresa publica en nuestra plataforma, y se contaba a sí misma en la facturación, en el embudo y en las listas de seguimiento. Cómo la sacamos de las estadísticas sin sacarla del sitio.</summary>        <content type="html">&lt;p&gt;Todo el mundo recomienda usar el propio producto. Nadie advierte del efecto secundario: en cuanto tu empresa tiene una cuenta, entra en tus cifras. No en una nota al pie, sino en la facturación, en la tasa de conversión, en la lista de clientes a los que hay que llamar.&lt;/p&gt;
&lt;p&gt;Nuestro caso: BlackMesa publica casos reales en &lt;a href=&quot;https://showmetherex.com/es/&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;Show me the REX&lt;/a&gt;. La cuenta es real, el plan es real, los artículos se leen. Lo que no es real son los ingresos: no nos facturamos a nosotros mismos. Resultado: un cliente de cero euros figuraba en el MRR, inflaba el reparto por planes y ocupaba una casilla del embudo de conversión sin haber convertido jamás nada.&lt;/p&gt;
&lt;p&gt;La corrección evidente — «excluimos nuestra empresa» — es falsa. Da por supuesto que el problema es la empresa. El problema está en otro sitio.&lt;/p&gt;
&lt;h2 id=&quot;no-es-a-quién-excluir-es-qué-responde-esta-cifra&quot;&gt;No es «a quién excluir», es «qué responde esta cifra»&lt;/h2&gt;
&lt;p&gt;El reflejo es buscar una lista de entidades que apartar. La pregunta correcta se plantea métrica a métrica: ¿de qué pregunta es respuesta esta cifra?&lt;/p&gt;
&lt;p&gt;Un contador de visualizaciones responde a «cuánta gente ha leído este texto». La respuesta es la misma venga el lector de nuestras oficinas o de cualquier otro sitio: la página se sirvió, se leyó, el contenido existe. Excluir nuestras visualizaciones volvería falsa esa cifra.&lt;/p&gt;
&lt;p&gt;La facturación mensual responde a «cuánto nos pagan nuestros clientes». Nuestra propia empresa no es un cliente. Su presencia vuelve falsa esa cifra.&lt;/p&gt;
&lt;p&gt;Ambas métricas miran la misma base de datos, a veces la misma fila, y necesitan reglas opuestas. No es una excepción que gestionar, es la regla: &lt;strong&gt;la unidad de exclusión no es el dato, es la pregunta formulada.&lt;/strong&gt;&lt;/p&gt;
&lt;h2 id=&quot;el-caso-que-zanja-una-visualización-que-cuenta-y-no-cuenta&quot;&gt;El caso que zanja: una visualización que cuenta y no cuenta&lt;/h2&gt;
&lt;p&gt;El mejor ejemplo es también el más incómodo, porque descarta cualquier atajo de implementación.&lt;/p&gt;
&lt;p&gt;En la plataforma, la visualización de un caso alimenta dos cosas distintas. Por un lado la audiencia: el contador que aparece en el artículo, el acumulado del panel, la curva de tráfico. Por otro, una señal comercial: «qué empresas han consultado tus casos», que sirve para identificar contactos con los que retomar el hilo.&lt;/p&gt;
&lt;p&gt;Mismo evento, mismo registro. En el primer grupo, una lectura hecha desde nuestras oficinas cuenta: alguien ha leído de verdad. En el segundo no debe contar de ninguna manera: no somos un cliente potencial al que llamar, y un lector interno dentro de una lista de leads es una acción comercial disparada para nada.&lt;/p&gt;
&lt;p&gt;No existe, por tanto, un filtro global que se ponga una sola vez en la entrada. Cada consulta tiene que saber a qué familia pertenece.&lt;/p&gt;
&lt;h2 id=&quot;una-marca-en-la-base-de-datos-no-una-constante-en-el-código&quot;&gt;Una marca en la base de datos, no una constante en el código&lt;/h2&gt;
&lt;p&gt;Primera versión, la más rápida: una lista de nombres de empresa escrita en el código. Duró una hora. Una constante obliga a desplegar para reclasificar una empresa y, sobre todo, miente sobre la naturaleza de la información: «esta empresa no es un cliente» es un dato de negocio, cambia, se decide, y tiene que estar a la vista de quien administra las cuentas.&lt;/p&gt;
&lt;p&gt;Así que se convirtió en una casilla en la ficha de empresa, con su texto de ayuda explícito, porque una opción cuyo alcance nadie entiende acaba marcada al azar:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Nuestras propias empresas publican y siguen visibles en el sitio público, pero no cuentan en ningún dato comercial ni de marketing: MRR, planes, embudo, upsell/abandono, leads, resúmenes. Las visualizaciones y las visitas sí se siguen contando.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;La lista de nombres no desapareció: sirve de arranque, para que un entorno recién instalado no empiece nunca con cifras contaminadas. Pero ya no decide nada.&lt;/p&gt;
&lt;p&gt;El predicado en sí vive en una única clase pequeña, en dos versiones: una para las consultas del ORM y otra para el SQL en crudo. Parece anecdótico; es lo que hace la regla auditable. Encontrar los sitios que la aplican se convirtió en una búsqueda de texto, y contrastarla con la lista de cifras comerciales se hace a ojo en un minuto.&lt;/p&gt;
&lt;h2 id=&quot;verificar-en-lugar-de-releer&quot;&gt;Verificar en lugar de releer&lt;/h2&gt;
&lt;p&gt;Releer el propio código de exclusión no demuestra nada: uno relee lo que cree haber escrito. La única verificación que vale consiste en cambiar la casilla y comparar los paneles antes y después, cifra por cifra.&lt;/p&gt;
&lt;p&gt;Una treintena de valores se movieron. Siete se quedaron rigurosamente idénticos, y ese era el resultado esperado: son los contadores de audiencia y los volúmenes de contenido publicado. Una cifra que se mueve cuando no debía es un fallo; una cifra que no se mueve cuando debía es un olvido. Sin ese paso no habríamos distinguido ninguno de los dos.&lt;/p&gt;
&lt;p&gt;El resultado final: una marca, una clase de política, treinta y cuatro predicados repartidos en ocho archivos — MRR, planes, embudo, upsell, riesgo de abandono, seguimientos, inteligencia comercial, resúmenes mensuales, caducidad de cupones, nurturing.&lt;/p&gt;
&lt;p&gt;Este último merece una mención. Sin la exclusión, nuestra propia empresa entraba en la secuencia automática de reactivación. Nos habríamos enviado nuestros propios correos de recuperación.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-dio-de-sí&quot;&gt;Lo que dio de sí&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Un MRR sin ningún cliente de cero euros dentro&lt;/strong&gt;, y una tasa de conversión que ya no cuenta nuestro propio registro en el denominador.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Una treintena de valores corregidos&lt;/strong&gt; en los paneles comerciales, siete intencionadamente sin cambios.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Cero cambios en la parte pública&lt;/strong&gt;: los casos siguen publicados, visibles, filtrables, y sus visualizaciones se siguen contando.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Una regla escrita en un solo sitio&lt;/strong&gt;, con su motivo, en lugar de un &lt;code&gt;AND&lt;/code&gt; copiado de consulta en consulta.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Una casilla&lt;/strong&gt; que permite reclasificar una empresa sin desplegar.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;buenas-prácticas&quot;&gt;Buenas prácticas&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Clasificar cada métrica antes de programar el filtro: medida de audiencia o señal comercial. La respuesta determina la regla, y no es la misma para dos cifras sacadas de la misma tabla.&lt;/li&gt;
&lt;li&gt;Poner la pertenencia en la base de datos, no en una constante: es un dato de negocio, cambia y se decide.&lt;/li&gt;
&lt;li&gt;Concentrar el predicado en una sola clase aunque quepa en una línea: lo importante no es reutilizarlo, es poder encontrar todas las llamadas.&lt;/li&gt;
&lt;li&gt;Verificar cambiando la casilla: comparar las cifras antes y después es la única forma de distinguir un olvido de una decisión.&lt;/li&gt;
&lt;li&gt;Escribir el alcance en la interfaz de administración, justo donde se marca la casilla.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;puntos-de-vigilancia&quot;&gt;Puntos de vigilancia&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Nada impide que la próxima consulta olvide el predicado.&lt;/strong&gt; La regla se sostiene con la revisión de código, no con una prueba automática, y hoy esa es la debilidad principal del montaje.&lt;/li&gt;
&lt;li&gt;Una exclusión demasiado amplia es tan falsa como la ausencia de exclusión: quitar nuestras visualizaciones del contador de audiencia habría producido una mentira en el otro sentido.&lt;/li&gt;
&lt;li&gt;El día en que una empresa interna se convierta en cliente de pago de verdad, habrá que desmarcar la casilla, y nadie lo recordará. Esa decisión es humana y necesita un momento fijado para revisarla.&lt;/li&gt;
&lt;li&gt;Decir públicamente que tus estadísticas excluyen tus propios datos no cuesta nada, y es mejor que descubrirlo en boca de otro.&lt;/li&gt;
&lt;/ul&gt;
</content>
    </entry>
        <entry>
        <title>La funcionalidad más barata es la que no se construye</title>
        <link href="https://mesa.black/es/el-codigo-que-no-escribimos/"/>
        <id>https://mesa.black/es/el-codigo-que-no-escribimos/</id>
        <updated>2026-09-27T02:00:00+02:00</updated>
        <summary>Tres señales que dicen «no escribas este código», y lo que nos ahorraron en un solo día.</summary>        <content type="html">&lt;p&gt;La sobriedad digital casi siempre se plantea como un problema de optimización: imágenes más
ligeras, mejor caché, una región más limpia. Todo es cierto, y todo es marginal. El
desperdicio real está en otra parte, y nadie lo mide: &lt;strong&gt;el código escrito para nada&lt;/strong&gt;. Una
migración que rehacer, una herramienta comprada y abandonada, una funcionalidad entregada que
nadie abre. Queda la pregunta que nunca habíamos formulado: ¿cómo se &lt;em&gt;decide&lt;/em&gt; no construir
algo?&lt;/p&gt;
&lt;p&gt;El caso expone las &lt;strong&gt;tres señales&lt;/strong&gt; que nos dimos, y lo que cada una ahorró en una jornada de
trabajo corriente: una funcionalidad rota de la que nadie se quejó — información sobre la
funcionalidad, no sobre el fallo; 1.400 traducciones que no escribimos porque ningún lector
podía alcanzarlas; y una carencia de supervisión que resultó ser una carencia de ensayo, no
de herramienta.&lt;/p&gt;
&lt;p&gt;También dice lo que esas señales &lt;strong&gt;no&lt;/strong&gt; significan. «Nadie lo necesita» es la excusa perfecta
para no hacer nada, y una regla que solo sabe decir que no ha dejado de ser una regla. Dos
salvaguardas la mantienen honesta — entre ellas esta: una funcionalidad sin uso a veces está
mal expuesta, no es inútil.&lt;/p&gt;
</content>
    </entry>
        <entry>
        <title>Subir el SO bajo Docker: lo que sigue acoplado y lo que nada valida</title>
        <link href="https://mesa.black/es/subir-el-so-bajo-docker/"/>
        <id>https://mesa.black/es/subir-el-so-bajo-docker/</id>
        <updated>2026-09-27T02:00:00+02:00</updated>
        <summary>La aplicación vive en una imagen, así que la distribución no puede tocarla. Quedan cuatro puntos de acoplamiento, y uno de ellos está en un punto ciego que ningún pipeline cubre.</summary>        <content type="html">&lt;p&gt;&lt;a href=&quot;https://showmetherex.com/es/&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;Show me the REX&lt;/a&gt; funciona en un único anfitrión: un Postgres, un Redis, un proxy frontal y la aplicación desplegada en blue-green — dos instancias idénticas, «azul» y «verde», de las que solo una sirve tráfico a la vez. La nueva versión se arranca en la que está en reposo y, cuando responde bien, se conmuta el proxy. Cuando escribimos esto, ese anfitrión sirve 52 casos publicados y algo más de 16.000 visualizaciones acumuladas.&lt;/p&gt;
&lt;p&gt;Este montaje protege una entrega: si la nueva versión se porta mal, volver atrás lleva un segundo y nadie se entera. No protege nada frente a la máquina misma, porque las dos instancias viven en ese mismo anfitrión — si se para, se paran las dos.&lt;/p&gt;
&lt;p&gt;El anfitrión único es una decisión asumida, no un descuido: sin redundancia mientras el tráfico no la justifique, y con el umbral de revisión por escrito — mil visitas al día. Por debajo, una segunda máquina cuesta mucho más en complejidad (replicación, conmutación, coherencia) de lo que aporta en disponibilidad, y la complejidad que nadie necesita todavía es lo más caro que se puede construir.&lt;/p&gt;
&lt;p&gt;Pero asumir esa decisión crea una obligación. Si aceptas que un reinicio corta el servicio, te debes una cifra exacta de lo que cuesta. Eso es lo que hicimos mal esa noche, y volvemos sobre ello al final.&lt;/p&gt;
&lt;p&gt;Subimos ese anfitrión de una versión de Ubuntu a la siguiente. La operación salió bien, y eso no es lo interesante. Lo interesante es que la contenerización ha reducido lo que una subida así puede romper a una lista muy corta, y que encontramos justo el elemento de esa lista que nada en nuestra cadena vigilaba.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-la-contenerización-desacopló-de-verdad&quot;&gt;Lo que la contenerización desacopló de verdad&lt;/h2&gt;
&lt;p&gt;La aplicación es inmune a una subida de distribución, y conviene precisar por qué: no usa nada del anfitrión. Su PHP, sus extensiones, sus bibliotecas de sistema y su almacén de certificados viajan dentro de la imagen. Se puede sustituir por completo el &lt;code&gt;ca-certificates&lt;/code&gt; del anfitrión: nuestras llamadas salientes a VIES, a la pasarela de pago y al almacenamiento de objetos no se enteran, porque nunca leen ese almacén.&lt;/p&gt;
&lt;p&gt;Por eso los equipos han acabado tratando una subida de SO en un anfitrión de contenedores como rutina. Es casi cierto, y es ese «casi» el que cuesta.&lt;/p&gt;
&lt;h2 id=&quot;los-cuatro-puntos-de-acoplamiento-que-quedan&quot;&gt;Los cuatro puntos de acoplamiento que quedan&lt;/h2&gt;
&lt;p&gt;Cuando ya has metido en imágenes todo lo que se podía, lo que sigue perteneciendo al anfitrión es una lista corta, y es la misma en cualquier servidor contenerizado:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;El núcleo.&lt;/strong&gt; Los contenedores lo comparten. Un salto mayor cambia el suelo bajo una base de datos mucho más que bajo un proceso web.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;El demonio Docker.&lt;/strong&gt; No está en tu imagen: es un paquete del anfitrión, instalado desde un repositorio de terceros.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Las fuentes apt de ese demonio.&lt;/strong&gt; Lo que decide si el punto anterior volverá a recibir algún parche de seguridad.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;El contrato de reinicio.&lt;/strong&gt; Qué contenedores vuelven solos tras un arranque y cuáles, deliberadamente, no — la instancia en reposo, por ejemplo, debe quedarse abajo, o dos versiones de la aplicación se pelearían por la misma base de datos.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Nada más importa realmente. La lista es lo bastante corta como para revisarla a mano, antes y después — lo que hace imperdonable no revisarla.&lt;/p&gt;
&lt;h2 id=&quot;el-único-daño-duradero-cayó-en-el-punto-tres&quot;&gt;El único daño duradero cayó en el punto tres&lt;/h2&gt;
&lt;p&gt;Una subida de versión desactiva o elimina las fuentes apt de terceros. No es un fallo: esas fuentes están compiladas para la versión que abandonas, y mantenerlas activas durante el salto es la forma de romper el sistema. La herramienta hace bien, y lo advierte.&lt;/p&gt;
&lt;p&gt;Lo que no hace es decírtelo después. Nuestra fuente de Docker había desaparecido. Nada se rompió: el demonio siguió funcionando, los contenedores con él, el sitio sirviendo. Pero el paquete instalado estaba compilado para la distribución anterior, y ya no quedaba ningún repositorio capaz de reemplazarlo. &lt;strong&gt;El modo de fallo no es un servicio que se detiene; es un gestor de paquetes que se vuelve autoritativo y vacío a la vez.&lt;/strong&gt; Informa de que todo está al día, y dice la verdad sobre un universo que ya no puede ver.&lt;/p&gt;
&lt;p&gt;Restaurar la fuente son cuatro líneas y ningún reinicio. Reveló de inmediato siete versiones menores de deriva acumuladas en silencio. Nada habría levantado la mano jamás: ni el demonio, que funciona; ni la monitorización que no tenemos; ni &lt;code&gt;apt&lt;/code&gt;, que ya no tenía con qué comparar.&lt;/p&gt;
&lt;h2 id=&quot;el-punto-ciego-los-ficheros-compose&quot;&gt;El punto ciego: los ficheros compose&lt;/h2&gt;
&lt;p&gt;Y llegamos al hallazgo estructural, que es el que merece llevarse.&lt;/p&gt;
&lt;p&gt;Nuestro servicio de base de datos no tenía política de reinicio. Tras un arranque, todos los demás contenedores habrían vuelto y Postgres no. El fallo es trivial: falta una línea. Su vida útil no lo es: llevaba meses ahí, y solo podía manifestarse en un reinicio del anfitrión, que no había ocurrido en todo ese tiempo.&lt;/p&gt;
&lt;p&gt;La pregunta buena no es cómo se escribió. Es por qué nada lo detectó. Y la respuesta se generaliza mucho más allá de nuestro montaje: &lt;strong&gt;los ficheros compose son la única configuración de producción que nadie posee.&lt;/strong&gt; No se cuecen en la imagen, así que la construcción nunca los ve. Ningún test los ejercita, porque los tests corren contra la aplicación, no contra la topología del anfitrión. Y nuestro job de despliegue ni siquiera los copia: abre una sesión SSH y lanza un script. Se editan en el repositorio, se aplican a mano y no los valida nada.&lt;/p&gt;
&lt;p&gt;En una cadena por lo demás totalmente automatizada —tests, análisis estático, construcción de imagen, despliegue sin corte— ahí es donde un defecto puede dormir indefinidamente. No en el código que el pipeline lee veinte veces al día, sino en el puñado de líneas YAML que no abre nunca.&lt;/p&gt;
&lt;h2 id=&quot;lo-que-el-núcleo-pudo-romper-y-lo-que-no-verificamos&quot;&gt;Lo que el núcleo pudo romper, y lo que no verificamos&lt;/h2&gt;
&lt;p&gt;Un salto mayor de núcleo bajo un Postgres contenerizado merece algo más que «volvió a arrancar». Hay tres preguntas que hacerse, y solo podemos responder a dos:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;em&gt;El directorio de datos.&lt;/em&gt; Vive en un volumen con nombre, en el mismo sistema de ficheros, con el mismo driver de almacenamiento. Nada se movió, y esa es la razón de que la subida fuera superable, no la suerte.&lt;/li&gt;
&lt;li&gt;&lt;em&gt;Los perfiles de confinamiento del demonio.&lt;/em&gt; Los valores por defecto de seccomp y AppArmor vienen con el paquete Docker, no con la distribución, y por eso los contenedores encontraron el mismo entorno al otro lado.&lt;/li&gt;
&lt;li&gt;&lt;em&gt;La semántica de durabilidad.&lt;/em&gt; Si un núcleo nuevo cambia algo para Postgres con nuestras opciones de montaje es una pregunta que no respondimos. Aguantó, lo que no prueba nada. Lo escribimos en lugar de reclamar una verificación que nunca hicimos.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;la-medición-ya-existía&quot;&gt;La medición ya existía&lt;/h2&gt;
&lt;p&gt;Queda la obligación planteada en la introducción: conocer el coste real del corte que decidimos aceptar. Dimos una cifra leyendo los registros de los contenedores: el intervalo entre el último error de un proceso y el arranque del siguiente. Ese número describe el anfitrión, no a los visitantes. Deja fuera el apagado anterior y el calentamiento posterior, y puede errar por un factor de tres.&lt;/p&gt;
&lt;p&gt;Mientras tanto, todo nuestro tráfico pasa por una CDN que ya había registrado, petición a petición, exactamente lo que recibió la gente en esa ventana. &lt;strong&gt;La medición que creíamos que nos faltaba ya la habían tomado por nosotros, en un aparato que pagábamos y nunca habíamos consultado.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;El reflejo a corregir no es «añadir instrumentación». Es inventariar lo que ya mide antes de añadir nada: la CDN, los registros del propio proxy, la consola del proveedor. Nuestros tropiezos de procedimiento de esa noche —un nombre de contenedor adivinado, variables de shell que no sobreviven a una reconexión SSH, un grep tan amplio que informó de 41 líneas para 2 errores— son todos de la misma familia y valen exactamente una frase: un runbook resuelve lo que necesita, nunca lo congela. Qué instancia está sirviendo es el caso de manual: cambia en cada despliegue.&lt;/p&gt;
&lt;h2 id=&quot;por-qué-lo-publicamos-todo--y-lo-único-que-nos-callamos&quot;&gt;Por qué lo publicamos todo — y lo único que nos callamos&lt;/h2&gt;
&lt;p&gt;Un caso solo sirve si es concreto, así que este lleva las órdenes, los modos de fallo y las lagunas. Lo que plantea una pregunta legítima: ¿publicar todo eso no es entregarle un mapa a un atacante?&lt;/p&gt;
&lt;p&gt;Nuestra regla cabe en una frase. &lt;strong&gt;El problema nunca es nombrar una versión. Es nombrar una versión en la que sigues siendo vulnerable.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;«Estábamos en la versión X, nos costó esto, ya está corregido» es práctica habitual de post-mortem. El mismo texto publicado antes de la corrección es una debilidad todavía vigente con la diana puesta: un caso va firmado, nombra una empresa y un dominio. Así que primero corregir, después contar, y generalizar lo que no enseña nada. La &lt;em&gt;distancia&lt;/em&gt; —siete versiones de deriva silenciosa— es la lección; la cadena de versión exacta de nuestro servidor no lo es. Lo que nunca se publica es la otra categoría, la que no se aprende pero sí se copia: nombres de máquina, rutas, la cadena de claves que descifra una copia. La frontera no es «sensible o inofensivo», es &lt;strong&gt;¿esto enseña, o esto abre?&lt;/strong&gt;&lt;/p&gt;
&lt;h2 id=&quot;lo-que-dio-de-sí&quot;&gt;Lo que dio de sí&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Cuatro puntos de acoplamiento&lt;/strong&gt; aislados entre una aplicación contenerizada y su anfitrión: núcleo, demonio, fuentes apt del demonio, contrato de reinicio. Lo bastante pocos para revisarlos a mano, antes y después.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Una vía de actualización congelada, restaurada&lt;/strong&gt;: el demonio había derivado siete versiones menores sin que nada pudiera señalarlo.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Un punto ciego estructural, nombrado&lt;/strong&gt;: los ficheros compose, la única configuración de producción que ninguna construcción, ningún test y ningún despliegue llegan a leer.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Una medición recuperada en lugar de construida&lt;/strong&gt;: la CDN ya había registrado lo que vieron los visitantes, gratis.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;buenas-prácticas&quot;&gt;Buenas prácticas&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Escribe tus puntos de acoplamiento una vez. En un anfitrión de contenedores son cuatro, siempre los mismos, y revisarlos lleva diez minutos.&lt;/li&gt;
&lt;li&gt;Tras una subida de versión, revisa primero las fuentes de terceros: un gestor de paquetes sin nada con qué comparar informa de que todo está al día, y no miente.&lt;/li&gt;
&lt;li&gt;Busca lo que tu automatización no posee. En una cadena totalmente automatizada, el defecto que sobrevive está en el fichero que el pipeline no abre nunca.&lt;/li&gt;
&lt;li&gt;Inventaría lo que ya mide —CDN, proxy, consola del proveedor— antes de añadir instrumentación. La cifra que te falta suele estar ya registrada.&lt;/li&gt;
&lt;li&gt;Un runbook resuelve, nunca congela: qué instancia está sirviendo, su nombre de contenedor y el id del servicio se piden en el momento.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;puntos-de-vigilancia&quot;&gt;Puntos de vigilancia&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;El fallo peligroso no es el servicio que se detiene, es el que sigue funcionando mientras pierde su capacidad de ser actualizado. No emite nada.&lt;/li&gt;
&lt;li&gt;«Volvió a arrancar» no prueba nada sobre durabilidad. Escribe las preguntas que no respondiste en vez de reclamar una verificación que no hiciste.&lt;/li&gt;
&lt;li&gt;Un defecto que solo puede manifestarse en un reinicio del anfitrión vive lo que dura el intervalo entre dos reinicios. En un servidor que se porta bien, son meses.&lt;/li&gt;
&lt;li&gt;Un registro interno dice cuándo murió un proceso, nunca cuándo dejaron de ser servidos los visitantes. Eso solo lo dice una medición tomada por delante de la pila.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Corrige antes de contar: un caso que describe una debilidad todavía abierta, firmado con tu nombre, no es transparencia: es un manual de instrucciones.&lt;/strong&gt;&lt;/li&gt;
&lt;/ul&gt;
</content>
    </entry>
        <entry>
        <title>Construir un SaaS completo y listo para producción con un agente de código</title>
        <link href="https://mesa.black/es/un-saas-completo-con-un-agente-de-codigo/"/>
        <id>https://mesa.black/es/un-saas-completo-con-un-agente-de-codigo/</id>
        <updated>2026-09-26T02:00:00+02:00</updated>
        <summary>Despliegue sin corte, pagos reales, acceso sin contraseña — en pareja con una IA.</summary>        <content type="html">&lt;p&gt;Cómo diseñamos, aseguramos y desplegamos una plataforma entera — conmutación blue-green sin
corte, domiciliaciones reales, acceso con passkey, sitio trilingüe, copias de seguridad
cifradas — trabajando en pareja con un agente de código.&lt;/p&gt;
&lt;p&gt;El caso detalla la arquitectura elegida, lo que el agente aceleró de verdad y, sobre todo,
los puntos en los que hubo que retomar el control.&lt;/p&gt;
</content>
    </entry>
        <entry>
        <title>Garantizar casos legítimos sin equipo de moderación</title>
        <link href="https://mesa.black/es/legitimidad-sin-moderacion/"/>
        <id>https://mesa.black/es/legitimidad-sin-moderacion/</id>
        <updated>2026-09-25T02:00:00+02:00</updated>
        <summary>Apostar por la identidad verificada en lugar de la censura, y los dos fallos que nos hicieron dudar.</summary>        <content type="html">&lt;p&gt;Una plataforma de casos vale exactamente lo que vale la confianza depositada en lo que allí
se publica. Un solo caso falso y la credibilidad de todo el corpus se tambalea. La pregunta
que nos ocupaba: ¿cómo garantizar la legitimidad de cada publicación, a escala, sin montar
un equipo de moderación — y sin delegar el filtrado en una IA, que juzga la forma de un
texto y no la legitimidad de quien lo publica?&lt;/p&gt;
&lt;p&gt;Nuestra respuesta sustituye la moderación del contenido por la &lt;strong&gt;verificación del emisor&lt;/strong&gt;:
sin empresa, no hay publicación; se exige una sustancia mínima; el número de IVA
intracomunitario se valida en el registro europeo; y todo queda trazado.&lt;/p&gt;
&lt;p&gt;El caso cuenta además las &lt;strong&gt;dos trampas&lt;/strong&gt; que encontramos por el camino, ambas de la misma
familia: un servicio de terceros que responde &lt;code&gt;200 OK&lt;/code&gt; sin haber podido verificar nada, y
después un estado «desconocido» que en realidad cubría dos situaciones opuestas — «no he
podido verificar ahora» y «nunca podré verificar este valor». La segunda dejó pasar
cualquier cadena de caracteres durante meses.&lt;/p&gt;
</content>
    </entry>
    </feed>
