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_Method1in [MS-OFFCRYPTO] §2.3.7.2 produceert uit twee constante tabellen,InitialCode(15 woorden) enXorMatrix(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
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
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:
| Keuze | Optie A | Optie B |
|---|---|---|
| Array-rotatie | XorRor (1 naar rechts) | 2 naar links |
| Array-index | (offset + recordlengte) mod 16 | offset mod 16 |
| Volgorde van de bytetransformatie | 5 naar links, dan XOR | XOR, 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
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_Method1leest 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 voorxlExcel97en XOR voorxlExcel5, passend bij wat Excel zelf per formaat schreefxletXoris alleen geldig voor BIFF5; bijxlExcel97geeft de opslag een exception in plaats van uit te wijken naar een ander schemaxletRC4enxletRC4CryptoAPIzijn 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
secretleest de 4-byte FILEPASS-body op schijf4D 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