Skip to main content

auth_framework/server/
mod.rs

1//! Server-side authentication and authorization implementations.
2//!
3//! This module provides comprehensive server-side capabilities including:
4//! - OAuth 2.0 Authorization Server (RFC 6749, RFC 8628) ✅ Working
5//! - OAuth 2.1 Authorization Framework ✅ Working
6//! - OpenID Connect Provider (OIDC 1.0) [Testing needed]
7//! - JWT Token Server
8//! - API Gateway Authentication
9//! - SAML Identity Provider
10//! - WebAuthn Relying Party Server
11
12// Hierarchical module organization
13pub mod core; // Core server functionality
14pub mod jwt; // JWT-related modules
15pub mod oauth; // OAuth 2.0/2.1 components
16pub mod oidc; // OpenID Connect components
17pub mod security;
18pub mod token_exchange; // Token exchange components // Security & compliance modules
19
20// Re-export modules from hierarchical structure for convenience
21
22// Core functionality re-exports
23pub use core::{
24    additional_modules::{
25        api_gateway, consent, device_flow_server, introspection, jwt_server, saml_idp,
26    },
27    client_registration::{
28        ClientRegistrationConfig, ClientRegistrationManager, ClientRegistrationRequest,
29        ClientRegistrationResponse, RegisteredClient,
30    },
31    client_registry::ClientRegistry,
32    federated_authentication_orchestration::{
33        AlternativeIdp, AppliedTransformation, AttributeMappingConfig, AttributeTransformation,
34        AuthenticationProtocol, CircuitBreakerConfig, CircuitBreakerState, FederationOrchestrator,
35        FederationOrchestratorConfig, FederationOrchestratorImpl, IdentityProvider, IdpCapability,
36        IdpHealthMetrics, IdpRecommendation, IdpRoutingRule, IdpSessionInfo, OrchestrationMetadata,
37        OrchestrationPattern, OrchestrationPreferences, OrchestrationRequest,
38        OrchestrationResponse, OrchestrationSessionInfo, ProtocolTranslationConfig,
39        SelectedIdpInfo, SessionFederationConfig, SessionProtocol, StringOperation, TimeConstraint,
40        TrustLevel, TrustValidationConfig,
41    },
42    metadata::MetadataProvider,
43    stepped_up_auth::{
44        AuthenticationLevel, AuthenticationMethod, LocationInfo, StepUpConfig, StepUpContext,
45        StepUpEvaluationResult, StepUpRequest, StepUpResponse, StepUpRule, StepUpStatus,
46        StepUpTrigger, SteppedUpAuthManager,
47    },
48};
49
50// OAuth 2.0/2.1 re-exports
51pub use oauth::{
52    device::{
53        DeviceAuthManager, DeviceAuthorizationRequest, DeviceAuthorizationResponse,
54        DeviceAuthorizationStatus, DeviceTokenRequest, StoredDeviceAuthorization,
55    },
56    oauth2::OAuth2Server,
57    oauth21::OAuth21Server,
58    par::PARManager,
59    rich_authorization_requests::{
60        AuthorizationDetail, RarAuthorizationDecision, RarAuthorizationProcessor,
61        RarAuthorizationRequest, RarCondition, RarConfig, RarDecisionType, RarDetailDecision,
62        RarManager, RarPermissionGrant, RarResourceAccess, RarResourceDiscoveryRequest,
63        RarResourceDiscoveryResponse, RarRestriction, RarValidationResult,
64    },
65};
66
67// OIDC re-exports
68pub use oidc::{
69    core::OidcProvider,
70    oidc_advanced_jarm::{
71        AdvancedJarmConfig, AdvancedJarmManager, AuthorizationResponse, DeliveryResult,
72        JarmDeliveryMode, JarmResponse, JarmValidationResult,
73    },
74    oidc_backchannel_logout::{
75        BackChannelLogoutConfig, BackChannelLogoutManager, BackChannelLogoutRequest,
76        BackChannelLogoutResponse, LogoutEvents, LogoutTokenClaims, NotificationResult,
77        RpBackChannelConfig,
78    },
79    oidc_enhanced_ciba::{
80        AuthenticationContext, AuthenticationMode, CibaDeviceInfo, CibaRequestStatus,
81        CibaTokenResponse, ConsentInfo, ConsentStatus, DeviceBinding, EnhancedCibaAuthRequest,
82        EnhancedCibaAuthResponse, EnhancedCibaConfig, EnhancedCibaManager, GeoLocation,
83        UserIdentifierHint,
84    },
85    oidc_error_extensions::{
86        AuthenticationRequirements, OidcErrorCode, OidcErrorManager, OidcErrorResponse,
87    },
88    oidc_extensions::OidcExtensionsManager,
89    oidc_frontchannel_logout::{
90        FailedNotification, FrontChannelLogoutConfig, FrontChannelLogoutManager,
91        FrontChannelLogoutRequest, FrontChannelLogoutResponse, RpFrontChannelConfig,
92    },
93    oidc_response_modes::{
94        FormPostResponseMode, JarmResponseMode, MultipleResponseTypesManager, ResponseMode,
95    },
96    oidc_rp_initiated_logout::{
97        ClientLogoutConfig, LogoutNotificationTarget, RpInitiatedLogoutConfig,
98        RpInitiatedLogoutManager, RpInitiatedLogoutRequest, RpInitiatedLogoutResponse,
99    },
100    oidc_session_management::{
101        OidcSession, OidcSessionState, SessionCheckRequest, SessionCheckResponse, SessionManager,
102    },
103    oidc_user_registration::{
104        RegistrationData, RegistrationManager, RegistrationRequest, RegistrationResponse,
105    },
106};
107
108// JWT re-exports
109pub use jwt::{
110    jwt_access_tokens::{JwtAccessTokenBuilder, JwtAccessTokenValidator},
111    jwt_best_practices::{
112        CryptoStrength, JwtBestPracticesConfig, JwtBestPracticesValidator, SecureJwtClaims,
113        SecurityLevel,
114    },
115    jwt_introspection::{
116        BasicIntrospectionResponse, JwtIntrospectionClaims, JwtIntrospectionConfig,
117        JwtIntrospectionManager,
118    },
119    private_key_jwt::PrivateKeyJwtManager,
120};
121
122// Token Exchange re-exports
123pub use token_exchange::{
124    advanced_token_exchange::{AdvancedTokenExchangeConfig, AdvancedTokenExchangeManager},
125    core::TokenExchangeManager,
126    token_exchange_common::{
127        ExchangeRequirements, ServiceComplexityLevel, TokenExchangeCapabilities,
128        TokenExchangeFactory, TokenExchangeService, TokenExchangeUseCase, TokenValidationResult,
129        ValidationUtils,
130    },
131    token_exchange_factory::{PerformanceCharacteristics, SetupGuide, TokenExchangeManagerFactory},
132};
133
134// Security re-exports
135pub use security::{
136    caep_continuous_access::{
137        CaepAccessDecision, CaepConfig, CaepDeviceInfo, CaepEvaluationResult, CaepEvaluationRule,
138        CaepEvent, CaepEventHandler, CaepEventSeverity, CaepEventSource, CaepEventType,
139        CaepLocationInfo, CaepManager, CaepRuleAction, CaepRuleCondition, CaepSessionState,
140    },
141    dpop::DpopManager,
142    fapi::FapiManager,
143    mtls::MutualTlsManager,
144    x509_signing::X509CertificateManager,
145};
146
147use crate::errors::Result;
148use crate::permissions::Permission;
149use async_trait::async_trait;
150use serde::{Deserialize, Serialize};
151use std::collections::HashMap;
152use std::time::SystemTime;
153
154// Re-export the canonical ClientType for use via `server::ClientType`.
155pub use crate::client::ClientType;
156
157/// Minimal server configuration for working components
158#[derive(Debug, Clone, Default)]
159pub struct WorkingServerConfig {}
160
161/// Trait for server-side authentication providers
162#[async_trait]
163pub trait AuthenticationProvider {
164    /// Provider name
165    fn name(&self) -> &str;
166
167    /// Initialize the provider
168    async fn initialize(&self) -> Result<()>;
169
170    /// Handle authentication request
171    async fn handle_auth_request(&self, request: AuthRequest) -> Result<AuthResponse>;
172
173    /// Validate credentials
174    async fn validate_credentials(&self, credentials: &str) -> Result<ValidationResult>;
175
176    /// Get provider metadata
177    async fn get_metadata(&self) -> Result<ProviderMetadata>;
178}
179
180/// Generic authentication request
181#[derive(Clone, Serialize, Deserialize)]
182pub struct AuthRequest {
183    /// Request type
184    pub request_type: String,
185
186    /// Request parameters
187    pub parameters: HashMap<String, String>,
188
189    /// Client information
190    pub client_id: Option<String>,
191
192    /// User information
193    pub user_id: Option<String>,
194
195    /// Request timestamp
196    pub timestamp: SystemTime,
197}
198
199impl std::fmt::Debug for AuthRequest {
200    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
201        let mut d = f.debug_struct("AuthRequest");
202        d.field("request_type", &self.request_type);
203        d.field(
204            "parameters",
205            &crate::utils::redact::redacted(&self.parameters),
206        );
207        d.field("client_id", &self.client_id);
208        d.field("user_id", &self.user_id);
209        d.field("timestamp", &self.timestamp);
210        d.finish()
211    }
212}
213
214/// Generic authentication response
215#[derive(Clone, Serialize, Deserialize)]
216pub struct AuthResponse {
217    /// Response type
218    pub response_type: String,
219
220    /// Response data
221    pub data: HashMap<String, serde_json::Value>,
222
223    /// Success indicator
224    pub success: bool,
225
226    /// Error message if any
227    pub error: Option<String>,
228
229    /// Response timestamp
230    pub timestamp: SystemTime,
231}
232
233impl std::fmt::Debug for AuthResponse {
234    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
235        let mut d = f.debug_struct("AuthResponse");
236        d.field("response_type", &self.response_type);
237        d.field("data", &crate::utils::redact::redacted(&self.data));
238        d.field("success", &self.success);
239        d.field("error", &self.error);
240        d.field("timestamp", &self.timestamp);
241        d.finish()
242    }
243}
244
245/// Validation result
246#[derive(Debug, Clone, Serialize, Deserialize)]
247pub struct ValidationResult {
248    /// Whether the credentials are valid
249    pub valid: bool,
250
251    /// User ID if valid
252    pub user_id: Option<String>,
253
254    /// Client ID if applicable
255    pub client_id: Option<String>,
256
257    /// Scopes granted
258    pub scopes: Vec<String>,
259
260    /// Permissions granted
261    pub permissions: Vec<Permission>,
262
263    /// Token expiration time
264    pub expires_at: Option<SystemTime>,
265
266    /// Additional metadata
267    pub metadata: HashMap<String, serde_json::Value>,
268}
269
270/// Provider metadata
271#[derive(Debug, Clone, Serialize, Deserialize)]
272pub struct ProviderMetadata {
273    /// Provider name
274    pub name: String,
275
276    /// Supported endpoints
277    pub endpoints: HashMap<String, String>,
278
279    /// Supported grant types
280    pub grant_types: Vec<String>,
281
282    /// Supported response types
283    pub response_types: Vec<String>,
284
285    /// Supported scopes
286    pub scopes: Vec<String>,
287
288    /// Additional metadata
289    pub additional: HashMap<String, serde_json::Value>,
290}