Eén omgekeerde byte in de EncryptedPackage-stream van een met wachtwoord beveiligde .xlsx houdt AES-CBC niet tegen om het geheel te ontcijferen met het juiste wachtwoord: het blok van 16 bytes dat de omgekeerde byte bevat verandert in ruis, en precies dezelfde bits gaan netjes om in de plaintext-blok erna. Encryptie alleen kan u niet vertellen dat dit gebeurd is. De verdediging zit in het element dataIntegrity van [MS-OFFCRYPTO] §2.3.4.14, een HMAC over de opgeslagen ciphertext die een lezer controleert voordat hij ook maar één segment ontcijfert
Agile-versleuteling, het schema dat Excel standaard schrijft voor werkboeken met een wachtwoord, geeft vertrouwelijkheid via AES in CBC-modus met een sleutel afgeleid uit een herhaald toegepaste SHA-512-wachtwoordhash. CBC is geen geauthenticeerde modus, dus het cipher heeft geen mening over of de ciphertext die het krijgt ook de ciphertext is die er is weggeschreven. Een gewijzigd package ontploft meestal later als ZIP- of deflate-fout, omdat een beschadigde gecomprimeerde stream de inflatie zelden overleeft. "Meestal" draagt veel gewicht in die zin, en een parsefout drie lagen dieper is een arme plek om te ontdekken dat iemand het bestand onderweg heeft bewerkt
Waarom ontcijfert een gemanipuleerd versleuteld werkboek nog steeds?
Een gemanipuleerd werkboek ontcijfert nog steeds omdat CBC blokken alleen aan elkaar ketent; hij authenticeert ze nooit. Elke ciphertext-blok wordt ontcijferd met de sleutel en daarna ge-XORd met de vorige ciphertext-blok, dus een verandering in blok n doorhaalt plaintext-blok n en keert precies dezelfde bits om in blok n+1. Wie de opbouw van de plaintext kent, kan dat tweede effect sturen. Wie die niet kent, kan toch data beschadigen op manieren waar een downstream-parser wel of niet iets van merkt
[MS-OFFCRYPTO] antwoordt hierop met een MAC berekend over de versleutelde bytes. De schrijver genereert een willekeurige HMAC-sleutel waarvan de lengte overeenkomt met de keyData-hashgrootte (64 bytes voor SHA-512), berekent een HMAC over de volledige EncryptedPackage-stream en bewaart beide waarden in het element dataIntegrity als encryptedHmacKey en encryptedHmacValue. Beide worden versleuteld met de packagesleutel, met IV's afgeleid uit de keyData-salt en twee vaste bloksleutels die de specificatie definieert. De HMAC dekt de stream zoals die is opgeslagen, inclusief het StreamSize-prefix van 8 bytes vóór de segmenten, dus zelfs de opgegeven plaintext-lengte kan niet onopgemerkt worden gewijzigd
De volgorde waarin HotXLS bij het openen controleert
HotXLS voert de integriteitscontrole uit nadat het wachtwoord is bewezen en voordat er ook maar één packagesegment wordt ontcijferd. TXLSXWorkbook.OpenEncrypted probeert eerst de Standard Encryption-lezer, en wanneer de EncryptionInfo-stream de Agile-handtekening (versie 4.4) draagt, neemt de Agile-pijplijn het over. Die pijplijn doorloopt deze stappen in volgorde:
- Voer de herhaalde wachtwoordhash uit met de salt en de spin count uit de descriptor; een
spinCountboven het specificatieplafond van 10.000.000 wordt behandeld als een misvormde descriptor en geweigerd voordat er ook maar gehasht wordt - Ontcijfer de wachtwoordverificateur, hash hem en vergelijk het resultaat met de opgeslagen verificateurhash; een mismatch hier betekent een verkeerd wachtwoord
- Wikkel de tussenliggende packagesleutel uit, ontcijfer daarna de HMAC-sleutel en de HMAC-waarde uit de
dataIntegrity-attributen - Bereken de HMAC over de EncryptedPackage-bytes precies zoals ze in het bestand staan, en vergelijk die met de opgeslagen waarde
- Pas na een match de segmenten van 4096 bytes ontcijferen en de binnenste ZIP aan de normale XLSX-lader overdragen
De MAC over ciphertext berekenen is de standaard encrypt-then-MAC-discipline. Een gemanipuleerd package wordt geweigerd voordat ook maar één byte onder invloed van de aanvaller AES-ontcijfering, inflatie of de XML-parser bereikt. Beide vergelijkingen in dit pad, de verificateurhash en de HMAC-waarde, OR-en samen de XOR van elk bytepaar over de volledige digest in plaats van terug te keren bij het eerste verschil, dus de responstijd verradt niet hoeveel voorloopbytes overeenkwamen. De hash-algoritme volgt de descriptor: Excel geeft SHA-512 op, sommige externe schrijvers geven SHA-256 op, en de HMAC, de IV's en de sleutelafleiding schakelen mee met wat de keyData- en wachtwoordsleutelversleutelingsknooppunten zeggen
Vanuit de blik van de aanroeper zijn een mislukte integriteitscontrole en een verkeerd wachtwoord dezelfde gebeurtenis. Beide laten OpenEncrypted een EXlsxEncryptionNotImplemented gooien met de boodschap "The supplied password is incorrect for this encrypted workbook." Een container die noch Standard noch Agile is, of een CFB-bestand dat niet leesbaar is, gooit dezelfde exceptionklasse met een andere boodschap. Alleen een geslaagde ontcijfering gevolgd door een mislukte lading van het binnenste werkboek komt terug als een andere returnwaarde dan 1
uses
SysUtils, lxHandleX;
// Opent een werkboek dat versleuteld moet aankomen
function OpenIntake(const FileName, Password: WideString): TXLSXWorkbook;
var
Book: TXLSXWorkbook;
begin
Book := TXLSXWorkbook.Create;
try
// OpenEncrypted valt terug op een gewone Open voor een onversleutelde ZIP,
// dus een pijplijn die encryption afdwingt moet eerst controleren
if not Book.CanReadEncrypted(FileName) then
raise Exception.Create('Not an encrypted package: ' + FileName);
// Verkeerd wachtwoord en HMAC-mismatch gooien beide EXlsxEncryptionNotImplemented
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;
// Aanroeper; Quarantine en ProcessWorkbook zijn uw eigen routines
try
Book := OpenIntake('incoming.xlsx', PasswordFromVault);
try
ProcessWorkbook(Book);
finally
Book.Free;
end;
except
on E: EXlsxEncryptionNotImplemented do
Quarantine('incoming.xlsx', E.Message);
end;
De CanReadEncrypted-bewaking telt zwaarder dan hij lijkt. Hij test op de OLE compound file-handtekening, en zonder hem zou iemand een versleuteld werkboek kunnen vervangen door een gewone .xlsx en zou OpenEncrypted hem laden alsof er niets aan de hand was. Een hernoemde legacy-.xls draagt die handtekening ook, en daarom komt hij door de bewaking heen en faalt hij vervolgens binnen OpenEncrypted met de boodschap over een niet-ondersteund versleutelingsschema
Packages schrijven die het blok dragen
SaveAsEncryptedAgile is de aanroep die een dataIntegrity-blok produceert. Hij serialiseert het werkboek naar een XLSX in het geheugen, versleutelt het met AES-256-CBC onder een SHA-512-sleutelafleiding met een spin count van 100.000, berekent een HMAC-SHA-512 over de voltooide EncryptedPackage-stream en schrijft beide versleutelde HMAC-blobs in de descriptor. SaveAsEncrypted schrijft in plaats daarvan ECMA-376 Standard Encryption (AES-128 met een SHA-1-sleutelafleiding), en de EncryptionInfo-structuur van Standard zoals gedefinieerd in [MS-OFFCRYPTO] heeft helemaal geen plek voor een integriteits-MAC. Voor alles wat een netwerk oversteekt of op een gedeelde schijf staat, gebruikt u de Agile-schrijver: hij kost geen extra code en hij is de enige van de twee waarvan een lezer de uitvoer op manipulatie kan controleren
var
Book: TXLSXWorkbook;
begin
Book := TXLSXWorkbook.Create;
try
BuildPayrollSheets(Book); // uw eigen code die het werkboek vult
// Open het weggeschreven containerbestand opnieuw via de ontcijferpijplijn
// en rapporteer falen in plaats van een kapot bestand achter te laten
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;
Met VerifyEncryptedSave aan opent de opslag het nieuwe bestand opnieuw met hetzelfde wachtwoord, dus een geverifieerde opslag is de HMAC-controle al één keer gepasseerd. Het willekeurige materiaal — beide salts van 16 bytes, de verificateurinvoer, de packagesleutel van 32 bytes en de HMAC-sleutel van 64 bytes — komt uit de CSPRNG van het besturingssysteem (CryptGenRandom op Windows). Kan die bron niet leveren, dan gooit de Agile-schrijver een exception in plaats van terug te vallen op een generator met tijdszaad. Die bytes worden salts en AES-sleutels; een voorspelbare terugval zou bestanden produceren die er versleuteld uitzien, elke functionele test passeren en niets beschermen. Een mislukte opslag is hier de betere uitkomst
Wat gebeurt er als een bestand geen dataIntegrity-blok heeft?
Het bestand opent gewoon. Veel Agile-versleutelde werkboeken in omloop komen van schrijvers die dataIntegrity weglaten, en die weigeren zou veel meer legitiem werk breken dan het stopt. HotXLS behandelt het blok alleen als aanwezig wanneer zowel encryptedHmacKey als encryptedHmacValue decodeert naar niet-lege, op 16 bytes uitgelijnde waarden; anders wordt de verificatie overgeslagen en verloopt de ontcijfering na de wachtwoordcontrole
Die compatibiliteitskeuze heeft een beveiligingsgevolg dat het schrijven waard is in uw threatmodel. Het element dataIntegrity zit in de EncryptionInfo-stream, buiten de bytes die zijn eigen MAC dekt, dus een ontbrekend blok lijkt precies op een blok dat een aanvaller heeft verwijderd. Beheerst u beide uiteinden van een pijplijn en gebruikt elke producent SaveAsEncryptedAgile, behandel dan een ontbrekend blok als beleidsfalen op applicatieniveau. De open-aanroep rapporteert niet of de verificatie heeft gedraaid, dus die regel afdwingen betekent dat u de EncryptionInfo-XML zelf leest met een compound-file-lezer voordat u het bestand doorgeeft. Voor bestanden van buitenaf: lees de controle voor wat hij is, een sterk signaal wanneer het blok er is, en helemaal geen signaal wanneer het ontbreekt
De OnPassword-hervatlus en gemanipuleerde bestanden
De gewone overload Open(FileName, Password) ontcijfert ook Standard- en Agile-packages, en hij voegt een hervatcontract toe dat OpenEncrypted niet heeft. Als het resultaat "verkeerd wachtwoord" is en OnPassword is toegewezen, roept het werkboek de handler aan, die een ander wachtwoord kan aanreiken en Retry op True kan zetten; de lus stopt na drie handler-aanroepen. Omdat een HMAC-mismatch datzelfde resultaat "verkeerd wachtwoord" oplevert, wordt een handler die simpelweg opnieuw vraagt tot drie keer toe aangeroepen voor een gemanipuleerd package, elke poging faalt, en de lus eindigt met de boodschap over het onjuiste wachtwoord. Het juiste wachtwoord faalt aan de HMAC, en elk ander wachtwoord faalt aan de verificateur
procedure TIntakeForm.BookPassword(Sender: TObject;
var PassWord: WideString; var Retry: Boolean);
begin
// Ook bereikt voor een package waarvan de HMAC niet matchte.
// Opnieuw vragen kan dat geval niet repareren, dus reik één fallbacksleutel aan
// en laat het volgende falen als fout opduiken
Inc(FPasswordCalls);
Retry := (FPasswordCalls = 1) and FetchFallbackKey(PassWord); // uw eigen functie
end;
// Koppeling
FPasswordCalls := 0;
Book.OnPassword := BookPassword;
Book.Open('incoming.xlsx', PasswordFromVault);
Voor onbeheerde intake laat u OnPassword niet toegewezen en roept u OpenEncrypted aan. De eerste mislukking gooit dan meteen een exception, en het quarantinelog boekt één gebeurtenis per bestand in plaats van een bos hervattingen
Wachtwoord om te wijzigen is afstemming, geen bescherming
Klassieke XLS-werkboeken kennen een apart mechanisme dat mensen vaak verwarren met encryptie: de write reservation achter de prompt "password to modify" van Excel. HotXLS legt hem bloot op IXLSWorkbook via SetModifyPassword, die het wachtwoord, een recommend-read-only-vlag en de reserverende gebruikersnaam neemt, en de toestand rapporteert via de property IsWriteReserved. Een leeg wachtwoord doorgeven heft de reservering op en laat de aparte WRITEACCESS-gebruikersnaam ongemoeid
De recordopbouw is kort. FILESHARING draagt de recommend-read-only-vlag, een legacy-wachtwoordhash van 16 bits en de gebruikersnaam als een ongecomprimeerde BIFF8 Unicode-tekenreeks; bij het opslaan zet HotXLS het lege WRITEPROT-markeringrecord vóór WRITEACCESS en FILESHARING zodra er een reservering bestaat, wat de File Protection Block-volgorde is die Excel verwacht. Reserveringen die Excel zelf schreef overleven een HotXLS-roundtrip via hetzelfde pad. Deze records worden alleen weggeschreven voor het BIFF8-formaat xlExcel97
var
Book: IXLSWorkbook; // interface-geteld: niet Free-en
begin
Book := TXLSWorkbook.Create;
if Book.Open('shared-model.xls') = 1 then
begin
// Aanbevelen alleen-lezen, gereserveerd door de rapportageservice
Book.SetModifyPassword('edit-me', True, 'Reporting Service');
if Book.IsWriteReserved then
Book.SaveAs('shared-model.xls', xlExcel97);
end;
end;
Een hash van 16 bits is een checksum, en de bladdata onder een write reservation is helemaal niet versleuteld; elk ander gereedschap leest elke cel. De functie vertelt de volgende persoon in Excel dat iemand dit bestand als het zijne beschouwt om te bewerken, in dezelfde categorie als de controles op bladniveau die in XLSX-bladbeveiliging en allow-opties worden behandeld. Vertrouwelijkheid komt uit de versleutelde opslapaden die in AES-beveiligde XLSX-uitvoer worden beschreven, en controles op containerniveau horen nog eerder in de keten, want de ZIP-structuur van een gewoon package wordt geparseerd voordat er ook maar werkboeklogica draait; ZIP-einde-central-directory-validatie voor onbetrouwbare XLSX behandelt die faalmodi
HotXLS leest en schrijft XLS, XLSX en ODS vanuit Delphi en C++Builder zonder een Excel-installatie, en zijn Standard- en Agile-versleutelingscode is in Pascal geschreven tegen [MS-OFFCRYPTO]. De volledige methodreferentie voor OpenEncrypted, SaveAsEncryptedAgile en SetModifyPassword staat op de HotXLS Delphi-spreadsheetcomponentpagina