Una cartella di lavoro BIFF5 protetta con la password secret può portare un verifier della password che combacia alla perfezione e far rispondere comunque a Excel 16 che la password non è corretta. Excel accetta il file solo quando la chiave del FILEPASS eguaglia CreateXorKey_Method1(password), l'array XOR a 16 byte è costruito con XorRor, e ogni byte usa XorArrayIndex = (offset di stream + lunghezza del record) mod 16
Excel 16 ha due modi diversi di rifiutare un simile file, e si mappano con pulizia sui livelli del [MS-OFFCRYPTO] §2.3.7. Una richiesta di password che continua a rifiutare la password giusta punta alla word chiave nel FILEPASS. Un report che il file ha un problema e non può essere aperto, mostrato dopo che la password è stata accettata, punta all'array XOR o all'indice che sceglie un byte dell'array. Le sezioni qui sotto seguono quell'ordine, fino al byte
Che cosa memorizza il record FILEPASS in un file BIFF5
L'offuscamento XOR di BIFF conserva nel file solo due word a 16 bit, e tutto il resto viene ricalcolato dalla password. Il record FILEPASS ($002F) sta subito dopo il BOF delle workbook globals, e in un file BIFF5 il suo corpo è lungo 4 byte: la chiave XOR, poi il verifier della password. Niente salt. Nanche un identificatore di algoritmo, e niente di simile al blob di verifier cifrato che portano gli schemi RC4 e AES
Da quelle due word un reader ricostruisce tre valori:
- Il verifier, un hash a 16 bit dei byte della password XORato con la lunghezza della password e
$CE4B. Confrontarlo con la word salvata è il controllo della password documentato - La chiave XOR, un valore a 16 bit prodotto da
CreateXorKey_Method1in [MS-OFFCRYPTO] §2.3.7.2 a partire da due tabelle di costanti,InitialCode(15 word) eXorMatrix(105 word) - L'array XOR, 16 byte fatti dei byte della password riempiti con un pad fisso a 16 byte, ognuno XORato con il byte basso della chiave alle posizioni pari o il byte alto alle posizioni dispari, poi ruotato a destra di un bit
Gli header dei record restano in chiaro. Così anche qualche record intero che lo schema esenta — BOF, FILEPASS, USREXCL, FILELOCK, INTERFACEHDR, RRDHEAD e RRDINFO — più i primi 4 byte di ogni BOUNDSHEET. Ogni altro corpo di record viene trasformato byte per byte: rotazione a sinistra di 5 bit, poi XOR con una voce dell'array a 16 byte. La decifratura, che il §2.3.7.3 descrive come DecryptData_Method1, esegue l'immagine speculare: prima XOR, poi rotazione a destra di 5
HotXLS tiene tutto questo dietro due proprietà del workbook. TXLSWorkbook.EncryptionPassword contiene la password, EncryptionType sceglie lo schema, e SaveAs con xlExcel5 emette FILEPASS subito dopo il BOF e trasforma il resto dello stream:
uses
SysUtils, lxHandle;
procedure SaveLegacyProtectedBook(const FileName: string);
var
Wb: IXLSWorkbook;
begin
Wb := TXLSWorkbook.Create;
Wb.Sheets.Add.Name := 'Ledger';
Wb.Sheets[1].Range['A1', 'A1'].Value := 'Account';
Wb.Sheets[1].Range['B1', 'B1'].Value := 1250.75;
// BIFF5 ha solo l'offuscamento XOR; xletAuto sceglie lo stesso schema
// per xlExcel5, così l'impostazione esplicita documenta solo l'intento
Wb.EncryptionType := xletXor;
// ASCII, al massimo 15 caratteri (vedi le note sulla password qui sotto)
Wb.EncryptionPassword := 'secret';
if Wb.SaveAs(FileName, xlExcel5) <> 1 then
raise Exception.Create('BIFF5 save failed');
end;
Perché Excel dice che la password è sbagliata quando il verifier combacia?
Excel deriva la chiave dalla password digitata con CreateXorKey_Method1 e la confronta con la word chiave del FILEPASS, quindi un file la cui chiave è qualsiasi altra cosa fallisce il controllo della password anche quando il verifier è corretto. La specifica tratta la chiave come una funzione della password, e Excel 16 impone questa lettura in modo rigoroso
La scorciatoia allettante è riempire la word chiave con due byte casuali. Sulla carta sembra innocua: il verifier è il controllo della password documentato, e l'array viene costruito dalla chiave che il file dichiara. Un reader che prende la chiave del FILEPASS per buona apre quei file senza protestare, ed è così che la scorciatoia sopravvive in codice provato solo contro se stesso. Excel 16, con lo stesso file e la password corretta, rifiuta alla richiesta. HotXLS deriva la chiave a ogni salvataggio, quindi il FILEPASS per la password secret contiene sempre la chiave $014D e il verifier $DAA7
La derivazione in sé è breve una volta che le due tabelle sono al loro posto. Percorri la password all'indietro dall'ultimo byte, testa il bit 6 di ogni byte sette volte mentre lo sposti a sinistra, e XORa dentro una voce di XorMatrix ogni volta che il bit è a 1; l'indice della tabella parte dall'ultima voce, $68, e scende di uno per bit, che il bit sia impostato o no. Lo schizzo qui sotto riproduce l'algoritmo della specifica passo per passo e dà gli stessi risultati della libreria. È un'illustrazione per il vostro reader, e nessuna di queste routine fa parte dell'API HotXLS:
// Schizzo di principio di [MS-OFFCRYPTO] 2.3.7.2 CreateXorKey_Method1
// e CreateXorArray_Method1 (solo illustrazione, non un'API HotXLS)
type
TXorArray = array [0..15] of Byte;
function DemoCreateXorKey(const Password: AnsiString): Word;
const
InitialCode: array [0..14] of Word = ($E1F0, $1D0F, $CC9C, $84C0, $110C,
$0E10, $F1CE, $313E, $1872, $E139, $D40F, $84F9, $280C, $A96A, $4EC3);
XorMatrix: array [0..104] of Word = (
$AEFC, $4DD9, $9BB2, $2745, $4E8A, $9D14, $2A09,
$7B61, $F6C2, $FDA5, $EB6B, $C6F7, $9DCF, $2BBF,
$4563, $8AC6, $05AD, $0B5A, $16B4, $2D68, $5AD0,
$0375, $06EA, $0DD4, $1BA8, $3750, $6EA0, $DD40,
$D849, $A0B3, $5147, $A28E, $553D, $AA7A, $44D5,
$6F45, $DE8A, $AD35, $4A4B, $9496, $390D, $721A,
$EB23, $C667, $9CEF, $29FF, $53FE, $A7FC, $5FD9,
$47D3, $8FA6, $0F6D, $1EDA, $3DB4, $7B68, $F6D0,
$B861, $60E3, $C1C6, $93AD, $377B, $6EF6, $DDEC,
$45A0, $8B40, $06A1, $0D42, $1A84, $3508, $6A10,
$AA51, $4483, $8906, $022D, $045A, $08B4, $1168,
$76B4, $ED68, $CAF1, $85C3, $1BA7, $374E, $6E9C,
$3730, $6E60, $DCC0, $A9A1, $4363, $86C6, $1DAD,
$3331, $6662, $CCC4, $89A9, $0373, $06E6, $0DCC,
$1021, $2042, $4084, $8108, $1231, $2462, $48C4);
var
Len, I, Bit, Element: Integer;
Ch: Byte;
begin
Result := 0;
Len := Length(Password);
if Len > 15 then
Len := 15; // la chiave vede solo 15 byte
if Len = 0 then
Exit;
Result := InitialCode[Len - 1];
Element := $68; // ultima voce di XorMatrix
for I := Len downto 1 do
begin
Ch := Ord(Password[I]);
for Bit := 1 to 7 do
begin
if (Ch and $40) <> 0 then
Result := Result xor XorMatrix[Element];
Ch := Byte(Ch shl 1);
Dec(Element);
end;
end;
end;
function XorRor(B, KeyByte: Byte): Byte;
begin
B := B xor KeyByte;
Result := Byte((B shr 1) or (B shl 7)); // rotazione a destra di un bit
end;
procedure DemoCreateXorArray(const Password: AnsiString; out Arr: TXorArray);
const
PadArray: TXorArray = ($BB, $FF, $FF, $BA, $FF, $FF, $B9, $80,
$00, $BE, $0F, $00, $BF, $0F, $00, $00);
var
Key: Word;
Len, I: Integer;
begin
Key := DemoCreateXorKey(Password);
Len := Length(Password);
if Len > 16 then
Len := 16;
for I := 0 to Len - 1 do
Arr[I] := Ord(Password[I + 1]);
for I := Len to 15 do
Arr[I] := PadArray[I - Len];
for I := 0 to 15 do
if Odd(I) then
Arr[I] := XorRor(Arr[I], Byte(Key shr 8))
else
Arr[I] := XorRor(Arr[I], Byte(Key and $FF));
end;
Per secret questo produce l'array 1F 32 17 B9 14 BA 7B 7F 59 DD 59 7F 7A C0 A6 DF. Insieme alla chiave $014D e al verifier $DAA7 vi dà tre valori validi noti su cui fare assert prima ancora di coinvolgere Excel
Rotazione a destra di uno, e perché la rotazione a sinistra di due sembra plausibile
Con la chiave giusta, Excel 16 passa oltre la richiesta di password e dritto nel secondo errore, il report che il file ha un problema. La causa consueta è un array XOR ruotato nel verso sbagliato. Il §2.3.7.2 definisce il passo dell'array come XorRor, una rotazione a destra di un bit, eppure una variante che ruota ogni byte dell'array a sinistra di 2 bit circola in parecchie implementazioni BIFF, e un reader costruito sulla stessa variante non nota mai nulla di sbagliato
Excel 16 non salva file Excel 5.0/95, e non offre XOR salvando BIFF8, quindi non c'è un campione nativo su cui fare il diff. Quando serve messa a punto quale combinazione implementa il vostro codice, il metodo affidabile gira nella direzione opposta: scrivete uno stream BIFF5 in chiaro, ricodatelo sotto ogni combinazione di tre scelte indipendenti, e fate aprire ogni risultato a Excel 16:
| Scelta | Opzione A | Opzione B |
|---|---|---|
| Rotazione dell'array | XorRor (rotazione a destra di 1) | Rotazione a sinistra di 2 |
| Indice dell'array | (offset + lunghezza record) mod 16 | offset mod 16 |
| Ordine della trasformazione dei byte | Rotazione a sinistra di 5, poi XOR | XOR, poi rotazione a sinistra di 5 |
Degli otto file, Excel 16 accetta la combinazione della specifica — XorRor, rotazione-poi-XOR, indice con lunghezza record — ed esattamente un'altra che sembra diversa solo in apparenza. La rotazione-a-sinistra-2 abbinata a XOR-poi-rotazione e allo stesso indice è la stessa funzione travestita. La rotazione si distribuisce sull'XOR, quindi rol5(p xor rol2(b)) eguaglia rol5(p) xor rol7(b), e su un valore a 8 bit una rotazione a sinistra di 7 è una rotazione a destra di 1. In compatto: rol5 ∘ rol2 = ror1
Quell'identità spiega perché l'array con rotazione a sinistra di 2 sembra giusto in isolamento. È corretto solo insieme all'ordine di trasformazione opposto; abbinato all'ordine della specifica corrompe ogni byte trasformato. Anche ogni variante che toglie la lunghezza del record dall'indice fallisce, qualunque rotazione usi. Scrivete la combinazione della specifica e nient'altro. Il gemello algebrico si apre, ma lascia al prossimo manutentore due deviazioni da ricostruire con il reverse engineering dove il testo della specifica non ne lascia nessuna
Come si calcola XorArrayIndex per ogni byte?
XorArrayIndex per un byte è il suo offset nello stream della cartella di lavoro più la lunghezza dell'intero dato del record a cui appartiene, mod 16. L'indice quindi riparte da un valore dipendente dal record per ogni record e incrementa di uno per byte al suo interno. Lo pseudocodice della specifica nomina gli input FileOffset e Data.Length, ed è facile leggere il primo come il solo offset d'inizio del record
Tre dettagli decidono se i vostri indici vanno d'accordo con Excel:
- L'header del record a 4 byte non viene mai trasformato, ma occupa comunque posizioni di stream, quindi il primo byte del corpo di un record sta a header offset + 4
- Il termine lunghezza è la lunghezza completa del dato del record, inclusi gli eventuali prefissi in chiaro che la trasformazione salta
- BOUNDSHEET è in parte in chiaro: i suoi primi 4 byte,
lbPlyPos, l'offset di stream del BOF del foglio, restano leggibili così un parser può localizzare i fogli senza la password. Quei 4 byte vengono saltati dalla trasformazione ma contano comunque sia per l'offset sia per la lunghezza del record
Messi insieme, la trasformazione per record sono poche righe. Come prima, è uno schizzo della regola per il vostro codice; HotXLS la applica internamente durante SaveAs:
function Rol8(B: Byte; N: Integer): Byte;
begin
Result := Byte((B shl N) or (B shr (8 - N)));
end;
// Offusca il corpo di un record in place. BodyPos è l'offset di stream di
// Body[0], cioè l'offset dell'header del record + 4. PlainPrefix è 4 per
// BOUNDSHEET, la lunghezza piena per BOF / FILEPASS, 0 per la maggior parte dei record
procedure DemoObfuscateRecord(var Body: array of Byte; RecordLength: Word;
PlainPrefix: Integer; BodyPos: LongWord; const Arr: TXorArray);
var
I: Integer;
begin
for I := PlainPrefix to RecordLength - 1 do
Body[I] := Rol8(Body[I], 5) xor
Arr[(BodyPos + LongWord(I) + RecordLength) mod 16];
end;
// La lettura è l'immagine speculare: B := Body[I] xor Arr[...];
// poi rotazione a destra di 5, cioè Rol8(B, 3)
Un reader e un writer che indicizzano entrambi dalla sola posizione di stream tralasciano la lunghezza del record da entrambe le parti, quindi vanno d'accordo fra loro e con nessun altro. Sul lato lettura, HotXLS calcola l'indice dalla posizione corrente di stream più la lunghezza del prefisso in chiaro più il numero di byte trasformati — la stessa lunghezza di record che ha usato il writer
Leggere i file che usano l'array con rotazione a sinistra di 2
HotXLS apre anche i file XOR costruiti con l'array a rotazione a sinistra di 2 e una chiave casuale, e li distingue dalla chiave del FILEPASS. Quando la chiave salvata eguaglia la chiave derivata dalla password, il reader costruisce l'array XorRor della specifica; quando differisce, il reader passa all'array con rotazione a sinistra di 2. I file scritti da Excel portano sempre la chiave derivata, quindi prendono sempre il percorso della specifica
Il test è un'euristica con una percentuale di fallimento precisa. Per un file la cui chiave era stata riempita a caso, la probabilità che per caso eguagli la chiave derivata — e che venga quindi letto con l'array sbagliato — è 1 su 65.536. La commutazione copre solo la rotazione dell'array; la regola dell'indice resta fissa, quindi si applica ai file che usano già l'indice con lunghezza record. Aprire un simile file con HotXLS e risalvarlo produce un file che Excel accetta, perché il writer usa sempre la chiave derivata e XorRor
Due dettagli sulla password valgono per ogni file, qualunque array usi:
- Lunghezza.
CreateXorKey_Method1legge solo i primi 15 byte della password, che è il limite della specifica. HotXLS applica quel tetto alla chiave e tiene il verifier sulla password intera e l'array sulla sua regola a 16 byte, in modo identico sul lato lettura e su quello scrittura. Dato che la chiave vede solo e sempre 15 byte, 15 caratteri sono il massimo pratico - Insieme di caratteri. HotXLS converte la password in byte attraverso la code page ANSI di sistema, per la chiave, il verifier e l'array allo stesso modo. La specifica descrive il prendere il byte basso di ogni carattere UTF-16, e le due cose concordano per l'ASCII. Senza campioni Excel protetti da password non ASCII non c'è una verità di riferimento per il resto, quindi tenete le password XOR su ASCII puro
Quando Open incontra un record FILEPASS e la password manca o è sbagliata, scatta TXLSWorkbook.OnPassword. L'handler è un TXLSPasswordEvent con un var PassWord: WideString e un var Retry: Boolean; assegnate una nuova password e impostate Retry a True per riprovare, fino a tre retry. Lasciare Retry a False fa sì che Open restituisca il codice di errore della password:
procedure TImportForm.WorkbookPassword(Sender: TObject;
var PassWord: WideString; var Retry: Boolean);
var
S: string;
begin
S := '';
Retry := InputQuery('Protected workbook', 'Password:', S);
PassWord := S;
end;
procedure TImportForm.ImportLegacyFile(const FileName: string);
var
Wb: IXLSWorkbook;
Rc: Integer;
begin
Wb := TXLSWorkbook.Create;
Wb.OnPassword := WorkbookPassword;
Rc := Wb.Open(FileName);
// -1003: serve una password ma non ne è stata fornita nessuna; -1005: password sbagliata
if Rc <> 1 then
raise Exception.CreateFmt('Cannot open %s (code %d)', [FileName, Rc]);
ShowMessage(VarToStr(Wb.Sheets[1].Range['A1', 'A1'].Value));
end;
Se la password è già nota, l'overload Open(FileName, APassWord) la passa subito all'inizio e l'evento scatta solo quando quella password fallisce
L'offuscamento XOR vale la pena di essere scritto?
L'offuscamento XOR di BIFF tiene fuori un utente occasionale da un file e non fa nulla contro uno motivato. Il controllo della password è un verifier a 16 bit, la chiave è 16 bit, e l'array a 16 byte si ripete per tutto lo stream, quindi contenuti di record BIFF prevedibili espongono i byte dell'array senza alcuna password. L'unico motivo per scriverlo oggi è un consumatore legacy che legge file Excel 5.0/95 e niente di più recente, perché BIFF5 non offre altri schemi
Il motore classico sceglie lo schema tramite TXLSWorkbook.EncryptionType, e la combinazione con il formato di salvataggio viene controllata severamente:
xletAuto(il default) scrive RC4 CryptoAPI perxlExcel97e XOR perxlExcel5, seguendo ciò che Excel stesso scriveva per ogni formatoxletXorè valido solo per BIFF5; conxlExcel97il salvataggio solleva un'eccezione invece di ricadere su un altro schemaxletRC4exletRC4CryptoAPIsono solo BIFF8, e chiederli su un salvataggio BIFF5 solleva anch'esso un'eccezione
Lasciate EncryptionType a xletAuto nel codice che può salvare in entrambi i formati. Atterra sempre sullo schema più forte che il formato di destinazione supporta, e non può sollevare l'eccezione di disaccordo che un xletXor esplicito solleva il giorno in cui qualcuno commuta il salvataggio su xlExcel97
Anche RC4 è datato, e i dettagli per farlo interoperare sono trattati in perché Excel rifiuta una cartella di lavoro cifrata con una password corretta. Se il destinatario sa leggere XLSX, saltate i formati legacy e usate il motore XLSX: TXLSXWorkbook.SaveAsEncryptedAgile scrive Agile Encryption (hashing della password SHA-512 con uno spin count di 100.000 iterazioni e AES-256-CBC), il contenitore che Excel 2010 e successivi scrivono per default, mentre SaveAsEncrypted scrive la più vecchia Standard Encryption AES-128. I compromessi tra le due sono in cifrare file XLSX con AES in Delphi, e il lato lettura è coperto in leggere file Excel cifrati Agile con HotXLS
Controllare l'output XOR BIFF5 prima che lo veda Excel 16
- Salvate lo stesso foglio due volte con la stessa password e confrontate i corpi del FILEPASS in un dump esadecimale. Entrambe le copie dovrebbero contenere word identiche; una chiave che cambia fra i salvataggi era stata riempita a caso, e Excel 16 rifiuterà la password
- Per la password
secretil corpo del FILEPASS a 4 byte si legge4D 01 A7 DAsu disco, chiave prima, entrambe le word little-endian - I primi 4 byte di ogni BOUNDSHEET dovrebbero leggersi come un offset di stream in chiaro che cade su un BOF di foglio; se non puntano da nessuna parte, la trasformazione ha toccato il prefisso e nessun parser può localizzare i fogli senza la password
- Tenete le password di test su ASCII puro e a 15 caratteri o meno, così chiave, verifier e array vedono gli stessi byte su ogni macchina
La stessa libreria Delphi e C++Builder copre l'XOR BIFF5, RC4 e RC4 CryptoAPI BIFF8, la Standard e la Agile Encryption XLSX e il callback della password lato lettura, con ogni regola a livello di byte qui sopra applicata al salvataggio. Edizioni, piattaforme supportate e un download di prova sono sulla pagina del componente fogli di calcolo Delphi HotXLS