Skip to main content

yaiko_core/
security.rs

1//! Security middleware for Yaiko applications
2//!
3//! Provides CSRF protection, rate limiting, and security headers.
4
5use 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
11/// Security headers middleware
12/// Adds common security headers to all responses
13pub 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        // Add security headers
37        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
50/// Rate limiter using token bucket algorithm
51pub 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        // Background cleanup task
64        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            // Reset if window expired
136            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
162/// CSRF protection middleware using double-submit cookie pattern
163pub 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        // Skip CSRF check for safe methods
200        if method == "GET" || method == "HEAD" || method == "OPTIONS" {
201            let mut response = next.handle(req).await?;
202
203            // Reuse the existing token so cached pages and multi-tab flows remain valid.
204            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        // For unsafe methods, verify CSRF token
214        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}