Skoroszyt BIFF5 chroniony hasłem secret może nieść weryfikator hasła zgadzający się co do joty i mimo to sprawić, że Excel 16 odpowie, iż hasło jest niepoprawne. Excel przyjmuje plik tylko wtedy, gdy klucz w FILEPASS równa się CreateXorKey_Method1(password), 16-bajtowa tablica XOR powstaje przez XorRor, a każdy bajt używa XorArrayIndex = (offset w strumieniu + długość rekordu) mod 16
Excel 16 ma dwa różne sposoby odmowy takiego pliku, i oba czysto mapują się na warstwy [MS-OFFCRYPTO] §2.3.7. Monit o hasło, który uparcie odrzuca poprawne hasło, wskazuje słowo klucza w FILEPASS. Komunikat, że plik ma problem i nie da się go otworzyć, pokazywany po przyjęciu hasła, wskazuje tablicę XOR albo indeks wybierający bajt tablicy. Poniższe sekcje idą w tej kolejności, aż do bajtu
Co rekord FILEPASS przechowuje w pliku BIFF5
Zaciemnienie XOR w BIFF zapisuje w pliku tylko dwa 16-bitowe słowa, a wszystko inne jest przeliczane z hasła. Rekord FILEPASS ($002F) siedzi zaraz po BOF globals skoroszytu, a w pliku BIFF5 jego ciało ma dokładnie 4 bajty: klucz XOR, po nim weryfikator hasła. Nie ma soli, identyfikatora algorytmu ani zaszyfrowanego bloba weryfikatora, jakie niosą schematy RC4 i AES
Z tych dwóch słów czytnik odtwarza trzy rzeczy:
- Weryfikator — 16-bitowy hash bajtów hasła XOR-owany z długością hasła i
$CE4B. Porównanie go z przechowanym słowem to sprawdzenie hasła, i to jedyne - Klucz XOR — 16-bitowa wartość z
CreateXorKey_Method1w [MS-OFFCRYPTO] §2.3.7.2, napędzana dwiema stałymi tablicami (InitialCode, 15 słów, iXorMatrix, 105 słów) - Tablica XOR — 16 bajtów złożonych z bajtów hasła dopełnionych stałym 16-bajtowym padem, każdy XOR-owany z młodszym bajtem klucza (pozycje parzyste) albo starszym bajtem klucza (pozycje nieparzyste), a potem obrócony w prawo o jeden bit
Nagłówki rekordów pozostają w czystym tekście. Podobnie garść całych rekordów, których schemat nie obejmuje — BOF, FILEPASS, USREXCL, FILELOCK, INTERFACEHDR, RRDHEAD i RRDINFO — plus pierwsze 4 bajty każdego BOUNDSHEET. Ciało każdego innego rekordu jest przekształcane bajt po bajcie: obrót w lewo o 5 bitów, potem XOR z jednym wpisem 16-bajtowej tablicy. Odszyfrowanie, które §2.3.7.3 zapisuje jako DecryptData_Method1, to obraz lustrzany: najpierw XOR, potem obrót w prawo o 5
HotXLS trzyma to wszystko za dwiema właściwościami skoroszytu. TXLSWorkbook.EncryptionPassword trzyma hasło, EncryptionType wybiera schemat, a SaveAs z xlExcel5 emituje FILEPASS zaraz za BOF i przekształca resztę strumienia:
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 ma wyłącznie zaciemnienie XOR; xletAuto wybiera ten sam schemat
// dla xlExcel5, więc jawne ustawienie tylko dokumentuje intencję
Wb.EncryptionType := xletXor;
// ASCII, najwyżej 15 znaków (patrz uwagi o haśle niżej)
Wb.EncryptionPassword := 'secret';
if Wb.SaveAs(FileName, xlExcel5) <> 1 then
raise Exception.Create('BIFF5 save failed');
end;
Dlaczego Excel twierdzi, że hasło jest złe, skoro weryfikator się zgadza?
Excel wyprowadza klucz z wpisanego hasła przez CreateXorKey_Method1 i porównuje go ze słowem klucza w FILEPASS, więc plik z jakimkolwiek innym kluczem oblewa sprawdzenie hasła, nawet gdy weryfikator jest poprawny. Specyfikacja traktuje klucz jako funkcję hasła, a Excel 16 egzekwuje takie odczytanie restrykcyjnie
Kuszący skrót to wypełnienie słowa klucza dwoma losowymi bajtami. Na papierze wygląda to niewinnie: weryfikator jest udokumentowanym sprawdzeniem hasła, a tablica powstaje z tego klucza, który plik deklaruje. Czytnik biorący klucz z FILEPASS jako dany otwiera takie pliki bez zawahania — i tak skrót przetrwa w kodzie testowanym wyłącznie na sobie. Excel 16, dostawszy ten sam plik i poprawne hasło, odmawia przy monicie. HotXLS wyprowadza klucz przy każdym zapisie, więc FILEPASS dla hasła secret zawsze trzyma klucz $014D i weryfikator $DAA7
Sama wyprowadzka jest krótka, gdy obie tablice są już na miejscu. Przejdź hasło od tyłu, od ostatniego bajtu, siedem razy spójrz na bit 6 każdego bajtu, przesuwając go w lewo, i za każdym ustawionym bitem XOR-uj jeden wpis XorMatrix; indeks tablicy startuje od ostatniego wpisu, $68, i spada o jeden na bit, ustawiony czy nie. Poniższy szkic odtwarza algorytm ze specyfikacji krok po kroku i daje te same wyniki co biblioteka. To ilustracja dla twojego własnego czytnika, a żadna z tych procedur nie jest częścią API HotXLS:
// Poglądowy szkic [MS-OFFCRYPTO] 2.3.7.2 CreateXorKey_Method1
// i CreateXorArray_Method1 (tylko ilustracja, nie 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; // klucz widzi tylko 15 bajtów
if Len = 0 then
Exit;
Result := InitialCode[Len - 1];
Element := $68; // ostatni wpis 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)); // obrót w prawo o jeden 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;
Dla secret daje to tablicę 1F 32 17 B9 14 BA 7B 7F 59 DD 59 7F 7A C0 A6 DF. Razem z kluczem $014D i weryfikatorem $DAA7 masz trzy znane dobre wartości do asercji, zanim w ogóle włączysz do gry Excela
Obrót w prawo o jeden i czemu obrót w lewo o dwa wygląda wiarygodnie
Przy poprawnym kluczu Excel 16 przechodzi za monit o hasło prosto w drugi błąd — komunikat, że plik ma problem. Zwykłą przyczyną jest tablica XOR obrócona w złą stronę. §2.3.7.2 definiuje krok tablicy jako XorRor, obrót w prawo o jeden bit, jednak wariant obracający każdy bajt tablicy w lewo o 2 bity krąży w kilku implementacjach BIFF, a czytnik zbudowany na tym samym wariancie nigdy nie zauważa, że coś jest nie tak
Excel 16 nie zapisuje plików Excel 5.0/95, a przy zapisie BIFF8 nie oferuje XOR, więc nie ma natywnej próbki do porównania. Gdy musisz rozstrzygnąć, którą kombinację implementuje twój własny kod, pewna metoda biegnie z drugiej strony: zapisz jeden czystotekstowy strumień BIFF5, zakoduj go ponownie dla każdej kombinacji trzech niezależnych wyborów i każ Excelowi 16 otworzyć każdy wynik:
| Wybór | Opcja A | Opcja B |
|---|---|---|
| Obrót tablicy | XorRor (obrót w prawo o 1) | Obrót w lewo o 2 |
| Indeks tablicy | (offset + długość rekordu) mod 16 | offset mod 16 |
| Kolejność przekształcenia bajtu | Obrót w lewo o 5, potem XOR | XOR, potem obrót w lewo o 5 |
Z ośmiu plików Excel 16 przyjmuje kombinację ze specyfikacji — XorRor, obrót-potem-XOR, indeks z długością rekordu — i dokładnie jeden inny, który tylko wygląda inaczej. Obrót-w-lewo-o-2 w parze z XOR-potem-obrót i tym samym indeksem to ta sama funkcja w przebraniu. Obrót jest rozdzielny względem XOR, więc rol5(p xor rol2(b)) równa się rol5(p) xor rol7(b), a na wartości 8-bitowej obrót w lewo o 7 to obrót w prawo o 1. Krótko: rol5 ∘ rol2 = ror1
Ta tożsamość wyjaśnia, czemu tablica z obrotem w lewo o 2 wygląda poprawnie w izolacji. Jest poprawna tylko w parze z odwrotną kolejnością przekształcenia; w parze z kolejnością ze specyfikacji psuje każdy przekształcony bajt. Każdy wariant, który wyrzuca długość rekordu z indeksu, też polegnie — niezależnie od obrotu. Pisz kombinację ze specyfikacji i nic innego. Bliźniak algebraiczny się otwiera, ale zostawia kolejnemu utrzymującemu kod dwa odstępstwa do rozgryzienia odwrotnego, tam gdzie tekst specyfikacji nie zostawia żadnego
Jak liczy się XorArrayIndex dla każdego bajtu?
XorArrayIndex dla bajtu to jego offset w strumieniu skoroszytu plus długość całych danych rekordu, do którego należy, mod 16. Indeks startuje więc od wartości zależnej od rekordu przy każdym rekordzie i rośnie o jeden na bajt w jego obrębie. Pseudokod specyfikacji nazywa wejścia FileOffset i Data.Length, a pierwsze łatwo błędnie odczytać jako sam offset początku rekordu
O tym, czy twoje indeksy ułożą się z Excela, decydują trzy szczegóły:
- 4-bajtowy nagłówek rekordu nie jest nigdy przekształcany, ale i tak zajmuje pozycje w strumieniu, więc pierwszy bajt ciała rekordu siedzi na offset nagłówka + 4
- składnik długości to pełna długość danych rekordu, łącznie z każdym czystym prefiksem, który przekształcenie pomija
- BOUNDSHEET jest częściowo czysty: jego pierwsze 4 bajty,
lbPlyPos, offset w strumieniu BOF arkusza, pozostają czytelne, żeby parser mógł zlokalizować arkusze. Te 4 bajty są pomijane przez przekształcenie, ale wliczają się i do offsetu, i do długości rekordu
Złożone w całość, przekształcenie per rekord to kilka linii. I znów: to szkic reguły dla twojego własnego kodu; HotXLS stosuje go wewnętrznie podczas SaveAs:
function Rol8(B: Byte; N: Integer): Byte;
begin
Result := Byte((B shl N) or (B shr (8 - N)));
end;
// Zaciemnia ciało jednego rekordu w miejscu. BodyPos to offset w strumieniu
// Body[0], czyli offset nagłówka rekordu + 4. PlainPrefix to 4 dla
// BOUNDSHEET, pełna długość dla BOF / FILEPASS, 0 dla większości rekordów
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;
// Odczyt to obraz lustrzany: B := Body[I] xor Arr[...];
// potem obrót w prawo o 5, czyli Rol8(B, 3)
Czytnik i pisarz indeksujące oba wyłącznie po pozycji w strumieniu wyrzucają długość rekordu po obu stronach, więc zgadzają się ze sobą i z nikim więcej. Po stronie czytania HotXLS liczy indeks z bieżącej pozycji w strumieniu plus długości czystego prefiksu plus liczby przekształconych bajtów — tej samej długości rekordu, której użył pisarz
Czytanie plików z tablicą obróconą w lewo o 2
HotXLS otwiera też pliki XOR zbudowane z tablicą obróconą w lewo o 2 i losowym kluczem, i odróżnia je po kluczu w FILEPASS. Gdy przechowany klucz równa się kluczowi wyprowadzonemu z hasła, czytnik buduje tablicę XorRor ze specyfikacji; gdy się różni, czytnik przełącza się na tablicę z obrotem w lewo o 2. Pliki zapisane przez Excela zawsze niosą klucz wyprowadzony, więc zawsze idą ścieżką specyfikacji
Ten test to heurystyka z dokładnie znaną stopą porażek. Dla pliku z kluczem wypełnionym losowo szansa, że zrządzi się z kluczem wyprowadzonym — i zostanie przez to czytany złą tablicą — wynosi 1 do 65 536. Przełącznik obejmuje tylko obrót tablicy; reguła indeksu zostaje stała, więc dotyczy plików, które już używają indeksu z długością rekordu. Otwarcie takiego pliku w HotXLS i zapis ponowny dają plik akceptowany przez Excela, bo pisarz zawsze używa klucza wyprowadzonego i XorRor
Dwa szczegóły dotyczące hasła obowiązują każdy plik, stary czy nowy:
- Długość.
CreateXorKey_Method1czyta tylko pierwsze 15 bajtów hasła — to limit ze specyfikacji. HotXLS stosuje ten limit do klucza, a weryfikator i tablicę trzyma przy swoich zwykłych regułach pełnej długości i 16 bajtów, konsekwentnie po obu stronach. Ponieważ klucz widzi najwyżej 15 bajtów, 15 znaków to praktyczne maksimum - Zestaw znaków. HotXLS konwertuje hasło na bajty przez systemową stronę kodową ANSI — dla klucza, weryfikatora i tablicy zarazem. Specyfikacja opisuje branie młodszego bajtu każdego znaku UTF-16, co dla ASCII się zgadza. Bez próbek Excela chronionych hasłami nie-ASCII nie ma punktu odniesienia dla reszty, więc trzymaj się haseł ASCII dla plików XOR
Gdy Open trafi na rekord FILEPASS, a hasła brakuje albo jest złe, odpala się TXLSWorkbook.OnPassword. Handler to TXLSPasswordEvent z var PassWord: WideString i var Retry: Boolean; przypisz nowe hasło i ustaw Retry na True, żeby spróbować ponownie — maksymalnie trzy ponowienia. Zostawienie Retry na False sprawia, że Open zwraca kod błędu hasła:
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: wymagane hasło, ale żadnego nie podano; -1005: złe hasło
if Rc <> 1 then
raise Exception.CreateFmt('Cannot open %s (code %d)', [FileName, Rc]);
ShowMessage(VarToStr(Wb.Sheets[1].Range['A1', 'A1'].Value));
end;
Jeśli hasło już znasz, przeciążenie Open(FileName, APassWord) podaje je z góry, a zdarzenie odpala się tylko wtedy, gdy to hasło zawiedzie
Czy zaciemnienie XOR w ogóle warto zapisywać?
Zaciemnienie XOR w BIFF trzyma przypadkowego użytkownika z dala od pliku i nie robi nic przeciwko zdeterminowanemu. Sprawdzenie hasła to 16-bitowy weryfikator, klucz ma 16 bitów, a 16-bajtowa tablica powtarza się w całym strumieniu, więc przewidywalne treści rekordów BIFF wystawiają bajty tablicy bez żadnego hasła. Jedyne powody, by dziś to zapisywać, to legacy'owy konsument czytający wyłącznie pliki Excel 5.0/95, bo BIFF5 nie oferuje innego schematu
Silnik klasyczny wybiera schemat przez TXLSWorkbook.EncryptionType, a kombinacja z formatem zapisu jest sprawdzana restrykcyjnie:
xletAuto(domyślny) zapisuje RC4 CryptoAPI dlaxlExcel97i XOR dlaxlExcel5, zgodnie z tym, co sam Excel zapisywał dla każdego formatuxletXorjest ważny tylko dla BIFF5; przyxlExcel97zapis rzuca wyjątkiem zamiast po cichu schodzić na niższy schematxletRC4ixletRC4CryptoAPIto wyłącznie BIFF8, a żądanie ich przy zapisie BIFF5 również rzuca wyjątkiem
Zostaw EncryptionType na xletAuto w kodzie, który może zapisywać oba formaty. Zawsze ląduje na najsilniejszym schemacie, jaki wspiera format docelowy, i nie rzuci wyjątku niezgodności, jaki jawne xletXor rzuca, gdy ktoś kiedyś przełączy zapis na xlExcel97
RC4 też ma swoje lata, a doprowadzenie go do współpracy ma własne pułapki — opisuje je artykuł o tym, dlaczego Excel odrzuca zaszyfrowany skoroszyt mimo poprawnego hasła. Jeśli odbiorca potrafi czytać XLSX, pomiń formaty legacy i użyj silnika XLSX: TXLSXWorkbook.SaveAsEncryptedAgile zapisuje Agile Encryption (haszowanie hasła SHA-512 ze spin countem 100 000 iteracji i AES-256-CBC) — kontener, który domyślnie zapisują Excel 2010 i nowsze — a SaveAsEncrypted zapisuje starsze Standard Encryption z AES-128. O kompromisach między nimi piszemy w artykule o szyfrowaniu plików XLSX algorytmem AES w Delphi, a stronę czytania opisuje czytanie zaszyfrowanych Agile plików Excela w HotXLS
Sprawdzenie wyjścia BIFF5 XOR, zanim zobaczy je Excel 16
- Zapisz ten sam skoroszyt dwa razy z tym samym hasłem i porównaj ciała FILEPASS w zrzucie hex. Obie kopie powinny trzymać identyczne słowa; klucz, który zmienia się między zapisami, był wypełniony losowo, a Excel 16 odrzuci hasło
- Dla hasła
secret4-bajtowe ciało FILEPASS czyta się z dysku jako4D 01 A7 DA, klucz pierwszy, oba słowa little-endian - Pierwsze 4 bajty każdego BOUNDSHEET powinny czytać się jako czysty offset w strumieniu, który ląduje na BOF arkusza; jeśli nie wskazują nikąd, przekształcenie dotknęło prefiks i żaden parser nie zlokalizuje arkuszy bez hasła
- Trzymaj testowe hasła w czystym ASCII i najwyżej 15 znakach, żeby klucz, weryfikator i tablica widziały te same bajty na każdej maszynie
Ta sama biblioteka Delphi i C++Buildera obejmuje BIFF5 XOR, BIFF8 RC4 i RC4 CryptoAPI, XLSX Standard i Agile Encryption oraz callback hasła po stronie czytania, z każdą z powyższych reguł bajtowych zastosowaną przy zapisie. Wydania, wspierane platformy i wersję próbną znajdziesz na stronie komponentu arkuszy HotXLS dla Delphi