Ein Kunde lädt eine Arbeitsmappe hoch, die an seinem Arbeitsplatz problemlos öffnet, und der Importdienst weist sie mit einem ZIP-Fehler zurück. Ein Hexdump der ersten acht Bytes zeigt D0 CF 11 E0 A1 B1 1A E1, die OLE-Compound-File-Signatur, die eine .xls aus dem Jahr 1997 trägt. Die Datei hat die Endung .xlsx, sie stammt aus einem aktuellen Excel, und sie ist gar kein ZIP-Paket. Jemand hat im Speichern-unter-Dialog ein Passwort gesetzt
Das ist das ganze Mysterium. Speichert Excel eine Arbeitsmappe mit einem Passwort, verschlüsselt es das eigentliche .xlsx-ZIP und verpackt das Ergebnis in einem Compound File Binary (CFB)-Container, nach dem Agile-Schema aus [MS-OFFCRYPTO] §2.3.4.10 bis §2.3.4.15. Jeder Loader, der Dateien anhand der Endung klassifiziert oder jede .xlsx direkt an einen ZIP-Reader durchreicht, wirft den Upload an einen Nutzer zurück, der aus seiner Sicht nichts Ungewöhnliches getan hat
Was in einer Agile-verschlüsselten Arbeitsmappe steckt
Eine Agile-verschlüsselte Arbeitsmappe ist ein CFB-Container mit zwei relevanten Streams: EncryptionInfo, das beschreibt, wie die Verschlüsselung durchgeführt wurde, und EncryptedPackage, das das ursprüngliche ZIP als einen opaken, verschlüsselten Blob hält. HotXLS liest beide Streams direkt aus dem Container, ohne Excel, COM oder eine externe Krypto-DLL auf der Maschine
Was Agile vom älteren Standard Encryption unterscheidet: EncryptionInfo beschreibt sich selbst. Nach einem 8-Byte-Präfix, dessen Major- und Minor-Version beide 4 sind, ist der Stream ein UTF-8-XML-Deskriptor. Ein keyData-Element nennt die Chiffre (AES), den Verkettungsmodus (ChainingModeCBC), den Hashalgorithmus, die Schlüssellänge in Bit, die Blockgröße und einen Base64-Salt. Der Passwort-keyEncryptor trägt seinen eigenen Salt, einen spinCount und drei Base64-Nutzdaten: encryptedVerifierHashInput, encryptedVerifierHashValue und encryptedKeyValue. Ein dataIntegrity-Element ergänzt einen verschlüsselten HMAC-Schlüssel und HMAC-Wert zur Manipulationserkennung
Excel selbst schreibt AES-256, SHA-512 und einen Spin Count von 100.000. Der Deskriptor darf aber etwas anderes behaupten, und Drittanbieter-Writer tun das. HotXLS nimmt keyBits aus dem Deskriptor, statt 256 anzunehmen, sodass AES-128- und AES-192-Dateien genauso entschlüsselt werden, und es akzeptiert hashAlgorithm="SHA256" ebenso wie SHA-512. Der eigene Hash-Attribut eines Elements steuert die Schritte, die zu ihm gehören: Der keyEncryptor-Hash treibt Passwortableitung und -verifizierung, während der keyData-Hash die Segment-IVs und den Integritäts-HMAC steuert. Eine Datei, die beides mischt, öffnet trotzdem
Die Datei öffnen: OpenEncrypted oder Open mit Passwort
TXLSXWorkbook.OpenEncrypted nimmt einen Dateinamen und ein Passwort und gibt bei Erfolg 1 zurück, derselbe Vertrag wie Open. Es erschnüffelt die ersten acht Bytes mit CanReadEncrypted. Eine Datei ohne CFB-Signatur läuft über den gewöhnlichen Open-Pfad, und das Passwort wird ignoriert, sodass ein Importeur, der immer OpenEncrypted aufruft, an der Aufrufstelle keine Verzweigung braucht. Eine CFB-Datei wird zuerst als Standard Encryption versucht, und wenn das EncryptionInfo-Präfix die Agile-Version 4.4 trägt, übernimmt der Agile-Reader. Die entschlüsselten ZIP-Bytes gehen dann an den regulären XLSX-Loader im Speicher
Beide Einstiegspunkte nehmen einen Dateinamen. Open(Stream) verweigert einen Stream, der mit der CFB-Signatur beginnt, und wirft eine Exception, deren Meldung auf OpenEncrypted zeigt, sodass ein in einem TMemoryStream gehaltener Upload zuerst in eine temporäre Datei muss
uses
System.SysUtils, System.Classes, System.IOUtils, System.Variants, lxHandleX;
function ReadFirstCell(Upload: TMemoryStream;
const Password: WideString): WideString;
var
TempName: string;
Wb: TXLSXWorkbook;
begin
Result := '';
// Verschlüsselte Pakete werden aus einer Datei geöffnet, also den Upload auf Platte auslagern
TempName := TPath.GetTempFileName;
Wb := TXLSXWorkbook.Create;
try
Upload.SaveToFile(TempName);
// Schlichte .xlsx, Standard-verschlüsselte und Agile-verschlüsselte Dateien funktionieren hier alle
if Wb.OpenEncrypted(TempName, Password) = 1 then
Result := VarToWideStr(Wb.Sheets[1].Cells[1, 1].Value);
finally
Wb.Free;
TFile.Delete(TempName);
end;
end;
Das zweiparametrige Overload Open(FileName, Password) erreicht denselben Entschlüsselungscode, hat aber eine Sache, die OpenEncrypted nicht hat: das OnPassword-Ereignis. Schlägt das gelieferte Passwort fehl, feuert Open OnPassword, lässt den Handler ein neues Passwort zuweisen und Retry auf True setzen und fragt erneut, bis zu dreimal. Eine Desktop-Anwendung kann in diesem Handler eine Passwortabfrage unterbringen. Ein Server kann ihn für etwas anderes nutzen, worauf der letzte Abschnitt eingeht
Wie wird aus einem Passwort ein AES-Schlüssel?
Das Passwort entschlüsselt nie etwas direkt. Der erste Digest ist SHA-512 über den keyEncryptor-Salt, gefolgt von den UTF-16LE-Bytes des Passworts; dieser Digest wird dann spinCount-mal neu gehasht, wobei jede Runde den 32-Bit-Little-Endian-Rundenzähler vor den vorherigen Digest setzt. Mit Excels 100.000 Runden kostet jeder einzelne Passwortversuch einhunderttausend serielle SHA-512-Aufrufe. Das ist der Sinn des Spin Counts. Ein legitimes Öffnen zahlt ihn einmal, und ein Wörterbuchangriff zahlt ihn für jeden Versuch
Die Kette ist kurz genug, um sie nachzubauen, und das ist der schnellste Weg zu sehen, was ein Versuch auf der eigenen Hardware kostet. Die Skizze unten folgt §2.3.4.11 für einen SHA-512-Deskriptor und nutzt die öffentliche Funktion XlsSHA512 aus der Unit lxXlsxAgileDecrypt
uses
System.SysUtils, lxXlsxAgileDecrypt;
// H0 = SHA-512(salt + UTF-16LE(password))
// Hn = SHA-512(LE32(n - 1) + H(n-1)), SpinCount-mal wiederholt
function SpinHash(const Password: WideString; const Salt: TBytes;
SpinCount: Integer): TBytes;
var
Buf: TBytes;
PwdLen, I: Integer;
begin
PwdLen := Length(Password) * SizeOf(WideChar);
SetLength(Buf, Length(Salt) + PwdLen);
if Length(Salt) > 0 then
Move(Salt[0], Buf[0], Length(Salt));
if PwdLen > 0 then
Move(Password[1], Buf[Length(Salt)], PwdLen);
Result := XlsSHA512(Buf);
SetLength(Buf, 4 + 64);
for I := 0 to SpinCount - 1 do
begin
Buf[0] := Byte(I and $FF); // Rundenzähler, Little-Endian
Buf[1] := Byte((I shr 8) and $FF);
Buf[2] := Byte((I shr 16) and $FF);
Buf[3] := Byte((I shr 24) and $FF);
Move(Result[0], Buf[4], 64); // vorheriger Digest
Result := XlsSHA512(Buf);
end;
end;
Der gedrehte Hash ist immer noch kein Schlüssel. Drei Schlüssel fallen heraus, jeder durch erneutes Hashen des gedrehten Werts mit einem angehängten festen 8-Byte-Blockschlüssel: FE A7 D2 76 3B 4B 9E 79 für die Verifier-Eingabe, D7 AA 0F 6D 30 61 34 4E für den Verifier-Hash und 14 6E 0B E7 AB AC D0 D6 zum Entpacken des Paketschlüssels. Jedes Ergebnis wird auf die deklarierte Schlüssellänge gekürzt, 32 Bytes bei AES-256. Die Spezifikation definiert auch, was passiert, wenn ein Hash kürzer als der Schlüssel ausfällt: mit 0x36-Bytes auffüllen. Keine AES-Schlüsselgröße löst das bei SHA-256 oder SHA-512 tatsächlich aus, aber dieselbe 0x36-Regel greift, wenn der Passwort-Salt auf Blockgröße gestreckt wird, um als CBC-IV zu dienen
Der Spin Count wird aus der Datei gelesen, ist also auch eine Angriffsfläche: Ein Upload, der eine Milliarde Runden deklariert, würde einen CPU-Kern festnageln, bevor er scheitert. §2.3.4.11 kappt spinCount bei 10.000.000, und HotXLS meldet einen größeren Wert als nicht unterstützten Deskriptor, bevor irgendetwas gehasht wird. Für einen öffentlichen Upload-Endpunkt ist diese Kappe die richtige Vorgabe. Excels eigene 100.000 liegen weit darunter
Passwort-Verifizierung und die saltSize-Kürzungsfalle
HotXLS prüft das Passwort, bevor es das Paket anfasst. Es entschlüsselt encryptedVerifierHashInput mit dem ersten abgeleiteten Schlüssel, hasht das Ergebnis, entschlüsselt encryptedVerifierHashValue mit dem zweiten Schlüssel und vergleicht beide Digests über die volle Hash-Länge, ohne beim ersten unterschiedlichen Byte anzuhalten. Eine Abweichung beendet das Öffnen mit einem Falsch-Passwort-Ergebnis, und der Paketkörper wird unter einem falschen Schlüssel nie entschlüsselt. Ein falsches Passwort kann daher keine Arbeitsmappe voller plausibler Müllbytes produzieren
Ein Satz in der Spezifikation ist hier leicht misszulesen. §2.3.4.13 definiert den Verifier als saltSize Bytes an Zufallsdaten, wobei saltSize die Länge des Salts des Key Encryptors ist. Der entschlüsselte Verifier kommt auf ein Vielfaches des 16-Byte-AES-Blocks aufgefüllt zurück, also muss er vor dem Hashen auf saltSize zurückgestutzt werden. Excel schreibt saltSize und blockSize immer als 16, sodass Code, der auf die Blockgröße kürzt, jeden Test gegen Excel-Ausgabe besteht. Er weist dann das korrekte Passwort bei der ersten Datei eines Producer zurück, der einen 32-Byte-Salt gewählt hat. HotXLS kürzt auf die Salt-Länge, denn das ist es, was der Text sagt, und dass die beiden Zahlen in Excel-Dateien übereinstimmen, ist ein Zufall
Wie wird das EncryptedPackage entschlüsselt?
Der Paketschlüssel ist zufällig, nicht passwortabgeleitet. Der Writer hat ihn erzeugt, in encryptedKeyValue verschlüsselt, und HotXLS packt ihn mit dem dritten abgeleiteten Schlüssel aus und behält so viele Bytes, wie keyData in keyBits deklariert. Bevor ein einziges Segment entschlüsselt wird, prüft HotXLS dataIntegrity, wenn die Datei es trägt: HMAC-Schlüssel und -Wert werden mit dem Paketschlüssel entschlüsselt, und ein HMAC über den kompletten EncryptedPackage-Stream, Größenpräfix eingeschlossen, muss dem gespeicherten Wert entsprechen. Dateien ohne brauchbares dataIntegrity-Element überspringen diesen Schritt und öffnen trotzdem
Der Stream selbst beginnt mit einer 8-Byte-Little-Endian-Klartextgröße, gefolgt von Chiffretext in 4096-Byte-Segmenten. Jedes Segment bekommt seinen eigenen IV: der Hash aus dem keyData-Salt, gefolgt vom 32-Bit-Little-Endian-Segmentindex, gekürzt auf Blockgröße. Jedes Segment lässt sich daher für sich entschlüsseln, was prinzipiell wahlfreien Zugriff erlauben würde; HotXLS entschlüsselt das ganze Paket in den Speicher, weil der ZIP-Loader ohnehin das komplette Archiv will. Die deklarierte Größe wird vor dem Entschlüsseln gegen die tatsächliche Stream-Länge geprüft, sodass ein abgeschnittener Upload oder ein aufgeblähtes Größenfeld sauber scheitert. Nach dem letzten Segment wird der Puffer auf die deklarierte Größe gestutzt, was die bis zu 15 Bytes AES-Padding fallen lässt, und was bleibt, ist byte für byte das ZIP, das Excel verschlüsselt hat
Ein falsches Passwort von einer nicht unterstützten Datei unterscheiden
Jeder Verschlüsselungsfehler in OpenEncrypted und Open wirft EXlsxEncryptionNotImplemented, und die Meldung sagt, welcher Fall es ist: Das gelieferte Passwort ist falsch, oder die Datei nutzt ein Schema, das HotXLS nicht liest. HotXLS liest den Passwort-Key-Encryptor mit AES im CBC-Modus und SHA-512- oder SHA-256-Hashing, was abdeckt, was aktuelle Excel-Versionen schreiben; ein Container, der nur durch einen Zertifikats-Key-Encryptor geschützt ist, ein Deskriptor, der eine andere Chiffre nennt, oder ein CFB, der weder Standard noch Agile ist, etwa ein umbenanntes BIFF-.xls, bekommt die Meldung „nicht unterstützt“
Abgleichen über Meldungstexte ist spröde, zumal wenn die Ressource-Strings jemals lokalisiert werden. Das OnPassword-Ereignis liefert ein sauberes Signal: Open feuert es nur, wenn der Verifier oder die Integritätsprüfung das Passwort zurückweist, nie bei einem nicht unterstützten Schema. Für einen Importdienst ruft man Open(FileName, Password) mit einem Handler auf, der die Zurückweisung aufzeichnet, statt OpenEncrypted, das wirft, ohne irgendein Ereignis zu fragen
type
TUploadOutcome = (uoLoaded, uoPasswordRejected, uoUnreadable);
TUploadLoader = class
private
FPasswordRejected: Boolean;
procedure HandlePassword(Sender: TObject; var PassWord: WideString;
var Retry: Boolean);
public
function Load(Wb: TXLSXWorkbook;
const FileName, Password: WideString): TUploadOutcome;
end;
procedure TUploadLoader.HandlePassword(Sender: TObject;
var PassWord: WideString; var Retry: Boolean);
begin
// Wird nur gefeuert, wenn das Passwort (oder der Integritäts-HMAC) zurückgewiesen wurde
FPasswordRejected := True;
Retry := False; // auf einem Server fragt es niemanden; Open wirft als Nächstes
end;
function TUploadLoader.Load(Wb: TXLSXWorkbook;
const FileName, Password: WideString): TUploadOutcome;
begin
FPasswordRejected := False;
Wb.OnPassword := HandlePassword;
try
if Wb.Open(FileName, Password) = 1 then
Result := uoLoaded
else
Result := uoUnreadable;
except
on E: EXlsxEncryptionNotImplemented do
if FPasswordRejected then
Result := uoPasswordRejected // den Nutzer erneut fragen ist safe
else
Result := uoUnreadable; // ein Retry hilft nicht; E.Message loggen
end;
end;
Eine Falle bleibt auch bei dieser Trennung. Eine Integritätsabweichung wird genauso gemeldet wie ein falsches Passwort, sodass eine Arbeitsmappe, deren Chiffretext unterwegs beschädigt wurde, etwa durch einen Proxy, der den Body umschreibt, oder einen Upload, der mitten im Segment abbricht, als uoPasswordRejected zurückkommt, selbst wenn der Nutzer das richtige Passwort getippt hat. Scheitert derselbe Nutzer zweimal mit einem Passwort, auf das er schwört, fordern Sie die Datei erneut an, bevor Sie das Passwort erneut anfordern
Die Schreibseite nutzt dieselbe Maschinerie rückwärts. SaveAsEncryptedAgile erzeugt einen Agile-Container mit SHA-512-Schlüsselableitung, 100.000 Spin-Runden und AES-256-Paketverschlüsselung, SaveAsEncrypted erzeugt Standard Encryption, und VerifyEncryptedSave auf True lässt beide Aufrufe die gerade geschriebene Datei durch den Entschlüsselungspfad wieder öffnen und bei Scheitern -1 zurückgeben. Der Standard-Pfad wird im Artikel über AES-geschützte XLSX-Ausgaben durchgangen, und die RC4- und XOR-Schemata in alten BIFF-Dateien behandelt der Artikel über ECB- und RC4-Interoperabilität
Für eine Pipeline, die nie im Voraus weiß, ob der nächste Upload ein Passwort trägt, ist der oben beschriebene Reader, zusammen mit nativem XLS- und XLSX-Lesen und -Schreiben für Delphi und C++Builder, Teil des HotXLS Delphi Excel Component