Artykuł techniczny

Obfuskacja XOR w XLS HotXLS: wyprowadzanie klucza i XorRor

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_Method1 w [MS-OFFCRYPTO] §2.3.7.2, napędzana dwiema stałymi tablicami (InitialCode, 15 słów, i XorMatrix, 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

Diagram HotXLS rekordu FILEPASS zaciemnienia XOR w BIFF5, który Excel 16 sprawdza przy otwarciu: cztery czyste bajty ciała trzymają klucz XOR i weryfikator hasła, Excel wyprowadza klucz z wpisanego hasła przez CreateXorKey_Method1 i odrzuca losowy klucz błędem hasła nawet wtedy, gdy weryfikator się zgadza; HotXLS zapisuje wyprowadzony klucz 014D dla secret
Ciało FILEPASS to tylko dwa słowa, ale Excel wyprowadza klucz z twojego hasła od nowa i porównuje; klucz wypełniony losowo oblewa sprawdzenie nawet przy poprawnym weryfikatorze, dlatego HotXLS zawsze go wyprowadza

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

Diagram HotXLS budowy tablicy XOR dla zaciemnienia BIFF5: szesnaście bajtów zasianych hasłem i stałym padem jest XOR-owanych z młodszym bajtem klucza na pozycjach parzystych i starszym bajtem na pozycjach nieparzystych, a potem obracanych w prawo o jeden bit przez XorRor, co daje tablicę 1F 32 17 B9 dla hasła secret
Bajty tablicy pochodzą z hasła, pada i dwóch bajtów klucza, a na końcu jest jeden obrót; obrót w lewo o 2 jest równoważny tylko przy przekształceniu bajtów w odwrotnej kolejności, a Excel trzyma się kolejności ze specyfikacji

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órOpcja AOpcja B
Obrót tablicyXorRor (obrót w prawo o 1)Obrót w lewo o 2
Indeks tablicy(offset + długość rekordu) mod 16offset mod 16
Kolejność przekształcenia bajtuObrót w lewo o 5, potem XORXOR, 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
Diagram HotXLS reguły XorArrayIndex dla zaciemnienia XOR w BIFF5: każdy bajt ciała używa offsetu w strumieniu plus pełnej długości danych rekordu modulo 16, czysty nagłówek o długości czterech bajtów i prefiks BOUNDSHEET lbPlyPos wliczają się do offsetu, a zignorowanie składnika długości rekordu rozjeżdża każdy rekord
Indeks tablicy restartuje raz na rekord, a nie raz na strumień: nagłówek i każdy czysty prefiks zajmują pozycje, długość danych rekordu zasila modulo, a czytnik i pisarz, które oba wyrzucą ten składnik, zgadzają się tylko ze sobą

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_Method1 czyta 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 dla xlExcel97 i XOR dla xlExcel5, zgodnie z tym, co sam Excel zapisywał dla każdego formatu
  • xletXor jest ważny tylko dla BIFF5; przy xlExcel97 zapis rzuca wyjątkiem zamiast po cichu schodzić na niższy schemat
  • xletRC4 i xletRC4CryptoAPI to 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 secret 4-bajtowe ciało FILEPASS czyta się z dysku jako 4D 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