Техническая статья

XOR-обфускация XLS в HotXLS: вывод ключа и XorRor

BIFF5-книга, защищённая паролем secret, может нести верификатор пароля, сходящийся идеально, — и всё равно заставить Excel 16 ответить, что пароль неверен. Excel принимает файл, только когда ключ FILEPASS равен CreateXorKey_Method1(password), 16-байтовый XOR-массив построен через XorRor, а каждый байт использует XorArrayIndex = (смещение в потоке + длина записи) mod 16

У Excel 16 два разных способа отказать такому файлу, и они аккуратно ложатся на слои [MS-OFFCRYPTO] §2.3.7. Запрос пароля, который отвергает правильный пароль, указывает на слово ключа в FILEPASS. Сообщение, что у файла проблема и открыть его нельзя, показываемое после принятия пароля, указывает на XOR-массив или на индекс, выбирающий байт массива. Разделы ниже идут в этом порядке, вплоть до байта

Что запись FILEPASS хранит в BIFF5-файле

BIFF XOR-обфускация хранит в файле всего два 16-битных слова, всё остальное пересчитывается из пароля. Запись FILEPASS ($002F) сидит сразу после BOF глобальных данных книги, и в BIFF5-файле её тело — ровно 4 байта: XOR-ключ, за ним верификатор пароля. Ни соли, ни идентификатора алгоритма, ни шифрованного блока верификатора, какие носят схемы RC4 и AES

Из этих двух слов читатель восстанавливает три значения:

  • Верификатор — 16-битный хеш байтов пароля, XOR-нутый с длиной пароля и $CE4B. Сравнение его с сохранённым словом и есть задокументированная проверка пароля
  • XOR-ключ — 16-битное значение из CreateXorKey_Method1 в [MS-OFFCRYPTO] §2.3.7.2, управляемое двумя таблицами констант (InitialCode, 15 слов, и XorMatrix, 105 слов)
  • XOR-массив — 16 байтов из байтов пароля, дополненных фиксированной 16-байтовой набивкой, каждый XOR-ится с младшим байтом ключа (чётные позиции) или старшим (нечётные), а затем сдвигается вправо на один бит

Заголовки записей остаются открытым текстом. Как и несколько целых записей, которые схема освобождает, — BOF, FILEPASS, USREXCL, FILELOCK, INTERFACEHDR, RRDHEAD и RRDINFO, — плюс первые 4 байта каждого BOUNDSHEET. Тело всякой другой записи преобразуется побайтно: циклический сдвиг влево на 5 бит, затем XOR с одной ячейкой 16-байтового массива. Расшифровка, которую §2.3.7.3 описывает как DecryptData_Method1, — зеркальное отражение: сперва XOR, затем сдвиг вправо на 5

HotXLS прячет всё это за двумя свойствами книги. TXLSWorkbook.EncryptionPassword держит пароль, EncryptionType выбирает схему, а SaveAs с xlExcel5 выпускает FILEPASS сразу после BOF и преобразует остаток потока:

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 есть только XOR-обфускация; xletAuto выбирает ту же схему
  // для xlExcel5, так что явная установка просто документирует намерение
  Wb.EncryptionType := xletXor;
  // ASCII, не более 15 символов (заметки о пароле ниже)
  Wb.EncryptionPassword := 'secret';

  if Wb.SaveAs(FileName, xlExcel5) <> 1 then
    raise Exception.Create('BIFF5 save failed');
end;

Почему Excel говорит, что пароль неверен, хотя верификатор совпадает?

Excel выводит ключ из введённого пароля через CreateXorKey_Method1 и сравнивает его со словом ключа в FILEPASS, поэтому файл с любым другим ключом проваливает проверку пароля, даже когда верификатор корректен. Спецификация трактует ключ как функцию пароля, и Excel 16 читает это строго

Соблазнительный shortcut — заполнить слово ключа двумя случайными байтами. На бумаге выглядит безобидно: верификатор — задокументированная проверка пароля, а массив строится из какого ни на есть ключа, объявленного файлом. Читатель, принимающий ключ из FILEPASS как данность, открывает такие файлы без возражений — именно поэтому shortcut выживает в коде, протестированном только против самого себя. Excel 16, получив тот же файл и правильный пароль, отказывает в запросе. HotXLS выводит ключ при каждом сохранении, поэтому FILEPASS для пароля secret всегда держит ключ $014D и верификатор $DAA7

Схема HotXLS записи BIFF5 XOR FILEPASS, которую Excel 16 проверяет при открытии: открытое четырёхбайтовое тело держит XOR-ключ и верификатор пароля, Excel выводит ключ из введённого пароля через CreateXorKey_Method1 и отвергает случайный ключ с ошибкой пароля, даже когда верификатор совпадает; HotXLS сохраняет выведенный ключ 014D для secret
Тело FILEPASS — всего два слова, но Excel заново выводит ключ из вашего пароля и сравнивает; случайно заполненный ключ проваливает проверку даже с корректным верификатором, потому HotXLS и выводит его всегда

Сам вывод короток, как только обе таблицы на месте. Идите по паролю с последнего байта, семь раз проверяйте бит 6 каждого байта, сдвигая его влево, и XOR-ьте очередную ячейку XorMatrix каждый раз, когда бит взведён; индекс таблицы стартует с последней ячейки, $68, и падает на единицу за бит, взведён тот или нет. Набросок ниже воспроизводит алгоритм спецификации шаг за шагом и даёт те же результаты, что библиотека. Это иллюстрация для вашего собственного читателя, и ни одна из этих процедур не входит в API HotXLS:

// Принципиальный набросок [MS-OFFCRYPTO] 2.3.7.2 CreateXorKey_Method1
// и CreateXorArray_Method1 (только иллюстрация, не 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;                       // ключ видит только 15 байтов
  if Len = 0 then
    Exit;
  Result := InitialCode[Len - 1];
  Element := $68;                    // последняя ячейка 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));   // циклический сдвиг вправо на один бит
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;

Для secret это даёт массив 1F 32 17 B9 14 BA 7B 7F 59 DD 59 7F 7A C0 A6 DF. Вместе с ключом $014D и верификатором $DAA7 это три заведомо корректных значения, которые можно проверять assert-ами ещё до всякого Excel

Схема HotXLS построения XOR-массива для обфускации BIFF5: шестнадцать байтов, засеянных паролем и фиксированной набивкой, XOR-ятся с младшим байтом ключа на чётных позициях и старшим на нечётных, затем сдвигаются вправо на один бит через XorRor, давая массив 1F 32 17 B9 для пароля secret
Байты массива берутся из пароля, набивки и двух байтов ключа, один сдвиг в самом конце; сдвиг влево на 2 эквивалентен только при обратном порядке байтового преобразования, а Excel следует порядку спецификации

Сдвиг вправо на один — и почему сдвиг влево на два выглядит правдоподобно

С верным ключом Excel 16 проходит мимо запроса пароля прямо во вторую ошибку — сообщение, что у файла проблема. Обычная причина — XOR-массив, повёрнутый не в ту сторону. §2.3.7.2 определяет шаг массива как XorRor, циклический сдвиг вправо на один бит, однако вариант, поворачивающий каждый байт массива влево на 2 бита, гуляет по нескольким реализациям BIFF, и читатель, построенный на том же варианте, ничего не замечает

Excel 16 не сохраняет файлы Excel 5.0/95, а при сохранении BIFF8 XOR не предлагает, так что диффить не с чем. Когда нужно точно установить, какую комбинацию реализует ваш код, надёжный метод идёт в обратную сторону: запишите один открытый BIFF5-поток, перекодируйте его под каждую комбинацию из трёх независимых выборов и дайте Excel 16 открыть каждый результат:

ВыборВариант AВариант B
Сдвиг массиваXorRor (сдвиг вправо на 1)Сдвиг влево на 2
Индекс массива(смещение + длина записи) mod 16смещение mod 16
Порядок байтового преобразованияСдвиг влево на 5, затем XORXOR, затем сдвиг влево на 5

Из восьми файлов Excel 16 принимает спецификационную комбинацию — XorRor, сдвиг-затем-XOR, индекс по длине записи — и ровно ещё одну, которая лишь выглядит иначе. Сдвиг-влево-2 в паре с XOR-затем-сдвиг и тем же индексом — та же функция в маскировке. Сдвиг дистрибутивен над XOR, поэтому rol5(p xor rol2(b)) равен rol5(p) xor rol7(b), а на 8-битном значении сдвиг влево на 7 — это сдвиг вправо на 1. Компактно: rol5 ∘ rol2 = ror1

Это тождество объясняет, почему массив со сдвигом влево на 2 выглядит правильным в изоляции. Он верен только в паре с обратным порядком преобразования; в паре с порядком спецификации он портит каждый преобразованный байт. Все варианты, выбросившие длину записи из индекса, проваливаются тоже, каким бы сдвигом ни пользовались. Пишите спецификационную комбинацию и ничего другого. Алгебраический двойник открывается, но оставляет следующему сопровождающему два отклонения для реверс-инжиниринга там, где текст спецификации не оставляет ни одного

Как вычисляется XorArrayIndex для каждого байта?

XorArrayIndex для байта — это его смещение в потоке книги плюс длина всех данных записи, к которой он принадлежит, по модулю 16. Индекс потому стартует заново от зависящего от записи значения для каждой записи и растёт на единицу с каждым байтом внутри неё. Псевдокод спецификации называет входы FileOffset и Data.Length, и первое легко прочесть как одно лишь смещение начала записи

Три детали решают, сойдутся ли ваши индексы с Excel:

  • 4-байтовый заголовок записи не преобразуется никогда, но позиции в потоке всё же занимает, так что первый байт тела записи сидит на смещении заголовка + 4
  • Слагаемое длины — полная длина данных записи, включая любой открытый префикс, который преобразование пропускает
  • BOUNDSHEET частично открыт: его первые 4 байта, lbPlyPos, смещение в потоке BOF листа, остаются читаемыми, чтобы парсер мог найти листы. Эти 4 байта преобразование пропускает, но к смещению и к длине записи они всё равно идут в счёт
Схема HotXLS правила XorArrayIndex для XOR-обфускации BIFF5: каждый байт тела использует смещение в потоке плюс полную длину данных записи по модулю 16, открытый четырёхбайтовый заголовок и префикс BOUNDSHEET lbPlyPos всё равно идут в счёт смещения, а игнорирование слагаемого длины записи расстраивает каждую запись
Индекс массива стартует заново раз за запись, а не раз за поток: заголовок и любой открытый префикс занимают позиции, длина данных записи питает модуль, а читатель и писатель, оба выбросившие это слагаемое, сходятся только друг с другом

Вместе взятое, преобразование одной записи — это несколько строк. Как и раньше, это набросок правила для вашего кода; HotXLS применяет его внутри при SaveAs:

function Rol8(B: Byte; N: Integer): Byte;
begin
  Result := Byte((B shl N) or (B shr (8 - N)));
end;

// Обфусцирует тело одной записи на месте. BodyPos — смещение в потоке
// Body[0], т.е. смещение заголовка записи + 4. PlainPrefix равен 4 для
// BOUNDSHEET, полной длине для BOF / FILEPASS, 0 для большинства записей
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;

// Чтение — зеркальное отражение: B := Body[I] xor Arr[...];
// затем сдвиг вправо на 5, т.е. Rol8(B, 3)

Читатель и писатель, которые оба индексируют по одной позиции в потоке, выбрасывают длину записи с обеих сторон, поэтому сходятся друг с другом и ни с кем больше. На стороне чтения HotXLS вычисляет индекс из текущей позиции в потоке плюс длины открытого префикса плюс числа преобразованных байтов — той же длины записи, что использовал писатель

Чтение файлов со сдвигом-влево-2 массивом

HotXLS также открывает XOR-файлы, построенные со сдвигом-влево-2 массивом и случайным ключом, и различает их по ключу FILEPASS. Когда сохранённый ключ равен ключу, выведенному из пароля, читатель строит спецификационный XorRor-массив; когда отличается — переключается на массив со сдвигом влево на 2. Файлы, написанные Excel, всегда несут выведенный ключ, поэтому всегда идут по спецификационному пути

Проверка — эвристика с точной частотой промаха. Для файла, чей ключ был заполнен случайно, вероятность того, что он случайно окажется равен выведенному — и будет прочитан с неверным массивом, — 1 на 65 536. Переключение покрывает только поворот массива; правило индекса не меняется, так что относится к файлам, уже использующим индекс по длине записи. Открытие такого файла HotXLS и повторное сохранение дают файл, который принимает Excel, потому что писатель всегда использует выведенный ключ и XorRor

Две детали про пароль касаются всякого файла, каким бы массивом он ни пользовался:

  • Длина. CreateXorKey_Method1 читает только первые 15 байтов пароля — это предел спецификации. HotXLS применяет этот потолок к ключу, а верификатор и массив держит на их обычных правилах полной длины и 16 байтов, единообразно по обе стороны. Поскольку ключ видит только 15 байтов, практический максимум — 15 символов
  • Набор символов. HotXLS переводит пароль в байты через системную ANSI-кодовую страницу, одинаково для ключа, верификатора и массива. Спецификация описывает взятие младшего байта каждого UTF-16-символа, что для ASCII совпадает. Без образцов Excel, защищённых не-ASCII паролями, истины для остального нет, так что держите XOR-пароли простым ASCII

Когда Open встречает запись FILEPASS, а пароль отсутствует или неверен, срабатывает TXLSWorkbook.OnPassword. Обработчик — TXLSPasswordEvent с var PassWord: WideString и var Retry: Boolean; назначьте новый пароль и выставьте Retry в True, чтобы попробовать снова, до трёх попыток. Оставите Retry в False — Open вернёт код ошибки пароля:

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: пароль требуется, но не подан; -1005: неверный пароль
  if Rc <> 1 then
    raise Exception.CreateFmt('Cannot open %s (code %d)', [FileName, Rc]);
  ShowMessage(VarToStr(Wb.Sheets[1].Range['A1', 'A1'].Value));
end;

Если пароль уже известен, перегрузка Open(FileName, APassWord) подаёт его заранее, и событие срабатывает, только когда тот пароль не подошёл

Стоит ли XOR-обфускацию вообще писать?

BIFF XOR-обфускация держит на расстоянии случайного пользователя и бессильна против мотивированного. Проверка пароля — 16-битный верификатор, ключ — 16 бит, а 16-байтовый массив повторяется по всему потоку, так что предсказуемое содержимое записей BIFF выдаёт байты массива вовсе без пароля. Единственный повод писать её сегодня — легаси-потребитель, читающий файлы Excel 5.0/95 и ничего новее, потому что у BIFF5 нет другой схемы

Классический движок выбирает схему через TXLSWorkbook.EncryptionType, и комбинация с форматом сохранения проверяется строго:

  • xletAuto (дефолт) пишет RC4 CryptoAPI для xlExcel97 и XOR для xlExcel5 — ровно то, что сам Excel писал для каждого формата
  • xletXor действителен только для BIFF5; с xlExcel97 сохранение бросает исключение вместо отката к другой схеме
  • xletRC4 и xletRC4CryptoAPI — только BIFF8, и запрос любого из них при сохранении BIFF5 тоже бросает исключение

Оставьте EncryptionType в xletAuto в коде, который может сохранять оба формата. Он всегда приземляется на самую сильную схему, которую поддерживает целевой формат, и не может бросить исключение о несовпадении, которое бросит явный xletXor в тот день, когда кто-нибудь переключит сохранение на xlExcel97

RC4 тоже устарел, а детали его интеропа разобраны в статье о том, почему Excel отвергает шифрованную книгу с верным паролем. Если получатель умеет читать XLSX, берите движок XLSX: TXLSXWorkbook.SaveAsEncryptedAgile пишет Agile Encryption (хэширование пароля SHA-512 со spin count в 100 000 итераций и AES-256-CBC) — формат, который Excel 2010 и новее пишут по умолчанию, а SaveAsEncrypted пишет более старое Standard Encryption на AES-128. Компромиссы между ними — в статье о шифровании XLSX-файлов AES в Delphi, а сторона чтения разобрана в чтении Agile-шифрованных файлов Excel с HotXLS

Проверка BIFF5 XOR-вывода до того, как его увидит Excel 16

  • Сохраните одну и ту же книгу дважды с одним паролем и сравните тела FILEPASS в hex-дампе. Обе копии должны держать идентичные слова; ключ, меняющийся между сохранениями, был заполнен случайно, и Excel 16 отвергнет пароль
  • Для пароля secret четырёхбайтовое тело FILEPASS читается с диска как 4D 01 A7 DA, ключ впереди, оба слова little-endian
  • Первые 4 байта каждого BOUNDSHEET должны читаться как открытое смещение в потоке, попадающее на BOF листа; если они указывают в никуда, преобразование тронуло префикс, и ни один парсер не найдёт листы без пароля
  • Держите тестовые пароли простым ASCII не длиннее 15 символов, чтобы ключ, верификатор и массив видели одни и те же байты на каждой машине

Та же библиотека для Delphi и C++Builder покрывает BIFF5 XOR, BIFF8 RC4 и RC4 CryptoAPI, XLSX Standard и Agile Encryption и колбэк пароля на стороне чтения, применяя каждое байтовое правило выше при сохранении. Издания, поддерживаемые платформы и пробная загрузка — на странице HotXLS Delphi spreadsheet component