Un cliente carga un libro de trabajo que abre bien en su escritorio, y el servicio de importación lo rechaza con un error de ZIP. Un hex dump de los primeros ocho bytes muestra D0 CF 11 E0 A1 B1 1A E1, la firma de OLE Compound File que llevaba un .xls de la era de 1997. El archivo 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 Save As
Ese es todo el misterio. Cuando Excel guarda un libro de trabajo 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 cargador que clasifique archivos por extensión, o que le entregue cada .xlsx directamente a un lector ZIP, rebotará 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 contiene el ZIP original como un blob opaco cifrado. HotXLS lee ambos streams directamente del contenedor, sin Excel, sin COM y sin DLL criptográfica externa en la máquina
Lo que distingue a Agile del Standard Encryption más antiguo 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 payloads Base64: encryptedVerifierHashInput, encryptedVerifierHashValue y encryptedKeyValue. Un elemento dataIntegrity agrega una clave HMAC y un valor HMAC cifrados para detectar manipulación
Excel propiamente escribe AES-256, SHA-512 y un spin count de 100,000. El descriptor, sin embargo, puede decir otra cosa, y escritores de terceros lo hacen. HotXLS toma keyBits del descriptor en lugar de asumir 256, así que los archivos AES-128 y AES-192 descifran igual, y acepta hashAlgorithm="SHA256" además de SHA-512. El atributo de hash de cada elemento gobierna los pasos que le pertenecen: el hash del keyEncryptor maneja la derivación y verificación de la contraseña, mientras que el hash de keyData maneja los IV de segmento y el HMAC de integridad. Un archivo que mezcle ambos igual abre
Abrir el archivo: OpenEncrypted u Open con contraseña
TXLSXWorkbook.OpenEncrypted toma un nombre de archivo y una contraseña y devuelve 1 en éxito, el mismo contrato que Open. Husmea los primeros ocho bytes con CanReadEncrypted. Un archivo sin la firma CFB va por la ruta ordinaria de Open y la contraseña se ignora, así que un importador que siempre llama a OpenEncrypted no necesita ninguna rama en el sitio de llamada. Un archivo CFB se prueba primero como Standard Encryption, y cuando el prefijo de EncryptionInfo lleva la versión Agile 4.4, el lector Agile toma el control. Los bytes ZIP descifrados van entonces al cargador XLSX regular en memoria
Ambos puntos de entrada toman un nombre de archivo. Open(Stream) rechaza un stream que arranque con la firma CFB y levanta una excepción cuyo mensaje apunta a OpenEncrypted, así que una carga guardada en un TMemoryStream tiene que aterrizar primero en un archivo 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 archivo, así que vierta la carga al disco
TempName := TPath.GetTempFileName;
Wb := TXLSXWorkbook.Create;
try
Upload.SaveToFile(TempName);
// Los archivos .xlsx planos, con cifrado Standard y con cifrado Agile funcionan 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;
El overload de dos argumentos Open(FileName, Password) llega al mismo código de descifrado pero agrega algo que OpenEncrypted no tiene: el evento OnPassword. Cuando la contraseña suministrada falla, Open dispara OnPassword, deja que el handler asigne una nueva contraseña y ponga Retry en True, y pregunta otra vez, hasta tres veces. Una aplicación de escritorio puede poner un prompt de contraseña en ese handler. Un servidor puede usarlo para otra cosa, de la 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, con cada ronda anteponiendo 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 punto del spin count. Una apertura legítima lo paga una vez, y un ataque de diccionario lo paga por cada intento
La cadena es lo bastante corta para reproducirla, y hacerlo es la manera más rápida de ver lo que cuesta un intento en su propio hardware. El sketch de abajo sigue §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(salt + 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 todavía no es 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 dispara en realidad con SHA-256 o SHA-512, pero la misma regla de 0x36 sí 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 archivo, así que también es una superficie de ataque: una carga que declare mil millones de rondas dejaría un núcleo de CPU clavado antes de fallar. §2.3.4.11 acota 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 tope es el valor por defecto correcto. El 100,000 propio de Excel queda muy por debajo
Verificación de contraseña y la trampa de truncamiento de saltSize
HotXLS verifica 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 detenerse 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 mala. Una contraseña incorrecta por lo tanto no puede producir un libro de trabajo lleno de basura plausible
Una frase de la especificación es fácil de malinterpretar aquí. §2.3.4.13 define el verificador como saltSize bytes de datos aleatorios, donde saltSize es la longitud de la sal del key encryptor. El verificador descifrado vuelve rellenado a un múltiplo del bloque AES de 16 bytes, así que hay que cortarlo de vuelta a saltSize antes de hashear. Excel siempre escribe saltSize y blockSize como 16, lo que significa que el código que trunca al tamaño de bloque pasa todas las pruebas contra salida de Excel. Luego rechaza la contraseña correcta en el primer archivo de un productor que eligió una sal de 32 bytes. HotXLS trunca a la longitud de la sal, porque eso es lo que dice el texto, y que los dos números coincidan en los archivos de Excel es una coincidencia
¿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, conservando tantos bytes como keyData declare en keyBits. Antes de descifrar un solo segmento, HotXLS verifica dataIntegrity cuando el archivo lo trae: la clave HMAC 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 archivos escritos sin un elemento dataIntegrity utilizable se saltan este paso y aun así abren
El stream en sí arranca con un tamaño de texto plano little-endian de 8 bytes, seguido de ciphertext en segmentos de 4096 bytes. Cada segmento obtiene 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 en principio permitiría acceso aleatorio; HotXLS descifra el paquete completo a memoria porque el cargador ZIP quiere el archivo completo de todos modos. El tamaño declarado se verifica 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 buffer 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ó
Distintar una contraseña incorrecta de un archivo no soportado
Cada fallo de cifrado en OpenEncrypted y Open levanta EXlsxEncryptionNotImplemented, y el mensaje dice de qué caso se trata: la contraseña suministrada es incorrecta, o el archivo 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
Clasificar por el texto del mensaje es frágil, sobre todo si las cadenas de recursos se llegan a localizar. El evento OnPassword da una señal más limpia: Open lo dispara solo cuando el verificador o la verificació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 handler que registre el rechazo, en lugar de OpenEncrypted, que levanta sin consultar ningún evento
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 la contraseña (o el HMAC de integridad) fue rechazada
FPasswordRejected := True;
Retry := False; // nadie a quien preguntar en un servidor; Open levanta 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 ayuda; haga log de E.Message
end;
end;
Una trampa sigue presente incluso con esta separación. Una discrepancia de integridad se reporta igual que una contraseña mala, 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 tecleó la contraseña correcta. Si el mismo usuario falla dos veces con una contraseña que insiste en que es correcta, pida el archivo otra vez antes de volver a pedir la contraseña
El lado de escritura usa la misma maquinaria en reversa. 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 Standard Encryption, y poner VerifyEncryptedSave en True hace que cualquiera de las dos llamadas reabra el archivo 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 archivos BIFF antiguos están cubiertos en el artículo de interop ECB y RC4
Para un pipeline que nunca sabe de antemano si la próxima carga lleva contraseña, el lector descrito arriba, junto con la lectura y escritura nativa de XLS y XLSX para Delphi y C++Builder, es parte del HotXLS Delphi Excel Component