Struct Context 

pub struct Context { /* private fields */ }

Context holds the configuration and dependencies for C2PA operations.

Context replaces the global Settings pattern with a more flexible, thread-safe approach. It encapsulates:

• Settings: Configuration options for C2PA operations
• HTTP Resolvers: Customizable sync and async HTTP resolvers for fetching remote manifests
• Signer: The cryptographic signer used to sign manifests

Creating a Signer

There are two ways to provide a signer to a Context:

1. From Settings (recommended): Configure signer settings in your configuration, and the Context will create the signer automatically when you call signer():

[signer.local]
alg = "ps256"
sign_cert = "path/to/cert.pem"
private_key = "path/to/key.pem"

let context = Context::new()
    .with_settings(include_str!("config.toml"))?;

let builder = Builder::from_context(context);

// Signer is created automatically from context's settings
let signer = builder.context().signer()?;

2. Custom Signer: Use with_signer() to provide a custom signer directly. This is useful for HSMs, remote signing services, or custom signing logic.

Usage with Builder and Reader

Both Builder and Reader can be created with a Context:

// Create a Context with settings
let context = Context::new()
    .with_settings(r#"{"verify": {"verify_after_sign": true}}"#)?;

// Use with Builder
let builder = Builder::from_context(context);

// Get signer from context (created automatically from settings)
let signer = builder.context().signer()?;

Examples

Basic usage with default settings

let context = Context::new();

Configure with JSON settings

let context = Context::new().with_settings(r#"{"verify": {"verify_after_sign": true}}"#)?;

Configure with TOML settings

let toml = r#"
    [verify]
    verify_after_sign = true
"#;
let context = Context::new().with_settings(toml)?;

Implementations

impl Context

pub fn new() -> Self

Creates a new Context with default settings.

The default Context will load settings from environment variables or configuration files if available, and use default HTTP resolvers.

Examples

let context = Context::new();

pub fn into_shared(self) -> Arc<Self>

Consume this context and wrap it in an Arc for sharing between components.

This is equivalent to Arc::new(self) or Arc::from(self), but more discoverable and chainable with the builder pattern.

Examples

let context = Context::new()
    .with_settings(r#"{"verify": {"verify_after_sign": true}}"#)?
    .into_shared();

// Now context is Arc<Context> and can be shared
let builder = c2pa::Builder::from_shared_context(&context);
let reader = c2pa::Reader::from_shared_context(&context);

pub fn with_settings<S: IntoSettings>(self, settings: S) -> Result<Self>

Configure this Context with the provided settings.

Settings can be provided as a Settings struct, JSON string, TOML string, or serde_json::Value.

Arguments

• settings - Any type that implements IntoSettings

Examples

// From JSON string
let context = Context::new().with_settings(r#"{"verify": {"verify_after_sign": true}}"#)?;

pub fn settings(&self) -> &Settings

Returns a reference to the settings.

Examples

let context = Context::new();
let settings = context.settings();

pub fn settings_mut(&mut self) -> &mut Settings

Returns a mutable reference to the settings.

Examples

let mut context = Context::new();
context.settings_mut().verify.verify_after_sign = true;

pub fn with_resolver<T: SyncHttpResolver + Send + Sync + 'static>( self, resolver: T, ) -> Self

Available on non-WebAssembly only.

Configure this Context with a custom synchronous HTTP resolver.

Custom resolvers can be used to add authentication, caching, logging, or mock network calls in tests.

Arguments

• resolver - Any type implementing SyncHttpResolver

pub fn with_resolver_async<T: AsyncHttpResolver + Send + Sync + 'static>( self, resolver: T, ) -> Self

Available on non-WebAssembly only.

Configure this Context with a custom asynchronous HTTP resolver.

Async resolvers are used for asynchronous operations like fetching remote manifests.

Arguments

• resolver - Any type implementing AsyncHttpResolver

pub fn resolver(&self) -> &dyn SyncHttpResolver

Returns a reference to the sync resolver.

The default resolver is a SyncGenericResolver wrapped with RestrictedResolver to apply host filtering from the settings.

pub fn resolver_async(&self) -> &dyn AsyncHttpResolver

Returns a reference to the async resolver.

The default resolver is an AsyncGenericResolver wrapped with RestrictedResolver to apply host filtering from the settings.

pub fn with_signer<T: Signer + Send + Sync + 'static>(self, signer: T) -> Self

Available on non-WebAssembly only.

Configure this Context with a custom cryptographic signer.

Note: In most cases, you don’t need to call this method. Instead, configure signer settings in your configuration file, and the Context will create the signer automatically from those settings when you call signer().

Use this method when you need custom control over signer creation, such as:

• Using a hardware security module (HSM)
• Implementing custom signing logic
• Using a remote signing service with custom authentication

Arguments

• signer - Any type implementing Signer

Examples

// Explicitly create and set a signer
let signer = create_signer::from_files(
    "path/to/cert.pem",
    "path/to/key.pem",
    SigningAlg::Ps256,
    None
)?;

let context = Context::new().with_signer(signer);

pub fn signer(&self) -> Result<&dyn Signer>

Returns a reference to the signer.

If a signer was explicitly set via with_signer(), returns that signer. Otherwise, creates a signer from this Context’s settings on first access (lazy initialization).

The signer is created from the signer field in this Context’s Settings, which should contain either local signer configuration (certificate and private key) or remote signer configuration (URL and certificate).

Returns

A reference to the signer.

Errors

Returns Error::MissingSignerSettings if:

• No signer was explicitly set with with_signer()
• No signer configuration is present in this Context’s settings
• The signer configuration in settings is invalid

Examples

Creating from settings (recommended)

let toml = r#"
    [signer.local]
    alg = "ps256"
    sign_cert = "path/to/cert.pem"
    private_key = "path/to/key.pem"
"#;

let context = Context::new().with_settings(toml)?;

// Signer is created automatically from context's settings
let signer = context.signer()?;

Using a custom signer

let signer = create_signer::from_files(
    "path/to/cert.pem",
    "path/to/key.pem",
    SigningAlg::Ps256,
    None
)?;

let context = Context::new().with_signer(signer);
let signer_ref = context.signer()?;

pub fn async_signer(&self) -> Result<&dyn AsyncSigner>

Returns a reference to the async signer.

If a custom async signer was set with Context::with_async_signer, it will be returned. Otherwise, the async signer will be created from the context’s settings on first access and cached for future use.

Errors

Returns an error if no async signer is configured in settings and no custom signer was provided.

Examples

let context = Context::new();
let async_signer = context.async_signer()?;
let signature = async_signer.sign(vec![1, 2, 3]).await?;

pub fn with_async_signer( self, signer: impl AsyncSigner + Send + Sync + 'static, ) -> Self

Available on non-WebAssembly only.

Sets a custom async signer for this Context.

This replaces any existing async signer (whether from settings or previously set).

Arguments

• signer - An async signer that implements the AsyncSigner trait

Examples

let context = Context::new()
    .with_async_signer(MyAsyncSigner);

Trait Implementations

impl Debug for Context

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

Formats the value using the given formatter.

impl Default for Context

fn default() -> Self

Returns the “default value” for a type.