Article technique

Obfuscation XOR des XLS HotXLS : clé dérivée et XorRor

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_Method1 de [MS-OFFCRYPTO] §2.3.7.2 à partir de deux tables constantes, InitialCode (15 mots) et XorMatrix (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

Schéma HotXLS de l'enregistrement FILEPASS XOR BIFF5 qu'Excel 16 contrôle à l'ouverture : le corps simple de quatre octets porte la clé XOR et le vérificateur de mot de passe, Excel dérive la clé depuis le mot de passe tapé avec CreateXorKey_Method1 et rejette une clé aléatoire par une erreur de mot de passe même quand le vérificateur correspond ; HotXLS stocke la clé dérivée 014D pour secret
Le corps FILEPASS ne fait que deux mots, mais Excel redérive la clé depuis votre mot de passe et compare ; une clé remplie au hasard échoue au contrôle même avec un vérificateur correct, voilà pourquoi HotXLS la dérive toujours

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

Schéma HotXLS de la construction du tableau XOR pour l'obfuscation BIFF5 : seize octets issus du mot de passe et d'un bourrage fixe sont XORés avec l'octet bas de la clé aux positions paires et l'octet haut aux positions impaires, puis pivotés à droite d'un bit avec XorRor, produisant le tableau 1F 32 17 B9 pour le mot de passe secret
Les octets du tableau viennent du mot de passe, du bourrage et des deux octets de clé, une seule rotation à la fin ; rotation à gauche de 2 n'est équivalent que lorsque la transformation d'octet tourne dans l'ordre opposé, et Excel suit l'ordre de la spécification

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 :

ChoixOption AOption B
Rotation du tableauXorRor (rotation à droite de 1)Rotation à gauche de 2
Index du tableau(décalage + longueur d’enregistrement) mod 16décalage mod 16
Ordre de transformation d’octetRotation à gauche de 5, puis XORXOR, 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
Schéma HotXLS de la règle XorArrayIndex pour l'obfuscation XOR BIFF5 : chaque octet de corps utilise le décalage de flux plus la longueur complète de la donnée d'enregistrement modulo 16, l'en-tête simple de quatre octets et le préfixe lbPlyPos de BOUNDSHEET comptent quand même dans le décalage, et ignorer le terme de longueur d'enregistrement désaligne chaque enregistrement
L'index du tableau redémarre une fois par enregistrement, pas une fois par flux : l'en-tête et tout préfixe simple occupent des positions, la longueur de donnée d'enregistrement alimente le modulo, et un lecteur et un writer qui abandonnent tous deux ce terme ne sont d'accord qu'entre eux

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_Method1 ne 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 pour xlExcel97 et XOR pour xlExcel5, à l'image de ce qu'Excel lui-même écrivait pour chaque format
  • xletXor n'est valable que pour le BIFF5 ; avec xlExcel97 l'enregistrement lève une exception au lieu de retomber sur un autre schéma
  • xletRC4 et xletRC4CryptoAPI sont 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 lit 4D 01 A7 DA sur 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