Deep-Dive into C2PA Architecture: How JUMBF Superboxes and caBX Manifests Embed in JPEGs

Executive Summary & Technical Architecture Overview

The Coalition for Content Provenance and Authenticity (C2PA) standard—formally codified under ISO/IEC 19566-5 (JPEG Universal Metadata Box Format or JUMBF)—represents the digital media industry's most sophisticated infrastructure for cryptographically binding origin, authorship, and editing history to digital files. In 2026, major artificial intelligence developers (OpenAI DALL-E 3, Google Gemini Imagen 3, Adobe Firefly, Midjourney, and Microsoft Designer) and camera manufacturers (Sony, Leica, Nikon, Canon) embed C2PA manifests into media containers at the point of generation or capture.

However, while C2PA was conceived to establish verifiable digital authenticity and fight malicious deepfakes, its blunt implementation across consumer social platforms (Instagram, TikTok, Facebook, and LinkedIn) has created severe unintended side effects for professional creators. Social media ingestion pipelines do not parse the nuance of a C2PA cryptographic chain; rather, they evaluate a binary check: Does an APP11 segment or caBX chunk exist? If yes, apply the 'Made with AI' or 'AI Info' label to the entire upload.

To understand how to safely inspect and strip these assertions without degrading visual quality or losing camera hardware EXIF, we must first examine the internal binary byte stream of a C2PA-bearing digital image.

Anatomy of a JPEG Container: Markers, Segments, and APP11

Every standard JPEG file is organized as a sequential series of binary segments, each delimited by a two-byte marker starting with 0xFF followed by a marker type byte:

1. SOI (Start of Image - 0xFF 0xD8): The initial two bytes of every valid JPEG stream.
2. APP0 (JFIF Header - 0xFF 0xE0): Contains basic format and pixel density parameters.
3. APP1 (EXIF & Adobe XMP - 0xFF 0xE1): Stores camera hardware TIFF headers (Make, Model, Lens, ISO, GPSInfo) and Adobe XML/RDF metadata packets.
4. APP2 through APP10: Reserved for ICC color profiles (0xFF 0xE2), FlashPix, and proprietary camera maker tags.
5. APP11 (ISO/IEC 19566-5 JUMBF / C2PA - 0xFF 0xEB): The designated marker segment where modern C2PA manifest stores are encapsulated.
6. DQT (Define Quantization Tables - 0xFF 0xDB): Compression matrices for luminance and chrominance.
7. SOF0 / SOF2 (Start of Frame - 0xFF 0xC0 / 0xC2): Image height, width, and color component parameters.
8. DHT (Define Huffman Tables - 0xFF 0xC4): Huffman encoding trees.
9. SOS (Start of Scan - 0xFF 0xDA): The transition point where raw compressed image pixel scan data begins.
10. EOI (End of Image - 0xFF 0xD9): The terminating two bytes marking file completion.

In a C2PA-signed JPEG, immediately following the SOI marker and standard APP1 EXIF segment sits one or more APP11 marker segments (0xFF 0xEB). Each segment begins with a two-byte unsigned big-endian integer indicating the length of the segment, followed by a 4-byte JUMBF Box signature.

The JUMBF Box Hierarchy: Superboxes, Descriptions, and Assertions

C2PA does not store loose JSON or XML text. Instead, it employs an ISOBMFF-derived box structure defined by ISO/IEC 19566-5. The core building block is the JUMBF Superbox, a recursive container composed of:

• 4-byte LBox (Length): The total byte length of the superbox.
• 4-byte TBox (Type): Four ASCII characters identifying the box (jumb).
• JUMBF Description Box (jumd): A mandatory child box that identifies the payload type, a UUID, request types, and an optional human-readable label. For C2PA, the UUID is c2pa.
• Payload Box: The binary content box containing the actual manifest store, typically encoded as CBOR (Concise Binary Object Representation).

Inside the CBOR payload box, the C2PA specification establishes a cryptographic tree:

`` [JPEG File] └── APP11 Segment (0xFF 0xEB) └── JUMBF Superbox ('jumb') ├── Description Box ('jumd') [UUID: C2PA Specification] └── C2PA Manifest Store Box ('c2pa') ├── Active Manifest Superbox │ ├── Claim Box ('c2cl') [CBOR format, hashes of assertions] │ ├── Claim Signature Box ('c2cs') [COSE_Sign1 with X.509 cert] │ ├── Assertion Store Superbox ('c2as') │ │ ├── c2pa.actions [e.g., 'c2pa.created', 'c2pa.edited'] │ │ ├── c2pa.hash.data [SHA-256 of image pixel byte stream] │ │ └── c2pa.thumbnail [Small embedded preview image] │ └── Credential Store Superbox [Digital signing certificate chain] └── Parent / Predecessor Manifests (Audit Trail) ``

Because the c2pa.hash.data assertion contains a cryptographic hash (such as SHA-256) of the image pixels, any alteration of a single pixel invalidates the signature. However, when an invalid or broken C2PA signature is uploaded to Instagram or TikTok, the platform does not simply ignore it; their automated pipelines detect the presence of the APP11 or c2pa marker and flag the post anyway.

Hexadecimal Inspection: What C2PA Looks Like in Binary

When opening a C2PA-signed photo from Adobe Photoshop, ChatGPT, or DALL-E 3 in a binary hex viewer, the structure is instantly recognizable:

`` Offset(h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F ASCII 00000000 FF D8 FF E1 12 34 45 78 69 66 00 00 49 49 2A 00 .Ø.á.4Exif..II*. ... [Camera EXIF Data] ... 000002A0 FF EB 1F B2 6A 75 6D 62 00 00 00 18 6A 75 6D 64 .ë.²jumb....jumd 000002B0 63 32 70 61 00 00 00 00 00 00 00 00 00 00 00 00 c2pa............ 000002C0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................ 000002D0 00 00 00 01 6A 75 6D 62 00 00 1F 80 63 32 63 6C ....jumb...€c2cl ``

Breaking down the byte sequence at offset 0x000002A0: - FF EB: The JPEG APP11 marker. - 1F B2: The 16-bit big-endian length of this marker segment (8,114 bytes). - 6A 75 6D 62: The ASCII characters jumb (JUMBF Box Type). - 00 00 00 18: The length of the child jumd box (24 bytes). - 6A 75 6D 64: The ASCII characters jumd (JUMBF Description Box). - 63 32 70 61: The identifier c2pa.

When an image is large or has an extensive edit history, a single C2PA manifest can exceed the maximum 65,535-byte limit of a single JPEG marker segment. In these cases, the specification uses JUMBF segment splitting, distributing the manifest across multiple consecutive APP11 segments (0xFF 0xEB).

Client-Side JavaScript Excision Algorithm (Pure TypedArrays)

Most online metadata tools take the brute-force approach: they load the photo into an HTML5 <canvas> element and re-encode it using canvas.toBlob('image/jpeg', 0.92). While this strips metadata, it introduces two catastrophic flaws: 1. Generational Compression Loss: The image undergoes a full lossy DCT re-quantization pass, introducing compression artifacts, color banding, and softening fine edge detail. 2. Loss of Authentic Camera EXIF: The canvas wipes out authentic binary TIFF camera data (Canon/Sony/Nikon serial numbers, lens focal length, exposure time, aperture, ISO), making the file look like a digital render rather than a camera photo.

At Clear AI Label, our in-browser engine uses a lossless byte-level excision algorithm implemented with JavaScript Uint8Array and DataView. Here is a simplified version of our core byte parser:

```javascript /** Losslessly excises C2PA APP11 (0xFFEB) segments from a JPEG Uint8Array without recompressing pixel scan data. @param {Uint8Array} fileBytes - The raw input file bytes. @returns {Uint8Array} - The cleaned JPEG bytes with 100% untouched pixels. */ function stripC2PAFromJpegLossless(fileBytes) { const view = new DataView(fileBytes.buffer, fileBytes.byteOffset, fileBytes.byteLength); // Verify JPEG SOI marker (0xFFD8) if (view.getUint16(0, false) !== 0xFFD8) { throw new Error("Invalid JPEG: Missing SOI marker"); }

const chunksToKeep = []; let offset = 2; // Start after SOI let lastRetainedOffset = 0;

while (offset < fileBytes.byteLength - 1) { // Check for marker prefix if (view.getUint8(offset) !== 0xFF) { offset++; continue; }

const marker = view.getUint8(offset + 1);

// Stop at Start of Scan (0xFFDA) or End of Image (0xFFD9) if (marker === 0xDA || marker === 0xD9) { break; }

// Markers without payload length if (marker === 0xD8 || (marker >= 0xD0 && marker <= 0xD7)) { offset += 2; continue; }

// Read 16-bit big-endian segment length (length includes the 2 length bytes) const segmentLength = view.getUint16(offset + 2, false); const segmentEnd = offset + 2 + segmentLength;

// Check if this segment is APP11 (0xFFEB) if (marker === 0xEB) { // Check if it's a JUMBF/C2PA box (inspect first 4 bytes after length) const isJumbf = view.getUint32(offset + 4, false) === 0x6A756D62; // 'jumb' if (isJumbf) { // Retain everything up to this segment chunksToKeep.push(fileBytes.subarray(lastRetainedOffset, offset)); // Skip over this APP11 segment completely lastRetainedOffset = segmentEnd; } }

offset = segmentEnd; }

// Push the remainder of the file (including SOS, pixel scan data, and EOI) chunksToKeep.push(fileBytes.subarray(lastRetainedOffset));

// Concatenate retained chunks into a single clean Uint8Array const totalLength = chunksToKeep.reduce((acc, chunk) => acc + chunk.byteLength, 0); const cleanBytes = new Uint8Array(totalLength); let writeOffset = 0; for (const chunk of chunksToKeep) { cleanBytes.set(chunk, writeOffset); writeOffset += chunk.byteLength; }

return cleanBytes; } ```

By operating purely on the container marker stream, the raw pixel bytes between SOS (0xFFDA) and EOI (0xFFD9) remain 100% bit-for-bit identical to the master camera file. There is zero generational loss, zero color shift, and the operation completes in under 15 milliseconds inside your browser's V8 JavaScript engine.

Step-by-Step Verification: Confirming C2PA Excision

To verify that your file's C2PA manifest has been cleanly eliminated before publishing to social media:

1. Before Cleaning: Drop your photo into Clear AI Label's AI Metadata Checker. The tool inspects your binary stream and flags:
   APP11 JUMBF Superbox: Detected (e.g. 14.8 KB)
   Claim Generator: Adobe Photoshop 26.0 / DALL-E 3
   Social Ingestion Prediction: "AI Info" label will be applied.
2. Execute Clean: Select Lossless Byte Strip (or AI-Only Mode if you wish to re-inject clean camera EXIF).
3. Inspect the Result: Click Inspect Details on your processed card. The before/after diff confirms:
   C2PA JUMBF Box: 0 Bytes (Stripped)
   Pixel Dimensions: Unchanged (e.g. 6000 x 4000)
   File Size Reduction: Reduced by the exact size of the excised manifest.
4. Publish Directly: Upload the sanitized Social_Ready_ image to Instagram, TikTok, or Facebook. Because the upload scanner finds no APP11 marker, the automated pipeline processes the image as a standard authentic photograph.

Frequently Asked Questions (FAQ)