use serde::{Deserialize, Serialize};
use uuid::Uuid;
use axiam_opaque::{AxiamKsf, ClientLoginState, ClientRegistrationState};
use super::auth::{LoginResult, LoginUserInfoWire, absorb_session_cookies};
use crate::client::{AxiamClient, OrgIdentifier, TenantIdentifier};
use crate::error::AxiamError;
use crate::sensitive::Sensitive;
const REGISTER_START_PATH: &str = "/api/v1/auth/opaque/register/start";
const LOGIN_START_PATH: &str = "/api/v1/auth/opaque/login/start";
const LOGIN_FINISH_PATH: &str = "/api/v1/auth/opaque/login/finish";
#[derive(Debug, Deserialize)]
struct KsfFields {
ksf: String,
#[serde(default)]
memory_kib: Option<u32>,
#[serde(default)]
iterations: Option<u32>,
#[serde(default)]
parallelism: Option<u32>,
#[serde(default)]
log_n: Option<u8>,
#[serde(default)]
r: Option<u32>,
#[serde(default)]
p: Option<u32>,
}
impl KsfFields {
fn build(&self) -> Result<AxiamKsf, AxiamError> {
let missing = |what: &str| {
AxiamError::network(format!(
"OPAQUE: the server named ksf `{}` without `{what}`",
self.ksf
))
};
let ksf = match self.ksf.as_str() {
"argon2id" => AxiamKsf::argon2id(
self.memory_kib.ok_or_else(|| missing("memory_kib"))?,
self.iterations.ok_or_else(|| missing("iterations"))?,
self.parallelism.ok_or_else(|| missing("parallelism"))?,
),
"scrypt" => AxiamKsf::scrypt(
self.log_n.ok_or_else(|| missing("log_n"))?,
self.r.ok_or_else(|| missing("r"))?,
self.p.ok_or_else(|| missing("p"))?,
),
other => {
return Err(AxiamError::network(format!(
"OPAQUE: this SDK cannot perform the key-stretching function \
the server named (`{other}`)"
)));
}
};
ksf.map_err(|e| AxiamError::network(format!("OPAQUE: {e}")))
}
}
#[derive(Debug, Serialize)]
struct WorkspaceBody {
#[serde(skip_serializing_if = "Option::is_none")]
tenant_id: Option<Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
org_id: Option<Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
tenant_slug: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
org_slug: Option<String>,
}
#[derive(Debug, Serialize)]
struct RegisterStartRequest {
#[serde(flatten)]
workspace: WorkspaceBody,
registration_request: String,
}
#[derive(Debug, Deserialize)]
struct RegisterStartResponse {
opaque_session: String,
registration_response: String,
#[serde(flatten)]
ksf: KsfFields,
}
#[derive(Debug, Serialize)]
struct LoginStartRequest {
#[serde(flatten)]
workspace: WorkspaceBody,
username_or_email: String,
ke1: String,
}
#[derive(Debug, Deserialize)]
struct LoginStartResponse {
opaque_session: String,
ke2: String,
#[serde(default)]
mode: Option<String>,
#[serde(flatten)]
ksf: KsfFields,
}
#[derive(Debug, Serialize)]
struct LoginFinishRequest {
opaque_session: String,
ke3: String,
}
#[derive(Debug, Deserialize)]
struct FinishSuccessResponse {
session_id: Uuid,
expires_in: u64,
#[serde(default)]
user: Option<LoginUserInfoWire>,
}
#[derive(Debug, Deserialize)]
struct FinishMfaRequiredResponse {
challenge_token: String,
#[serde(default)]
available_methods: Vec<String>,
}
#[derive(Debug, Clone, Serialize)]
pub struct OpaqueEnrollment {
pub opaque_session: String,
pub registration_record: String,
}
impl AxiamClient {
pub async fn login_opaque(
&self,
username_or_email: &str,
password: &str,
) -> Result<LoginResult, AxiamError> {
let (state, ke1) = ClientLoginState::start(password)
.map_err(|e| AxiamError::network(format!("OPAQUE: {e}")))?;
let response = self
.http()
.post(self.url(LOGIN_START_PATH))
.header("X-Tenant-ID", self.tenant_header_value())
.json(&LoginStartRequest {
workspace: self.workspace_body(),
username_or_email: username_or_email.to_string(),
ke1,
})
.send()
.await
.map_err(|e| AxiamError::Network {
message: format!("OPAQUE login/start request failed: {e}"),
source: Some(Box::new(e)),
})?;
let status = response.status().as_u16();
if status == 404 {
return Err(AxiamError::network(
"this tenant does not offer OPAQUE (opaque_mode is disabled); \
use login() instead",
));
}
if status != 200 {
return Err(super::auth::map_error_response(status, response).await);
}
let started: LoginStartResponse = response.json().await.map_err(super::auth::deser_err)?;
let ksf = started.ksf.build()?;
let finished = match state.finish(password, &started.ke2, &ksf) {
Ok(finished) => finished,
Err(_) => {
return self
.ke2_failure(username_or_email, password, started.mode)
.await;
}
};
let response = self
.http()
.post(self.url(LOGIN_FINISH_PATH))
.header("X-Tenant-ID", self.tenant_header_value())
.json(&LoginFinishRequest {
opaque_session: started.opaque_session,
ke3: finished.ke3,
})
.send()
.await
.map_err(|e| AxiamError::Network {
message: format!("OPAQUE login/finish request failed: {e}"),
source: Some(Box::new(e)),
})?;
match response.status().as_u16() {
200 => {
let wire: FinishSuccessResponse =
response.json().await.map_err(super::auth::deser_err)?;
absorb_session_cookies(self).await?;
if let Some(user) = &wire.user {
self.set_principal_scope(Some(user.principal_scope()));
}
Ok(LoginResult::success(wire.session_id, wire.expires_in))
}
202 => {
let wire: FinishMfaRequiredResponse =
response.json().await.map_err(super::auth::deser_err)?;
self.set_pending_mfa_challenge(Sensitive::new(wire.challenge_token.clone()));
Ok(LoginResult::mfa_required(
wire.challenge_token,
wire.available_methods,
))
}
status => Err(super::auth::map_error_response(status, response).await),
}
}
pub async fn opaque_enrollment(&self, password: &str) -> Result<OpaqueEnrollment, AxiamError> {
self.enroll(password, self.workspace_body()).await
}
pub async fn opaque_enrollment_for_self(
&self,
password: &str,
) -> Result<OpaqueEnrollment, AxiamError> {
let Some(principal_tenant) = self.resolved_principal_tenant_id() else {
return Err(AxiamError::network(
"OPAQUE: no principal tenant is known yet -- sign in before \
building a registration record for your own password",
));
};
let mut workspace = self.workspace_body();
workspace.tenant_id = Some(principal_tenant);
workspace.tenant_slug = None;
self.enroll(password, workspace).await
}
async fn enroll(
&self,
password: &str,
workspace: WorkspaceBody,
) -> Result<OpaqueEnrollment, AxiamError> {
let (state, request) = ClientRegistrationState::start(password)
.map_err(|e| AxiamError::network(format!("OPAQUE: {e}")))?;
let response = self
.http()
.post(self.url(REGISTER_START_PATH))
.header("X-Tenant-ID", self.tenant_header_value())
.json(&RegisterStartRequest {
workspace,
registration_request: request,
})
.send()
.await
.map_err(|e| AxiamError::Network {
message: format!("OPAQUE register/start request failed: {e}"),
source: Some(Box::new(e)),
})?;
let status = response.status().as_u16();
if status == 404 {
return Err(AxiamError::network(
"this tenant does not offer OPAQUE (opaque_mode is disabled); \
use login() instead",
));
}
if status != 200 {
return Err(super::auth::map_error_response(status, response).await);
}
let started: RegisterStartResponse =
response.json().await.map_err(super::auth::deser_err)?;
let ksf = started.ksf.build()?;
let outcome = state
.finish(password, &started.registration_response, &ksf)
.map_err(|e| AxiamError::network(format!("OPAQUE: {e}")))?;
Ok(OpaqueEnrollment {
opaque_session: started.opaque_session,
registration_record: outcome.record,
})
}
pub fn opaque_available(&self) -> bool {
true
}
async fn ke2_failure(
&self,
username_or_email: &str,
password: &str,
mode: Option<String>,
) -> Result<LoginResult, AxiamError> {
if mode.as_deref() == Some("optional") {
return self.login(username_or_email, password).await;
}
Err(AxiamError::auth("invalid credentials"))
}
fn workspace_body(&self) -> WorkspaceBody {
let (tenant_id, tenant_slug) = match &self.inner.tenant {
TenantIdentifier::Id(id) => (Some(*id), None),
TenantIdentifier::Slug(slug) => (None, Some(slug.clone())),
};
let (org_id, org_slug) = match self.org_identifier() {
Some(OrgIdentifier::Id(id)) => (Some(*id), None),
Some(OrgIdentifier::Slug(slug)) => (None, Some(slug.clone())),
None => (None, None),
};
WorkspaceBody {
tenant_id,
org_id,
tenant_slug,
org_slug,
}
}
}