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

Чтение XLSX с шифрованием Agile в Delphi через HotXLS

Клиент загружает рабочую книгу, которая отлично открывается у него на столе, а сервис импорта отвергает её с ZIP-ошибкой. HEX-дамп первых восьми байтов показывает D0 CF 11 E0 A1 B1 1A E1 — подпись OLE Compound File, которую носит .xls образца 1997 года. У файла расширение .xlsx, он вышел из актуального Excel, и он вовсе не ZIP-пакет. Кто-то поставил пароль в диалоге Save As

На этом вся загадка исчерпывается. Сохраняя книгу с паролем, Excel шифрует настоящий .xlsx ZIP и заворачивает результат в контейнер Compound File Binary (CFB) по схеме Agile из [MS-OFFCRYPTO] §2.3.4.10–§2.3.4.15. Любой загрузчик, классифицирующий файлы по расширению или передающий каждый .xlsx прямо ZIP-ридеру, отфутболит загрузку обратно пользователю, который со своей стороны экрана не сделал ничего необычного

Что лежит внутри книги с шифрованием Agile

Книга с шифрованием Agile — это контейнер CFB с двумя значимыми потоками: EncryptionInfo, описывающий, как выполнено шифрование, и EncryptedPackage, держащий исходный ZIP одним непрозрачным зашифрованным блобом. HotXLS читает оба потока прямо из контейнера — без Excel, без COM и без внешней крипто-DLL на машине

Анатомия рабочей книги с шифрованием Agile, которую HotXLS открывает в Delphi: контейнер CFB с потоком дескриптора EncryptionInfo и потоком EncryptedPackage из сегментов AES-CBC
HotXLS читает книгу с шифрованием Agile как контейнер CFB с самоописывающимся потоком EncryptionInfo и ZIP .xlsx, зашифрованным как непрозрачный поток EncryptedPackage

То, что отличает Agile от старого Standard Encryption, — EncryptionInfo описывает сам себя. После 8-байтового префикса, у которого и старшая, и младшая версия равны 4, поток представляет собой UTF-8 XML-дескриптор. Элемент keyData называет шифр (AES), режим сцепления (ChainingModeCBC), хеш-алгоритм, длину ключа в битах, размер блока и Base64-соль. keyEncryptor пароля несёт собственную соль, spinCount и три Base64-нагрузки: encryptedVerifierHashInput, encryptedVerifierHashValue и encryptedKeyValue. Элемент dataIntegrity добавляет зашифрованные ключ и значение HMAC для обнаружения подмены

Сам Excel пишет AES-256, SHA-512 и счётчик оборотов 100 000. Правда, дескриптору разрешено говорить иное, и сторонние писатели этим пользуются. HotXLS берёт keyBits из дескриптора вместо предположения о 256, поэтому файлы AES-128 и AES-192 расшифровываются тем же путём, и он принимает hashAlgorithm="SHA256" наряду с SHA-512. Хеш-атрибут каждого элемента управляет своими шагами: хеш keyEncryptor ведёт деривацию и проверку пароля, а хеш keyData — сегментные IV и integrity HMAC. Файл, смешивающий их, всё равно откроется

Открытие файла: OpenEncrypted или Open с паролем

TXLSXWorkbook.OpenEncrypted принимает имя файла и пароль и возвращает 1 при успехе — тот же контракт, что у Open. Он распознаёт первые восемь байтов через CanReadEncrypted. Файл без подписи CFB идёт обычным путём Open, и пароль игнорируется, так что импортёру, который всегда вызывает OpenEncrypted, не нужна ветка на месте вызова. CFB-файл сначала пробуется как Standard Encryption, а когда префикс EncryptionInfo несёт Agile-версию 4.4, вступает Agile-ридер. Расшифрованные байты ZIP затем уходят обычному XLSX-загрузчику в памяти

Обе точки входа принимают имя файла. Open(Stream) отказывает потоку, начинающемуся с подписи CFB, и поднимает исключение, чьё сообщение указывает на OpenEncrypted, поэтому загрузку, живущую в TMemoryStream, сначала придётся вылить во временный файл

uses
  System.SysUtils, System.Classes, System.IOUtils, System.Variants, lxHandleX;

function ReadFirstCell(Upload: TMemoryStream;
  const Password: WideString): WideString;
var
  TempName: string;
  Wb: TXLSXWorkbook;
begin
  Result := '';
  // Зашифрованные пакеты открываются из файла, поэтому вылейте загрузку на диск
  TempName := TPath.GetTempFileName;
  Wb := TXLSXWorkbook.Create;
  try
    Upload.SaveToFile(TempName);
    // Обычный .xlsx, Standard-encrypted и Agile-encrypted файлы здесь работают одинаково
    if Wb.OpenEncrypted(TempName, Password) = 1 then
      Result := VarToWideStr(Wb.Sheets[1].Cells[1, 1].Value);
  finally
    Wb.Free;
    TFile.Delete(TempName);
  end;
end;

Перегрузка Open(FileName, Password) с двумя аргументами доходит до того же кода расшифровки, но добавляет то, чего у OpenEncrypted нет: событие OnPassword. Когда предложенный пароль не подходит, Open зажигает OnPassword, позволяет обработчику назначить новый пароль и поставить Retry в True и спрашивает снова — до трёх раз. Настольное приложение может вставить в этот обработчик запрос пароля. Сервер может использовать его для чего-то другого, о чём последний раздел и расскажет

Как пароль преобразуется в AES-ключ?

Пароль никогда не расшифровывает ничего напрямую. Первый дайджест — SHA-512 по соли keyEncryptor, за которой следуют байты пароля в UTF-16LE; затем дайджест перехешируется spinCount раз, причём каждый раунд приписывает перед предыдущим дайджестом 32-битный счётчик раунда в little-endian. При 100 000 раундов Excel каждая попытка пароля стоит ста тысяч последовательных вызовов SHA-512. В этом и смысл счётчика оборотов. Легитимное открытие платит один раз, словарная атака — за каждую догадку

Как HotXLS выводит ключи шифрования Agile в Delphi: пароль прокручивается через 100 000 раундов SHA-512, затем три фиксированных 8-байтовых блочных ключа дают ключи verifier и package
Пароль никогда не расшифровывает ничего напрямую: цепочка счётчика оборотов SHA-512 питает три хеша блочных ключей, которые порождают ключи верификатора и разворачивают случайный ключ пакета

Цепочка достаточно коротка, чтобы воспроизвести её, и это самый быстрый способ узнать, чего стоит одна догадка на вашем железе. Набросок ниже следует §2.3.4.11 для дескриптора SHA-512 и использует публичную функцию XlsSHA512 из модуля lxXlsxAgileDecrypt

uses
  System.SysUtils, lxXlsxAgileDecrypt;

// H0 = SHA-512(salt + UTF-16LE(password))
// Hn = SHA-512(LE32(n - 1) + H(n-1)), repeated SpinCount times
function SpinHash(const Password: WideString; const Salt: TBytes;
  SpinCount: Integer): TBytes;
var
  Buf: TBytes;
  PwdLen, I: Integer;
begin
  PwdLen := Length(Password) * SizeOf(WideChar);
  SetLength(Buf, Length(Salt) + PwdLen);
  if Length(Salt) > 0 then
    Move(Salt[0], Buf[0], Length(Salt));
  if PwdLen > 0 then
    Move(Password[1], Buf[Length(Salt)], PwdLen);
  Result := XlsSHA512(Buf);
  SetLength(Buf, 4 + 64);
  for I := 0 to SpinCount - 1 do
  begin
    Buf[0] := Byte(I and $FF);           // счётчик раунда, little-endian
    Buf[1] := Byte((I shr 8) and $FF);
    Buf[2] := Byte((I shr 16) and $FF);
    Buf[3] := Byte((I shr 24) and $FF);
    Move(Result[0], Buf[4], 64);         // предыдущий дайджест
    Result := XlsSHA512(Buf);
  end;
end;

Прокрученный хеш всё ещё не ключ. Из него выходят три ключа, каждый — новым хешированием прокрученного значения с приписанным фиксированным 8-байтовым блочным ключом: FE A7 D2 76 3B 4B 9E 79 для входа верификатора, D7 AA 0F 6D 30 61 34 4E для хеша верификатора и 14 6E 0B E7 AB AC D0 D6 для разворачивания ключа пакета. Каждый результат обрезается до заявленной длины ключа — 32 байта для AES-256. Спецификация определяет и случай, когда хеш вышел короче ключа: добивать байтами 0x36. Ни один размер AES-ключа в реальности не запускает это с SHA-256 или SHA-512, но то же правило 0x36 действительно работает, когда соль пароля растягивается до размера блока, чтобы служить CBC IV

Счётчик оборотов читается из файла, так что это ещё и поверхность атаки: загрузка, заявляющая миллиард раундов, прибила бы ядро CPU прежде, чем провалиться. §2.3.4.11 ограничивает spinCount сверху значением 10 000 000, и HotXLS сообщает о большем значении как о неподдерживаемом дескрипторе, не хешируя ничего. Для публичной конечной точки загрузки этот потолок — правильное значение по умолчанию. Собственные 100 000 Excel сидят далеко ниже него

Проверка пароля и ловушка усечения по размеру соли (saltSize)

HotXLS проверяет пароль прежде, чем тронет пакет. Он расшифровывает encryptedVerifierHashInput первым выведенным ключом, хеширует результат, расшифровывает encryptedVerifierHashValue вторым ключом и сравнивает два дайджеста на полную длину хеша, не останавливаясь на первом различающемся байте. Несовпадение заканчивает открытие результатом «неверный пароль», и тело пакета никогда не расшифровывается под неверным ключом. Неверный пароль, таким образом, не может породить книгу, полную правдоподобного мусора

Одну фразу спецификации здесь легко прочесть неверно. §2.3.4.13 определяет верификатор как saltSize байтов случайных данных, где saltSize — длина соли key encryptor. Расшифрованный верификатор возвращается с добивкой до кратности 16-байтового AES-блока, поэтому перед хешированием его надо отрезать обратно до saltSize. Excel всегда пишет saltSize и blockSize равными 16, и код, усекающий до размера блока, проходит все тесты на выходе Excel. А потом отвергает правильный пароль на первом же файле от производителя, выбравшего 32-байтовую соль. HotXLS усекает до длины соли, потому что так написано в тексте, а совпадение двух чисел в файлах Excel — совпадение

Как расшифровывается EncryptedPackage?

Ключ пакета случайный, не выведенный из пароля. Писатель его сгенерировал, зашифровал в encryptedKeyValue, а HotXLS разворачивает его третьим выведенным ключом, оставляя столько байтов, сколько keyData заявляет в keyBits. Прежде чем расшифровать хоть один сегмент, HotXLS проверяет dataIntegrity, если файл его несёт: ключ и значение HMAC расшифровываются ключом пакета, и HMAC над полным потоком EncryptedPackage, включая префикс размера, обязан совпасть с сохранённым значением. Файлы, записанные без пригодного dataIntegrity, этот шаг пропускают и всё равно открываются

HotXLS расшифровывает поток EncryptedPackage в Delphi сегмент за сегментом, выводя IV каждого сегмента AES-CBC на 4096 байт из соли keyData и индекса сегмента
Каждый 4096-байтовый сегмент AES-CBC расшифровывается независимо со своим IV из соли и индекса, а результат усекается до заявленного размера открытого текста

Сам поток начинается с 8-байтового размера открытого текста в little-endian, за которым следует шифртекст сегментами по 4096 байт. Каждый сегмент получает собственный IV: хеш соли keyData, за которым следует 32-битный индекс сегмента в little-endian, обрезанный до размера блока. Любой сегмент, таким образом, можно расшифровать отдельно — в принципе это допускало бы случайный доступ; HotXLS расшифровывает весь пакет в память, потому что ZIP-загрузчику всё равно нужен полный архив. Заявленный размер сверяется с фактической длиной потока до начала расшифровки, так что усечённая загрузка или завышенное поле размера проваливаются чисто. После последнего сегмента буфер обрезается до заявленного размера, что сбрасывает до 15 байтов AES-добивки, и остаток — байт в байт тот ZIP, который зашифровал Excel

Отличить неверный пароль от неподдерживаемого файла

Каждый провал шифрования в OpenEncrypted и Open поднимает EXlsxEncryptionNotImplemented, и сообщение говорит, какой это случай: предложенный пароль неверен или файл использует схему, которую HotXLS не читает. HotXLS читает key encryptor пароля с AES в режиме CBC и хешированием SHA-512 или SHA-256, что покрывает то, что пишут актуальные версии Excel; контейнер, защищённый только certificate key encryptor, дескриптор с другим шифром или CFB, который не Standard и не Agile — как переименованный BIFF .xls — получают сообщение о неподдерживаемой схеме

Сверка по тексту сообщения хрупка, особенно если строки ресурсов однажды локализуют. Событие OnPassword даёт более чистый сигнал: Open зажигает его только когда верификатор или проверка целостности отвергают пароль, и никогда — для неподдерживаемой схемы. Для сервиса импорта вызывайте Open(FileName, Password) с обработчиком, фиксирующим отказ, а не OpenEncrypted, который поднимает исключение, не справляясь ни о каком событии

type
  TUploadOutcome = (uoLoaded, uoPasswordRejected, uoUnreadable);

  TUploadLoader = class
  private
    FPasswordRejected: Boolean;
    procedure HandlePassword(Sender: TObject; var PassWord: WideString;
      var Retry: Boolean);
  public
    function Load(Wb: TXLSXWorkbook;
      const FileName, Password: WideString): TUploadOutcome;
  end;

procedure TUploadLoader.HandlePassword(Sender: TObject;
  var PassWord: WideString; var Retry: Boolean);
begin
  // Зажигается только когда пароль (или integrity HMAC) был отвергнут
  FPasswordRejected := True;
  Retry := False;   // на сервере спрашивать некого; дальше Open поднимет исключение
end;

function TUploadLoader.Load(Wb: TXLSXWorkbook;
  const FileName, Password: WideString): TUploadOutcome;
begin
  FPasswordRejected := False;
  Wb.OnPassword := HandlePassword;
  try
    if Wb.Open(FileName, Password) = 1 then
      Result := uoLoaded
    else
      Result := uoUnreadable;
  except
    on E: EXlsxEncryptionNotImplemented do
      if FPasswordRejected then
        Result := uoPasswordRejected   // можно безопасно спросить пользователя снова
      else
        Result := uoUnreadable;        // повтор не поможет; залогируйте E.Message
  end;
end;

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

Записывающая сторона использует ту же машинерию в обратную сторону. SaveAsEncryptedAgile производит Agile-контейнер с деривацией ключа SHA-512, 100 000 раундов прокрутки и шифрованием пакета AES-256, SaveAsEncrypted производит Standard Encryption, а установка VerifyEncryptedSave в True заставляет любой из вызовов заново открыть только что записанный файл через путь расшифровки и вернуть -1 при провале. Стандартный путь разобран в статье о записи AES-защищённого вывода XLSX, а схемы RC4 и XOR из наследимых BIFF-файлов рассмотрены в статье об интеропе ECB и RC4

Для конвейера, который никогда не знает заранее, несёт ли следующая загрузка пароль, ридер, описанный выше, вместе с нативным чтением и записью XLS и XLSX для Delphi и C++Builder — часть HotXLS Delphi Excel Component