No confíes en la extensión: cómo enseñar a tu app a detectar 200 formatos de archivo por sus firmasArtículo · digest del 10 de noviembre
Lupa de investigador sobre un volcado hexadecimal de los primeros bytes de un archivo binario
Artículo4 secciones≈ 9 min

No confíes en la extensión: cómo enseñar a tu app a detectar 200 formatos de archivo por sus firmas

En muchos servicios, validar un archivo subido se reduce a mirar las últimas letras de su nombre. Parece obvio: si el documento se llama report.pdf, tenemos un PDF, y si es avatar.png, una imagen inofensiva. En realidad todo archivo tiene dos nombres. El primero va después del punto, y es solo una etiqueta de texto que pudo pegar el usuario, un gateway de correo o un atacante. El segundo nombre está grabado en los primeros bytes del propio archivo, y casi nunca miente.

El desarrollador Sentaik se topó con esto al crear el visor móvil XanderFiles para Android. La aplicación debía abrir más de 200 formatos: desde hojas de cálculo hasta paquetes de correo winmail.dat, pases de billetera digital, fotos RAW sin procesar y tomografías. Los usuarios subían archivos comprimidos renombrados, capturas sin extensión y documentos con etiquetas rotas. ¿Cómo construir un pipeline rápido de validación que reconozca el tipo real del archivo y frene falsificaciones al vuelo, sin cargar archivos pesados completos en memoria?

La ilusión de las extensiones: por qué revisar el nombre del archivo no tiene nada que ver con la seguridad

Cuando un cliente móvil envía archivos al servidor o al renderizador, la tentación más frecuente es llamar a path.extname(filename) o fiarse de la cabecera Content-Type del navegador. ¿Para qué asomarse dentro del flujo si el cliente ya etiquetó el paquete como image/png?

El problema es que el navegador genera el Content-Type según la etiqueta tras el punto. Basta renombrar un script shell.php a invoice.pdf para que el cliente reporte que sube un documento. Si el backend le cree a la etiqueta bajo palabra y guarda el archivo en una carpeta pública o lo pasa a un parser, el servicio abre las puertas a ejecución remota de código —Remote Code Execution (RCE)— y cross-site scripting (XSS).

En el día a día, confiar en las extensiones hace igual daño. Alguien descarga de su correo un contrato que el gateway empaquetó en un ZIP dejando el .pdf al final. El programa intenta leer el ZIP como una página PDF y lanza «Archivo dañado», aunque los datos están intactos: simplemente pusieron «Mermelada» en el frasco de pepinillos.

Anatomía de los «números mágicos»: cómo funcionan las firmas en bytes de los formatos populares

Para que el lector entienda desde el primer instante la estructura de los datos, los autores de especificaciones reservan al inicio del archivo una secuencia fija de bytes: los «números mágicos» (magic bytes):

FormatoFirma (Hex)Particularidades de la cabecera
PNG89 50 4E 47 0D 0A 1A 0A8 bytes (\x89PNG\r\n\x1a\n) con verificación de saltos de línea
JPEGFF D8 FF3 bytes iniciales del marcador de inicio de imagen
GIF47 49 46 384 bytes de la cadena GIF8 (GIF87a o GIF89a)
ZIP50 4B 03 044 bytes PK\x03\x04 (iniciales de Phil Katz)
OLE2D0 CF 11 E0 A1 B1 1A E18 bytes del contenedor de archivos antiguos de Word, Excel y .msg
PDF25 50 44 46 2D5 bytes %PDF- (en cualquier punto de los primeros 1024 bytes según ISO 32000)

Parecería fácil: armas una tabla con doscientas máscaras, recorres un ciclo y listo. Yo también pensaba que el problema se resolvía con un catálogo. Pero el autor de XanderFiles, tras escribir 22 mil líneas de JavaScript para 26 visores, descubrió que la trampa principal no está en los bytes, sino en el orden en que se revisan.

Según el estándar, el marcador %PDF- puede aparecer en cualquier lugar dentro de los primeros 1024 bytes. Si un usuario sube un ZIP sin compresión, un paquete winmail.dat (78 9F 3E 22) o un .pdf.p7m firmado (CMS/PKCS#7) con un documento adentro, la cadena %PDF- del adjunto caerá justo en el primer kilobyte del archivo. Si verificas PDF antes que los contenedores, el escáner tomará todo el archivo con firma por un PDF común y perderá en silencio el resto de adjuntos.

Lo mismo pasa con las tomografías DICOM: su marca DICM está en el desplazamiento de 128 bytes, mientras que en los primeros 128 bytes del preámbulo los tomógrafos suelen colocar una cabecera de imagen TIFF (II*\x00). Si revisas TIFF antes del byte 128, mostrarás una miniatura en vez del corte de TC. Y en los negativos digitales RAW (CR2, NEF, ARW), los formatos mismos se construyen sobre TIFF, por lo que sus marcadores deben comprobarse estrictamente antes de la regla general de TIFF.

Contenedores engañosos: detectar tipos internos en ZIP, RIFF y MP4 sin descomprimir

La mitad de los formatos cotidianos son contenedores tipo matrioska. La cabecera RIFF (52 49 46 46 en los bytes 0–3) solo indica que tenemos una caja delante: para distinguir una imagen WebP de un video AVI hay que revisar los bytes 8–11 buscando la cadena WEBP (57 45 42 50). Mientras tanto, los videos MP4, fotos HEIC y RAW Canon CR3 viven dentro del contenedor ISO-BMFF con el marcador ftyp a partir del desplazamiento 4.

Pero el maestro del disfraz es ZIP (50 4B 03 04). Los documentos .docx, hojas .xlsx, presentaciones .pptx, libros .epub, archivos Apple Pages, diseños de CorelDRAW (desde la versión X4) y tarjetas de embarque de Apple Wallet (.pkpass) son archivos ZIP corrientes. Para distinguir una tarjeta de embarque que un mensajero renombró a .zip no hace falta descomprimir nada: basta inspeccionar la lista de sus entradas:

export function detectZipSubtype(entries: string[]): string {
  if (entries.includes('word/document.xml')) return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
  if (entries.includes('xl/workbook.xml')) return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
  if (entries.includes('pass.json')) return 'application/vnd.apple.pkpass';
  if (entries.includes('META-INF/container.xml')) return 'application/epub+zip';
  return 'application/zip';
}

La función detectZipSubtype analiza el arreglo de nombres entries del índice del archivo (Central Directory) sin leer gigabytes de datos. Al encontrar pass.json, el validador devuelve application/vnd.apple.pkpass y la app dibuja la tarjeta de embarque con su código de barras. Del mismo modo se identifican archivos de Apple iWork por Index/*.iwa y diseños de CorelDRAW por content/riffData.cdr.

Arquitectura del validador: búfer de los primeros 64 bytes, árbol de condiciones y defensa contra políglotas

Para que la comprobación tome microsegundos en archivos de cualquier tamaño, el validador lee del flujo únicamente el corte inicial: los primeros 64 bytes bastan para firmas básicas y contenedores, y un búfer de 64–1024 bytes cubre formatos con desplazamiento según los principios de WHATWG MIME Sniffing Standard. Aquí está el núcleo de un escáner así en Node.js:

import fs from 'node:fs';

export async function sniffFileHeader(filePath: string): Promise<string> {
  const stream = fs.createReadStream(filePath, { start: 0, end: 1023 });
  const chunks: Buffer[] = [];
  for await (const chunk of stream) chunks.push(Buffer.from(chunk));
  const buf = Buffer.concat(chunks);

  if (buf.length >= 132 && buf.subarray(128, 132).toString('ascii') === 'DICM') return 'application/dicom';
  if (buf.length >= 4 && buf[0] === 0x50 && buf[1] === 0x4B && buf[2] === 0x03 && buf[3] === 0x04) return 'application/zip';
  if (buf.length >= 12 && buf.subarray(0, 4).toString('ascii') === 'RIFF' && buf.subarray(8, 12).toString('ascii') === 'WEBP') return 'image/webp';
  if (buf.length >= 8 && buf.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]))) return 'image/png';
  if (buf.indexOf(Buffer.from('%PDF-')) !== -1) return 'application/pdf';
  return 'application/octet-stream';
}

La llamada fs.createReadStream con límites start: 0, end: 1023 toma exactamente el primer kilobyte. Primero revisa el desplazamiento 128 para imágenes DICOM; luego, en los primeros 64 bytes, intercepta contenedores ZIP y RIFF/WEBP; después verifica el prefijo PNG y solo al final busca %PDF-. Si la extensión contradice al contenido, XanderFiles abre el archivo según su tipo real con un aviso: «El archivo se llama .pdf, pero en realidad es un archivo comprimido; abierto como archivo comprimido». Y para formatos sin firma como TGA se validan dimensiones distintas de cero y profundidad de color de 8, 15, 16, 24 o 32 bits.

Protección contra archivos políglotas en el backend

Leer solo los primeros bytes no basta contra archivos políglotas: un atacante puede pegar una cabecera GIF89a con un script PHP o JS dentro (ya analizamos el ocultamiento de código en la cola de archivos en Anatomía de amenazas en el mundo del vibe coding: por qué uno de cada cinco skills para agentes de IA es peligroso). En el servidor, complementa el escáner recodificando las imágenes y enviando la cabecera X-Content-Type-Options: nosniff.

Controlar los datos en los bordes es el mejor seguro para producción, como comentamos en Del vibe coding a producción: trampas de arquitectura y seguridad del software creado con IA. Y no hace falta escribir en una sola noche un parser para doscientos formatos. Empieza revisando los primeros 64 bytes para los cinco o diez tipos principales de tu servicio y activa nosniff. Eso protegerá tu almacenamiento desde el primer día frente a extensiones falsas, e irás sumando ramas al árbol de condiciones conforme aparezcan necesidades, igual que en XanderFiles el soporte de pases Wallet nació de una sola tarjeta de embarque que no abría antes de un vuelo.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 2