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 ¶ms {
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");
}