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
Сам вывод короток, как только обе таблицы на месте. Идите по паролю с последнего байта, семь раз проверяйте бит 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
Сдвиг вправо на один — и почему сдвиг влево на два выглядит правдоподобно
С верным ключом 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, затем XOR | XOR, затем сдвиг влево на 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 применяет его внутри при 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