Rust SDK

impl Client {
    pub fn builder(identity: impl Into<String>) -> ClientBuilder;
    /// MESSH_IDENTITY, MESSH_KEY or MESSH_KEY_FILE, MESSH_REGISTRY.
    pub fn from_env() -> Result<Client, messh::Error>;
    pub fn builder_from_env() -> Result<ClientBuilder, messh::Error>;
}

impl ClientBuilder {
    /// Default: KeySource::File("~/.ssh/id_ed25519").
    pub fn key(self, key: KeySource) -> Self;
    /// Default: "https://messh.io".
    pub fn registry(self, url: impl Into<String>) -> Self;
    /// Default: 60 s, at most 300 s.
    pub fn expires_in(self, d: Duration) -> Self;
    pub fn build(self) -> Result<Client, messh::Error>;
}

impl Client {
    /// Feature "fetch" (default).
    pub fn whoami(&self) -> Result<PublishedKey, messh::Error>;
    /// SHA256:…, as messh keys and ssh-keygen -l print it.
    pub fn fingerprint(&self) -> String;
}

pub struct PublishedKey {
    pub identity: String,     // "mukul"
    pub key_name: String,     // "build-bot"
    pub key_id: String,       // RFC 7638 thumbprint, sent as keyid
    pub fingerprint: String,  // "SHA256:…"
    pub agent_url: String,    // "https://messh.io/mukul"
}

impl Client {
    /// Feature "fetch" (default): sends with ureq.
    pub fn send(
        &self,
        method: &str,
        url: &str,
        body: Option<&[u8]>,
    ) -> Result<(u16, Vec<u8>), messh::Error>;
}

impl Client {
    pub fn sign(
        &self,
        method: &str,
        url: &str,
        body: Option<&[u8]>,
    ) -> Result<Vec<(String, String)>, messh::Error>;

    /// Like sign, for a Host header that differs from the URL's.
    pub fn sign_with_host(
        &self,
        method: &str,
        url: &str,
        body: Option<&[u8]>,
        host: Option<&str>,
    ) -> Result<Vec<(String, String)>, messh::Error>;

    /// Feature "http": signs an http::Request in place.
    pub fn sign_request<B: AsRef<[u8]>>(&self, req: &mut http::Request<B>)
        -> Result<(), messh::Error>;
}

impl Verifier {
    pub fn new(config: VerifyConfig) -> Verifier;

    /// Feature "http".
    pub fn verify_http<B>(&self, req: &http::Request<B>, body: &[u8])
        -> Result<Agent, VerifyError>;
}

impl VerifyConfig {
    pub fn trust<I, S>(patterns: I) -> Self
    where
        I: IntoIterator<Item = S>,
        S: Into<String>;
    pub fn registry(self, origin: &str, fetch_base: &str) -> Self;
    pub fn max_skew(self, d: Duration) -> Self;
    pub fn cache_ttl(self, d: Duration) -> Self;
    pub fn stale_if_error(self, d: Duration) -> Self;
    pub fn nonce_store(self, s: Arc<dyn NonceStore>) -> Self;
    pub fn timeout(self, d: Duration) -> Self; // directory fetch, default: 5 s
}

pub struct Request<'a> {
    pub method: &'a str,
    pub url: &'a str,                     // the full request URL
    pub headers: &'a [(String, String)],
    pub body: &'a [u8],
}

impl Verifier {
    /// Blocks while it fetches a key directory on a cache miss.
    pub fn verify(&self, req: &Request<'_>) -> Result<Agent, VerifyError>;
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Agent {
    pub identity: String,     // "mukul"
    pub key_name: String,     // "build-bot": the key's name on messh
    pub key_id: String,       // RFC 7638 thumbprint
    pub fingerprint: String,  // "SHA256:…"
    pub agent_url: String,    // "https://messh.io/mukul"
    pub created: i64,         // unix seconds
}