1use crate::session::SessionHandle;
2use crate::{Handler, Middleware, Request, Response};
3use async_trait::async_trait;
4use jsonwebtoken::{decode, encode, DecodingKey, EncodingKey, Header, Validation};
5use serde::{Deserialize, Serialize};
6use std::sync::Arc;
7
8#[derive(Debug, Serialize, Deserialize)]
9pub struct Claims {
10 pub sub: String,
11 pub exp: usize,
12 pub iat: usize,
13 pub roles: Vec<String>,
14}
15
16#[allow(dead_code)]
17pub struct JwtAuth {
18 secret: String,
19 algorithm: jsonwebtoken::Algorithm,
20}
21
22impl JwtAuth {
23 pub fn new(secret: &str) -> Self {
24 JwtAuth {
25 secret: secret.to_string(),
26 algorithm: jsonwebtoken::Algorithm::HS256,
27 }
28 }
29
30 pub fn generate_token(
31 &self,
32 user_id: &str,
33 roles: Vec<String>,
34 ) -> Result<String, jsonwebtoken::errors::Error> {
35 let now = chrono::Utc::now();
36 let exp = now + chrono::Duration::hours(24);
37
38 let claims = Claims {
39 sub: user_id.to_string(),
40 exp: exp.timestamp() as usize,
41 iat: now.timestamp() as usize,
42 roles,
43 };
44
45 encode(
46 &Header::default(),
47 &claims,
48 &EncodingKey::from_secret(self.secret.as_ref()),
49 )
50 }
51
52 pub fn verify_token(&self, token: &str) -> Result<Claims, jsonwebtoken::errors::Error> {
53 let mut validation = Validation::new(self.algorithm);
54 validation.validate_exp = true;
55 decode::<Claims>(
56 token,
57 &DecodingKey::from_secret(self.secret.as_ref()),
58 &validation,
59 )
60 .map(|data| data.claims)
61 }
62}
63
64pub struct AuthMiddleware {
65 jwt: Arc<JwtAuth>,
66 skip_paths: Vec<String>,
67}
68
69impl AuthMiddleware {
70 pub fn new(jwt: Arc<JwtAuth>) -> Self {
71 AuthMiddleware {
72 jwt,
73 skip_paths: vec!["/login".to_string(), "/register".to_string()],
74 }
75 }
76
77 pub fn skip_path(mut self, path: &str) -> Self {
78 self.skip_paths.push(path.to_string());
79 self
80 }
81}
82
83#[async_trait]
84impl Middleware for AuthMiddleware {
85 async fn handle(
86 &self,
87 mut req: Request,
88 next: Arc<dyn Handler>,
89 ) -> Result<Response, Box<dyn std::error::Error + Send + Sync>> {
90 if self.skip_paths.contains(&req.uri.path().to_string()) {
91 return next.handle(req).await;
92 }
93
94 let token = req
95 .headers
96 .get("authorization")
97 .and_then(|auth| auth.to_str().ok())
98 .and_then(|auth| auth.strip_prefix("Bearer "));
99
100 if let Some(token) = token {
101 match self.jwt.verify_token(token) {
102 Ok(claims) => {
103 req.user_id = Some(claims.sub);
104 req.user_roles = claims.roles;
105 next.handle(req).await
106 }
107 Err(_) => Ok(unauthorized_json("Invalid token")?),
108 }
109 } else {
110 Ok(unauthorized_json("Missing token")?)
111 }
112 }
113}
114
115pub struct SessionAuth {
116 skip_paths: Vec<String>,
117 user_id_key: String,
118 roles_key: String,
119 optional: bool,
120}
121
122impl SessionAuth {
123 pub fn new() -> Self {
124 Self {
125 skip_paths: vec!["/login".to_string(), "/register".to_string()],
126 user_id_key: "user_id".to_string(),
127 roles_key: "roles".to_string(),
128 optional: false,
129 }
130 }
131
132 pub fn skip_path(mut self, path: &str) -> Self {
133 self.skip_paths.push(path.to_string());
134 self
135 }
136
137 pub fn optional(mut self) -> Self {
138 self.optional = true;
139 self
140 }
141
142 pub fn user_id_key(mut self, key: &str) -> Self {
143 self.user_id_key = key.to_string();
144 self
145 }
146
147 pub fn roles_key(mut self, key: &str) -> Self {
148 self.roles_key = key.to_string();
149 self
150 }
151}
152
153impl Default for SessionAuth {
154 fn default() -> Self {
155 Self::new()
156 }
157}
158
159#[async_trait]
160impl Middleware for SessionAuth {
161 async fn handle(
162 &self,
163 mut req: Request,
164 next: Arc<dyn Handler>,
165 ) -> Result<Response, Box<dyn std::error::Error + Send + Sync>> {
166 if self.skip_paths.iter().any(|path| path == req.uri.path()) {
167 return next.handle(req).await;
168 }
169
170 if let Some(session) = &req.session {
171 if let Some(user_id) = session.get::<String>(&self.user_id_key) {
172 req.user_id = Some(user_id);
173 req.user_roles = session
174 .get::<Vec<String>>(&self.roles_key)
175 .unwrap_or_default();
176 return next.handle(req).await;
177 }
178 }
179
180 if self.optional {
181 return next.handle(req).await;
182 }
183
184 Ok(unauthorized_json("Authentication required")?)
185 }
186}
187
188pub fn login_session(
189 session: &SessionHandle,
190 user_id: &str,
191 roles: &[String],
192) -> Result<(), serde_json::Error> {
193 session.rotate_id();
194 session.set("user_id", user_id)?;
195 session.set("roles", roles)?;
196 Ok(())
197}
198
199pub fn logout_session(session: &SessionHandle) {
200 session.destroy();
201}
202
203pub fn require_role(req: &Request, role: &str) -> Result<(), Response> {
204 if req.user_roles.iter().any(|existing| existing == role) {
205 Ok(())
206 } else {
207 Err(Response::new()
208 .status(hyper::StatusCode::FORBIDDEN)
209 .json(&serde_json::json!({ "error": "Forbidden" }))
210 .expect("failed to serialize forbidden response"))
211 }
212}
213
214fn unauthorized_json(message: &str) -> Result<Response, serde_json::Error> {
215 Response::new()
216 .status(hyper::StatusCode::UNAUTHORIZED)
217 .json(&serde_json::json!({ "error": message }))
218}
219
220#[cfg(test)]
221mod tests {
222 use super::*;
223 use crate::{MemorySessionStore, Request, SessionMiddleware, StatusCode};
224 use hyper::Body;
225
226 #[tokio::test]
227 async fn session_auth_sets_user_context_and_allows_access() {
228 let store = Arc::new(MemorySessionStore::new());
229 let session_middleware = SessionMiddleware::new(store).secure(false);
230 let auth_middleware = Arc::new(SessionAuth::new());
231
232 let login_handler = Arc::new(|req: Request| async move {
233 let session = req.session.as_ref().unwrap();
234 login_session(session, "user-1", &["admin".to_string()]).unwrap();
235 Ok(Response::new().status(StatusCode::OK))
236 });
237 let login_req = Request::from_hyper(
238 hyper::Request::builder()
239 .method("GET")
240 .uri("/login")
241 .body(Body::empty())
242 .unwrap(),
243 )
244 .await
245 .unwrap();
246 let login_response = session_middleware
247 .handle(login_req, login_handler)
248 .await
249 .unwrap();
250 let cookie = login_response.headers.get("Set-Cookie").unwrap().clone();
251
252 let protected_handler = Arc::new(|req: Request| async move {
253 Ok(Response::new().text(req.user_id.as_deref().unwrap_or("missing")))
254 });
255 let protected_req = Request::from_hyper(
256 hyper::Request::builder()
257 .method("GET")
258 .uri("/dashboard")
259 .header("cookie", cookie)
260 .body(Body::empty())
261 .unwrap(),
262 )
263 .await
264 .unwrap();
265 let auth = auth_middleware.clone();
266 let protected = protected_handler.clone();
267 let hydrated = session_middleware
268 .handle(
269 protected_req,
270 Arc::new(move |req: Request| {
271 let auth = auth.clone();
272 let protected = protected.clone();
273 async move { auth.handle(req, protected).await }
274 }),
275 )
276 .await
277 .unwrap();
278
279 let body = hyper::body::to_bytes(hydrated.body).await.unwrap();
280 assert_eq!(&body[..], b"user-1");
281 }
282
283 #[tokio::test]
284 async fn session_auth_rejects_missing_session() {
285 let auth = SessionAuth::new();
286 let next = Arc::new(|_req: Request| async move { Ok(Response::new().text("ok")) });
287 let req = Request::from_hyper(
288 hyper::Request::builder()
289 .method("GET")
290 .uri("/protected")
291 .body(Body::empty())
292 .unwrap(),
293 )
294 .await
295 .unwrap();
296
297 let response = auth.handle(req, next).await.unwrap();
298 assert_eq!(response.status, StatusCode::UNAUTHORIZED);
299 }
300}