upload-safety 0.2.1 → 0.4.0

package/src/rtf-content.ts

@@ -0,0 +1,178 @@
+/**
+ * Checks that an RTF upload holds no active content. Word's RTF reader is lenient and attackers
+ * obfuscate heavily, so this refuses on the presence of dangerous control words and DDE fields
+ * instead of trying to understand the document.
+ */
+
+// Word opens a file as RTF when it starts with `{\rt`, whatever follows (`{\rtf1` is only the usual form).
+const RTF_SIGNATURE = '{\\rt';
+const MAX_GROUP_DEPTH = 1000;
+const DEFAULT_UNICODE_SKIP = 1;
+// Word runs the command of a DDE field (with a prompt); QUOTE with character codes can spell one out.
+const DDE_FIELD = /\bDDE(?:AUTO)?\b|\bQUOTE\s+\d/i;
+/**
+ * Control words that carry or load active content:
+ * - `obj*` starts an embedded or linked OLE object (`\object`, `\objdata`, `\objemb`, `\objautlink`, `\objupdate`, ...),
+ *   the carrier of Equation Editor exploits (CVE-2017-11882) and auto-loading links (CVE-2017-0199).
+ * - `template` attaches a template, which can be a remote one that Word loads and runs macros from.
+ * - `datastore` holds a custom XML data store, a way to smuggle an object past a reader that only looks for `obj*`.
+ */
+const ACTIVE_CONTROL_WORD_PREFIXES = [ 'obj', 'template', 'datastore' ];
+const FIELD_INSTRUCTION_WORD = 'fldinst';
+const BIN_WORD = 'bin';
+const UNICODE_WORD = 'u';
+const UNICODE_SKIP_WORD = 'uc';
+
+const CHAR_OPEN_GROUP = 0x7b;
+const CHAR_CLOSE_GROUP = 0x7d;
+const CHAR_BACKSLASH = 0x5c;
+const CHAR_QUOTE = 0x27;
+const CHAR_TILDE = 0x7e;
+const CHAR_SPACE = 0x20;
+const CHAR_CR = 0x0d;
+const CHAR_LF = 0x0a;
+const CHAR_MINUS = 0x2d;
+const CHAR_ZERO = 0x30;
+const CHAR_NINE = 0x39;
+const MAX_UNICODE_PARAMETER = 0xffff;
+const UNICODE_RANGE = 0x10000;
+
+const isLetter = ( byte: number ) => ( byte >= 0x41 && byte <= 0x5a ) || ( byte >= 0x61 && byte <= 0x7a );
+const isDigit = ( byte: number ) => byte >= CHAR_ZERO && byte <= CHAR_NINE;
+
+/** The value of a hex digit byte, or -1. */
+function hexValue( byte: number | undefined ): number {
+	if ( byte === undefined ) {
+		return -1;
+	}
+	if ( isDigit( byte ) ) {
+		return byte - CHAR_ZERO;
+	}
+	const lower = byte | 0x20;
+	return lower >= 0x61 && lower <= 0x66 ? lower - 0x61 + 10 : -1;
+}
+
+function isActiveControlWord( word: string ): boolean {
+	return ACTIVE_CONTROL_WORD_PREFIXES.some( ( prefix ) => word.startsWith( prefix ) );
+}
+
+/**
+ * Scans RTF the way a reader tokenizes it: groups, control words, control symbols, `\bin` data and text.
+ * Returns 'macros' for an active control word or a DDE field, 'mismatch' when the file is not RTF
+ * or cannot be read to the end, else 'valid'.
+ */
+export function inspectRtf( content: Buffer ): 'valid' | 'macros' | 'mismatch' {
+	if ( content.toString( 'latin1', 0, RTF_SIGNATURE.length ).toLowerCase() !== RTF_SIGNATURE ) {
+		return 'mismatch';
+	}
+
+	// Word reads the instruction of a field from its `\fldinst` group, nested groups included.
+	let instructions = '';
+	let fieldDepth = -1;
+	// `\uc` is scoped to its group.
+	const unicodeSkips = [ DEFAULT_UNICODE_SKIP ];
+	let depth = 0;
+	let skipCount = 0;
+	let position = 0;
+
+	const addText = ( text: string ) => {
+		if ( skipCount > 0 ) {
+			skipCount--;
+			return;
+		}
+		if ( fieldDepth >= 0 ) {
+			instructions += text;
+		}
+	};
+
+	while ( position < content.length ) {
+		const byte = content[ position++ ]!;
+
+		if ( byte === CHAR_OPEN_GROUP ) {
+			depth++;
+			if ( depth > MAX_GROUP_DEPTH ) {
+				return 'mismatch';
+			}
+			unicodeSkips.push( unicodeSkips[ unicodeSkips.length - 1 ]! );
+			skipCount = 0;
+		} else if ( byte === CHAR_CLOSE_GROUP ) {
+			if ( depth > 0 ) {
+				if ( depth === fieldDepth ) {
+					fieldDepth = -1;
+				}
+				depth--;
+				unicodeSkips.pop();
+			}
+			skipCount = 0;
+		} else if ( byte === CHAR_CR || byte === CHAR_LF ) {
+			// Readers ignore raw line breaks, so `DD` and `E` on two lines still spell DDE.
+			continue;
+		} else if ( byte !== CHAR_BACKSLASH ) {
+			addText( String.fromCharCode( byte ) );
+		} else if ( position < content.length ) {
+			const next = content[ position ]!;
+			if ( !isLetter( next ) ) {
+				position++;
+				if ( next === CHAR_QUOTE ) {
+					const high = hexValue( content[ position ] );
+					const low = hexValue( content[ position + 1 ] );
+					if ( high >= 0 && low >= 0 ) {
+						position += 2;
+						addText( String.fromCharCode( high * 16 + low ) );
+					}
+				} else if ( next === CHAR_TILDE ) {
+					addText( String.fromCharCode( CHAR_SPACE ) );
+				} else if ( next === CHAR_BACKSLASH || next === CHAR_OPEN_GROUP || next === CHAR_CLOSE_GROUP ) {
+					addText( String.fromCharCode( next ) );
+				}
+				continue;
+			}
+
+			const wordStart = position;
+			while ( position < content.length && isLetter( content[ position ]! ) ) {
+				position++;
+			}
+			const word = content.toString( 'latin1', wordStart, position ).toLowerCase();
+
+			let parameter: number | undefined;
+			const parameterStart = position;
+			if ( content[ position ] === CHAR_MINUS ) {
+				position++;
+			}
+			const digitsStart = position;
+			while ( position < content.length && isDigit( content[ position ]! ) ) {
+				position++;
+			}
+			if ( position > digitsStart ) {
+				parameter = Number( content.toString( 'latin1', parameterStart, position ) );
+			} else {
+				position = parameterStart;
+			}
+			if ( content[ position ] === CHAR_SPACE ) {
+				position++;
+			}
+
+			if ( isActiveControlWord( word ) ) {
+				return 'macros';
+			}
+			if ( word === FIELD_INSTRUCTION_WORD && fieldDepth < 0 ) {
+				fieldDepth = depth;
+			} else if ( word === BIN_WORD ) {
+				const length = parameter ?? 0;
+				if ( length < 0 || position + length > content.length ) {
+					return 'mismatch';
+				}
+				position += length;
+			} else if ( word === UNICODE_SKIP_WORD && parameter !== undefined && parameter >= 0 ) {
+				unicodeSkips[ unicodeSkips.length - 1 ] = parameter;
+			} else if ( word === UNICODE_WORD && parameter !== undefined ) {
+				const codePoint = parameter < 0 ? parameter + UNICODE_RANGE : Math.min( parameter, MAX_UNICODE_PARAMETER );
+				skipCount = 0;
+				addText( String.fromCharCode( codePoint ) );
+				skipCount = unicodeSkips[ unicodeSkips.length - 1 ]!;
+			}
+		}
+	}
+
+	return DDE_FIELD.test( instructions ) ? 'macros' : 'valid';
+}

package/src/upload-allowlist.ts

@@ -1,29 +1,46 @@
 /**
- * Strict allowlist + validation for document uploads: PDF, MS Office (also the
- * legacy formats), LibreOffice, photos (JPEG, PNG, WebP, HEIC/HEIF, AVIF) and CSV and text. Validation happens on three axes: file
- * extension, declared MIME type, and the actual content, i.e. the magic-byte
- * signature plus the parts a file of that kind always has. Extension and MIME
- * alone are trivially spoofed.
+ * Strict allowlist + validation for uploads: PDF, MS Office (also the legacy formats), LibreOffice,
+ * images, audio, video, text, RTF and archives. Validation happens on three axes: file extension,
+ * declared MIME type, and the actual content, i.e. the magic-byte signature plus the parts a file
+ * of that kind always has. Extension and MIME alone are trivially spoofed.
  */
 
+import { inspectGzip, inspectTarArchive, inspectZipArchive } from './archive-content.js';
+import { inspectAsf } from './asf-media.js';
 import { inspectExcelGlobals } from './excel-macro-sheets.js';
 import { readFtypBrands } from './heif-metadata.js';
 import { readOleDirectory, type OleDirectory } from './ole-streams.js';
 import { inspectPdf } from './pdf-active-content.js';
+import { M4A_BRANDS, MP4_BRANDS, stripPhotoMetadata } from './photo-metadata.js';
 import { hasPowerPointCode, isEncryptedPowerPoint } from './powerpoint-vba.js';
+import { inspectRtf } from './rtf-content.js';
 import { inspectText } from './text-content.js';
 import { stripXmlMarkup } from './xml-markup.js';
 import { readZipEntries, readZipEntryData, startsWithBytes, type ZipEntry } from './zip-entries.js';
 
 export type AllowedExtension =
 	| 'pdf' | 'doc' | 'docx' | 'ppt' | 'pptx' | 'xls' | 'xlsx' | 'odt' | 'ods' | 'odp'
-	| 'jpg' | 'jpeg' | 'png' | 'webp' | 'heic' | 'heif' | 'avif' | 'csv' | 'txt';
+	| 'jpg' | 'jpeg' | 'png' | 'webp' | 'heic' | 'heif' | 'avif' | 'gif' | 'bmp' | 'ico'
+	| 'mp3' | 'aac' | 'wav' | 'flac' | 'ogg' | 'm4a' | 'wma' | 'mp4' | 'mov' | 'webm' | 'mkv' | 'avi' | 'wmv'
+	| 'csv' | 'txt' | 'md' | 'rtf' | 'zip' | 'tar' | 'gz' | 'tgz' | 'rar' | '7z';
+
+/**
+ * How much accepting a format exposes. `low`: read in full, nothing in it runs, and it is in the
+ * default list. `elevated`: read in full, but the format is a common malware carrier, gets rendered
+ * or gets unpacked; accepted only when named in `allowedExtensions`. `unchecked`: only the
+ * signature is checked, as its content cannot be read without a decompressor; accepted only when
+ * named, and best served as an opaque download.
+ */
+export type FormatRisk = 'low' | 'elevated' | 'unchecked';
 
 /** Magic-byte family an extension's bytes must match; text has no signature and is checked on its own. */
-type MagicFamily = 'pdf' | 'zip' | 'ole' | 'jpeg' | 'png' | 'webp' | 'isobmff' | 'text';
+type MagicFamily =
+	| 'pdf' | 'zip' | 'ole' | 'jpeg' | 'png' | 'webp' | 'isobmff' | 'text' | 'gif' | 'bmp' | 'ico'
+	| 'mp3' | 'aac' | 'wav' | 'flac' | 'ogg' | 'quicktime' | 'webm' | 'avi' | 'asf' | 'rtf' | 'tar' | 'gzip' | 'rar' | '7z';
 
 interface AllowedType {
 	extension: AllowedExtension;
+	risk: FormatRisk;
 	/** Accepted declared MIME types for this extension. */
 	mimeTypes: string[];
 	/** Byte-signature family the actual content must match. */
@@ -351,69 +368,116 @@ function isEncryptedOpenDocument( content: Buffer, entries: ZipEntry[] ): boolea
 const ODT = 'application/vnd.oasis.opendocument.text';
 const ODS = 'application/vnd.oasis.opendocument.spreadsheet';
 const ODP = 'application/vnd.oasis.opendocument.presentation';
-const JPEG = { magic: 'jpeg', mimeTypes: [ 'image/jpeg', 'image/pjpeg' ] } as const satisfies Omit<AllowedType, 'extension'>;
+const JPEG = { magic: 'jpeg', mimeTypes: [ 'image/jpeg', 'image/pjpeg' ] } as const satisfies Omit<AllowedType, 'extension' | 'risk'>;
 // HEIC is HEIF with HEVC images; `mif1` names HEIF without saying which codec. Sequences (`msf1`, `hevc`, `hevx`, `avis`) are left out.
 const HEVC_BRANDS = [ 'heic', 'heix', 'heim', 'heis' ];
+const ARCHIVE_EXTENSIONS: ReadonlySet<AllowedExtension> = new Set( [ 'zip', 'tar', 'gz', 'tgz', 'rar', '7z' ] );
 
 // OOXML (docx/xlsx/pptx) and OpenDocument (odt/ods/odp) files are ZIP
 // containers; legacy Office formats (doc/xls/ppt) are OLE compound files.
 const ALLOWED_TYPES: readonly AllowedType[] = [
-	{ extension: 'pdf', magic: 'pdf', mimeTypes: [ 'application/pdf' ] },
+	{ extension: 'pdf', risk: 'low', magic: 'pdf', mimeTypes: [ 'application/pdf' ] },
 	{
-		extension: 'doc', magic: 'ole', mimeTypes: [ 'application/msword' ], oleStreams: [ 'WordDocument' ],
+		extension: 'doc',
+		risk: 'low', magic: 'ole', mimeTypes: [ 'application/msword' ], oleStreams: [ 'WordDocument' ],
 	},
 	{
 		extension: 'docx',
+		risk: 'low',
 		magic: 'zip',
 		mimeTypes: [ 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' ],
 		zipEntries: ooxml( 'word/document.xml' ),
 	},
 	{
-		extension: 'ppt', magic: 'ole', mimeTypes: [ 'application/vnd.ms-powerpoint' ], oleStreams: [ 'PowerPoint Document' ],
+		extension: 'ppt',
+		risk: 'low', magic: 'ole', mimeTypes: [ 'application/vnd.ms-powerpoint' ], oleStreams: [ 'PowerPoint Document' ],
 	},
 	{
 		extension: 'pptx',
+		risk: 'low',
 		magic: 'zip',
 		mimeTypes: [ 'application/vnd.openxmlformats-officedocument.presentationml.presentation' ],
 		zipEntries: ooxml( 'ppt/presentation.xml' ),
 	},
 	{
-		extension: 'xls', magic: 'ole', mimeTypes: [ 'application/vnd.ms-excel' ], oleStreams: [ 'Workbook', 'Book' ],
+		extension: 'xls',
+		risk: 'low', magic: 'ole', mimeTypes: [ 'application/vnd.ms-excel' ], oleStreams: [ 'Workbook', 'Book' ],
 	},
 	{
 		extension: 'xlsx',
+		risk: 'low',
 		magic: 'zip',
 		mimeTypes: [ 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' ],
 		zipEntries: ooxml( 'xl/workbook.xml' ),
 	},
 	{
-		extension: 'odt', magic: 'zip', mimeTypes: [ ODT ], zipEntries: OPEN_DOCUMENT_ENTRIES, openDocumentType: ODT,
+		extension: 'odt',
+		risk: 'low', magic: 'zip', mimeTypes: [ ODT ], zipEntries: OPEN_DOCUMENT_ENTRIES, openDocumentType: ODT,
 	},
 	{
-		extension: 'ods', magic: 'zip', mimeTypes: [ ODS ], zipEntries: OPEN_DOCUMENT_ENTRIES, openDocumentType: ODS,
+		extension: 'ods',
+		risk: 'low', magic: 'zip', mimeTypes: [ ODS ], zipEntries: OPEN_DOCUMENT_ENTRIES, openDocumentType: ODS,
 	},
 	{
-		extension: 'odp', magic: 'zip', mimeTypes: [ ODP ], zipEntries: OPEN_DOCUMENT_ENTRIES, openDocumentType: ODP,
+		extension: 'odp',
+		risk: 'low', magic: 'zip', mimeTypes: [ ODP ], zipEntries: OPEN_DOCUMENT_ENTRIES, openDocumentType: ODP,
 	},
-	{ extension: 'jpg', ...JPEG },
-	{ extension: 'jpeg', ...JPEG },
-	{ extension: 'png', magic: 'png', mimeTypes: [ 'image/png' ] },
-	{ extension: 'webp', magic: 'webp', mimeTypes: [ 'image/webp' ] },
-	{ extension: 'heic', magic: 'isobmff', mimeTypes: [ 'image/heic' ], brands: HEVC_BRANDS },
-	{ extension: 'heif', magic: 'isobmff', mimeTypes: [ 'image/heif', 'image/heic' ], brands: [ ...HEVC_BRANDS, 'mif1' ] },
-	{ extension: 'avif', magic: 'isobmff', mimeTypes: [ 'image/avif' ], brands: [ 'avif' ] },
+	{ extension: 'jpg', risk: 'low', ...JPEG },
+	{ extension: 'jpeg', risk: 'low', ...JPEG },
+	{ extension: 'png', risk: 'low', magic: 'png', mimeTypes: [ 'image/png' ] },
+	{ extension: 'webp', risk: 'low', magic: 'webp', mimeTypes: [ 'image/webp' ] },
+	{ extension: 'heic', risk: 'low', magic: 'isobmff', mimeTypes: [ 'image/heic' ], brands: HEVC_BRANDS },
+	{ extension: 'heif', risk: 'low', magic: 'isobmff', mimeTypes: [ 'image/heif', 'image/heic' ], brands: [ ...HEVC_BRANDS, 'mif1' ] },
+	{ extension: 'avif', risk: 'low', magic: 'isobmff', mimeTypes: [ 'image/avif' ], brands: [ 'avif' ] },
 	// Windows names the type of a CSV file after Excel.
 	{
-		extension: 'csv', magic: 'text', mimeTypes: [ 'text/csv', 'application/vnd.ms-excel', 'application/csv', 'text/x-csv', 'text/comma-separated-values', 'text/plain' ],
+		extension: 'csv',
+		risk: 'low', magic: 'text', mimeTypes: [ 'text/csv', 'application/vnd.ms-excel', 'application/csv', 'text/x-csv', 'text/comma-separated-values', 'text/plain' ],
 	},
-	{ extension: 'txt', magic: 'text', mimeTypes: [ 'text/plain' ] },
+	{ extension: 'txt', risk: 'low', magic: 'text', mimeTypes: [ 'text/plain' ] },
+	{ extension: 'gif', risk: 'low', magic: 'gif', mimeTypes: [ 'image/gif' ] },
+	{ extension: 'bmp', risk: 'low', magic: 'bmp', mimeTypes: [ 'image/bmp', 'image/x-bmp', 'image/x-ms-bmp' ] },
+	{ extension: 'ico', risk: 'low', magic: 'ico', mimeTypes: [ 'image/vnd.microsoft.icon', 'image/x-icon', 'image/ico' ] },
+	{ extension: 'mp3', risk: 'low', magic: 'mp3', mimeTypes: [ 'audio/mpeg', 'audio/mp3', 'audio/mpeg3' ] },
+	{ extension: 'wav', risk: 'low', magic: 'wav', mimeTypes: [ 'audio/wav', 'audio/x-wav', 'audio/wave', 'audio/vnd.wave' ] },
+	{ extension: 'flac', risk: 'low', magic: 'flac', mimeTypes: [ 'audio/flac', 'audio/x-flac' ] },
+	{ extension: 'ogg', risk: 'low', magic: 'ogg', mimeTypes: [ 'audio/ogg', 'application/ogg', 'video/ogg' ] },
+	{ extension: 'm4a', risk: 'low', magic: 'isobmff', mimeTypes: [ 'audio/mp4', 'audio/x-m4a', 'audio/m4a' ], brands: M4A_BRANDS },
+	{ extension: 'mp4', risk: 'low', magic: 'isobmff', mimeTypes: [ 'video/mp4', 'application/mp4' ], brands: MP4_BRANDS },
+	// Old QuickTime movies have no `ftyp`; the structure is checked when the metadata is removed.
+	{ extension: 'mov', risk: 'low', magic: 'quicktime', mimeTypes: [ 'video/quicktime' ] },
+	{ extension: 'webm', risk: 'low', magic: 'webm', mimeTypes: [ 'video/webm', 'audio/webm' ] },
+	{ extension: 'aac', risk: 'low', magic: 'aac', mimeTypes: [ 'audio/aac', 'audio/x-aac', 'audio/aacp' ] },
+	{ extension: 'mkv', risk: 'low', magic: 'webm', mimeTypes: [ 'video/x-matroska', 'video/matroska', 'audio/x-matroska' ] },
+	{ extension: 'avi', risk: 'low', magic: 'avi', mimeTypes: [ 'video/x-msvideo', 'video/avi', 'video/msvideo' ] },
+	// Windows Media Player runs script commands and opens DRM license URLs in these; both are refused.
+	{ extension: 'wma', risk: 'elevated', magic: 'asf', mimeTypes: [ 'audio/x-ms-wma', 'application/vnd.ms-asf' ] },
+	{ extension: 'wmv', risk: 'elevated', magic: 'asf', mimeTypes: [ 'video/x-ms-wmv', 'video/x-ms-asf', 'application/vnd.ms-asf' ] },
+	// Rendered Markdown may carry raw HTML and `javascript:` links; the file itself is checked as text.
+	{ extension: 'md', risk: 'elevated', magic: 'text', mimeTypes: [ 'text/markdown', 'text/x-markdown', 'text/plain' ] },
+	// A common carrier of OLE exploits; refused on any object, template or DDE field.
+	{ extension: 'rtf', risk: 'elevated', magic: 'rtf', mimeTypes: [ 'application/rtf', 'text/rtf' ] },
+	// Archives pass when every file in them would pass on its own; they are not rewritten.
+	{ extension: 'zip', risk: 'elevated', magic: 'zip', mimeTypes: [ 'application/zip', 'application/x-zip-compressed' ] },
+	{ extension: 'tar', risk: 'elevated', magic: 'tar', mimeTypes: [ 'application/x-tar' ] },
+	{ extension: 'gz', risk: 'elevated', magic: 'gzip', mimeTypes: [ 'application/gzip', 'application/x-gzip' ] },
+	{ extension: 'tgz', risk: 'elevated', magic: 'gzip', mimeTypes: [ 'application/gzip', 'application/x-gzip', 'application/x-compressed-tar', 'application/x-gtar' ] },
+	// Reading these needs an LZMA or RAR decompressor, so only their signature is checked.
+	{ extension: 'rar', risk: 'unchecked', magic: 'rar', mimeTypes: [ 'application/vnd.rar', 'application/x-rar-compressed', 'application/x-rar' ] },
+	{ extension: '7z', risk: 'unchecked', magic: '7z', mimeTypes: [ 'application/x-7z-compressed' ] },
 ];
 
 const TYPE_BY_EXTENSION = new Map<AllowedExtension, AllowedType>(
 	ALLOWED_TYPES.map( ( type ) => [ type.extension, type ] )
 );
 
-export const ALLOWED_EXTENSIONS: readonly AllowedExtension[] = ALLOWED_TYPES.map( ( type ) => type.extension );
+/** The default list: every format of `low` risk. The others must be named in `allowedExtensions`. */
+export const ALLOWED_EXTENSIONS: readonly AllowedExtension[] = ALLOWED_TYPES.filter( ( type ) => type.risk === 'low' ).map( ( type ) => type.extension );
+
+/** The risk of accepting each format; see {@link FormatRisk}. */
+export const FORMAT_RISK: Readonly<Record<AllowedExtension, FormatRisk>> = Object.fromEntries(
+	ALLOWED_TYPES.map( ( type ) => [ type.extension, type.risk ] )
+) as Record<AllowedExtension, FormatRisk>;
 
 /** The `accept` attribute value for a file input that takes `extensions`. */
 export function acceptAttribute( extensions: readonly AllowedExtension[] = ALLOWED_EXTENSIONS ): string {
@@ -431,7 +495,7 @@ export interface UploadDescriptor {
 
 export interface UploadOptions {
 	maxBytes: number;
-	/** Narrows the built-in allowlist; defaults to every type in it. */
+	/** The formats to accept; defaults to {@link ALLOWED_EXTENSIONS}, the formats of `low` risk. */
 	allowedExtensions?: readonly AllowedExtension[];
 }
 
@@ -563,6 +627,42 @@ const MAGIC_SIGNATURES: Record<MagicFamily, ( bytes: Uint8Array ) => boolean> =
 	jpeg: ( bytes ) => startsWith( bytes, [ 0xff, 0xd8, 0xff ] ),
 	// "\x89PNG\r\n\x1A\n"
 	png: ( bytes ) => startsWith( bytes, [ 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a ] ),
+	// "GIF8", then "7a" or "9a"
+	gif: ( bytes ) => startsWith( bytes, [ 0x47, 0x49, 0x46, 0x38 ] ),
+	// "BM"
+	bmp: ( bytes ) => startsWith( bytes, [ 0x42, 0x4d ] ),
+	// Reserved 0, type 1 (icon)
+	ico: ( bytes ) => startsWith( bytes, [ 0x00, 0x00, 0x01, 0x00 ] ),
+	// An ID3 tag or an MPEG audio frame sync
+	mp3: ( bytes ) => startsWith( bytes, [ 0x49, 0x44, 0x33 ] ) || ( bytes.length >= 2 && bytes[ 0 ] === 0xff && ( bytes[ 1 ] & 0xe0 ) === 0xe0 ),
+	// "RIFF", the size, "WAVE"
+	wav: ( bytes ) => startsWith( bytes, [ 0x52, 0x49, 0x46, 0x46 ] ) && bytes.length >= 12 &&
+		startsWith( bytes.subarray( 8 ), [ 0x57, 0x41, 0x56, 0x45 ] ),
+	// An ID3 tag or an ADTS frame sync (12 bits set, MPEG layer 0)
+	aac: ( bytes ) => startsWith( bytes, [ 0x49, 0x44, 0x33 ] ) || ( bytes.length >= 2 && bytes[ 0 ] === 0xff && ( bytes[ 1 ] & 0xf6 ) === 0xf0 ),
+	// "RIFF", the size, "AVI "
+	avi: ( bytes ) => startsWith( bytes, [ 0x52, 0x49, 0x46, 0x46 ] ) && bytes.length >= 12 &&
+		startsWith( bytes.subarray( 8 ), [ 0x41, 0x56, 0x49, 0x20 ] ),
+	// The ASF Header Object GUID
+	asf: ( bytes ) => startsWith( bytes, [ 0x30, 0x26, 0xb2, 0x75, 0x8e, 0x66, 0xcf, 0x11, 0xa6, 0xd9, 0x00, 0xaa, 0x00, 0x62, 0xce, 0x6c ] ),
+	// "fLaC"
+	flac: ( bytes ) => startsWith( bytes, [ 0x66, 0x4c, 0x61, 0x43 ] ),
+	// "OggS"
+	ogg: ( bytes ) => startsWith( bytes, [ 0x4f, 0x67, 0x67, 0x53 ] ),
+	// Checked box by box when the metadata is removed, as an old movie may start with any of several boxes.
+	quicktime: ( bytes ) => bytes.length >= 8,
+	// EBML header
+	webm: ( bytes ) => startsWith( bytes, [ 0x1a, 0x45, 0xdf, 0xa3 ] ),
+	// Checked by the RTF reader, which also takes Word's shorter `{\rt`.
+	rtf: () => true,
+	// "ustar" at 257, checked by the tar reader.
+	tar: () => true,
+	gzip: ( bytes ) => startsWith( bytes, [ 0x1f, 0x8b ] ),
+	// "Rar!\x1A\x07", then 0x00 (RAR 4) or 0x01 0x00 (RAR 5)
+	rar: ( bytes ) => startsWith( bytes, [ 0x52, 0x61, 0x72, 0x21, 0x1a, 0x07, 0x00 ] ) ||
+		startsWith( bytes, [ 0x52, 0x61, 0x72, 0x21, 0x1a, 0x07, 0x01, 0x00 ] ),
+	// "7z\xBC\xAF\x27\x1C"
+	'7z': ( bytes ) => startsWith( bytes, [ 0x37, 0x7a, 0xbc, 0xaf, 0x27, 0x1c ] ),
 	// "RIFF", the size, "WEBP"
 	webp: ( bytes ) => startsWith( bytes, [ 0x52, 0x49, 0x46, 0x46 ] ) && bytes.length >= 12 &&
 		startsWith( bytes.subarray( 8 ), [ 0x57, 0x45, 0x42, 0x50 ] ),
@@ -574,11 +674,31 @@ const MAGIC_SIGNATURES: Record<MagicFamily, ( bytes: Uint8Array ) => boolean> =
 /** What an upload's bytes turned out to be; `macros` and `encrypted` get their own refusal messages. */
 export type FileContentVerdict = 'valid' | 'macros' | 'encrypted' | 'mismatch';
 
+/**
+ * A check for a file inside an archive: it must be of a format in `allowedExtensions`, not an
+ * archive itself, and pass what it would pass uploaded alone, its structure included.
+ */
+function archiveEntryCheck( allowedExtensions: readonly AllowedExtension[] ) {
+	return ( name: string, bytes: Buffer ): FileContentVerdict => {
+		const extension = getExtension( name );
+		if ( ! isAllowedExtension( extension ) || ! allowedExtensions.includes( extension ) || ARCHIVE_EXTENSIONS.has( extension ) ) {
+			return 'mismatch';
+		}
+		const verdict = inspectFileContent( extension, bytes, allowedExtensions );
+		return verdict === 'valid' && ! stripPhotoMetadata( extension, bytes ) ? 'mismatch' : verdict;
+	};
+}
+
 /**
  * Checks once that a file's bytes are what `extension` claims: the signature
  * of its family and every part a file of that kind contains, but no macros.
+ * Files inside an archive must be of a format in `allowedExtensions`.
  */
-export function inspectFileContent( extension: AllowedExtension, bytes: Uint8Array ): FileContentVerdict {
+export function inspectFileContent(
+	extension: AllowedExtension,
+	bytes: Uint8Array,
+	allowedExtensions: readonly AllowedExtension[] = ALLOWED_EXTENSIONS
+): FileContentVerdict {
 	const allowed = TYPE_BY_EXTENSION.get( extension );
 	if ( allowed?.zipEntries && ! allowed.openDocumentType && MAGIC_SIGNATURES.ole( bytes ) ) {
 		return holdsEncryptedPackage( readOleDirectory( toBuffer( bytes ) ) ) ? 'encrypted' : 'mismatch';
@@ -597,6 +717,21 @@ export function inspectFileContent( extension: AllowedExtension, bytes: Uint8Arr
 	if ( allowed.magic === 'text' ) {
 		return inspectText( content, allowed.extension === 'csv' );
 	}
+	if ( allowed.magic === 'asf' ) {
+		return inspectAsf( content, allowed.extension === 'wmv' ).verdict;
+	}
+	if ( allowed.magic === 'rtf' ) {
+		return inspectRtf( content );
+	}
+	if ( allowed.extension === 'zip' ) {
+		return inspectZipArchive( content, archiveEntryCheck( allowedExtensions ) );
+	}
+	if ( allowed.magic === 'tar' ) {
+		return inspectTarArchive( content, archiveEntryCheck( allowedExtensions ) );
+	}
+	if ( allowed.magic === 'gzip' ) {
+		return inspectGzip( content, archiveEntryCheck( allowedExtensions ), allowed.extension === 'tgz' );
+	}
 	if ( allowed.brands ) {
 		const brands = readFtypBrands( content );
 		return allowed.brands.some( ( brand ) => brands.includes( brand ) ) ? 'valid' : 'mismatch';