Artigo Técnico

Ler Arquivos do Excel com Criptografia Agile no HotXLS

Um cliente faz upload de uma pasta de trabalho que abre normalmente na máquina dele, e o serviço de importação a rejeita com um erro de ZIP. Um dump hexadecimal dos primeiros oito bytes mostra D0 CF 11 E0 A1 B1 1A E1, a assinatura OLE Compound File que um .xls da era 1997 carrega. O arquivo tem extensão .xlsx, saiu de um Excel atual e não é um pacote ZIP de forma alguma. Alguém definiu uma senha no diálogo Save As

Esse é todo o mistério. Quando o Excel salva uma pasta de trabalho com senha, ele criptografa o ZIP .xlsx real e embrulha o resultado em um contêiner Compound File Binary (CFB), usando o esquema Agile do [MS-OFFCRYPTO] §2.3.4.10 até §2.3.4.15. Qualquer loader que classifique arquivos pela extensão, ou que entregue todo .xlsx direto a um leitor ZIP, vai devolver o upload para um usuário que, do lado dele da tela, não fez nada fora do comum

O que mora dentro de uma pasta de trabalho com criptografia Agile

Uma pasta de trabalho com criptografia Agile é um contêiner CFB com dois streams que importam: EncryptionInfo, que descreve como a criptografia foi feita, e EncryptedPackage, que guarda o ZIP original como um blob opaco criptografado. O HotXLS lê os dois streams direto do contêiner, sem Excel, sem COM e sem DLL de criptografia externa na máquina

Anatomia da pasta de trabalho com criptografia Agile que o HotXLS abre em Delphi: um contêiner CFB segurando um stream descritor EncryptionInfo e um stream EncryptedPackage de segmentos AES-CBC
O HotXLS lê uma pasta de trabalho com criptografia Agile como um contêiner CFB com um stream EncryptionInfo autodescritivo e o ZIP .xlsx criptografado como um stream EncryptedPackage opaco

A parte que diferencia o Agile da antiga Criptografia Padrão é que o EncryptionInfo se autodescreve. Depois de um prefixo de 8 bytes cuja versão maior e menor são ambas 4, o stream é um descritor XML em UTF-8. Um elemento keyData nomeia a cifra (AES), o modo de encadeamento (ChainingModeCBC), o algoritmo de hash, o comprimento da chave em bits, o tamanho do bloco e um salt em Base64. O keyEncryptor de senha carrega seu próprio salt, um spinCount e três payloads em Base64: encryptedVerifierHashInput, encryptedVerifierHashValue e encryptedKeyValue. Um elemento dataIntegrity acrescenta uma chave HMAC e um valor HMAC criptografados para detecção de adulteração

O próprio Excel grava AES-256, SHA-512 e um spin count de 100.000. O descritor, porém, pode dizer outra coisa, e escritores de terceiros dizem. O HotXLS usa o keyBits do descritor em vez de assumir 256, então arquivos AES-128 e AES-192 decifram do mesmo jeito, e ele aceita hashAlgorithm="SHA256" além de SHA-512. O atributo de hash de cada elemento governa os passos que pertencem a ele: o hash do keyEncryptor dirige a derivação e a verificação da senha, enquanto o hash do keyData dirige os IVs de segmento e o HMAC de integridade. Um arquivo que mistura os dois ainda abre

Abrindo o arquivo: OpenEncrypted ou Open com senha

O TXLSXWorkbook.OpenEncrypted recebe um nome de arquivo e uma senha e retorna 1 em caso de sucesso, o mesmo contrato do Open. Ele fareja os primeiros oito bytes com CanReadEncrypted. Um arquivo sem a assinatura CFB segue o caminho comum do Open e a senha é ignorada, então um importador que sempre chama OpenEncrypted não precisa de nenhum branch no ponto de chamada. Um arquivo CFB é tentado primeiro como Criptografia Padrão, e quando o prefixo do EncryptionInfo carrega a versão Agile 4.4, o leitor Agile assume. Os bytes do ZIP decifrados então vão para o loader XLSX regular em memória

Os dois pontos de entrada recebem um nome de arquivo. O Open(Stream) recusa um stream que começa com a assinatura CFB e levanta uma exceção cuja mensagem aponta para o OpenEncrypted, então um upload guardado em um TMemoryStream precisa primeiro ir para um arquivo temporário

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 := '';
  // Pacotes criptografados são abertos a partir de um arquivo, então despeje o upload no disco
  TempName := TPath.GetTempFileName;
  Wb := TXLSXWorkbook.Create;
  try
    Upload.SaveToFile(TempName);
    // Arquivos .xlsx comuns, com criptografia Padrão e com criptografia Agile funcionam aqui
    if Wb.OpenEncrypted(TempName, Password) = 1 then
      Result := VarToWideStr(Wb.Sheets[1].Cells[1, 1].Value);
  finally
    Wb.Free;
    TFile.Delete(TempName);
  end;
end;

A sobrecarga Open(FileName, Password) de dois argumentos chega ao mesmo código de decifração, mas acrescenta uma coisa que o OpenEncrypted não tem: o evento OnPassword. Quando a senha fornecida falha, o Open dispara o OnPassword, deixa o handler atribuir uma nova senha e definir Retry como True, e pergunta de novo, até três vezes. Uma aplicação desktop pode colocar um prompt de senha nesse handler. Um servidor pode usá-lo para outra coisa, assunto da última seção

Como uma senha se torna uma chave AES?

A senha nunca decifra nada diretamente. O primeiro digest é um SHA-512 sobre o salt do keyEncryptor seguido dos bytes UTF-16LE da senha; esse digest é então hasheado spinCount vezes, cada rodada precedendo o contador de rodada de 32 bits little-endian ao digest anterior. Com as 100.000 rodadas do Excel, cada tentativa de senha custa cem mil chamadas seriais de SHA-512. Esse é o propósito do spin count. Uma abertura legítima paga o preço uma vez, e um ataque de dicionário o paga a cada palpite

Como o HotXLS deriva chaves de criptografia Agile em Delphi: a senha é girada por 100.000 rodadas de SHA-512, então três block keys fixas de 8 bytes produzem as chaves de verifier e de package
A senha nunca decifra nada diretamente: uma cadeia de spin count SHA-512 alimenta três hashes de block key que produzem as chaves do verifier e desembrulham a chave aleatória do pacote

A cadeia é curta o bastante para reproduzir, e fazê-lo é o caminho mais rápido para ver o que um palpite custa no seu hardware. O esboço abaixo segue a §2.3.4.11 para um descritor SHA-512 e usa a função pública XlsSHA512 da unit lxXlsxAgileDecrypt

uses
  System.SysUtils, lxXlsxAgileDecrypt;

// H0 = SHA-512(salt + UTF-16LE(password))
// Hn = SHA-512(LE32(n - 1) + H(n-1)), repetido SpinCount vezes
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);           // contador de rodada, 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);         // digest anterior
    Result := XlsSHA512(Buf);
  end;
end;

O hash girado ainda não é uma chave. Três chaves saem dele, cada uma hasseando o valor girado mais uma vez com uma block key fixa de 8 bytes anexada: FE A7 D2 76 3B 4B 9E 79 para a entrada do verifier, D7 AA 0F 6D 30 61 34 4E para o hash do verifier e 14 6E 0B E7 AB AC D0 D6 para desembrulhar a chave do pacote. Cada resultado é cortado no comprimento de chave declarado, 32 bytes para AES-256. A especificação também define o que acontece quando um hash sai menor que a chave: preencher com bytes 0x36. Nenhum tamanho de chave AES de fato dispara isso com SHA-256 ou SHA-512, mas a mesma regra do 0x36 vale quando o salt da senha é esticado até o tamanho do bloco para servir de IV do CBC

O spin count é lido do arquivo, então também é uma superfície de ataque: um upload declarando um bilhão de rodadas prenderia um núcleo de CPU antes de falhar. A §2.3.4.11 limita o spinCount a 10.000.000, e o HotXLS reporta um valor maior como descritor não suportado antes de hassear qualquer coisa. Para um endpoint público de upload, esse teto é o padrão certo. Os 100.000 do próprio Excel ficam bem abaixo dele

Verificação de senha e a armadilha de truncamento do saltSize

O HotXLS verifica a senha antes de tocar no pacote. Ele decifra o encryptedVerifierHashInput com a primeira chave derivada, hasseia o resultado, decifra o encryptedVerifierHashValue com a segunda chave e compara os dois digests ao longo do comprimento completo do hash, sem parar no primeiro byte que diverge. Uma divergência encerra a abertura com um resultado de senha errada, e o corpo do pacote nunca é decifrado sob uma chave errada. Uma senha incorreta, portanto, não pode produzir uma pasta de trabalho cheia de lixo plausível

Uma frase da especificação é fácil de ler errado aqui. A §2.3.4.13 define o verifier como saltSize bytes de dados aleatórios, em que saltSize é o comprimento do salt do key encryptor. O verifier decifrado volta preenchido até um múltiplo do bloco AES de 16 bytes, então precisa ser cortado de volta para saltSize antes do hash. O Excel sempre grava saltSize e blockSize como 16, o que significa que código que trunca pelo tamanho do bloco passa em todo teste contra saída do Excel. E depois rejeita a senha correta no primeiro arquivo de um produtor que escolheu um salt de 32 bytes. O HotXLS trunca pelo comprimento do salt, porque é o que o texto diz, e os dois números coincidirem em arquivos do Excel é coincidência

Como o EncryptedPackage é descriptografado?

A chave do pacote é aleatória, não derivada da senha. O escritor a gerou, criptografou-a no encryptedKeyValue, e o HotXLS a desembrulha com a terceira chave derivada, guardando tantos bytes quantos o keyData declarar no keyBits. Antes de decifrar um único segmento, o HotXLS verifica o dataIntegrity quando o arquivo o traz: a chave HMAC e o valor HMAC são decifrados com a chave do pacote, e um HMAC sobre o stream EncryptedPackage completo, prefixo de tamanho incluído, precisa casar com o valor guardado. Arquivos gravados sem um elemento dataIntegrity utilizável pulam esse passo e ainda abrem

O HotXLS decifra o stream EncryptedPackage em Delphi segmento por segmento, derivando o IV de cada segmento AES-CBC de 4096 bytes do salt do keyData e do índice do segmento
Cada segmento AES-CBC de 4096 bytes decifra independentemente sob seu próprio IV de salt e índice, e o resultado é truncado ao tamanho de texto simples declarado

O stream em si começa com um tamanho de texto simples de 8 bytes little-endian, seguido pelo ciphertext em segmentos de 4096 bytes. Cada segmento ganha seu próprio IV: o hash do salt do keyData seguido do índice de segmento de 32 bits little-endian, cortado ao tamanho do bloco. Qualquer segmento pode, portanto, ser decifrado por si só, o que permitiria acesso aleatório em princípio; o HotXLS decifra o pacote inteiro para a memória porque o leitor ZIP quer o arquivo completo de qualquer forma. O tamanho declarado é conferido contra o comprimento real do stream antes de a decifração começar, então um upload truncado ou um campo de tamanho inflado falha de forma limpa. Depois do último segmento, o buffer é cortado ao tamanho declarado, o que descarta os até 15 bytes de padding do AES, e o que sobra é byte a byte o ZIP que o Excel criptografou

Distinguir uma senha errada de um arquivo não suportado

Toda falha de criptografia no OpenEncrypted e no Open levanta EXlsxEncryptionNotImplemented, e a mensagem diz qual caso é: a senha fornecida está incorreta, ou o arquivo usa um esquema que o HotXLS não lê. O HotXLS lê o key encryptor de senha com AES em modo CBC e hash SHA-512 ou SHA-256, o que cobre o que as versões atuais do Excel gravam; um contêiner protegido apenas por um key encryptor de certificado, um descritor nomeando outra cifra ou um CFB que não é nem Padrão nem Agile, como um .xls BIFF renomeado, recebe a mensagem de não suportado

Casar pelo texto da mensagem é frágil, principalmente se as strings de recurso um dia forem localizadas. O evento OnPassword dá um sinal mais limpo: o Open o dispara somente quando o verifier ou a checagem de integridade rejeita a senha, nunca por um esquema não suportado. Para um serviço de importação, chame Open(FileName, Password) com um handler que registra a rejeição, em vez do OpenEncrypted, que levanta sem consultar evento algum

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
  // Disparado somente quando a senha (ou o HMAC de integridade) foi rejeitada
  FPasswordRejected := True;
  Retry := False;   // ninguém para perguntar em um servidor; o Open levanta em seguida
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   // seguro perguntar ao usuário de novo
      else
        Result := uoUnreadable;        // uma nova tentativa não ajuda; registre o E.Message
  end;
end;

Uma pegadinha permanece mesmo com essa separação. Uma divergência de integridade é reportada do mesmo jeito que uma senha ruim, então uma pasta de trabalho cujo ciphertext foi danificado em trânsito, por um proxy que reescreveu o corpo ou por um upload cortado no meio de um segmento, volta como uoPasswordRejected mesmo quando o usuário digitou a senha certa. Se o mesmo usuário falhar duas vezes com uma senha que ele jura estar correta, peça o arquivo de novo antes de pedir a senha de novo

O lado da escrita usa a mesma maquinaria ao contrário. O SaveAsEncryptedAgile produz um contêiner Agile com derivação de chave SHA-512, 100.000 rodadas de spin e criptografia de pacote AES-256, o SaveAsEncrypted produz a Criptografia Padrão, e definir VerifyEncryptedSave como True faz qualquer uma das chamadas reabrir o arquivo que acabou de gravar pelo caminho de decifração e retornar -1 se isso falhar. O caminho Padrão é percorrido em o artigo sobre gravação de saída XLSX protegida por AES, e os esquemas RC4 e XOR encontrados dentro de arquivos BIFF legados são cobertos em o artigo de interoperabilidade ECB e RC4

Para um pipeline que nunca sabe de antemão se o próximo upload traz senha, o leitor descrito acima, junto com a leitura e gravação nativas de XLS e XLSX para Delphi e C++Builder, faz parte do HotXLS Delphi Excel Component