Chiffrer des fichiers avec AES-256-GCM dans votre navigateur
Dernière mise à jour:
Chiffrer un fichier avec AES-256-GCM dans votre navigateur, c’est transformer le fichier en texte chiffré sur votre propre machine, avec une clé dérivée d’un mot de passe que vous choisissez, avant que le fichier n’aille nulle part — vers un disque en nuage, une pièce jointe, une clé USB. Le chiffrement s’exécute dans la page, avec WebCrypto, et le fichier comme le mot de passe ne quittent jamais le navigateur. Cela compte parce qu’un fichier n’est pas comme un message que l’on peut retaper : il est le secret lui-même. Une conversation peut décrire AES-GCM, mais elle ne peut pas chiffrer votre vrai fichier, et coller le fichier dans une conversation ou le téléverser sur un site quelconque qui promet de « chiffrer en ligne » pour qu’il le chiffre, c’est remettre le texte clair à un inconnu. Vous pouvez chiffrer et déchiffrer des fichiers dans le Chiffreur de fichiers, entièrement dans votre navigateur, sans limite de taille.
Votre fichier est le secret — ne le collez jamais dans une conversation, ne le téléversez jamais sur un site quelconque
Les gens sont prudents avec leurs mots de passe et négligents avec leurs fichiers, et les fichiers sont la pire fuite. Un mot de passe peut se changer ; un fichier, une fois lu, ne peut pas être « délu ». Une déclaration d’impôts, un brouillon de contrat, un scan de pièce d’identité, un dossier de photos de famille — chacun porte des informations qui restent sensibles pendant des années, et une fois qu’une copie quitte votre machine, vous ne pouvez pas la rappeler. C’est la première règle de cet article : ne collez jamais un fichier dans une conversation, et ne le téléversez jamais sur un site dont le seul titre de confiance est la phrase « chiffrer en ligne ». Le service qui chiffre votre fichier pour vous a, par définition, vu le texte clair. S’il est piraté, vendu, ou s’il se contente d’enregistrer les téléversements, le chiffrement qu’il applique ensuite n’est que de la décoration.
Le chiffrement local dans le navigateur inverse cet ordre. Le fichier est lu par la page, chiffré bloc par bloc sur votre machine, et seul le texte chiffré en sort — vers votre dossier de téléchargements, puis vers l’endroit où vous décidez de le mettre. Le site ne reçoit jamais le fichier, le mot de passe ni la clé, parce qu’il n’y a aucun serveur pour les recevoir : l’outil est une page statique. La même logique explique pourquoi cet outil existe au lieu d’être une réponse de chatbot. Un chatbot peut expliquer AES-GCM parfaitement et pourtant ne pas chiffrer votre vrai fichier, et au moment où vous collez le fichier pour qu’il le fasse, vous avez remis le texte clair à la partie même dont vous tentiez de le protéger. Si un flux de travail a besoin du fichier lui-même, le travail doit se faire là où le fichier se trouve déjà — sur votre machine.
AES-256-GCM en langage simple : une clé, une vérification neuve à chaque bloc
AES-256-GCM réunit deux garanties dans un seul algorithme, et les deux comptent pour les fichiers. La partie « AES-256 » est le chiffrement : une clé de 256 bits brouille chaque bloc de données si profondément qu’avec une clé que personne ne peut deviner, le texte chiffré ne révèle rien du texte clair. La partie « GCM » est l’authentification : pour chaque bloc du fichier, l’algorithme calcule une étiquette de 16 octets qui est une empreinte de ce bloc, de sa position et de la clé. Le déchiffrement recalcule l’étiquette et la compare ; si un seul octet a changé — un bit inversé en transit, un mot de passe erroné, un bloc échangé avec celui d’un autre fichier — l’étiquette ne correspond pas et le déchiffrement refuse, au lieu de vous remettre silencieusement des données corrompues.
Cette seconde garantie est la raison pour laquelle GCM surpasse l’ancien mode CBC pour les fichiers, et il vaut la peine de comprendre la différence. CBC chiffre chaque bloc enchaîné au précédent, mais il n’a aucun moyen intégré de savoir si le texte chiffré a été altéré : un attaquant capable d’inverser des bits dans un fichier CBC peut modifier la sortie déchiffrée de façon prévisible, et les attaques classiques par oracle de remplissage contre CBC exploitent exactement cette faiblesse. Avec CBC, il faut un HMAC séparé pour détecter l’altération, et c’est dans cette construction que les implémentations se trompent. GCM intègre la vérification — chaque bloc porte sa propre étiquette, vérifiée avant que son texte clair soit digne de confiance — donc aucun second mécanisme à greffer, aucun remplissage à attaquer. Une clé, un algorithme, confidentialité et authentification ensemble.
Mot de passe ou paire de clés ? Quand un mot de passe partagé est le bon outil
Il existe deux façons honnêtes de chiffrer un fichier pour quelqu’un d’autre, et elles résolvent des problèmes différents. Un mot de passe est un secret partagé : vous et le destinataire vous mettez d’accord — idéalement par un autre canal, en personne ou par un moyen que le fichier lui-même n’empruntera pas — et le fichier peut être ouvert par quiconque le connaît. Une paire de clés, le modèle PGP, est asymétrique : vous chiffrez avec la clé publique du destinataire, seule sa clé privée l’ouvre, et personne n’a besoin de convenir d’un secret à l’avance. La paire de clés gagne quand vous ne pouvez pas partager un secret en sécurité, quand le destinataire doit être exactement une personne, et quand vous voulez des signatures qui prouvent qui a envoyé le fichier. Elle perd sur la mise en place : des clés à générer, conserver, sauvegarder et révoquer, et un destinataire qui doit déjà en posséder une.
Le mot de passe gagne chaque fois que le coût de mise en place d’une paire de clés est la raison pour laquelle le chiffrement n’a tout simplement pas lieu — ce qui, pour la plupart des gens et des fichiers, est le cas courant. Un fichier pour votre vous futur, une sauvegarde sur un disque auquel vous ne faites pas entièrement confiance, un document pour un collègue à qui vous pouvez remettre le mot de passe en personne : cela ne demande aucune infrastructure de clés, juste un mot de passe fort et un format que le destinataire peut ouvrir. Utilisez le Chiffreur de fichiers pour ces cas. Quand le destinataire est un inconnu, quand le fichier doit pouvoir vous être attribué, ou quand vous devez chiffrer pour plusieurs personnes sans partager un secret entre elles, utilisez plutôt la Suite PGP — c’est le même site, la même règle du tout-dans-le-navigateur, et le bon outil pour les messages et l’identité. Choisir l’outil à mot de passe quand il fallait l’outil à paire de clés est une vraie erreur ; choisir l’outil à paire de clés puis ne jamais rien chiffrer parce que la mise en place vous a vaincu est l’erreur la plus courante.
Pourquoi les autres outils limitent les fichiers à 10 Mo — et comment le streaming supprime la limite
Si vous avez déjà essayé de chiffrer un fichier en ligne, vous avez rencontré la limite : 10 Mo, parfois moins, et tout ce qui est plus gros est refusé. La limite n’est pas de l’avarice. La plupart des outils lisent tout le fichier en mémoire, le chiffrent en une passe, gardent tout le texte chiffré en mémoire, puis le proposent en téléchargement — quatre copies d’un gros fichier en RAM en même temps, plus les limites propres du navigateur sur la taille d’un seul blob en mémoire. Une vidéo de 2 Go aurait besoin de gigaoctets de mémoire pour être chiffrée ainsi, et sur une machine modeste cela échoue tout simplement. L’outil limite donc l’entrée à une taille qu’il peut supporter, et les gros fichiers restent non chiffrés.
La solution est d’arrêter de tenir tout le fichier à la fois. Le chiffreur lit le fichier par tranches de 1 Mio, chiffre une tranche, écrit son texte chiffré, et oublie la tranche avant de lire la suivante — la mémoire de pointe reste proche d’un mégaoctet, quelle que soit la taille du fichier. Sur Chromium et Edge, la sortie passe par l’API File System Access, donc chaque bloc chiffré est écrit sur le disque dès qu’il est produit : du vrai streaming, sans aucun stockage complet du fichier dans le pipeline. Firefox et Safari n’offrent pas encore cette API, donc là-bas les blocs sont rassemblés en un téléchargement à la fin — la page le dit clairement, et pour les très gros fichiers sur ces navigateurs, le conseil honnête est d’utiliser un navigateur Chromium pour ce travail. La taille de bloc de 1 Mio est fixée par le format de fichier, ce n’est pas un réglage : c’est ce que le déchiffreur attend, et la garder fixe est ce qui fait que chaque fichier produit par cet outil reste lisible par toute autre implémentation du format.
Le format, documenté : votre fichier n’est pas prisonnier de ce site
Un fichier chiffré que vous ne pouvez pas ouvrir sans le site qui l’a créé est un otage, pas une sauvegarde. Le format du conteneur est donc documenté en entier sur la page de l’outil, et cette section en est la version courte. Un fichier .sysxenc commence par les huit octets magiques SYSXENC1, puis une longueur d’en-tête de deux octets, puis un en-tête JSON : la version du format, le nom du KDF et le nombre d’itérations, un sel aléatoire de 16 octets, la taille de bloc de 1 Mio, le nom original du fichier, la taille du texte clair, le SHA-256 du texte clair et un horodatage. Le corps est une suite de blocs, chacun avec une longueur de texte chiffré de quatre octets, un nouvel IV aléatoire de 12 octets, et le texte chiffré avec son étiquette GCM de 16 octets. La clé provient de votre mot de passe via PBKDF2-SHA-256 avec 600 000 itérations — le nombre que l’OWASP recommande — et chaque bloc est authentifié avec des données additionnelles qui le lient à ce fichier et à sa position : les octets exacts de l’en-tête plus l’index du bloc, de sorte qu’un bloc réordonné ou greffé depuis un autre fichier échoue à sa vérification d’étiquette.
L’intérêt d’écrire tout cela, c’est que n’importe qui peut implémenter un lecteur, et le déchiffreur Python ci-dessous en est la preuve. Il n’utilise que la bibliothèque standard plus le paquet cryptography, lit l’en-tête, dérive à nouveau la clé, déchiffre bloc par bloc en vérifiant chaque étiquette, et enfin contrôle le SHA-256 du texte clair — exactement ce que fait l’outil du navigateur. Il a été exécuté sur des fichiers produits dans ce format, dont un fichier de plusieurs mégaoctets, un fichier vide, un mot de passe erroné et un fichier altéré, et il s’est comporté correctement dans chaque cas. Une limite honnête : la ligne de commande OpenSSL ne peut pas déchiffrer directement ce format par blocs, parce qu’elle n’a aucun moyen d’exprimer les IV par bloc, les données authentifiées additionnelles et les étiquettes. C’est une propriété de la conception du format, pas un secret, et cet article ne prétendra pas le contraire — utilisez le script ci-dessous, ou n’importe quelle implémentation d’AES-GCM.
Les modes d’échec : ce contre quoi le chiffrement ne peut pas vous sauver
Le premier mode d’échec est celui contre lequel l’outil met en garde le plus fort, parce qu’il n’y a pas de remède : perdez le mot de passe et le fichier est perdu. Pas de récupération, pas de lien « mot de passe oublié », pas de clé maîtresse conservée quelque part — la clé est dérivée de votre mot de passe et de rien d’autre, et sans lui le texte chiffré est indiscernable d’octets aléatoires. Notez le mot de passe dans un endroit sûr, séparé du fichier, avant de supprimer l’original. Le second mode d’échec est un mot de passe faible. PBKDF2 avec 600 000 itérations ralentit les tentatives, mais ne peut pas rendre « password123 » fort : un attaquant qui obtient le fichier peut deviner hors ligne, aussi vite que son matériel le lui permet, sans aucun serveur pour le bloquer. Utilisez une longue phrase secrète dont vous pouvez vous souvenir, pas un mot de passe court que vous pouvez taper vite.
Les troisième et quatrième modes d’échec concernent ce que le chiffrement ne couvre pas. L’en-tête conserve en clair le nom original du fichier, sa taille et sa date de création — le contenu est secret, les métadonnées ne le sont pas. Si le nom du fichier lui-même est sensible, renommez le fichier avant de chiffrer, et envisagez de le passer d’abord par le Nettoyeur de documents, car les documents portent leurs propres métadonnées à l’intérieur : noms d’auteur, historique des modifications, miniatures intégrées. Et aucun chiffrement n’aide sur un appareil compromis. Si la machine sur laquelle vous chiffrez exécute déjà un logiciel malveillant, il peut lire le fichier avant le chiffrement et le mot de passe pendant que vous le tapez. Le chiffrement protège un fichier en transit et au repos ; il ne protège pas un fichier sur une machine déjà possédée. Ce n’est pas une raison de sauter le chiffrement — c’est la raison de savoir exactement ce qu’il vous apporte.
Déchiffrer un fichier .sysxenc avec 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())