Struct SignableSigner

pub struct SignableSigner<'a> { /* private fields */ }

A single invocation of a signing operation.

Instances are constructed from a Signer and Signability result and are used to sign a single item. Instances can be customized to tailor signing just the entity in question.

Implementations

impl<'a> SignableSigner<'a>

pub fn signable(&self) -> &Signable

Obtain a reference to the underlying Signable.

pub fn in_place_destination(&self) -> SigningDestination

Obtain a SigningDestination that is the same as the input.

pub fn as_apple_signing_settings( &self, ) -> Result<SigningSettings<'_>, SigningError>

Obtain a apple_codesign::SigningSettings from this instance.

pub fn as_windows_signer(&self) -> Result<SigntoolSign, SigningError>

Obtain a tugger_windows_codesign::SigntoolSign from this instance.

pub fn destination_compatibility( &self, destination: &SigningDestination, ) -> SigningDestinationCompatibility

Compute SigningDestinationCompatibility with a given SigningDestination.

This takes the current to-be-signed entity into account.

pub fn sign( &self, temp_dir: Option<&Path>, destination: &SigningDestination, ) -> Result<SignedOutput, SigningError>

Signs this signable entity to the given destination.

Callers should probably verify destination compatibility by calling [Self.destination_compatibility] first. But we will turn it into an Err if the destination isn’t compatibile.

temp_dir denotes the path of a writable directory where temporary files can be created, as needed. If not provided, a new temporary directory will be managed. In all cases, we attempt to remove temporary files as part of execution.

pub fn requires_temporary_files(&self, destination: &SigningDestination) -> bool

Whether signing to the specified SigningDestination will require temporary files.

Temporary files are used when:

• Signed content lives in memory and signer only supports signing files. (e.g. signtool.exe)
• We are sending output to the filesystem and the destination path isn’t the source path. We could write directly to the destination. However, we choose to play it safe and only write to the destination after signing success. By going through a temporary directory, we prevent polluting the destination with corrupted results.