Struct apple_codesign::remote_signing::PairedClient

pub struct PairedClient { /* private fields */ }

A remote signing client that has joined a session and is ready to exchange messages.

Implementations

impl PairedClient

pub fn request_signing_certificate(
    &mut self
) -> Result<(CapturedX509Certificate, Vec<CapturedX509Certificate>), RemoteSignError>

Request the signing certificate from the peer.

Examples found in repository

src/remote_signing/mod.rs (line 544)

    fn create_session_and_wait_for_signer(
        mut self,
        initiator: Box<dyn SessionInitiatePeer>,
        session_info_cb: Option<SessionInfoCallback>,
    ) -> Result<InitiatorClient, RemoteSignError> {
        let session_id = initiator.session_id().to_string();

        self.send_request(
            ApiMethod::CreateSession,
            Some(ClientPayload::CreateSession {
                session_id: session_id.clone(),
                ttl: 600,
                context: initiator.session_create_context().map(base64::encode),
            }),
        )?;

        let sjs_base64 = initiator.session_join_string_base64()?;
        let sjs_pem = initiator.session_join_string_pem()?;

        wait_for_expected_server_message(&mut self.ws, ServerMessageType::SessionCreated)?;
        warn!("session successfully created on server");

        if let Some(cb) = session_info_cb {
            cb(&sjs_base64, &sjs_pem)?;
        }

        let res = wait_for_expected_server_message(&mut self.ws, ServerMessageType::SessionJoined)?;

        let joined = res.as_session_joined()?;
        warn!("signer joined session; deriving shared encryption key");

        let context = if let Some(context) = joined.context {
            Some(base64::decode(context)?)
        } else {
            None
        };

        let keys = initiator.negotiate_session(context)?;

        let mut client = PairedClient {
            ws: self.ws,
            session_id,
            keys,
        };

        client.send_ping()?;

        let (signing_cert, signing_chain) = client.request_signing_certificate()?;

        if let Some(name) = signing_cert.subject_common_name() {
            warn!("remote signer will sign with certificate: {}", name);
        }

        Ok(InitiatorClient {
            client: RefCell::new(client),
            signing_cert,
            signing_chain,
        })
    }

Trait Implementations

impl Drop for PairedClient

fn drop(&mut self)

Executes the destructor for this type.