Artigo Técnico

HotXLS: detecte XLSX adulterados com dataIntegrity HMAC

Um único byte alterado dentro do stream EncryptedPackage de um .xlsx protegido por senha não impede o AES-CBC de decifrar tudo com a senha certa: o bloco de 16 bytes que contém o byte virado vira ruído, e o mesmo bit vira limpinho no bloco de plaintext seguinte. A criptografia sozinha não consegue avisar que isso aconteceu. A defesa vive no elemento dataIntegrity do [MS-OFFCRYPTO] §2.3.4.14, um HMAC sobre o ciphertext armazenado que o leitor verifica antes de decifrar um único segmento

A criptografia Agile, o esquema que o Excel grava por padrão para pastas de trabalho protegidas por senha, dá confidencialidade por AES em modo CBC com uma chave derivada de um hash de senha SHA-512 iterado. O CBC não é um modo autenticado, então a cifra não tem opinião sobre se o ciphertext à sua frente é o ciphertext que foi escrito. Um pacote modificado normalmente explode depois como um erro de ZIP ou deflate, porque um stream comprimido corrompido raramente sobrevive à inflação. O "normalmente" carrega muito peso nessa frase, e um erro de parser três camadas abaixo é um péssimo lugar para descobrir que alguém editou o arquivo em trânsito

Por que uma pasta de trabalho criptografada e adulterada ainda decifra?

Uma pasta de trabalho adulterada ainda decifra porque o CBC apenas encadeia blocos; ele nunca os autentica. Cada bloco de ciphertext é decifrado com a chave e depois passado por XOR com o bloco de ciphertext anterior, então uma mudança no bloco n embaralha o bloco de plaintext n e vira exatamente os mesmos bits no bloco n+1. Alguém que conhece o layout do plaintext pode direcionar esse segundo efeito. Alguém que não conhece ainda pode corromper dados de formas que um parser a jusante pode ou não notar

O [MS-OFFCRYPTO] responde a isso com um MAC calculado sobre os bytes criptografados. O gerador cria uma chave HMAC aleatória cujo comprimento corresponde ao tamanho de hash do keyData (64 bytes para SHA-512), calcula um HMAC sobre o stream EncryptedPackage completo e guarda ambos os valores no elemento dataIntegrity como encryptedHmacKey e encryptedHmacValue. Ambos são criptografados com a chave do pacote, usando IVs derivados do salt do keyData e duas block keys fixas definidas pela especificação. O HMAC cobre o stream como armazenado, incluindo o prefixo StreamSize de 8 bytes à frente dos segmentos, então nem o comprimento de plaintext declarado pode ser alterado sem detecção

A ordem em que o HotXLS verifica as coisas ao abrir

O HotXLS roda a verificação de integridade depois que a senha é provada e antes que qualquer segmento do pacote seja decifrado. O TXLSXWorkbook.OpenEncrypted primeiro tenta o leitor de Standard Encryption e, quando o stream EncryptionInfo carrega a assinatura Agile (versão 4.4), o pipeline Agile assume. Esse pipeline roda estes passos em ordem:

  1. Rodar o hash de senha iterado com o salt e o spin count do descritor; um spinCount acima do teto de 10.000.000 da especificação é tratado como descritor malformado e rejeitado antes de qualquer hash começar
  2. Decifrar o verificador de senha, calcular o hash dele e comparar o resultado com o hash do verificador armazenado; uma divergência aqui significa senha errada
  3. Desembrulhar a chave intermediária do pacote e então decifrar a chave HMAC e o valor HMAC dos atributos dataIntegrity
  4. Calcular o HMAC sobre os bytes do EncryptedPackage exatamente como estão no arquivo e comparar com o valor armazenado
  5. Só depois de uma correspondência, decifrar os segmentos de 4096 bytes e entregar o ZIP interno ao carregador XLSX normal

Rodar o MAC sobre o ciphertext é a disciplina padrão encrypt-then-MAC. Um pacote adulterado é rejeitado antes que qualquer byte controlado pelo atacante chegue à descriptografia AES, à inflação ou ao parser de XML. Ambas as comparações neste caminho, o hash do verificador e o valor do HMAC, fazem OR do XOR de cada par de bytes ao longo do digest completo em vez de retornar na primeira diferença, então o tempo de resposta não revela quantos bytes iniciais corresponderam. O algoritmo de hash segue o descritor: o Excel declara SHA-512, alguns geradores de terceiros declaram SHA-256, e o HMAC, os IVs e a derivação de chave mudam para o que os nós keyData e do encryptor de chave de senha disserem

HotXLS: diagrama de fluxo da ordem de verificação do dataIntegrity: derivar chave, decifrar chave e valor HMAC, calcular HMAC-SHA-512 sobre o ciphertext, comparar em tempo constante, então decifrar segmentos ou rejeitar
O portão de integridade roda antes de qualquer coisa ser inflada: o HMAC é calculado sobre o ciphertext armazenado, então uma senha errada ou um pacote adulterado é rejeitado no portão em vez de aparecer como lixo depois da descriptografia

Do lado de quem chama, uma verificação de integridade falha e uma senha errada são o mesmo evento. Ambos fazem o OpenEncrypted disparar EXlsxEncryptionNotImplemented com a mensagem "The supplied password is incorrect for this encrypted workbook." Um contêiner que não é Standard nem Agile, ou um arquivo CFB ilegível, dispara a mesma classe de exceção com outra mensagem. Só uma descriptografia bem-sucedida seguida de falha ao carregar a pasta interna volta como valor de retorno diferente de 1

uses
  SysUtils, lxHandleX;

// Abre uma pasta de trabalho que precisa chegar criptografada
function OpenIntake(const FileName, Password: WideString): TXLSXWorkbook;
var
  Book: TXLSXWorkbook;
begin
  Book := TXLSXWorkbook.Create;
  try
    // OpenEncrypted cai para um Open simples para um ZIP não criptografado,
    // então um pipeline que exige criptografia precisa verificar antes
    if not Book.CanReadEncrypted(FileName) then
      raise Exception.Create('Not an encrypted package: ' + FileName);
    // Senha errada e HMAC divergente ambos disparam EXlsxEncryptionNotImplemented
    if Book.OpenEncrypted(FileName, Password) <> 1 then
      raise Exception.Create('Decrypted, but the inner workbook did not load');
    Result := Book;
  except
    Book.Free;
    raise;
  end;
end;

// Chamador; Quarantine e ProcessWorkbook são rotinas suas
try
  Book := OpenIntake('incoming.xlsx', PasswordFromVault);
  try
    ProcessWorkbook(Book);
  finally
    Book.Free;
  end;
except
  on E: EXlsxEncryptionNotImplemented do
    Quarantine('incoming.xlsx', E.Message);
end;

A guarda CanReadEncrypted importa mais do que parece. Ela testa a assinatura de OLE compound file, e sem ela alguém poderia substituir uma pasta criptografada por um .xlsx comum e o OpenEncrypted carregaria como se nada estivesse errado. Um .xls legado renomeado também carrega essa assinatura, e é por isso que ele passa pela guarda e depois falha dentro do OpenEncrypted com a mensagem de esquema de criptografia não suportado

Escrevendo pacotes que carregam o bloco

O SaveAsEncryptedAgile é a chamada que produz um bloco dataIntegrity. Ele serializa a pasta para um XLSX em memória, criptografa com AES-256-CBC sob uma derivação de chave SHA-512 com spin count de 100.000, calcula um HMAC-SHA-512 sobre o stream EncryptedPackage final e escreve os dois blobs HMAC criptografados no descritor. O SaveAsEncrypted grava ECMA-376 Standard Encryption (AES-128 com derivação de chave SHA-1) em vez disso, e a estrutura EncryptionInfo Standard definida pelo [MS-OFFCRYPTO] não tem nenhum slot para um MAC de integridade. Para qualquer coisa que cruze uma rede ou fique em uma unidade compartilhada, use o gerador Agile: não custa nada extra em código e é o único dos dois cuja saída um leitor pode verificar contra adulteração

var
  Book: TXLSXWorkbook;
begin
  Book := TXLSXWorkbook.Create;
  try
    BuildPayrollSheets(Book);        // código seu que preenche a pasta
    // Reabre o contêiner gravado pelo pipeline de descriptografia
    // e reporta falha em vez de deixar um arquivo quebrado para trás
    Book.VerifyEncryptedSave := True;
    if Book.SaveAsEncryptedAgile('payroll-2026-10.xlsx', PasswordFromVault) <> 1 then
      raise Exception.Create('Encrypted save failed or did not verify');
  finally
    Book.Free;
  end;
end;

Com o VerifyEncryptedSave definido, o save abre o arquivo novo de novo com a mesma senha, então um save verificado já passou pela verificação HMAC uma vez. O material aleatório — os dois salts de 16 bytes, a entrada do verificador, a chave de pacote de 32 bytes e a chave HMAC de 64 bytes — vem do CSPRNG do sistema operacional (CryptGenRandom no Windows). Se essa fonte não puder entregar, o gerador Agile dispara uma exceção em vez de cair para um gerador semeado pelo relógio. Esses bytes viram salts e chaves AES; um fallback previsível produziria arquivos que parecem criptografados, passam em todo teste funcional e não protegem nada. Um save que falha é o desfecho melhor aqui

O que acontece quando um arquivo não tem bloco dataIntegrity?

O arquivo abre normalmente. Muitas pastas de trabalho com criptografia Agile em circulação vêm de geradores que deixam o dataIntegrity de fora, e recusá-las quebraria muito mais trabalho legítimo do que impediria. O HotXLS trata o bloco como presente só quando encryptedHmacKey e encryptedHmacValue decodificam para valores não vazios e alinhados a 16 bytes; caso contrário, a verificação é pulada e a descriptografia segue após a checagem de senha

Essa escolha de compatibilidade tem uma consequência de segurança que vale registrar no seu modelo de ameaças. O elemento dataIntegrity fica no stream EncryptionInfo, fora dos bytes que o próprio MAC dele cobre, então um bloco ausente é idêntico a um bloco que um atacante apagou. Se você controla as duas pontas de um pipeline e todo produtor usa SaveAsEncryptedAgile, trate um bloco ausente como falha de política no nível da aplicação. A chamada de abertura não informa se a verificação rodou, então impor essa regra significa ler o XML do EncryptionInfo você mesmo com um leitor de compound files antes de entregar o arquivo. Para arquivos que vêm do mundo exterior, leia a checagem pelo que ela é: um sinal forte quando o bloco está lá, e nenhum sinal quando está ausente

O loop de retry do OnPassword e arquivos adulterados

A sobrecarga simples Open(FileName, Password) também decifra pacotes Standard e Agile, e adiciona um contrato de retry que o OpenEncrypted não tem. Quando o resultado é "senha errada" e o OnPassword está atribuído, a pasta chama o handler, que pode fornecer outra senha e definir Retry como True; o loop para após três chamadas do handler. Como uma divergência de HMAC produz o mesmo resultado de "senha errada", um handler que apenas repete o prompt é chamado até três vezes para um pacote adulterado, toda tentativa falha, e o loop termina com a mensagem de senha incorreta. A senha correta falha no HMAC, e toda outra senha falha no verificador

procedure TIntakeForm.BookPassword(Sender: TObject;
  var PassWord: WideString; var Retry: Boolean);
begin
  // Também alcançado para um pacote cujo HMAC não bateu.
  // Repetir o prompt não corrige esse caso, então ofereça uma única chave de fallback
  // e deixe a próxima falha aparecer como erro
  Inc(FPasswordCalls);
  Retry := (FPasswordCalls = 1) and FetchFallbackKey(PassWord); // função sua
end;

// Ligação
FPasswordCalls := 0;
Book.OnPassword := BookPassword;
Book.Open('incoming.xlsx', PasswordFromVault);

Para intake não assistido, deixe o OnPassword sem atribuir e chame o OpenEncrypted. A primeira falha então dispara imediatamente, e o log de quarentena registra um evento por arquivo em vez de uma rajada de retries

Senha de modificação é coordenação, não proteção

Pastas XLS clássicas suportam um mecanismo separado que as pessoas costumam confundir com criptografia: a write reservation por trás do prompt de "password to modify" do Excel. O HotXLS o expõe no IXLSWorkbook via SetModifyPassword, que recebe a senha, uma flag de recomendar somente leitura e o nome do usuário que reserva, e informa o estado pela propriedade IsWriteReserved. Passar uma senha vazia limpa a reserva e deixa o nome de usuário WRITEACCESS separado intocado

O layout de registros é curto. O FILESHARING carrega a flag de recomendar somente leitura, um hash de senha legado de 16 bits e o nome do usuário como uma string Unicode BIFF8 descomprimida; ao salvar, o HotXLS posiciona o marcador WRITEPROT vazio antes do WRITEACCESS e do FILESHARING sempre que existe uma reserva, que é a ordem do File Protection Block que o Excel espera. Reservas que o próprio Excel escreveu sobrevivem a um round trip do HotXLS pelo mesmo caminho. Esses registros são gravados só para o formato BIFF8 xlExcel97

var
  Book: IXLSWorkbook;   // contado por interface: não dê Free
begin
  Book := TXLSWorkbook.Create;
  if Book.Open('shared-model.xls') = 1 then
  begin
    // Recomenda somente leitura, reservado pelo serviço de relatórios
    Book.SetModifyPassword('edit-me', True, 'Reporting Service');
    if Book.IsWriteReserved then
      Book.SaveAs('shared-model.xls', xlExcel97);
  end;
end;

Um hash de 16 bits é um checksum, e os dados das planilhas sob uma write reservation não estão criptografados de forma alguma; qualquer outra ferramenta lê todas as células. A feature avisa à próxima pessoa no Excel que alguém considera este arquivo seu para editar, na mesma categoria dos controles no nível de planilha cobertos em proteção de planilha XLSX e opções allow. Confidencialidade vem dos caminhos de save criptografados descritos em saída XLSX protegida por AES, e checagens no nível do contêiner pertencem ainda mais cedo na cadeia, já que a estrutura ZIP de um pacote simples é analisada antes de qualquer lógica de pasta rodar; validação de ZIP end-of-central-directory para XLSX não confiável cobre esses modos de falha

O HotXLS lê e escreve XLS, XLSX e ODS a partir de Delphi e C++Builder sem instalação do Excel, e seu código de criptografia Standard e Agile é escrito em Pascal contra o [MS-OFFCRYPTO]. A referência completa de métodos de OpenEncrypted, SaveAsEncryptedAgile e SetModifyPassword está na página do componente de planilhas Delphi da HotXLS