Un client téléverse un classeur qui s'ouvre parfaitement sur son poste, et le service d'importation le rejette avec une erreur ZIP. Un dump hexadécimal des huit premiers octets montre D0 CF 11 E0 A1 B1 1A E1, la signature OLE Compound File que porte un .xls d'époque 1997. Le fichier a une extension .xlsx, il sort d'un Excel actuel, et ce n'est pas du tout un package ZIP. Quelqu'un a mis un mot de passe dans la boîte de dialogue Enregistrer sous
Tout le mystère est là. Quand Excel enregistre un classeur avec un mot de passe, il chiffre le vrai ZIP .xlsx et enveloppe le résultat dans un conteneur Compound File Binary (CFB), selon le schéma Agile de [MS-OFFCRYPTO] §2.3.4.10 à §2.3.4.15. Tout chargeur qui classe les fichiers par extension, ou qui remet chaque .xlsx directement à un lecteur ZIP, renverra le téléversement à un utilisateur qui n'a rien fait d'inhabituel de son côté de l'écran
Ce que contient un classeur chiffré en mode Agile
Un classeur chiffré en mode Agile est un conteneur CFB avec deux flux qui comptent : EncryptionInfo, qui décrit comment le chiffrement a été fait, et EncryptedPackage, qui détient le ZIP d'origine comme un blob opaque et chiffré. HotXLS lit les deux flux directement depuis le conteneur, sans Excel, sans COM, sans DLL de cryptographie externe sur la machine
Ce qui distingue Agile de l'ancien chiffrement Standard, c'est que EncryptionInfo se décrit lui-même. Après un préfixe de 8 octets dont les versions majeure et mineure valent toutes deux 4, le flux est un descripteur XML UTF-8. Un élément keyData nomme le chiffrement (AES), le mode de chaînage (ChainingModeCBC), l'algorithme de hachage, la longueur de clé en bits, la taille de bloc et un sel Base64. Le keyEncryptor du mot de passe porte son propre sel, un spinCount, et trois charges Base64 : encryptedVerifierHashInput, encryptedVerifierHashValue et encryptedKeyValue. Un élément dataIntegrity ajoute une clé HMAC et une valeur HMAC chiffrées pour la détection d'altération
Excel lui-même écrit AES-256, SHA-512 et un spin count de 100 000. Mais le descripteur a le droit d'affirmer autre chose, et des rédacteurs tiers le font. HotXLS prend keyBits dans le descripteur au lieu de supposer 256, si bien que les fichiers AES-128 et AES-192 se déchiffrent de la même façon, et il accepte hashAlgorithm="SHA256" en plus de SHA-512. L'attribut de hachage propre à chaque élément gouverne les étapes qui lui appartiennent : le hachage du keyEncryptor pilote la dérivation et la vérification du mot de passe, tandis que le hachage du keyData pilote les IV de segments et le HMAC d'intégrité. Un fichier qui mélange les deux s'ouvre quand même
Ouvrir le fichier : OpenEncrypted ou Open avec un mot de passe
TXLSXWorkbook.OpenEncrypted prend un nom de fichier et un mot de passe et renvoie 1 en cas de succès, le même contrat que Open. Il renifle les huit premiers octets avec CanReadEncrypted. Un fichier sans la signature CFB emprunte le chemin ordinaire de Open et le mot de passe est ignoré, si bien qu'un importateur qui appelle toujours OpenEncrypted n'a besoin d'aucun branchement sur le site d'appel. Un fichier CFB est d'abord tenté comme chiffrement Standard, et quand le préfixe EncryptionInfo porte la version Agile 4.4, le lecteur Agile prend la main. Les octets ZIP déchiffrés partent alors vers le chargeur XLSX ordinaire, en mémoire
Les deux points d'entrée prennent un nom de fichier. Open(Stream) refuse un flux qui commence par la signature CFB et lève une exception dont le message renvoie à OpenEncrypted, si bien qu'un téléversement détenu dans un TMemoryStream doit d'abord atterrir dans un fichier temporaire
uses
System.SysUtils, System.Classes, System.IOUtils, System.Variants, lxHandleX;
function ReadFirstCell(Upload: TMemoryStream;
const Password: WideString): WideString;
var
TempName: string;
Wb: TXLSXWorkbook;
begin
Result := '';
// Les packages chiffrés s'ouvrent depuis un fichier, donc déversez le chargement sur disque
TempName := TPath.GetTempFileName;
Wb := TXLSXWorkbook.Create;
try
Upload.SaveToFile(TempName);
// Les .xlsx simples, chiffrés Standard et chiffrés Agile marchent tous ici
if Wb.OpenEncrypted(TempName, Password) = 1 then
Result := VarToWideStr(Wb.Sheets[1].Cells[1, 1].Value);
finally
Wb.Free;
TFile.Delete(TempName);
end;
end;
La surcharge à deux arguments Open(FileName, Password) atteint le même code de déchiffrement mais ajoute une chose que OpenEncrypted n'a pas : l'événement OnPassword. Quand le mot de passe fourni échoue, Open déclenche OnPassword, laisse le gestionnaire affecter un nouveau mot de passe et mettre Retry à True, et redemande, jusqu'à trois fois. Une application de bureau peut placer une invite de mot de passe dans ce gestionnaire. Un serveur peut s'en servir pour autre chose, ce sur quoi revient la dernière section
Comment un mot de passe devient-il une clé AES ?
Le mot de passe ne déchiffre jamais rien directement. Le premier condensé est un SHA-512 sur le sel du keyEncryptor suivi des octets UTF-16LE du mot de passe ; ce condensé est ensuite rehaché spinCount fois, chaque tour préfixant le compteur de tour en entier 32 bits petit-boutiste au condensé précédent. Avec les 100 000 tours d'Excel, chaque tentative de mot de passe coûte cent mille appels SHA-512 sériels. C'est le but du spin count. Une ouverture légitime le paie une fois, et une attaque par dictionnaire le paie pour chaque essai
La chaîne est assez courte pour se reproduire, et le faire est la manière la plus rapide de mesurer ce qu'un essai coûte sur votre propre matériel. Le croquis ci-dessous suit le §2.3.4.11 pour un descripteur SHA-512 et utilise la fonction publique XlsSHA512 de l'unité lxXlsxAgileDecrypt
uses
System.SysUtils, lxXlsxAgileDecrypt;
// H0 = SHA-512(salt + UTF-16LE(password))
// Hn = SHA-512(LE32(n - 1) + H(n-1)), répété SpinCount fois
function SpinHash(const Password: WideString; const Salt: TBytes;
SpinCount: Integer): TBytes;
var
Buf: TBytes;
PwdLen, I: Integer;
begin
PwdLen := Length(Password) * SizeOf(WideChar);
SetLength(Buf, Length(Salt) + PwdLen);
if Length(Salt) > 0 then
Move(Salt[0], Buf[0], Length(Salt));
if PwdLen > 0 then
Move(Password[1], Buf[Length(Salt)], PwdLen);
Result := XlsSHA512(Buf);
SetLength(Buf, 4 + 64);
for I := 0 to SpinCount - 1 do
begin
Buf[0] := Byte(I and $FF); // compteur de tours, petit-boutiste
Buf[1] := Byte((I shr 8) and $FF);
Buf[2] := Byte((I shr 16) and $FF);
Buf[3] := Byte((I shr 24) and $FF);
Move(Result[0], Buf[4], 64); // condensé précédent
Result := XlsSHA512(Buf);
end;
end;
Le condensé issu des tours n'est toujours pas une clé. Trois clés en sortent, chacune en rehachant une fois la valeur issue des tours avec une clé de bloc fixe de 8 octets ajoutée : FE A7 D2 76 3B 4B 9E 79 pour l'entrée du vérificateur, D7 AA 0F 6D 30 61 34 4E pour le hachage du vérificateur, et 14 6E 0B E7 AB AC D0 D6 pour déballer la clé de package. Chaque résultat est coupé à la longueur de clé déclarée, 32 octets pour AES-256. La spécification définit aussi ce qui se passe quand un hachage sort plus court que la clé : compléter avec des octets 0x36. Aucune taille de clé AES ne déclenche réellement cela avec SHA-256 ou SHA-512, mais la même règle du 0x36 s'applique quand le sel du mot de passe est étendu à la taille de bloc pour servir d'IV CBC
Le spin count est lu dans le fichier, donc c'est aussi une surface d'attaque : un téléversement déclarant un milliard de tours épinglerait un cœur de CPU avant d'échouer. Le §2.3.4.11 plafonne spinCount à 10 000 000, et HotXLS signale une valeur supérieure comme descripteur non pris en charge avant de hacher quoi que ce soit. Pour un point de terminaison de téléversement public, ce plafond est le bon défaut. Les 100 000 d'Excel restent bien en dessous
La vérification du mot de passe et le piège de la troncature à saltSize
HotXLS vérifie le mot de passe avant de toucher au package. Il déchiffre encryptedVerifierHashInput avec la première clé dérivée, hache le résultat, déchiffre encryptedVerifierHashValue avec la seconde clé, et compare les deux condensés sur la longueur de hachage complète sans s'arrêter au premier octet différent. Un écart met fin à l'ouverture avec un résultat de mot de passe erroné, et le corps du package n'est jamais déchiffré sous une mauvaise clé. Un mauvais mot de passe ne peut donc pas produire un classeur plein de déchets plausibles
Une phrase de la spécification se lit mal ici. Le §2.3.4.13 définit le vérificateur comme saltSize octets de données aléatoires, où saltSize est la longueur du sel du key encryptor. Le vérificateur déchiffré revient complété à un multiple du bloc AES de 16 octets, donc il faut le recouper à saltSize avant de le hacher. Excel écrit toujours saltSize et blockSize à 16, ce qui fait que le code qui tronque à la taille de bloc passe tous les tests contre la sortie d'Excel. Il rejette ensuite le bon mot de passe sur le premier fichier d'un producteur qui a choisi un sel de 32 octets. HotXLS tronque à la longueur du sel, parce que c'est ce que dit le texte, et l'accord des deux nombres dans les fichiers Excel est une coïncidence
Comment l'EncryptedPackage est-il déchiffré ?
La clé de package est aléatoire, pas dérivée du mot de passe. Le rédacteur l'a générée, chiffrée dans encryptedKeyValue, et HotXLS la déballer avec la troisième clé dérivée, en gardant autant d'octets que keyData le déclare dans keyBits. Avant de déchiffrer un seul segment, HotXLS consulte dataIntegrity quand le fichier le porte : la clé et la valeur HMAC sont déchiffrées avec la clé de package, et un HMAC sur le flux EncryptedPackage complet, préfixe de taille compris, doit correspondre à la valeur stockée. Les fichiers écrits sans élément dataIntegrity utilisable sautent cette étape et s'ouvrent quand même
Le flux lui-même commence par une taille de texte clair sur 8 octets petit-boutiste, suivie du chiffré en segments de 4096 octets. Chaque segment reçoit son propre IV : le hachage du sel de keyData suivi de l'index de segment en entier 32 bits petit-boutiste, coupé à la taille de bloc. N'importe quel segment peut donc être déchiffré seul, ce qui permettrait un accès aléatoire en principe ; HotXLS déchiffre le package entier en mémoire parce que le chargeur ZIP veut de toute façon l'archive complète. La taille déclarée est confrontée à la longueur réelle du flux avant que le déchiffrement ne commence, si bien qu'un téléversement tronqué ou un champ de taille gonflé échoue proprement. Après le dernier segment, le tampon est coupé à la taille déclarée, ce qui jette les jusqu'à 15 octets de bourrage AES, et ce qui reste est octet pour octet le ZIP qu'Excel a chiffré
Distinguer un mauvais mot de passe d'un fichier non pris en charge
Chaque échec de chiffrement dans OpenEncrypted et Open lève EXlsxEncryptionNotImplemented, et le message dit de quel cas il s'agit : le mot de passe fourni est incorrect, ou le fichier utilise un schéma que HotXLS ne lit pas. HotXLS lit le key encryptor à mot de passe avec AES en mode CBC et hachage SHA-512 ou SHA-256, ce qui couvre ce que les versions actuelles d'Excel écrivent ; un conteneur protégé seulement par un key encryptor à certificat, un descripteur nommant un autre chiffrement, ou un CFB qui n'est ni Standard ni Agile, tel qu'un .xls BIFF renommé, reçoit le message de non prise en charge
Reconnaître le cas sur le texte du message est fragile, surtout si les chaînes de ressources sont un jour localisées. L'événement OnPassword donne un signal plus propre : Open ne le déclenche que quand le vérificateur ou le contrôle d'intégrité rejette le mot de passe, jamais pour un schéma non pris en charge. Pour un service d'importation, appelez Open(FileName, Password) avec un gestionnaire qui enregistre le rejet, plutôt que OpenEncrypted, qui lève sans consulter aucun événement
type
TUploadOutcome = (uoLoaded, uoPasswordRejected, uoUnreadable);
TUploadLoader = class
private
FPasswordRejected: Boolean;
procedure HandlePassword(Sender: TObject; var PassWord: WideString;
var Retry: Boolean);
public
function Load(Wb: TXLSXWorkbook;
const FileName, Password: WideString): TUploadOutcome;
end;
procedure TUploadLoader.HandlePassword(Sender: TObject;
var PassWord: WideString; var Retry: Boolean);
begin
// Déclenché seulement quand le mot de passe (ou le HMAC d'intégrité) a été rejeté
FPasswordRejected := True;
Retry := False; // personne à qui demander sur un serveur ; Open lève ensuite
end;
function TUploadLoader.Load(Wb: TXLSXWorkbook;
const FileName, Password: WideString): TUploadOutcome;
begin
FPasswordRejected := False;
Wb.OnPassword := HandlePassword;
try
if Wb.Open(FileName, Password) = 1 then
Result := uoLoaded
else
Result := uoUnreadable;
except
on E: EXlsxEncryptionNotImplemented do
if FPasswordRejected then
Result := uoPasswordRejected // sans risque de redemander à l'utilisateur
else
Result := uoUnreadable; // une nouvelle tentative n'aidera pas ; journalisez E.Message
end;
end;
Un piège subsiste même avec cette séparation. Un écart d'intégrité est signalé de la même façon qu'un mauvais mot de passe, si bien qu'un classeur dont le chiffré a été abîmé en route, par un proxy qui a réécrit le corps ou un téléversement coupé en plein segment, revient en uoPasswordRejected même quand l'utilisateur a tapé le bon mot de passe. Si le même utilisateur échoue deux fois avec un mot de passe qu'il jure être correct, redemandez le fichier avant de redemander le mot de passe
Le côté écriture utilise la même machinerie en sens inverse. SaveAsEncryptedAgile produit un conteneur Agile avec dérivation de clé SHA-512, 100 000 tours et chiffrement de package AES-256, SaveAsEncrypted produit le chiffrement Standard, et mettre VerifyEncryptedSave à True fait que l'un ou l'autre appel rouvre le fichier qu'il vient d'écrire par le chemin de déchiffrement et renvoie -1 si cela échoue. Le chemin Standard est parcouru dans l'article sur l'écriture de sortie XLSX protégée par AES, et les schémas RC4 et XOR trouvés dans les fichiers BIFF hérités sont couverts dans l'article sur l'interopérabilité ECB et RC4
Pour un pipeline qui ne sait jamais à l'avance si le prochain téléversement porte un mot de passe, le lecteur décrit ci-dessus, avec la lecture et l'écriture natives XLS et XLSX pour Delphi et C++Builder, fait partie du HotXLS Delphi Excel Component