Cifrar con AES a Base64

Cómo cifrar un texto con contraseña

1. Deja seleccionados Cifrar y el tipo de clave Contraseña.
2. Escribe una Contraseña. Mostrar contraseña la deja visible mientras escribes. Deja Iteraciones de PBKDF2 en 310.000 salvo que tengas un motivo; quien descifre tendrá que introducir el mismo número.
3. Escribe el mensaje en Texto plano y pulsa Cifrar, o Enter en el campo de la contraseña, o Ctrl+Enter en el texto.
4. Copia el Base64 cifrado o descárgalo. Marca Salida URL-safe (- _ , sin =) si la cadena va a ir en una URL.

Debajo de la salida, la herramienta muestra un desglose: los tamaños del salt, el IV, el texto cifrado y la etiqueta, el total y la derivación de clave usada. Para enviar el resultado, manda el Base64 en un mensaje y la contraseña por otro canal, como una llamada o una aplicación de chat distinta. El destinatario abre Descifrar AES y hace el proceso inverso.

Para qué sirve esta herramienta

Esta herramienta sirve para compartir un texto de forma segura cuando no hay un canal mejor: la contraseña del Wi-Fi para un invitado, un código de recuperación para un compañero, una nota pegada en un ticket que lee demasiada gente. Sustituye el «te lo mando por el chat y ya» por algo que nadie que intercepte el mensaje puede leer.

No es un gestor de secretos. No guarda nada, no controla quién tiene acceso, no registra quién descifró qué, no rota claves ni revoca un secreto ya enviado. Las credenciales de aplicaciones, las claves de producción y todo lo que se comparte en un equipo deben ir en un gestor de secretos de verdad o en un gestor de contraseñas con opción de compartir. Ten en cuenta también que el texto cifrado se puede descifrar para siempre por cualquiera que conozca la contraseña más adelante.

El formato exacto

En modo contraseña, la salida es:

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

• Clave: PBKDF2-HMAC-SHA256 sobre la contraseña en UTF-8, con el salt de 16 bytes y 310.000 iteraciones, que produce 32 bytes.
• Cifrado: AES-256-GCM con el IV de 12 bytes, una etiqueta de 128 bits y sin datos asociados.
• Aleatoriedad: un salt y un IV nuevos en cada cifrado, obtenidos de crypto.getRandomValues.

El texto cifrado mide exactamente lo mismo que el mensaje en UTF-8, así que el bloque añade 44 bytes. Un mensaje de 33 bytes se convierte en 77 bytes, es decir, 104 caracteres Base64. No hay byte de versión y el número de iteraciones no se guarda: si lo cambias, el destinatario tiene que escribir el mismo valor o el descifrado fallará con el mismo error que una contraseña incorrecta.

En modo Clave sin procesar desaparece el paso de PBKDF2 y la salida es Base64( iv[12] ‖ ciphertext ‖ tag[16] ), cifrada con tu clave de 16, 24 o 32 bytes en Base64 o hex. Generar clave aleatoria crea una. Chrome y Edge no admiten claves AES de 192 bits, y la herramienta lo avisa en lugar de fallar sin decir nada; usa 128 o 256 bits.

Cómo descifrarlo en Python o Node.js

El destinatario no necesita esta web. Con Python y el paquete 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")

AESGCM.decrypt espera la etiqueta al final del texto cifrado, que es justo donde la pone este formato. En Node.js hay que separar la etiqueta y pasarla aparte:

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

Los bloques generados en esta página se descifran con ambas funciones, y los de encrypt() se descifran en esta página. Si usaste la salida URL-safe, Buffer.from(b64, "base64") de Node la lee tal cual; en Python usa base64.urlsafe_b64decode(b64 + "=" * (-len(b64) % 4)). Ten en cuenta que openssl enc no sirve aquí, porque no admite GCM. Las páginas de Python y Node.js tratan la parte de Base64 con más detalle.

Preguntas frecuentes