Struct apple_codesign::remote_signing::session_negotiation::PublicKeyInitiator

pub struct PublicKeyInitiator { /* private fields */ }

Implementations

impl PublicKeyInitiator

pub fn new(
    peer_public_key: impl AsRef<[u8]>,
    server_url: Option<String>
) -> Result<Self, RemoteSignError>

Create a new initiator using public key agreement.

Examples found in repository

src/cli.rs (lines 518-521)

fn get_remote_signing_initiator(
    args: &ArgMatches,
) -> Result<Box<dyn SessionInitiatePeer>, RemoteSignError> {
    let server_url = args
        .get_one::<String>("remote_signing_url")
        .map(|x| x.to_string());

    if let Some(public_key_data) = args.get_one::<String>("remote_public_key") {
        let public_key_data = base64::decode(public_key_data)?;

        Ok(Box::new(PublicKeyInitiator::new(
            public_key_data,
            server_url,
        )?))
    } else if let Some(path) = args.get_one::<String>("remote_public_key_pem_file") {
        let pem_data = std::fs::read(path)?;
        let doc = pem::parse(pem_data)?;

        let spki_der = match doc.tag.as_str() {
            "PUBLIC KEY" => doc.contents,
            "CERTIFICATE" => {
                let cert = CapturedX509Certificate::from_der(doc.contents)?;
                cert.to_public_key_der()?.as_ref().to_vec()
            }
            tag => {
                error!(
                    "unknown PEM format: {}; only `PUBLIC KEY` and `CERTIFICATE` are parsed",
                    tag
                );
                return Err(RemoteSignError::Crypto("invalid public key data".into()));
            }
        };

        Ok(Box::new(PublicKeyInitiator::new(spki_der, server_url)?))
    } else if let Some(env) = args.get_one::<String>("remote_shared_secret_env") {
        let secret = std::env::var(env).map_err(|_| {
            RemoteSignError::ClientState("failed reading from shared secret environment variable")
        })?;

        Ok(Box::new(SharedSecretInitiator::new(
            secret.as_bytes().to_vec(),
        )?))
    } else if let Some(value) = args.get_one::<String>("remote_shared_secret") {
        Ok(Box::new(SharedSecretInitiator::new(
            value.as_bytes().to_vec(),
        )?))
    } else {
        error!("no arguments provided to establish session with remote signer");
        error!(
            "specify --remote-public-key, --remote-shared-secret-env, or --remote-shared-secret"
        );
        Err(RemoteSignError::ClientState(
            "unable to initiate remote signing",
        ))
    }
}

Trait Implementations

impl SessionInitiatePeer for PublicKeyInitiator

fn session_id(&self) -> &str

Obtain the session ID to create / use.

fn session_create_context(&self) -> Option<Vec<u8>>

Obtain additional session context to store with the server.

fn session_join_string_bytes(&self) -> Result<Vec<u8>, RemoteSignError>

Obtain the raw bytes constituting the session join string.

fn negotiate_session(
    self: Box<Self>,
    peer_context: Option<Vec<u8>>
) -> Result<PeerKeys, RemoteSignError>

Finalize a peer joined session using optional context provided by the peer.

fn session_join_string_base64(&self) -> Result<String, RemoteSignError>

Obtain the base 64 encoded session join string.

fn session_join_string_pem(&self) -> Result<String, RemoteSignError>

Obtain the PEM encoded session join string.