Artículo técnico

Leer Excel con cifrado Agile en Delphi con HotXLS

Un cliente sube un libro de trabajo que abre bien en su escritorio, y el servicio de importación lo rechaza con un error de ZIP. Un volcado hexadecimal de los primeros ocho bytes muestra D0 CF 11 E0 A1 B1 1A E1, la firma de OLE Compound File que lleva un .xls de 1997. El fichero tiene extensión .xlsx, salió de un Excel actual, y no es un paquete ZIP en absoluto. Alguien puso una contraseña en el diálogo Guardar como

Ese es todo el misterio. Cuando Excel guarda un libro con contraseña, cifra el ZIP .xlsx real y envuelve el resultado en un contenedor Compound File Binary (CFB), usando el esquema Agile de [MS-OFFCRYPTO] §2.3.4.10 a §2.3.4.15. Cualquier loader que clasifique ficheros por extensión, o que entregue cada .xlsx directamente a un lector de ZIP, devolverá la carga a un usuario que desde su lado de la pantalla no hizo nada inusual

Qué hay dentro de un libro con cifrado Agile

Un libro con cifrado Agile es un contenedor CFB con dos streams que importan: EncryptionInfo, que describe cómo se hizo el cifrado, y EncryptedPackage, que guarda el ZIP original como un blob opaco y cifrado. HotXLS lee ambos streams directamente del contenedor, sin Excel, sin COM y sin ninguna DLL de criptografía externa en la máquina

Anatomía del libro de trabajo con cifrado Agile que HotXLS abre en Delphi: un contenedor CFB que contiene un stream descriptor EncryptionInfo y un stream EncryptedPackage de segmentos AES-CBC
HotXLS lee un libro cifrado Agile como un contenedor CFB con un flujo EncryptionInfo autodescriptivo y el ZIP .xlsx cifrado como un flujo EncryptedPackage opaco

Lo que separa a Agile del antiguo cifrado Standard es que EncryptionInfo se autodescribe. Tras un prefijo de 8 bytes cuya versión mayor y menor son ambas 4, el stream es un descriptor XML UTF-8. Un elemento keyData nombra el cifrado (AES), el modo de encadenamiento (ChainingModeCBC), el algoritmo de hash, la longitud de clave en bits, el tamaño de bloque y una sal Base64. El keyEncryptor de la contraseña lleva su propia sal, un spinCount, y tres cargas Base64: encryptedVerifierHashInput, encryptedVerifierHashValue y encryptedKeyValue. Un elemento dataIntegrity añade una clave y un valor HMAC cifrados para la detección de manipulación

El propio Excel escribe AES-256, SHA-512 y un spin count de 100.000. El descriptor puede decir otra cosa, sin embargo, y los escritores de terceros lo hacen. HotXLS toma keyBits del descriptor en lugar de asumir 256, así que los ficheros AES-128 y AES-192 se descifran igual, y acepta hashAlgorithm="SHA256" además de SHA-512. El atributo hash de cada elemento gobierna los pasos que le pertenecen: el hash del keyEncryptor dirige la derivación y verificación de la contraseña, mientras que el hash de keyData dirige los IV de segmento y el HMAC de integridad. Un fichero que mezcle ambos sigue abriendo

Abrir el fichero: OpenEncrypted u Open con contraseña

TXLSXWorkbook.OpenEncrypted toma un nombre de fichero y una contraseña y devuelve 1 en caso de éxito, el mismo contrato que Open. Husmea los primeros ocho bytes con CanReadEncrypted. Un fichero sin la firma CFB va por la ruta ordinaria de Open y la contraseña se ignora, así que un importador que siempre llame a OpenEncrypted no necesita ninguna rama en el punto de llamada. Un fichero CFB se prueba primero como cifrado Standard, y cuando el prefijo de EncryptionInfo lleva la versión Agile 4.4, toma el mando el lector Agile. Los bytes ZIP descifrados van entonces al loader XLSX regular en memoria

Ambos puntos de entrada toman un nombre de fichero. Open(Stream) rechaza un stream que empiece por la firma CFB y lanza una excepción cuyo mensaje apunta a OpenEncrypted, así que una carga guardada en un TMemoryStream tiene que aterrizar primero en un fichero temporal

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 := '';
  // Los paquetes cifrados se abren desde un fichero, así que vierta la carga a disco
  TempName := TPath.GetTempFileName;
  Wb := TXLSXWorkbook.Create;
  try
    Upload.SaveToFile(TempName);
    // Los .xlsx planos, los cifrados Standard y los cifrados Agile funcionan todos aquí
    if Wb.OpenEncrypted(TempName, Password) = 1 then
      Result := VarToWideStr(Wb.Sheets[1].Cells[1, 1].Value);
  finally
    Wb.Free;
    TFile.Delete(TempName);
  end;
end;

La sobrecarga de dos argumentos Open(FileName, Password) llega al mismo código de descifrado pero añade algo que OpenEncrypted no tiene: el evento OnPassword. Cuando la contraseña suministrada falla, Open dispara OnPassword, deja que el manejador asigne una contraseña nueva y ponga Retry a True, y pregunta otra vez, hasta tres veces. Una aplicación de escritorio puede poner un prompt de contraseña en ese manejador. Un servidor puede usarlo para otra cosa, de lo que se ocupa la última sección

¿Cómo se convierte una contraseña en una clave AES?

La contraseña nunca descifra nada directamente. El primer resumen es SHA-512 sobre la sal del keyEncryptor seguida de los bytes UTF-16LE de la contraseña; ese resumen se vuelve a hashear spinCount veces, y cada ronda antepone el contador de ronda de 32 bits little-endian al resumen anterior. Con las 100.000 rondas de Excel, cada intento de contraseña cuesta cien mil llamadas seriales a SHA-512. Ese es el propósito del spin count. Una apertura legítima lo paga una vez, y un ataque de diccionario lo paga por cada suposición

Cómo HotXLS deriva las claves de cifrado Agile en Delphi: la contraseña se agita por 100.000 rondas SHA-512, y luego tres claves de bloque fijas de 8 bytes producen la clave verificador y las claves del paquete
La contraseña nunca descifra nada directamente: una cadena de conteo de vueltas SHA-512 alimenta tres hashes de clave de bloque que producen las claves verificadoras y desenvuelven la clave aleatoria del paquete

La cadena es lo bastante corta para reproducirla, y hacerlo es la forma más rápida de ver lo que cuesta una suposición en su propio hardware. El bosquejo de abajo sigue el §2.3.4.11 para un descriptor SHA-512 y usa la función pública XlsSHA512 de la unidad lxXlsxAgileDecrypt

uses
  System.SysUtils, lxXlsxAgileDecrypt;

// H0 = SHA-512(sal + UTF-16LE(password))
// Hn = SHA-512(LE32(n - 1) + H(n-1)), repetido SpinCount veces
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 rondas, 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);         // resumen anterior
    Result := XlsSHA512(Buf);
  end;
end;

El hash girado sigue sin ser una clave. De él salen tres claves, cada una hasheando el valor girado una vez más con una clave de bloque fija de 8 bytes añadida: FE A7 D2 76 3B 4B 9E 79 para la entrada del verificador, D7 AA 0F 6D 30 61 34 4E para el hash del verificador, y 14 6E 0B E7 AB AC D0 D6 para desenvolver la clave del paquete. Cada resultado se corta a la longitud de clave declarada, 32 bytes para AES-256. La especificación también define qué pasa cuando un hash sale más corto que la clave: rellenar con bytes 0x36. Ningún tamaño de clave AES lo desencadena realmente con SHA-256 o SHA-512, pero la misma regla del 0x36 sí se aplica cuando la sal de la contraseña se estira al tamaño de bloque para servir de IV CBC

El spin count se lee del fichero, así que también es una superficie de ataque: una carga que declare mil millones de rondas dejaría clavado un núcleo de CPU antes de fallar. El §2.3.4.11 limita spinCount a 10.000.000, y HotXLS reporta un valor mayor como descriptor no soportado antes de hashear nada. Para un endpoint de carga público ese límite es el valor por defecto correcto. Las 100.000 de Excel quedan muy por debajo

Verificación de contraseña y la trampa de truncamiento de saltSize

HotXLS comprueba la contraseña antes de tocar el paquete. Descifra encryptedVerifierHashInput con la primera clave derivada, hashea el resultado, descifra encryptedVerifierHashValue con la segunda clave, y compara los dos resúmenes sobre la longitud completa del hash sin parar en el primer byte distinto. Una discrepancia termina la apertura con un resultado de contraseña incorrecta, y el cuerpo del paquete nunca se descifra bajo una clave errónea. Una contraseña incorrecta no puede producir por tanto un libro lleno de basura plausible

Hay un detalle de la especificación aquí que es fácil de entender mal. La norma [MS-OFFCRYPTO] §2.3.4.13 define el verificador como saltSize bytes de datos aleatorios, donde saltSize es la longitud de la sal del cifrador de claves, no el tamaño del bloque de cifrado. Debido a que el texto cifrado AES-CBC está alineado por bloques, la entrada del verificador descifrada regresa rellena a un múltiplo de 16 bytes y debe truncarse de nuevo a saltSize antes de calcular el hash. Excel siempre escribe saltSize igual a blockSize, ambos 16, por lo que una implementación que omita el truncamiento supera todas las pruebas con la salida real de Excel y luego falla en el primer archivo de un productor que eligió una longitud de sal diferente. HotXLS trunca a la longitud de la sal porque eso es lo que realmente dice la especificación, y que los dos valores coincidan en la práctica es una coincidencia, no un contrato

¿Cómo se descifra el EncryptedPackage?

La clave del paquete es aleatoria, no derivada de la contraseña. El escritor la generó, la cifró en encryptedKeyValue, y HotXLS la desenvuelve con la tercera clave derivada, quedando tantos bytes como declare keyData en keyBits. Antes de descifrar un solo segmento, HotXLS comprueba dataIntegrity cuando el fichero lo lleva: la clave y el valor HMAC se descifran con la clave del paquete, y un HMAC sobre el stream EncryptedPackage completo, prefijo de tamaño incluido, debe coincidir con el valor guardado. Los ficheros escritos sin un elemento dataIntegrity utilizable se saltan este paso y siguen abriendo

HotXLS descifra el stream EncryptedPackage en Delphi segmento a segmento, derivando el IV de cada segmento AES-CBC de 4096 bytes a partir del salt de keyData y el índice del segmento
Cada segmento AES-CBC de 4096 bytes se descifra de forma independiente bajo su propio IV de sal e índice, y el resultado se trunca al tamaño de texto en claro declarado

El stream en sí empieza con un tamaño de texto en claro little-endian de 8 bytes, seguido de ciphertext en segmentos de 4096 bytes. Cada segmento recibe su propio IV: el hash de la sal de keyData seguida del índice de segmento de 32 bits little-endian, cortado al tamaño de bloque. Cualquier segmento puede por tanto descifrarse por su cuenta, lo que permitiría acceso aleatorio en principio; HotXLS descifra el paquete entero a memoria porque el loader de ZIP quiere el archivo completo de todos modos. El tamaño declarado se comprueba contra la longitud real del stream antes de empezar el descifrado, así que una carga truncada o un campo de tamaño inflado falla limpiamente. Tras el último segmento, el búfer se corta al tamaño declarado, lo que suelta los hasta 15 bytes de padding AES, y lo que queda es byte a byte el ZIP que Excel cifró

Distinguir una contraseña incorrecta de un fichero no soportado

Cada fallo de cifrado en OpenEncrypted y Open lanza EXlsxEncryptionNotImplemented, y el mensaje dice de qué caso se trata: la contraseña suministrada es incorrecta, o el fichero usa un esquema que HotXLS no lee. HotXLS lee el key encryptor de contraseña con AES en modo CBC y hasheo SHA-512 o SHA-256, lo que cubre lo que escriben las versiones actuales de Excel; un contenedor protegido solo por un key encryptor de certificado, un descriptor que nombre otro cifrado, o un CFB que no sea ni Standard ni Agile, como un .xls BIFF renombrado, recibe el mensaje de no soportado

Comparar por el texto del mensaje es frágil, sobre todo si las cadenas de recursos se localizan algún día. El evento OnPassword da una señal más limpia: Open lo dispara solo cuando el verificador o la comprobación de integridad rechazan la contraseña, nunca para un esquema no soportado. Para un servicio de importación, llame a Open(FileName, Password) con un manejador que registre el rechazo, en lugar de OpenEncrypted, que lanza sin consultar evento alguno

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
  // Se dispara solo cuando se rechazó la contraseña (o el HMAC de integridad)
  FPasswordRejected := True;
  Retry := False;   // nadie a quien preguntar en un servidor; Open lanza después
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 volver a preguntar al usuario
      else
        Result := uoUnreadable;        // un reintento no ayudará; registre E.Message
  end;
end;

Una trampa sigue existiendo incluso con esta separación. Un fallo de integridad se reporta igual que una contraseña errónea, así que un libro cuyo ciphertext se dañó en tránsito, por un proxy que reescribió el cuerpo o una carga cortada a mitad de segmento, vuelve como uoPasswordRejected incluso cuando el usuario escribió la contraseña correcta. Si el mismo usuario falla dos veces con una contraseña que insiste en que es correcta, pida el fichero otra vez antes de volver a pedir la contraseña

El lado de escritura usa la misma maquinaria al revés. SaveAsEncryptedAgile produce un contenedor Agile con derivación de clave SHA-512, 100.000 rondas de giro y cifrado de paquete AES-256, SaveAsEncrypted produce cifrado Standard, y poner VerifyEncryptedSave a True hace que cualquiera de las dos llamadas reabra el fichero que acaba de escribir por la ruta de descifrado y devuelva -1 si eso falla. La ruta Standard se recorre en el artículo sobre escribir salida XLSX protegida por AES, y los esquemas RC4 y XOR que se encuentran dentro de los ficheros BIFF heredados están cubiertos en el artículo de interoperabilidad ECB y RC4

Para una canalización que nunca sabe de antemano si la siguiente carga lleva contraseña, el lector descrito arriba, junto con la lectura y escritura nativas de XLS y XLSX para Delphi y C++Builder, forma parte del HotXLS Delphi Excel Component