ordinary 0.13.0

Ordinary CLI
Documentation
// Copyright (C) 2026 The Ordinary Authors.
//
// SPDX-License-Identifier: BSD-3-Clause

use aes_gcm::aead::KeyInit;
use aes_gcm::{Aes256Gcm, Key, Nonce, aead::Aead};
use anyhow::bail;
use axum::http::header::ACCESS_CONTROL_ALLOW_ORIGIN;
use axum::http::{HeaderValue, StatusCode};
use axum::response::IntoResponse;
use axum::{Router, extract::Form, routing::post};
use base64::{Engine as B64Engine, engine::general_purpose::URL_SAFE_NO_PAD as b64};
use ed25519_dalek::SigningKey;
use getrandom::{SysRng, rand_core::UnwrapErr};
use ordinary_auth::{ACCOUNT_REGEX, ZEROED_KEY};
use ordinary_host::client::OrdinaryHostClient;
use ordinary_server_utils::shutdown_signal;
use saferlmdb::Environment;
use std::path::Path;
use std::sync::Arc;
use tokio::net::TcpListener;

#[derive(serde::Deserialize)]
struct WebCreds {
    public: String,
    iv: String,
    token: String,
    account: String,
}

pub async fn register(
    host: &str,
    host_domain: Option<&str>,
    accept_invalid_certs: bool,
    oidc_provider: Option<&str>,
    invite_token: Option<&str>,
    account_name: Option<&str>,
    env: &Arc<Environment>,
) -> anyhow::Result<String> {
    get_refresh_token_via_web(
        host,
        host_domain,
        accept_invalid_certs,
        "register",
        oidc_provider,
        invite_token,
        account_name,
        env,
    )
    .await
}

pub async fn login(
    host: &str,
    host_domain: Option<&str>,
    accept_invalid_certs: bool,
    oidc_provider: Option<&str>,
    account_name: Option<&str>,
    env: &Arc<Environment>,
) -> anyhow::Result<String> {
    get_refresh_token_via_web(
        host,
        host_domain,
        accept_invalid_certs,
        "login",
        oidc_provider,
        None,
        account_name,
        env,
    )
    .await
}

#[expect(clippy::too_many_lines, clippy::too_many_arguments)]
async fn get_refresh_token_via_web(
    host: &str,
    host_domain: Option<&str>,
    accept_invalid_certs: bool,
    route: &str,
    oidc_provider: Option<&str>,
    invite_token: Option<&str>,
    account_name: Option<&str>,
    env: &Arc<Environment>,
) -> anyhow::Result<String> {
    let device_id = OrdinaryHostClient::get_device_id()?;
    let client = crate::USER_AGENT;

    let priv_key = x25519_dalek::EphemeralSecret::random();
    let pub_key = x25519_dalek::PublicKey::from(&priv_key);

    let mut rng = UnwrapErr(SysRng);
    let signing_key: SigningKey = SigningKey::generate(&mut rng);
    let verifying_key = signing_key.verifying_key();

    let b64_encoded_pub_key = b64.encode(pub_key.as_bytes());
    let b64_encoded_verifying_key = b64.encode(verifying_key.as_bytes());

    let listener = TcpListener::bind("127.0.0.1:0").await?;
    let redirect = format!("http://{}", listener.local_addr()?);

    let (tx, mut rx) = tokio::sync::mpsc::channel(1);

    let cors_header = HeaderValue::from_str(host)?;

    let task = tokio::spawn(async move {
        let router = Router::new().route(
            "/",
            post(|Form(form): Form<WebCreds>| async move {
                if let Err(err) = tx.send(form).await {
                    tracing::error!(%err, file = %file!(), line = %line!());

                    return StatusCode::INTERNAL_SERVER_ERROR.into_response();
                }

                (StatusCode::OK, [(ACCESS_CONTROL_ALLOW_ORIGIN, cors_header)]).into_response()
            }),
        );

        axum::serve(listener, router)
            .with_graceful_shutdown(shutdown_signal())
            .await
    });

    scopeguard::defer! {
        task.abort();
    }

    let mut params = vec![
        ("device", device_id.as_str()),
        ("client", client),
        ("public", b64_encoded_pub_key.as_str()),
        ("verifying", b64_encoded_verifying_key.as_str()),
        ("redirect", redirect.as_str()),
    ];

    if let Some(account_name) = account_name {
        params.push(("account", account_name));
    }

    if let Some(invite_token) = invite_token {
        params.push(("invite", invite_token));
    }

    if let Some(oidc_provider) = oidc_provider {
        params.push(("provider", oidc_provider));
    }

    let mut integrity_data = vec![];

    for &(key, val) in &params {
        match key {
            "public" => integrity_data.extend_from_slice(pub_key.as_bytes()),
            "verifying" => integrity_data.extend_from_slice(verifying_key.as_bytes()),
            _ => integrity_data.extend_from_slice(val.as_bytes()),
        }
    }

    let b64_encoded_integrity = {
        use sha2::{Digest, Sha256};

        let mut hasher = Sha256::new();
        hasher.update(&integrity_data);
        b64.encode(hasher.finalize())
    };

    params.push(("integrity", b64_encoded_integrity.as_str()));

    let qs_params = serde_urlencoded::to_string(params)?;

    let route = if oidc_provider.is_some() {
        "oidc"
    } else {
        route
    };

    open::that(format!("{host}/{route}?{qs_params}"))?;

    println!("MAKE SURE THE FOLLOWING MATCH:");
    println!("- client: {client}");
    println!("- redirect: {redirect}");
    println!("- device: {device_id}");

    if let Some(web_creds) = rx.recv().await {
        let browser_pub_key_bytes: [u8; 32] = b64
            .decode(web_creds.public)?
            .try_into()
            .expect("couldn't convert decoded pub key to array");

        if browser_pub_key_bytes == ZEROED_KEY {
            bail!("responding public key cannot be all 0s");
        }

        let iv: [u8; 12] = b64
            .decode(web_creds.iv)?
            .try_into()
            .expect("couldn't convert decoded iv to array");
        let encrypted_token = b64.decode(web_creds.token)?;

        let browser_pub_key = x25519_dalek::PublicKey::from(browser_pub_key_bytes);
        let shared_secret = priv_key.diffie_hellman(&browser_pub_key);

        if !shared_secret.was_contributory() {
            bail!("non-contributory shared secret");
        }

        let key = Key::<Aes256Gcm>::try_from(&shared_secret.as_bytes()[..])
            .expect("failed to convert shared secret to AES key");

        let cipher = Aes256Gcm::new(&key);
        let nonce = Nonce::from(iv);

        let refresh_token = cipher.decrypt(&nonce, encrypted_token.as_slice())?;

        let account = Path::new(&web_creds.account)
            .file_name()
            .and_then(|file_name| file_name.to_str())
            .expect("failed to sanitize");

        if !ACCOUNT_REGEX.is_match(account) {
            bail!("invalid account format");
        }

        OrdinaryHostClient::set_host(host_domain.unwrap_or(host), account, host)?;

        let client = OrdinaryHostClient::new(
            host,
            account,
            host_domain,
            accept_invalid_certs,
            crate::USER_AGENT,
            false,
            OrdinaryHostClient::secrets_store("cli", env)?,
        )?;

        client.save_credentials(
            host_domain.unwrap_or(host),
            account,
            &signing_key.as_bytes()[..],
            &refresh_token,
        )?;

        client.clear_access_token(host_domain.unwrap_or(host), account);

        client.host_get_access(None, None).await?;

        return Ok(web_creds.account);
    }

    bail!("failed to get web credentials");
}