Changes to token (#21)

Reviewed-on: #21
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>

src/callers/login.rs

@@ -42,55 +42,48 @@ pub mod endpoint {
         axum::Extension(pool): axum::Extension<sqlx::PgPool>,
         Json(payload): Json<request::Request>,
     ) -> (StatusCode, Json<response::Response>) {
-        let usr = icarus_models::user::User {
-            username: payload.username,
-            password: payload.password,
-            ..Default::default()
-        };
-
         // Check if user exists
-        match repo::user::exists(&pool, &usr.username).await {
+        match repo::user::get(&pool, &payload.username).await {
-            Ok(exists) => {
+            Ok(user) => {
-                if !exists {
+                let salt = repo::salt::get(&pool, &user.salt_id).await.unwrap();
-                    return not_found("Not Found").await;
+                let salt_str = hashing::get_salt(&salt.salt).unwrap();
-                }
+                let unhashed_password = payload.password;
-            }
-            Err(err) => {
-                return not_found(&err.to_string()).await;
-            }
-        };
 
-        let user = repo::user::get(&pool, &usr.username).await.unwrap();
+                // Check if password is correct
-        let salt = repo::salt::get(&pool, &user.salt_id).await.unwrap();
+                match hashing::hash_password(&unhashed_password, &salt_str) {
-        let salt_str = hashing::get_salt(&salt.salt).unwrap();
+                    Ok(hash_password) => {
+                        if hashing::verify_password(&unhashed_password, hash_password.clone())
+                            .unwrap()
+                        {
+                            // Create token
+                            let key = token_stuff::get_key().unwrap();
+                            let (token_literal, duration) =
+                                token_stuff::create_token(&key).unwrap();
 
-        // Check if password is correct
+                            if token_stuff::verify_token(&key, &token_literal) {
-        match hashing::hash_password(&usr.password, &salt_str) {
+                                (
-            Ok(hash_password) => {
+                                    StatusCode::OK,
-                if hashing::verify_password(&usr.password, hash_password.clone()).unwrap() {
+                                    Json(response::Response {
-                    // Create token
+                                        message: String::from("Successful"),
-                    let key = token_stuff::get_key().unwrap();
+                                        data: vec![icarus_models::login_result::LoginResult {
-                    let (token_literal, duration) = token_stuff::create_token(&key).unwrap();
+                                            id: user.id,
-
+                                            username: user.username,
-                    if token_stuff::verify_token(&key, &token_literal) {
+                                            token: token_literal,
-                        (
+                                            token_type: String::from(token_stuff::TOKENTYPE),
-                            StatusCode::OK,
+                                            expiration: duration,
-                            Json(response::Response {
+                                        }],
-                                message: String::from("Successful"),
+                                    }),
-                                data: vec![icarus_models::login_result::LoginResult {
+                                )
-                                    id: user.id,
+                            } else {
-                                    username: user.username,
+                                return not_found("Could not verify password").await;
-                                    token: token_literal,
+                            }
-                                    token_type: String::from(token_stuff::TOKENTYPE),
+                        } else {
-                                    expiration: duration,
+                            return not_found("Error Hashing").await;
-                                }],
+                        }
-                            }),
+                    }
-                        )
+                    Err(err) => {
-                    } else {
+                        return not_found(&err.to_string()).await;
-                        return not_found("Could not verify password").await;
                     }
-                } else {
-                    return not_found("Error Hashing").await;
                 }
             }
             Err(err) => {

src/token_stuff/mod.rs

@@ -18,11 +18,22 @@ pub fn get_key() -> Result<String, dotenvy::Error> {
     Ok(key)
 }
 
-pub fn get_expiration() -> time::Result<time::Duration> {
+pub fn get_issued() -> time::Result<time::OffsetDateTime> {
-    let now = time::OffsetDateTime::now_utc();
+    Ok(time::OffsetDateTime::now_utc())
-    let epoch = time::OffsetDateTime::UNIX_EPOCH;
+}
-    let since_the_epoch = now - epoch;
+
-    Ok(since_the_epoch)
+pub fn get_expiration(issued: &time::OffsetDateTime) -> Result<time::OffsetDateTime, time::Error> {
+    let duration_expire = time::Duration::hours(4);
+    Ok(*issued + duration_expire)
+}
+
+mod util {
+    pub fn time_to_std_time(
+        provided_time: &time::OffsetDateTime,
+    ) -> Result<std::time::SystemTime, std::time::SystemTimeError> {
+        let converted = std::time::SystemTime::from(*provided_time);
+        Ok(converted)
+    }
 }
 
 pub fn create_token(provided_key: &String) -> Result<(String, i64), josekit::JoseError> {
@@ -33,13 +44,11 @@ pub fn create_token(provided_key: &String) -> Result<(String, i64), josekit::Jos
     payload.set_subject(MESSAGE);
     payload.set_issuer(ISSUER);
     payload.set_audience(vec![AUDIENCE]);
-    match get_expiration() {
+    match get_issued() {
-        Ok(duration) => {
+        Ok(issued) => {
-            let expire = duration.whole_seconds();
+            let expire = get_expiration(&issued).unwrap();
-            let _ = payload.set_claim(
+            payload.set_issued_at(&util::time_to_std_time(&issued).unwrap());
-                "expiration",
+            payload.set_expires_at(&util::time_to_std_time(&expire).unwrap());
-                Some(serde_json::to_value(expire.to_string()).unwrap()),
-            );
 
             let key: String = if provided_key.is_empty() {
                 get_key().unwrap()
@@ -50,7 +59,7 @@ pub fn create_token(provided_key: &String) -> Result<(String, i64), josekit::Jos
             let signer = Hs256.signer_from_bytes(key.as_bytes()).unwrap();
             Ok((
                 josekit::jwt::encode_with_signer(&payload, &header, &signer).unwrap(),
-                duration.whole_seconds(),
+                (expire - time::OffsetDateTime::UNIX_EPOCH).whole_seconds(),
             ))
         }
         Err(e) => Err(josekit::JoseError::InvalidClaim(e.into())),