Technischer Artikel

HotXLS XLS-XOR-Obfuskation: Schlüsselableitung und XorRor

Eine mit dem Passwort secret geschützte BIFF5-Arbeitsmappe kann einen Passwort-Verifier tragen, der perfekt passt, und Excel 16 trotzdem antworten lassen, das Passwort sei falsch. Excel akzeptiert die Datei nur, wenn der FILEPASS-Schlüssel gleich CreateXorKey_Method1(password) ist, das 16-Byte-XOR-Array mit XorRor gebaut ist und jedes Byte XorArrayIndex = (Stream-Offset + Record-Länge) mod 16 verwendet

Excel 16 hat zwei verschiedene Arten, eine solche Datei abzulehnen, und sie lassen sich sauber auf die Schichten von [MS-OFFCRYPTO] §2.3.7 mappen. Eine Passwort-Abfrage, die das richtige Passwort weiter ablehnt, zeigt auf das Schlüsselwort in FILEPASS. Eine Meldung, die Datei habe ein Problem und lasse sich nicht öffnen, angezeigt, nachdem das Passwort akzeptiert wurde, zeigt auf das XOR-Array oder auf den Index, der ein Array-Byte wählt. Die Abschnitte unten folgen dieser Reihenfolge, bis auf das Byte

Was der FILEPASS-Record in einer BIFF5-Datei speichert

Die BIFF-XOR-Obfuskation legt nur zwei 16-Bit-Wörter in der Datei ab, alles andere wird aus dem Passwort neu berechnet. Der FILEPASS-Record ($002F) sitzt direkt nach dem Workbook-Globals-BOF, und in einer BIFF5-Datei ist sein Body exakt 4 Bytes groß: der XOR-Schlüssel gefolgt vom Passwort-Verifier. Es gibt kein Salt, keinen Algorithmus-Identifier und keinen verschlüsselten Verifier-Blob, wie ihn die RC4- und AES-Schemata mitführen

Aus diesen zwei Wörtern baut ein Reader drei Dinge nach:

  • Den Verifier, einen 16-Bit-Hash der Passwort-Bytes, XOR-verknüpft mit der Passwort-Länge und $CE4B. Sein Vergleich mit dem gespeicherten Wort ist die dokumentierte Passwort-Prüfung
  • Den XOR-Schlüssel, einen 16-Bit-Wert aus CreateXorKey_Method1 in [MS-OFFCRYPTO] §2.3.7.2, getrieben von zwei Konstantentabellen (InitialCode, 15 Wörter, und XorMatrix, 105 Wörter)
  • Das XOR-Array, 16 Bytes aus den Passwort-Bytes, aufgefüllt mit einem festen 16-Byte-Pad, jedes XOR-verknüpft mit dem niedrigen Schlüsselbyte (gerade Positionen) oder dem hohen Schlüsselbyte (ungerade Positionen), danach rechts um ein Bit rotiert

Record-Header bleiben im Klartext. Ebenso eine Handvoll ganzer Records, die das Schema ausnimmt — BOF, FILEPASS, USREXCL, FILELOCK, INTERFACEHDR, RRDHEAD und RRDINFO — plus die ersten 4 Bytes jedes BOUNDSHEET. Jeder andere Record-Body wird Byte für Byte transformiert: Rotation links um 5 Bits, dann XOR mit einem Eintrag des 16-Byte-Arrays. Die Entschlüsselung, die §2.3.7.3 als DecryptData_Method1 ausschreibt, läuft als Spiegelbild: erst XOR, dann Rotation rechts um 5

HotXLS hält das alles hinter zwei Workbook-Properties. TXLSWorkbook.EncryptionPassword hält das Passwort, EncryptionType wählt das Schema, und SaveAs mit xlExcel5 emittiert FILEPASS direkt nach dem BOF und transformiert den Rest des Streams:

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 hat nur die XOR-Obfuskation; xletAuto wählt dasselbe Schema
  // für xlExcel5, die explizite Einstellung dokumentiert also nur die Absicht
  Wb.EncryptionType := xletXor;
  // ASCII, höchstens 15 Zeichen (siehe die Passwort-Notizen unten)
  Wb.EncryptionPassword := 'secret';

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

Warum meldet Excel ein falsches Passwort, obwohl der Verifier stimmt?

Excel leitet den Schlüssel aus dem getippten Passwort mit CreateXorKey_Method1 her und vergleicht ihn mit dem Schlüsselwort in FILEPASS, also scheitert eine Datei mit irgendeinem anderen Schlüssel an der Passwort-Prüfung, selbst wenn der Verifier korrekt ist. Die Spezifikation behandelt den Schlüssel als Funktion des Passworts, und Excel 16 erzwingt diese Lesart streng

Der verlockende Shortcut ist, das Schlüsselwort mit zwei zufälligen Bytes zu füllen. Auf dem Papier sieht das harmlos aus: der Verifier ist die dokumentierte Passwort-Prüfung, und das Array wird aus dem Schlüssel gebaut, den die Datei deklariert. Ein Reader, der den FILEPASS-Schlüssel als gegeben nimmt, öffnet diese Dateien ohne Murren, so überlebt der Shortcut in Code, der nur gegen sich selbst getestet wurde. Excel 16, mit derselben Datei und dem korrekten Passwort konfrontiert, lehnt an der Abfrage ab. HotXLS leitet den Schlüssel bei jedem Sichern her, also hält FILEPASS für das Passwort secret stets Schlüssel $014D und Verifier $DAA7

HotXLS-Diagramm des BIFF5-XOR-FILEPASS-Records, den Excel 16 beim Öffnen prüft: Der klartextliche Vier-Byte-Body hält den XOR-Schlüssel und den Passwort-Verifier, Excel leitet den Schlüssel aus dem getippten Passwort per CreateXorKey_Method1 her und weist einen zufälligen Schlüssel mit einer Passwort-Fehlermeldung ab, selbst wenn der Verifier passt; HotXLS speichert den abgeleiteten Schlüssel 014D für secret
Der FILEPASS-Body besteht nur aus zwei Wörtern, aber Excel leitet den Schlüssel aus Ihrem Passwort neu her und vergleicht; ein zufällig gefüllter Schlüssel fällt durch die Prüfung, selbst mit korrektem Verifier, weshalb HotXLS ihn stets ableitet

Die Ableitung ist kurz, sobald die zwei Tabellen stehen. Gehen Sie das Passwort ab seinem letzten Byte rückwärts durch, prüfen Sie Bit 6 jedes Bytes sieben Mal, während Sie es nach links schieben, und XOR-verknüpfen Sie bei jedem gesetzten Bit einen XorMatrix-Eintrag; der Tabellenindex startet beim letzten Eintrag, $68, und sinkt um eins pro Bit, ob das Bit gesetzt war oder nicht. Die Skizze unten bildet den Spezifikations-Algorithmus Schritt für Schritt nach und liefert dieselben Ergebnisse wie die Bibliothek. Sie ist eine Illustration für Ihren eigenen Reader, und keine dieser Routinen ist Teil der HotXLS-API:

// Prinzip-Skizze zu [MS-OFFCRYPTO] 2.3.7.2 CreateXorKey_Method1
// und CreateXorArray_Method1 (nur Illustration, keine 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;                       // der Schlüssel sieht nur 15 Bytes
  if Len = 0 then
    Exit;
  Result := InitialCode[Len - 1];
  Element := $68;                    // letzter XorMatrix-Eintrag
  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 rechts um ein 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;

Für secret ergibt das das Array 1F 32 17 B9 14 BA 7B 7F 59 DD 59 7F 7A C0 A6 DF. Zusammen mit Schlüssel $014D und Verifier $DAA7 haben Sie damit drei bekannte gute Werte, gegen die Sie asserten können, bevor Sie überhaupt Excel involvieren

HotXLS-Diagramm des XOR-Array-Aufbaus für die BIFF5-Obfuskation: Sechzehn Bytes aus Passwort und festem Pad werden an geraden Positionen mit dem niedrigen und an ungeraden Positionen mit dem hohen Schlüsselbyte XOR-verknüpft, danach per XorRor rechts um ein Bit rotiert, was das Fixture 1F 32 17 B9 für das Passwort secret liefert
Die Array-Bytes kommen aus dem Passwort, dem Pad und den zwei Schlüsselbytes, eine Rotation am Ende; Rotation links 2 ist nur äquivalent, wenn die Byte-Transformation in umgekehrter Reihenfolge läuft, und Excel folgt der Spezifikations-Reihenfolge

Um eins nach rechts rotieren – und warum Rotation links um zwei plausibel wirkt

Mit dem richtigen Schlüssel kommt Excel 16 an der Passwort-Abfrage vorbei und landet direkt im zweiten Fehler, der Meldung, die Datei habe ein Problem. Die übliche Ursache ist ein XOR-Array, das in die falsche Richtung rotiert wurde. §2.3.7.2 definiert den Array-Schritt als XorRor, eine Rotation rechts um ein Bit, doch eine Variante, die jedes Array-Byte links um 2 Bits rotiert, zirkuliert in mehreren BIFF-Implementierungen, und ein Reader, der auf derselben Variante basiert, merkt nie, dass etwas falsch ist

Excel 16 speichert keine Excel-5.0/95-Dateien, und es bietet beim Sichern von BIFF8 kein XOR an, es gibt also keine native Referenzdatei zum Diffen. Wenn Sie festnageln müssen, welche Kombination Ihr eigener Code implementiert, läuft die verlässliche Methode in die andere Richtung: einen Klartext-BIFF5-Stream schreiben, ihn unter jeder Kombination von drei unabhängigen Entscheidungen neu kodieren und Excel 16 jedes Ergebnis öffnen lassen:

EntscheidungOption AOption B
Array-RotationXorRor (Rotation rechts 1)Rotation links 2
Array-Index(Offset + Record-Länge) mod 16Offset mod 16
Reihenfolge der Byte-TransformationRotation links 5, dann XORXOR, dann Rotation links 5

Von den acht Dateien akzeptiert Excel 16 die Spezifikations-Kombination — XorRor, Rotation-dann-XOR, Record-Längen-Index — und exakt eine weitere, die nur anders aussieht. Rotation-links-2 gepaart mit XOR-dann-Rotation und demselben Index ist dieselbe Funktion in Verkleidung. Rotation verteilt über XOR, also gilt rol5(p xor rol2(b)) gleich rol5(p) xor rol7(b), und auf einem 8-Bit-Wert ist eine Rotation links um 7 eine Rotation rechts um 1. Kompakt: rol5 ∘ rol2 = ror1

Diese Identität erklärt, warum das Rotation-links-2-Array für sich genommen richtig aussieht. Es ist nur neben der entgegengesetzten Transformationsreihenfolge korrekt; gepaart mit der Spezifikations-Reihenfolge korrumpiert es jedes transformierte Byte. Jede Variante, die die Record-Länge aus dem Index streicht, scheitert ebenfalls, ganz gleich welche Rotation sie benutzt. Schreiben Sie die Spezifikations-Kombination und nichts sonst. Der algebraische Zwilling öffnet, aber er hinterlässt dem nächsten Maintainer zwei Abweichungen zum Reverse-Engineering, wo der Spezifikationstext keine hinterlässt

Wie wird XorArrayIndex für jedes Byte berechnet?

XorArrayIndex für ein Byte ist sein Offset im Workbook-Stream plus die Länge des gesamten Record-Datenblocks, zu dem es gehört, mod 16. Der Index startet also pro Record an einem record-abhängigen Wert neu und wächst darin um eins pro Byte. Der Spezifikations-Pseudocode nennt die Eingaben FileOffset und Data.Length, und es ist leicht, den ersten als bloßen Record-Start-Offset fehlzulesen

Drei Details entscheiden, ob Ihre Indizes mit Excels übereinstimmen:

  • Der 4-Byte-Record-Header wird nie transformiert, belegt aber trotzdem Stream-Positionen, das erste Body-Byte eines Records sitzt also bei Header-Offset + 4
  • Der Längen-Term ist die volle Record-Datenlänge, eingeschlossen jedes Klartext-Präfix, das die Transformation überspringt
  • BOUNDSHEET ist teilweise Klartext: Seine ersten 4 Bytes, lbPlyPos, der Stream-Offset des Sheet-BOF, bleiben lesbar, damit ein Parser die Sheets findet. Diese 4 Bytes überspringt die Transformation, zählen aber weiterhin zum Offset wie zur Record-Länge
HotXLS-Diagramm der XorArrayIndex-Regel für die BIFF5-XOR-Obfuskation: Jedes Body-Byte nutzt den Stream-Offset plus die volle Record-Datenlänge modulo 16, der klartextliche Vier-Byte-Header und das BOUNDSHEET-lbPlyPos-Präfix zählen weiterhin zum Offset, und das Ignorieren des Record-Längen-Terms verschiebt jeden Record
Der Array-Index startet einmal pro Record neu, nicht einmal pro Stream: Header und Klartext-Präfix belegen Positionen, die Record-Datenlänge speist den Modulo, und ein Reader und ein Writer, die beide diesen Term streichen, sind sich nur miteinander einig

Zusammengenommen ist die Transformation pro Record eine Sache von wenigen Zeilen. Auch das skizziert die Regel für Ihren eigenen Code; HotXLS wendet sie intern während SaveAs an:

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

// Obfuskiert einen Record-Body in place. BodyPos ist der Stream-Offset von
// Body[0], also der Record-Header-Offset + 4. PlainPrefix ist 4 für
// BOUNDSHEET, die volle Länge für BOF / FILEPASS, 0 für die meisten 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;

// Lesen ist das Spiegelbild: B := Body[I] xor Arr[...];
// dann Rotation rechts um 5, also Rol8(B, 3)

Ein Reader und ein Writer, die beide allein nach Stream-Position indizieren, streichen die Record-Länge auf beiden Seiten, also sind sie sich miteinander und mit niemand sonst einig. Auf der Lese-Seite berechnet HotXLS den Index aus der aktuellen Stream-Position plus der Klartext-Präfix-Länge plus der Anzahl transformierter Bytes — dieselbe Record-Länge, die der Writer benutzt hat

Dateien lesen, die das Rotation-links-2-Array verwenden

HotXLS öffnet auch XOR-Dateien, die mit dem Rotation-links-2-Array und einem zufälligen Schlüssel gebaut wurden, und hält sie anhand des FILEPASS-Schlüssels auseinander. Stimmt der gespeicherte Schlüssel mit dem aus dem Passwort abgeleiteten überein, baut der Reader das Spezifikations-XorRor-Array; weicht er ab, schaltet der Reader auf das Rotation-links-2-Array um. Excel-geschriebene Dateien tragen stets den abgeleiteten Schlüssel, sie nehmen also stets den Spezifikations-Pfad

Der Test ist eine Heuristik mit präziser Fehlerrate. Bei einer Datei, deren Schlüssel zufällig gefüllt wurde, liegt die Chance, dass er zufällig dem abgeleiteten entspricht und die Datei daher mit dem falschen Array gelesen wird, bei 1 zu 65.536. Der Schalter deckt nur die Array-Rotation ab; die Index-Regel bleibt fix, er gilt also für Dateien, die bereits den Record-Längen-Index verwenden. Eine solche Datei mit HotXLS zu öffnen und erneut zu sichern ergibt eine Datei, die Excel akzeptiert, denn der Writer benutzt stets den abgeleiteten Schlüssel und XorRor

Zwei Passwort-Details gelten für jede Datei, ganz gleich, welches Array sie benutzt:

  • Länge. CreateXorKey_Method1 liest nur die ersten 15 Passwort-Bytes, das ist das Spezifikations-Limit. HotXLS wendet diese Grenze auf den Schlüssel an und hält den Verifier beim vollen Passwort und das Array bei seiner 16-Byte-Regel, identisch auf der Lese- und der Schreibseite. Weil der Schlüssel nie mehr als 15 Bytes sieht, sind 15 Zeichen das praktische Maximum
  • Zeichensatz. HotXLS konvertiert das Passwort über die System-ANSI-Codepage in Bytes. Die Spezifikation beschreibt das Nehmen des niedrigen Bytes jedes UTF-16-Zeichens, was für ASCII übereinstimmt. Ohne Excel-Referenzdateien mit Nicht-ASCII-Passwörtern gibt es für den Rest keine Ground Truth, bleiben Sie bei XOR-Dateien also bei ASCII-Passwörtern

Wenn Open auf einen FILEPASS-Record trifft und das Passwort fehlt oder falsch ist, feuert TXLSWorkbook.OnPassword. Der Handler ist ein TXLSPasswordEvent mit einem var PassWord: WideString und einem var Retry: Boolean; weisen Sie ein neues Passwort zu und setzen Sie Retry auf True, um es erneut zu versuchen, bis zu drei Wiederholungen. Retry auf False zu lassen lässt Open den Passwort-Fehlercode zurückgeben:

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: Passwort erforderlich, aber keines geliefert; -1005: falsches Passwort
  if Rc <> 1 then
    raise Exception.CreateFmt('Cannot open %s (code %d)', [FileName, Rc]);
  ShowMessage(VarToStr(Wb.Sheets[1].Range['A1', 'A1'].Value));
end;

Ist das Passwort bereits bekannt, reicht die Überladung Open(FileName, APassWord) es vorab durch, und das Event feuert nur, wenn dieses Passwort scheitert

Ist XOR-Obfuskation überhaupt das Schreiben wert?

BIFF-XOR-Obfuskation hält einen Gelegenheitsnutzer aus einer Datei raus und macht gegen einen motivierten nichts. Die Passwort-Prüfung ist ein 16-Bit-Verifier, der Schlüssel hat 16 Bits, und das 16-Byte-Array wiederholt sich über den ganzen Stream, also legen vorhersehbare BIFF-Record-Inhalte die Array-Bytes ohne jedes Passwort offen. Der einzige Grund, das heute noch zu schreiben, ist ein Legacy-Consumer, der Excel-5.0/95-Dateien liest und nichts Neueres, denn BIFF5 bietet kein anderes Schema

Die klassische Engine wählt das Schema über TXLSWorkbook.EncryptionType, und die Kombination mit dem Speicherformat wird streng geprüft:

  • xletAuto (Default) schreibt RC4 CryptoAPI für xlExcel97 und XOR für xlExcel5, passend zu dem, was Excel selbst für jedes Format schrieb
  • xletXor ist nur für BIFF5 gültig; mit xlExcel97 wirft das Sichern eine Exception, statt still zurückzufallen
  • xletRC4 und xletRC4CryptoAPI sind nur für BIFF8, und ihre Anfrage bei einem BIFF5-Sichern wirft ebenfalls eine Exception

Lassen Sie EncryptionType auf xletAuto in Code, der beide Formate speichern kann. Es landet stets auf dem stärksten Schema, das das Zielformat unterstützt, und es kann die Mismatch-Exception nicht werfen, die ein explizites xletXor an dem Tag wirft, an dem jemand das Sichern auf xlExcel97 umstellt

RC4 ist auch in die Jahre gekommen, die Details der Interop-Fähigkeit behandelt warum Excel eine verschlüsselte Arbeitsmappe mit korrektem Passwort ablehnt. Kann der Empfänger XLSX lesen, nehmen Sie stattdessen die XLSX-Engine: TXLSXWorkbook.SaveAsEncryptedAgile schreibt Agile Encryption (SHA-512-Passwort-Hashing mit einem Spin-Count von 100.000 Iterationen und AES-256-CBC), das Format, das Excel 2010 und später standardmäßig schreiben, während SaveAsEncrypted die ältere AES-128-Standard-Verschlüsselung schreibt. Die Abwägungen zwischen beiden finden sich in XLSX-Dateien mit AES in Delphi verschlüsseln, die Lese-Seite in Agile-verschlüsselte Excel-Dateien mit HotXLS lesen

BIFF5-XOR-Ausgabe prüfen, bevor Excel 16 sie sieht

  • Sichern Sie dieselbe Arbeitsmappe zweimal mit demselben Passwort und vergleichen Sie die FILEPASS-Bodies in einem Hex-Dump. Beide Kopien sollten identische Wörter halten; ein Schlüssel, der zwischen Sicherungen wechselt, wurde zufällig gefüllt, und Excel 16 wird das Passwort ablehnen
  • Für das Passwort secret liest sich der 4-Byte-FILEPASS-Body auf der Platte als 4D 01 A7 DA, Schlüssel zuerst, beide Wörter little-endian
  • Die ersten 4 Bytes jedes BOUNDSHEET sollten sich als Klartext-Stream-Offset lesen, der auf einem Sheet-BOF landet; zeigen sie ins Leere, hat die Transformation das Präfix angefasst, und kein Parser kann die Sheets ohne das Passwort finden
  • Halten Sie Test-Passwörter bei purem ASCII und 15 Zeichen oder weniger, damit Schlüssel, Verifier und Array auf jeder Maschine dieselben Bytes sehen

Dieselbe Delphi- und C++Builder-Bibliothek deckt BIFF5-XOR, BIFF8-RC4 und RC4 CryptoAPI, XLSX-Standard- und Agile Encryption sowie den Passwort-Callback auf der Lese-Seite ab, mit jeder Byte-Level-Regel von oben beim Sichern angewandt. Editionen, unterstützte Plattformen und ein Testdownload finden sich auf der Seite zur HotXLS Delphi spreadsheet component