auth_framework/api/
middleware.rs1use 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#[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 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#[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
70pub async fn auth_middleware(
72 State(state): State<ApiState>,
73 mut request: Request,
74 next: Next,
75) -> Result<Response, Response> {
76 let path = request.uri().path();
78 if is_public_endpoint(path) {
79 return Ok(next.run(request).await);
80 }
81
82 let headers = request.headers();
84 match extract_bearer_token(headers) {
85 Some(token) => {
86 match validate_api_token(&state.auth_framework, &token).await {
88 Ok(auth_token) => {
89 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
106pub async fn admin_middleware(
108 State(_state): State<ApiState>,
109 request: Request,
110 next: Next,
111) -> Result<Response, Response> {
112 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 let error_response = ApiResponse::<()>::unauthorized();
125 Err(error_response.into_response())
126 }
127 }
128}
129
130pub async fn rate_limit_middleware(request: Request, next: Next) -> Result<Response, Response> {
132 let mut response = next.run(request).await;
136
137 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()); Ok(response)
144}
145
146pub 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
167pub 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 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
208pub 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 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
235pub async fn timeout_middleware(request: Request, next: Next) -> Result<Response, Response> {
237 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
248fn 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
259pub 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
268pub 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()) }
273
274