1use crate::{Handler, Middleware, Request, Response, StatusCode};
6use async_trait::async_trait;
7use std::collections::HashMap;
8use std::sync::{Arc, Mutex};
9use std::time::{Duration, Instant};
10
11pub struct SecurityHeaders;
14
15impl Default for SecurityHeaders {
16 fn default() -> Self {
17 Self::new()
18 }
19}
20
21impl SecurityHeaders {
22 pub fn new() -> Self {
23 Self
24 }
25}
26
27#[async_trait]
28impl Middleware for SecurityHeaders {
29 async fn handle(
30 &self,
31 req: Request,
32 next: Arc<dyn Handler>,
33 ) -> Result<Response, Box<dyn std::error::Error + Send + Sync>> {
34 let mut response = next.handle(req).await?;
35
36 response = response
38 .header("X-Content-Type-Options", "nosniff")
39 .header("X-Frame-Options", "DENY")
40 .header("X-XSS-Protection", "1; mode=block")
41 .header("Referrer-Policy", "strict-origin-when-cross-origin")
42 .header("Permissions-Policy", "geolocation=(), microphone=(), camera=()")
43 .header("Content-Security-Policy", "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'")
44 .header("Strict-Transport-Security", "max-age=31536000; includeSubDomains");
45
46 Ok(response)
47 }
48}
49
50pub struct RateLimiter {
52 requests_per_window: u32,
53 window_duration: Duration,
54 buckets: Arc<Mutex<HashMap<String, (u32, Instant)>>>,
55 trust_proxy_headers: bool,
56}
57
58impl RateLimiter {
59 pub fn new(requests_per_window: u32, window_secs: u64) -> Self {
60 let window_duration = Duration::from_secs(window_secs);
61 let buckets = Arc::new(Mutex::new(HashMap::new()));
62
63 let cleanup_buckets = buckets.clone();
65 tokio::spawn(async move {
66 let mut interval = tokio::time::interval(Duration::from_secs(300));
67 loop {
68 interval.tick().await;
69 if let Ok(mut map) = cleanup_buckets.lock() {
70 let now = Instant::now();
71 map.retain(|_, &mut (_, timestamp)| {
72 now.duration_since(timestamp) <= window_duration
73 });
74 }
75 }
76 });
77
78 Self {
79 requests_per_window,
80 window_duration,
81 buckets,
82 trust_proxy_headers: false,
83 }
84 }
85
86 pub fn trust_proxy_headers(mut self, trust: bool) -> Self {
87 self.trust_proxy_headers = trust;
88 self
89 }
90
91 fn get_client_ip(&self, req: &Request) -> String {
92 if self.trust_proxy_headers {
93 if let Some(ip) = req
94 .headers
95 .get("x-forwarded-for")
96 .and_then(|v| v.to_str().ok())
97 .map(|s| s.split(',').next().unwrap_or("unknown").trim().to_string())
98 .filter(|s| !s.is_empty())
99 {
100 return ip;
101 }
102
103 if let Some(ip) = req
104 .headers
105 .get("x-real-ip")
106 .and_then(|v| v.to_str().ok())
107 .map(|s| s.to_string())
108 .filter(|s| !s.is_empty())
109 {
110 return ip;
111 }
112 }
113
114 req.remote_addr
115 .map(|addr| addr.ip().to_string())
116 .unwrap_or_else(|| "unknown".to_string())
117 }
118}
119
120#[async_trait]
121impl Middleware for RateLimiter {
122 async fn handle(
123 &self,
124 req: Request,
125 next: Arc<dyn Handler>,
126 ) -> Result<Response, Box<dyn std::error::Error + Send + Sync>> {
127 let client_ip = self.get_client_ip(&req);
128
129 let allowed = {
130 let mut buckets = self.buckets.lock().unwrap();
131 let now = Instant::now();
132
133 let entry = buckets.entry(client_ip.clone()).or_insert((0, now));
134
135 if now.duration_since(entry.1) > self.window_duration {
137 *entry = (0, now);
138 }
139
140 if entry.0 < self.requests_per_window {
141 entry.0 += 1;
142 true
143 } else {
144 false
145 }
146 };
147
148 if !allowed {
149 return Ok(Response::new()
150 .status(StatusCode::TOO_MANY_REQUESTS)
151 .header(
152 "Retry-After",
153 self.window_duration.as_secs().to_string().as_str(),
154 )
155 .text(r#"{"error": "Rate limit exceeded"}"#));
156 }
157
158 next.handle(req).await
159 }
160}
161
162pub struct CsrfProtection {
164 cookie_name: String,
165 header_name: String,
166 form_field_name: String,
167}
168
169impl Default for CsrfProtection {
170 fn default() -> Self {
171 Self::new()
172 }
173}
174
175impl CsrfProtection {
176 pub fn new() -> Self {
177 Self {
178 cookie_name: "csrf_token".to_string(),
179 header_name: "X-CSRF-Token".to_string(),
180 form_field_name: "_csrf".to_string(),
181 }
182 }
183
184 fn generate_token() -> String {
185 uuid::Uuid::new_v4().to_string()
186 }
187}
188
189#[async_trait]
190impl Middleware for CsrfProtection {
191 async fn handle(
192 &self,
193 mut req: Request,
194 next: Arc<dyn Handler>,
195 ) -> Result<Response, Box<dyn std::error::Error + Send + Sync>> {
196 let method = req.method.as_str();
197 let cookie_token = extract_cookie_value(req.header("cookie"), &self.cookie_name);
198
199 if method == "GET" || method == "HEAD" || method == "OPTIONS" {
201 let mut response = next.handle(req).await?;
202
203 let token = cookie_token.unwrap_or_else(Self::generate_token);
205 response = response.header(
206 "Set-Cookie",
207 &format!("{}={}; Path=/; SameSite=Strict", self.cookie_name, token),
208 );
209
210 return Ok(response);
211 }
212
213 let header_token = req.header(&self.header_name).map(|s| s.to_string());
215 let form_token = if req
216 .header("content-type")
217 .map(|ct| ct.starts_with("application/x-www-form-urlencoded"))
218 .unwrap_or(false)
219 {
220 req.form_data().await?.get(&self.form_field_name).cloned()
221 } else {
222 None
223 };
224
225 let request_token = header_token.or(form_token);
226
227 match (cookie_token, request_token) {
228 (Some(cookie), Some(header)) if cookie == header => next.handle(req).await,
229 _ => Ok(Response::new()
230 .status(StatusCode::FORBIDDEN)
231 .text(r#"{"error": "CSRF token validation failed"}"#)),
232 }
233 }
234}
235
236fn extract_cookie_value(cookie_header: Option<&str>, cookie_name: &str) -> Option<String> {
237 cookie_header.and_then(|cookies| {
238 cookies.split(';').find_map(|cookie| {
239 let (name, value) = cookie.trim().split_once('=')?;
240
241 (name == cookie_name).then(|| value.to_string())
242 })
243 })
244}
245
246#[cfg(test)]
247mod tests {
248 use super::*;
249 use hyper::Body;
250 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
251
252 #[tokio::test]
253 async fn csrf_cookie_is_reusable_and_not_httponly() {
254 let middleware = CsrfProtection::new();
255 let next = Arc::new(|_req: Request| async { Ok(Response::new().text("ok")) });
256
257 let get_req = Request::from_hyper(
258 hyper::Request::builder()
259 .method("GET")
260 .uri("/")
261 .body(Body::empty())
262 .unwrap(),
263 )
264 .await
265 .unwrap();
266 let first = middleware.handle(get_req, next.clone()).await.unwrap();
267 let set_cookie = first.headers.get("Set-Cookie").unwrap().clone();
268
269 assert!(!set_cookie.contains("HttpOnly"));
270
271 let post_req = Request::from_hyper(
272 hyper::Request::builder()
273 .method("POST")
274 .uri("/")
275 .header("cookie", &set_cookie)
276 .header(
277 "X-CSRF-Token",
278 extract_cookie_value(Some(&set_cookie), "csrf_token").unwrap(),
279 )
280 .body(Body::empty())
281 .unwrap(),
282 )
283 .await
284 .unwrap();
285 let response = middleware.handle(post_req, next).await.unwrap();
286
287 assert_eq!(response.status, StatusCode::OK);
288 }
289
290 #[tokio::test]
291 async fn rate_limiter_ignores_spoofed_proxy_headers_by_default() {
292 let limiter = RateLimiter::new(1, 60);
293 let next = Arc::new(|_req: Request| async { Ok(Response::new().text("ok")) });
294 let remote_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 3000);
295
296 let first = Request::from_hyper_with_addr(
297 hyper::Request::builder()
298 .method("GET")
299 .uri("/")
300 .header("x-forwarded-for", "1.1.1.1")
301 .body(Body::empty())
302 .unwrap(),
303 Some(remote_addr),
304 )
305 .await
306 .unwrap();
307 assert_eq!(
308 limiter.handle(first, next.clone()).await.unwrap().status,
309 StatusCode::OK
310 );
311
312 let second = Request::from_hyper_with_addr(
313 hyper::Request::builder()
314 .method("GET")
315 .uri("/")
316 .header("x-forwarded-for", "8.8.8.8")
317 .body(Body::empty())
318 .unwrap(),
319 Some(remote_addr),
320 )
321 .await
322 .unwrap();
323 assert_eq!(
324 limiter.handle(second, next).await.unwrap().status,
325 StatusCode::TOO_MANY_REQUESTS
326 );
327 }
328}