Uma pasta BIFF5 protegida com a senha secret pode carregar um verificador de senha que confere perfeitamente e ainda assim fazer o Excel 16 responder que a senha está incorreta. O Excel só aceita o arquivo quando a chave do FILEPASS é igual a CreateXorKey_Method1(password), o array XOR de 16 bytes é construído com XorRor, e cada byte usa XorArrayIndex = (offset do stream + comprimento do record) mod 16
O Excel 16 tem dois jeitos diferentes de recusar esse tipo de arquivo, e eles mapeiam limpo nas camadas do [MS-OFFCRYPTO] §2.3.7. Um prompt de senha que continua rejeitando a senha certa aponta para a palavra-chave no FILEPASS. Um relato de que o arquivo tem um problema e não pode ser aberto, mostrado depois que a senha é aceita, aponta para o array XOR ou para o índice que escolhe um byte do array. As seções abaixo seguem essa ordem, até o byte
O que o record FILEPASS guarda num arquivo BIFF5
A ofuscação XOR do BIFF guarda exatamente duas palavras de 16 bits, e todo o resto é recalculado a partir da senha. O record FILEPASS ($002F) fica logo depois do BOF de globals da pasta e, num arquivo BIFF5, o corpo dele tem 4 bytes: a chave XOR, depois o verificador de senha. Não há salt. Também não há identificador de algoritmo, nem nada parecido com o blob de verificador criptografado que esquemas RC4 e AES carregam
A partir dessas duas palavras um leitor reconstrói três valores:
- O verificador, um hash de 16 bits dos bytes da senha XORed com o comprimento da senha e
$CE4B. Compará-lo com a palavra armazenada é a conferência de senha documentada - A chave XOR, um valor de 16 bits produzido por
CreateXorKey_Method1no [MS-OFFCRYPTO] §2.3.7.2 a partir de duas tabelas constantes,InitialCode(15 palavras) eXorMatrix(105 palavras) - O array XOR, 16 bytes feitos dos bytes da senha preenchidos com um pad fixo de 16 bytes, cada um XORed com o byte baixo da chave nas posições pares ou o byte alto nas ímpares, depois rotacionado à direita um bit
Cabeçalhos de record ficam em texto puro. Alguns records inteiros ficam também — BOF, FILEPASS, USREXCL, FILELOCK, INTERFACEHDR, RRDHEAD e RRDINFO — mais os primeiros 4 bytes de todo BOUNDSHEET. Todo outro corpo de record é transformado byte a byte: rotação à esquerda de 5 bits, depois XOR com uma entrada do array de 16 bytes. A decriptação, que o §2.3.7.3 escreve como DecryptData_Method1, roda a imagem espelhada: XOR primeiro, depois rotação à direita de 5
O HotXLS mantém tudo isso atrás de duas propriedades de pasta. TXLSWorkbook.EncryptionPassword guarda a senha, EncryptionType escolhe o esquema, e o SaveAs com xlExcel5 emite o FILEPASS logo depois do BOF e transforma o resto do stream:
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 só tem ofuscação XOR; xletAuto escolhe o mesmo esquema
// para xlExcel5, então a definição explícita só documenta a intenção
Wb.EncryptionType := xletXor;
// ASCII, no máximo 15 caracteres (veja as notas de senha abaixo)
Wb.EncryptionPassword := 'secret';
if Wb.SaveAs(FileName, xlExcel5) <> 1 then
raise Exception.Create('BIFF5 save failed');
end;
Por que o Excel diz que a senha está errada quando o verificador bate?
O Excel deriva a chave da senha digitada com CreateXorKey_Method1 e compara com a palavra-chave no FILEPASS, então um arquivo cuja chave é qualquer outra coisa falha na conferência de senha mesmo quando o verificador está correto. A especificação trata a chave como função da senha, e o Excel 16 impõe essa leitura com rigor
O atalho tentador é preencher a palavra-chave com dois bytes aleatórios. No papel parece inofensivo: o verificador é a conferência de senha documentada, e o array é construído a partir de qualquer chave que o arquivo declare. Um leitor que aceita a chave do FILEPASS como dada abre esses arquivos sem reclamar, e é assim que o atalho sobrevive em código testado só contra ele mesmo. O Excel 16, recebendo o mesmo arquivo e a senha correta, recusa no prompt. O HotXLS deriva a chave a todo salvamento, então o FILEPASS da senha secret sempre guarda a chave $014D e o verificador $DAA7
A derivação fica curta quando as duas tabelas estão no lugar. Percorra a senha de trás para frente a partir do último byte, teste o bit 6 de cada byte sete vezes enquanto desloca à esquerda, e XOR com uma entrada de XorMatrix cada vez que o bit estiver armado; o índice da tabela começa na última entrada, $68, e cai um por bit, tenha o bit sido armado ou não. O esboço abaixo reproduz o algoritmo da especificação passo a passo e dá os mesmos resultados que a biblioteca. É uma ilustração para o seu próprio leitor, e nenhuma dessas rotinas faz parte da API do HotXLS:
// Esboço de [MS-OFFCRYPTO] 2.3.7.2 CreateXorKey_Method1 e
// CreateXorArray_Method1 (só ilustração, não é API do 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; // a chave só vê 15 bytes
if Len = 0 then
Exit;
Result := InitialCode[Len - 1];
Element := $68; // última entrada de 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)); // rotação à direita de um bit
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;
Para secret isso produz o array 1F 32 17 B9 14 BA 7B 7F 59 DD 59 7F 7A C0 A6 DF. Junto com a chave $014D e o verificador $DAA7, você tem três valores conhecidos e bons para afirmar nos testes antes de envolver o Excel
Rotação à direita de um, e por que rotação à esquerda de dois parece plausível
Com a chave certa, o Excel 16 passa do prompt de senha direto para o segundo erro, o relato de que o arquivo tem um problema. A causa usual é um array XOR rotacionado para o lado errado. O §2.3.7.2 define o passo do array como XorRor, uma rotação à direita de um bit, mas uma variante que rota cada byte do array 2 bits à esquerda circula em várias implementações BIFF, e um leitor construído sobre a mesma variante nunca percebe nada de errado
O Excel 16 não salva arquivos Excel 5.0/95, e não oferece XOR ao salvar BIFF8, então não há amostra nativa para diff. Quando você precisa cravar qual combinação o seu código implementa, o método confiável roda no outro sentido: escreva um stream BIFF5 em texto puro, recodifique-o sob cada combinação de três escolhas independentes e deixe o Excel 16 abrir cada resultado:
| Escolha | Opção A | Opção B |
|---|---|---|
| Rotação do array | XorRor (rotação à direita de 1) | Rotação à esquerda de 2 |
| Índice do array | (offset + comprimento do registro) mod 16 | offset mod 16 |
| Ordem da transformação do byte | Rotação à esquerda de 5, depois XOR | XOR, depois rotação à esquerda de 5 |
Dos oito arquivos, o Excel 16 aceita a combinação da especificação — XorRor, rota-então-XOR, índice pelo comprimento do record — e exatamente mais uma que só parece diferente. Rotação à esquerda de 2 em par com XOR-então-rotação e o mesmo índice é a mesma função disfarçada. Rotação distribui sobre XOR, então rol5(p xor rol2(b)) é igual a rol5(p) xor rol7(b), e num valor de 8 bits rotação à esquerda de 7 é rotação à direita de 1. Resumindo: rol5 ∘ rol2 = ror1
Essa identidade explica por que o array de rotação à esquerda de 2 parece certo isolado. Ele só está correto junto com a ordem de transformação oposta; em par com a ordem da especificação corrompe todo byte transformado. Toda variante que tira o comprimento do record do índice falha também, seja qual rotação usar. Escreva a combinação da especificação e nada mais. O gêmeo algébrico abre, mas deixa para o próximo mantenedor duas divergências para fazer engenharia reversa, onde o texto da especificação não deixa nenhuma
Como o XorArrayIndex é calculado para cada byte?
O XorArrayIndex de um byte é o offset dele no stream da pasta mais o comprimento de todos os dados do record a que pertence, mod 16. O índice então reinicia num valor dependente do record a cada record e incrementa um por byte dentro dele. O pseudocódigo da especificação nomeia as entradas FileOffset e Data.Length, e é fácil ler a primeira como sendo só o offset de início do record
Três detalhes decidem se os seus índices se alinham com o Excel:
- O cabeçalho de record de 4 bytes nunca é transformado, mas ocupa posições do stream mesmo assim, então o primeiro byte de corpo de um record fica em offset do cabeçalho + 4
- O termo de comprimento é o comprimento total dos dados do record, incluindo qualquer prefixo simples que a transformação pula
- BOUNDSHEET é parcialmente simples: os primeiros 4 bytes dele, o
lbPlyPos, offset no stream do BOF da planilha, ficam legíveis para um parser localizar planilhas sem a senha. Esses 4 bytes são pulados pela transformação mas contam tanto para o offset quanto para o comprimento do record
Juntando, a transformação por record são umas poucas linhas. Como antes, isto esboça a regra para o seu código; o HotXLS a aplica internamente durante o SaveAs:
function Rol8(B: Byte; N: Integer): Byte;
begin
Result := Byte((B shl N) or (B shr (8 - N)));
end;
// Ofusca um corpo de registro in place. BodyPos é o offset no stream de
// Body[0], ou seja, o offset do cabeçalho do registro + 4. PlainPrefix é 4 para
// BOUNDSHEET, o comprimento total para BOF / FILEPASS, 0 para a maioria dos registros
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;
// A leitura é a imagem espelhada: B := Body[I] xor Arr[...];
// depois rotação à direita de 5, ou seja, Rol8(B, 3)
Um leitor e um escritor que indexam só pela posição do stream descartam o comprimento do record dos dois lados, então concordam entre si e com mais ninguém. No lado da leitura, o HotXLS calcula o índice a partir da posição atual do stream mais o comprimento do prefixo simples mais a contagem de bytes transformados — o mesmo comprimento de record que o escritor usou
Lendo arquivos que usam o array de rotação à esquerda de 2
O HotXLS também abre arquivos XOR construídos com o array de rotação à esquerda de 2 e uma chave aleatória, e distingue-os pela chave do FILEPASS. Quando a chave armazenada é igual à chave derivada da senha, o leitor constrói o array XorRor da especificação; quando difere, o leitor troca para o array de rotação à esquerda de 2. Arquivos escritos pelo Excel sempre carregam a chave derivada, então sempre seguem o caminho da especificação
O teste é uma heurística com taxa de falha precisa. Para um arquivo cuja chave foi preenchida aleatoriamente, a chance de ela por acaso ser igual à chave derivada — e portanto ser lido com o array errado — é 1 em 65.536. A troca cobre só a rotação do array; a regra de índice fica fixa, então vale para arquivos que já usam o índice por comprimento de record. Abrir tal arquivo com o HotXLS e salvá-lo de novo produz um arquivo que o Excel aceita, porque o escritor sempre usa a chave derivada e XorRor
Dois detalhes de senha valem para todo arquivo, seja qual array ele usar:
- Comprimento.
CreateXorKey_Method1lê só os primeiros 15 bytes da senha, que é o limite da especificação. O HotXLS aplica esse teto à chave e mantém o verificador na senha completa e o array na regra de 16 bytes dele, identicamente nos lados de leitura e escrita. Como a chave só vê 15 bytes, 15 caracteres é o máximo prático - Conjunto de caracteres. O HotXLS converte a senha em bytes pela página de código ANSI do sistema, para a chave, o verificador e o array igualmente. A especificação descreve pegar o byte baixo de cada caractere UTF-16, e os dois concordam para ASCII. Sem amostras do Excel protegidas por senhas não ASCII não há verdade de referência para mais nada, então mantenha senhas XOR em ASCII puro
Quando o Open encontra um record FILEPASS e a senha falta ou está errada, TXLSWorkbook.OnPassword dispara. O handler é um TXLSPasswordEvent com um var PassWord: WideString e um var Retry: Boolean; atribua uma senha nova e ponha Retry em True para tentar de novo, até três retries. Deixar Retry em False faz o Open devolver o código de erro de senha:
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: senha exigida mas nenhuma fornecida; -1005: senha errada
if Rc <> 1 then
raise Exception.CreateFmt('Cannot open %s (code %d)', [FileName, Rc]);
ShowMessage(VarToStr(Wb.Sheets[1].Range['A1', 'A1'].Value));
end;
Se a senha já é conhecida, a sobrecarga Open(FileName, APassWord) a passa adiantado e o evento só dispara quando essa senha falha
A ofuscação XOR vale a pena ser escrita afinal?
A ofuscação XOR do BIFF mantém um usuário casual longe de um arquivo e não faz nada contra alguém motivado. A conferência de senha é um verificador de 16 bits, a chave tem 16 bits, e o array de 16 bytes se repete pelo stream inteiro, então conteúdos previsíveis de record BIFF expõem bytes do array sem senha nenhuma. O único motivo para escrevê-la hoje é um consumidor legado que lê arquivos Excel 5.0/95 e nada mais novo, porque o BIFF5 não oferece outro esquema
O motor clássico escolhe o esquema através de TXLSWorkbook.EncryptionType e confere a combinação com o formato de salvamento com rigor:
xletAuto(o padrão) escreve RC4 CryptoAPI paraxlExcel97e XOR paraxlExcel5, batendo com o que o próprio Excel gravou para cada formatoxletXorsó vale para BIFF5; comxlExcel97o salvamento levanta uma exceção em vez de cair para outro esquemaxletRC4exletRC4CryptoAPIsão só BIFF8, e pedir qualquer um num salvamento BIFF5 também levanta exceção
Deixe EncryptionType em xletAuto em código que pode salvar qualquer um dos formatos. Ele sempre cai no esquema mais forte que o formato alvo suporta, e não pode levantar a exceção de combinação que um xletXor explícito levanta no dia em que alguém troca o salvamento para xlExcel97
RC4 também está datado, e fazê-lo interoperar tem as próprias armadilhas, cobertas em por que o Excel rejeita uma pasta criptografada com a senha correta. Se o destinatário consegue ler XLSX, pule os formatos legados e use o motor XLSX: TXLSXWorkbook.SaveAsEncryptedAgile escreve Agile Encryption (hashing de senha SHA-512 com spin count de 100.000 iterações e AES-256-CBC), o contêiner que o Excel 2010 e posteriores gravam por padrão, enquanto SaveAsEncrypted escreve a Standard Encryption AES-128 mais velha. As trocas entre os dois estão em criptografar arquivos XLSX com AES em Delphi, e o lado de leitura está coberto em ler arquivos Excel com criptografia Agile usando o HotXLS
Checando a saída XOR BIFF5 antes de o Excel 16 vê-la
- Salve a mesma pasta duas vezes com a mesma senha e compare os corpos do FILEPASS num hex dump. As duas cópias devem ter palavras idênticas; uma chave que muda entre salvamentos foi preenchida aleatoriamente, e o Excel 16 vai rejeitar a senha
- Para a senha
secreto corpo de 4 bytes do FILEPASS lê4D 01 A7 DAno disco, chave primeiro, as duas palavras little-endian - Os primeiros 4 bytes de todo BOUNDSHEET devem ler como um offset de stream simples que cai num BOF de planilha; se apontam para lugar nenhum, a transformação tocou o prefixo e nenhum parser localiza as planilhas sem a senha
- Mantenha senhas de teste em ASCII puro e 15 caracteres ou menos, para que chave, verificador e array vejam os mesmos bytes em toda máquina
A mesma biblioteca Delphi e C++Builder cobre XOR BIFF5, RC4 e RC4 CryptoAPI BIFF8, Standard e Agile Encryption XLSX, e o callback de senha do lado da leitura, com toda regra de nível de byte acima aplicada ao salvar. Edições, plataformas suportadas e um download de teste estão na página do HotXLS Delphi spreadsheet component