Technisch artikel

HotXLS XLS XOR-obfuscatie: sleutelafleiding en XorRor

Een BIFF5-workbook beveiligd met het wachtwoord secret kan een password verifier bevatten die perfect matcht en toch van Excel 16 als antwoord krijgen dat het wachtwoord onjuist is. Excel accepteert het bestand alleen als de FILEPASS-sleutel gelijk is aan CreateXorKey_Method1(password), de 16-byte XOR-array met XorRor is gebouwd, en elke byte XorArrayIndex = (stream-offset + recordlengte) mod 16 gebruikt

Excel 16 heeft twee verschillende manieren om zo'n bestand te weigeren, en die landen netjes op de lagen van [MS-OFFCRYPTO] §2.3.7. Een wachtwoordprompt die het juiste wachtwoord steeds blijft weigeren wijst naar het sleutelwoord in FILEPASS. De melding dat het bestand een probleem heeft en niet kan worden geopend, getoond nadat het wachtwoord is geaccepteerd, wijst naar de XOR-array of naar de index die een arraybyte kiest. De secties hieronder volgen die volgorde, tot op de byte

Wat het FILEPASS-record in een BIFF5-bestand bewaart

BIFF XOR-obfuscatie bewaart precies twee 16-bit woorden, en alles daarna wordt uit het wachtwoord herberekend. Het FILEPASS-record ($002F) zit direct na de workbook globals BOF, en in een BIFF5-bestand is zijn body 4 bytes lang: de XOR-sleutel, dan de password verifier. Er is geen salt. Er is ook geen algoritme-identificatie, en niets dat lijkt op de encrypted-verifier-blob die RC4- en AES-schema's meedragen

Uit die twee woorden bouwt een lezer drie waarden terug:

  • De verifier, een 16-bit hash van de wachtwoordbytes, ge-XORd met de wachtwoordlengte en $CE4B. Die vergelijken met het opgeslagen woord is de gedocumenteerde wachtwoordcontrole
  • De XOR-sleutel, een 16-bit waarde die CreateXorKey_Method1 in [MS-OFFCRYPTO] §2.3.7.2 produceert uit twee constante tabellen, InitialCode (15 woorden) en XorMatrix (105 woorden)
  • De XOR-array, 16 bytes opgebouwd uit de wachtwoordbytes aangevuld met een vaste pad van 16 bytes, elk ge-XORd met de lage sleutelbyte op even posities of de hoge sleutelbyte op oneven posities, en daarna een bit naar rechts geroteerd

Recordheaders blijven in platte tekst. Dat geldt ook voor een paar hele records die het schema uitzondert — BOF, FILEPASS, USREXCL, FILELOCK, INTERFACEHDR, RRDHEAD en RRDINFO — plus de eerste 4 bytes van elke BOUNDSHEET. Elke andere recordbody wordt byte voor byte getransformeerd: 5 bits naar links roteren, daarna XOR met een entry uit de 16-byte array. Ontcijferen, wat §2.3.7.3 als DecryptData_Method1 uitwerkt, draait het spiegelbeeld: eerst XOR, dan 5 naar rechts

HotXLS stopt dit alles achter twee workbookproperties. TXLSWorkbook.EncryptionPassword bevat het wachtwoord, EncryptionType kiest het schema, en SaveAs met xlExcel5 emitteert FILEPASS direct na BOF en transformeert de rest van de stream:

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;

  // BIFF5 kent alleen XOR-obfuscatie; xletAuto kiest hetzelfde schema
  // voor xlExcel5, dus de expliciete instelling documenteert vooral de intentie
  Wb.EncryptionType := xletXor;
  // ASCII, ten hoogste 15 tekens (zie de wachtwoordopmerkingen hieronder)
  Wb.EncryptionPassword := 'secret';

  if Wb.SaveAs(FileName, xlExcel5) <> 1 then
    raise Exception.Create('BIFF5 save failed');
end;

Waarom zegt Excel dat het wachtwoord verkeerd is terwijl de verifier matcht?

Excel leidt de sleutel af uit het getypte wachtwoord met CreateXorKey_Method1 en vergelijkt die met het sleutelwoord in FILEPASS, dus een bestand met een andere sleutel faalt op de wachtwoordcontrole zelfs als de verifier klopt. De specificatie behandelt de sleutel als een functie van het wachtwoord, en Excel 16 handhaaft die lezing streng

De verleidelijke shortcut is het sleutelwoord met twee willekeurige bytes vullen. Op papier ziet het er onschuldig uit: de verifier is de gedocumenteerde wachtwoordcontrole, en de array wordt opgebouwd vanuit de sleutel die het bestand zelf aangeeft. Een lezer die de FILEPASS-sleutel klakkeloos overneemt, opent die bestanden zonder mopperen, en zo overleeft de shortcut in code die alleen tegen zichzelf is getest. Excel 16, met hetzelfde bestand en het juiste wachtwoord, weigert bij de prompt. HotXLS leidt de sleutel bij elke opslag af, dus FILEPASS voor het wachtwoord secret bevat altijd sleutel $014D en verifier $DAA7

HotXLS-diagram van het BIFF5 XOR FILEPASS-record dat Excel 16 bij het openen controleert: de platte body van vier bytes bevat de XOR-sleutel en de password verifier, Excel leidt de sleutel uit het getypte wachtwoord af met CreateXorKey_Method1 en wijst een willekeurige sleutel af met een wachtwoordfout ook als de verifier matcht; HotXLS bewaart de afgeleide sleutel 014D voor secret
De FILEPASS-body is maar twee woorden, maar Excel leidt de sleutel opnieuw af uit je wachtwoord en vergelijkt; een willekeurig gevulde sleutel faalt op de controle ook met een correcte verifier, en daarom leidt HotXLS hem altijd af

De afleiding is kort zodra de twee tabellen staan. Loop het wachtwoord achterstevoren vanaf zijn laatste byte, test bit 6 van elke byte zeven keer terwijl je hem naar links verschuift, en XOR telkens een XorMatrix-entry erin als de bit is gezet; de tabelindex begint bij de laatste entry, $68, en daalt per bit met een, of de bit nu was gezet of niet. De schets hieronder reproduceert het specificatie-algoritme stap voor stap en geeft dezelfde resultaten als de bibliotheek. Het is een illustratie voor je eigen lezer, en geen van deze routines hoort bij de HotXLS-API:

// Schets van [MS-OFFCRYPTO] 2.3.7.2 CreateXorKey_Method1 en
// CreateXorArray_Method1 (alleen illustratie, geen HotXLS-API)
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;                       // de sleutel ziet maar 15 bytes
  if Len = 0 then
    Exit;
  Result := InitialCode[Len - 1];
  Element := $68;                    // laatste XorMatrix-entry
  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));   // een bit naar rechts roteren
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;

Voor secret levert dit de array 1F 32 17 B9 14 BA 7B 7F 59 DD 59 7F 7A C0 A6 DF op. Samen met sleutel $014D en verifier $DAA7 heb je daarmee drie bekende goede waarden om op te asserten voordat je Excel erbij haalt

HotXLS-diagram van de bouw van de XOR-array voor BIFF5-obfuscatie: zestien bytes gezaaid uit het wachtwoord en een vaste pad worden ge-XORd met de lage sleutelbyte op even posities en de hoge sleutelbyte op oneven posities, en daarna met XorRor een bit naar rechts geroteerd, wat voor het wachtwoord secret de array 1F 32 17 B9 oplevert
De arraybytes komen uit het wachtwoord, de pad en de twee sleutelbytes, met een rotatie aan het einde; 2 naar links roteren is alleen equivalent als de bytetransformatie in omgekeerde volgorde draait, en Excel volgt de volgorde van de specificatie

Een naar rechts roteren, en waarom 2 naar links plausibel oogt

Met de juiste sleutel komt Excel 16 voorbij de wachtwoordprompt en belandt meteen bij de tweede fout, de melding dat het bestand een probleem heeft. De gebruikelijke oorzaak is een XOR-array die de verkeerde kant op is geroteerd. §2.3.7.2 definieert de arraystap als XorRor, een rotatie van een bit naar rechts, toch circuleert in verschillende BIFF-implementaties een variant die elke arraybyte 2 bits naar links roteert, en een lezer op diezelfde variant merkt niets

Excel 16 slaat Excel 5.0/95-bestanden niet op, en biedt bij het opslaan van BIFF8 geen XOR aan, dus er is geen native voorbeeld om tegen te diffen. Als je wilt vastleggen welke combinatie je eigen code implementeert, werkt de betrouwbare methode andersom: schrijf een BIFF5-stream in platte tekst, codeer hem opnieuw onder elke combinatie van drie onafhankelijke keuzes, en laat Excel 16 elk resultaat openen:

KeuzeOptie AOptie B
Array-rotatieXorRor (1 naar rechts)2 naar links
Array-index(offset + recordlengte) mod 16offset mod 16
Volgorde van de bytetransformatie5 naar links, dan XORXOR, dan 5 naar links

Van de acht bestanden accepteert Excel 16 de specificatiecombinatie — XorRor, eerst roteren dan XOR, index met recordlengte — en precies een andere die alleen anders oogt. 2-naar-links gecombineerd met XOR-then-rotate en dezelfde index is dezelfde functie in vermomming. Rotatie distribueert over XOR, dus rol5(p xor rol2(b)) is gelijk aan rol5(p) xor rol7(b), en op een 8-bit waarde is een rotatie van 7 naar links een rotatie van 1 naar rechts. Kort gezegd: rol5 ∘ rol2 = ror1

Die identiteit verklaart waarom de 2-naar-links-array op zichzelf juist oogt. Hij klopt alleen naast de omgekeerde transformatievolgorde; naast de specificatievolgorde corrumpeert hij elke getransformeerde byte. Elke variant die de recordlengte uit de index laat vallen, faalt ook, welke rotatie hij ook gebruikt. Schrijf de specificatiecombinatie en niets anders. Het algebraische tweelingbestand opent, maar het laat de volgende onderhouder twee afwijkingen reverse-engineeren waar de specificatietekst er geen laat

Hoe wordt XorArrayIndex per byte berekend?

XorArrayIndex voor een byte is zijn offset in de workbookstream plus de lengte van de hele recorddata waar hij bij hoort, mod 16. De index begint daarom per record op een recordafhankelijke waarde en loopt per byte met een op. Het specificatie-pseudocode noemt de inputs FileOffset en Data.Length, en de eerste wordt gauw gelezen als louter de startoffset van het record

Drie details bepalen of uw indices uitlijnen met die van Excel:

  • De record-header van 4 bytes wordt nooit getransformeerd, maar hij bezet wél stream-posities, dus de eerste bodybyte van een record zit op header-offset + 4
  • De lengteterm is de volledige recorddatalengte, inclusief een platte prefix die de transformatie overslaat
  • BOUNDSHEET is deels plat: zijn eerste 4 bytes, lbPlyPos, de stream-offset van de sheet BOF, blijven leesbaar zodat een parser de sheets zonder wachtwoord kan vinden. Die 4 bytes worden door de transformatie overgeslagen maar tellen wel mee voor zowel de offset als de recordlengte
HotXLS-diagram van de XorArrayIndex-regel voor BIFF5 XOR-obfuscatie: elke bodybyte gebruikt de stream-offset plus de volledige recorddatalengte modulo 16, de platte header van vier bytes en de BOUNDSHEET lbPlyPos-prefix tellen nog steeds mee voor de offset, en de recordlengteterm negeren ontregelt elk record
De arrayindex begint opnieuw per record, niet per stream: de header en een platte prefix bezetten posities, de recorddatalengte voedt de modulo, en een lezer en writer die die term allebei laten vallen zijn het alleen met elkaar eens

Samengevat is de transformatie per record een paar regels. Zoals eerder: dit schetst de regel voor je eigen code; HotXLS past hem intern toe tijdens SaveAs:

function Rol8(B: Byte; N: Integer): Byte;
begin
  Result := Byte((B shl N) or (B shr (8 - N)));
end;

// Obfusceer één record-body in place. BodyPos is de stream-offset van
// Body[0], dus de record-header-offset + 4. PlainPrefix is 4 voor
// BOUNDSHEET, de volledige lengte voor BOF / FILEPASS, 0 voor de meeste records
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;

// Lezen is het spiegelbeeld: B := Body[I] xor Arr[...];
// daarna 5 naar rechts roteren, dus Rol8(B, 3)

Een lezer en een writer die allebei louter op streampositie indexeren, laten de recordlengte aan beide kanten vallen, zodat ze het met elkaar eens zijn en met niemand anders. Aan de leeskant berekent HotXLS de index uit de huidige streampositie plus de lengte van de platte prefix plus het aantal getransformeerde bytes — dezelfde recordlengte die de writer gebruikte

Bestanden lezen die de 2-naar-links-array gebruiken

HotXLS opent ook XOR-bestanden die met de 2-naar-links-array en een willekeurige sleutel zijn gebouwd, en hij houdt ze uit elkaar aan de FILEPASS-sleutel. Is de opgeslagen sleutel gelijk aan de sleutel die uit het wachtwoord is afgeleid, dan bouwt de lezer de XorRor-array uit de specificatie; wijkt hij af, dan schakelt de lezer over op de 2-naar-links-array. Door Excel geschreven bestanden dragen altijd de afgeleide sleutel, dus ze nemen altijd het specificatiepad

De test is een heuristiek met een precieze faalkans. Voor een bestand waarvan de sleutel willekeurig is gevuld, is de kans dat hij toevallig gelijk is aan de afgeleide sleutel — en dus met de verkeerde array wordt gelezen — 1 op 65.536. De schakelaar dekt alleen de arrayrotatie; de indexregel blijft vast, dus hij geldt voor bestanden die al de recordlengte-index gebruiken. Zo'n bestand met HotXLS openen en opnieuw opslaan levert een bestand op dat Excel accepteert, want de writer gebruikt altijd de afgeleide sleutel en XorRor

Twee wachtwoorddetails gelden voor elk bestand, welke array het ook gebruikt:

  • Lengte. CreateXorKey_Method1 leest alleen de eerste 15 wachtwoordbytes, wat de specificatielimiet is. HotXLS past die cap op de sleutel toe en houdt de verifier op het volledige wachtwoord en de array op zijn 16-byte regel, identiek aan lees- en schrijfkant. Omdat de sleutel maar 15 bytes ooit ziet, zijn 15 tekens het praktische maximum
  • Tekenset. HotXLS zet het wachtwoord via de systeem-ANSI-codepagina om naar bytes, voor sleutel, verifier en array alledrie. De specificatie beschrijft het nemen van de lage byte van elk UTF-16-teken, en voor ASCII zijn beide identiek. Zonder door Excel beveiligde voorbeelden met niet-ASCII-wachtwoorden is er geen ground truth voor iets anders, dus houd XOR-wachtwoorden bij plat ASCII

Als Open een FILEPASS-record treft en het wachtwoord ontbreekt of verkeerd is, gaat TXLSWorkbook.OnPassword af. De handler is een TXLSPasswordEvent met een var PassWord: WideString en een var Retry: Boolean; wijs een nieuw wachtwoord toe en zet Retry op True om het opnieuw te proberen, tot drie retries. Retry op False laten, laat Open de wachtwoordfoutcode teruggeven:

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: wachtwoord vereist maar geen opgegeven; -1005: verkeerd wachtwoord
  if Rc <> 1 then
    raise Exception.CreateFmt('Cannot open %s (code %d)', [FileName, Rc]);
  ShowMessage(VarToStr(Wb.Sheets[1].Range['A1', 'A1'].Value));
end;

Is het wachtwoord al bekend, dan geeft de overload Open(FileName, APassWord) het vooraf mee en gaat het event alleen af als dat wachtwoord faalt

Is XOR-obfuscatie het schrijven waard?

BIFF XOR-obfuscatie houdt een toevallige gebruiker uit een bestand en doet niets tegen een gemotiveerde. De wachtwoordcontrole is een 16-bit verifier, de sleutel is 16 bits, en de 16-byte array herhaalt zich over de hele stream, dus voorspelbare BIFF-recordinhouden leggen arraybytes bloot zonder enig wachtwoord. De enige reden om het vandaag nog te schrijven is een legacy-consument die Excel 5.0/95-bestanden leest en niets nieuwer, want BIFF5 biedt geen ander schema

De klassieke engine kiest het schema via TXLSWorkbook.EncryptionType en controleert de combinatie met het opslagformaat streng:

  • xletAuto (de default) schrijft RC4 CryptoAPI voor xlExcel97 en XOR voor xlExcel5, passend bij wat Excel zelf per formaat schreef
  • xletXor is alleen geldig voor BIFF5; bij xlExcel97 geeft de opslag een exception in plaats van uit te wijken naar een ander schema
  • xletRC4 en xletRC4CryptoAPI zijn alleen voor BIFF8, en het vragen van een van beide bij een BIFF5-opslag geeft ook een exception

Laat EncryptionType op xletAuto staan in code die beide formaten kan opslaan. Hij landt altijd op het sterkste schema dat het targetformaat ondersteunt, en hij kan de mismatch-exception niet geven die een expliciete xletXor geeft op de dag dat iemand de opslag naar xlExcel97 omschakelt

RC4 is ook gedateerd, en het interoperateerbaar maken kent eigen valkuilen, behandeld in waarom Excel een versleuteld workbook met een juist wachtwoord weigert. Kan de ontvanger XLSX lezen, sla dan de legacy-formaten over en gebruik de XLSX-engine: TXLSXWorkbook.SaveAsEncryptedAgile schrijft Agile Encryption (SHA-512-wachtwoordhashing met een spin count van 100.000 iteraties en AES-256-CBC), de container die Excel 2010 en later standaard schrijven, terwijl SaveAsEncrypted de oudere AES-128 Standard Encryption schrijft. De afwegingen tussen beide staan in XLSX-bestanden met AES versleutelen in Delphi, en de leeskant is behandeld in Agile-versleutelde Excel-bestanden lezen met HotXLS

BIFF5 XOR-uitvoer controleren voordat Excel 16 hem ziet

  • Sla hetzelfde workbook twee keer op met hetzelfde wachtwoord en vergelijk de FILEPASS-bodies in een hexdump. Beide kopieën moeten identieke woorden bevatten; een sleutel die tussen opslagen verandert, was willekeurig gevuld, en Excel 16 zal het wachtwoord weigeren
  • Voor het wachtwoord secret leest de 4-byte FILEPASS-body op schijf 4D 01 A7 DA, sleutel eerst, beide woorden little-endian
  • De eerste 4 bytes van elke BOUNDSHEET moeten als een platte stream-offset lezen die op een sheet BOF uitkomt; wijzen ze nergens heen, dan heeft de transformatie de prefix aangeraakt en kan geen parser de sheets zonder wachtwoord vinden
  • Houd testwachtwoorden bij plat ASCII en 15 tekens of minder, zodat sleutel, verifier en array op elke machine dezelfde bytes zien

Dezelfde Delphi- en C++Builder-bibliotheek dekt BIFF5 XOR, BIFF8 RC4 en RC4 CryptoAPI, XLSX Standard en Agile Encryption, en de password-callback aan de leeskant, met elke bytelevel-regel hierboven toegepast bij het opslaan. Edities, ondersteunde platforms en een trial-download staan op de HotXLS Delphi-spreadsheetcomponent-pagina