Artículo técnico

Detecte XLSX manipulados: HMAC dataIntegrity de HotXLS

Un solo byte alterado dentro del stream EncryptedPackage de un .xlsx protegido con contraseña no impide que AES-CBC descifre todo el paquete con la contraseña correcta: el bloque de 16 bytes que contiene el byte alterado se convierte en ruido, y los mismos bits quedan alterados limpiamente en el bloque de texto plano siguiente. El cifrado por sí solo no puede decirte que eso pasó. La defensa vive en el elemento dataIntegrity de [MS-OFFCRYPTO] §2.3.4.14, un HMAC sobre el texto cifrado almacenado que el lector comprueba antes de descifrar un solo segmento

El cifrado Agile, el esquema que Excel escribe por defecto para libros protegidos con contraseña, te da confidencialidad mediante AES en modo CBC con una clave derivada de un hash de contraseña SHA-512 iterado. CBC no es un modo autenticado, así que el cifrado no opina sobre si el texto cifrado que tiene delante es el que se escribió. Un paquete modificado suele explotar más adelante como error de ZIP o deflate, porque un stream comprimido corrompido rara vez sobrevive a la inflación. El «suele» carga mucho peso en esa frase, y un error de parser tres capas más abajo es un mal sitio para enterarte de que alguien editó el archivo en tránsito

¿Por qué un libro cifrado manipulado sigue descifrando?

Un libro manipulado sigue descifrando porque CBC solo encadena bloques; nunca los autentica. Cada bloque de texto cifrado se descifra con la clave y luego se XOR con el bloque de texto cifrado anterior, así que un cambio en el bloque n embarra el bloque n de texto plano y altera exactamente los mismos bits en el bloque n+1. Alguien que conoce la estructura del texto plano puede dirigir ese segundo efecto. Alguien que no la conoce igualmente puede corromper datos de formas que el parser de turno puede o no notar

[MS-OFFCRYPTO] responde a esto con un MAC calculado sobre los bytes cifrados. El escritor genera una clave HMAC aleatoria cuya longitud coincide con el tamaño de hash de keyData (64 bytes para SHA-512), calcula un HMAC sobre el stream EncryptedPackage completo y guarda ambos valores en el elemento dataIntegrity como encryptedHmacKey y encryptedHmacValue. Ambos van cifrados con la clave de paquete, con IVs derivados de la sal de keyData y dos block keys fijos que define la especificación. El HMAC cubre el stream tal y como está almacenado, incluido el prefijo StreamSize de 8 bytes delante de los segmentos, así que ni la longitud de texto plano declarada puede alterarse sin detección

El orden en que HotXLS comprueba las cosas al abrir

HotXLS corre la comprobación de integridad después de probar la contraseña y antes de descifrar cualquier segmento del paquete. TXLSXWorkbook.OpenEncrypted prueba primero el lector de Standard Encryption y, cuando el stream EncryptionInfo lleva la firma Agile (versión 4.4), el pipeline Agile toma el control. Ese pipeline ejecuta estos pasos en orden:

  1. Ejecutar el hash de contraseña iterado con la sal y el spin count del descriptor; un spinCount por encima del techo de 10.000.000 que fija la especificación se trata como descriptor malformado y se rechaza antes de empezar a hashear
  2. Descifrar el verificador de contraseña, hashear y comparar el resultado con el hash del verificador almacenado; una discrepancia aquí significa contraseña errónea
  3. Desenvolver la clave de paquete intermedia y después descifrar la clave HMAC y el valor HMAC de los atributos de dataIntegrity
  4. Calcular el HMAC sobre los bytes del EncryptedPackage exactamente como están en el archivo y compararlo con el valor almacenado
  5. Solo tras una coincidencia, descifrar los segmentos de 4096 bytes y entregar el ZIP interior al cargador XLSX normal

Calcular el MAC sobre el texto cifrado es la disciplina estándar encrypt-then-MAC. Un paquete manipulado se rechaza antes de que un solo byte controlado por el atacante llegue al descifrado AES, a la inflación o al parser XML. Las dos comparaciones de esta ruta, el hash del verificador y el valor HMAC, acumulan con OR la XOR de cada pareja de bytes a lo largo del digest completo en lugar de volver en la primera diferencia, así que el tiempo de respuesta no revela cuántos bytes iniciales coincidieron. El algoritmo de hash sigue al descriptor: Excel declara SHA-512, algunos escritores de terceros declaran SHA-256, y el HMAC, los IVs y la derivación de clave cambian a lo que digan los nodos keyData y el cifrador de clave de contraseña

HotXLS: Diagrama de flujo del orden de comprobación de dataIntegrity: derivar clave, descifrar clave y valor HMAC, calcular HMAC-SHA-512 sobre el texto cifrado, comparación en tiempo constante, y después descifrar segmentos o rechazar
La compuerta de integridad corre antes de descomprimir nada: el HMAC se calcula sobre el texto cifrado almacenado, de modo que una contraseña errónea o un paquete manipulado se rechazan en la compuerta en lugar de aparecer como basura tras el descifrado

Desde el lado del que llama, un fallo de integridad y una contraseña errónea son el mismo evento. Ambos hacen que OpenEncrypted lance EXlsxEncryptionNotImplemented con el mensaje «The supplied password is incorrect for this encrypted workbook». Un contenedor que no es ni Standard ni Agile, o un archivo CFB ilegible, lanza la misma clase de excepción con otro mensaje. Solo un descifrado exitoso seguido de una carga fallida del libro interior vuelve como un valor de retorno distinto de 1

uses
  SysUtils, lxHandleX;

// Abre un libro que debe llegar cifrado
function OpenIntake(const FileName, Password: WideString): TXLSXWorkbook;
var
  Book: TXLSXWorkbook;
begin
  Book := TXLSXWorkbook.Create;
  try
    // OpenEncrypted cae en un Open normal ante un ZIP sin cifrar,
    // así que un pipeline que exige cifrado tiene que comprobarlo antes
    if not Book.CanReadEncrypted(FileName) then
      raise Exception.Create('Not an encrypted package: ' + FileName);
    // Contraseña errónea y HMAC que no cuadra lanzan ambos EXlsxEncryptionNotImplemented
    if Book.OpenEncrypted(FileName, Password) <> 1 then
      raise Exception.Create('Decrypted, but the inner workbook did not load');
    Result := Book;
  except
    Book.Free;
    raise;
  end;
end;

// Llamador; Quarantine y ProcessWorkbook son rutinas tuyas
try
  Book := OpenIntake('incoming.xlsx', PasswordFromVault);
  try
    ProcessWorkbook(Book);
  finally
    Book.Free;
  end;
except
  on E: EXlsxEncryptionNotImplemented do
    Quarantine('incoming.xlsx', E.Message);
end;

La guarda CanReadEncrypted importa más de lo que parece. Comprueba la firma de archivo compuesto OLE, y sin ella alguien podría sustituir un libro cifrado por un .xlsx corriente y OpenEncrypted lo cargaría como si nada. Un .xls clásico renombrado también lleva esa firma, y por eso pasa la guarda y luego falla dentro de OpenEncrypted con el mensaje de esquema de cifrado no soportado

Escribir paquetes que llevan el bloque

SaveAsEncryptedAgile es la llamada que produce un bloque dataIntegrity. Serializa el libro a un XLSX en memoria, lo cifra con AES-256-CBC bajo una derivación de clave SHA-512 con un spin count de 100.000, calcula un HMAC-SHA-512 sobre el stream EncryptedPackage terminado y escribe los dos blobs HMAC cifrados en el descriptor. SaveAsEncrypted escribe en cambio ECMA-376 Standard Encryption (AES-128 con derivación SHA-1), y la estructura EncryptionInfo Standard definida por [MS-OFFCRYPTO] no tiene ningún hueco para un MAC de integridad. Para cualquier cosa que cruce una red o viva en una unidad compartida, usa el escritor Agile: no cuesta nada de código extra y es el único de los dos cuya salida un lector puede comprobar contra manipulación

var
  Book: TXLSXWorkbook;
begin
  Book := TXLSXWorkbook.Create;
  try
    BuildPayrollSheets(Book);        // tu propio código que rellena el libro
    // Reabre el contenedor escrito por el pipeline de descifrado
    // e informa del fallo en lugar de dejar un archivo roto detrás
    Book.VerifyEncryptedSave := True;
    if Book.SaveAsEncryptedAgile('payroll-2026-10.xlsx', PasswordFromVault) <> 1 then
      raise Exception.Create('Encrypted save failed or did not verify');
  finally
    Book.Free;
  end;
end;

Con VerifyEncryptedSave activado, el guardado vuelve a abrir el archivo nuevo con la misma contraseña, así que un guardado verificado ya pasó una vez la comprobación HMAC. El material aleatorio, es decir las dos sales de 16 bytes, la entrada del verificador, la clave de paquete de 32 bytes y la clave HMAC de 64 bytes, sale del CSPRNG del sistema operativo (CryptGenRandom en Windows). Si esa fuente no puede entregar, el escritor Agile lanza una excepción en lugar de caer en un generador sembrado con la hora. Esos bytes acaban siendo sales y claves AES; una reserva predecible produciría archivos que parecen cifrados, pasan cualquier test funcional y no protegen nada. Un guardado fallido es el mejor desenlace aquí

¿Qué pasa cuando un archivo no tiene bloque dataIntegrity?

El archivo se abre con normalidad. Muchos libros cifrados en Agile en circulación salen de escritores que omiten dataIntegrity, y rechazarlos rompería mucho más trabajo legítimo de lo que evitaría. HotXLS considera el bloque presente solo cuando encryptedHmacKey y encryptedHmacValue decodifican a valores no vacíos y alineados a 16 bytes; en cualquier otro caso se salta la verificación y el descifrado continúa tras la comprobación de contraseña

Esa decisión de compatibilidad tiene una consecuencia de seguridad que conviene escribir en tu modelo de amenazas. El elemento dataIntegrity vive en el stream EncryptionInfo, fuera de los bytes que su propio MAC cubre, así que un bloque ausente se ve exactamente igual que un bloque que un atacante borró. Si controlas los dos extremos de un pipeline y todos los productores usan SaveAsEncryptedAgile, trata un bloque ausente como un fallo de política a nivel de aplicación. La llamada de apertura no informa de si la verificación corrió, así que imponer esa regla significa leer el XML de EncryptionInfo tú mismo con un lector de archivos compuestos antes de entregar el archivo. Para los archivos que vienen del mundo exterior, lee la comprobación por lo que es: una señal fuerte cuando el bloque está, y ninguna señal cuando falta

El bucle de reintentos de OnPassword y los archivos manipulados

La sobrecarga normal Open(FileName, Password) también descifra paquetes Standard y Agile, y añade un contrato de reintentos que OpenEncrypted no tiene. Cuando el resultado es «contraseña errónea» y OnPassword está asignado, el libro llama al handler, que puede aportar otra contraseña y poner Retry a True; el bucle se detiene tras tres llamadas al handler. Como una discrepancia de HMAC produce ese mismo resultado de «contraseña errónea», un handler que simplemente vuelve a preguntar se llama hasta tres veces para un paquete manipulado, cada intento falla, y el bucle acaba con el mensaje de contraseña incorrecta. La contraseña correcta falla en el HMAC, y todas las demás fallan en el verificador

procedure TIntakeForm.BookPassword(Sender: TObject;
  var PassWord: WideString; var Retry: Boolean);
begin
  // También se llega aquí para un paquete cuyo HMAC no cuadró.
  // Volver a preguntar no arregla ese caso, así que ofrece una única clave
  // de reserva y deja que el siguiente fallo aparezca como error
  Inc(FPasswordCalls);
  Retry := (FPasswordCalls = 1) and FetchFallbackKey(PassWord); // función tuya
end;

// Cableado
FPasswordCalls := 0;
Book.OnPassword := BookPassword;
Book.Open('incoming.xlsx', PasswordFromVault);

Para ingesta desatendida, deja OnPassword sin asignar y llama a OpenEncrypted. El primer fallo lanza la excepción al momento, y el log de cuarentena registra un evento por archivo en lugar de una ráfaga de reintentos

La contraseña para modificar es coordinación, no protección

Los libros XLS clásicos admiten un mecanismo aparte que la gente confunde a menudo con el cifrado: la reserva de escritura tras el aviso de «contraseña para modificar» de Excel. HotXLS la expone en IXLSWorkbook mediante SetModifyPassword, que toma la contraseña, un flag de recomendar solo lectura y el usuario que reserva, y comunica el estado a través de la propiedad IsWriteReserved. Pasar una contraseña vacía limpia la reserva y deja intacto el nombre de usuario de WRITEACCESS, que va aparte

La estructura de registros es corta. FILESHARING lleva el flag de recomendar solo lectura, un hash de contraseña de 16 bits heredado y el nombre de usuario como cadena Unicode BIFF8 sin comprimir; al guardar, HotXLS coloca el marcador WRITEPROT vacío delante de WRITEACCESS y FILESHARING siempre que exista una reserva, que es el orden del File Protection Block que Excel espera. Las reservas escritas por el propio Excel sobreviven a un viaje de ida y vuelta por HotXLS por el mismo camino. Estos registros solo se escriben para el formato BIFF8 xlExcel97

var
  Book: IXLSWorkbook;   // contado por interfaz: no llamar a Free
begin
  Book := TXLSWorkbook.Create;
  if Book.Open('shared-model.xls') = 1 then
  begin
    // Recomendar solo lectura, reservado por el servicio de informes
    Book.SetModifyPassword('edit-me', True, 'Reporting Service');
    if Book.IsWriteReserved then
      Book.SaveAs('shared-model.xls', xlExcel97);
  end;
end;

Un hash de 16 bits es un checksum, y los datos de hoja bajo una reserva de escritura no están cifrados en absoluto; cualquier otra herramienta lee todas las celdas. La función le dice a la siguiente persona, dentro de Excel, que alguien considera suyo este archivo para editarlo, en la misma categoría que los controles a nivel de hoja tratados en la protección de hojas XLSX y sus opciones allow. La confidencialidad viene de las rutas de guardado cifrado descritas en la salida XLSX protegida con AES, y las comprobaciones a nivel de contenedor van aún antes en la cadena, porque la estructura ZIP de un paquete normal se parsea antes de que corra cualquier lógica de libros; la validación del end-of-central-directory ZIP para XLSX no confiables cubre esos modos de fallo

HotXLS lee y escribe XLS, XLSX y ODS desde Delphi y C++Builder sin necesidad de instalar Excel, y su código de cifrado Standard y Agile está escrito en Pascal contra [MS-OFFCRYPTO]. La referencia completa de métodos de OpenEncrypted, SaveAsEncryptedAgile y SetModifyPassword está en la página del componente de hojas de cálculo HotXLS para Delphi