Un cliente carica una cartella di lavoro che sul suo desktop si apre senza problemi, e il servizio di importazione la respinge con un errore ZIP. Un hex dump dei primi otto byte mostra D0 CF 11 E0 A1 B1 1A E1, la firma OLE Compound File che porta un .xls del 1997. Il file ha un'estensione .xlsx, esce da un Excel attuale, e non è per niente un pacchetto ZIP. Qualcuno ha impostato una password nella finestra Salva con nome
Tutto il mistero sta qui. Quando Excel salva una cartella di lavoro con una password, cifra il vero ZIP .xlsx e avvolge il risultato in un contenitore Compound File Binary (CFB), usando lo schema Agile di [MS-OFFCRYPTO] da §2.3.4.10 a §2.3.4.15. Qualsiasi loader che classifica i file per estensione, o che consegna ogni .xlsx direttamente a un reader ZIP, respingerà il caricamento a un utente che dal suo lato dello schermo non ha fatto nulla di insolito
Cosa si trova dentro una cartella di lavoro cifrata Agile
Una cartella di lavoro cifrata Agile è un contenitore CFB con due stream che contano: EncryptionInfo, che descrive come è stata fatta la cifratura, e EncryptedPackage, che tiene lo ZIP originale come un blob opaco e cifrato. HotXLS legge entrambi gli stream direttamente dal contenitore, senza Excel, COM, o una DLL di crittografia esterna sulla macchina
La parte che distingue Agile dalla più vecchia Standard Encryption è che EncryptionInfo descrive se stesso. Dopo un prefisso a 8 byte la cui versione major e minor sono entrambe 4, lo stream è un descrittore XML UTF-8. Un elemento keyData nomina il cifrario (AES), la chaining mode (ChainingModeCBC), l'algoritmo di hash, la lunghezza della chiave in bit, la dimensione del blocco e un salt Base64. Il keyEncryptor della password porta il proprio salt, uno spinCount, e tre payload Base64: encryptedVerifierHashInput, encryptedVerifierHashValue e encryptedKeyValue. Un elemento dataIntegrity aggiunge una chiave HMAC e un valore HMAC cifrati per la rilevazione delle manomissioni
Excel stesso scrive AES-256, SHA-512 e uno spin count di 100.000. Al descrittore però è permesso dire altro, e writer di terze parti lo fanno. HotXLS prende keyBits dal descrittore invece di assumere 256, quindi i file AES-128 e AES-192 si decifrano allo stesso modo, e accetta hashAlgorithm="SHA256" oltre a SHA-512. L'attributo hash di ogni elemento governa i passi che gli appartengono: l'hash del keyEncryptor pilota derivazione e verifica della password, mentre l'hash del keyData pilota gli IV dei segmenti e l'HMAC di integrità. Un file che mescola i due si apre comunque
Aprire il file: OpenEncrypted oppure Open con una password
TXLSXWorkbook.OpenEncrypted prende un nome file e una password e restituisce 1 in caso di successo, lo stesso contratto di Open. Annusa i primi otto byte con CanReadEncrypted. Un file senza la firma CFB passa per il percorso ordinario di Open e la password viene ignorata, quindi un importer che chiama sempre OpenEncrypted non ha bisogno di alcun ramo nel punto di chiamata. Un file CFB viene provato prima come Standard Encryption, e quando il prefisso EncryptionInfo porta la versione Agile 4.4 prende il comando il reader Agile. I byte ZIP decifrati finiscono poi nel consueto loader XLSX in memoria
Entrambi i punti di ingresso prendono un nome file. Open(Stream) rifiuta uno stream che inizia con la firma CFB e solleva un'eccezione il cui messaggio rimanda a OpenEncrypted, quindi un caricamento tenuto in un TMemoryStream deve prima atterrare in un file temporaneo
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 := '';
// i pacchetti cifrati si aprono da file, quindi scarica l'upload su disco
TempName := TPath.GetTempFileName;
Wb := TXLSXWorkbook.Create;
try
Upload.SaveToFile(TempName);
// file .xlsx normali, cifrati Standard e cifrati Agile funzionano tutti qui
if Wb.OpenEncrypted(TempName, Password) = 1 then
Result := VarToWideStr(Wb.Sheets[1].Cells[1, 1].Value);
finally
Wb.Free;
TFile.Delete(TempName);
end;
end;
L'overload a due argomenti Open(FileName, Password) raggiunge lo stesso codice di decifratura ma aggiunge una cosa che OpenEncrypted non ha: l'evento OnPassword. Quando la password fornita fallisce, Open fa scattare OnPassword, lascia che l'handler assegni una nuova password e imposti Retry a True, e chiede di nuovo, fino a tre volte. Un'applicazione desktop può mettere una richiesta di password in quell'handler. Un server può usarlo per altro, e l'ultima sezione arriva lì
Come fa una password a diventare una chiave AES?
La password non decifra mai nulla direttamente. Il primo digest è SHA-512 sul salt del keyEncryptor seguito dai byte UTF-16LE della password; quel digest viene poi riassato spinCount volte, ogni round anteponendo il contatore di round little-endiano a 32 bit al digest precedente. Con i 100.000 round di Excel, ogni singolo tentativo di password costa centomila chiamate seriali a SHA-512. È questo il punto dello spin count. Un'apertura legittima lo paga una volta, e un attacco a dizionario lo paga per ogni tentativo
La catena è abbastanza corta da poter essere riprodotta, e farlo è il modo più rapido per vedere quanto costa un tentativo sul vostro hardware. Lo schema qui sotto segue il §2.3.4.11 per un descrittore SHA-512 e usa la funzione pubblica XlsSHA512 della unit lxXlsxAgileDecrypt
uses
System.SysUtils, lxXlsxAgileDecrypt;
// H0 = SHA-512(salt + UTF-16LE(password))
// Hn = SHA-512(LE32(n - 1) + H(n-1)), ripetuto SpinCount volte
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); // contatore di round, 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); // digest precedente
Result := XlsSHA512(Buf);
end;
end;
L'hash girato non è ancora una chiave. Da esso escono tre chiavi, ciascuna riassando il valore girato una volta di più con una block key fissa da 8 byte accodata: FE A7 D2 76 3B 4B 9E 79 per l'input del verifier, D7 AA 0F 6D 30 61 34 4E per l'hash del verifier, e 14 6E 0B E7 AB AC D0 D6 per svelare la chiave del pacchetto. Ogni risultato viene tagliato alla lunghezza della chiave dichiarata, 32 byte per AES-256. La specifica definisce anche cosa succede quando un hash esce più corto della chiave: riempire con byte 0x36. Nessuna dimensione di chiave AES attiva in effetti questo caso con SHA-256 o SHA-512, ma la stessa regola dello 0x36 si applica quando il salt della password viene allungato alla dimensione del blocco per fare da IV CBC
Lo spin count viene letto dal file, quindi è anche una superficie d'attacco: un caricamento che dichiara un miliardo di round bloccherebbe un core di CPU prima di fallire. Il §2.3.4.11 pone un tetto di 10.000.000 a spinCount, e HotXLS riporta un valore maggiore come descrittore non supportato prima di fare hashing su qualunque cosa. Per un endpoint di caricamento pubblico quel tetto è il default giusto. I 100.000 di Excel stanno molto al di sotto
Verifica della password e la trappola del troncamento a saltSize
HotXLS controlla la password prima di toccare il pacchetto. Decifra encryptedVerifierHashInput con la prima chiave derivata, fa l'hash del risultato, decifra encryptedVerifierHashValue con la seconda chiave, e confronta i due digest sull'intera lunghezza dell'hash senza fermarsi al primo byte diverso. Una discrepanza chiude l'apertura con un esito password errata, e il corpo del pacchetto non viene mai decifrato sotto una chiave sbagliata. Una password errata quindi non può produrre una cartella di lavoro piena di spazzatura verosimile
Una frase della specifica qui è facile da fraintendere. Il §2.3.4.13 definisce il verifier come saltSize byte di dati casuali, dove saltSize è la lunghezza del salt del key encryptor. Il verifier decifrato torna riempito fino a un multiplo del blocco AES da 16 byte, quindi va tagliato di nuovo a saltSize prima dell'hash. Excel scrive sempre saltSize e blockSize come 16, il che significa che il codice che tronca alla dimensione del blocco supera ogni test su output di Excel. E poi rifiuta la password corretta sul primo file di un producer che ha scelto un salt da 32 byte. HotXLS tronca alla lunghezza del salt, perché è quello che dice il testo, e il fatto che i due numeri coincidano nei file di Excel è una coincidenza
Come viene decifrato l'EncryptedPackage?
La chiave del pacchetto è casuale, non derivata dalla password. Il writer l'ha generata, cifrata dentro encryptedKeyValue, e HotXLS la svela con la terza chiave derivata, tenendo quanti byte keyData dichiara in keyBits. Prima di decifrare un solo segmento, HotXLS controlla dataIntegrity quando il file la porta: la chiave e il valore HMAC vengono decifrati con la chiave del pacchetto, e un HMAC sull'intero stream EncryptedPackage, prefisso di dimensione incluso, deve combaciare con il valore memorizzato. I file scritti senza un elemento dataIntegrity utilizzabile saltano questo passo e si aprono comunque
Lo stream in sé inizia con una dimensione del plaintext a 8 byte little-endiana, seguita da ciphertext in segmenti da 4096 byte. Ogni segmento ottiene il proprio IV: l'hash del salt keyData seguito dall'indice di segmento little-endiano a 32 bit, tagliato alla dimensione del blocco. Qualsiasi segmento può quindi essere decifrato da solo, il che in linea di principio permetterebbe l'accesso casuale; HotXLS decifra l'intero pacchetto in memoria perché il loader ZIP vuole comunque l'archivio completo. La dimensione dichiarata viene confrontata con la lunghezza effettiva dello stream prima che la decifratura parta, quindi un caricamento troncato o un campo dimensione gonfiato fallisce pulito. Dopo l'ultimo segmento il buffer viene tagliato alla dimensione dichiarata, cosa che butta via i fino a 15 byte di padding AES, e ciò che resta è byte per byte lo ZIP che Excel ha cifrato
Distinguere una password sbagliata da un file non supportato
Ogni fallimento di cifratura in OpenEncrypted e Open solleva EXlsxEncryptionNotImplemented, e il messaggio dice di quale caso si tratta: la password fornita è incorretta, oppure il file usa uno schema che HotXLS non legge. HotXLS legge il key encryptor a password con AES in modalità CBC e hashing SHA-512 o SHA-256, il che copre ciò che le versioni attuali di Excel scrivono; un contenitore protetto solo da un key encryptor a certificato, un descrittore che nomina un altro cifrario, o un CFB che non è né Standard né Agile, come un BIFF .xls rinominato, riceve il messaggio di non supportato
Fare matching sul testo del messaggio è fragile, specie se le stringhe di risorsa un giorno venissero localizzate. L'evento OnPassword dà un segnale più pulito: Open lo fa scattare solo quando il verifier o il controllo di integrità rifiuta la password, mai per uno schema non supportato. Per un servizio di importazione, chiamate Open(FileName, Password) con un handler che registra il rifiuto, invece di OpenEncrypted, che solleva senza consultare alcun evento
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
// Scatta solo quando la password (o l'HMAC di integrità) è stata rifiutata
FPasswordRejected := True;
Retry := False; // su un server nessuno a cui chiedere; poi Open solleva
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 // si può chiedere di nuovo all'utente
else
Result := uoUnreadable; // un altro tentativo non serve; log E.Message
end;
end;
Una trappola resta anche con questa separazione. Una discrepanza di integrità viene riportata allo stesso modo di una password sbagliata, quindi una cartella di lavoro il cui ciphertext è stato danneggiato in transito, da un proxy che ha riscritto il body o da un caricamento troncato a metà segmento, torna come uoPasswordRejected anche quando l'utente ha scritto la password giusta. Se lo stesso utente fallisce due volte con una password che giura essere corretta, chiedete di nuovo il file prima di chiedere di nuovo la password
Il lato di scrittura usa la stessa macchina al contrario. SaveAsEncryptedAgile produce un contenitore Agile con derivazione della chiave SHA-512, 100.000 round di spin e cifratura del pacchetto AES-256, SaveAsEncrypted produce Standard Encryption, e impostare VerifyEncryptedSave a True fa sì che entrambe le chiamate riaprano il file appena scritto attraverso il percorso di decifratura e restituiscano -1 se fallisce. Il percorso Standard viene percorso passo passo nell'articolo sulla scrittura di output XLSX protetto da AES, e gli schemi RC4 e XOR trovati dentro i vecchi file BIFF sono trattati nell'articolo sull'interoperabilità ECB e RC4
Per una pipeline che non sa mai in anticipo se il prossimo caricamento porta con sé una password, il reader descritto sopra, insieme alla lettura e scrittura nativa di XLS e XLSX per Delphi e C++Builder, fa parte di HotXLS Delphi Excel Component