Metadata Removal: Files, Images and Documents

OpSec 9 min en 14

Master metadata removal for OpSec. Learn deep sanitization mechanisms for images, PDFs, and Office files using ExifTool, MAT2, and pixel-level rasterizatio

On this page

Every digital artifact carries a persistent shadow of forensic information known as metadata. While content represents what a creator intentionally communicates, metadata documents the underlying mechanics: the physical sensor that captured an image, the software build that compiled a text document, revision lineages, internal network paths, and exact geographic coordinates. In high-threat operational security (OpSec) contexts—such as investigative journalism, human rights advocacy, and offensive security red-teaming—unstripped metadata represents an acute deanonymization vector. Effectively neutralizing this data requires moving beyond superficial "clear properties" dialogues and understanding how file formats serialize structured metadata down to byte offsets and container specifications.

The Structural Taxonomy of File Metadata

Metadata is not monolithic; it exists in discrete layers defined by international standards, proprietary container formats, and operating system file systems. Addressing file privacy requires differentiating between internal file metadata (embedded directly inside the byte stream) and external file system metadata (managed by file system tables like NTFS, ext4, or APFS).

Raster and Vector Images

Modern images encapsulate metadata across several standardized data structures embedded within specific format markers or chunks:

  • EXIF (Exchangeable Image File Format): Typically residing in the APP1 marker segment of JPEG files (starting at byte offset 0xFFE1) or within TIFF header tags. EXIF records hardware specifications (camera make, model, lens profile), exposure telemetry (ISO, shutter speed, aperture), serial numbers, and high-precision GPS coordinates (WGS 84 latitude, longitude, altitude, and timestamps).
  • IPTC-IIM (Information Interchange Model): Legacy structural metadata often used by media organizations to embed editorial details, copyright notices, captions, and subject keywords.
  • XMP (Extensible Metadata Platform): An ISO standard (ISO 16684-1) developed by Adobe that serializes metadata as XML. XMP can be embedded in almost any media format (JPEG, PNG, TIFF, PDF) and frequently records non-destructive edit histories, including internal UUIDs, document ancestors, and local file paths of asset dependencies.
  • Ancillary Chunks: PNG files utilize chunk-based storage where critical chunks handle rendering (IHDR, IDAT, IEND) and ancillary chunks store operational context (tEXt, zTXt, iTXt, and eXIf). Text chunks frequently leak creation software signatures and host OS details.

Complex Office Documents

Legacy Microsoft Office formats (Binary Interchange File Format or BIFF, such as .doc, .xls) rely on OLE Compound File Binary (CFBF) structures, which contain distinct streams such as \x05SummaryInformation. These streams store author names, last-modified-by accounts, total editing time, revision counts, and internal network printer destinations.

Modern office files (Microsoft Office OpenXML like .docx, .xlsx and OpenDocument Formats like .odt) are zipped archives containing structured XML documents. Critical metadata resides within distinct files:

  • docProps/core.xml: Houses Dublin Core properties including dc:creator, cp:lastModifiedBy, and ISO 8601 timestamps.
  • docProps/app.xml: Details the precise application version, build number, template dependencies, and structural counts (paragraphs, lines, words).
  • word/settings.xml and word/document.xml: Can retain Revision Save IDs (rsidR, rsidRPr), which assign unique hex identifiers to specific editing sessions, enabling analysts to reconstruct the chronological sequence and multi-author provenance of a text.

Portable Document Format (PDF)

PDF metadata is governed by two concurrent structures: the Info Dictionary and the Metadata Stream. The Info Dictionary is a set of key-value pairs (e.g., /Title, /Author, /Creator, /Producer, /CreationDate) referenced from the document's catalog. In modern PDFs conforming to PDF/A or version 1.4+, this is supplemented or superseded by an XMP packet embedded inside a designated stream object (/Type /Metadata /Subtype /XML). Deleting the Info Dictionary while failing to clear the XMP stream leaves complete author identity records intact.

Critical Attack Vectors and Deanonymization Mechanisms

Understanding why metadata stripping is critical requires analyzing how adversaries exploit passive technical disclosures.

Embedded Thumbnail Desynchronization

A frequent catastrophic failure occurs when an image is cropped or visually redacted, but the software fails to regenerate the embedded thumbnail stored in the EXIF IFD1 block or XMP metadata. Forensic investigators routinely extract intact, uncropped, and unredacted originals directly from the thumbnail bytes embedded in the header, completely undermining intended visual redactions.

Linearized PDFs and Incremental Saves

The PDF specification supports incremental updates. When changes are made (such as placing a black shape over sensitive text or clearing a field), the PDF engine often appends an updated cross-reference (xref) table and new objects to the end of the file, leaving the original objects and streams intact earlier in the byte structure. Simple text extraction via basic tools can recover the underlying strings because the original content stream was never overwritten—merely visually superseded.

Unique Hardware and Cryptographic Fingerprints

Modern smartphone cameras and digital bodies embed internal device identifiers, including sensor serial numbers, lens IDs, and firmware revisions. These signatures allow investigators to correlate separate images published across disparate platforms to a singular, physical camera body. Similarly, machine identification codes (such as color laser printer tracking yellow dots) encode machine serial numbers, dates, and times directly across physical and scanned pages.

Deep Sanitization Protocols: Images

Surface-level sanitization (such as Windows "Remove Properties and Personal Information") often leaves proprietary vendor tags (e.g., MakerNotes) intact. Defensive security mandates deterministic, low-level inspection and stripping.

ExifTool Deep Inspection and Scrubbing

The standard reference for metadata analysis is Phil Harvey’s ExifTool. To inspect every byte tag, including unrecognized vendor MakerNotes:

exiftool -G -a -s -u sample.jpg

The parameters -G (show group name), -a (allow duplicate tags), -s (show tag names instead of descriptions), and -u (extract unknown tags) ensure no obfuscated data remains hidden.

To perform an exhaustive scrub of all metadata groups (EXIF, IPTC, XMP, MakerNotes):

exiftool -all= --icc_profile:all -overwrite_original target.jpg

Note on Color Profiles: The flag --icc_profile:all instructs ExifTool to preserve the International Color Consortium profile. While color profiles can occasionally contain proprietary vendor comments (which can be stripped specifically), wholesale removal of the ICC profile can result in severe color distortion and gamma shifts upon decoding.

Lossless Pixel-Stream Re-encoding

When operational constraints demand absolute certainty against header-based exploits or zero-day parser vulnerabilities, the safest posture is stripping all metadata by isolating the raw pixel data and re-encoding it in a sterile environment:

# Decode image directly into an uncompressed PAM/PPM stream and re-encode
ffmpeg -i input.jpg -map_metadata -1 -vf "format=yuvj420p" -q:v 2 output.jpg

This process discards all proprietary container markers, metadata streams, and custom segments, forcing the reconstructed file to contain strictly the newly generated structural decoding blocks.

Document Sanitization and True Redaction

Sanitizing documents requires treating text containers as complex databases rather than flat text representations.

Office OpenXML (OOXML) Unpacking and Purging

Automated scripts or deliberate analysts can inspect modern Office files using basic decompression utilities. To manually eliminate tracking structures:

  1. Unpack the archive: unzip document.docx -d unzipped_doc/
  2. Remove properties files: rm -f unzipped_doc/docProps/core.xml unzipped_doc/docProps/app.xml unzipped_doc/docProps/custom.xml
  3. Sanitize revision IDs in the main text stream: Open unzipped_doc/word/document.xml and use regex substitution to eliminate all occurrences of w:rsidR="[A-Fa-f0-9]{8}" and w:rsidRPr="[A-Fa-f0-9]{8}".
  4. Repack the structure: cd unzipped_doc && zip -r -D ../sanitized.docx *

The Dangerzone Methodology: Structural Disinfection

Simple PDF redaction plugins are prone to implementation failure. True redaction requires pixel-level destruction of underlying layout information. Freedom of the Press Foundation's tool Dangerzone implements a defensive architectural pattern that should be the gold standard for high-risk document sanitization:

  1. The suspect document is transferred to an isolated, unprivileged, network-isolated container (or sandbox).
  2. The container uses a rendering engine (like Poppler or GraphicsMagick) to rasterize every single page into raw, uncompressed RGB/RGBA pixel bitmaps.
  3. All structural vectors, hidden text layers, embedded fonts, JavaScript objects, form fields, and incremental updates are irrevocably destroyed during the rendering phase.
  4. The raw pixel bitmaps are copied from the sandbox to a secondary, independent container.
  5. The secondary container compiles the sterile pixel bitmaps back into a brand-new, clean PDF. Optional optical character recognition (OCR) can be applied locally using Tesseract to restore selectable text safely without preserving historical streams.

A minimal CLI pipeline executing this concept using pdftoppm and ImageMagick/Ghostscript:

# Step 1: Render pages to pristine PNG bitmaps (300 DPI)
pdftoppm -png -r 300 sensitive_source.pdf /tmp/page

# Step 2: Reconstruct sanitized PDF from flat images
img2pdf /tmp/page-*.png -o sterile_output.pdf

# Step 3: Securely wipe temporary page buffers
shred -u -z -n 3 /tmp/page-*.png

Automating OpSec with MAT2

For scalable, multidisciplinary pipelines, the Metadata Anonymisation Toolkit v2 (MAT2) provides a Python-based engine tailored specifically for defensive hygiene. MAT2 parses formats natively, strips metadata deterministically, and re-encodes files into clean specifications.

# Check for present metadata without modifying
mat2 --show target_file.pdf

# Strip all metadata in-place
mat2 --inplace target_file.pdf target_file.png document.docx

MAT2 handles complex nested structures: it unzips archives, recursively strips discovered contents (including media nested inside presentation decks or word processing files), normalizes XML structures, and safely repacks the archive.

File System and Protocol Leaks (Residual Risk)

Cleaning the internal bits of an image or document is only half the battle. File systems and network transfer protocols generate parallel metadata layers that must be proactively mitigated before file distribution.

Operating System Timestamps and Extended Attributes

When an operating system accesses, creates, or modifies a file, it records temporal and provenance data directly onto the disk partition:

  • MACB Timestamps: Modification, Access, Change (inode), and Birth/Creation dates. While modifying a file changes the mtime, the file creation date (btime on ext4/APFS) or inode change date (ctime on POSIX) often retains an immutable record of when the file was processed on that machine.
  • Extended Attributes (xattrs): On macOS, files downloaded from web browsers receive a com.apple.quarantine attribute encoding the download timestamp, the browser binary, and the originating URL. Linux desktop managers frequently assign tags via user.xdg.origin.url.

To inspect and clear extended attributes on Linux:

# Read extended attributes
getfattr -d target_file.jpg

# Remove all extended attributes recursively
attr -r target_file.jpg

On macOS systems:

# Remove quarantine and metadata attributes
xattr -c target_file.pdf

Defensive Hygiene: The Volatile Staging Paradigm

To guarantee that external metadata does not attach to files destined for publication or transmission:

  • Perform all extraction, stripping, and re-encoding within a ramdisk or tmpfs partition (e.g., mount -t tmpfs -o size=512M tmpfs /mnt/secure_scratch). RAM-backed file systems do not write permanent inodes to physical storage blocks, precluding forensic timestamp recovery via unallocated disk space analysis.
  • Standardize file modification timestamps across your batch before dissemination using the POSIX touch utility: 
    touch -t 202001010000.00 sanitized_*
    This normalizes the modification and access records across all staged files to a static historical baseline.
  • Rename all release artifacts with deterministic, non-identifying naming conventions (e.g., SHA-256 hashes or sequential numbering) to ensure internal workstation paths, original camera naming schemes (e.g., IMG_4302.CR2), or project codenames are not inadvertently leaked via the file header or file system catalog.

Conclusion

Metadata removal is not an aesthetic task accomplished through graphical file properties dialogs; it is a fundamental discipline of software isolation, format parsing, and data sanitization. Because contemporary document and media containers are inherently complex databases designed to maximize author collaboration and contextual telemetry, they are naturally hostile to passive anonymity. Implementing an uncompromising operational security stance requires treating all original files as contaminated environments. Users must leverage rigorous deep-cleaning engines like ExifTool and MAT2, enforce absolute architectural sanitization via image rasterization pipelines like Dangerzone, and stage all distributions from sanitized, memory-backed filesystems.

Keywords
metadata removalOpSecExifTooldocument sanitizationPDF metadataimage scrubbingMAT2operational security