Struct SecurityService 

pub struct SecurityService { /* private fields */ }

Main security service combining all components

Implementations

impl SecurityService

pub async fn new(config: SecurityConfig) -> Result<Self>

Create a new security service with the given configuration

pub async fn authenticate_local( &self, identifier: &str, password: &str, ) -> Result<AuthResult>

Authenticate a user with username/email and password

pub async fn start_oauth2_flow( &self, provider: OAuth2Provider, ) -> Result<String>

Start OAuth2 authentication flow

pub async fn complete_oauth2_flow( &self, provider: OAuth2Provider, code: &str, state: &str, ) -> Result<AuthResult>

Complete OAuth2 authentication flow

pub fn setup_mfa(&self, user_id: &str) -> Result<(String, String)>

Generate MFA secret and QR code for user

pub fn verify_mfa(&self, secret: &str, code: &str) -> Result<bool>

Verify MFA code

pub fn validate_token(&self, token: &str) -> Result<JwtClaims>

Validate JWT token

pub fn generate_tokens( &self, user_id: &str, roles: Vec<String>, ) -> Result<TokenPair>

Generate new token pair

pub fn refresh_token(&self, refresh_token: &str) -> Result<TokenPair>

Refresh access token

pub fn check_authorization( &self, principal: &Principal, resource: &Resource, ) -> AuthzResult

Check authorization for principal on resource using capabilities

pub fn hash_password(&self, password: &str) -> Result<PasswordHash>

Hash password

pub fn verify_password( &self, password: &str, hash: &PasswordHash, ) -> Result<bool>

Verify password against hash

pub fn grant_capabilities( &self, principal_caps: &CapabilitySet, new_caps: Vec<Capability>, ) -> CapabilitySet

Grant capabilities to a principal

pub fn revoke_capabilities( &self, principal_caps: &CapabilitySet, caps_to_revoke: Vec<Capability>, ) -> CapabilitySet

Revoke capabilities from a principal

pub fn attenuate_capabilities( &self, cap_set: &CapabilitySet, restrictions: Vec<Capability>, ) -> CapabilitySet

Create an attenuated capability set for safer operations

pub fn create_principal_with_capabilities( &self, user_id: String, capabilities: CapabilitySet, roles: Vec<String>, permissions: Vec<String>, attributes: HashMap<String, Value>, ) -> Principal

Create a principal with specific capabilities

pub fn create_resource( &self, resource_type: ResourceType, action: Action, resource_id: Option<String>, attributes: HashMap<String, Value>, ) -> Resource

Create a resource for authorization checks

pub async fn log_audit_event(&self, event: AuditEvent) -> Result<()>

Log an audit event

pub async fn log_authentication( &self, user_id: Option<&str>, ip_address: Option<&str>, user_agent: Option<&str>, result: AuditResult, message: &str, ) -> Result<()>

Log authentication event

pub async fn log_authorization( &self, user_id: &str, resource: &str, action: &str, result: AuditResult, ip_address: Option<&str>, ) -> Result<()>

Log authorization event

pub async fn log_data_access( &self, user_id: &str, resource: &str, action: &str, result: AuditResult, metadata: HashMap<String, Value>, ) -> Result<()>

Log data access event

pub async fn get_audit_events( &self, start_time: Option<DateTime<Utc>>, end_time: Option<DateTime<Utc>>, event_type: Option<&AuditEventType>, user_id: Option<&str>, limit: Option<usize>, ) -> Result<Vec<AuditEvent>>

Get audit events

pub async fn get_audit_statistics(&self) -> Result<AuditStatistics>

Get audit statistics

pub async fn cleanup_audit_events(&self) -> Result<usize>

Clean up old audit events

pub fn setup_policy_service(&mut self, config: PolicyEngineConfig) -> Result<()>

Set up policy service with RBAC and ABAC

pub fn set_policy_service(&mut self, policy_service: PolicyService)

Set policy service directly

pub async fn check_access_policy( &self, principal_id: &str, resource_type: &ResourceType, resource_id: Option<&str>, action: &Action, ) -> Result<bool>

Check access permission using unified RBAC/ABAC policy engine

pub async fn authorize_action( &self, principal_id: &str, resource_type: &ResourceType, resource_id: Option<&str>, action: &Action, ) -> Result<UnifiedPolicyDecision>

Authorize action with detailed policy decision

pub fn add_role(&mut self, role: Role) -> Result<()>

Add RBAC role

pub fn assign_role(&mut self, assignment: RoleAssignment) -> Result<()>

Assign role to principal

pub fn add_policy(&mut self, policy: Policy) -> Result<()>

Add ABAC policy

pub fn setup_common_policies(&mut self) -> Result<()>

Setup common roles and policies

pub fn policy_service(&self) -> Option<&PolicyService>

Get policy service for advanced operations

pub fn policy_service_mut(&mut self) -> Option<&mut PolicyService>

Get mutable policy service