Todos los artículos

Front-end16 min de lectura

Cómo compartir contraseñas de forma segura: Yush por dentro

Por qué enviar contraseñas por chat es riesgoso y cómo Yush, la app que hice, cifra todo en el navegador: clave tras el #, AES-GCM, HKDF y link que se autodestruye.

También en Português, English, Français

Todo equipo tiene ese momento: alguien necesita la contraseña de la base de datos de staging, la clave de una API o el token de un servicio, y termina en Slack, en WhatsApp o en Teams. Resuelve en el momento. Y se queda ahí para siempre.

Hice Yush para ese momento. Pegas el secreto, obtienes un link, envías el link. Quien lo recibe hace clic, el secreto va directo al portapapeles y el link muere. Y lo más importante: el servidor de Yush nunca ve el secreto, ni por un instante.

En este post te muestro la app funcionando y te explico, con el código real, cómo es posible lograrlo solo con lo que el navegador ya trae.

La página de inicio de Yush, corriendo en mi máquina

TL;DR#

  • Una contraseña en el chat se convierte en copias en varios lugares: servidor de la app, backup, notificación, historial. Y no expira.
  • En Yush, todo se cifra en el navegador con la Web Crypto API: AES-GCM-256, HKDF-SHA256 y, con contraseña extra, PBKDF2 con 600 mil iteraciones.
  • La clave vive después del # del link. El navegador nunca envía esa parte de la URL en una petición HTTP.
  • El servidor guarda solo el texto cifrado, metadatos y hashes de dos pruebas (linkProof y accessProof).
  • Abrir el link no gasta visualizaciones. Gastar requiere un POST, un clic y la prueba de la clave, así que el bot de vista previa de WhatsApp no quema el secreto.
  • El secreto va directo al portapapeles y nunca se dibuja en la pantalla.
  • No es magia: quien tiene el link completo tiene el secreto, y el malware en la computadora de quien lo recibe sigue siendo malware.

Por qué enviar contraseñas por chat es un problema#

El problema no es que el chat sea inseguro. Muchos están cifrados en el camino. El problema es que el mensaje no desaparece. Una contraseña enviada por chat se convierte en varias copias, cada una con su propia vida:

La misma contraseña, enviada de dos formas. En el chat se queda. En Yush tiene fecha de vencimiento
  • El servidor de la app guarda el mensaje. Si el chat no tiene cifrado de extremo a extremo (Slack y Teams, por ejemplo), el propio servicio puede leerlo y, según el plan, quien administra el espacio de trabajo puede exportarlo.
  • El backup del celular o de la nube se lleva la conversación.
  • La notificación muestra la contraseña en la pantalla bloqueada, para quien esté al lado.
  • El historial y la búsqueda encuentran la contraseña meses después. Y quien invada la cuenta, también.
  • Quien entre al grupo después muchas veces ve el historial.
  • Una captura de pantalla y la contraseña se vuelve imagen, lejos de cualquier control.

Y casi nadie vuelve a borrarla. La contraseña de la base de staging de 2024 sigue en el canal #dev.

La idea de un link de un solo uso resuelve esto: lo que queda en el chat es un link muerto. Después de que la persona copió, o después del plazo, ya no hay nada que encontrar.

Yush en 30 segundos#

Del lado de quien envía, es un campo de texto y tres opciones: cuánto tiempo vive el secreto (de 1 hora a 30 días), cuántas veces se puede copiar (1, 5, 10 o 25) y las opciones extra.

Creando un secreto de prueba: 7 días, 1 visualización y paso de confirmación

Haces clic en enviar, el navegador cifra todo y te devuelve el link. El link queda oculto por defecto (de nuevo: para que no termine en una captura), y puedes mostrarlo con el ícono del ojo:

El link listo. Todo lo que va después del # es la clave, y solo existe aquí

Fíjate en el link. Tiene dos partes, y la diferencia entre ellas es el corazón de la app:

http://localhost:5173/s/317yFlKeQyqSttkkk45_hoqM#k=Tupf9Ege-5H227VRp0wy72E2MPU_SOv_KjX5wUyTAuA
                        └── id del secreto ────┘ └── clave (32 bytes) ──────────────────────┘

El resto del post trata de cómo trabajan esas dos partes.

El servidor no conoce el secreto#

La regla número uno de Yush: el texto y la clave existen solamente en el navegador. El servidor guarda el texto cifrado, metadatos que no revelan nada y hashes de dos pruebas.

Lo que cruza la red y lo que guarda el servidor. Lo que está a la izquierda nunca sale del navegador

Esta es la petición que manda el navegador cuando creas un secreto (acorté los valores):

{
  "ciphertext": "7TK66-zY5asPtCEXK--_DvCGJeLLwMdJy8oDL_91zke820rv-5oncBwgtUihGL...",
  "iv": "gH3tupn6kX87cn32",
  "kdf": null,
  "linkProof": "bPi5MXkmB3C6Ql2_YC1mRfmUZRg8-74maec5w-XuacM",
  "accessProof": "ygxSepD_0Ut2_37sww4y...",
  "expiresIn": 604800,
  "maxViews": 1,
  "allowImmediateDeletion": true,
  "requireConfirmation": true
}

No hay secreto, no hay clave. Y además el servidor reemplaza las pruebas por su SHA-256 antes de guardarlas. Ni la base de datos tiene las pruebas originales.

Del otro lado, el log del servidor tampoco guarda nada sensible: solo el método, el patrón de la ruta, el status y el tiempo. Una línea se ve así:

{"method":"POST","route":"/api/secrets/:id/consume","statusCode":200,"ms":1,"msg":"request completed"}

La clave vive después del ##

Esta es la parte más elegante, y es puro estándar web: el fragmento de la URL (todo lo que va después del #) no viaja en las peticiones HTTP. La RFC 3986 define que el fragmento lo maneja solo quien tiene la página abierta. El navegador le pide /s/317yFl... al servidor y se guarda el #k=... para sí.

El id viaja hasta el servidor. La clave, después del #, se queda en el navegador

En el código, armar el link es una línea:

src/secret-service/link.ts
// https://host/s/{id}#k={key}: the key lives in the fragment, which browsers never send to servers
export function buildSecretLink(origin: string, id: string, linkKey: Uint8Array): string {
  if (!SECRET_ID_PATTERN.test(id)) throw new RangeError('Invalid secret id');
  return `${origin}/s/${id}#${encodeKeyForURL(linkKey)}`;
}

La clave son 32 bytes aleatorios de crypto.getRandomValues, en base64url. El id es otra cosa: 18 bytes aleatorios (144 bits), generados por el servidor. Adivinar un id es inviable, y aunque aciertes no sirve de nada, como vas a ver en las pruebas.

Un cuidado más: cuando se abre el link, Yush borra el #k= de la barra de direcciones con history.replaceState. Así la clave no queda a la vista de quien pase detrás de ti, ni en la restauración de pestañas. El precio es que recargar la página exige abrir el link original otra vez.

Una clave, tres derivaciones#

Con los 32 bytes de la clave en la mano, Yush no la usa directamente para cifrar. Deriva tres valores distintos con HKDF-SHA256, cambiando solo una etiqueta (el info) en cada uno:

De la clave del link salen la clave de cifrado y las dos pruebas. La contraseña extra entra por PBKDF2
  • encKey: la clave AES-GCM de 256 bits que cifra el secreto. Se crea como no extraíble: ni el propio JavaScript de la página puede leer sus bytes.
  • linkProof: la prueba de que "tengo el link". Deriva solo de la clave del link.
  • accessProof: la prueba de que "tengo el link y la contraseña extra" (cuando hay contraseña).

Este es el fragmento que lo hace:

src/crypto/kdf.ts
export async function deriveSecretKeys(linkKey: Bytes, passphrase: PassphraseInput | null): Promise<SecretKeys> {
  const linkBase = await hkdfBase(linkKey);
  const linkProof = await hkdfBits(linkBase, INFO_LINK_PROOF); // "yush/v1/link-proof"
 
  let ikm: Bytes = linkKey;
  if (passphrase) {
    const stretched = await pbkdf2(passphrase); // PBKDF2-SHA256, 600k iterations
    ikm = new Uint8Array(KEY_BYTES * 2);
    ikm.set(linkKey, 0);
    ikm.set(stretched, KEY_BYTES);
    stretched.fill(0); // wipe the intermediate bytes
  }
 
  const base = passphrase ? await hkdfBase(ikm) : linkBase;
  const encryptionKey = await crypto.subtle.deriveKey(
    { name: 'HKDF', hash: 'SHA-256', salt: HKDF_SALT, info: INFO_ENCRYPTION_KEY },
    base,
    { name: 'AES-GCM', length: 256 },
    false, // non-extractable
    ['encrypt', 'decrypt'],
  );
  const accessProof = await hkdfBits(base, INFO_ACCESS_PROOF);
  return { encryptionKey, linkProof, accessProof };
}

(Lo acorté para que cupiera: el archivo real también tiene la verificación del tamaño de la clave y un try/finally que pone en cero el ikm.)

La contraseña extra#

La contraseña extra es opcional y sirve para un caso específico: que el link se filtre. Si envías el link por correo y la contraseña por teléfono, quien consiga solo el link no copia nada.

Las contraseñas humanas son débiles, así que pasa por PBKDF2-SHA256 con 600 mil iteraciones y una sal aleatoria de 16 bytes. Es el número que la OWASP recomienda para PBKDF2 con SHA-256. Antes, la contraseña se normaliza en NFC, para que una "ñ" escrita en Mac y en Windows dé los mismos bytes.

Por qué dos pruebas#

Esta fue la decisión de diseño que más me gusta. Las pruebas resuelven tres ataques a la vez:

  • Quien solo conoce el id (en un log de proxy, en un historial recortado) no descarga el texto cifrado, no quema el secreto y no lo borra: le falta el linkProof, que depende de una clave de 256 bits.
  • Una contraseña extra incorrecta se detecta antes de gastar la visualización. El accessProof no coincide, el servidor responde 403 y cuenta el intento. Después de 10 errores, el secreto se autodestruye.
  • Una base de datos filtrada no sirve para nada: solo tiene hashes de las pruebas (no se pueden recrear las pruebas) y no tiene la clave (no se puede atacar la contraseña offline).

Cifrar y ocultar el tamaño#

El cifrado es AES-GCM, con un IV aleatorio de 12 bytes por secreto y un dato asociado fijo (yush/v1). GCM, además de cifrar, autentica: si alguien cambia un byte del texto cifrado, el descifrado falla en vez de devolver basura.

Pero cifrar no oculta el tamaño. Una contraseña de 8 caracteres y una clave privada de 3 mil tendrían textos cifrados de tamaños muy distintos. Por eso Yush coloca el secreto en un marco de tamaño fijo antes de cifrar:

frame = u32be(length) ‖ utf8(plaintext) ‖ ceros hasta la siguiente potencia de 2 (mín. 256, máx. 32 768 bytes)

El secreto de ejemplo de las capturas, STRIPE_KEY=sk_test_exemplo_nao_e_real_51Hx9, tiene 43 caracteres. Su texto cifrado tiene 272 bytes: el marco mínimo de 256 más los 16 de la etiqueta de GCM. Una contraseña de 8 caracteres daría exactamente el mismo tamaño.

Aquí aparece un problema que poca gente recuerda: los bots abren links. WhatsApp, Slack, Discord y Telegram visitan el link para armar la vista previa. Los antivirus de correo también. Si abrir el link gastara la visualización, el secreto de un solo uso moriría antes de llegar a la persona.

Entonces, en Yush, abrir y consumir son cosas separadas:

Solo el clic gasta la visualización. El bot de vista previa se detiene en el GET
  • La página (GET /s/:id) es solo el HTML de la app. Ni siquiera toca la base de datos.
  • El status (GET /api/secrets/:id/status) solo lee: plazo, visualizaciones restantes y si necesita contraseña.
  • Consumir (POST /api/secrets/:id/consume) es el único paso que gasta, y exige las dos pruebas en el cuerpo. Solo se ejecuta después de un clic.

Todavía queda un caso: un escáner que ejecuta JavaScript y hace clic. Para eso existe la opción paso de confirmación, que pide un segundo clic antes de copiar:

Con el paso de confirmación, copiar pide un segundo clic

En el servidor, consumir es atómico: en SQLite con BEGIN IMMEDIATE, en Postgres con SELECT ... FOR UPDATE. Dos personas haciendo clic al mismo tiempo en un secreto de un solo uso no lo reciben las dos. Lo cubrí con un test de 12 threads en SQLite y otro con un pool de 30 conexiones en Postgres. Y en la última visualización la fila se borra en la misma transacción: no queda ni el registro de que existió.

Directo al portapapeles, sin pasar por la pantalla#

El secreto nunca se dibuja en la pantalla. Ni en el state de React, ni en un <input> oculto, ni con selección de texto. Va del resultado del descifrado directo al portapapeles.

Aquí hay un detalle de navegador. Safari solo deja escribir en el portapapeles si la llamada empieza dentro del clic, antes de cualquier await. Pero el secreto todavía ni llegó: falta buscarlo y descifrarlo. La salida es ClipboardItem, que acepta una Promise:

src/secret-service/clipboard.ts
export async function writeSecretToClipboard(text: Promise<string>): Promise<void> {
  if (!isClipboardAvailable()) throw new ClipboardUnavailableError();
 
  if (typeof ClipboardItem === 'function' && typeof navigator.clipboard.write === 'function') {
    try {
      const blob = text.then((value) => new Blob([value], { type: 'text/plain' }));
      await navigator.clipboard.write([new ClipboardItem({ 'text/plain': blob })]);
      return;
    } catch {
      await text; // surface the real failure (wrong passphrase, unavailable secret)
    }
  }
  await navigator.clipboard.writeText(await text);
}

(Lo simplifiqué: en la app, el entorno del portapapeles se inyecta, para poder testearlo.)

La página llama a esto de forma síncrona en el clic, pasando la Promise que busca y descifra. Safari ve el clic, el resto llega después. En los otros navegadores, writeText lo resuelve.

Y hay dos cuidados más que me parecen bonitos:

  • El portapapeles se verifica antes de gastar. Si el navegador no puede copiar, el secreto no se consume.
  • Si el navegador niega la copia después del consumo, la app guarda solo el texto cifrado en memoria por 2 minutos, para un nuevo clic, sin gastar otra visualización.
Copiado, y el secreto sigue sin aparecer en la pantalla

Para garantizarlo, hay un test que observa todos los cambios del DOM con un MutationObserver durante la copia.

Si abres el mismo link otra vez, esto es lo que aparece:

El link después de usarse. El servidor no dice si expiró o si fue copiado

El "nunca decimos el motivo" es a propósito: el servidor responde el mismo 404 para un id que no existe, que expiró, que fue consumido, que llegó malformado o con la prueba incorrecta. Quien intenta adivinar no aprende nada con la respuesta.

El servidor también se defiende#

Aunque no vea el secreto, el servidor tiene trabajo:

  • El schema rechaza cualquier campo de más. Si la petición de creación llega con un "plaintext" de más en el JSON, la respuesta es 400 Invalid request.. Así, un bug que envíe el secreto por error ni llega a guardar nada.
  • Límite de peticiones por IP en cada ruta.
  • Cabeceras estrictas: CSP con script-src 'self' y Trusted Types, frame-ancestors 'none', Referrer-Policy: no-referrer y Cache-Control: no-store. El build no tiene ningún script inline ni de terceros. Sin analytics.
  • Una base de datos que limpia de verdad: en SQLite, secure_delete pone en cero las páginas borradas. Los expirados nunca se devuelven y se eliminan cada cierto tiempo.

Lo que Yush no resuelve#

Toda app de seguridad debería decir lo que no protege. Estos son los límites de Yush:

  • El link es la credencial. Quien tenga el link completo copia el secreto. Para una defensa extra, usa la contraseña extra y envíala por otro canal.
  • El dispositivo de quien recibe. Malware, extensiones maliciosas o gestores de portapapeles están fuera del alcance de cualquier app web.
  • Un servidor activamente malicioso podría servir un JavaScript alterado que envíe la clave a otro lado. Es el límite de toda app de cifrado de extremo a extremo entregada por la web. Se puede reducir con builds reproducibles y hashes publicados de los archivos.
  • Los strings de JavaScript no se pueden poner en cero. Los buffers de bytes se ponen en cero, pero el texto descifrado es un string inmutable, y quien lo saca de la memoria es el recolector de basura.

Y algunos trade-offs que elegí conscientemente:

  • El límite de peticiones está en memoria, por instancia. En Vercel, cada instancia de la función tiene el suyo. Para un límite global haría falta Redis o el firewall de Vercel. La protección de verdad viene de la entropía del id y de las pruebas.
  • Cualquier persona con el link puede borrar el secreto (si la opción está activada), incluida quien lo recibe. No hay cuentas, así que no hay "dueño".
  • El status muestra cuántas visualizaciones quedan a quien tiene el id. No revela contenido, pero es información.

Lo que aprendí#

La web ya tiene lo que necesita. Yush no tiene ninguna librería de criptografía: todo es crypto.subtle. AES-GCM, HKDF, PBKDF2 y claves no extraíbles están en todo navegador moderno.

El # es un canal privado gratis. Saber que el fragmento no va al servidor cambia todo el diseño: puedes entregar la clave junto con el link sin que el servidor la vea.

Piensa en los bots. El ataque más probable a un link de un solo uso no es un hacker, es la vista previa de WhatsApp. Separar "abrir" de "consumir" fue la decisión que hizo que la app funcionara en el mundo real.

No mostrar también es una decisión de interfaz. Enviar directo al portapapeles saca el secreto de la pantalla, de las capturas y de las extensiones que leen la página. Y dio más trabajo de lo que parece, por culpa de Safari.

Escribe lo que no proteges. Escribir la lista de limitaciones me obligó a pensar en cada ataque y decidir: lo mitigo, o lo asumo y aviso.

Referencias#

  • Front-end
  • seguridad
  • criptografia
  • web-crypto
  • react
  • typescript

Escrito por

Ingeniera de software y diseñadora. Escribo sobre lo que encuentro construyendo apps, APIs y productos.