Un libro BIFF5 protegido con la contraseña secret puede llevar un verificador de contraseña que coincida perfectamente y aun así hacer que Excel 16 responda que la contraseña es incorrecta. Excel acepta el archivo solo cuando la clave del FILEPASS es igual a CreateXorKey_Method1(password), el array XOR de 16 bytes se construye con XorRor y cada byte usa XorArrayIndex = (offset de stream + longitud de registro) mod 16
Excel 16 tiene dos maneras distintas de rechazar un archivo así, y se corresponden limpiamente con las capas de [MS-OFFCRYPTO] §2.3.7. Un diálogo de contraseña que sigue rechazando la contraseña correcta apunta a la palabra de clave del FILEPASS. Un aviso de que el archivo tiene un problema y no se puede abrir, mostrado después de aceptar la contraseña, apunta al array XOR o al índice que elige un byte del array. Las secciones de abajo siguen ese orden, hasta el byte
Qué almacena el registro FILEPASS en un archivo BIFF5
La ofuscación XOR de BIFF almacena exactamente dos palabras de 16 bits, y todo lo demás se recalcula desde la contraseña. El registro FILEPASS ($002F) va inmediatamente después del BOF de los globals del libro, y en un archivo BIFF5 su cuerpo mide 4 bytes: la clave XOR y después el verificador de contraseña. No hay salt. Tampoco hay identificador de algoritmo, ni nada parecido al blob de verificador cifrado que llevan los esquemas RC4 y AES
De esas dos palabras un lector reconstruye tres valores:
- El verificador, un hash de 16 bits de los bytes de la contraseña aplicado XOR con la longitud de la contraseña y
$CE4B. Compararlo con la palabra almacenada es la comprobación de contraseña documentada - La clave XOR, un valor de 16 bits producido por
CreateXorKey_Method1en [MS-OFFCRYPTO] §2.3.7.2 a partir de dos tablas constantes,InitialCode(15 palabras) yXorMatrix(105 palabras) - El array XOR, 16 bytes formados por los bytes de la contraseña rellenados con un pad fijo de 16 bytes, cada uno con XOR del byte bajo de la clave en posiciones pares o del byte alto en las impares, y después rotado un bit a la derecha
Las cabeceras de registro quedan en texto plano. También unos cuantos registros enteros que el esquema exime — BOF, FILEPASS, USREXCL, FILELOCK, INTERFACEHDR, RRDHEAD y RRDINFO — más los primeros 4 bytes de cada BOUNDSHEET. Todos los demás cuerpos de registro se transforman byte a byte: rotar 5 bits a la izquierda y después XOR con una entrada del array de 16 bytes. El descifrado, que §2.3.7.3 detalla como DecryptData_Method1, corre la imagen especular: primero XOR, después rotar 5 a la derecha
HotXLS mantiene todo esto detrás de dos propiedades del libro. TXLSWorkbook.EncryptionPassword guarda la contraseña, EncryptionType elige el esquema, y SaveAs con xlExcel5 emite el FILEPASS justo después del BOF y transforma el resto del 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 solo tiene ofuscación XOR; xletAuto elige el mismo esquema
// para xlExcel5, así que el ajuste explícito solo documenta la intención
Wb.EncryptionType := xletXor;
// ASCII, como mucho 15 caracteres (vea las notas de contraseña más abajo)
Wb.EncryptionPassword := 'secret';
if Wb.SaveAs(FileName, xlExcel5) <> 1 then
raise Exception.Create('BIFF5 save failed');
end;
¿Por qué Excel dice que la contraseña es incorrecta cuando el verificador coincide?
Excel deriva la clave de la contraseña tecleada con CreateXorKey_Method1 y la compara con la palabra de clave del FILEPASS, así que un archivo cuya clave es otra cosa falla la comprobación de contraseña aunque el verificador sea correcto. La especificación trata la clave como una función de la contraseña, y Excel 16 hace cumplir esa lectura de forma estricta
El atajo tentador es rellenar la palabra de clave con dos bytes al azar. Sobre el papel parece inofensivo: el verificador es la comprobación de contraseña documentada, y el array se construye a partir de la clave que el archivo declare. Un lector que toma la clave del FILEPASS tal cual abre esos archivos sin queja, que es como el atajo sobrevive en código probado solo contra sí mismo. Excel 16, con el mismo archivo y la contraseña correcta, rechaza en el diálogo. HotXLS deriva la clave en cada guardado, así que el FILEPASS de la contraseña secret lleva siempre la clave $014D y el verificador $DAA7
La derivación es corta una vez que las dos tablas están en su sitio. Recorra la contraseña hacia atrás desde su último byte, pruebe el bit 6 de cada byte siete veces mientras lo desplaza a la izquierda, y aplique XOR con una entrada de XorMatrix cada vez que el bit esté a uno; el índice de tabla empieza en la última entrada, $68, y baja uno por bit se haya activado o no. El esquema de abajo reproduce el algoritmo de la especificación paso a paso y da los mismos resultados que la biblioteca. Es una ilustración para su propio lector, y ninguna de estas rutinas forma parte de la API de HotXLS:
// Esquema de [MS-OFFCRYPTO] 2.3.7.2 CreateXorKey_Method1 y
// CreateXorArray_Method1 (solo ilustración, no es una API de 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; // la clave solo ve 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)); // rotar a la derecha un 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 esto produce el array 1F 32 17 B9 14 BA 7B 7F 59 DD 59 7F 7A C0 A6 DF. Junto con la clave $014D y el verificador $DAA7 tiene tres valores conocidos buenos contra los que afirmar antes de involucrar a Excel
Rotar uno a la derecha, y por qué rotar dos a la izquierda parece plausible
Con la clave correcta, Excel 16 pasa el diálogo de contraseña y entra directo en el segundo error, el aviso de que el archivo tiene un problema. La causa habitual es un array XOR rotado en la dirección equivocada. §2.3.7.2 define el paso del array como XorRor, una rotación de un bit a la derecha, pero una variante que rota cada byte del array 2 bits a la izquierda circula en varias implementaciones BIFF, y un lector construido sobre la misma variante nunca nota nada raro
Excel 16 no guarda archivos de Excel 5.0/95, y no ofrece XOR al guardar BIFF8, así que no hay muestra nativa con la que hacer diff. Cuando necesite fijar qué combinación implementa su propio código, el método fiable corre por el otro lado: escriba un stream BIFF5 de texto plano, recodifíquelo bajo cada combinación de tres decisiones independientes y deje que Excel 16 abra cada resultado:
| Decisión | Opción A | Opción B |
|---|---|---|
| Rotación del array | XorRor (rotar derecha 1) | Rotar izquierda 2 |
| Índice del array | (offset + longitud de registro) mod 16 | offset mod 16 |
| Orden de la transformación de byte | Rotar izquierda 5, luego XOR | XOR, luego rotar izquierda 5 |
De los ocho archivos, Excel 16 acepta la combinación de la especificación — XorRor, rotar-primero-XOR, índice con longitud de registro — y exactamente otro que solo parece distinto. Rotar-2-a-la-izquierda emparejado con XOR-primero-rotar y el mismo índice es la misma función disfrazada. La rotación se distribuye sobre el XOR, así que rol5(p xor rol2(b)) es igual a rol5(p) xor rol7(b), y en un valor de 8 bits una rotación de 7 a la izquierda es una rotación de 1 a la derecha. Dicho compacto: rol5 ∘ rol2 = ror1
Esa identidad explica por qué el array de rotar-2-a-la-izquierda parece correcto en aislamiento. Solo es correcto junto al orden de transformación contrario; emparejado con el orden de la especificación corrompe cada byte transformado. Toda variante que suelte la longitud de registro del índice falla también, con la rotación que use. Escriba la combinación de la especificación y nada más. El gemelo algebraico abre, pero le deja al siguiente mantenedor dos desviaciones que reingenierar donde el texto de la especificación no deja ninguna
¿Cómo se calcula XorArrayIndex para cada byte?
XorArrayIndex de un byte es su offset en el stream del libro más la longitud de todos los datos del registro al que pertenece, mod 16. El índice por tanto reinicia en un valor dependiente del registro para cada registro e incrementa uno por byte dentro de él. El pseudocódigo de la especificación nombra las entradas FileOffset y Data.Length, y es fácil leer mal la primera como el offset de inicio del registro a secas
Tres detalles deciden si sus índices cuadran con Excel:
- La cabecera de registro de 4 bytes nunca se transforma, pero sigue ocupando posiciones del stream, así que el primer byte del cuerpo de un registro está en offset de cabecera + 4
- El término de longitud es la longitud completa de los datos del registro, incluido cualquier prefijo plano que la transformación se salte
- BOUNDSHEET es parcialmente plano: sus primeros 4 bytes,
lbPlyPos, el offset de stream del BOF de la hoja, siguen legibles para que un parser localice las hojas sin la contraseña. Esos 4 bytes los salta la transformación pero cuentan tanto para el offset como para la longitud del registro
Todo junto, la transformación por registro son unas pocas líneas. Como antes, esto esboza la regla para su propio código; HotXLS la aplica internamente durante SaveAs:
function Rol8(B: Byte; N: Integer): Byte;
begin
Result := Byte((B shl N) or (B shr (8 - N)));
end;
// Ofusca el cuerpo de un registro in situ. BodyPos es el offset de stream de
// Body[0], es decir, el offset de cabecera de registro + 4. PlainPrefix es 4 para
// BOUNDSHEET, la longitud completa para BOF / FILEPASS, 0 para la mayoría
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;
// La lectura es la imagen especular: B := Body[I] xor Arr[...];
// luego rotar a la derecha 5, es decir, Rol8(B, 3)
Un lector y un escritor que ambos indexen solo por posición del stream sueltan la longitud de registro por ambos lados, así que coinciden entre sí y con nadie más. En el lado de lectura, HotXLS calcula el índice desde la posición actual del stream más la longitud del prefijo plano más el conteo de bytes transformados — la misma longitud de registro que usó el escritor
Leer archivos que usan el array de rotar-2-a-la-izquierda
HotXLS también abre archivos XOR construidos con el array de rotar-2-a-la-izquierda y una clave aleatoria, y los distingue por la clave del FILEPASS. Cuando la clave almacenada es igual a la clave derivada de la contraseña, el lector construye el array XorRor de la especificación; cuando difiere, el lector cambia al array de rotar-2-a-la-izquierda. Los archivos escritos por Excel siempre llevan la clave derivada, así que siempre toman el camino de la especificación
La prueba es una heurística con una tasa de fallo precisa. Para un archivo cuya clave se rellenó al azar, la probabilidad de que resulte igual a la clave derivada — y se lea por tanto con el array equivocado — es 1 entre 65.536. El conmutador cubre solo la rotación del array; la regla del índice sigue fija, así que aplica a archivos que ya usan el índice con longitud de registro. Abrir ese archivo con HotXLS y volverlo a guardar produce un archivo que Excel acepta, porque el escritor siempre usa la clave derivada y XorRor
Dos detalles de contraseña aplican a todos los archivos, sea cual sea el array que usen:
- Longitud.
CreateXorKey_Method1lee solo los primeros 15 bytes de la contraseña, que es el límite de la especificación. HotXLS aplica ese tope a la clave y mantiene el verificador sobre la contraseña completa y el array sobre su regla de 16 bytes, igual en los lados de lectura y de escritura. Como la clave solo ve 15 bytes, 15 caracteres es el máximo práctico - Conjunto de caracteres. HotXLS convierte la contraseña a bytes mediante la página de códigos ANSI del sistema, por igual para la clave, el verificador y el array. La especificación describe tomar el byte bajo de cada carácter UTF-16, y ambos coinciden para ASCII. Sin muestras de Excel protegidas con contraseñas no ASCII no hay verdad de referencia para nada más, así que mantenga las contraseñas XOR en ASCII plano
Cuando Open se encuentra un registro FILEPASS y la contraseña falta o es errónea, se dispara TXLSWorkbook.OnPassword. El handler es un TXLSPasswordEvent con un var PassWord: WideString y un var Retry: Boolean; asigne una contraseña nueva y ponga Retry a True para reintentar, hasta tres reintentos. Dejar Retry en False hace que Open devuelva el código de error de contraseña:
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: se requiere contraseña pero no se dio ninguna; -1005: contraseña equivocada
if Rc <> 1 then
raise Exception.CreateFmt('Cannot open %s (code %d)', [FileName, Rc]);
ShowMessage(VarToStr(Wb.Sheets[1].Range['A1', 'A1'].Value));
end;
Si la contraseña ya se conoce, la sobrecarga Open(FileName, APassWord) la pasa por adelantado y el evento solo se dispara cuando esa contraseña falla
¿Tiene sentido escribir la ofuscación XOR?
La ofuscación XOR de BIFF mantiene fuera del archivo a un usuario casual y no hace nada contra uno motivado. La comprobación de contraseña es un verificador de 16 bits, la clave son 16 bits, y el array de 16 bytes se repite por todo el stream, así que los contenidos predecibles de los registros BIFF exponen bytes del array sin contraseña alguna. La única razón para escribirlo hoy es un consumidor legado que lee archivos de Excel 5.0/95 y nada más nuevo, porque BIFF5 no ofrece otro esquema
El motor clásico elige el esquema mediante TXLSWorkbook.EncryptionType y comprueba la combinación con el formato de guardado de forma estricta:
xletAuto(el valor por defecto) escribe RC4 CryptoAPI paraxlExcel97y XOR paraxlExcel5, igual que lo que el propio Excel escribió para cada formatoxletXorsolo es válido para BIFF5; conxlExcel97el guardado lanza una excepción en lugar de recurrir a otro esquemaxletRC4yxletRC4CryptoAPIson solo BIFF8, y pedir cualquiera en un guardado BIFF5 también lanza una excepción
Deje EncryptionType en xletAuto en código que pueda guardar cualquiera de los dos formatos. Siempre aterriza en el esquema más fuerte que el formato de destino soporta, y no puede lanzar la excepción de discrepancia que un xletXor explícito lanza el día que alguien cambia el guardado a xlExcel97
RC4 también está anticuado, y hacer que interopere tiene sus propias trampas, tratadas en por qué Excel rechaza un libro cifrado con la contraseña correcta. Si el destinatario puede leer XLSX, salte los formatos legados y use el motor XLSX: TXLSXWorkbook.SaveAsEncryptedAgile escribe Agile Encryption (hash de contraseña SHA-512 con un spin count de 100.000 iteraciones y AES-256-CBC), el contenedor que Excel 2010 y posteriores escriben por defecto, mientras que SaveAsEncrypted escribe el Standard Encryption AES-128 más viejo. Los compromisos entre ambos están en cifrar archivos XLSX con AES en Delphi, y el lado de lectura queda cubierto en leer archivos Excel cifrados con Agile en HotXLS
Comprobar la salida XOR de BIFF5 antes de que la vea Excel 16
- Guarde el mismo libro dos veces con la misma contraseña y compare los cuerpos del FILEPASS en un volcado hexadecimal. Ambas copias deben llevar palabras idénticas; una clave que cambia entre guardados se rellenó al azar, y Excel 16 rechazará la contraseña
- Para la contraseña
secretel cuerpo de 4 bytes del FILEPASS se lee4D 01 A7 DAen el disco, clave primero, ambas palabras little-endian - Los primeros 4 bytes de cada BOUNDSHEET deberían leerse como un offset de stream plano que aterriza en el BOF de una hoja; si no apuntan a ninguna parte, la transformación tocó el prefijo y ningún parser puede localizar las hojas sin la contraseña
- Mantenga las contraseñas de prueba en ASCII plano y de 15 caracteres o menos, para que la clave, el verificador y el array vean los mismos bytes en cada máquina
La misma biblioteca Delphi y C++Builder cubre el XOR de BIFF5, el RC4 y RC4 CryptoAPI de BIFF8, el Standard y el Agile Encryption de XLSX y el callback de contraseña del lado de lectura, con cada regla a nivel de byte de arriba aplicada al guardar. Ediciones, plataformas soportadas y una descarga de prueba están en la página del componente de hojas de cálculo HotXLS para Delphi