Cifra archivos con AES-256-GCM en tu navegador

Cifrar un archivo con AES-256-GCM en tu navegador es convertir el archivo en texto cifrado en tu propia máquina, con una clave derivada de una contraseña que tú eliges, antes de que el archivo vaya a ningún sitio: a una unidad en la nube, a un adjunto de correo, a una memoria USB. El cifrado se ejecuta en la página, con WebCrypto, y el archivo y la contraseña nunca salen del navegador. Eso importa porque un archivo no es como un mensaje que puedes volver a escribir: es el secreto mismo. Un chat puede describir AES-GCM, pero no puede cifrar tu archivo real, y pegar el archivo en un chat o subirlo a un sitio cualquiera que dice "cifrar en línea" para que lo cifre es entregar el texto plano a un desconocido. Puedes cifrar y descifrar archivos en el Cifrador de archivos, por completo en tu navegador, sin límite de tamaño.

Tu archivo es el secreto: no lo pegues nunca en un chat ni lo subas a un sitio cualquiera

La gente es cuidadosa con las contraseñas y descuidada con los archivos, y los archivos son la fuga peor. Una contraseña se puede cambiar; un archivo, una vez leído, no se puede dejar de leer. Una declaración de impuestos, un borrador de contrato, un escaneo del documento de identidad, una carpeta de fotos familiares: cada uno lleva información que sigue siendo sensible durante años, y una vez que una copia sale de tu máquina no puedes recuperarla. Esa es la primera regla de este artículo: no pegues nunca un archivo en un chat, y no lo subas a ningún sitio cuya única credencial sea decir "cifrar en línea". El servicio que cifra tu archivo por ti ha visto, por definición, el texto plano. Si lo vulneran, lo venden o simplemente registra las subidas, el cifrado que aplica después es decoración.

El cifrado local en el navegador invierte ese orden. El archivo lo lee la página, se cifra bloque a bloque en tu máquina, y solo el texto cifrado sale de ella: a tu carpeta de descargas, y de ahí a donde tú decidas ponerlo. El sitio nunca recibe el archivo, la contraseña ni la clave, porque no hay ningún servidor que pueda recibirlos: la herramienta es una página estática. La misma lógica explica por qué esta herramienta existe en lugar de ser una respuesta de un chatbot. Un chatbot puede explicar AES-GCM a la perfección y aun así no puede cifrar tu archivo real, y en el momento en que pegas el archivo para que lo haga, has entregado el texto plano justo a la parte de la que intentabas protegerlo. Si un flujo de trabajo necesita el archivo mismo, el trabajo tiene que hacerse donde el archivo ya está: en tu máquina.

AES-256-GCM en lenguaje sencillo: una clave, una comprobación nueva en cada bloque

AES-256-GCM son dos garantías en un solo algoritmo, y ambas importan para los archivos. La parte "AES-256" es el cifrado: una clave de 256 bits revuelve cada bloque de datos tan a fondo que, con una clave que nadie puede adivinar, el texto cifrado no revela nada del texto plano. La parte "GCM" es la autenticación: para cada bloque del archivo, el algoritmo calcula una etiqueta de 16 bytes que es una huella de ese bloque, su posición y la clave. El descifrado vuelve a calcular la etiqueta y la compara; si un solo byte cambió — un bit invertido en tránsito, una contraseña equivocada, un bloque intercambiado con el de otro archivo — la etiqueta no coincide y el descifrado se niega, en lugar de entregarte en silencio datos corruptos.

Esa segunda garantía es la razón por la que GCM supera al modo CBC, más antiguo, para archivos, y merece la pena entender la diferencia. CBC cifra cada bloque encadenado al anterior, pero no tiene ninguna forma integrada de saber si el texto cifrado fue manipulado: un atacante que puede invertir bits en un archivo CBC puede cambiar la salida descifrada de formas predecibles, y los clásicos ataques de oráculo de relleno contra CBC explotan exactamente esa debilidad. Con CBC necesitas un HMAC aparte para detectar la manipulación, y acertar con esa construcción es donde las implementaciones fallan. GCM incorpora la comprobación: cada bloque lleva su propia etiqueta, verificada antes de confiar en su texto plano, así que no hay un segundo mecanismo que acoplar ni relleno que atacar. Una clave, un algoritmo, confidencialidad y autenticación juntas.

¿Contraseña o par de claves? Cuándo una contraseña compartida es la herramienta adecuada

Hay dos formas honestas de cifrar un archivo para otra persona, y resuelven problemas distintos. Una contraseña es un secreto compartido: tú y el destinatario la acordáis — idealmente por otro canal, en persona o por un medio por el que el archivo mismo no viajará — y el archivo lo puede abrir cualquiera que la conozca. Un par de claves, el modelo PGP, es asimétrico: cifras con la clave pública del destinatario, solo su clave privada lo abre, y nadie necesita acordar un secreto de antemano. El par de claves gana cuando no puedes compartir un secreto con seguridad, cuando el destinatario debe ser exactamente una persona, y cuando quieres firmas que prueben quién envió el archivo. Pierde en configuración: claves que generar, guardar, respaldar y revocar, y un destinatario que ya debe tener un par.

La contraseña gana siempre que el coste de configuración de un par de claves es la razón por la que el cifrado no se hace en absoluto, que para la mayoría de las personas y de los archivos es el caso común. Un archivo para tu yo futuro, una copia de seguridad en un disco en el que no confías del todo, un documento para un colega al que puedes entregar la contraseña en persona: eso no necesita ninguna infraestructura de claves, solo una contraseña fuerte y un formato que el destinatario pueda abrir. Usa el Cifrador de archivos para esos casos. Cuando el destinatario es un desconocido, cuando el archivo debe ser atribuible a ti, o cuando necesitas cifrar para varias personas sin compartir un secreto entre ellas, usa la Suite PGP: es el mismo sitio, la misma regla de todo en el navegador, y la herramienta adecuada para mensajes e identidad. Elegir la herramienta de contraseña cuando necesitabas la de par de claves es un error real; elegir la de par de claves y luego no cifrar nunca nada porque la configuración te venció es el error más común.

Por qué otras herramientas limitan los archivos a 10 MB, y cómo la transmisión elimina el límite

Si alguna vez has intentado cifrar un archivo en línea, te has topado con el límite: 10 MB, a veces menos, y todo lo más grande se rechaza. El límite no es tacañería. La mayoría de las herramientas leen el archivo entero en memoria, lo cifran de una pasada, guardan todo el texto cifrado en memoria y luego lo ofrecen como descarga: cuatro copias de un archivo grande en RAM a la vez, más los límites propios del navegador sobre el tamaño de un solo blob en memoria. Un vídeo de 2 GB necesitaría gigabytes de memoria para cifrarse así, y en una máquina modesta simplemente falla. Así que la herramienta limita la entrada a un tamaño que puede soportar, y los archivos grandes se quedan sin cifrar.

La solución es dejar de sostener el archivo entero a la vez. El cifrador lee el archivo en trozos de 1 MiB, cifra un trozo, escribe su texto cifrado, y olvida el trozo antes de leer el siguiente: la memoria máxima se mantiene cerca de un megabyte sin importar lo grande que sea el archivo. En Chromium y Edge, la salida pasa por la API de acceso al sistema de archivos, así que cada bloque cifrado se escribe en disco en cuanto se produce: transmisión real, sin almacenar el archivo entero en ningún punto del proceso. Firefox y Safari todavía no ofrecen esa API, así que allí los bloques se reúnen en una descarga al final: la página lo dice claramente, y para archivos muy grandes en esos navegadores el consejo honesto es usar un navegador Chromium para el trabajo. El tamaño de bloque de 1 MiB lo fija el formato de archivo, no es un ajuste: es lo que el descifrador espera, y mantenerlo fijo es lo que hace que cada archivo que produce esta herramienta sea legible por cualquier otra implementación del formato.

El formato, documentado: tu archivo no queda encerrado en este sitio

Un archivo cifrado que no puedes abrir sin el sitio web que lo creó es un rehén, no una copia de seguridad. Por eso el formato del contenedor está documentado por completo en la página de la herramienta, y esta sección es la versión corta. Un archivo .sysxenc empieza con los ocho bytes mágicos SYSXENC1, luego una longitud de cabecera de dos bytes, luego una cabecera JSON: la versión del formato, el nombre del KDF y el número de iteraciones, una sal aleatoria de 16 bytes, el tamaño de bloque de 1 MiB, el nombre original del archivo, el tamaño del texto plano, el SHA-256 del texto plano y una marca de tiempo. El cuerpo es una secuencia de bloques, cada uno con una longitud de texto cifrado de cuatro bytes, un IV aleatorio nuevo de 12 bytes y el texto cifrado con su etiqueta GCM de 16 bytes. La clave procede de tu contraseña mediante PBKDF2-SHA-256 con 600.000 iteraciones, el número que OWASP recomienda, y cada bloque se autentica con datos adicionales que lo atan a este archivo y a su posición: los bytes exactos de la cabecera más el índice del bloque, de modo que un bloque reordenado o injertado desde otro archivo no supera su comprobación de etiqueta.

El sentido de escribir todo esto es que cualquiera puede implementar un lector, y el descifrador en Python de abajo es la prueba. Usa solo la biblioteca estándar más el paquete cryptography, lee la cabecera, vuelve a derivar la clave, descifra bloque a bloque verificando cada etiqueta, y por último comprueba el SHA-256 del texto plano: exactamente lo que hace la herramienta del navegador. Se ejecutó con archivos producidos en este formato, incluido un archivo de varios megabytes, un archivo vacío, una contraseña equivocada y un archivo manipulado, y se comportó correctamente en cada caso. Una limitación honesta: la línea de comandos de OpenSSL no puede descifrar este formato por bloques directamente, porque no tiene forma de expresar los IV por bloque, los datos autenticados adicionales ni las etiquetas. Es una propiedad del diseño del formato, no un secreto, y este artículo no fingirá lo contrario: usa el script de abajo, o cualquier implementación de AES-GCM.

Los modos de fallo: de lo que el cifrado no puede salvarte

El primer modo de fallo es el que la herramienta advierte con más insistencia, porque no tiene solución: si pierdes la contraseña, el archivo se pierde. No hay recuperación, no hay enlace de "olvidé mi contraseña", no hay clave maestra guardada en ningún sitio: la clave se deriva de tu contraseña y de nada más, y sin ella el texto cifrado es indistinguible de bytes aleatorios. Anota la contraseña en un lugar seguro, separado del archivo, antes de borrar el original. El segundo modo de fallo es una contraseña débil. PBKDF2 con 600.000 iteraciones ralentiza los intentos, pero no puede hacer fuerte a "password123": un atacante que consiga el archivo puede adivinar sin conexión, tan rápido como su hardware lo permita, sin ningún servidor que lo bloquee. Usa una frase larga que puedas recordar, no una contraseña corta que puedas teclear rápido.

El tercer y cuarto modo de fallo tratan de lo que el cifrado no cubre. La cabecera guarda el nombre original del archivo, el tamaño y la hora de creación en claro: el contenido es secreto, los metadatos no. Si el propio nombre del archivo es sensible, cambia el nombre antes de cifrar, y considera pasarlo antes por el Limpiador de documentos, ya que los documentos llevan sus propios metadatos dentro: nombres de autor, historial de edición, miniaturas incrustadas. Y ningún cifrado ayuda en un dispositivo comprometido. Si la máquina en la que cifras ya ejecuta malware, puede leer el archivo antes del cifrado y la contraseña mientras la escribes. El cifrado protege un archivo en tránsito y en reposo; no protege un archivo en una máquina que ya está en manos de otro. Eso no es razón para saltarse el cifrado: es la razón para saber exactamente qué te compra.

Descifra un archivo .sysxenc con Python

#!/usr/bin/env python3
"""Decrypt a SYSXENC v1 file produced by the SysOSX file encryptor.

Format (SYSXENC v1), as documented at
https://www.sysosx.com/tools/file-encryptor/ :
  header: 8-byte magic b"SYSXENC1", u16BE header length, header JSON bytes
          {"v": 1, "kdf": "PBKDF2-SHA256", "iter": 600000,
           "salt": <base64, 16 bytes>, "chunkSize": 1048576,
           "name": <original filename>, "size": <plaintext bytes>,
           "sha256": <hex of plaintext>, "created": <ISO timestamp>}
  body:   chunks, each u32BE ciphertext length (ciphertext INCLUDING the
          16-byte GCM tag) + 12-byte random IV + ciphertext+tag.
          The last chunk may be shorter; an empty file has zero chunks.
  AAD per chunk: the exact header JSON bytes + u32LE chunk index.
  KDF: PBKDF2-HMAC-SHA-256, 600,000 iterations, 256-bit key.

Requires the `cryptography` package:  pip install cryptography

Note: OpenSSL's command-line tool cannot decrypt this chunked format
directly — it has no way to express per-chunk IVs, AAD, and tags — so
use this script (or any AES-GCM implementation) instead.

Usage:
  python3 sysxenc_decrypt.py encrypted.sysxenc decrypted.bin
  python3 sysxenc_decrypt.py encrypted.sysxenc decrypted.bin --password hunter2
  (without --password, the password is read securely from the terminal)
"""

import argparse
import base64
import getpass
import hashlib
import json
import struct
import sys

MAGIC = b"SYSXENC1"
HEADER_LEN_FMT = ">H"   # u16 big-endian
CHUNK_LEN_FMT = ">I"    # u32 big-endian
CHUNK_INDEX_FMT = "<I"  # u32 little-endian
IV_LEN = 12
TAG_LEN = 16
KEY_LEN = 32


def _read_exact(f, n, what):
    data = f.read(n)
    if len(data) != n:
        raise ValueError(f"truncated file: could not read {what}")
    return data


def decrypt_file(in_path, out_path, password):
    with open(in_path, "rb") as f:
        magic = _read_exact(f, 8, "magic")
        if magic != MAGIC:
            raise ValueError(
                f"bad magic {magic!r}: not a SYSXENC v1 file")
        (header_len,) = struct.unpack(
            HEADER_LEN_FMT, _read_exact(f, 2, "header length"))
        header_bytes = _read_exact(f, header_len, "header JSON")
        header = json.loads(header_bytes.decode("utf-8"))
        if header.get("v") != 1:
            raise ValueError(
                f"unsupported format version: {header.get('v')!r}")
        if header.get("kdf") != "PBKDF2-SHA256":
            raise ValueError(
                f"unsupported KDF: {header.get('kdf')!r}")
        iterations = int(header["iter"])
        salt = base64.b64decode(header["salt"])
        chunk_size = int(header["chunkSize"])
        expected_size = int(header["size"])
        expected_sha256 = header["sha256"]

        key = hashlib.pbkdf2_hmac(
            "sha256", password.encode("utf-8"), salt, iterations, KEY_LEN)

        # Imported here so a bad file fails fast with a format error,
        # not an ImportError.
        from cryptography.hazmat.primitives.ciphers.aead import AESGCM

        aesgcm = AESGCM(key)
        hasher = hashlib.sha256()
        written = 0
        index = 0
        with open(out_path, "wb") as out:
            while True:
                len_bytes = f.read(4)
                if len(len_bytes) == 0:
                    break  # end of body
                if len(len_bytes) != 4:
                    raise ValueError(
                        f"truncated file: chunk {index} length field")
                (ct_len,) = struct.unpack(CHUNK_LEN_FMT, len_bytes)
                iv = _read_exact(f, IV_LEN, f"chunk {index} IV")
                ct_and_tag = _read_exact(
                    f, ct_len, f"chunk {index} ciphertext")
                aad = header_bytes + struct.pack(CHUNK_INDEX_FMT, index)
                try:
                    plain = aesgcm.decrypt(iv, ct_and_tag, aad)
                except Exception as exc:
                    raise ValueError(
                        f"chunk {index} failed authentication: "
                        "wrong password or tampered file") from exc
                out.write(plain)
                hasher.update(plain)
                written += len(plain)
                index += 1

        if written != expected_size:
            raise ValueError(
                f"size mismatch: header says {expected_size} bytes, "
                f"decrypted {written}")
        if hasher.hexdigest() != expected_sha256:
            raise ValueError(
                "SHA-256 mismatch: decrypted content does not match "
                "the header digest (file tampered or corrupt)")
        return header


def main(argv=None):
    parser = argparse.ArgumentParser(
        description="Decrypt a SYSXENC v1 (.sysxenc) file.")
    parser.add_argument("input", help="encrypted .sysxenc file")
    parser.add_argument("output", help="where to write the plaintext")
    parser.add_argument("--password",
                        help="password (if omitted, prompted securely)")
    args = parser.parse_args(argv)
    password = args.password
    if password is None:
        password = getpass.getpass("Password: ")
    try:
        header = decrypt_file(args.input, args.output, password)
    except (ValueError, OSError, KeyError) as exc:
        print(f"error: {exc}", file=sys.stderr)
        return 1
    print(f"decrypted {header.get('name', args.input)} "
          f"({header['size']} bytes, {header['sha256'][:12]}..., "
          f"SHA-256 verified)")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Fuentes

Preguntas frecuentes

¿Mi archivo o mi contraseña salen alguna vez de mi navegador?

No. El cifrado se ejecuta en la página con la API WebCrypto, el archivo se lee en trozos de 1 MiB en tu máquina, y la contraseña solo se usa para derivar la clave localmente. No hay ningún paso de subida, no hay servidor, no hay cuenta: la herramienta es una página estática. Lo único que sale del navegador es el texto cifrado, cuando lo descargas. Si quieres confirmarlo, abre la pestaña de red de tu navegador mientras cifras: no verás ninguna petición que lleve el archivo.

¿Qué pasa si olvido la contraseña?

El archivo es irrecuperable. La clave se deriva de tu contraseña mediante PBKDF2 y de nada más: no hay copia de la contraseña, no hay clave de recuperación, y el sitio no tiene forma de restablecerla, porque nunca la ve. Una contraseña equivocada no produce un archivo corrupto: el descifrado falla su comprobación de autenticación y te lo dice, sin escribir ninguna salida. Guarda la contraseña en un lugar seguro, separada del archivo cifrado, antes de borrar el original.

¿Puedo descifrar un archivo .sysxenc sin este sitio web?

Sí. El formato SYSXENC v1 está documentado por completo en la página de la herramienta: disposición de la cabecera, disposición de los bloques, la regla de AAD y los parámetros del KDF, y el descifrador en Python de este artículo lo implementa con la biblioteca estándar más el paquete cryptography. Se verificó con archivos producidos por la herramienta. Lo único que no puedes usar es la línea de comandos de OpenSSL: no tiene forma de expresar los IV por bloque, el AAD y las etiquetas, así que no puede descifrar este formato por bloques directamente.