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
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
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 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