use actix_web::{web, HttpResponse};
use chrono::{Duration, Utc};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use uuid::Uuid;
use super::audit::Database;
use super::auth::{AuthResponse, SubscriptionTier, User};
const LOGIN_STATE_TTL_MINUTES: i64 = 15;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OidcProviderConfig {
pub id: String,
pub name: String,
pub issuer: String,
pub client_id: String,
#[serde(default)]
pub client_secret: Option<String>,
pub redirect_uri: String,
#[serde(default)]
pub scopes: Vec<String>,
#[serde(default)]
pub groups_claim: Option<String>,
pub enabled: bool,
#[serde(default)]
pub domains: Vec<String>,
#[serde(default)]
pub organization_id: Option<String>,
#[serde(default)]
pub default_tier: SubscriptionTier,
pub auto_provision: bool,
pub created_at: i64,
pub updated_at: i64,
}
impl OidcProviderConfig {
pub fn redacted(&self) -> PublicOidcProvider {
PublicOidcProvider {
id: self.id.clone(),
name: self.name.clone(),
issuer: self.issuer.clone(),
client_id: self.client_id.clone(),
has_client_secret: self.client_secret.is_some(),
redirect_uri: self.redirect_uri.clone(),
scopes: self.scopes.clone(),
groups_claim: self.groups_claim.clone(),
enabled: self.enabled,
domains: self.domains.clone(),
organization_id: self.organization_id.clone(),
default_tier: self.default_tier,
auto_provision: self.auto_provision,
created_at: self.created_at,
updated_at: self.updated_at,
}
}
fn to_sso_config(&self) -> ironbridge_sso::oidc::OidcConfig {
ironbridge_sso::oidc::OidcConfig {
issuer: self.issuer.clone(),
client_id: self.client_id.clone(),
client_secret: self.client_secret.clone(),
redirect_uri: self.redirect_uri.clone(),
scopes: self.scopes.clone(),
groups_claim: self.groups_claim.clone(),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PublicOidcProvider {
pub id: String,
pub name: String,
pub issuer: String,
pub client_id: String,
pub has_client_secret: bool,
pub redirect_uri: String,
pub scopes: Vec<String>,
pub groups_claim: Option<String>,
pub enabled: bool,
pub domains: Vec<String>,
pub organization_id: Option<String>,
pub default_tier: SubscriptionTier,
pub auto_provision: bool,
pub created_at: i64,
pub updated_at: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OidcLoginState {
pub state: String,
pub provider_id: String,
pub nonce: String,
pub verifier: String,
pub return_to: Option<String>,
pub created_at: i64,
pub expires_at: i64,
}
#[derive(Debug, Deserialize)]
pub struct CreateOidcProviderRequest {
pub name: String,
pub issuer: String,
pub client_id: String,
pub client_secret: Option<String>,
pub redirect_uri: String,
#[serde(default)]
pub scopes: Vec<String>,
pub groups_claim: Option<String>,
#[serde(default)]
pub domains: Vec<String>,
pub organization_id: Option<String>,
pub auto_provision: Option<bool>,
pub enabled: Option<bool>,
}
#[derive(Debug, Deserialize)]
pub struct UpdateOidcProviderRequest {
pub name: Option<String>,
pub client_id: Option<String>,
pub client_secret: Option<String>,
pub redirect_uri: Option<String>,
pub scopes: Option<Vec<String>>,
pub groups_claim: Option<String>,
pub enabled: Option<bool>,
pub auto_provision: Option<bool>,
pub domains: Option<Vec<String>>,
}
#[derive(Debug, Deserialize)]
pub struct BeginOidcLoginRequest {
pub provider_id: Option<String>,
pub email_domain: Option<String>,
pub return_to: Option<String>,
}
#[derive(Debug, Serialize)]
pub struct BeginOidcLoginResponse {
pub authorization_url: String,
pub state: String,
}
#[derive(Debug, Deserialize)]
pub struct OidcCallbackRequest {
pub code: String,
pub state: String,
}
pub struct OidcService {
db: Database,
http: reqwest::Client,
}
impl OidcService {
pub fn new(db: Database) -> Self {
Self {
db,
http: reqwest::Client::new(),
}
}
pub async fn list_providers(
&self,
organization_id: Option<&str>,
) -> Result<Vec<PublicOidcProvider>, String> {
Ok(self
.db
.list_oidc_providers(organization_id)?
.iter()
.map(OidcProviderConfig::redacted)
.collect())
}
pub async fn get_provider(&self, id: &str) -> Result<Option<OidcProviderConfig>, String> {
self.db.get_oidc_provider(id)
}
pub async fn create_provider(
&self,
request: CreateOidcProviderRequest,
) -> Result<PublicOidcProvider, String> {
if request.issuer.trim().is_empty() {
return Err("issuer is required".to_string());
}
if request.client_id.trim().is_empty() {
return Err("client_id is required".to_string());
}
require_secure_issuer(&request.issuer)?;
let now = Utc::now().timestamp();
let provider = OidcProviderConfig {
id: Uuid::new_v4().to_string(),
name: request.name,
issuer: request.issuer.trim_end_matches('/').to_string(),
client_id: request.client_id,
client_secret: request.client_secret,
redirect_uri: request.redirect_uri,
scopes: request.scopes,
groups_claim: request.groups_claim,
enabled: request.enabled.unwrap_or(true),
domains: request
.domains
.iter()
.map(|d| d.trim().to_lowercase())
.filter(|d| !d.is_empty())
.collect(),
organization_id: request.organization_id,
default_tier: SubscriptionTier::Enterprise,
auto_provision: request.auto_provision.unwrap_or(false),
created_at: now,
updated_at: now,
};
self.db.create_oidc_provider(&provider)?;
Ok(provider.redacted())
}
pub async fn update_provider(
&self,
id: &str,
request: UpdateOidcProviderRequest,
) -> Result<PublicOidcProvider, String> {
let mut provider = self
.db
.get_oidc_provider(id)?
.ok_or_else(|| "Provider not found".to_string())?;
if let Some(v) = request.name {
provider.name = v;
}
if let Some(v) = request.client_id {
provider.client_id = v;
}
if let Some(v) = request.client_secret {
provider.client_secret = Some(v);
}
if let Some(v) = request.redirect_uri {
provider.redirect_uri = v;
}
if let Some(v) = request.scopes {
provider.scopes = v;
}
if let Some(v) = request.groups_claim {
provider.groups_claim = Some(v);
}
if let Some(v) = request.enabled {
provider.enabled = v;
}
if let Some(v) = request.auto_provision {
provider.auto_provision = v;
}
if let Some(v) = request.domains {
provider.domains = v
.iter()
.map(|d| d.trim().to_lowercase())
.filter(|d| !d.is_empty())
.collect();
}
provider.updated_at = Utc::now().timestamp();
self.db.update_oidc_provider(&provider)?;
Ok(provider.redacted())
}
pub async fn delete_provider(&self, id: &str) -> Result<(), String> {
self.db.delete_oidc_provider(id)
}
pub async fn begin_login(
&self,
request: BeginOidcLoginRequest,
) -> Result<BeginOidcLoginResponse, String> {
let provider = match (&request.provider_id, &request.email_domain) {
(Some(id), _) => self.db.get_oidc_provider(id)?,
(None, Some(domain)) => self
.db
.get_oidc_provider_by_domain(&domain.trim().to_lowercase())?,
(None, None) => {
return Err("Must provide either provider_id or email_domain".to_string())
}
}
.ok_or_else(|| "Provider not found".to_string())?;
if !provider.enabled {
return Err("Provider is disabled".to_string());
}
let client =
ironbridge_sso::oidc::OidcClient::discover(provider.to_sso_config(), &self.http)
.await
.map_err(|e| format!("OIDC discovery failed: {}", e))?;
let auth = client.begin();
let now = Utc::now();
self.db.store_oidc_login_state(&OidcLoginState {
state: auth.state.clone(),
provider_id: provider.id.clone(),
nonce: auth.nonce,
verifier: auth.verifier,
return_to: request.return_to,
created_at: now.timestamp(),
expires_at: (now + Duration::minutes(LOGIN_STATE_TTL_MINUTES)).timestamp(),
})?;
Ok(BeginOidcLoginResponse {
authorization_url: auth.authorization_url,
state: auth.state,
})
}
pub async fn complete_login(
&self,
request: OidcCallbackRequest,
) -> Result<AuthResponse, String> {
let login = self
.db
.take_oidc_login_state(&request.state)?
.ok_or_else(|| "Unknown or already-used state".to_string())?;
if Utc::now().timestamp() >= login.expires_at {
return Err("Login expired; start again".to_string());
}
let provider = self
.db
.get_oidc_provider(&login.provider_id)?
.ok_or_else(|| "Provider no longer configured".to_string())?;
if !provider.enabled {
return Err("Provider is disabled".to_string());
}
let client =
ironbridge_sso::oidc::OidcClient::discover(provider.to_sso_config(), &self.http)
.await
.map_err(|e| format!("OIDC discovery failed: {}", e))?;
let auth_request = ironbridge_sso::oidc::AuthRequest {
authorization_url: String::new(),
state: login.state.clone(),
nonce: login.nonce.clone(),
verifier: login.verifier.clone(),
};
let (identity, _tokens) = client
.complete_login(&self.http, &request.code, &auth_request)
.await
.map_err(|e| format!("OIDC login failed: {}", e))?;
let email = identity
.email
.clone()
.ok_or_else(|| "Provider returned no email claim".to_string())?;
if !identity.email_verified {
return Err("Provider did not assert the email address is verified".to_string());
}
let display_name = identity
.display_name
.clone()
.unwrap_or_else(|| email.split('@').next().unwrap_or(&email).to_string());
let user = self.find_or_create_user(&provider, &email, &display_name)?;
let access_token = super::auth::generate_access_token(&user)
.ok_or_else(|| "Failed to generate access token".to_string())?;
let refresh_token = super::auth::generate_refresh_token(&user)
.ok_or_else(|| "Failed to generate refresh token".to_string())?;
Ok(AuthResponse {
user: user.into(),
access_token,
refresh_token,
expires_in: 24 * 60 * 60,
})
}
fn find_or_create_user(
&self,
provider: &OidcProviderConfig,
email: &str,
display_name: &str,
) -> Result<User, String> {
if let Some(user) = self.db.get_user_by_email(email)? {
self.db.update_user_login(&user.id)?;
return Ok(user);
}
if !provider.auto_provision {
return Err("User not found and auto-provisioning is disabled".to_string());
}
let now = Utc::now().timestamp();
let user = User {
id: Uuid::new_v4().to_string(),
email: email.to_string(),
display_name: display_name.to_string(),
password_hash: String::new(),
subscription_tier: provider.default_tier,
subscription_expires_at: None,
created_at: now,
updated_at: now,
last_login_at: Some(now),
email_verified: true,
avatar_url: None,
metadata: Some(format!(r#"{{"oidc_provider":"{}"}}"#, provider.id)),
};
self.db.create_user(&user)?;
Ok(user)
}
}
fn require_secure_issuer(issuer: &str) -> Result<(), String> {
let lower = issuer.trim().to_lowercase();
if lower.starts_with("https://") {
return Ok(());
}
if let Some(rest) = lower.strip_prefix("http://") {
let authority = rest.split(['/', '?', '#']).next().unwrap_or("");
let host = if let Some(end) = authority.find(']') {
&authority[..=end]
} else {
authority.split(':').next().unwrap_or("")
};
if matches!(host, "localhost" | "127.0.0.1" | "[::1]") {
return Ok(());
}
}
Err("issuer must be https (loopback may use http for development)".to_string())
}
pub async fn list_providers(
service: web::Data<OidcService>,
query: web::Query<HashMap<String, String>>,
) -> HttpResponse {
match service
.list_providers(query.get("organization_id").map(|s| s.as_str()))
.await
{
Ok(providers) => HttpResponse::Ok().json(providers),
Err(e) => HttpResponse::InternalServerError().json(serde_json::json!({ "error": e })),
}
}
pub async fn get_provider(
service: web::Data<OidcService>,
path: web::Path<String>,
) -> HttpResponse {
match service.get_provider(&path.into_inner()).await {
Ok(Some(p)) => HttpResponse::Ok().json(p.redacted()),
Ok(None) => {
HttpResponse::NotFound().json(serde_json::json!({ "error": "Provider not found" }))
}
Err(e) => HttpResponse::InternalServerError().json(serde_json::json!({ "error": e })),
}
}
pub async fn create_provider(
service: web::Data<OidcService>,
request: web::Json<CreateOidcProviderRequest>,
) -> HttpResponse {
match service.create_provider(request.into_inner()).await {
Ok(p) => HttpResponse::Created().json(p),
Err(e) => HttpResponse::BadRequest().json(serde_json::json!({ "error": e })),
}
}
pub async fn update_provider(
service: web::Data<OidcService>,
path: web::Path<String>,
request: web::Json<UpdateOidcProviderRequest>,
) -> HttpResponse {
match service
.update_provider(&path.into_inner(), request.into_inner())
.await
{
Ok(p) => HttpResponse::Ok().json(p),
Err(e) => HttpResponse::BadRequest().json(serde_json::json!({ "error": e })),
}
}
pub async fn delete_provider(
service: web::Data<OidcService>,
path: web::Path<String>,
) -> HttpResponse {
match service.delete_provider(&path.into_inner()).await {
Ok(()) => HttpResponse::NoContent().finish(),
Err(e) => HttpResponse::BadRequest().json(serde_json::json!({ "error": e })),
}
}
pub async fn begin_login(
service: web::Data<OidcService>,
request: web::Json<BeginOidcLoginRequest>,
) -> HttpResponse {
match service.begin_login(request.into_inner()).await {
Ok(r) => HttpResponse::Ok().json(r),
Err(e) => HttpResponse::BadRequest().json(serde_json::json!({ "error": e })),
}
}
pub async fn callback(
service: web::Data<OidcService>,
query: web::Query<OidcCallbackRequest>,
) -> HttpResponse {
match service.complete_login(query.into_inner()).await {
Ok(r) => HttpResponse::Ok().json(r),
Err(e) => HttpResponse::BadRequest().json(serde_json::json!({ "error": e })),
}
}
pub fn configure_oidc_routes(cfg: &mut web::ServiceConfig) {
cfg.service(
web::scope("/oidc")
.route("/providers", web::get().to(list_providers))
.route("/providers", web::post().to(create_provider))
.route("/providers/{provider_id}", web::get().to(get_provider))
.route("/providers/{provider_id}", web::put().to(update_provider))
.route(
"/providers/{provider_id}",
web::delete().to(delete_provider),
)
.route("/login", web::post().to(begin_login))
.route("/callback", web::get().to(callback)),
);
}
#[cfg(test)]
mod tests {
use super::*;
fn provider() -> OidcProviderConfig {
OidcProviderConfig {
id: "p1".into(),
name: "Entra".into(),
issuer: "https://login.example.com/v2.0".into(),
client_id: "client-abc".into(),
client_secret: Some("super-secret-value".into()),
redirect_uri: "https://ironbridge.example.com/oidc/callback".into(),
scopes: vec![],
groups_claim: Some("groups".into()),
enabled: true,
domains: vec!["example.com".into()],
organization_id: None,
default_tier: SubscriptionTier::Enterprise,
auto_provision: true,
created_at: 0,
updated_at: 0,
}
}
#[test]
fn the_client_secret_is_never_serialised_to_a_client() {
let json = serde_json::to_string(&provider().redacted()).unwrap();
assert!(
!json.contains("super-secret-value"),
"the client secret leaked into a response body: {json}"
);
assert!(
json.contains("\"has_client_secret\":true"),
"callers still need to know whether one is set: {json}"
);
}
#[test]
fn a_provider_without_a_secret_reports_that() {
let mut p = provider();
p.client_secret = None;
assert!(!p.redacted().has_client_secret);
}
#[test]
fn a_plaintext_issuer_is_refused() {
assert!(require_secure_issuer("http://idp.example.com").is_err());
assert!(require_secure_issuer("HTTP://IdP.Example.Com").is_err());
for impostor in [
"http://localhost.evil.test",
"http://127.0.0.1.evil.test",
"http://localhost@evil.test/",
"http://localhosts",
] {
assert!(
require_secure_issuer(impostor).is_err(),
"{impostor} was accepted as loopback"
);
}
}
#[test]
fn https_and_loopback_issuers_are_allowed() {
for ok in [
"https://login.example.com/v2.0",
"http://localhost:8080/realms/x",
"http://localhost",
"http://127.0.0.1:8080",
"http://[::1]:8080/realms/x",
"http://[::1]",
] {
assert!(require_secure_issuer(ok).is_ok(), "{ok} was refused");
}
}
#[test]
fn the_stored_config_maps_onto_the_sso_crates_config() {
let p = provider();
let c = p.to_sso_config();
assert_eq!(c.issuer, p.issuer);
assert_eq!(c.client_id, p.client_id);
assert_eq!(c.client_secret, p.client_secret);
assert_eq!(c.redirect_uri, p.redirect_uri);
assert_eq!(c.groups_claim, p.groups_claim);
}
}