Ingredient Assertion

An Ingredient Assertion cryptographically references a specific source file through its asset hash, creating a tamper-evident link between the ingredient and the final composite. This binding ensures that any alteration to the original source—even a single pixel or byte—invalidates the provenance chain.

• Uses SHA-256 hashing to generate a unique content fingerprint
• The hash is stored within the manifest's ingredient field alongside metadata
• Enables validators to mathematically verify the exact source file was used

Each Ingredient Assertion specifies a relationship type that defines how the source media contributed to the final asset. This transforms a flat list of sources into a machine-readable provenance data model.

• componentOf: The ingredient is a direct, composited part of the final work
• inputTo: The ingredient served as input to a generative or transformative process
• Captures the directed acyclic graph (DAG) of media creation

An ingredient can itself carry a complete C2PA manifest from its own creation. This recursive structure allows a final asset's credential to surface the full, multi-generational edit history of every source file, not just a flat list.

• Enables deep provenance chain traversal
• A stock photo with its own C2PA data retains its creator attribution when composited
• Validators can recursively verify each ingredient's own signature chain

Beyond the cryptographic hash, an Ingredient Assertion carries descriptive metadata about the source media, including its title, format, and the specific actions applied during integration. This provides human-readable context for the technical lineage.

• Documents the software agent used for compositing
• Records transformation parameters like scaling or color space conversion
• Supports Action Assertions to describe edits made to the ingredient before finalization

While hard binding embeds the ingredient's hash directly, soft binding allows an Ingredient Assertion to reference source media stored externally through a content hash URI. This is critical for workflows where embedding large source files is impractical.

• Uses the hashlink URI scheme to reference external assets
• The validator fetches the remote asset and verifies its hash matches the assertion
• Enables cloud-native provenance for high-resolution video and complex composites

During provenance verification, a validator engine must recursively process every Ingredient Assertion. For each ingredient, the engine checks the claim signature of its own manifest, validates its certificate chain, and confirms the hash of the referenced asset matches the recorded value.

• A single broken ingredient chain can flag the entire composite for review
• Validators check revocation status of all signing certificates in the chain
• The final trust decision depends on the verifier's configured trust list

A structured, digitally signed statement within a C2PA manifest that makes a specific claim about the content. An Ingredient Assertion is one type of manifest assertion, alongside others like Action Assertions (describing edits) and Identity Assertions (linking to a creator). Each assertion is individually hashed and collectively signed to form the manifest's claim set.

The complete, end-to-end sequence of cryptographically linked manifests that traces a digital asset's entire history. Each link in the chain represents a state change:

• Initial creation: The first manifest with a creator identity assertion
• Ingredient import: A manifest asserting that external source media was incorporated
• Edit action: A manifest recording a transformation (crop, resize, composite)
• Final publication: The terminal manifest, binding all prior history

Altering any prior manifest breaks the cryptographic hash chain, making tampering immediately detectable.

A method of provenance attachment where the cryptographically signed manifest is embedded directly into the binary structure of the asset file itself. C2PA uses the JUMBF (JPEG Universal Metadata Box Format) container to embed manifests into JPEG, PNG, and other formats. Hard binding ensures:

• The provenance data travels with the file
• No external dependencies for verification
• Resistance to accidental separation of asset and metadata

Contrast with Soft Binding, where the manifest is stored as a sidecar file or cloud URL.

A cryptographic digital signature generated over the complete set of assertions in a manifest. The signature binds all assertions—including any Ingredient Assertions—to a specific identity and ensures:

• Integrity: Any modification to an assertion invalidates the signature
• Non-repudiation: The signer cannot deny having made the claim
• Authenticity: The signature can be traced to a verified identity via an X.509 Certificate chain

The signing process hashes the assertion set, then encrypts the hash with the signer's private key.

The software component that performs cryptographic verification of a content credential. When validating an Ingredient Assertion, the engine:

• Verifies the Claim Signature against the signer's public key
• Validates the X.509 Certificate chain to a trusted root
• Performs a Revocation Check via OCSP to ensure the certificate is still valid
• Confirms the signer is on the configured Trust List
• Recomputes all Asset Hashes to detect tampering

Only after all checks pass is the provenance chain displayed as verified.

A visual representation of the Provenance Chain as a directed acyclic graph (DAG). Unlike a simple linear chain, a DAG can represent complex compositions where multiple Ingredient Assertions feed into a single composite output. Each node represents a state of the asset, and each edge represents an action or ingredient import. This graph structure enables:

• Tracing any final asset back to all source ingredients
• Identifying which source contributed which visual element
• Auditing the complete lineage for journalistic or legal verification