Article technique

HotXLS : détecter un XLSX altéré via HMAC Agile

Un seul octet basculé dans le flux EncryptedPackage d'un .xlsx protégé par mot de passe n'empêche pas AES-CBC de tout déchiffrer avec le bon mot de passe : le bloc de 16 octets portant l'octet basculé devient du bruit, et le même bit bascule proprement dans le bloc de texte clair qui le suit. Le chiffrement seul ne peut pas vous dire que cela s'est produit. La défense habite dans l'élément dataIntegrity de [MS-OFFCRYPTO] §2.3.4.14, un HMAC sur le chiffré stocké qu'un lecteur contrôle avant de déchiffrer le moindre segment

Le chiffrement Agile, le schéma qu'Excel écrit par défaut pour les classeurs protégés par mot de passe, donne la confidentialité par AES en mode CBC avec une clé dérivée d'un hachage de mot de passe SHA-512 itéré. CBC n'est pas un mode authentifié, donc le chiffrement ne se prononce pas sur la question de savoir si le chiffré devant lui est celui qui a été écrit. Un paquet modifié explose en général plus tard en erreur ZIP ou deflate, car un flux compressé corrompu survit rarement à la décompression. Habituellement pèse lourd dans cette phrase, et une erreur d'analyse trois couches plus bas est un bien mauvais endroit pour apprendre que quelqu'un a édité le fichier en route

Pourquoi un classeur chiffré altéré se déchiffre-t-il quand même ?

Un classeur altéré se déchiffre quand même parce que CBC ne fait que chaîner les blocs ; il ne les authentifie jamais. Chaque bloc de chiffré est déchiffré avec la clé puis XORé avec le bloc de chiffré précédent, donc un changement dans le bloc n brouille le bloc de texte clair n et bascule exactement les mêmes bits dans le bloc n+1. Quelqu'un qui connaît la disposition du texte clair peut piloter ce second effet. Quelqu'un qui ne la connaît pas peut quand même corrompre des données d'une manière qu'un analyseur aval remarquera ou non

[MS-OFFCRYPTO] répond à cela par un MAC calculé sur les octets chiffrés. Le rédacteur génère une clé HMAC aléatoire dont la longueur correspond à la taille de hachage de keyData (64 octets pour SHA-512), calcule un HMAC sur l'intégralité du flux EncryptedPackage, et stocke les deux valeurs dans l'élément dataIntegrity comme encryptedHmacKey et encryptedHmacValue. Les deux sont chiffrées avec la clé de paquet, avec des IV dérivés du sel keyData et deux clés de bloc fixes définies par la spécification. Le HMAC couvre le flux tel que stocké, y compris le préfixe StreamSize de 8 octets devant les segments, si bien que même la longueur de texte clair déclarée ne peut pas être altérée sans détection

L'ordre des contrôles de HotXLS à l'ouverture

HotXLS exécute le contrôle d'intégrité après que le mot de passe est prouvé et avant que tout segment de paquet ne soit déchiffré. TXLSXWorkbook.OpenEncrypted essaie d'abord le lecteur Standard Encryption, et quand le flux EncryptionInfo porte la signature Agile (version 4.4), le pipeline Agile prend la main. Ce pipeline enchaîne ces étapes dans l'ordre :

  1. Exécuter le hachage de mot de passe itéré avec le sel et le spin count du descripteur ; un spinCount au-dessus du plafond de 10 000 000 de la spécification est traité comme un descripteur mal formé et rejeté avant tout hachage
  2. Déchiffrer le vérificateur de mot de passe, le hacher, et comparer le résultat au hachage de vérificateur stocké ; une discordance ici signifie un mot de passe erroné
  3. Déballer la clé de paquet intermédiaire, puis déchiffrer la clé HMAC et la valeur HMAC depuis les attributs dataIntegrity
  4. Calculer le HMAC sur les octets EncryptedPackage exactement tels qu'ils se trouvent dans le fichier, et le comparer à la valeur stockée
  5. Seulement après une correspondance, déchiffrer les segments de 4096 octets et remettre le ZIP intérieur au chargeur XLSX normal

Calculer le MAC sur le chiffré est la discipline encrypt-then-MAC standard. Un paquet altéré est rejeté avant que le moindre octet contrôlé par un attaquant n'atteigne le déchiffrement AES, la décompression ou l'analyseur XML. Les deux comparaisons de ce chemin, le hachage de vérificateur et la valeur HMAC, combinent par OU le XOR de chaque paire d'octets sur toute l'empreinte au lieu de retourner à la première différence, donc la temporisation de la réponse ne révèle pas combien d'octets de tête correspondaient. L'algorithme de hachage suit le descripteur : Excel déclare SHA-512, certains rédacteurs tiers déclarent SHA-256, et le HMAC, les IV et la dérivation de clé basculent sur ce que disent les nœuds keyData et chiffreur de clé de mot de passe

HotXLS : diagramme de flux de l'ordre des contrôles dataIntegrity : dériver la clé, déchiffrer la clé et la valeur HMAC, calculer HMAC-SHA-512 sur le chiffré, comparer en temps constant, puis déchiffrer les segments ou rejeter
Le contrôle d'intégrité s'exécute avant toute décompression : le HMAC se calcule sur le texte chiffré stocké, si bien qu'un mot de passe erroné ou un paquet altéré est rejeté à la porte au lieu de se manifester en données corrompues après le déchiffrement

Côté appelant, un contrôle d'intégrité raté et un mauvais mot de passe sont le même événement. Les deux font lever à OpenEncrypted une EXlsxEncryptionNotImplemented avec le message "The supplied password is incorrect for this encrypted workbook." Un conteneur ni Standard ni Agile, ou un fichier CFB illisible, lève la même classe d'exception avec un autre message. Seul un déchiffrement réussi suivi d'un chargement raté du classeur intérieur revient comme valeur de retour autre que 1

uses
  SysUtils, lxHandleX;

// Ouvre un classeur qui doit arriver chiffré
function OpenIntake(const FileName, Password: WideString): TXLSXWorkbook;
var
  Book: TXLSXWorkbook;
begin
  Book := TXLSXWorkbook.Create;
  try
    // OpenEncrypted retombe sur un Open simple pour un ZIP non chiffré,
    // donc un pipeline qui exige le chiffrement doit contrôler d'abord
    if not Book.CanReadEncrypted(FileName) then
      raise Exception.Create('Not an encrypted package: ' + FileName);
    // Mauvais mot de passe et discordance HMAC lèvent tous deux EXlsxEncryptionNotImplemented
    if Book.OpenEncrypted(FileName, Password) <> 1 then
      raise Exception.Create('Decrypted, but the inner workbook did not load');
    Result := Book;
  except
    Book.Free;
    raise;
  end;
end;

// Appelant ; Quarantine et ProcessWorkbook sont vos propres routines
try
  Book := OpenIntake('incoming.xlsx', PasswordFromVault);
  try
    ProcessWorkbook(Book);
  finally
    Book.Free;
  end;
except
  on E: EXlsxEncryptionNotImplemented do
    Quarantine('incoming.xlsx', E.Message);
end;

Le garde-fou CanReadEncrypted compte plus qu'il y paraît. Il teste la signature de fichier composé OLE, et sans lui quelqu'un pourrait remplacer un classeur chiffré par un .xlsx ordinaire et OpenEncrypted le chargerait comme si de rien n'était. Un .xls historique renommé porte aussi cette signature, voilà pourquoi il passe le garde-fou puis échoue à l'intérieur de OpenEncrypted avec le message de schéma de chiffrement non pris en charge

Écrire des paquets qui portent le bloc

SaveAsEncryptedAgile est l'appel qui produit un bloc dataIntegrity. Il sérialise le classeur en XLSX en mémoire, le chiffre en AES-256-CBC sous une dérivation de clé SHA-512 avec un spin count de 100 000, calcule un HMAC-SHA-512 sur le flux EncryptedPackage fini, et écrit les deux blobs HMAC chiffrés dans le descripteur. SaveAsEncrypted écrit du Standard Encryption ECMA-376 (AES-128 avec dérivation de clé SHA-1) à la place, et la structure EncryptionInfo Standard définie par [MS-OFFCRYPTO] n'a aucun emplacement pour un MAC d'intégrité. Pour tout ce qui traverse un réseau ou dort sur un partage, utilisez le rédacteur Agile : il ne coûte rien de plus en code et c'est le seul des deux dont un lecteur peut vérifier la sortie contre la falsification

var
  Book: TXLSXWorkbook;
begin
  Book := TXLSXWorkbook.Create;
  try
    BuildPayrollSheets(Book);        // votre propre code qui remplit le classeur
    // Rouvrir le conteneur écrit via le pipeline de déchiffrement
    // et signaler l'échec au lieu de laisser un fichier cassé derrière soi
    Book.VerifyEncryptedSave := True;
    if Book.SaveAsEncryptedAgile('payroll-2026-10.xlsx', PasswordFromVault) <> 1 then
      raise Exception.Create('Encrypted save failed or did not verify');
  finally
    Book.Free;
  end;
end;

Avec VerifyEncryptedSave actif, la sauvegarde rouvre le nouveau fichier avec le même mot de passe, donc une sauvegarde vérifiée a déjà passé le contrôle HMAC une fois. Le matériel aléatoire, à savoir les deux sels de 16 octets, l'entrée du vérificateur, la clé de paquet de 32 octets et la clé HMAC de 64 octets, vient du CSPRNG du système (CryptGenRandom sous Windows). Si cette source ne peut pas livrer, le rédacteur Agile lève une exception au lieu de retomber sur un générateur amorcé par l'horloge. Ces octets deviennent des sels et des clés AES ; un repli prévisible produirait des fichiers qui ont l'air chiffrés, passent tous les tests fonctionnels et ne protègent rien. Un échec de sauvegarde est la meilleure issue ici

Que se passe-t-il quand un fichier n'a pas de bloc dataIntegrity ?

Le fichier s'ouvre normalement. Nombre de classeurs chiffrés en Agile en circulation viennent de rédacteurs qui laissent dataIntegrity de côté, et les refuser casserait bien plus de travail légitime qu'il n'y arrêterait. HotXLS considère le bloc comme présent seulement quand encryptedHmacKey et encryptedHmacValue se décodent tous deux en valeurs non vides et alignées sur 16 octets ; sinon la vérification est sautée et le déchiffrement suit le contrôle du mot de passe

Ce choix de compatibilité a une conséquence de sécurité qui mérite une ligne dans votre modèle de menace. L'élément dataIntegrity se trouve dans le flux EncryptionInfo, hors des octets que son propre MAC couvre, donc un bloc manquant ressemble exactement à un bloc qu'un attaquant a supprimé. Si vous contrôlez les deux bouts d'un pipeline et que chaque producteur passe par SaveAsEncryptedAgile, traitez un bloc manquant comme un échec de politique au niveau application. L'appel d'ouverture ne rapporte pas si la vérification a tourné, donc faire respecter cette règle signifie lire le XML EncryptionInfo vous-même avec un lecteur de fichiers composés avant de remettre le fichier. Pour les fichiers qui viennent du monde extérieur, lisez le contrôle pour ce qu'il est : un signal fort quand le bloc est là, et aucun signal du tout quand il est absent

La boucle de relance OnPassword et les fichiers altérés

La surcharge simple Open(FileName, Password) déchiffre aussi les paquets Standard et Agile, et elle ajoute un contrat de relance que OpenEncrypted n'a pas. Quand le résultat est « mauvais mot de passe » et que OnPassword est affecté, le classeur appelle le gestionnaire, qui peut fournir un autre mot de passe et mettre Retry à True ; la boucle s'arrête après trois appels du gestionnaire. Comme une discordance HMAC produit ce même résultat « mauvais mot de passe », un gestionnaire qui se contente de redemander est appelé jusqu'à trois fois pour un paquet altéré, chaque tentative échoue, et la boucle se termine sur le message de mot de passe incorrect. Le bon mot de passe échoue au HMAC, et tout autre mot de passe échoue au vérificateur

procedure TIntakeForm.BookPassword(Sender: TObject;
  var PassWord: WideString; var Retry: Boolean);
begin
  // Atteint aussi pour un paquet dont le HMAC ne correspondait pas.
  // Redemander ne peut pas réparer ce cas, proposez donc une unique clé de repli
  // et laissez l'échec suivant surgir en erreur
  Inc(FPasswordCalls);
  Retry := (FPasswordCalls = 1) and FetchFallbackKey(PassWord); // votre propre fonction
end;

// Câblage
FPasswordCalls := 0;
Book.OnPassword := BookPassword;
Book.Open('incoming.xlsx', PasswordFromVault);

Pour une entrée sans surveillance, laissez OnPassword non affecté et appelez OpenEncrypted. Le premier échec lève alors immédiatement, et le journal de quarantaine enregistre un événement par fichier au lieu d'une rafale de relances

Le mot de passe de modification est de la coordination, pas de la protection

Les classeurs XLS classiques gèrent un mécanisme séparé que l'on confond souvent avec le chiffrement : la réservation en écriture derrière l'invitation « password to modify » d'Excel. HotXLS l'expose sur IXLSWorkbook via SetModifyPassword, qui prend le mot de passe, un drapeau recommander-lecture-seule et le nom utilisateur réservant, et rapporte l'état via la propriété IsWriteReserved. Passer un mot de passe vide lève la réservation et laisse le nom utilisateur WRITEACCESS séparé intact

La disposition des enregistrements est courte. FILESHARING porte le drapeau recommander-lecture-seule, un hachage de mot de passe 16 bits historique et le nom utilisateur en chaîne Unicode BIFF8 non compressée ; à la sauvegarde, HotXLS place le marqueur WRITEPROT vide devant WRITEACCESS et FILESHARING dès qu'une réservation existe, l'ordre du File Protection Block qu'Excel attend. Les réservations qu'Excel lui-même a écrites survivent à un aller-retour HotXLS par le même chemin. Ces enregistrements ne sont écrits que pour le format BIFF8 xlExcel97

var
  Book: IXLSWorkbook;   // compté par interface : ne pas Free
begin
  Book := TXLSWorkbook.Create;
  if Book.Open('shared-model.xls') = 1 then
  begin
    // Recommander lecture-seule, réservé par le service de rapports
    Book.SetModifyPassword('edit-me', True, 'Reporting Service');
    if Book.IsWriteReserved then
      Book.SaveAs('shared-model.xls', xlExcel97);
  end;
end;

Un hachage 16 bits est une somme de contrôle, et les données de feuille sous réservation en écriture ne sont pas chiffrées du tout ; n'importe quel autre outil lit chaque cellule. La fonctionnalité dit à la personne suivante dans Excel que quelqu'un considère ce fichier comme le sien à éditer, dans la même catégorie que les contrôles au niveau feuille traités dans la protection de feuille XLSX et les options allow. La confidentialité vient des chemins de sauvegarde chiffrés décrits dans la sortie XLSX protégée par AES, et les contrôles au niveau conteneur appartiennent encore plus tôt dans la chaîne, puisque la structure ZIP d'un paquet simple est analysée avant toute logique de classeur ; la validation ZIP end-of-central-directory pour un XLSX non fiable couvre ces modes d'échec

HotXLS lit et écrit XLS, XLSX et ODS depuis Delphi et C++Builder sans installation d'Excel, et son code de chiffrement Standard et Agile est écrit en Pascal contre [MS-OFFCRYPTO]. La référence complète des méthodes OpenEncrypted, SaveAsEncryptedAgile et SetModifyPassword est sur la page du composant tableur HotXLS Delphi