Criptografar AES para Base64

Como criptografar texto com senha

1. Mantenha Criptografar e o tipo de chave Senha selecionados.
2. Digite uma Senha. Mostrar senha a exibe enquanto você digita. Deixe Iterações do PBKDF2 em 310.000, a menos que tenha um motivo; quem for descriptografar precisa digitar o mesmo número.
3. Digite a mensagem em Texto simples e clique em Criptografar, ou aperte Enter no campo da senha, ou Ctrl+Enter no texto.
4. Copie o Base64 criptografado ou baixe-o. Marque Saída URL-safe (- _ , sem =) se a string for para uma URL.

Abaixo da saída, a ferramenta mostra um detalhamento: tamanhos do salt, do IV, do texto cifrado e da tag, o total e a derivação de chave usada. Para enviar o resultado, mande o Base64 numa mensagem e a senha por outro canal, como uma ligação ou outro app de chat. O destinatário abre o descriptografar AES e faz o caminho inverso.

Para que serve esta ferramenta

Esta ferramenta serve para compartilhar um trecho de texto com segurança quando não existe canal melhor: a senha do Wi-Fi para uma visita, um código de recuperação enviado a um colega, uma anotação colada num chamado que gente demais consegue ler. Ela troca o “vou mandar pelo chat mesmo” por algo que um bisbilhoteiro não consegue ler.

Ela não é um gerenciador de segredos. Ela não armazena nada, não controla quem tem acesso, não registra quem descriptografou o quê, não faz rotação de chaves nem revoga um segredo depois de enviado. Credenciais de aplicações, chaves de produção e tudo o que é compartilhado por uma equipe devem ficar num gerenciador de segredos de verdade ou num gerenciador de senhas com compartilhamento. Lembre também que o texto criptografado continua descriptografável para sempre por qualquer um que venha a descobrir a senha.

O formato exato

No modo senha, a saída é:

Base64( salt[16] ‖ iv[12] ‖ ciphertext ‖ tag[16] )

• Chave: PBKDF2-HMAC-SHA256 sobre a senha em UTF-8, com o salt de 16 bytes e 310.000 iterações, gerando 32 bytes.
• Cifra: AES-256-GCM com o IV de 12 bytes, tag de 128 bits e sem dados associados.
• Aleatoriedade: um salt e um IV novos a cada criptografia, vindos de crypto.getRandomValues.

O texto cifrado tem exatamente o comprimento da mensagem em UTF-8, então o blob tem 44 bytes de acréscimo. Uma mensagem de 33 bytes vira 77 bytes, ou seja, 104 caracteres Base64. Não há byte de versão, e o número de iterações não é armazenado: se você o alterar, o destinatário precisa digitar o mesmo valor, senão a descriptografia falha com o mesmo erro de uma senha errada.

No modo Chave bruta, a etapa do PBKDF2 desaparece e a saída é Base64( iv[12] ‖ ciphertext ‖ tag[16] ), criptografada com sua chave de 16, 24 ou 32 bytes informada em Base64 ou hex. Gerar chave aleatória cria uma. Chrome e Edge não suportam chaves AES de 192 bits, e a ferramenta avisa isso em vez de falhar em silêncio; use 128 ou 256 bits.

Descriptografando em Python ou Node.js

O destinatário não precisa deste site. Com Python e o pacote cryptography (pip install cryptography):

import base64, os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes

def _key(password, salt):
    return PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=salt,
                      iterations=310000).derive(password.encode("utf-8"))

def decrypt(b64, password):
    data = base64.b64decode(b64)
    salt, iv, ct = data[:16], data[16:28], data[28:]
    return AESGCM(_key(password, salt)).decrypt(iv, ct, None).decode("utf-8")

def encrypt(text, password):
    salt, iv = os.urandom(16), os.urandom(12)
    ct = AESGCM(_key(password, salt)).encrypt(iv, text.encode("utf-8"), None)
    return base64.b64encode(salt + iv + ct).decode("ascii")

O AESGCM.decrypt espera a tag no fim do texto cifrado, que é onde este formato a coloca. No Node.js, a tag precisa ser separada e passada à parte:

const crypto = require("crypto");

function decrypt(b64, password) {
  const data = Buffer.from(b64, "base64");
  const salt = data.subarray(0, 16), iv = data.subarray(16, 28);
  const tag = data.subarray(data.length - 16), ct = data.subarray(28, data.length - 16);
  const key = crypto.pbkdf2Sync(password, salt, 310000, 32, "sha256");
  const d = crypto.createDecipheriv("aes-256-gcm", key, iv);
  d.setAuthTag(tag);
  return Buffer.concat([d.update(ct), d.final()]).toString("utf8");
}

Os blobs desta página descriptografam com as duas funções, e os blobs gerados por encrypt() descriptografam nesta página. Se você usou a saída URL-safe, o Buffer.from(b64, "base64") do Node a lê como está; no Python, use base64.urlsafe_b64decode(b64 + "=" * (-len(b64) % 4)). O openssl enc não ajuda aqui, porque não suporta GCM. As páginas de Python e Node.js tratam o lado do Base64 com mais profundidade.

Perguntas frequentes