Method delegate_from_request

atomic-cli/src/commands/identity/delegate.rs:315–359

Verify a self-signed request and turn it into a delegate identity. The verification is the point: it proves whoever produced the request holds the private half of the key it names. Without it, `--request` would be a way to talk someone into signing a certificate for a key chosen by an attacker.

(&self, path: &str)

    /// would be a way to talk someone into signing a certificate for a key
    /// chosen by an attacker.
    fn delegate_from_request(&self, path: &str) -> CliResult<Identity> {
        let raw = if path == "-" {
            use std::io::Read;
            let mut buf = String::new();
            std::io::stdin().read_to_string(&mut buf)?;
            buf
        } else {
            std::fs::read_to_string(path)?
        };

        let value: serde_json::Value =
            serde_json::from_str(&raw).map_err(|e| CliError::InvalidArgument {
                message: format!("{path} is not valid JSON: {e}"),
            })?;

        let request = cert::verify_request(&value).map_err(|e| CliError::DelegationError {
            message: format!(
                "The request in {path} does not verify: {e}\n  \
                 Only countersign a request whose self-signature checks out — it is the \
                 only evidence the far end actually holds that key."
            ),
        })?;

        let public_key =
            atomic_identity::PublicKey::from_did_key(&request.delegate_key).map_err(|e| {
                CliError::DelegationError {
                    message: format!("Request carries a malformed key: {e}"),
                }
            })?;

        print_hint(&format!(
            "Countersigning a verified request from '{}' ({})",
            request.delegate_name, request.delegate
        ));

        let mut builder = Identity::builder(&request.delegate_name)
            .identity_type(IdentityType::Agent)
            .public_key(public_key);
        if let Some(agent) = &request.software_agent {
            builder = builder.description(format!("software-agent:{agent}"));
        }
        builder
            .build()
            .map_err(|e| CliError::Internal(anyhow::anyhow!("Failed to build delegate: {e}")))
    }
}

/// Recover the software-agent URN we stash in an identity description.