Un workbook BIFF5 protegido con la contraseña secret puede llevar un verificador de contraseña que coincide perfectamente y aun así hacer que Excel 16 responda que la contraseña es incorrecta. Excel solo acepta el archivo cuando la clave del FILEPASS es igual a CreateXorKey_Method1(password), el array XOR de 16 bytes está construido con XorRor, y cada byte usa XorArrayIndex = (offset en el stream + longitud del record) mod 16
Excel 16 tiene dos formas distintas de rechazar ese tipo de archivo, y se mapean limpiamente a las capas de [MS-OFFCRYPTO] §2.3.7. Un prompt de contraseña que sigue rechazando la contraseña correcta apunta a la palabra de clave del FILEPASS. Un reporte de que el archivo tiene un problema y no se puede abrir, mostrado después de que la contraseña se acepta, apunta al array XOR o al índice que elige un byte del array. Las secciones de abajo siguen ese orden, hasta el byte
¿Qué guarda realmente la ofuscación XOR de BIFF?
La ofuscación XOR de BIFF guarda solo dos palabras de 16 bits en el archivo, y todo lo demás se recalcula a partir de la contraseña. El record FILEPASS ($002F) va inmediatamente después del BOF de los globals del workbook, y en un archivo BIFF5 su cuerpo es exactamente 4 bytes: la clave XOR seguida del verificador de contraseña. No hay salt, ni identificador de algoritmo, ni blob de verificador cifrado como el que cargan los esquemas RC4 y AES
De esas dos palabras un reader reconstruye tres cosas:
- El verificador, un hash de 16 bits de los bytes de la contraseña XOR con la longitud de la contraseña y con
$CE4B. Compararlo con la palabra guardada es la verificación de contraseña documentada - La clave XOR, un valor de 16 bits que produce
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 hechos de los bytes de la contraseña rellenados con un pad fijo de 16 bytes, cada uno XOR con el byte bajo de la clave (posiciones pares) o el byte alto (posiciones impares), y luego rotado a la derecha un bit
Las cabeceras de los records quedan en texto plano. También unos cuantos records completos que el esquema exime — BOF, FILEPASS, USREXCL, FILELOCK, INTERFACEHDR, RRDHEAD y RRDINFO — más los primeros 4 bytes de cada BOUNDSHEET. Cada otro cuerpo de record se transforma byte a byte: rotar a la izquierda 5 bits, y luego XOR con una entrada del array de 16 bytes. El descifrado, que §2.3.7.3 detalla como DecryptData_Method1, corre la imagen espejo: primero XOR, luego rotar a la derecha 5
HotXLS mantiene todo esto detrás de dos propiedades del workbook. 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, a lo sumo 15 caracteres (vea las notas sobre contraseñas 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 desde la contraseña tecleada con CreateXorKey_Method1 y la compara con la palabra de clave del FILEPASS, así que un archivo cuya clave sea cualquier otra cosa falla la verificación de contraseña incluso cuando el verificador es 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 llenar la palabra de clave con dos bytes al azar. En el papel parece inofensivo: el verificador es la verificación de contraseña documentada, y el array se construye a partir de la clave que el archivo declare. Un reader que toma la clave del FILEPASS como algo dado abre esos archivos sin queja, que es como el atajo sobrevive en código probado solo contra sí mismo. Excel 16, recibiendo el mismo archivo y la contraseña correcta, rechaza en el prompt. HotXLS deriva la clave en cada guardado, así que el FILEPASS para la contraseña secret siempre lleva la clave $014D y el verificador $DAA7
La derivación es corta una vez que las dos tablas están en su lugar. Recorra la contraseña hacia atrás desde su último byte, pruebe el bit 6 de cada byte siete veces mientras lo corre a la izquierda, y XOR una entrada de XorMatrix cada vez que el bit esté encendido; el índice de la tabla arranca en la última entrada, $68, y baja uno por bit se haya encendido o no. El boceto 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 reader, y ninguna de estas rutinas es parte de la API de HotXLS:
// Boceto 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 y buenos contra los que afirmar antes de involucrar a Excel
Rotar a la derecha uno, y por qué rotar a la izquierda dos parece plausible
Con la clave correcta, Excel 16 pasa el prompt de contraseña y entra derecho al segundo error, el reporte de que el archivo tiene un problema. La causa usual es un array XOR rotado del lado equivocado. §2.3.7.2 define el paso del array como XorRor, una rotación a la derecha de un bit, pero circula una variante que rota cada byte del array 2 bits a la izquierda en varias implementaciones BIFF, y un reader construido sobre esa 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 contra la que hacer diff. Cuando necesita precisar qué combinación implementa su propio código, el método confiable corre por el otro lado: escriba un stream BIFF5 en 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 a la derecha 1) | Rotar a la izquierda 2 |
| Índice del array | (offset + record length) mod 16 | offset mod 16 |
| Orden de la transformación del byte | Rotar a la izquierda 5, luego XOR | XOR, luego rotar a la izquierda 5 |
De los ocho archivos, Excel 16 acepta la combinación de la especificación — XorRor, rotar-luego-XOR, índice con longitud de record — y exactamente otra que solo parece distinta. Rotar-izquierda-2 emparejado con XOR-luego-rotar y el mismo índice es la misma función disfrazada. La rotación distribuye sobre el XOR, así que rol5(p xor rol2(b)) equivale a rol5(p) xor rol7(b), y sobre un valor de 8 bits rotar a la izquierda 7 es rotar a la derecha 1. En corto, rol5 ∘ rol2 = ror1
Esa identidad explica por qué el array de rotar-izquierda-2 parece correcto en aislamiento. Es correcto solo junto al orden de transformación opuesto; emparejado con el orden de la especificación corrompe cada byte transformado. También falla toda variante que quite la longitud del record del índice, sea cual sea 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 próximo mantenedor dos desvíos para hacer ingeniería inversa donde el texto de la especificación no le deja ninguno
¿Cómo se calcula XorArrayIndex para cada byte?
El XorArrayIndex de un byte es su offset en el stream del workbook más la longitud de todos los datos del record al que pertenece, mod 16. El índice por lo tanto rearranca en un valor dependiente del record para cada record y se incrementa de a uno por byte dentro de él. El pseudocódigo de la especificación nombra las entradas FileOffset y Data.Length, y es fácil malinterpretar la primera como el offset de inicio del record solamente
Tres detalles deciden si sus índices cuadran con Excel:
- La cabecera de record de 4 bytes jamás se transforma, pero igual ocupa posiciones del stream, así que el primer byte del cuerpo de un record queda en offset de cabecera + 4
- El término de longitud es la longitud completa de los datos del record, incluido cualquier prefijo plano que la transformación se salte
- BOUNDSHEET es en parte plano: sus primeros 4 bytes,
lbPlyPos, el offset en el stream del BOF de la hoja, quedan legibles para que un parser pueda ubicar hojas sin la contraseña. Esos 4 bytes se saltan en la transformación pero igual cuentan tanto para el offset como para la longitud del record
Junto todo, la transformación por record son unas pocas líneas. Como antes, esto bosqueja 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 un cuerpo de record in situ. BodyPos es el offset del stream de
// Body[0], es decir, el offset de la cabecera del record + 4. PlainPrefix es 4 para
// BOUNDSHEET, la longitud completa para BOF / FILEPASS, 0 para la mayoría de los records
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;
// Leer es la imagen espejo: B := Body[I] xor Arr[...];
// luego rotar a la derecha 5, es decir Rol8(B, 3)
Un reader y un writer que ambos indexan solo por la posición del stream descartan la longitud del record en los dos lados, así que concuerdan entre sí y con nadie más. Del lado de lectura, HotXLS computa 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 record que usó el writer
Leer archivos que usan el array de rotar-izquierda-2
HotXLS también abre archivos XOR construidos con el array de rotar-izquierda-2 y una clave al azar, y los distingue por la clave del FILEPASS. Cuando la clave guardada es igual a la clave derivada de la contraseña, el reader construye el array XorRor de la especificación; cuando difiere, el reader cambia al array de rotar-izquierda-2. 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 casualmente sea igual a la derivada — y de que por lo tanto se lea con el array equivocado — es 1 en 65,536. La conmutación cubre solo la rotación del array; la regla de índice queda fija, así que aplica a archivos que ya usan el índice con longitud de record. Abrir ese archivo con HotXLS y guardarlo de nuevo produce un archivo que Excel acepta, porque el writer siempre usa la clave derivada y XorRor
Dos detalles de contraseña aplican a cada archivo, viejo o nuevo:
- 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 el lado de lectura y en el de escritura. Como la clave solo ve 15 bytes, 15 caracteres es el máximo práctico - Juego de caracteres. HotXLS convierte la contraseña a bytes por la página de códigos ANSI del sistema, para la clave, el verificador y el array por igual. 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 puro
Cuando Open se topa con un record FILEPASS y la contraseña falta o es incorrecta, 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 en True para intentar de nuevo, 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 pide contraseña pero no se dio ninguna; -1005: contraseña incorrecta
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 de entrada y el evento solo se dispara cuando esa contraseña falla
¿La ofuscación XOR es lo bastante segura para algo?
La ofuscación XOR de BIFF mantiene alejado a un usuario casual y no hace nada contra uno motivado. La verificación de contraseña es un verificador de 16 bits, la clave es de 16 bits, y el array de 16 bytes se repite a lo largo de todo el stream, así que contenidos de record BIFF predecibles exponen bytes del array sin contraseña alguna. La única razón para escribirlo hoy es un consumidor legacy que lee archivos de Excel 5.0/95 y nada más nuevo, porque BIFF5 no ofrece otro esquema
El engine clásico selecciona el esquema mediante TXLSWorkbook.EncryptionType, y la combinación con el formato de guardado se verifica de forma estricta:
xletAuto(por defecto) escribe RC4 CryptoAPI paraxlExcel97y XOR paraxlExcel5, en línea con lo que el propio Excel escribía para cada formatoxletXores válido solo para BIFF5; conxlExcel97el guardado lanza una excepción en vez de hacer fallback en silencioxletRC4yxletRC4CryptoAPIson solo BIFF8, y pedirlos en un guardado BIFF5 también lanza una excepción
Deje EncryptionType en xletAuto en código que puede guardar cualquiera de los dos formatos. Siempre cae en el esquema más fuerte que el formato objetivo soporta, y no puede lanzar la excepción de combinación inválida que un xletXor explícito lanza el día que alguien cambia el guardado a xlExcel97
RC4 también está añejo, y los detalles para hacerlo interoperar están cubiertos en por qué Excel rechaza un workbook cifrado con una contraseña correcta. Si el destinatario puede leer XLSX, use mejor el engine 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 formato que Excel 2010 y posteriores escriben por defecto, mientras que SaveAsEncrypted escribe el Standard Encryption AES-128 más antiguo. Las contrapartidas entre los dos están en cifrar archivos XLSX con AES en Delphi, y el lado de lectura está cubierto en leer archivos Excel cifrados con Agile usando HotXLS
Verificar la salida XOR de BIFF5 antes de que la vea Excel 16
- Guarde el mismo workbook dos veces con la misma contraseña y compare los cuerpos del FILEPASS en un volcado hex. Las dos copias deben llevar las mismas palabras; una clave que cambia entre guardados se rellenó al azar, y Excel 16 va a rechazar la contraseña
- Para la contraseña
secretel cuerpo de 4 bytes del FILEPASS se lee4D 01 A7 DAen disco, clave primero, ambas palabras little-endian - Los primeros 4 bytes de cada BOUNDSHEET deben leerse como un offset de stream en plano que cae sobre el BOF de una hoja; si no apuntan a ningún lado, la transformación tocó el prefijo y ningún parser puede ubicar las hojas sin la contraseña
- Mantenga las contraseñas de prueba en ASCII puro 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 XOR de BIFF5, RC4 y RC4 CryptoAPI de BIFF8, Standard y Agile Encryption de XLSX, y el callback de contraseña del lado de lectura, con cada regla de 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