Technischer Artikel

HotXLS: Manipulierte XLSX per Agile-HMAC erkennen

Ein einzelnes gekipptes Byte im EncryptedPackage-Stream einer passwortgeschützten .xlsx hindert AES-CBC nicht daran, das ganze Paket mit dem richtigen Passwort zu entschlüsseln: Der 16-Byte-Block mit dem gekippten Byte wird zu Rauschen, und dasselbe Bit kippt sauber im Klartext-Block danach. Verschlüsselung allein kann Ihnen das nicht sagen. Die Verteidigung steckt im dataIntegrity-Element aus [MS-OFFCRYPTO] §2.3.4.14, einem HMAC über den gespeicherten Chiffretext, den ein Reader prüft, bevor er auch nur ein Segment entschlüsselt

Agile-Verschlüsselung, das Schema, das Excel standardmäßig für passwortgeschützte Arbeitsmappen schreibt, gibt Ihnen Vertraulichkeit durch AES im CBC-Modus mit einem Schlüssel, der aus einem iterierten SHA-512-Passworthash abgeleitet wird. CBC ist kein authentifizierter Modus, also hat der Chiffre keine Meinung dazu, ob der Chiffretext vor ihm der Chiffretext ist, der geschrieben wurde. Ein manipuliertes Paket fliegt meist später als ZIP- oder Deflate-Fehler auf, weil ein beschädigter komprimierter Stream das Inflationieren selten übersteht. "Meist" trägt in diesem Satz viel Gewicht, und ein Parser-Fehler drei Schichten weiter unten ist ein schlechter Ort, um zu erfahren, dass jemand die Datei unterwegs editiert hat

Warum entschlüsselt eine manipulierte verschlüsselte Arbeitsmappe trotzdem?

Eine manipulierte Arbeitsmappe entschlüsselt trotzdem, weil CBC Blöcke nur aneinander verkettet, sie aber niemals authentifiziert. Jeder Chiffretext-Block wird mit dem Schlüssel entschlüsselt und dann mit dem vorherigen Chiffretext-Block per XOR verbunden, also verwürfelt eine Änderung in Block n den Klartext-Block n und kippt exakt dieselben Bits in Block n+1. Wer das Layout des Klartexts kennt, kann diesen zweiten Effekt steuern. Wer ihn nicht kennt, kann Daten trotzdem so beschädigen, dass ein nachgelagerter Parser es bemerken mag oder nicht

[MS-OFFCRYPTO] beantwortet das mit einem MAC über die verschlüsselten Bytes. Der Schreiber erzeugt einen zufälligen HMAC-Schlüssel, dessen Länge der keyData-Hash-Größe entspricht (64 Bytes bei SHA-512), berechnet einen HMAC über den kompletten EncryptedPackage-Stream und legt beide Werte im dataIntegrity-Element als encryptedHmacKey und encryptedHmacValue ab. Beide werden mit dem Paketschlüssel verschlüsselt, mit IVs, die aus dem keyData-Salt und zwei von der Spezifikation definierten festen Blockschlüsseln abgeleitet werden. Der HMAC deckt den Stream so ab, wie er gespeichert ist, einschließlich des 8-Byte-StreamSize-Präfixes vor den Segmenten, also lässt sich nicht einmal die deklarierte Klartext-Länge unbemerkt ändern

Die Reihenfolge, in der HotXLS beim Öffnen prüft

HotXLS führt die Integritätsprüfung aus, nachdem das Passwort bewiesen ist und bevor irgendein Paketsegment entschlüsselt wird. TXLSXWorkbook.OpenEncrypted versucht zuerst den Standard-Encryption-Reader, und wenn der EncryptionInfo-Stream die Agile-Signatur trägt (Version 4.4), übernimmt die Agile-Pipeline. Diese Pipeline läuft folgende Schritte in dieser Reihenfolge ab:

  1. Den iterierten Passworthash mit Salt und Spin-Count aus dem Descriptor laufen lassen; ein spinCount über der Spezifikationsgrenze von 10.000.000 wird als missgestalteter Descriptor behandelt und abgelehnt, bevor irgendetwas hasht
  2. Den Passwort-Verifier entschlüsseln, hashen und das Ergebnis mit dem gespeicherten Verifier-Hash vergleichen; eine Abweichung hier bedeutet ein falsches Passwort
  3. Den Zwischen-Paketschlüssel aufschlüsseln, dann den HMAC-Schlüssel und den HMAC-Wert aus den dataIntegrity-Attributen entschlüsseln
  4. Den HMAC über die EncryptedPackage-Bytes berechnen, exakt so, wie sie in der Datei liegen, und ihn mit dem gespeicherten Wert vergleichen
  5. Erst nach einer Übereinstimmung die 4096-Byte-Segmente entschlüsseln und das innere ZIP dem normalen XLSX-Loader übergeben

Den MAC über dem Chiffretext laufen zu lassen ist die übliche Encrypt-then-MAC-Disziplin. Ein manipuliertes Paket wird abgelehnt, bevor ein von Angreifern kontrolliertes Byte die AES-Entschlüsselung, das Inflationieren oder den XML-Parser erreicht. Beide Vergleiche in diesem Pfad, der Verifier-Hash und der HMAC-Wert, verodern die XOR-Verknüpfung jedes Bytepaars über das volle Digest, statt beim ersten Unterschied zurückzukehren, sodass das Antwort-Timing nicht verrät, wie viele führende Bytes übereinstimmten. Der Hash-Algorithmus folgt dem Descriptor: Excel deklariert SHA-512, manche Dritt-Schreiber deklarieren SHA-256, und HMAC, IVs und Schlüsselableitung schalten um auf das, was die keyData- und Passwort-Key-Encryptor-Knoten sagen

HotXLS: Flussdiagramm der dataIntegrity-Prüfungsreihenfolge: Schlüssel ableiten, HMAC-Schlüssel und -Wert entschlüsseln, HMAC-SHA-512 über den Chiffretext rechnen, Vergleich in konstanter Zeit, dann Segmente entschlüsseln oder zurückweisen
Das Integritätstor läuft, bevor irgendetwas entpackt wird: Der HMAC wird über den gespeicherten Chiffretext berechnet, daher wird ein falsches Passwort oder ein manipuliertes Paket am Tor verworfen, statt nach der Entschlüsselung als Datenmüll aufzutauchen

Aus Sicht des Aufrufers sind eine gescheiterte Integritätsprüfung und ein falsches Passwort dasselbe Ereignis. Beide lassen OpenEncrypted eine EXlsxEncryptionNotImplemented mit der Meldung "The supplied password is incorrect for this encrypted workbook." auslösen. Ein Container, der weder Standard noch Agile ist, oder eine CFB-Datei, die sich nicht lesen lässt, löst dieselbe Exception-Klasse mit einer anderen Meldung aus. Nur ein erfolgreiches Entschlüsseln, gefolgt von einem gescheiterten Laden der inneren Arbeitsmappe, kommt als Rückgabewert ungleich 1 zurück

uses
  SysUtils, lxHandleX;

// Öffnet eine Arbeitsmappe, die verschlüsselt ankommen muss
function OpenIntake(const FileName, Password: WideString): TXLSXWorkbook;
var
  Book: TXLSXWorkbook;
begin
  Book := TXLSXWorkbook.Create;
  try
    // OpenEncrypted fällt bei einem unverschlüsselten ZIP auf ein schlichtes Open zurück,
    // also muss eine Pipeline, die auf Verschlüsselung besteht, vorher prüfen
    if not Book.CanReadEncrypted(FileName) then
      raise Exception.Create('Not an encrypted package: ' + FileName);
    // Falsches Passwort und HMAC-Abweichung lösen beide EXlsxEncryptionNotImplemented aus
    if Book.OpenEncrypted(FileName, Password) <> 1 then
      raise Exception.Create('Decrypted, but the inner workbook did not load');
    Result := Book;
  except
    Book.Free;
    raise;
  end;
end;

// Aufrufer; Quarantine und ProcessWorkbook sind Ihre eigenen Routinen
try
  Book := OpenIntake('incoming.xlsx', PasswordFromVault);
  try
    ProcessWorkbook(Book);
  finally
    Book.Free;
  end;
except
  on E: EXlsxEncryptionNotImplemented do
    Quarantine('incoming.xlsx', E.Message);
end;

Der CanReadEncrypted-Guard ist wichtiger, als er aussieht. Er prüft auf die OLE-Compound-File-Signatur, und ohne ihn könnte jemand eine verschlüsselte Arbeitsmappe durch eine gewöhnliche .xlsx ersetzen, und OpenEncrypted würde sie laden, als sei nichts verkehrt. Eine in .xlsx umbenannte Legacy-.xls trägt diese Signatur ebenfalls, weswegen sie den Guard passiert und dann in OpenEncrypted mit der Meldung zum nicht unterstützten Verschlüsselungsschema scheitert

Pakete schreiben, die den Block tragen

SaveAsEncryptedAgile ist der Aufruf, der einen dataIntegrity-Block erzeugt. Er serialisiert die Arbeitsmappe in ein In-Memory-XLSX, verschlüsselt es mit AES-256-CBC unter einer SHA-512-Schlüsselableitung mit einem Spin-Count von 100.000, berechnet einen HMAC-SHA-512 über den fertigen EncryptedPackage-Stream und schreibt beide verschlüsselten HMAC-Blobs in den Descriptor. SaveAsEncrypted schreibt stattdessen ECMA-376 Standard Encryption (AES-128 mit SHA-1-Schlüsselableitung), und die Standard-EncryptionInfo-Struktur aus [MS-OFFCRYPTO] hat gar keinen Platz für einen Integritäts-MAC. Für alles, was ein Netzwerk überquert oder auf einer geteilten Platte liegt, nehmen Sie den Agile-Schreiber: Er kostet keinen zusätzlichen Code, und er ist der einzige der beiden, dessen Ausgabe ein Reader auf Manipulation prüfen kann

var
  Book: TXLSXWorkbook;
begin
  Book := TXLSXWorkbook.Create;
  try
    BuildPayrollSheets(Book);        // Ihr eigener Code, der die Arbeitsmappe füllt
    // Den geschriebenen Container über die Entschlüsselungs-Pipeline wieder öffnen
    // und scheitern melden, statt eine kaputte Datei zurückzulassen
    Book.VerifyEncryptedSave := True;
    if Book.SaveAsEncryptedAgile('payroll-2026-10.xlsx', PasswordFromVault) <> 1 then
      raise Exception.Create('Encrypted save failed or did not verify');
  finally
    Book.Free;
  end;
end;

Mit gesetztem VerifyEncryptedSave öffnet das Speichern die neue Datei erneut mit demselben Passwort, also hat eine verifizierte Speicherung die HMAC-Prüfung bereits einmal passiert. Das zufällige Material, also beide 16-Byte-Salts, die Verifier-Eingabe, der 32-Byte-Paketschlüssel und der 64-Byte-HMAC-Schlüssel, kommt aus dem CSPRNG des Betriebssystems (CryptGenRandom unter Windows). Kann diese Quelle nicht liefern, löst der Agile-Schreiber eine Exception aus, statt auf einen zeitgestützten Generator zurückzufallen. Diese Bytes werden Salts und AES-Schlüssel; ein vorhersagbarer Rückfall würde Dateien erzeugen, die verschlüsselt aussehen, jeden funktionalen Test bestehen und nichts schützen. Ein gescheitertes Speichern ist hier das bessere Ergebnis

Was passiert, wenn eine Datei keinen dataIntegrity-Block hat?

Die Datei öffnet sich normal. Viele Agile-verschlüsselte Arbeitsmappen im Umlauf stammen von Schreibern, die dataIntegrity weglassen, und sie abzulehnen würde weit mehr legitime Arbeit brechen, als es aufhalten würde. HotXLS behandelt den Block nur dann als vorhanden, wenn sowohl encryptedHmacKey als auch encryptedHmacValue zu nicht-leeren, an 16 Bytes ausgerichteten Werten dekodieren; sonst wird die Verifizierung übersprungen und nach der Passwortprüfung entschlüsselt

Diese Kompatibilitätsentscheidung hat eine sicherheitsrelevante Konsequenz, die man in sein Bedrohungsmodell schreiben sollte. Das dataIntegrity-Element sitzt im EncryptionInfo-Stream, außerhalb der Bytes, die sein eigener MAC deckt, also sieht ein fehlender Block exakt aus wie ein Block, den ein Angreifer gelöscht hat. Kontrollieren Sie beide Enden einer Pipeline und verwendet jeder Produzent SaveAsEncryptedAgile, behandeln Sie einen fehlenden Block als Policy-Verstoß auf Anwendungsebene. Der Öffnen-Aufruf meldet nicht, ob eine Verifizierung lief, also bedeutet die Durchsetzung dieser Regel, die EncryptionInfo-XML selbst mit einem Compound-File-Reader zu lesen, bevor man die Datei weiterreicht. Für Dateien aus der Außenwelt lesen Sie die Prüfung als das, was sie ist: ein starkes Signal, wenn der Block da ist, und gar kein Signal, wenn er fehlt

Die OnPassword-Retry-Schleife und manipulierte Dateien

Die schlichte Open(FileName, Password)-Überladung entschlüsselt ebenfalls Standard- und Agile-Pakete, und sie fügt einen Retry-Vertrag hinzu, den OpenEncrypted nicht hat. Lautet das Ergebnis "falsches Passwort" und ist OnPassword zugewiesen, ruft die Arbeitsmappe den Handler auf, der ein anderes Passwort liefern und Retry auf True setzen kann; die Schleife stoppt nach drei Handler-Aufrufen. Weil eine HMAC-Abweichung dasselbe "falsches Passwort"-Ergebnis produziert, wird ein Handler, der schlicht neu fragt, bei einem manipulierten Paket bis zu dreimal aufgerufen, jeder Versuch scheitert, und die Schleife endet mit der Meldung zum falschen Passwort. Das richtige Passwort scheitert am HMAC, und jedes andere scheitert am Verifier

procedure TIntakeForm.BookPassword(Sender: TObject;
  var PassWord: WideString; var Retry: Boolean);
begin
  // Wird auch erreicht für ein Paket, dessen HMAC nicht stimmte.
  // Neu zu fragen kann diesen Fall nicht reparieren, also einen einzigen Fallback-Schlüssel anbieten
  // und den nächsten Fehlschlag als Fehler auftreten lassen
  Inc(FPasswordCalls);
  Retry := (FPasswordCalls = 1) and FetchFallbackKey(PassWord); // Ihre eigene Funktion
end;

// Verdrahtung
FPasswordCalls := 0;
Book.OnPassword := BookPassword;
Book.Open('incoming.xlsx', PasswordFromVault);

Für unbeaufsichtigten Eingang lassen Sie OnPassword unzugewiesen und rufen OpenEncrypted auf. Der erste Fehlschlag löst dann sofort aus, und das Quarantäne-Protokoll verzeichnet ein Ereignis je Datei statt einer Serie von Retries

Passwort zum Ändern ist Koordination, kein Schutz

Klassische XLS-Arbeitsmappen unterstützen einen separaten Mechanismus, den Leute oft mit Verschlüsselung verwechseln: die Write Reservation hinter Excels "Kennwort zum Ändern"-Aufforderung. HotXLS legt sie über SetModifyPassword an IXLSWorkbook offen, das das Passwort, ein Recommend-read-only-Flag und den Namen des reservierenden Nutzers entgegennimmt und den Zustand über die Property IsWriteReserved meldet. Ein leeres Passwort zu übergeben löscht die Reservation und lässt den separaten WRITEACCESS-Nutzernamen unberührt

Das Record-Layout ist kurz. FILESHARING trägt das Recommend-read-only-Flag, einen Legacy-16-Bit-Passworthash und den Nutzernamen als unkomprimierten BIFF8-Unicode-String; beim Speichern stellt HotXLS die leere WRITEPROT-Markierung vor WRITEACCESS und FILESHARING, wann immer eine Reservation existiert, also in der File-Protection-Block-Reihenfolge, die Excel erwartet. Reservationen, die Excel selbst schrieb, überstehen einen HotXLS-Roundtrip über denselben Pfad. Diese Records werden nur für das BIFF8-Format xlExcel97 geschrieben

var
  Book: IXLSWorkbook;   // interface-gezählt: nicht Free aufrufen
begin
  Book := TXLSWorkbook.Create;
  if Book.Open('shared-model.xls') = 1 then
  begin
    // Read-only empfehlen, reserviert vom Reporting-Dienst
    Book.SetModifyPassword('edit-me', True, 'Reporting Service');
    if Book.IsWriteReserved then
      Book.SaveAs('shared-model.xls', xlExcel97);
  end;
end;

Ein 16-Bit-Hash ist eine Prüfsumme, und die Blatt-Daten unter einer Write Reservation sind überhaupt nicht verschlüsselt; jedes andere Tool liest jede Zelle. Das Feature sagt der nächsten Person in Excel, dass jemand diese Datei als seine zum Editieren betrachtet, in derselben Kategorie wie die in XLSX-Blattschutz- und Allow-Optionen behandelten Steuerungen auf Blattebene. Vertraulichkeit kommt von den in AES-geschützter XLSX-Ausgabe beschriebenen verschlüsselten Speicherpfaden, und Container-Prüfungen gehören sogar noch früher in die Kette, denn die ZIP-Struktur eines gewöhnlichen Pakets wird geparst, bevor irgendeine Arbeitsmappen-Logik läuft; ZIP-End-of-Central-Directory-Validierung für nicht vertrauenswürdige XLSX behandelt diese Fehlerbilder

HotXLS liest und schreibt XLS, XLSX und ODS aus Delphi und C++Builder ohne Excel-Installation, und sein Standard- und Agile-Verschlüsselungscode ist in Pascal gegen [MS-OFFCRYPTO] geschrieben. Die vollständige Methoden-Referenz für OpenEncrypted, SaveAsEncryptedAgile und SetModifyPassword steht auf der HotXLS-Delphi-Spreadsheet-Komponentenseite