Struct c2pa::Manifest

pub struct Manifest {
    pub claim_generator: String,
    pub claim_generator_info: Option<Vec<ClaimGeneratorInfo>>,
    /* private fields */
}

A Manifest represents all the information in a c2pa manifest

Fields

claim_generator: String

A User Agent formatted string identifying the software/hardware/system produced this claim Spaces are not allowed in names, versions can be specified with product/1.0 syntax

claim_generator_info: Option<Vec<ClaimGeneratorInfo>>

Implementations

impl Manifest

pub fn new<S: Into<String>>(claim_generator: S) -> Self

Create a new Manifest requires a claim_generator string (User Agent))

pub fn claim_generator(&self) -> &str

Returns a User Agent formatted string identifying the software/hardware/system produced this claim

pub fn label(&self) -> Option<&str>

returns the manifest label for this Manifest, as referenced in a ManifestStore

pub fn format(&self) -> &str

Returns a MIME content_type for the asset associated with this manifest.

pub fn instance_id(&self) -> &str

Returns the instance identifier.

pub fn title(&self) -> Option<&str>

Returns a user-displayable title for this manifest

pub fn thumbnail(&self) -> Option<(&str, Cow<'_, Vec<u8>>)>

Returns thumbnail tuple with Some((format, bytes)) or None

pub fn thumbnail_ref(&self) -> Option<&ResourceRef>

Returns a thumbnail ResourceRef or None.

pub fn ingredients(&self) -> &[Ingredient]

Returns immutable Ingredients used by this Manifest This can include a parent as well as any placed assets

pub fn ingredients_mut(&mut self) -> &mut [Ingredient]

Returns mutable Ingredients used by this Manifest This can include a parent as well as any placed assets

pub fn assertions(&self) -> &[ManifestAssertion]

Returns Assertions for this Manifest

pub fn credentials(&self) -> Option<&[Value]>

Returns Verifiable Credentials

pub fn remote_manifest_url(&self) -> Option<&str>

Returns the remote_manifest Url if there is one This is only used when creating a manifest, it will always be None when reading

pub fn set_vendor<S: Into<String>>(&mut self, vendor: S) -> &mut Self

Sets the vendor prefix to be used when generating manifest labels Optional prefix added to the generated Manifest Label This is typically a lower case Internet domain name for the vendor (i.e. adobe)

pub fn set_label<S: Into<String>>(&mut self, label: S) -> &mut Self

Sets the label for this manifest A label will be generated if this is not called This is needed if embedding a URL that references the manifest label

pub fn set_claim_generator<S: Into<String>>( &mut self, generator: S ) -> &mut Self

Sets a human readable name for the product that created this manifest

pub fn set_format<S: Into<String>>(&mut self, format: S) -> &mut Self

Sets a human-readable title for this ingredient.

pub fn set_instance_id<S: Into<String>>(&mut self, instance_id: S) -> &mut Self

Sets a human-readable title for this ingredient.

pub fn set_title<S: Into<String>>(&mut self, title: S) -> &mut Self

Sets a human-readable title for this ingredient.

pub fn set_thumbnail_ref(&mut self, thumbnail: ResourceRef) -> Result<&mut Self>

Sets the thumbnail from a ResourceRef.

pub fn set_thumbnail<S: Into<String>, B: Into<Vec<u8>>>( &mut self, format: S, thumbnail: B ) -> Result<&mut Self>

Sets the thumbnail format and image data.

pub fn set_sidecar_manifest(&mut self) -> &mut Self

If set, the embed calls will create a sidecar .c2pa manifest file next to the output file No change will be made to the output file

pub fn set_remote_manifest<S: Into<String>>( &mut self, remote_url: S ) -> &mut Self

If set, the embed calls will put the remote url into the output file xmp provenance and create a c2pa manifest file next to the output file

pub fn set_embedded_manifest_with_remote_ref<S: Into<String>>( &mut self, remote_url: S ) -> &mut Self

If set, the embed calls will put the remote url into the output file xmp provenance and will embed the manifest into the output file

pub fn signature_info(&self) -> Option<&SignatureInfo>

pub fn parent(&self) -> Option<&Ingredient>

Returns the parent ingredient if it exists

pub fn set_parent(&mut self, ingredient: Ingredient) -> Result<&mut Self>

Sets the parent ingredient, assuring it is first and setting the is_parent flag

pub fn add_ingredient(&mut self, ingredient: Ingredient) -> &mut Self

Add an ingredient removing duplicates (consumes the asset)

pub fn add_labeled_assertion<S: Into<String>, T: Serialize>( &mut self, label: S, data: &T ) -> Result<&mut Self>

Adds assertion using given label and any serde serializable The data for predefined assertions must be in correct format

Example: Creating a custom assertion from a serde_json object.

 use c2pa::Manifest;
 use serde_json::json;
 let mut manifest = Manifest::new("my_app");
 let value = json!({"my_tag": "Anything I want"});
 manifest.add_labeled_assertion("org.contentauth.foo", &value)?;

pub fn add_assertion<T: Serialize + AssertionBase>( &mut self, data: &T ) -> Result<&mut Self>

Adds ManifestAssertions from existing assertions The data for standard assertions must be in correct format

Example: Creating a from an Actions object.

 use c2pa::{
     assertions::{c2pa_action, Action, Actions},
     Manifest,
 };
 let mut manifest = Manifest::new("my_app");
 let actions = Actions::new().add_action(Action::new(c2pa_action::EDITED));
 manifest.add_assertion(&actions)?;

pub fn find_assertion<T: DeserializeOwned>(&self, label: &str) -> Result<T>

Retrieves an assertion by label if it exists or Error::NotFound

Example: Find an Actions Assertion

use c2pa::{
    assertions::{c2pa_action, Action, Actions},
    Manifest,
};
let mut manifest = Manifest::new("my_app");
let actions = Actions::new().add_action(Action::new(c2pa_action::EDITED));
manifest.add_assertion(&actions)?;

let actions: Actions = manifest.find_assertion(Actions::LABEL)?;
for action in actions.actions {
    println!("{}", action.action());
}

pub fn find_assertion_with_instance<T: DeserializeOwned>( &self, label: &str, instance: usize ) -> Result<T>

Retrieves an assertion by label and instance if it exists or Error::NotFound

pub fn add_redaction<S: Into<String>>(&mut self, label: S) -> Result<&mut Self>

Redacts an assertion from the parent Ingredient of this manifest using the provided assertion label.

pub fn add_verifiable_credential<T: Serialize>( &mut self, data: &T ) -> Result<&mut Self>

Add verifiable credentials

pub fn issuer(&self) -> Option<String>

Returns the name of the signature issuer

pub fn time(&self) -> Option<String>

Returns the time that the manifest was signed

pub fn resources(&self) -> &ResourceStore

Return an immutable reference to the manifest resources

pub fn resources_mut(&mut self) -> &mut ResourceStore

Return a mutable reference to the manifest resources

pub fn from_json(json: &str) -> Result<Self>

Creates a Manifest from a JSON string formatted as a Manifest

pub fn with_base_path<P: AsRef<Path>>(&mut self, base_path: P) -> Result<&Self>

Available on crate feature file_io only.

Setting a base path will make the manifest use resource files instead of memory buffers

The files will be relative to the given base path Ingredients resources will also be relative to this path

pub fn set_asset_from_path<P: AsRef<Path>>(&mut self, path: P) -> Result<()>

Available on crate feature file_io only.

Sets the asset field from data in a file the information in the claim should reflect the state of the asset it is embedded in this method can be used to ensure that data is correct it will extract filename,format and xmp info and generate a thumbnail

pub fn embed<P: AsRef<Path>>( &mut self, source_path: P, dest_path: P, signer: &dyn Signer ) -> Result<Vec<u8>>

Available on crate feature file_io only.

Embed a signed manifest into the target file using a supplied signer.

Example: Embed a manifest in a file

use c2pa::{create_signer, Manifest, SigningAlg};
use serde::Serialize;

#[derive(Serialize)]
struct Test {
    my_tag: usize,
}

let mut manifest = Manifest::new("my_app".to_owned());
manifest.add_labeled_assertion("org.contentauth.test", &Test { my_tag: 42 })?;

// Create a PS256 signer using certs and public key files.
let signcert_path = "tests/fixtures/certs/ps256.pub";
let pkey_path = "tests/fixtures/certs/ps256.pem";
let signer = create_signer::from_files(signcert_path, pkey_path, SigningAlg::Ps256, None)?;

// Embed a manifest using the signer.
manifest.embed("tests/fixtures/C.jpg", "../target/test_file.jpg", &*signer)?;

pub fn embed_from_memory( &mut self, format: &str, asset: &[u8], signer: &dyn Signer ) -> Result<Vec<u8>>

Embed a signed manifest into a stream using a supplied signer. returns the bytes of the manifest that was embedded

pub fn embed_stream( &mut self, format: &str, stream: &mut dyn CAIRead, signer: &dyn Signer ) -> Result<Vec<u8>>

👎Deprecated since 0.27.2: use embed_to_stream instead

Embed a signed manifest into a stream using a supplied signer.

Returns the bytes of the new asset

pub fn embed_to_stream( &mut self, format: &str, source: &mut dyn CAIRead, dest: &mut dyn CAIReadWrite, signer: &dyn Signer ) -> Result<Vec<u8>>

Embed a signed manifest into a stream using a supplied signer.

Returns the bytes of c2pa_manifest that was embedded.

pub async fn embed_from_memory_remote_signed( &mut self, format: &str, asset: &[u8], signer: &dyn RemoteSigner ) -> Result<(Vec<u8>, Vec<u8>)>

Embed a signed manifest into a stream using a supplied signer. returns the asset generated and bytes of the manifest that was embedded

pub async fn embed_async_signed<P: AsRef<Path>>( &mut self, source_path: P, dest_path: P, signer: &dyn AsyncSigner ) -> Result<Vec<u8>>

Available on crate feature file_io only.

Embed a signed manifest into the target file using a supplied AsyncSigner.

pub async fn embed_remote_signed<P: AsRef<Path>>( &mut self, source_path: P, dest_path: P, signer: &dyn RemoteSigner ) -> Result<Vec<u8>>

Available on crate feature file_io only.

Embed a signed manifest into the target file using a supplied RemoteSigner.

pub fn remove_manifest<P: AsRef<Path>>(asset_path: P) -> Result<()>

Available on crate feature file_io only.

Removes any existing manifest from a file

This should only be used for special cases, such as converting an embedded manifest to a cloud manifest

pub fn data_hash_placeholder( &mut self, reserve_size: usize, format: &str ) -> Result<Vec<u8>>

Generates a data hashed placeholder manifest for a file

The return value is pre-formatted for insertion into a file of the given format For JPEG it is a series of App11 JPEG segments containing space for a manifest This is used to create a properly formatted file ready for signing. The reserve_size is the amount of space to reserve for the signature box. This value is fixed once set and must be sufficient to hold the completed signature

pub fn data_hash_embeddable_manifest( &mut self, dh: &DataHash, signer: &dyn Signer, format: &str, asset_reader: Option<&mut dyn CAIRead> ) -> Result<Vec<u8>>

Generates an data hashed embeddable manifest for a file

The return value is pre-formatted for insertion into a file of the given format For JPEG it is a series of App11 JPEG segments containing a signed manifest This can directly replace a placeholder manifest to create a properly signed asset The data hash must contain exclusions and may contain pre-calculated hashes if an asset reader is provided, it will be used to calculate the data hash

pub async fn data_hash_embeddable_manifest_remote( &mut self, dh: &DataHash, signer: &dyn RemoteSigner, format: &str, asset_reader: Option<&mut dyn CAIRead> ) -> Result<Vec<u8>>

Generates an data hashed embeddable manifest for a file

The return value is pre-formatted for insertion into a file of the given format For JPEG it is a series of App11 JPEG segments containing a signed manifest This can directly replace a placeholder manifest to create a properly signed asset The data hash must contain exclusions and may contain pre-calculated hashes if an asset reader is provided, it will be used to calculate the data hash

pub fn box_hash_embeddable_manifest( &mut self, signer: &dyn Signer, format: Option<&str> ) -> Result<Vec<u8>>

Generates a signed box hashed manifest, optionally preformatted for embedding

The manifest must include a box hash assertion with correct hashes

pub fn composed_manifest(manifest_bytes: &[u8], format: &str) -> Result<Vec<u8>>

Formats a signed manifest for embedding in the given format

For instance, this would return one or JPEG App11 segments containing the manifest

Trait Implementations

impl Debug for Manifest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Manifest

fn default() -> Manifest

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Manifest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Manifest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl JsonSchema for Manifest

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl Serialize for Manifest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.