Un classeur BIFF5 protégé par le mot de passe secret peut porter un vérificateur de mot de passe qui correspond parfaitement et faire quand même répondre à Excel 16 que le mot de passe est incorrect. Excel n'accepte le fichier que lorsque la clé FILEPASS égale CreateXorKey_Method1(password), que le tableau XOR de 16 octets est construit avec XorRor, et que chaque octet utilise XorArrayIndex = (décalage de flux + longueur d'enregistrement) mod 16
Excel 16 a deux façons différentes de refuser un tel fichier, et elles se projettent proprement sur les couches de [MS-OFFCRYPTO] §2.3.7. Une invite de mot de passe qui rejette sans fin le bon mot de passe pointe vers le mot de clé dans FILEPASS. Un rapport disant que le fichier a un problème et ne peut pas être ouvert, affiché après que le mot de passe a été accepté, pointe vers le tableau XOR ou vers l'index qui choisit un octet du tableau. Les sections suivantes suivent cet ordre, jusqu'à l'octet
Ce que l'enregistrement FILEPASS stocke dans un fichier BIFF5
L'obfuscation XOR du BIFF stocke exactement deux mots de 16 bits, et tout le reste se recalcule depuis le mot de passe. L'enregistrement FILEPASS ($002F) se place immédiatement après le BOF des globals du classeur, et dans un fichier BIFF5 son corps fait 4 octets : la clé XOR, puis le vérificateur de mot de passe. Pas de sel. Pas d'identifiant d'algorithme non plus, et rien qui ressemble au blob de vérificateur chiffré que les schémas RC4 et AES transportent
À partir de ces deux mots, un lecteur reconstruit trois valeurs :
- Le vérificateur, un haché 16 bits des octets du mot de passe XORé avec la longueur du mot de passe et
$CE4B. Le comparer au mot stocké est le contrôle de mot de passe documenté - La clé XOR, une valeur 16 bits produite par
CreateXorKey_Method1de [MS-OFFCRYPTO] §2.3.7.2 à partir de deux tables constantes,InitialCode(15 mots) etXorMatrix(105 mots) - Le tableau XOR, 16 octets faits des octets du mot de passe complétés par un bourrage fixe de 16 octets, chacun XORé avec l'octet bas de la clé aux positions paires ou l'octet haut aux positions impaires, puis pivoté à droite d'un bit
Les en-têtes d'enregistrements restent en clair. Il en va de même pour quelques enregistrements entiers exemptés par le schéma — BOF, FILEPASS, USREXCL, FILELOCK, INTERFACEHDR, RRDHEAD et RRDINFO — plus les 4 premiers octets de chaque BOUNDSHEET. Tout autre corps d'enregistrement est transformé octet par octet : rotation à gauche de 5 bits, puis XOR avec une entrée du tableau de 16 octets. Le déchiffrement, que le §2.3.7.3 épelle DecryptData_Method1, tourne en image miroir : XOR d'abord, puis rotation à droite de 5
HotXLS garde tout cela derrière deux propriétés de classeur. TXLSWorkbook.EncryptionPassword porte le mot de passe, EncryptionType choisit le schéma, et SaveAs avec xlExcel5 émet FILEPASS juste après le BOF et transforme le reste du flux :
uses
SysUtils, lxHandle;
procedure SaveLegacyProtectedBook(const FileName: string);
var
Wb: IXLSWorkbook;
begin
Wb := TXLSWorkbook.Create;
Wb.Sheets.Add.Name := 'Ledger';
Wb.Sheets[1].Range['A1', 'A1'].Value := 'Account';
Wb.Sheets[1].Range['B1', 'B1'].Value := 1250.75;
// Le BIFF5 ne connaît que l'obfuscation XOR ; xletAuto choisit le même
// schéma pour xlExcel5, donc le réglage explicite ne fait que documenter l'intention
Wb.EncryptionType := xletXor;
// ASCII, au plus 15 caractères (voir les notes sur les mots de passe plus bas)
Wb.EncryptionPassword := 'secret';
if Wb.SaveAs(FileName, xlExcel5) <> 1 then
raise Exception.Create('BIFF5 save failed');
end;
Pourquoi Excel dit-il que le mot de passe est faux quand le vérificateur correspond ?
Excel dérive la clé depuis le mot de passe tapé avec CreateXorKey_Method1 et la compare au mot de clé dans FILEPASS, si bien qu'un fichier dont la clé est autre chose échoue au contrôle de mot de passe même quand le vérificateur est correct. La spécification traite la clé comme une fonction du mot de passe, et Excel 16 applique cette lecture strictement
Le raccourci tentant consiste à remplir le mot de clé avec deux octets aléatoires. Sur le papier cela paraît inoffensif : le vérificateur est le contrôle de mot de passe documenté, et le tableau est construit depuis la clé que le fichier déclare. Un lecteur qui prend la clé FILEPASS telle quelle ouvre ces fichiers sans plainte, et c'est ainsi que le raccourci survit dans du code testé seulement contre lui-même. Excel 16, face au même fichier et au bon mot de passe, refuse à l'invite. HotXLS dérive la clé à chaque enregistrement, si bien que FILEPASS pour le mot de passe secret porte toujours la clé $014D et le vérificateur $DAA7
La dérivation est courte une fois les deux tables en place. Parcourez le mot de passe à rebours depuis son dernier octet, testez sept fois le bit 6 de chaque octet tout en le décalant à gauche, et XORez une entrée de XorMatrix chaque fois que le bit est à 1 ; l'index de table démarre à la dernière entrée, $68, et descend d'un par bit, que le bit soit à 1 ou non. Le croquis ci-dessous reproduit l'algorithme de la spécification pas à pas et donne les mêmes résultats que la bibliothèque. C'est une illustration pour votre propre lecteur, et aucune de ces routines ne fait partie de l'API HotXLS :
// Esquisse de principe de [MS-OFFCRYPTO] 2.3.7.2 CreateXorKey_Method1
// et CreateXorArray_Method1 (illustration seule, pas une API HotXLS)
type
TXorArray = array [0..15] of Byte;
function DemoCreateXorKey(const Password: AnsiString): Word;
const
InitialCode: array [0..14] of Word = ($E1F0, $1D0F, $CC9C, $84C0, $110C,
$0E10, $F1CE, $313E, $1872, $E139, $D40F, $84F9, $280C, $A96A, $4EC3);
XorMatrix: array [0..104] of Word = (
$AEFC, $4DD9, $9BB2, $2745, $4E8A, $9D14, $2A09,
$7B61, $F6C2, $FDA5, $EB6B, $C6F7, $9DCF, $2BBF,
$4563, $8AC6, $05AD, $0B5A, $16B4, $2D68, $5AD0,
$0375, $06EA, $0DD4, $1BA8, $3750, $6EA0, $DD40,
$D849, $A0B3, $5147, $A28E, $553D, $AA7A, $44D5,
$6F45, $DE8A, $AD35, $4A4B, $9496, $390D, $721A,
$EB23, $C667, $9CEF, $29FF, $53FE, $A7FC, $5FD9,
$47D3, $8FA6, $0F6D, $1EDA, $3DB4, $7B68, $F6D0,
$B861, $60E3, $C1C6, $93AD, $377B, $6EF6, $DDEC,
$45A0, $8B40, $06A1, $0D42, $1A84, $3508, $6A10,
$AA51, $4483, $8906, $022D, $045A, $08B4, $1168,
$76B4, $ED68, $CAF1, $85C3, $1BA7, $374E, $6E9C,
$3730, $6E60, $DCC0, $A9A1, $4363, $86C6, $1DAD,
$3331, $6662, $CCC4, $89A9, $0373, $06E6, $0DCC,
$1021, $2042, $4084, $8108, $1231, $2462, $48C4);
var
Len, I, Bit, Element: Integer;
Ch: Byte;
begin
Result := 0;
Len := Length(Password);
if Len > 15 then
Len := 15; // la clé ne voit que 15 octets
if Len = 0 then
Exit;
Result := InitialCode[Len - 1];
Element := $68; // dernière entrée de XorMatrix
for I := Len downto 1 do
begin
Ch := Ord(Password[I]);
for Bit := 1 to 7 do
begin
if (Ch and $40) <> 0 then
Result := Result xor XorMatrix[Element];
Ch := Byte(Ch shl 1);
Dec(Element);
end;
end;
end;
function XorRor(B, KeyByte: Byte): Byte;
begin
B := B xor KeyByte;
Result := Byte((B shr 1) or (B shl 7)); // rotation à droite d’un bit
end;
procedure DemoCreateXorArray(const Password: AnsiString; out Arr: TXorArray);
const
PadArray: TXorArray = ($BB, $FF, $FF, $BA, $FF, $FF, $B9, $80,
$00, $BE, $0F, $00, $BF, $0F, $00, $00);
var
Key: Word;
Len, I: Integer;
begin
Key := DemoCreateXorKey(Password);
Len := Length(Password);
if Len > 16 then
Len := 16;
for I := 0 to Len - 1 do
Arr[I] := Ord(Password[I + 1]);
for I := Len to 15 do
Arr[I] := PadArray[I - Len];
for I := 0 to 15 do
if Odd(I) then
Arr[I] := XorRor(Arr[I], Byte(Key shr 8))
else
Arr[I] := XorRor(Arr[I], Byte(Key and $FF));
end;
Pour secret, cela produit le tableau 1F 32 17 B9 14 BA 7B 7F 59 DD 59 7F 7A C0 A6 DF. Avec la clé $014D et le vérificateur $DAA7, vous avez trois valeurs de référence pour vos assertions avant même d'impliquer Excel
Rotation à droite d'un bit, et pourquoi rotation à gauche de deux paraît plausible
Avec la bonne clé, Excel 16 passe l'invite de mot de passe et file droit vers la seconde erreur, le rapport de fichier à problème. La cause habituelle est un tableau XOR pivoté dans le mauvais sens. Le §2.3.7.2 définit l'étape du tableau comme XorRor, une rotation à droite d'un bit, pourtant une variante qui pivote chaque octet du tableau à gauche de 2 bits circule dans plusieurs implémentations BIFF, et un lecteur bâti sur la même variante ne remarque jamais rien
Excel 16 n'enregistre pas de fichiers Excel 5.0/95, et il ne propose pas XOR à l'enregistrement BIFF8, donc il n'existe aucun échantillon natif à comparer. Quand vous devez identifier quelle combinaison votre propre code implémente, la méthode fiable tourne dans l'autre sens : écrivez un flux BIFF5 en clair, réencodez-le sous chaque combinaison de trois choix indépendants, et laissez Excel 16 ouvrir chaque résultat :
| Choix | Option A | Option B |
|---|---|---|
| Rotation du tableau | XorRor (rotation à droite de 1) | Rotation à gauche de 2 |
| Index du tableau | (décalage + longueur d’enregistrement) mod 16 | décalage mod 16 |
| Ordre de transformation d’octet | Rotation à gauche de 5, puis XOR | XOR, puis rotation à gauche de 5 |
Sur les huit fichiers, Excel 16 accepte la combinaison de la spécification — XorRor, pivoter-puis-XOR, index à longueur d'enregistrement — et exactement un autre qui n'a l'air différent qu'en apparence. Rotation-gauche-2 associé à XOR-puis-rotation et au même index est la même fonction déguisée. La rotation se distribue sur le XOR, donc rol5(p xor rol2(b)) égale rol5(p) xor rol7(b), et sur une valeur 8 bits une rotation à gauche de 7 est une rotation à droite de 1. En compact : rol5 ∘ rol2 = ror1
Cette identité explique pourquoi le tableau rotation-gauche-2 semble correct isolément. Il n'est correct qu'accompagné de l'ordre de transformation opposé ; associé à l'ordre de la spécification il corrompt chaque octet transformé. Toute variante qui abandonne la longueur d'enregistrement dans l'index échoue aussi, quelle que soit sa rotation. Écrivez la combinaison de la spécification et rien d'autre. Le jumeau algébrique s'ouvre, mais il laisse au prochain mainteneur deux écarts à rétro-concevoir là où le texte de la spécification n'en laisse aucun
Comment XorArrayIndex est-il calculé pour chaque octet ?
XorArrayIndex pour un octet est son décalage dans le flux du classeur plus la longueur de la donnée complète de l'enregistrement auquel il appartient, mod 16. L'index redémarre donc à une valeur dépendant de l'enregistrement pour chaque enregistrement et s'incrémente d'un par octet à l'intérieur. Le pseudocode de la spécification nomme les entrées FileOffset et Data.Length, et il est facile de mal lire la première comme le seul décalage de début d'enregistrement
Trois détails décident si vos index s'alignent avec Excel :
- L'en-tête d'enregistrement de 4 octets n'est jamais transformé, mais il occupe quand même des positions de flux, si bien que le premier octet de corps d'un enregistrement se situe à en-tête + 4
- Le terme de longueur est la longueur complète de la donnée d'enregistrement, préfixe simple compris que la transformation saute
- BOUNDSHEET est partiellement en clair : ses 4 premiers octets,
lbPlyPos, le décalage de flux du BOF de feuille, restent lisibles pour qu'un analyseur puisse localiser les feuilles sans le mot de passe. Ces 4 octets sont sautés par la transformation mais comptent quand même dans le décalage et dans la longueur d'enregistrement
Réunie, la transformation par enregistrement tient en quelques lignes. Comme avant, ceci esquisse la règle pour votre propre code ; HotXLS l'applique en interne pendant SaveAs :
function Rol8(B: Byte; N: Integer): Byte;
begin
Result := Byte((B shl N) or (B shr (8 - N)));
end;
// Obfusque un corps d’enregistrement sur place. BodyPos est le décalage de flux de
// Body[0], c’est-à-dire le décalage de l’en-tête d’enregistrement + 4. PlainPrefix vaut 4 pour
// BOUNDSHEET, la longueur complète pour BOF / FILEPASS, 0 pour la plupart des enregistrements
procedure DemoObfuscateRecord(var Body: array of Byte; RecordLength: Word;
PlainPrefix: Integer; BodyPos: LongWord; const Arr: TXorArray);
var
I: Integer;
begin
for I := PlainPrefix to RecordLength - 1 do
Body[I] := Rol8(Body[I], 5) xor
Arr[(BodyPos + LongWord(I) + RecordLength) mod 16];
end;
// La lecture est l’image miroir : B := Body[I] xor Arr[...];
// puis rotation à droite de 5, soit Rol8(B, 3)
Un lecteur et un writer qui indexent tous deux par la seule position de flux abandonnent la longueur d'enregistrement des deux côtés, si bien qu'ils se comprennent entre eux et ne comprennent personne d'autre. En lecture, HotXLS calcule l'index depuis la position de flux courante plus la longueur du préfixe simple plus le nombre d'octets transformés — la même longueur d'enregistrement que le writer a utilisée
Lire des fichiers qui emploient le tableau rotation-gauche-2
HotXLS ouvre aussi des fichiers XOR construits avec le tableau rotation-gauche-2 et une clé aléatoire, et il les distingue par la clé FILEPASS. Quand la clé stockée égale la clé dérivée du mot de passe, le lecteur construit le tableau XorRor de la spécification ; quand elle diffère, le lecteur passe au tableau rotation-gauche-2. Les fichiers écrits par Excel portent toujours la clé dérivée, donc ils prennent toujours le chemin de la spécification
Le test est une heuristique avec un taux d'échec précis. Pour un fichier dont la clé a été remplie au hasard, la chance qu'elle égale par hasard la clé dérivée — et soit donc lue avec le mauvais tableau — est de 1 sur 65 536. Le basculement ne couvre que la rotation du tableau ; la règle d'index reste fixe, donc il s'applique aux fichiers qui emploient déjà l'index à longueur d'enregistrement. Ouvrir un tel fichier avec HotXLS et le réenregistrer produit un fichier qu'Excel accepte, parce que le writer emploie toujours la clé dérivée et XorRor
Deux détails de mot de passe s'appliquent à chaque fichier, quel que soit son tableau :
- Longueur.
CreateXorKey_Method1ne lit que les 15 premiers octets du mot de passe, ce qui est la limite de la spécification. HotXLS applique ce plafond à la clé et garde le vérificateur sur le mot de passe complet et le tableau sur sa règle à 16 octets, à l'identique en lecture et en écriture. Comme la clé ne voit jamais que 15 octets, 15 caractères est le maximum pratique - Jeu de caractères. HotXLS convertit le mot de passe en octets via la page de codes ANSI du système, pour la clé, le vérificateur et le tableau pareillement. La spécification décrit la prise de l'octet bas de chaque caractère UTF-16, et les deux se rejoignent pour l'ASCII. Sans échantillons Excel protégés par des mots de passe non ASCII, il n'existe pas de vérité terrain pour le reste, donc gardez les mots de passe XOR en ASCII pur
Quand Open rencontre un enregistrement FILEPASS et que le mot de passe manque ou est faux, TXLSWorkbook.OnPassword se déclenche. Le handler est un TXLSPasswordEvent avec un var PassWord: WideString et un var Retry: Boolean ; affectez un nouveau mot de passe et mettez Retry à True pour réessayer, jusqu'à trois tentatives. Laisser Retry à False fait renvoyer à Open le code d'erreur de mot de passe :
procedure TImportForm.WorkbookPassword(Sender: TObject;
var PassWord: WideString; var Retry: Boolean);
var
S: string;
begin
S := '';
Retry := InputQuery('Protected workbook', 'Password:', S);
PassWord := S;
end;
procedure TImportForm.ImportLegacyFile(const FileName: string);
var
Wb: IXLSWorkbook;
Rc: Integer;
begin
Wb := TXLSWorkbook.Create;
Wb.OnPassword := WorkbookPassword;
Rc := Wb.Open(FileName);
// -1003 : mot de passe requis mais aucun fourni ; -1005 : mot de passe erroné
if Rc <> 1 then
raise Exception.CreateFmt('Cannot open %s (code %d)', [FileName, Rc]);
ShowMessage(VarToStr(Wb.Sheets[1].Range['A1', 'A1'].Value));
end;
Si le mot de passe est déjà connu, la surcharge Open(FileName, APassWord) le passe d'emblée et l'événement ne se déclenche que si ce mot de passe échoue
L'obfuscation XOR vaut-elle la peine d'être écrite ?
L'obfuscation XOR BIFF tient un utilisateur occasionnel à l'écart d'un fichier et ne fait rien contre un motivé. Le contrôle de mot de passe est un vérificateur de 16 bits, la clé fait 16 bits, et le tableau de 16 octets se répète sur tout le flux, si bien que des contenus d'enregistrements BIFF prévisibles exposent des octets du tableau sans aucun mot de passe. La seule raison de l'écrire aujourd'hui est un consommateur historique qui lit des fichiers Excel 5.0/95 et rien de plus récent, parce que BIFF5 n'offre aucun autre schéma
Le moteur classique choisit le schéma via TXLSWorkbook.EncryptionType et contrôle strictement la combinaison avec le format d'enregistrement :
xletAuto(le défaut) écrit RC4 CryptoAPI pourxlExcel97et XOR pourxlExcel5, à l'image de ce qu'Excel lui-même écrivait pour chaque formatxletXorn'est valable que pour le BIFF5 ; avecxlExcel97l'enregistrement lève une exception au lieu de retomber sur un autre schémaxletRC4etxletRC4CryptoAPIsont BIFF8 uniquement, et les demander sur un enregistrement BIFF5 lève aussi une exception
Laissez EncryptionType à xletAuto dans du code qui peut enregistrer l'un ou l'autre format. Il retombe toujours sur le schéma le plus fort que le format cible prend en charge, et il ne peut pas lever l'exception d'incompatibilité qu'un xletXor explicite lève le jour où quelqu'un bascule l'enregistrement vers xlExcel97
RC4 est daté lui aussi, et le rendre interopérable a ses propres pièges, traités dans pourquoi Excel rejette un classeur chiffré avec un mot de passe correct. Si le destinataire sait lire le XLSX, sautez les formats historiques et utilisez le moteur XLSX : TXLSXWorkbook.SaveAsEncryptedAgile écrit Agile Encryption (hachage de mot de passe SHA-512 avec un spin count de 100 000 itérations et AES-256-CBC), le conteneur qu'Excel 2010 et suivants écrivent par défaut, tandis que SaveAsEncrypted écrit le Standard Encryption AES-128 plus ancien. Les arbitrages entre les deux sont dans le chiffrement XLSX avec AES en Delphi, et le côté lecture est couvert dans la lecture de fichiers Excel chiffrés Agile avec HotXLS
Contrôler la sortie XOR BIFF5 avant qu'Excel 16 la voie
- Enregistrez le même classeur deux fois avec le même mot de passe et comparez les corps FILEPASS dans un dump hexadécimal. Les deux copies doivent porter des mots identiques ; une clé qui change entre deux enregistrements a été remplie au hasard, et Excel 16 rejettera le mot de passe
- Pour le mot de passe
secret, le corps FILEPASS de 4 octets se lit4D 01 A7 DAsur disque, clé en premier, les deux mots en little-endian - Les 4 premiers octets de chaque BOUNDSHEET doivent se lire comme un décalage de flux en clair qui tombe sur un BOF de feuille ; s'ils ne pointent nulle part, la transformation a touché le préfixe et aucun analyseur ne peut localiser les feuilles sans le mot de passe
- Gardez les mots de passe de test en ASCII pur et à 15 caractères ou moins, pour que la clé, le vérificateur et le tableau voient les mêmes octets sur chaque machine
La même bibliothèque Delphi et C++Builder couvre le XOR BIFF5, le RC4 et le RC4 CryptoAPI BIFF8, le Standard et l'Agile Encryption XLSX, et le callback de mot de passe en lecture, avec chaque règle au niveau de l'octet ci-dessus appliquée à l'enregistrement. Éditions, plateformes prises en charge et téléchargement d'essai sont sur la page du HotXLS Delphi spreadsheet component