Skip to main content

auth_framework/api/
middleware.rs

1//! API Middleware
2//!
3//! Authentication, authorization, rate limiting, and other middleware
4
5use crate::api::{ApiResponse, ApiState, extract_bearer_token, validate_api_token};
6use axum::{
7    extract::{Request, State},
8    middleware::Next,
9    response::{IntoResponse, Response},
10};
11#[cfg(feature = "enhanced-rbac")]
12use std::net::{IpAddr, SocketAddr};
13use std::time::{Duration, Instant};
14
15/// The client address of a request: the connection's peer, unless the peer is one of the
16/// `trusted_proxies`, in which case the client it forwarded for.
17///
18/// A peer that is not a trusted proxy IS the client: its headers are ignored. A trusted
19/// proxy is believed: the client is the rightmost `X-Forwarded-For` entry that is not itself
20/// a trusted proxy (the entries to its left were supplied by the client and are ignored),
21/// else the proxy's own address (`X-Real-IP` is not consulted: many proxies pass a
22/// client-supplied copy through). Every trusted proxy must APPEND to `X-Forwarded-For`
23/// rather than pass it through. Anything unparsable falls back to the peer.
24#[cfg(feature = "enhanced-rbac")]
25pub(crate) fn forwarded_client_ip(
26    peer: IpAddr,
27    headers: &axum::http::HeaderMap,
28    trusted_proxies: &[IpAddr],
29) -> IpAddr {
30    let peer = peer.to_canonical();
31    let is_trusted = |ip: &IpAddr| trusted_proxies.iter().any(|t| t.to_canonical() == *ip);
32    if !is_trusted(&peer) {
33        return peer;
34    }
35    // A header line that is not text cannot be read, so which entry is rightmost is unknown:
36    // believe nothing and keep the peer.
37    let mut entries: Vec<&str> = Vec::new();
38    for value in headers.get_all("x-forwarded-for") {
39        match value.to_str() {
40            Ok(text) => entries.extend(text.split(',').map(str::trim)),
41            Err(_) => return peer,
42        }
43    }
44    for entry in entries.iter().rev() {
45        match parse_forwarded_addr(entry) {
46            Some(ip) if is_trusted(&ip) => continue,
47            Some(ip) => return ip,
48            None => return peer,
49        }
50    }
51    peer
52}
53
54/// Parse one `X-Forwarded-For` entry: a bare address, `addr:port`, or `[v6]` / `[v6]:port`.
55#[cfg(feature = "enhanced-rbac")]
56fn parse_forwarded_addr(entry: &str) -> Option<IpAddr> {
57    if let Ok(ip) = entry.parse::<IpAddr>() {
58        return Some(ip.to_canonical());
59    }
60    if let Ok(sock) = entry.parse::<SocketAddr>() {
61        return Some(sock.ip().to_canonical());
62    }
63    entry
64        .strip_prefix('[')
65        .and_then(|rest| rest.strip_suffix(']'))
66        .and_then(|inner| inner.parse::<IpAddr>().ok())
67        .map(|ip| ip.to_canonical())
68}
69
70/// Authentication middleware
71pub async fn auth_middleware(
72    State(state): State<ApiState>,
73    mut request: Request,
74    next: Next,
75) -> Result<Response, Response> {
76    // Skip auth for public endpoints
77    let path = request.uri().path();
78    if is_public_endpoint(path) {
79        return Ok(next.run(request).await);
80    }
81
82    // Extract token from headers
83    let headers = request.headers();
84    match extract_bearer_token(headers) {
85        Some(token) => {
86            // Validate token
87            match validate_api_token(&state.auth_framework, &token).await {
88                Ok(auth_token) => {
89                    // Add auth token to request extensions for use in handlers
90                    request.extensions_mut().insert(auth_token);
91                    Ok(next.run(request).await)
92                }
93                Err(_) => {
94                    let error_response = ApiResponse::<()>::unauthorized();
95                    Err(error_response.into_response())
96                }
97            }
98        }
99        None => {
100            let error_response = ApiResponse::<()>::unauthorized();
101            Err(error_response.into_response())
102        }
103    }
104}
105
106/// Admin authorization middleware
107pub async fn admin_middleware(
108    State(_state): State<ApiState>,
109    request: Request,
110    next: Next,
111) -> Result<Response, Response> {
112    // Get auth token from extensions (should be set by auth_middleware)
113    match request.extensions().get::<crate::tokens::AuthToken>() {
114        Some(auth_token) => {
115            if auth_token.roles.contains(&"admin".to_string()) {
116                Ok(next.run(request).await)
117            } else {
118                let error_response = ApiResponse::<()>::forbidden();
119                Err(error_response.into_response())
120            }
121        }
122        None => {
123            // If no auth token, user is not authenticated
124            let error_response = ApiResponse::<()>::unauthorized();
125            Err(error_response.into_response())
126        }
127    }
128}
129
130/// Rate limiting middleware
131pub async fn rate_limit_middleware(request: Request, next: Next) -> Result<Response, Response> {
132    // In a real implementation, use a distributed rate limiter like Redis
133    // For now, just add rate limit headers
134
135    let mut response = next.run(request).await;
136
137    // Add rate limit headers
138    let headers = response.headers_mut();
139    headers.insert("X-RateLimit-Limit", "100".parse().unwrap());
140    headers.insert("X-RateLimit-Remaining", "95".parse().unwrap());
141    headers.insert("X-RateLimit-Reset", "1692278400".parse().unwrap()); // Unix timestamp
142
143    Ok(response)
144}
145
146/// CORS middleware
147pub async fn cors_middleware(request: Request, next: Next) -> Response {
148    let response = next.run(request).await;
149
150    let mut response = response;
151    let headers = response.headers_mut();
152
153    headers.insert("Access-Control-Allow-Origin", "*".parse().unwrap());
154    headers.insert(
155        "Access-Control-Allow-Methods",
156        "GET, POST, PUT, DELETE, OPTIONS".parse().unwrap(),
157    );
158    headers.insert(
159        "Access-Control-Allow-Headers",
160        "Content-Type, Authorization".parse().unwrap(),
161    );
162    headers.insert("Access-Control-Max-Age", "3600".parse().unwrap());
163
164    response
165}
166
167/// Logging middleware
168pub async fn logging_middleware(request: Request, next: Next) -> Response {
169    let start = Instant::now();
170    let method = request.method().clone();
171    let uri = request.uri().clone();
172    let headers = request.headers().clone();
173
174    // Extract user agent and IP for logging
175    let user_agent = headers
176        .get("user-agent")
177        .and_then(|v| v.to_str().ok())
178        .unwrap_or("unknown");
179
180    let forwarded_for = headers
181        .get("x-forwarded-for")
182        .and_then(|v| v.to_str().ok())
183        .unwrap_or("unknown");
184
185    tracing::info!(
186        "Request started: {} {} from {} ({})",
187        method,
188        uri,
189        forwarded_for,
190        user_agent
191    );
192
193    let response = next.run(request).await;
194    let duration = start.elapsed();
195    let status = response.status();
196
197    tracing::info!(
198        "Request completed: {} {} {} in {:?}",
199        method,
200        uri,
201        status,
202        duration
203    );
204
205    response
206}
207
208/// Security headers middleware
209pub async fn security_headers_middleware(request: Request, next: Next) -> Response {
210    let response = next.run(request).await;
211
212    let mut response = response;
213    let headers = response.headers_mut();
214
215    // Security headers
216    headers.insert("X-Content-Type-Options", "nosniff".parse().unwrap());
217    headers.insert("X-Frame-Options", "DENY".parse().unwrap());
218    headers.insert("X-XSS-Protection", "1; mode=block".parse().unwrap());
219    headers.insert(
220        "Strict-Transport-Security",
221        "max-age=31536000; includeSubDomains".parse().unwrap(),
222    );
223    headers.insert(
224        "Referrer-Policy",
225        "strict-origin-when-cross-origin".parse().unwrap(),
226    );
227    headers.insert(
228        "Permissions-Policy",
229        "camera=(), microphone=(), geolocation=()".parse().unwrap(),
230    );
231
232    response
233}
234
235/// Request timeout middleware
236pub async fn timeout_middleware(request: Request, next: Next) -> Result<Response, Response> {
237    // Set a 30-second timeout for all requests
238    match tokio::time::timeout(Duration::from_secs(30), next.run(request)).await {
239        Ok(response) => Ok(response),
240        Err(_) => {
241            let error_response =
242                ApiResponse::<()>::error("REQUEST_TIMEOUT", "Request timed out after 30 seconds");
243            Err(error_response.into_response())
244        }
245    }
246}
247
248/// Check if endpoint is public (doesn't require authentication)
249fn is_public_endpoint(path: &str) -> bool {
250    match path {
251        "/health" | "/health/detailed" | "/metrics" | "/readiness" | "/liveness" => true,
252        "/auth/login" | "/auth/refresh" | "/auth/providers" => true,
253        "/oauth/authorize" | "/oauth/token" | "/oauth/.well-known/openid_configuration" => true,
254        _ if path.starts_with("/oauth/.well-known/") => true,
255        _ => false,
256    }
257}
258
259/// Permission check helper
260pub fn check_permission(auth_token: &crate::tokens::AuthToken, required_permission: &str) -> bool {
261    auth_token.permissions.iter().any(|perm| {
262        perm == required_permission
263            || perm == "*"
264            || (perm.ends_with("*") && required_permission.starts_with(&perm[..perm.len() - 1]))
265    })
266}
267
268/// Role check helper
269pub fn check_role(auth_token: &crate::tokens::AuthToken, required_role: &str) -> bool {
270    auth_token.roles.contains(&required_role.to_string())
271        || auth_token.roles.contains(&"admin".to_string()) // Admin has all roles
272}
273
274