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    token_introspection::{TokenIntrospectionHandler, TokenIntrospectionService},
133};
134
135// Security re-exports
136pub use security::{
137    caep_continuous_access::{
138        CaepAccessDecision, CaepConfig, CaepDeviceInfo, CaepEvaluationResult, CaepEvaluationRule,
139        CaepEvent, CaepEventHandler, CaepEventSeverity, CaepEventSource, CaepEventType,
140        CaepLocationInfo, CaepManager, CaepRuleAction, CaepRuleCondition, CaepSessionState,
141    },
142    dpop::DpopManager,
143    fapi::FapiManager,
144    mtls::MutualTlsManager,
145    x509_signing::X509CertificateManager,
146};
147
148use crate::errors::Result;
149use crate::permissions::Permission;
150use async_trait::async_trait;
151use serde::{Deserialize, Serialize};
152use std::collections::HashMap;
153use std::time::SystemTime;
154
155// Re-export the canonical ClientType for use via `server::ClientType`.
156pub use crate::client::ClientType;
157
158/// Minimal server configuration for working components
159#[derive(Debug, Clone, Default)]
160pub struct WorkingServerConfig {}
161
162/// Trait for server-side authentication providers
163#[async_trait]
164pub trait AuthenticationProvider {
165    /// Provider name
166    fn name(&self) -> &str;
167
168    /// Initialize the provider
169    async fn initialize(&self) -> Result<()>;
170
171    /// Handle authentication request
172    async fn handle_auth_request(&self, request: AuthRequest) -> Result<AuthResponse>;
173
174    /// Validate credentials
175    async fn validate_credentials(&self, credentials: &str) -> Result<ValidationResult>;
176
177    /// Get provider metadata
178    async fn get_metadata(&self) -> Result<ProviderMetadata>;
179}
180
181/// Generic authentication request
182#[derive(Clone, Serialize, Deserialize)]
183pub struct AuthRequest {
184    /// Request type
185    pub request_type: String,
186
187    /// Request parameters
188    pub parameters: HashMap<String, String>,
189
190    /// Client information
191    pub client_id: Option<String>,
192
193    /// User information
194    pub user_id: Option<String>,
195
196    /// Request timestamp
197    pub timestamp: SystemTime,
198}
199
200impl std::fmt::Debug for AuthRequest {
201    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
202        let mut d = f.debug_struct("AuthRequest");
203        d.field("request_type", &self.request_type);
204        d.field(
205            "parameters",
206            &crate::utils::redact::redacted(&self.parameters),
207        );
208        d.field("client_id", &self.client_id);
209        d.field("user_id", &self.user_id);
210        d.field("timestamp", &self.timestamp);
211        d.finish()
212    }
213}
214
215/// Generic authentication response
216#[derive(Clone, Serialize, Deserialize)]
217pub struct AuthResponse {
218    /// Response type
219    pub response_type: String,
220
221    /// Response data
222    pub data: HashMap<String, serde_json::Value>,
223
224    /// Success indicator
225    pub success: bool,
226
227    /// Error message if any
228    pub error: Option<String>,
229
230    /// Response timestamp
231    pub timestamp: SystemTime,
232}
233
234impl std::fmt::Debug for AuthResponse {
235    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
236        let mut d = f.debug_struct("AuthResponse");
237        d.field("response_type", &self.response_type);
238        d.field("data", &crate::utils::redact::redacted(&self.data));
239        d.field("success", &self.success);
240        d.field("error", &self.error);
241        d.field("timestamp", &self.timestamp);
242        d.finish()
243    }
244}
245
246/// Validation result
247#[derive(Debug, Clone, Serialize, Deserialize)]
248pub struct ValidationResult {
249    /// Whether the credentials are valid
250    pub valid: bool,
251
252    /// User ID if valid
253    pub user_id: Option<String>,
254
255    /// Client ID if applicable
256    pub client_id: Option<String>,
257
258    /// Scopes granted
259    pub scopes: Vec<String>,
260
261    /// Permissions granted
262    pub permissions: Vec<Permission>,
263
264    /// Token expiration time
265    pub expires_at: Option<SystemTime>,
266
267    /// Additional metadata
268    pub metadata: HashMap<String, serde_json::Value>,
269}
270
271/// Provider metadata
272#[derive(Debug, Clone, Serialize, Deserialize)]
273pub struct ProviderMetadata {
274    /// Provider name
275    pub name: String,
276
277    /// Supported endpoints
278    pub endpoints: HashMap<String, String>,
279
280    /// Supported grant types
281    pub grant_types: Vec<String>,
282
283    /// Supported response types
284    pub response_types: Vec<String>,
285
286    /// Supported scopes
287    pub scopes: Vec<String>,
288
289    /// Additional metadata
290    pub additional: HashMap<String, serde_json::Value>,
291}