Skip to main content

yaiko_core/
auth.rs

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}