C2PA Standard

The core mechanism that links provenance metadata to the content itself. A hard binding is created by hashing the asset and embedding that hash within a signed manifest. This ensures that any subsequent modification to the pixel data or audio waveform invalidates the signature. The standard supports both ingredient assertions, which track the lineage of source media, and update assertions, which record specific editing operations like cropping or color correction.

C2PA leverages the W3C Verifiable Credentials (VC) data model to structure identity claims within the manifest. A signing authority, such as a news organization or camera manufacturer, issues a cryptographically signed credential that attests to the content's origin. This allows relying parties to verify the issuer's digital signature against a Distributed Public Key Infrastructure (DPKI) without needing to trust a central certificate authority, enabling decentralized trust decisions.

The standard constructs a directed acyclic graph of ingredients that represents the complete derivation history of an asset. Each ingredient is a distinct piece of source media with its own manifest. When a composite image is created from multiple source files, the final manifest contains a chain of references to each ingredient's hash and provenance data. This allows a validator to recursively walk the entire edit graph and verify every step in the content's lifecycle.

Provenance data is embedded directly into the file container using the JPEG Universal Metadata Box Format (JUMBF) specification. This standard, defined in ISO 19566, allows the manifest to coexist with existing metadata formats like EXIF and XMP without breaking legacy parsers. The manifest is stored in a dedicated box that includes the signature block, making the provenance self-contained and portable across platforms that strip other metadata.

C2PA supports privacy-preserving workflows through redacted assertions. A manifest can contain claims that are encrypted or hashed in a way that allows a validator to prove a fact is true without revealing the underlying sensitive data. For example, a photojournalist can prove an image was captured at a specific GPS coordinate without exposing the exact location, using zero-knowledge proof techniques layered on top of the standard assertion model.

The specification defines a rigorous validation algorithm that produces a deterministic set of status codes. A validator checks the cryptographic signature chain, the integrity of each ingredient hash, and the revocation status of signing certificates. The result is not a binary pass/fail but a nuanced set of flags indicating whether the signature is valid, the certificate chain is trusted, and whether any assertions have been redacted or are stale due to certificate expiry.

The tamper-evident metadata manifest defined by the C2PA standard. It cryptographically binds assertions (who created the asset, what edits were made) to the digital content itself.

• Stored as a JWT (JSON Web Token) embedded in the file's metadata
• Contains a claim generator signature and a timestamp authority counter-signature
• Enables users to inspect the full provenance chain from capture to publication

Structured statements within a C2PA manifest that describe specific facts about the content. Each assertion is a discrete, verifiable claim.

• Creative Assertions: Author name, capture device, date created
• Action Assertions: Edits performed (e.g., c2pa.cropped, c2pa.filtered)
• Thumbnail Assertion: A visually safe, hashed preview for display in trust indicators
• Assertions can be redacted by subsequent editors while preserving signature validity

A critical C2PA dependency that cryptographically proves content existed before a specific moment. A Time Stamp Authority (TSA) signs the manifest's hash with a certified key.

• Prevents backdating attacks where a bad actor creates a fake manifest with an earlier date
• Binds the signature to a verifiable UTC timestamp
• Required for long-term validation even after original signing certificates expire

Two methods for associating a C2PA manifest with its content asset.

• Hard Binding: The manifest hash is embedded directly in the asset's file format (e.g., JPEG, PNG, AVIF). Any modification invalidates the signature. This is the standard approach.
• Soft Binding: The manifest is stored separately and linked via a content hash. Used for formats that cannot store embedded metadata or for remote provenance tracking.
• Soft binding requires a secure hash registry to prevent substitution attacks.

C2PA leverages W3C Decentralized Identifiers (DIDs) to cryptographically link a manifest signer to a real-world organization or individual.

• A DID document resolves to a public key controlled by the signer
• Enables organizational vetting through the Content Authenticity Initiative (CAI) trust list
• Distinguishes between an anonymous claim and a verified identity claim
• Prevents impersonation by binding the signature to a domain-validated or organization-validated certificate

C2PA's mechanism for documenting how multiple source assets were combined. This creates a provenance tree rather than a simple linear chain.

• Ingredient: A reference to a source file and its own C2PA manifest, linked by hash
• Composition Assertion: Declares the operation (e.g., c2pa.composite) that merged ingredients
• Enables forensic reconstruction: a viewer can trace a composite image back to each individual stock photo and verify each one's separate provenance