Artículo técnico

Ofuscación XOR de XLS en HotXLS: derivación y XorRor

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_Method1 en [MS-OFFCRYPTO] §2.3.7.2 a partir de dos tablas constantes, InitialCode (15 palabras) y XorMatrix (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

Diagrama de HotXLS del record FILEPASS XOR de BIFF5 que Excel 16 verifica al abrir: el cuerpo plano de cuatro bytes guarda la clave XOR y el verificador de contraseña, Excel deriva la clave desde la contraseña tecleada con CreateXorKey_Method1 y rechaza una clave aleatoria con un error de contraseña aunque el verificador coincida; HotXLS guarda la clave derivada 014D para secret
El cuerpo del FILEPASS son solo dos palabras, pero Excel vuelve a derivar la clave desde su contraseña y compara; una clave rellenada al azar falla la verificación incluso con un verificador correcto, razón por la cual HotXLS siempre la deriva

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

Diagrama de HotXLS de la construcción del array XOR para la ofuscación BIFF5: dieciséis bytes sembrados desde la contraseña y un pad fijo se XOR con el byte bajo de la clave en posiciones pares y el byte alto en posiciones impares, y luego se rotan a la derecha un bit con XorRor, produciendo el array 1F 32 17 B9 para la contraseña secret
Los bytes del array salen de la contraseña, el pad y los dos bytes de la clave, una rotación al final; rotar a la izquierda 2 solo es equivalente cuando la transformación del byte corre en el orden opuesto, y Excel sigue el orden de la especificación

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ónOpción AOpción B
Rotación del arrayXorRor (rotar a la derecha 1)Rotar a la izquierda 2
Índice del array(offset + record length) mod 16offset mod 16
Orden de la transformación del byteRotar a la izquierda 5, luego XORXOR, 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
Diagrama de HotXLS de la regla XorArrayIndex para la ofuscación XOR de BIFF5: cada byte del cuerpo usa el offset del stream más la longitud completa de los datos del record módulo 16, la cabecera plana de cuatro bytes y el prefijo lbPlyPos de BOUNDSHEET igual cuentan para el offset, e ignorar el término de longitud del record desalinea cada record
El índice del array rearranca una vez por record, no una vez por stream: la cabecera y cualquier prefijo plano ocupan posiciones, la longitud de los datos del record alimenta el módulo, y un reader y un writer que ambos descartan ese término solo concuerdan entre sí

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_Method1 lee 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 para xlExcel97 y XOR para xlExcel5, en línea con lo que el propio Excel escribía para cada formato
  • xletXor es válido solo para BIFF5; con xlExcel97 el guardado lanza una excepción en vez de hacer fallback en silencio
  • xletRC4 y xletRC4CryptoAPI son 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 secret el cuerpo de 4 bytes del FILEPASS se lee 4D 01 A7 DA en 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