Todos os artigos

Front-end15 min de leitura

Como compartilhar senhas com segurança: o Yush por dentro

Por que mandar senha e token pelo chat é arriscado e como o Yush, o app que eu fiz, cifra tudo no navegador: chave depois do #, AES-GCM, HKDF e link que se autodestrói.

Também em English, Español, Français

Todo time tem esse momento: alguém precisa da senha do banco de staging, da chave de uma API ou do token de um serviço, e ela vai parar no Slack, no WhatsApp ou no Teams. Resolve na hora. E fica lá pra sempre.

Eu fiz o Yush pra esse momento. Você cola o segredo, ganha um link, manda o link. Quem recebe clica, o segredo vai direto pra área de transferência e o link morre. E o mais importante: o servidor do Yush nunca vê o segredo, nem por um instante.

Nesse post eu mostro o app funcionando e explico, com o código de verdade, como isso é possível só com o que o navegador já tem.

A página inicial do Yush, rodando na minha máquina

TL;DR#

  • Senha no chat vira cópia em vários lugares: servidor do app, backup, notificação, histórico. E não expira.
  • No Yush, tudo é cifrado no navegador com a Web Crypto API: AES-GCM-256, HKDF-SHA256 e, com senha extra, PBKDF2 com 600 mil iterações.
  • A chave mora depois do # do link. O navegador nunca manda essa parte da URL numa requisição HTTP.
  • O servidor guarda só o texto cifrado, metadados e hashes de duas provas (linkProof e accessProof).
  • Abrir o link não gasta visualização. Gastar exige um POST, um clique e a prova da chave, então robô de prévia do WhatsApp não queima o segredo.
  • O segredo vai direto pro clipboard e nunca é desenhado na tela.
  • Não é mágica: quem tem o link completo tem o segredo, e malware no computador de quem recebe continua sendo malware.

Por que mandar senha no chat é um problema#

O problema não é o chat ser inseguro. Muitos são cifrados no caminho. O problema é que a mensagem não some. Uma senha mandada no chat vira várias cópias, cada uma com sua própria vida:

A mesma senha, mandada de dois jeitos. No chat ela fica. No Yush ela tem prazo
  • O servidor do app guarda a mensagem. Se o chat não tem criptografia de ponta a ponta (o Slack e o Teams, por exemplo), o próprio serviço consegue ler e, dependendo do plano, quem administra o espaço de trabalho pode exportar.
  • O backup do celular ou da nuvem leva a conversa junto.
  • A notificação mostra a senha na tela bloqueada, pra quem estiver do lado.
  • O histórico e a busca acham a senha meses depois. Pra quem invadir a conta, também.
  • Quem entrar no grupo depois muitas vezes enxerga o histórico.
  • Um print e a senha vira imagem, longe de qualquer controle.

E quase ninguém volta pra apagar. A senha do banco de staging de 2024 continua no canal #dev.

A ideia de um link de uso único resolve isso: o que fica no chat é um link morto. Depois que a pessoa copiou, ou depois do prazo, não há mais nada pra achar.

O Yush em 30 segundos#

Do lado de quem manda, é um campo de texto e três escolhas: quanto tempo o segredo vive (de 1 hora a 30 dias), quantas vezes pode ser copiado (1, 5, 10 ou 25) e as opções extras.

Criando um segredo de teste: 7 dias, 1 visualização e etapa de confirmação

Clicou em enviar, o navegador cifra tudo e devolve o link. O link fica escondido por padrão (de novo: pra não virar print), e dá pra mostrar no ícone do olho:

O link pronto. Tudo depois do # é a chave, e ela só existe aqui

Repare no link. Ele tem duas partes, e a diferença entre elas é o coração do app:

http://localhost:5173/s/317yFlKeQyqSttkkk45_hoqM#k=Tupf9Ege-5H227VRp0wy72E2MPU_SOv_KjX5wUyTAuA
                        └── id do segredo ─────┘ └── chave (32 bytes) ──────────────────────┘

O resto do post é sobre como essas duas partes trabalham.

O servidor não sabe o segredo#

A regra número um do Yush: o texto e a chave existem somente no navegador. O servidor guarda o texto cifrado, metadados que não revelam nada e hashes de duas provas.

O que cruza a rede e o que o servidor guarda. O que está à esquerda nunca sai do navegador

Essa é a requisição que o navegador manda quando você cria um segredo (encurtei os 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
}

Não tem segredo, não tem chave. E o servidor ainda troca as provas pelo SHA-256 delas antes de gravar. Nem o banco tem as provas originais.

Do outro lado, o log do servidor também não guarda nada sensível: só o método, o modelo da rota, o status e o tempo. Uma linha fica assim:

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

A chave mora depois do ##

Essa é a parte mais elegante, e é puro padrão da web: o fragmento da URL (tudo depois do #) não vai nas requisições HTTP. A RFC 3986 define que o fragmento é tratado só por quem está com a página aberta. O navegador pede /s/317yFl... pro servidor e guarda o #k=... pra si.

O id viaja até o servidor. A chave, depois do #, fica no navegador

No código, montar o link é uma linha:

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)}`;
}

A chave são 32 bytes aleatórios do crypto.getRandomValues, em base64url. O id é outra coisa: 18 bytes aleatórios (144 bits), gerados pelo servidor. Adivinhar um id é inviável, e mesmo acertando não adianta, como você vai ver nas provas.

Um cuidado a mais: quando o link abre, o Yush apaga o #k= da barra de endereço com history.replaceState. Assim a chave não fica à vista de quem passa atrás de você, nem na restauração de abas. O preço é que recarregar a página exige abrir o link original de novo.

Uma chave, três derivações#

Com os 32 bytes da chave na mão, o Yush não usa ela direto pra cifrar. Ele deriva três valores diferentes com o HKDF-SHA256, mudando só um rótulo (o info) em cada um:

Da chave do link saem a chave de cifra e as duas provas. A senha extra entra pelo PBKDF2
  • encKey: a chave AES-GCM de 256 bits que cifra o segredo. Ela é criada como não extraível: nem o próprio JavaScript da página consegue ler os bytes dela.
  • linkProof: a prova de que "eu tenho o link". Deriva só da chave do link.
  • accessProof: a prova de que "eu tenho o link e a senha extra" (quando há senha).

Esse é o trecho que faz isso:

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 };
}

(Encurtei pra caber: no arquivo de verdade tem também a checagem do tamanho da chave e um try/finally que zera o ikm.)

A senha extra#

A senha extra é opcional e serve pra um caso específico: o link vazar. Se você manda o link por e-mail e a senha por telefone, quem pegar só o link não copia nada.

Senha de gente é fraca, então ela passa pelo PBKDF2-SHA256 com 600 mil iterações e um sal aleatório de 16 bytes. É o número que a OWASP recomenda pra PBKDF2 com SHA-256. Antes, a senha é normalizada em NFC, pra que um "ã" digitado no Mac e no Windows dê os mesmos bytes.

Por que duas provas#

Essa foi a decisão de desenho que eu mais gosto. As provas resolvem três ataques de uma vez:

  • Quem só conhece o id (num log de proxy, num histórico cortado) não baixa o texto cifrado, não queima o segredo e não apaga: falta o linkProof, que depende de uma chave de 256 bits.
  • Uma senha extra errada é detectada antes de gastar a visualização. O accessProof não confere, o servidor responde 403 e conta a tentativa. Depois de 10 erros, o segredo se autodestrói.
  • Um banco vazado não serve pra nada: ele só tem hashes das provas (não dá pra recriar as provas) e não tem a chave (não dá pra atacar a senha offline).

Cifrar e esconder o tamanho#

A cifra é AES-GCM, com um IV aleatório de 12 bytes por segredo e um dado associado fixo (yush/v1). O GCM, além de cifrar, autentica: se alguém mudar um byte do texto cifrado, a decifragem falha em vez de devolver lixo.

Só que cifrar não esconde o tamanho. Uma senha de 8 caracteres e uma chave privada de 3 mil teriam textos cifrados de tamanhos bem diferentes. Por isso o Yush coloca o segredo num quadro de tamanho fixo antes de cifrar:

frame = u32be(length) ‖ utf8(plaintext) ‖ zeros até a próxima potência de 2 (mín. 256, máx. 32 768 bytes)

O segredo de exemplo dos prints, STRIPE_KEY=sk_test_exemplo_nao_e_real_51Hx9, tem 43 caracteres. O texto cifrado dele tem 272 bytes: o quadro mínimo de 256 mais os 16 da etiqueta do GCM. Uma senha de 8 caracteres daria exatamente o mesmo tamanho.

Aqui entra um problema que pouca gente lembra: robôs abrem links. O WhatsApp, o Slack, o Discord e o Telegram visitam o link pra montar a prévia. Antivírus de e-mail também. Se abrir o link gastasse a visualização, o segredo de uso único morreria antes de chegar na pessoa.

Então, no Yush, abrir e consumir são coisas separadas:

Só o clique gasta visualização. Robô de prévia para no GET
  • A página (GET /s/:id) é só o HTML do app. Ela nem toca no banco.
  • O status (GET /api/secrets/:id/status) só lê: prazo, visualizações restantes e se precisa de senha.
  • Consumir (POST /api/secrets/:id/consume) é o único passo que gasta, e ele exige as duas provas no corpo. Só roda depois de um clique.

Ainda sobra um caso: um scanner que executa JavaScript e clica. Pra esse existe a opção etapa de confirmação, que pede um segundo clique antes de copiar:

Com a etapa de confirmação, copiar pede um segundo clique

No servidor, consumir é atômico: no SQLite com BEGIN IMMEDIATE, no Postgres com SELECT ... FOR UPDATE. Duas pessoas clicando ao mesmo tempo num segredo de uso único não recebem as duas. Eu cobri isso com um teste de 12 threads no SQLite e outro com um pool de 30 conexões no Postgres. E na última visualização a linha é apagada na mesma transação: não sobra nem o registro de que existiu.

Direto pro clipboard, sem passar pela tela#

O segredo nunca é desenhado na tela. Nem em React state, nem num <input> escondido, nem com seleção de texto. Ele vai do resultado da decifragem direto pra área de transferência.

Tem um detalhe de navegador aqui. O Safari só deixa escrever no clipboard se a chamada começar dentro do clique, antes de qualquer await. Mas o segredo ainda nem chegou: falta buscar e decifrar. A saída é o ClipboardItem, que aceita uma 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);
}

(Simplifiquei: no app, o ambiente do clipboard é injetado, pra dar pra testar.)

A página chama isso de forma síncrona no clique, passando a Promise que busca e decifra. O Safari vê o clique, o resto chega depois. Nos outros navegadores, o writeText resolve.

E tem mais dois cuidados que eu acho bonitos:

  • O clipboard é checado antes de gastar. Se o navegador não consegue copiar, o segredo não é consumido.
  • Se o navegador negar a cópia depois do consumo, o app guarda só o texto cifrado na memória por 2 minutos, pra um novo clique, sem gastar outra visualização.
Copiado, e o segredo continua sem aparecer na tela

Pra garantir isso, tem um teste que observa todas as mudanças do DOM com um MutationObserver durante a cópia.

Abrindo o mesmo link de novo, é isso que aparece:

O link depois de usado. O servidor não diz se expirou ou se foi copiado

O "nunca dizemos o motivo" é proposital: o servidor responde o mesmo 404 pra id que não existe, que expirou, que foi consumido, que veio malformado ou com a prova errada. Quem está tentando adivinhar não aprende nada com a resposta.

O servidor também se defende#

Mesmo sem ver o segredo, o servidor tem trabalho:

  • O schema rejeita qualquer campo a mais. Se a requisição de criação chega com um "plaintext" a mais no JSON, a resposta é 400 Invalid request.. Assim, um bug que mande o segredo por engano não chega a gravar nada.
  • Limite de requisições por IP em cada rota.
  • Cabeçalhos rígidos: CSP com script-src 'self' e Trusted Types, frame-ancestors 'none', Referrer-Policy: no-referrer e Cache-Control: no-store. O build não tem nenhum script inline nem de terceiros. Sem analytics.
  • Banco que limpa de verdade: no SQLite, secure_delete zera as páginas apagadas. Expirados nunca são devolvidos e são removidos de tempos em tempos.

O que o Yush não resolve#

Todo app de segurança deveria dizer o que não protege. Esses são os limites do Yush:

  • O link é a credencial. Quem tiver o link completo copia o segredo. Pra defesa extra, use a senha extra e mande por outro canal.
  • O dispositivo de quem recebe. Malware, extensão maliciosa ou gerenciador de clipboard estão fora do alcance de qualquer app web.
  • Um servidor ativamente malicioso poderia servir um JavaScript alterado que manda a chave embora. É o limite de todo app de criptografia de ponta a ponta entregue pela web. Dá pra reduzir com build reproduzível e hashes publicados dos arquivos.
  • Strings do JavaScript não podem ser zeradas. Os buffers de bytes são zerados, mas o texto decifrado é uma string imutável, e quem tira ela da memória é o coletor de lixo.

E alguns trade-offs que eu escolhi conscientemente:

  • O limite de requisições é em memória, por instância. Na Vercel, cada instância da função tem o seu. Pra um limite global, seria preciso Redis ou o firewall da Vercel. A proteção de verdade vem da entropia do id e das provas.
  • Qualquer pessoa com o link pode apagar o segredo (se a opção estiver ligada), inclusive quem recebe. Não há contas, então não há "dono".
  • O status mostra quantas visualizações restam pra quem tem o id. Não revela conteúdo, mas é uma informação.

O que aprendi#

A web já tem o que precisa. O Yush não tem nenhuma biblioteca de criptografia: é tudo crypto.subtle. AES-GCM, HKDF, PBKDF2 e chave não extraível estão em todo navegador moderno.

O # é um canal privado de graça. Saber que o fragmento não vai pro servidor muda o desenho inteiro: dá pra entregar a chave junto com o link sem o servidor ver.

Pense nos robôs. O ataque mais provável a um link de uso único não é um hacker, é a prévia do WhatsApp. Separar "abrir" de "consumir" foi a decisão que fez o app funcionar no mundo real.

Não mostrar também é uma escolha de interface. Mandar direto pro clipboard tira o segredo da tela, dos prints e das extensões que leem a página. E deu mais trabalho do que parece, por causa do Safari.

Escreva o que você não protege. Escrever a lista de limitações me obrigou a pensar em cada ataque e decidir: mitigo, ou assumo e aviso.

Referências#

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

Escrito por

Engenheira de software e designer. Escrevo sobre o que encontro construindo apps, APIs e produtos.