1use crate::AuthFramework;
6#[cfg(feature = "saml")]
7use crate::api::saml;
8use crate::api::{
9 ApiState, admin, advanced_protocols, auth, email_verification, health, mfa, middleware,
10 oauth_advanced, oauth2, openapi, users, webauthn,
11};
12use axum::{
13 Router,
14 extract::DefaultBodyLimit,
15 http::Method,
16 middleware as axum_middleware,
17 routing::{delete, get, post, put},
18};
19use std::net::SocketAddr;
20use std::sync::Arc;
21use tower::ServiceBuilder;
22use tower_http::{cors::CorsLayer, trace::TraceLayer};
23use tracing::info;
24
25#[derive(Debug, Clone)]
41pub struct ApiServerConfig {
42 pub host: String,
44 pub port: u16,
46 pub cors: crate::config::CorsConfig,
50 pub max_body_size: usize,
52 pub enable_tracing: bool,
54}
55
56impl ApiServerConfig {
57 pub fn enable_cors(&self) -> bool {
59 self.cors.enabled
60 }
61}
62
63impl Default for ApiServerConfig {
64 fn default() -> Self {
65 Self {
66 host: "127.0.0.1".to_string(),
67 port: 8080,
68 cors: crate::config::CorsConfig::default(), max_body_size: 1024 * 1024, enable_tracing: true,
71 }
72 }
73}
74
75impl ApiServerConfig {
77 pub fn builder() -> ApiServerConfigBuilder {
79 ApiServerConfigBuilder::default()
80 }
81}
82
83#[derive(Default)]
88pub struct ApiServerConfigBuilder {
89 config: ApiServerConfig,
90}
91
92impl ApiServerConfigBuilder {
93 pub fn host(mut self, host: impl Into<String>) -> Self {
95 self.config.host = host.into();
96 self
97 }
98
99 pub fn port(mut self, port: u16) -> Self {
101 self.config.port = port;
102 self
103 }
104
105 pub fn enable_cors(mut self, enable: bool) -> Self {
107 self.config.cors.enabled = enable;
108 self
109 }
110
111 pub fn allow_origin(mut self, origin: impl Into<String>) -> Self {
113 self.config.cors.allowed_origins.push(origin.into());
114 self
115 }
116
117 pub fn allowed_origins(mut self, origins: Vec<String>) -> Self {
119 self.config.cors.allowed_origins = origins;
120 self
121 }
122
123 pub fn max_body_size(mut self, size: usize) -> Self {
125 self.config.max_body_size = size;
126 self
127 }
128
129 pub fn enable_tracing(mut self, enable: bool) -> Self {
131 self.config.enable_tracing = enable;
132 self
133 }
134
135 pub fn build(self) -> ApiServerConfig {
137 self.config
138 }
139}
140
141pub struct ApiServer {
151 config: ApiServerConfig,
152 auth_framework: Arc<AuthFramework>,
153 email_verification_sender: Option<Arc<dyn super::email_verification::EmailVerificationSender>>,
154 trusted_proxies: Vec<std::net::IpAddr>,
155}
156
157impl ApiServer {
158 pub fn new(auth_framework: Arc<AuthFramework>) -> Self {
160 Self {
161 config: ApiServerConfig::default(),
162 auth_framework,
163 email_verification_sender: None,
164 trusted_proxies: Vec::new(),
165 }
166 }
167
168 pub fn with_config(auth_framework: Arc<AuthFramework>, config: ApiServerConfig) -> Self {
170 Self {
171 config,
172 auth_framework,
173 email_verification_sender: None,
174 trusted_proxies: Vec::new(),
175 }
176 }
177
178 pub fn with_trusted_proxies(mut self, proxies: Vec<std::net::IpAddr>) -> Self {
183 self.trusted_proxies = proxies;
184 self
185 }
186
187 pub fn with_email_verification_sender(
190 mut self,
191 sender: Arc<dyn super::email_verification::EmailVerificationSender>,
192 ) -> Self {
193 self.email_verification_sender = Some(sender);
194 self
195 }
196
197 pub async fn build_router(&self) -> crate::errors::Result<Router> {
199 let mut state = ApiState::new(self.auth_framework.clone()).await?;
200 state.email_verification_sender = self.email_verification_sender.clone();
201 state.trusted_proxies = self.trusted_proxies.clone();
202
203 let api_v1 = Router::new()
205 .route("/health", get(health::health_check))
207 .route("/health/detailed", get(health::detailed_health_check))
208 .route("/metrics", get(health::metrics))
209 .route("/readiness", get(health::readiness_check))
210 .route("/liveness", get(health::liveness_check))
211 .route("/auth/login", post(auth::login))
213 .route("/auth/register", post(auth::register))
214 .route("/auth/refresh", post(auth::refresh_token))
215 .route("/auth/logout", post(auth::logout))
216 .route("/auth/validate", get(auth::validate_token))
217 .route("/auth/providers", get(auth::list_providers))
218 .route("/api-keys", post(auth::create_api_key))
219 .route(
221 "/auth/verify-email/send",
222 post(email_verification::send_verification),
223 )
224 .route("/auth/verify-email", post(email_verification::verify_email))
225 .route(
226 "/auth/resend-verification",
227 post(email_verification::resend_verification),
228 )
229 .route("/oauth/authorize", get(oauth2::authorize))
231 .route("/oauth/token", post(oauth2::token))
232 .route("/oauth/revoke", post(oauth2::revoke))
233 .route("/oauth/introspect", post(oauth_advanced::introspect_token))
235 .route(
237 "/oauth/par",
238 post(oauth_advanced::pushed_authorization_request),
239 )
240 .route("/oauth/clients/{client_id}", get(oauth2::get_client_info))
241 .route("/oauth/device", post(oauth_advanced::device_authorization))
243 .route("/oauth/ciba", post(oauth_advanced::ciba_backchannel_auth))
245 .route("/oauth/userinfo", get(oauth2::userinfo))
247 .route("/oauth/end_session", get(oauth2::end_session))
249 .route("/oauth/register", post(oauth2::register_client))
251 .route(
253 "/.well-known/openid-configuration",
254 get(oauth2::openid_configuration),
255 )
256 .route("/.well-known/jwks.json", get(oauth2::jwks))
258 .route("/users/me", get(oauth2::users_me))
260 .route("/users/profile", get(users::get_profile))
261 .route("/users/profile", put(users::update_profile))
262 .route("/users/change-password", post(users::change_password))
263 .route("/users/sessions", get(users::get_sessions))
264 .route(
265 "/users/sessions/{session_id}",
266 delete(users::revoke_session),
267 )
268 .route("/users/{user_id}/profile", get(users::get_user_profile))
269 .route("/mfa/setup", post(mfa::setup_mfa))
271 .route("/mfa/verify", post(mfa::verify_mfa))
272 .route("/mfa/disable", post(mfa::disable_mfa))
273 .route("/mfa/status", get(mfa::get_mfa_status))
274 .route(
275 "/mfa/regenerate-backup-codes",
276 post(mfa::regenerate_backup_codes),
277 )
278 .route("/mfa/verify-backup-code", post(mfa::verify_backup_code))
279 .route("/admin/users", get(admin::list_users))
281 .route("/admin/users", post(admin::create_user))
282 .route(
283 "/admin/users/{user_id}/roles",
284 put(admin::update_user_roles),
285 )
286 .route("/admin/users/{user_id}", delete(admin::delete_user))
287 .route("/admin/users/{user_id}/activate", put(admin::activate_user))
288 .route("/admin/stats", get(admin::get_system_stats))
289 .route("/admin/audit-logs", get(admin::get_audit_logs))
290 .route("/admin/audit-logs/stats", get(admin::get_audit_log_stats))
291 .route(
292 "/admin/config",
293 get(admin::get_config).put(admin::update_config),
294 )
295 .route(
297 "/webauthn/registration/init",
298 post(webauthn::webauthn_registration_init),
299 )
300 .route(
301 "/webauthn/registration/complete",
302 post(webauthn::webauthn_registration_complete),
303 )
304 .route(
305 "/webauthn/authentication/init",
306 post(webauthn::webauthn_authentication_init),
307 )
308 .route(
309 "/webauthn/authentication/complete",
310 post(webauthn::webauthn_authentication_complete),
311 )
312 .route(
313 "/webauthn/credentials/{username}",
314 get(webauthn::list_webauthn_credentials),
315 )
316 .route(
317 "/webauthn/credentials/{username}/{credential_id}",
318 delete(webauthn::delete_webauthn_credential),
319 );
320
321 let api_v1 = {
323 let router = api_v1;
324
325 #[cfg(feature = "saml")]
326 {
327 router
328 .route("/saml/metadata", get(saml::get_saml_metadata))
329 .route("/saml/sso", post(saml::initiate_saml_sso))
330 .route("/saml/acs", post(saml::handle_saml_acs))
331 .route("/saml/slo", post(saml::initiate_saml_slo))
332 .route("/saml/slo/response", get(saml::handle_saml_slo_response))
333 .route("/saml/assertion", post(saml::create_saml_assertion))
334 .route("/saml/idps", get(saml::list_saml_idps))
335 }
336
337 #[cfg(not(feature = "saml"))]
338 {
339 router
340 }
341 };
342
343 let router = Router::new()
345 .route("/api/openapi.json", get(openapi::serve_openapi_json))
346 .route("/docs", get(openapi::serve_swagger_ui))
347 .nest("/api/v1", api_v1)
348 .merge(advanced_protocols::router())
349 .with_state(state.clone());
350
351 let middleware_stack = ServiceBuilder::new()
353 .layer(axum_middleware::from_fn(middleware::timeout_middleware))
354 .layer(axum_middleware::from_fn(
355 middleware::security_headers_middleware,
356 ))
357 .layer(axum_middleware::from_fn({
358 let state = state.clone();
359 move |request, next| {
360 let state = state.clone();
361 async move {
362 middleware::rate_limit_middleware_with_state(state, request, next).await
363 }
364 }
365 }))
366 .layer(axum_middleware::from_fn(middleware::logging_middleware));
367
368 let router = if self.config.cors.enabled {
369 if self.config.cors.allowed_origins.is_empty() {
370 tracing::warn!(
371 "SECURITY/CORS: CORS is enabled but allowed_origins is empty. All cross-origin requests will be rejected! Disable CORS or add allowed origins."
372 );
373 }
374
375 let header_origins: Vec<axum::http::HeaderValue> = self
376 .config
377 .cors
378 .allowed_origins
379 .iter()
380 .filter_map(|o| o.parse::<axum::http::HeaderValue>().ok())
381 .collect();
382
383 if header_origins.is_empty() && !self.config.cors.allowed_origins.is_empty() {
384 tracing::warn!(
385 "CORS: none of the configured allowed_origins could be parsed as valid HTTP \
386 header values; cross-origin requests will be rejected"
387 );
388 }
389
390 let allow_origin = tower_http::cors::AllowOrigin::list(header_origins);
391
392 let allowed_methods: Vec<Method> = self
393 .config
394 .cors
395 .allowed_methods
396 .iter()
397 .filter_map(|m| m.parse::<Method>().ok())
398 .collect();
399
400 let allowed_headers: Vec<axum::http::HeaderName> = self
401 .config
402 .cors
403 .allowed_headers
404 .iter()
405 .filter_map(|h| h.parse::<axum::http::HeaderName>().ok())
406 .collect();
407
408 router.layer(
409 CorsLayer::new()
410 .allow_origin(allow_origin)
411 .allow_methods(allowed_methods)
412 .allow_headers(allowed_headers)
413 .max_age(std::time::Duration::from_secs(
414 self.config.cors.max_age_secs as u64,
415 )),
416 )
417 } else {
418 router
419 };
420
421 let router = if self.config.enable_tracing {
422 router.layer(TraceLayer::new_for_http())
423 } else {
424 router
425 };
426
427 Ok(router
428 .layer(middleware_stack)
429 .layer(DefaultBodyLimit::max(self.config.max_body_size)))
430 }
431
432 pub async fn start(&self) -> Result<(), Box<dyn std::error::Error>> {
434 let app = self.build_router().await?;
435
436 let addr = SocketAddr::new(self.config.host.parse()?, self.config.port);
437
438 info!("🚀 AuthFramework API server starting on http://{}", addr);
439 info!("📖 API documentation available at http://{}/docs", addr);
440 info!(
441 "📘 OpenAPI JSON available at http://{}/api/openapi.json",
442 addr
443 );
444 info!("🏥 Health check available at http://{}/health", addr);
445 info!("📊 Metrics available at http://{}/metrics", addr);
446
447 let listener = tokio::net::TcpListener::bind(addr).await?;
448 axum::serve(
449 listener,
450 app.into_make_service_with_connect_info::<SocketAddr>(),
451 )
452 .await?;
453
454 Ok(())
455 }
456
457 pub fn config(&self) -> &ApiServerConfig {
459 &self.config
460 }
461
462 pub fn address(&self) -> String {
464 format!("{}:{}", self.config.host, self.config.port)
465 }
466}
467
468pub async fn create_api_server(auth_framework: Arc<AuthFramework>) -> ApiServer {
470 ApiServer::new(auth_framework)
471}
472
473pub async fn create_api_server_with_address(
475 auth_framework: Arc<AuthFramework>,
476 host: impl Into<String>,
477 port: u16,
478) -> ApiServer {
479 let config = ApiServerConfig {
480 host: host.into(),
481 port,
482 ..Default::default()
483 };
484 ApiServer::with_config(auth_framework, config)
485}
486
487#[cfg(test)]
488mod tests {
489 use super::*;
490 use crate::storage::memory::InMemoryStorage;
491 use crate::{AuthConfig, AuthFramework};
492 use axum::body::Body;
493 use axum::http::{Request, StatusCode};
494 use tower::ServiceExt;
495
496 async fn create_test_api_server() -> ApiServer {
497 let _storage = Arc::new(InMemoryStorage::new());
498 let config = AuthConfig::default();
499 let auth_framework = Arc::new(AuthFramework::new(config));
500 ApiServer::new(auth_framework)
501 }
502
503 #[tokio::test]
504 async fn test_health_endpoint() {
505 let api_server = create_test_api_server().await;
506 let router = api_server.build_router().await.unwrap();
507
508 let request = Request::builder()
509 .uri("/api/v1/health")
510 .method("GET")
511 .body(Body::empty())
512 .unwrap();
513
514 let response = router.oneshot(request).await.unwrap();
515 assert_eq!(response.status(), StatusCode::OK);
516 }
517
518 #[tokio::test]
519 async fn test_auth_required_endpoints() {
520 let api_server = create_test_api_server().await;
521 let router = api_server.build_router().await.unwrap();
522
523 let request = Request::builder()
524 .uri("/api/v1/users/profile")
525 .method("GET")
526 .body(Body::empty())
527 .unwrap();
528
529 let response = router.oneshot(request).await.unwrap();
530 assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
532 }
533
534 #[tokio::test]
535 async fn test_cors_headers() {
536 let config = AuthConfig::default();
537 let auth_framework = Arc::new(AuthFramework::new(config));
538 let api_config = ApiServerConfig {
539 cors: crate::config::CorsConfig {
540 enabled: true,
541 allowed_origins: vec!["http://localhost:3000".to_string()],
542 ..crate::config::CorsConfig::default()
543 },
544 ..ApiServerConfig::default()
545 };
546 let api_server = ApiServer::with_config(auth_framework, api_config);
547 let router = api_server.build_router().await.unwrap();
548
549 let request = Request::builder()
550 .uri("/api/v1/health")
551 .method("GET")
552 .header("Origin", "http://localhost:3000")
553 .body(Body::empty())
554 .unwrap();
555
556 let response = router.oneshot(request).await.unwrap();
557 assert_eq!(response.status(), StatusCode::OK);
558
559 assert!(
561 response
562 .headers()
563 .contains_key("access-control-allow-origin")
564 );
565 }
566
567 #[tokio::test]
568 async fn test_readiness_endpoint() {
569 let api_server = create_test_api_server().await;
570 let router = api_server.build_router().await.unwrap();
571
572 let request = Request::builder()
573 .uri("/api/v1/readiness")
574 .method("GET")
575 .body(Body::empty())
576 .unwrap();
577
578 let response = router.oneshot(request).await.unwrap();
579 assert!(
581 response.status() == StatusCode::OK
582 || response.status() == StatusCode::SERVICE_UNAVAILABLE
583 );
584 }
585
586 #[tokio::test]
587 async fn test_liveness_endpoint() {
588 let api_server = create_test_api_server().await;
589 let router = api_server.build_router().await.unwrap();
590
591 let request = Request::builder()
592 .uri("/api/v1/liveness")
593 .method("GET")
594 .body(Body::empty())
595 .unwrap();
596
597 let response = router.oneshot(request).await.unwrap();
598 assert_eq!(response.status(), StatusCode::OK);
599 }
600
601 #[tokio::test]
602 async fn test_metrics_endpoint() {
603 let api_server = create_test_api_server().await;
604 let router = api_server.build_router().await.unwrap();
605
606 let request = Request::builder()
607 .uri("/api/v1/metrics")
608 .method("GET")
609 .body(Body::empty())
610 .unwrap();
611
612 let response = router.oneshot(request).await.unwrap();
613 assert_eq!(response.status(), StatusCode::OK);
614 }
615
616 #[tokio::test]
617 async fn test_nonexistent_route_returns_404() {
618 let api_server = create_test_api_server().await;
619 let router = api_server.build_router().await.unwrap();
620
621 let request = Request::builder()
622 .uri("/api/v1/this-does-not-exist")
623 .method("GET")
624 .body(Body::empty())
625 .unwrap();
626
627 let response = router.oneshot(request).await.unwrap();
628 assert_eq!(response.status(), StatusCode::NOT_FOUND);
629 }
630
631 #[tokio::test]
632 async fn test_login_with_empty_body() {
633 let api_server = create_test_api_server().await;
634 let router = api_server.build_router().await.unwrap();
635
636 let request = Request::builder()
637 .uri("/api/v1/auth/login")
638 .method("POST")
639 .header("Content-Type", "application/json")
640 .body(Body::from("{}"))
641 .unwrap();
642
643 let response = router.oneshot(request).await.unwrap();
644 assert_ne!(response.status(), StatusCode::OK);
646 }
647
648 #[tokio::test]
649 async fn test_register_endpoint_accessible() {
650 let api_server = create_test_api_server().await;
651 let router = api_server.build_router().await.unwrap();
652
653 let body = serde_json::json!({
654 "username": "newuser",
655 "password": "StrongP@ssw0rd123!",
656 "email": "test@example.com"
657 });
658
659 let request = Request::builder()
660 .uri("/api/v1/auth/register")
661 .method("POST")
662 .header("Content-Type", "application/json")
663 .body(Body::from(serde_json::to_string(&body).unwrap()))
664 .unwrap();
665
666 let response = router.oneshot(request).await.unwrap();
667 assert_ne!(response.status(), StatusCode::NOT_FOUND);
669 assert_ne!(response.status(), StatusCode::METHOD_NOT_ALLOWED);
670 }
671
672 #[tokio::test]
673 async fn test_server_config_defaults() {
674 let config = ApiServerConfig::default();
675 assert_eq!(config.host, "127.0.0.1");
676 assert_eq!(config.port, 8080);
677 assert!(!config.enable_cors());
678 }
679
680 #[tokio::test]
681 async fn test_server_address() {
682 let api_server = create_test_api_server().await;
683 assert_eq!(api_server.address(), "127.0.0.1:8080");
684 }
685
686 #[tokio::test]
687 async fn test_create_api_server_with_address() {
688 let config = AuthConfig::default();
689 let auth_framework = Arc::new(AuthFramework::new(config));
690 let api_server = create_api_server_with_address(auth_framework, "0.0.0.0", 8080).await;
691 assert_eq!(api_server.address(), "0.0.0.0:8080");
692 }
693
694 #[tokio::test]
695 async fn test_admin_endpoints_require_auth() {
696 let api_server = create_test_api_server().await;
697 let router = api_server.build_router().await.unwrap();
698
699 let request = Request::builder()
700 .uri("/api/v1/admin/users")
701 .method("GET")
702 .body(Body::empty())
703 .unwrap();
704
705 let response = router.oneshot(request).await.unwrap();
706 assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
707 }
708
709 #[tokio::test]
710 async fn test_security_headers_present() {
711 let api_server = create_test_api_server().await;
712 let router = api_server.build_router().await.unwrap();
713
714 let request = Request::builder()
715 .uri("/api/v1/health")
716 .method("GET")
717 .body(Body::empty())
718 .unwrap();
719
720 let response = router.oneshot(request).await.unwrap();
721 assert_eq!(response.status(), StatusCode::OK);
722
723 let headers = response.headers();
724 assert_eq!(
725 headers
726 .get("x-content-type-options")
727 .map(|v| v.to_str().unwrap()),
728 Some("nosniff")
729 );
730 assert_eq!(
731 headers.get("x-frame-options").map(|v| v.to_str().unwrap()),
732 Some("DENY")
733 );
734 }
735}