Un singolo byte alterato dentro lo stream EncryptedPackage di un .xlsx protetto da password non impedisce ad AES-CBC di decifrare tutto con la password giusta: il blocco da 16 byte che contiene il byte alterato diventa rumore, e lo stesso bit si altera pulitamente nel blocco di plaintext che viene dopo. La sola cifratura non può dirvi che è successo. La difesa sta nell'elemento dataIntegrity di [MS-OFFCRYPTO] §2.3.4.14, un HMAC sul ciphertext memorizzato che un reader controlla prima di decifrare un solo segmento
La cifratura Agile, lo schema che Excel scrive per predefinito per i workbook protetti da password, vi dà confidenzialità tramite AES in modalità CBC con una chiave derivata da un hash della password SHA-512 iterato. CBC non è una modalità autenticata, quindi il cipher non ha alcuna opinione sul fatto che il ciphertext che ha davanti sia il ciphertext che è stato scritto. Un pacchetto modificato di solito esplode più tardi come errore ZIP o deflate, perché uno stream compresso corrotto raramente sopravvive alla decompressione. "Di solito" pesa molto in quella frase, e un errore di parser tre strati più in basso è un pessimo posto dove scoprire che qualcuno ha modificato il file in transito
Perché un workbook cifrato manomesso si decifra comunque?
Un workbook manomesso si decifra comunque perché CBC concatena solo i blocchi; non li autentica mai. Ogni blocco di ciphertext viene decifrato con la chiave e poi messo in XOR con il blocco di ciphertext precedente, quindi una modifica nel blocco n scombina il blocco di plaintext n e altera esattamente gli stessi bit nel blocco n+1. Chi conosce il layout del plaintext può guidare quel secondo effetto. Chi non lo conosce può comunque corrompere dati in modi che un parser a valle può notare oppure no
[MS-OFFCRYPTO] risponde con un MAC calcolato sui byte cifrati. Il writer genera una chiave HMAC casuale la cui lunghezza corrisponde alla dimensione hash del keyData (64 byte per SHA-512), calcola un HMAC sull'intero stream EncryptedPackage, e memorizza entrambi i valori nell'elemento dataIntegrity come encryptedHmacKey e encryptedHmacValue. Entrambi vengono cifrati con la chiave del pacchetto, usando IV derivati dal salt del keyData e due block key fissi definiti dalla specifica. L'HMAC copre lo stream così come è memorizzato, incluso il prefisso StreamSize da 8 byte davanti ai segmenti, quindi perfino la lunghezza del plaintext dichiarata non può essere alterata senza essere scoperta
L'ordine con cui HotXLS controlla le cose all'apertura
HotXLS esegue il controllo di integrità dopo che la password è stata provata e prima che qualsiasi segmento del pacchetto venga decifrato. TXLSXWorkbook.OpenEncrypted prova prima il reader di Standard Encryption, e quando lo stream EncryptionInfo porta la firma Agile (versione 4.4) la pipeline Agile prende il comando. Quella pipeline esegue questi passi in ordine:
- Esegue l'hash della password iterato con il salt e lo spin count dal descrittore; uno
spinCountsopra il tetto di 10.000.000 della specifica viene trattato come descrittore malformato e rifiutato prima che qualsiasi hashing parta - Decifra il password verifier, ne calcola l'hash, e confronta il risultato con l'hash del verifier memorizzato; una mancata corrispondenza qui significa password sbagliata
- Svela la chiave intermedia del pacchetto, poi decifra la chiave HMAC e il valore HMAC dagli attributi
dataIntegrity - Calcola l'HMAC sui byte EncryptedPackage esattamente come stanno nel file, e lo confronta con il valore memorizzato
- Solo dopo una corrispondenza, decifra i segmenti da 4096 byte e consegna lo ZIP interno al normale loader XLSX
Calcolare il MAC sul ciphertext è la disciplina standard encrypt-then-MAC. Un pacchetto manomesso viene rifiutato prima che qualsiasi byte controllato dall'attaccante raggiunga la decifratura AES, la decompressione o il parser XML. Entrambi i confronti in questo percorso, l'hash del verifier e il valore HMAC, fanno OR dello XOR di ogni coppia di byte attraverso l'intero digest invece di restituire alla prima differenza, così il tempo di risposta non rivela quanti byte iniziali corrispondessero. L'algoritmo di hash segue il descrittore: Excel dichiara SHA-512, alcuni writer di terze parti dichiarano SHA-256, e l'HMAC, gli IV e la derivazione della chiave passano a ciò che dicono i nodi keyData e password key encryptor
Dal lato del chiamante, un controllo di integrità fallito e una password sbagliata sono lo stesso evento. Entrambi fanno generare a OpenEncrypted una EXlsxEncryptionNotImplemented con il messaggio "The supplied password is incorrect for this encrypted workbook." Un contenitore che non è né Standard né Agile, o un file CFB illeggibile, genera la stessa classe di eccezione con un messaggio diverso. Solo una decifratura riuscita seguita da un caricamento fallito del workbook interno torna come valore di ritorno diverso da 1
uses
SysUtils, lxHandleX;
// Apre un workbook che deve arrivare cifrato
function OpenIntake(const FileName, Password: WideString): TXLSXWorkbook;
var
Book: TXLSXWorkbook;
begin
Book := TXLSXWorkbook.Create;
try
// OpenEncrypted ripiega su una Open semplice per uno ZIP non cifrato,
// quindi una pipeline che pretende la cifratura deve controllare prima
if not Book.CanReadEncrypted(FileName) then
raise Exception.Create('Not an encrypted package: ' + FileName);
// Password sbagliata e HMAC non corrispondente generano entrambi 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;
// Chiamante; Quarantine e ProcessWorkbook sono routine vostre
try
Book := OpenIntake('incoming.xlsx', PasswordFromVault);
try
ProcessWorkbook(Book);
finally
Book.Free;
end;
except
on E: EXlsxEncryptionNotImplemented do
Quarantine('incoming.xlsx', E.Message);
end;
La guardia CanReadEncrypted conta più di quanto sembri. Verifica la firma del compound file OLE, e senza di essa qualcuno potrebbe sostituire un workbook cifrato con un .xlsx ordinario e OpenEncrypted lo caricherebbe come se nulla fosse. Un legacy .xls rinominato porta anch'esso quella firma, ed è per questo che passa la guardia per poi fallire dentro OpenEncrypted con il messaggio di schema di cifratura non supportato
Scrivere pacchetti che portano il blocco
SaveAsEncryptedAgile è la chiamata che produce un blocco dataIntegrity. Serializza il workbook in un XLSX in memoria, lo cifra con AES-256-CBC sotto una derivazione di chiave SHA-512 con spin count di 100.000, calcola un HMAC-SHA-512 sullo stream EncryptedPackage finito, e scrive entrambi i blob HMAC cifrati nel descrittore. SaveAsEncrypted scrive invece ECMA-376 Standard Encryption (AES-128 con derivazione di chiave SHA-1), e la struttura EncryptionInfo Standard definita da [MS-OFFCRYPTO] non ha alcuno slot per un MAC di integrità. Per tutto ciò che attraversa una rete o sta su una condivisione, usate il writer Agile: non costa nulla in più in codice ed è l'unico dei due il cui output un reader può controllare contro le manomissioni
var
Book: TXLSXWorkbook;
begin
Book := TXLSXWorkbook.Create;
try
BuildPayrollSheets(Book); // il vostro codice che riempie il workbook
// Riaprite il contenitore scritto attraverso la pipeline di decifratura
// e segnalate il fallimento invece di lasciare dietro un file rotto
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;
Con VerifyEncryptedSave impostato, il salvataggio riapre il nuovo file con la stessa password, quindi un salvataggio verificato ha già passato una volta il controllo HMAC. Il materiale casuale, cioè entrambi i salt da 16 byte, l'input del verifier, la chiave del pacchetto da 32 byte e la chiave HMAC da 64 byte, arriva dal CSPRNG del sistema operativo (CryptGenRandom su Windows). Se quella fonte non può consegnare, il writer Agile genera un'eccezione invece di ripiegare su un generatore seminato col tempo. Quei byte diventano salt e chiavi AES; un fallback prevedibile produrrebbe file che sembrano cifrati, passano ogni test funzionale e non proteggono nulla. Un salvataggio fallito è l'esito migliore qui
Cosa succede quando un file non ha blocco dataIntegrity?
Il file si apre normalmente. Molti workbook cifrati Agile in circolazione vengono da writer che lasciano fuori dataIntegrity, e rifiutarli romperebbe molto più lavoro legittimo di quanto fermerebbe. HotXLS tratta il blocco come presente solo quando sia encryptedHmacKey che encryptedHmacValue si decodificano in valori non vuoti e allineati a 16 byte; altrimenti la verifica viene saltata e la decifratura procede dopo il controllo della password
Quella scelta di compatibilità ha una conseguenza di sicurezza che vale la pena scrivere nel vostro threat model. L'elemento dataIntegrity sta nello stream EncryptionInfo, fuori dai byte che il suo stesso MAC copre, quindi un blocco mancante assomiglia esattamente a un blocco che un attaccante ha cancellato. Se controllate entrambe le estremità di una pipeline e ogni produttore usa SaveAsEncryptedAgile, trattate un blocco mancante come un fallimento di policy a livello applicativo. La chiamata open non riporta se la verifica è girata, quindi far rispettare quella regola significa leggere l'XML EncryptionInfo da soli con un reader di compound file prima di consegnare il file. Per i file che arrivano dal mondo esterno, leggete il controllo per ciò che è: un segnale forte quando il blocco c'è, e nessun segnale quando manca
Il loop di retry OnPassword e i file manomessi
L'overload semplice Open(FileName, Password) decifra anche i pacchetti Standard e Agile, e aggiunge un contratto di retry che OpenEncrypted non ha. Quando il risultato è "wrong password" e OnPassword è assegnato, il workbook chiama l'handler, che può fornire un'altra password e impostare Retry a True; il loop si ferma dopo tre chiamate all'handler. Dato che una mancata corrispondenza HMAC produce quello stesso risultato "wrong password", un handler che semplicemente riproponga la richiesta viene chiamato fino a tre volte per un pacchetto manomesso, ogni tentativo fallisce, e il loop si chiude con il messaggio di password non corretta. La password corretta fallisce all'HMAC, e ogni altra password fallisce al verifier
procedure TIntakeForm.BookPassword(Sender: TObject;
var PassWord: WideString; var Retry: Boolean);
begin
// Si arriva qui anche per un pacchetto il cui HMAC non corrispondeva.
// Riproporre la richiesta non può sistemare quel caso, quindi offrite una sola chiave di fallback
// e lasciate che il fallimento successivo affiori come errore
Inc(FPasswordCalls);
Retry := (FPasswordCalls = 1) and FetchFallbackKey(PassWord); // funzione vostra
end;
// Cablaggio
FPasswordCalls := 0;
Book.OnPassword := BookPassword;
Book.Open('incoming.xlsx', PasswordFromVault);
Per un intake senza supervisione, lasciate OnPassword non assegnato e chiamate OpenEncrypted. Il primo fallimento allora genera subito un'eccezione, e il log di quarantena registra un evento per file invece di una raffica di retry
La password di modifica è coordinamento, non protezione
I workbook XLS classici supportano un meccanismo separato che la gente spesso confonde con la cifratura: la write reservation dietro alla richiesta di "password to modify" di Excel. HotXLS la espone su IXLSWorkbook tramite SetModifyPassword, che prende la password, un flag recommend-read-only e il nome utente che riserva, e riporta lo stato tramite la proprietà IsWriteReserved. Passare una password vuota cancella la riserva e lascia intatto il nome utente WRITEACCESS separato
Il layout dei record è corto. FILESHARING porta il flag recommend-read-only, un hash di password legacy a 16 bit e il nome utente come stringa Unicode BIFF8 non compressa; al salvataggio, HotXLS colloca il marcatore WRITEPROT vuoto prima di WRITEACCESS e FILESHARING ogni volta che esiste una riserva, che è l'ordine del File Protection Block che Excel si aspetta. Le riserve che Excel stesso ha scritto sopravvivono a un round trip HotXLS per lo stesso percorso. Questi record vengono scritti solo per il formato BIFF8 xlExcel97
var
Book: IXLSWorkbook; // conteggiato a interfaccia: non fare Free
begin
Book := TXLSWorkbook.Create;
if Book.Open('shared-model.xls') = 1 then
begin
// Consiglia sola lettura, riservato dal servizio di reporting
Book.SetModifyPassword('edit-me', True, 'Reporting Service');
if Book.IsWriteReserved then
Book.SaveAs('shared-model.xls', xlExcel97);
end;
end;
Un hash a 16 bit è un checksum, e i dati del foglio sotto una write reservation non sono cifrati per niente; qualsiasi altro strumento legge ogni cella. La funzionalità dice alla persona successiva in Excel che qualcuno considera questo file proprio da modificare, nella stessa categoria dei controlli a livello di foglio trattati in protezione dei fogli XLSX e opzioni allow. La confidenzialità arriva dai percorsi di salvataggio cifrato descritti in output XLSX protetto da AES, e i controlli a livello di contenitore stanno ancora prima nella catena, dato che la struttura ZIP di un pacchetto semplice viene analizzata prima di qualsiasi logica del workbook; validazione ZIP end-of-central-directory per XLSX non fidati copre quelle modalità di fallimento
HotXLS legge e scrive XLS, XLSX e ODS da Delphi e C++Builder senza un'installazione di Excel, e il suo codice di cifratura Standard e Agile è scritto in Pascal contro [MS-OFFCRYPTO]. Il riferimento completo dei metodi OpenEncrypted, SaveAsEncryptedAgile e SetModifyPassword è sulla pagina del componente foglio di calcolo Delphi HotXLS