Move response encryption handler to a response handler

Move all encryption to a session handler
2026-08-26 15:02:18 +08:00 · 2026-07-24 14:40:12 -05:00 · 2026-07-24 14:20:26 -05:00
26 changed files with 290 additions and 356 deletions
--- a/src/database/gree.rs
+++ b/src/database/gree.rs
@@ -7,7 +7,6 @@ use sha1::Sha1;
 use sha1::Digest;
 use rsa::pkcs8::DecodePublicKey;

-use crate::encryption;
 use crate::router::{global, userdata};
 use crate::sql::SQLite;

@@ -72,7 +71,6 @@ fn verify_signature(signature: &[u8], message: &[u8], public_key: &str) -> bool
 }

 pub fn get_uuid(headers: &HeaderMap, body: &str) -> String {
-    let body = encryption::decrypt_packet(body).unwrap();
    let blank_header = HeaderValue::from_static("");
    let login = headers.get("a6573cbe").unwrap_or(&blank_header).to_str().unwrap_or("");
    let uid = headers.get("aoharu-user-id").unwrap_or(&blank_header).to_str().unwrap_or("");
--- a/src/router.rs
+++ b/src/router.rs
@@ -35,21 +35,93 @@ mod tools;
 use actix_web::{
    HttpResponse,
    HttpRequest,
+    FromRequest,
+    Responder,
    body::{BoxBody, MessageBody},
-    dev::{ServiceRequest, ServiceResponse},
+    dev::{Payload, ServiceRequest, ServiceResponse},
    middleware::{from_fn, Next},
-    http::header::HeaderMap
 };
+use futures_util::future::LocalBoxFuture;
+use futures_util::FutureExt;
 use jzon::{JsonValue, object};
 use crate::encryption;

+pub struct Body(pub JsonValue);
+
+pub struct Login(pub String);
+
+pub struct Session {
+    pub key: String,
+    pub body: JsonValue,
+}
+
+pub trait ApiBody {
+    fn into_json(self) -> JsonValue;
+}
+
+impl ApiBody for JsonValue {
+    fn into_json(self) -> JsonValue {
+        self
+    }
+}
+
+pub struct Api<T = JsonValue>(pub Option<T>);
+
+impl<T: ApiBody> Responder for Api<T> {
+    type Body = BoxBody;
+
+    fn respond_to(self, req: &HttpRequest) -> HttpResponse {
+        global::api(req, self.0.map(ApiBody::into_json))
+    }
+}
+
+impl FromRequest for Body {
+    type Error = actix_web::Error;
+    type Future = LocalBoxFuture<'static, Result<Self, Self::Error>>;
+
+    fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
+        let fut = String::from_request(req, payload);
+        async move {
+            Ok(Body(jzon::parse(&encryption::decrypt_packet(&fut.await?).unwrap()).unwrap()))
+        }.boxed_local()
+    }
+}
+
+impl FromRequest for Login {
+    type Error = actix_web::Error;
+    type Future = LocalBoxFuture<'static, Result<Self, Self::Error>>;
+
+    fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
+        let headers = req.headers().clone();
+        let fut = String::from_request(req, payload);
+        async move {
+            Ok(Login(global::get_login(&headers, &encryption::decrypt_packet(&fut.await?).unwrap())))
+        }.boxed_local()
+    }
+}
+
+impl FromRequest for Session {
+    type Error = actix_web::Error;
+    type Future = LocalBoxFuture<'static, Result<Self, Self::Error>>;
+
+    fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
+        let headers = req.headers().clone();
+        let fut = String::from_request(req, payload);
+        async move {
+            let body = encryption::decrypt_packet(&fut.await?).unwrap();
+            let key = global::get_login(&headers, &body);
+            Ok(Session { key, body: jzon::parse(&body).unwrap() })
+        }.boxed_local()
+    }
+}
+
 // Requests without client headers (a browser) get the webui
 async fn webui_fallback(req: ServiceRequest, next: Next<impl MessageBody + 'static>) -> Result<ServiceResponse<BoxBody>, actix_web::Error> {
    let is_from_game = req.headers().get("aoharu-asset-version").is_some() || req.path().starts_with("/api/webui");
    if !is_from_game {
        let req = req.into_parts().0;
        let resp = if crate::get_args().hidden {
-            not_found(req.headers())
+            not_found(&req)
        } else {
            webui::main(req.clone())
        };
@@ -76,20 +148,20 @@ fn unhandled(req: &HttpRequest, body: String) -> Option<JsonValue> {
    None
 }

-fn not_found(headers: &HeaderMap) -> HttpResponse {
+fn not_found(req: &HttpRequest) -> HttpResponse {
    let rv = object!{
        "code": 4,
        "server_time": global::timestamp(),
        "message": ""
    };
-    global::send(rv, 0, headers)
+    global::send(rv, 0, req)
 }

 // Fallback for paths no actix route matched. Game endpoints live in each module's routes()
 async fn api_req(req: HttpRequest, body: String) -> HttpResponse {
    let args = crate::get_args();
    if args.hidden && (req.path().starts_with("/api/webui/") || !(req.path().starts_with("/api") || req.path().starts_with("/v1.0"))) {
-        return not_found(req.headers());
+        return not_found(&req);
    } else if !req.path().starts_with("/api") && !req.path().starts_with("/v1.0") {
        return webui::main(req);
    }
@@ -101,11 +173,11 @@ pub async fn request(req: HttpRequest, body: String) -> HttpResponse {
    let args = crate::get_args();
    let headers = req.headers();
    if args.hidden && (req.path().starts_with("/api/webui/") || req.path().starts_with("/live_clear_rate.html")) {
-        return not_found(headers);
+        return not_found(&req);
    }
    if headers.get("aoharu-asset-version").is_none() && req.path().starts_with("/api") && !req.path().starts_with("/api/webui") {
        if args.hidden {
-            return not_found(headers);
+            return not_found(&req);
        } else {
            return webui::main(req);
        }
--- a/src/router/card.rs
+++ b/src/router/card.rs
@@ -1,8 +1,7 @@
 use jzon::{object, array, JsonValue};
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};

-use crate::router::{userdata, global, items, databases};
-use crate::encryption;
+use crate::router::{userdata, items, databases, Session, Api};

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.service(
@@ -106,9 +105,7 @@ fn do_reinforce(user: &mut JsonValue, body: &JsonValue, exp_id: &str, money_mult
    object!{}
 }

-async fn reinforce(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn reinforce(Session { key, body }: Session) -> impl Responder {
    let mut user = userdata::get_acc(&key);
    let mut clear_mission_ids = array![];
    
@@ -116,7 +113,7 @@ async fn reinforce(req: HttpRequest, body: String) -> impl Responder {

    userdata::save_acc(&key, user.clone());

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        card: card,
        item_list: material_item_list(&user, &body),
        point_list: user["point_list"].clone(),
@@ -124,9 +121,7 @@ async fn reinforce(req: HttpRequest, body: String) -> impl Responder {
    }))
 }

-async fn skill_reinforce(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn skill_reinforce(Session { key, body }: Session) -> impl Responder {
    let mut user = userdata::get_acc(&key);
    let mut clear_mission_ids = array![];
    
@@ -134,7 +129,7 @@ async fn skill_reinforce(req: HttpRequest, body: String) -> impl Responder {

    userdata::save_acc(&key, user.clone());

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        card: card,
        item_list: material_item_list(&user, &body),
        point_list: user["point_list"].clone(),
@@ -142,9 +137,7 @@ async fn skill_reinforce(req: HttpRequest, body: String) -> impl Responder {
    }))
 }

-async fn evolve(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn evolve(Session { key, body }: Session) -> impl Responder {
    let mut user = userdata::get_acc(&key);
    let mut chats = userdata::get_acc_chats(&key);
    let mut missions = userdata::get_acc_missions(&key);
@@ -156,7 +149,7 @@ async fn evolve(req: HttpRequest, body: String) -> impl Responder {
    userdata::save_acc_chats(&key, chats);
    userdata::save_acc_missions(&key, missions);

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        card: card,
        item_list: material_item_list(&user, &body),
        point_list: user["point_list"].clone(),
--- a/src/router/chat.rs
+++ b/src/router/chat.rs
@@ -1,8 +1,7 @@
 use jzon::{object, array, JsonValue};
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};

-use crate::router::{global, items, userdata, databases};
-use crate::encryption;
+use crate::router::{global, items, userdata, databases, Login, Session, Api};

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.service(
@@ -38,8 +37,7 @@ pub fn add_chat_from_chapter_id(chapter_id: i64, chats: &mut JsonValue) -> bool
    add_chat(chapter["masterChatId"].as_i64().unwrap(), chapter["roomId"].as_i64().unwrap(), chats)
 }

-async fn home(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
+async fn home(Login(key): Login) -> impl Responder {
    let chats = userdata::get_acc_chats(&key);
    
    let mut rooms = array![];
@@ -47,7 +45,7 @@ async fn home(req: HttpRequest, body: String) -> impl Responder {
        rooms.push(databases::CHATS[data["chat_id"].to_string()][data["room_id"].to_string()]["id"].clone()).unwrap();
    }
    
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "progress_list": chats,
        "master_chat_room_ids": rooms,
        "master_chat_stamp_ids": [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,43,44,45,46,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,11001003,22001001,33001001,44001002],
@@ -55,13 +53,11 @@ async fn home(req: HttpRequest, body: String) -> impl Responder {
    }))
 }

-async fn start(req: HttpRequest, _body: String) -> impl Responder {
-    global::api(&req, Some(object!{"select_talk_id_list":[],"get_item_list":[],"is_read":0}))
+async fn start() -> impl Responder {
+    Api(Some(object!{"select_talk_id_list":[],"get_item_list":[],"is_read":0}))
 }

-async fn end(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn end(Session { key, body }: Session) -> impl Responder {
    let mut missions = userdata::get_acc_missions(&key);
    let mut chats = userdata::get_acc_chats(&key);
    
@@ -77,5 +73,5 @@ async fn end(req: HttpRequest, body: String) -> impl Responder {
        }
    }
    
-    global::api(&req, Some(array![]))
+    Api(Some(array![]))
 }
--- a/src/router/clear_rate.rs
+++ b/src/router/clear_rate.rs
@@ -4,9 +4,8 @@ use rusqlite::params;
 use std::sync::Mutex;
 use lazy_static::lazy_static;

-use crate::encryption;
 use crate::sql::SQLite;
-use crate::router::{databases, global, userdata};
+use crate::router::{databases, global, userdata, Session, Api};
 use crate::include_file;
 use crate::router::tools::guest;

@@ -252,12 +251,10 @@ pub async fn clearrate(req: HttpRequest) -> impl Responder {
        data["all_user_clear_rate"] = new_rates;
        data["master_music_ids"] = new_ids;
    }
-    global::api(&req, Some(data))
+    Api(Some(data))
 }

-pub async fn ranking(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+pub async fn ranking(Session { key, body }: Session) -> impl Responder {
    let self_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
    let live = body["master_live_id"].as_i64().unwrap();

@@ -285,7 +282,7 @@ pub async fn ranking(req: HttpRequest, body: String) -> impl Responder {
        }).unwrap();
    }

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "ranking_list": rank
    }))
 }
--- a/src/router/custom_song.rs
+++ b/src/router/custom_song.rs
@@ -11,7 +11,7 @@ use std::collections::HashMap;
 use std::fs;
 use std::sync::Mutex;

-use crate::router::{global, userdata, webui};
+use crate::router::{global, userdata, webui, Login, Api};
 use crate::database::custom_song as database;
 use crate::runtime::get_data_path;
 use crate::lock_onto_mutex;
@@ -91,14 +91,13 @@ pub fn client_supports_custom_songs(req: &HttpRequest) -> bool {

 // The catalog is filtered per requesting user: private songs only show for
 // their owner, shared songs for the owner plus their shared-user list
-async fn list(req: HttpRequest, body: String) -> impl Responder {
+async fn list(Login(key): Login) -> impl Responder {
    if disabled() {
        // As if the endpoint doesn't exist - the client treats this as feature-off
-        return global::api(&req, None);
+        return Api(None);
    }
-    let key = global::get_login(req.headers(), &body);
    let uid = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "revision": database::get_revision(),
        "songs": database::get_songs_for_user(uid)
    }))
--- a/src/router/debug.rs
+++ b/src/router/debug.rs
@@ -1,17 +1,15 @@
 use jzon::object;
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};

-use crate::encryption;
-use crate::router::global;
+use crate::router::{Body, Api};

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.route("/debug/error", web::post().to(error));
 }

-async fn error(req: HttpRequest, body: String) -> impl Responder {
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn error(Body(body): Body) -> impl Responder {

    println!("client error: {}", body["code"]);

-    global::api(&req, Some(object!{}))
+    Api(Some(object!{}))
 }
--- a/src/router/event.rs
+++ b/src/router/event.rs
@@ -2,9 +2,8 @@ use jzon::{JsonValue, object, array};
 use actix_web::{web, HttpRequest, Responder};
 use rand::RngExt;

-use crate::encryption;
 use crate::include_file;
-use crate::router::{userdata, global, databases};
+use crate::router::{userdata, global, databases, Body, Session, Api};

 // I believe(?) this is all?
 const STAR_EVENT_IDS: [u32; 3] = [127, 135, 139];
@@ -114,12 +113,7 @@ fn init_star_event(event: &mut JsonValue) {
    switch_music(event, 5);
 }

-async fn event(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-
-    let body = &encryption::decrypt_packet(&body).unwrap();
-    let body = jzon::parse(&body).unwrap();
-
+async fn event(Session { key, body }: Session) -> impl Responder {
    let master_event_id = body["master_event_id"].as_u32().unwrap();
    let mut event = get_event_data(&key, master_event_id);

@@ -159,15 +153,11 @@ async fn event(req: HttpRequest, body: String) -> impl Responder {
        }
    }

-    global::api(&req, Some(event))
+    Api(Some(event))
 }

-async fn star_event(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
+async fn star_event(Session { key, body }: Session) -> impl Responder {
    let user = userdata::get_acc(&key);
-
-    let body = &encryption::decrypt_packet(&body).unwrap();
-    let body = jzon::parse(&body).unwrap();
    let master_event_id = body["master_event_id"].as_u32().unwrap();

    let mut event = get_event_data(&key, master_event_id);
@@ -180,18 +170,14 @@ async fn star_event(req: HttpRequest, body: String) -> impl Responder {

    save_event_data(&key, master_event_id, event.clone());

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        star_event: star_event,
        gift_list: [],
        reward_list: []
    }))
 }

-async fn change_target_music(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-
-    let body = &encryption::decrypt_packet(&body).unwrap();
-    let body = jzon::parse(&body).unwrap();
+async fn change_target_music(Session { key, body }: Session) -> impl Responder {
    let master_event_id = body["master_event_id"].as_u32().unwrap();

    let mut event = get_event_data(&key, master_event_id);
@@ -202,14 +188,10 @@ async fn change_target_music(req: HttpRequest, body: String) -> impl Responder {

    save_event_data(&key, master_event_id, event.clone());

-    global::api(&req, Some(event["star_event"].clone()))
+    Api(Some(event["star_event"].clone()))
 }

-async fn set_member(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-
-    let body = &encryption::decrypt_packet(&body).unwrap();
-    let body = jzon::parse(&body).unwrap();
+async fn set_member(Session { key, body }: Session) -> impl Responder {
    let master_event_id = body["master_event_id"].as_u32().unwrap();

    let mut event = get_event_data(&key, master_event_id);
@@ -222,7 +204,7 @@ async fn set_member(req: HttpRequest, body: String) -> impl Responder {

    save_event_data(&key, master_event_id, event.clone());

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        event_member: event["member_ranking"].clone()
    }))
 }
@@ -240,9 +222,7 @@ fn get_rank(event: u32, user_id: u64) -> u32 {
    0
 }

-async fn ranking(req: HttpRequest, body: String) -> impl Responder {
-    let body = &encryption::decrypt_packet(&body).unwrap();
-    let body = jzon::parse(&body).unwrap();
+async fn ranking(Body(body): Body) -> impl Responder {
    let master_event_id = body["master_event_id"].as_u32().unwrap();
    let scores = crate::router::event_ranking::get_scores_json().await[master_event_id as usize].clone();
    let mut rv = array![];
@@ -258,7 +238,7 @@ async fn ranking(req: HttpRequest, body: String) -> impl Responder {
        }
    }

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        ranking_detail_list: rv
    }))
 }
@@ -304,18 +284,14 @@ fn get_points(event_id: u32, user: &JsonValue) -> i64 {
    0
 }

-fn event_live(req: &HttpRequest, body: String, skipped: bool) -> Option<JsonValue> {
-    let key = global::get_login(req.headers(), &body);
-    let body_temp = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+fn event_live(req: &HttpRequest, key: &str, body: &JsonValue, skipped: bool) -> Option<JsonValue> {
    let event_id = if skipped {
-        body_temp["master_event_id"].as_u32().unwrap()
+        body["master_event_id"].as_u32().unwrap()
    } else {
-        crate::router::live::get_end_live_event_id(&key, &body_temp)?
+        crate::router::live::get_end_live_event_id(key, body)?
    };

-    let mut resp = crate::router::live::live_end(req, &body, skipped);
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+    let mut resp = crate::router::live::live_end(req, key, body, skipped);
    let mut event = get_event_data(&key, event_id);
    let mut user = userdata::get_acc(&key);

@@ -380,10 +356,10 @@ fn event_live(req: &HttpRequest, body: String, skipped: bool) -> Option<JsonValu
    Some(resp)
 }

-async fn event_end(req: HttpRequest, body: String) -> impl Responder {
-    global::api(&req, event_live(&req, body, false))
+async fn event_end(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
+    Api(event_live(&req, &key, &body, false))
 }

-async fn event_skip(req: HttpRequest, body: String) -> impl Responder {
-    global::api(&req, event_live(&req, body, true))
+async fn event_skip(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
+    Api(event_live(&req, &key, &body, true))
 }
--- a/src/router/exchange.rs
+++ b/src/router/exchange.rs
@@ -1,17 +1,15 @@
 use jzon::{object, array, JsonValue};
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};

-use crate::router::{global, userdata, items, databases};
-use crate::encryption;
+use crate::router::{userdata, items, databases, Login, Session, Api};

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.service(web::resource("/exchange").route(web::get().to(exchange)).route(web::post().to(exchange_post)));
 }

-async fn exchange(req: HttpRequest) -> impl Responder {
-    let key = global::get_login(req.headers(), "");
+async fn exchange(Login(key): Login) -> impl Responder {
    let exchange = userdata::get_acc_exchange(&key);
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "exchange_list": exchange
    }))
 }
@@ -34,9 +32,7 @@ fn exchange_updated_value_list(is_card: bool, granted_id: i64, consumed_id: i64,
    rv
 }

-async fn exchange_post(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn exchange_post(Session { key, body }: Session) -> impl Responder {
    let mut user = userdata::get_acc(&key);
    let mut missions = userdata::get_acc_missions(&key);
    let mut chats = userdata::get_acc_chats(&key);
@@ -81,7 +77,7 @@ async fn exchange_post(req: HttpRequest, body: String) -> impl Responder {
    userdata::save_acc_chats(&key, chats);
    userdata::save_acc_exchange(&key, exchanges);

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "clear_mission_ids": cleared_missions,
        "exchange": {
            master_exchange_item_id: exchange_id,
--- a/src/router/friend.rs
+++ b/src/router/friend.rs
@@ -1,8 +1,7 @@
 use jzon::{array, object};
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};

-use crate::router::{global, userdata};
-use crate::encryption;
+use crate::router::{global, userdata, Login, Session, Api};
 use crate::router::tools::guest;

 pub const FRIEND_LIMIT: usize = 40;
@@ -21,9 +20,7 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
    );
 }

-async fn friend(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn friend(Session { key, body }: Session) -> impl Responder {
    let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
    let friends = userdata::get_acc_friends(&key);

@@ -45,20 +42,18 @@ async fn friend(req: HttpRequest, body: String) -> impl Responder {
        rv.push(user).unwrap();
    }

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "friend_list": rv
    }))
 }

-async fn ids(req: HttpRequest) -> impl Responder {
-    let key = global::get_login(req.headers(), "");
+async fn ids(Login(key): Login) -> impl Responder {
    let friends = userdata::get_acc_friends(&key);

-    global::api(&req, Some(friends))
+    Api(Some(friends))
 }

-async fn recommend(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
+async fn recommend(Login(key): Login) -> impl Responder {
    let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
    let friends = userdata::get_acc_friends(&key);

@@ -78,29 +73,25 @@ async fn recommend(req: HttpRequest, body: String) -> impl Responder {
        rv.push(user).unwrap();
    }

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        friend_list: rv
    }))
 }

-async fn search(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn search(Session { key, body }: Session) -> impl Responder {
    let friends = userdata::get_acc_friends(&key);

    let uid = body["user_id"].as_i64().unwrap();
    let user = guest::get_user(uid, &friends, guest::UserView::Detail);

-    global::api(&req, Some(if user.is_empty() {
+    Api(Some(if user.is_empty() {
        array![]
    } else {
        user
    }))
 }

-async fn request(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn request(Session { key, body }: Session) -> impl Responder {
    let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
    let mut friends = userdata::get_acc_friends(&key);

@@ -113,12 +104,10 @@ async fn request(req: HttpRequest, body: String) -> impl Responder {
        userdata::friend_request(uid, user_id);
    }

-    global::api(&req, Some(array![]))
+    Api(Some(array![]))
 }

-async fn approve(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn approve(Session { key, body }: Session) -> impl Responder {
    let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
    let mut friends = userdata::get_acc_friends(&key);

@@ -134,12 +123,10 @@ async fn approve(req: HttpRequest, body: String) -> impl Responder {
        userdata::save_acc_friends(&key, friends);
    }

-    global::api(&req, Some(array![]))
+    Api(Some(array![]))
 }

-async fn cancel(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn cancel(Session { key, body }: Session) -> impl Responder {
    let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
    let mut friends = userdata::get_acc_friends(&key);

@@ -151,12 +138,10 @@ async fn cancel(req: HttpRequest, body: String) -> impl Responder {
    userdata::friend_request_approve(uid, user_id, false, "pending_user_id_list");
    userdata::save_acc_friends(&key, friends);

-    global::api(&req, Some(array![]))
+    Api(Some(array![]))
 }

-async fn delete(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn delete(Session { key, body }: Session) -> impl Responder {
    let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
    let mut friends = userdata::get_acc_friends(&key);

@@ -168,5 +153,5 @@ async fn delete(req: HttpRequest, body: String) -> impl Responder {
    userdata::friend_remove(uid, user_id);
    userdata::save_acc_friends(&key, friends);

-    global::api(&req, Some(array![]))
+    Api(Some(array![]))
 }
--- a/src/router/global.rs
+++ b/src/router/global.rs
@@ -324,14 +324,14 @@ pub fn set_time(current_time: u64, uid: i64, max: bool) -> u64 {
    return server_time + time_since_set;
 }

-pub fn send(mut data: JsonValue, uid: i64, headers: &HeaderMap) -> HttpResponse {
+pub fn send(mut data: JsonValue, uid: i64, req: &HttpRequest) -> HttpResponse {
    //println!("{}", jzon::stringify(data.clone()));
    data["server_time"] = set_time(data["server_time"].as_u64().unwrap_or(0), uid, true).into();

    if !data["data"]["item_list"].is_empty() || !data["data"]["updated_value_list"]["item_list"].is_empty() {
-        items::check_for_region(&mut data, headers);
+        items::check_for_region(&mut data, req.headers());
    }
-    
+
    let encrypted = encryption::encrypt_packet(&jzon::stringify(data)).unwrap();
    let resp = encrypted.into_bytes();

@@ -354,7 +354,7 @@ pub fn api(req: &HttpRequest, data: Option<JsonValue>) -> HttpResponse {
            "message": ""
        }
    };
-    send(rv, uid, req.headers())
+    send(rv, uid, req)
 }

 pub fn api_error(req: &HttpRequest, code: i32) -> HttpResponse {
@@ -363,7 +363,7 @@ pub fn api_error(req: &HttpRequest, code: i32) -> HttpResponse {
        "code": code,
        "server_time": timestamp(),
        "message": ""
-    }, uid, req.headers())
+    }, uid, req)
 }

 pub fn start_login_bonus(id: i64, bonus: &mut JsonValue) -> bool {
--- a/src/router/home.rs
+++ b/src/router/home.rs
@@ -1,9 +1,8 @@
 use jzon::{object, array, JsonValue};
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};
 use lazy_static::lazy_static;

-use crate::router::{global, userdata, items};
-use crate::encryption;
+use crate::router::{global, userdata, items, Login, Session, Api};

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.service(
@@ -14,9 +13,7 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
    );
 }

-async fn preset(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn preset(Session { key, body }: Session) -> impl Responder {
    let mut user = userdata::get_acc_home(&key);
    
    for data in user["home"]["preset_setting"].members_mut() {
@@ -26,7 +23,7 @@ async fn preset(req: HttpRequest, body: String) -> impl Responder {
    }
    userdata::save_acc_home(&key, user);

-    global::api(&req, Some(array![]))
+    Api(Some(array![]))
 }

 fn check_gifts(user: &mut JsonValue) {
@@ -41,21 +38,19 @@ fn check_gifts(user: &mut JsonValue) {
    }
 }

-pub async fn gift_get(req: HttpRequest) -> impl Responder {
-    let key = global::get_login(req.headers(), "");
+pub async fn gift_get(Login(key): Login) -> impl Responder {
    let mut user = userdata::get_acc_home(&key);
    check_gifts(&mut user);

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "gift_list": user["home"]["gift_list"].clone()
    }))
 }

-async fn preset_get(req: HttpRequest) -> impl Responder {
-    let key = global::get_login(req.headers(), "");
+async fn preset_get(Login(key): Login) -> impl Responder {
    let user = userdata::get_acc(&key);

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "master_preset_background_ids": [1,2,3,4,5],
        "master_preset_foreground_ids": [1,2,3],
        "card_list": user["card_list"].clone()
@@ -88,8 +83,7 @@ lazy_static! {
    };
 }

-async fn home(req: HttpRequest) -> impl Responder {
-    let key = global::get_login(req.headers(), "");
+async fn home(Login(key): Login) -> impl Responder {
    let mut user = userdata::get_acc_home(&key);
    
    check_gifts(&mut user);
@@ -133,5 +127,5 @@ async fn home(req: HttpRequest) -> impl Responder {
    //todo
    user["home"]["beginner_mission_complete"] = 1.into();

-    global::api(&req, Some(user))
+    Api(Some(user))
 }
--- a/src/router/items.rs
+++ b/src/router/items.rs
@@ -1,9 +1,8 @@
 use jzon::{array, object, JsonValue};
 use rand::RngExt;
-use actix_web::{web, HttpRequest, Responder, http::header::{HeaderMap, HeaderValue}};
-use crate::encryption;
+use actix_web::{web, Responder, http::header::{HeaderMap, HeaderValue}};

-use crate::router::{userdata, global, databases};
+use crate::router::{userdata, global, databases, Session, Api};

 pub fn remove_gems(user: &mut JsonValue, amount: i64) {
    let mut amount = amount;
@@ -557,9 +556,7 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.route("/item/use", web::post().to(use_item_req));
 }

-async fn use_item_req(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn use_item_req(Session { key, body }: Session) -> impl Responder {
    let mut user = userdata::get_acc(&key);
    
    let item = &databases::ITEM_INFO[body["id"].to_string()];
@@ -586,7 +583,7 @@ async fn use_item_req(req: HttpRequest, body: String) -> impl Responder {
        }
    }

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        item_list: [used],
        stamina: user["stamina"].clone()
    }))
--- a/src/router/live.rs
+++ b/src/router/live.rs
@@ -3,8 +3,7 @@ use actix_web::{web, HttpRequest, Responder};
 use rand::RngExt;
 use lazy_static::lazy_static;

-use crate::router::{databases, global, items, userdata};
-use crate::encryption;
+use crate::router::{databases, global, items, userdata, Login, Session, Api};
 use crate::router::clear_rate::live_completed;
 use crate::router::tools::guest;

@@ -25,23 +24,19 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
 }


-async fn retire(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn retire(Session { key, body }: Session) -> impl Responder {
    live_retire(&key, &body);
    if body["live_score"]["play_time"].as_i64().unwrap_or(0) > 5 {
        live_completed(body["master_live_id"].as_i64().unwrap(), body["level"].as_i32().unwrap(), true, 0, 0);
    }
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "stamina": {},
        "item_list": [],
        "event_point_list": []
    }))
 }

-async fn reward(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn reward(Session { key, body }: Session) -> impl Responder {
    let user = userdata::get_acc(&key);
    let live_id = body["master_live_id"].as_i64().unwrap();
    let cleared = get_clear_count(live_id, &user) > 0;
@@ -70,7 +65,7 @@ async fn reward(req: HttpRequest, body: String) -> impl Responder {
        }
    }

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "ensured_list": ensured_list,
        "random_list": random_list
    }))
@@ -85,8 +80,7 @@ fn random_number(lowest: usize, highest: usize) -> usize {
    rand::rng().random_range(lowest..highest + 1)
 }

-async fn guest(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
+async fn guest(Login(key): Login) -> impl Responder {
    let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
    let friends = userdata::get_acc_friends(&key);
    let user = userdata::get_acc(&key);
@@ -209,14 +203,14 @@ async fn guest(req: HttpRequest, body: String) -> impl Responder {
        }
    }
    
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "guest_list": guest_list
    }))
 }

-async fn mission(req: HttpRequest, _body: String) -> impl Responder {
+async fn mission() -> impl Responder {
    //todo
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "score_ranking": "",
        "combo_ranking": "",
        "clear_count_ranking": ""
@@ -284,29 +278,24 @@ fn start_live(login_token: &str, body: &JsonValue) {
    userdata::save_server_data(login_token, server_data);
 }

-async fn start(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn start(Session { key, body }: Session) -> impl Responder {
    start_live(&key, &body);
-    global::api(&req, Some(array![]))
+    Api(Some(array![]))
 }

-pub async fn event_start(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+pub async fn event_start(Session { key, body }: Session) -> impl Responder {
    start_live(&key, &body);
-    global::api(&req, Some(array![]))
+    Api(Some(array![]))
 }

-async fn continuee(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
+async fn continuee(Login(key): Login) -> impl Responder {
    let mut user = userdata::get_acc(&key);
    
    items::remove_gems(&mut user, 100);
    
    userdata::save_acc(&key, user.clone());
    
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        gem: user["gem"].clone()
    }))
 }
@@ -603,9 +592,7 @@ fn get_live_character_list(lp_used: i32, deck_id: i32, user: &mut JsonValue, mis
    rv
 }

-pub fn live_end(req: &HttpRequest, body: &str, skipped: bool) -> JsonValue {
-    let key = global::get_login(req.headers(), body);
-    let body = jzon::parse(&encryption::decrypt_packet(body).unwrap()).unwrap();
+pub fn live_end(req: &HttpRequest, key: &str, body: &JsonValue, skipped: bool) -> JsonValue {
    let mut user2 = userdata::get_acc_home(&key);
    let mut user = userdata::get_acc(&key);
    let mut user_missions = userdata::get_acc_missions(&key);
@@ -754,12 +741,12 @@ pub fn live_end(req: &HttpRequest, body: &str, skipped: bool) -> JsonValue {
    rv
 }

-async fn end(req: HttpRequest, body: String) -> impl Responder {
-    global::api(&req, Some(live_end(&req, &body, false)))
+async fn end(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
+    Api(Some(live_end(&req, &key, &body, false)))
 }

-async fn skip(req: HttpRequest, body: String) -> impl Responder {
-    global::api(&req, Some(live_end(&req, &body, true)))
+async fn skip(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
+    Api(Some(live_end(&req, &key, &body, true)))
 }

 #[cfg(test)]
--- a/src/router/location.rs
+++ b/src/router/location.rs
@@ -1,14 +1,14 @@
 use jzon::object;
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};

-use crate::router::global;
+use crate::router::Api;

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.route("/location", web::get().to(location));
 }

-async fn location(req: HttpRequest) -> impl Responder {
-    global::api(&req, Some(object!{
+async fn location() -> impl Responder {
+    Api(Some(object!{
        "master_location_ids": []
    }))
 }
--- a/src/router/login.rs
+++ b/src/router/login.rs
@@ -1,7 +1,7 @@
 use jzon::{object, array, JsonValue};
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};

-use crate::router::{global, userdata, items, databases};
+use crate::router::{global, userdata, items, databases, Login, Api};

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.route("/dummy/login", web::post().to(dummy));
@@ -9,11 +9,10 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.route("/login_bonus/event", web::post().to(bonus_event));
 }

-async fn dummy(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
+async fn dummy(Login(key): Login) -> impl Responder {
    let user = userdata::get_acc(&key);

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "user_id": user["user"]["id"].clone()
    }))
 }
@@ -53,8 +52,7 @@ fn do_bonus(user_home: &mut JsonValue, bonuses: &mut JsonValue) -> JsonValue {
    to_send
 }

-async fn bonus(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
+async fn bonus(Login(key): Login) -> impl Responder {
    let mut user_home = userdata::get_acc_home(&key);
    let mut user_missions = userdata::get_acc_missions(&key);
    
@@ -73,15 +71,14 @@ async fn bonus(req: HttpRequest, body: String) -> impl Responder {
    userdata::save_acc_loginbonus(&key, bonuses.clone());
    userdata::save_acc_home(&key, user_home.clone());
    
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "login_bonus_list": to_send,
        "start_time": bonuses["start_time"].clone(),
        "clear_mission_ids": cleared_missions
    }))
 }

-async fn bonus_event(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
+async fn bonus_event(Login(key): Login) -> impl Responder {
    let mut user_home = userdata::get_acc_home(&key);
    
    let mut bonuses = userdata::get_acc_eventlogin(&key);
@@ -93,7 +90,7 @@ async fn bonus_event(req: HttpRequest, body: String) -> impl Responder {
    userdata::save_acc_eventlogin(&key, bonuses.clone());
    userdata::save_acc_home(&key, user_home.clone());
    
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "login_bonus_list": to_send,
        "start_time": bonuses["start_time"].clone(),
        "clear_mission_ids": []
--- a/src/router/lottery.rs
+++ b/src/router/lottery.rs
@@ -1,9 +1,8 @@
 use jzon::{array, object, JsonValue};
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};
 use rand::RngExt;

-use crate::router::{global, userdata, items, databases};
-use crate::encryption;
+use crate::router::{global, userdata, items, databases, Body, Login, Session, Api};

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.service(
@@ -13,8 +12,7 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
    );
 }

-async fn tutorial(req: HttpRequest, body: String) -> impl Responder {
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn tutorial(Body(body): Body) -> impl Responder {
    
    let id = body["master_character_id"].to_string();
    let user = &id[id.len() - 2..].parse::<i32>().unwrap();
@@ -28,7 +26,7 @@ async fn tutorial(req: HttpRequest, body: String) -> impl Responder {
    }
    lotteryid += user;
    
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "lottery_list": [
            {
                "master_lottery_id": lotteryid,
@@ -189,17 +187,14 @@ fn get_lottery_list(user: &JsonValue) -> JsonValue {
    rv
 }

-async fn lottery(req: HttpRequest) -> impl Responder {
-    let key = global::get_login(req.headers(), "");
+async fn lottery(Login(key): Login) -> impl Responder {
    let user = userdata::get_acc(&key);
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "lottery_list": get_lottery_list(&user)
    }))
 }

-async fn lottery_post(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn lottery_post(Session { key, body }: Session) -> impl Responder {
    //println!("lottery: {}", body);
    let mut user = userdata::get_acc(&key);
    let user2 = userdata::get_acc(&key);
@@ -295,7 +290,7 @@ async fn lottery_post(req: HttpRequest, body: String) -> impl Responder {
    userdata::save_acc_chats(&key, chats);
    userdata::save_acc_missions(&key, missions);

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "lottery_item_list": lottery_list,
        "updated_value_list": {
            "card_list": new_cards,
--- a/src/router/mission.rs
+++ b/src/router/mission.rs
@@ -1,8 +1,7 @@
 use jzon::{array, object, JsonValue};
 use actix_web::{web, HttpRequest, Responder};

-use crate::router::{global, userdata, items, databases};
-use crate::encryption;
+use crate::router::{global, userdata, items, databases, Login, Session, Api};

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.service(
@@ -15,13 +14,12 @@ pub fn routes(cfg: &mut web::ServiceConfig) {

 const VARIABLE_MISSIONS: [[i64; 2]; 5] = [[1153001, 1153019], [1105001, 1105017], [1101001, 1101030], [1121001, 1121019], [1112001, 1112033]];

-async fn mission(req: HttpRequest) -> impl Responder {
-    let key = global::get_login(req.headers(), "");
+async fn mission(Login(key): Login) -> impl Responder {
    let user = userdata::get_acc(&key);
    let step = user["tutorial_step"].as_i64().unwrap_or(0);

    if (1..130).contains(&step) {
-        return global::api(&req, Some(object!{
+        return Api(Some(object!{
            "mission_list": array![]
        }));
    }
@@ -31,16 +29,13 @@ async fn mission(req: HttpRequest) -> impl Responder {
        userdata::save_acc_missions(&key, missions.clone());
    }

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "mission_list": missions
    }))
 }

-async fn clear(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-
+async fn clear(Session { key, body }: Session) -> impl Responder {
    let mut missions = userdata::get_acc_missions(&key);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();

    let mut cleared = array![];
    for id in body["master_mission_ids"].members() {
@@ -54,14 +49,12 @@ async fn clear(req: HttpRequest, body: String) -> impl Responder {

    userdata::save_acc_missions(&key, missions);

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "clear_mission_ids": cleared
    }))
 }

-async fn receive(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn receive(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
    let uid = global::get_uid(req.headers());
    let now = global::timestamp();

@@ -182,7 +175,7 @@ async fn receive(req: HttpRequest, body: String) -> impl Responder {
        updated_value_list["point_list"] = point_list;
    }

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "reward_list": rewards,
        "gift_list": array![],
        "updated_value_list": updated_value_list,
--- a/src/router/notice.rs
+++ b/src/router/notice.rs
@@ -1,19 +1,19 @@
 use jzon::{object, array};
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};

-use crate::router::global;
+use crate::router::Api;

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.service(web::resource("/notice/reward").route(web::get().to(reward)).route(web::post().to(reward_post)));
 }

 //todo
-async fn reward(req: HttpRequest) -> impl Responder {
-    global::api(&req, Some(object!{
+async fn reward() -> impl Responder {
+    Api(Some(object!{
        "reward_list": []
    }))
 }

-async fn reward_post(req: HttpRequest, _body: String) -> impl Responder {
-    global::api(&req, Some(array![]))
+async fn reward_post() -> impl Responder {
+    Api(Some(array![]))
 }
--- a/src/router/purchase.rs
+++ b/src/router/purchase.rs
@@ -1,14 +1,14 @@
 use jzon::object;
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};

-use crate::router::global;
+use crate::router::Api;

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.route("/purchase", web::get().to(purchase));
 }

-async fn purchase(req: HttpRequest) -> impl Responder {
-    global::api(&req, Some(object!{
+async fn purchase() -> impl Responder {
+    Api(Some(object!{
        "product_list": [//Client will error if this is an empty array
            {
                "product_id": "com.bushiroad.global.lovelive.sif2.google.promo.4199",
--- a/src/router/serial_code.rs
+++ b/src/router/serial_code.rs
@@ -1,8 +1,7 @@
 use jzon::{array, object};
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};

-use crate::router::{global, userdata, items};
-use crate::encryption;
+use crate::router::{userdata, items, Session, Api};

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.service(
@@ -12,15 +11,13 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
    );
 }

-async fn events(req: HttpRequest) -> impl Responder {
-    global::api(&req, Some(object!{
+async fn events() -> impl Responder {
+    Api(Some(object!{
        "serial_code_list": []
    }))
 }

-async fn serial_code(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn serial_code(Session { key, body }: Session) -> impl Responder {
    let mut user = userdata::get_acc_home(&key);
    
    let mut itemz = array![];
@@ -186,7 +183,7 @@ async fn serial_code(req: HttpRequest, body: String) -> impl Responder {
        itemz.push(items::gift_item_basic(30010001, 500, 3, "Okay...............", &mut user)).unwrap();
        itemz.push(items::gift_item_basic(15540001, 500, 3, "Okay...............", &mut user)).unwrap();
    } else {
-        return global::api(&req, Some(object!{
+        return Api(Some(object!{
            "result_code": 3
        }));
    }
@@ -195,7 +192,7 @@ async fn serial_code(req: HttpRequest, body: String) -> impl Responder {
        userdata::save_acc_home(&key, user.clone());
    }
    
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "serial_code_event": {"id":1,"name":"Serial Code Reward","unique_limit_count":0,"min_user_rank":0,"max_user_rank":0,"end_date":null},
        "reward_list": itemz,
        "result_code": 0,
--- a/src/router/shop.rs
+++ b/src/router/shop.rs
@@ -1,8 +1,7 @@
 use jzon::{object};
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};

-use crate::router::{userdata, global, items, databases};
-use crate::encryption;
+use crate::router::{userdata, items, databases, Login, Session, Api};

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.service(
@@ -12,18 +11,15 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
    );
 }

-async fn shop(req: HttpRequest) -> impl Responder {
-    let key = global::get_login(req.headers(), "");
+async fn shop(Login(key): Login) -> impl Responder {
    let user = userdata::get_acc(&key);

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "shop_list": user["shop_list"].clone()
    }))
 }

-async fn buy(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn buy(Session { key, body }: Session) -> impl Responder {
    let mut user = userdata::get_acc(&key);

    let shop_item_id = body["master_shop_item_id"].as_i64().unwrap();
@@ -43,7 +39,7 @@ async fn buy(req: HttpRequest, body: String) -> impl Responder {
        }
    }

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "gem": user["gem"].clone(),
        "shop_list": [bought],
        "gift_list": [],
--- a/src/router/start.rs
+++ b/src/router/start.rs
@@ -1,8 +1,7 @@
 use jzon::{JsonValue, object};
 use actix_web::{web, HttpRequest, Responder};

-use crate::encryption;
-use crate::router::{userdata, global};
+use crate::router::{userdata, global, Body, Session};

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.route("/start", web::post().to(start));
@@ -25,8 +24,7 @@ fn get_asset_hash(req: &HttpRequest, body: &JsonValue) -> Option<String> {
    rv
 }

-async fn asset_hash(req: HttpRequest, body: String) -> impl Responder {
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn asset_hash(req: HttpRequest, Body(body): Body) -> impl Responder {

    match get_asset_hash(&req, &body) {
        Some(hash) => global::api(&req, Some(object!{
@@ -36,9 +34,7 @@ async fn asset_hash(req: HttpRequest, body: String) -> impl Responder {
    }
 }

-async fn start(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn start(req: HttpRequest, Session { key, body }: Session) -> impl Responder {

    let Some(asset_hash) = get_asset_hash(&req, &body) else {
        return global::api_error(&req, global::RESULT_GAME_VERSION_UPDATED);
--- a/src/router/story.rs
+++ b/src/router/story.rs
@@ -1,16 +1,13 @@
 use jzon::{object};
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};

-use crate::encryption;
-use crate::router::{global, userdata, databases};
+use crate::router::{userdata, databases, Session, Api};

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.route("/story/read", web::post().to(read));
 }

-async fn read(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn read(Session { key, body }: Session) -> impl Responder {
    let mut user = userdata::get_acc(&key);
    let part = body["master_story_part_id"].as_i64().unwrap();
    let master_id = databases::STORY[part.to_string()]["masterStoryId"].as_i64().unwrap();
@@ -33,7 +30,7 @@ async fn read(req: HttpRequest, body: String) -> impl Responder {
    userdata::save_acc(&key, user.clone());


-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "gift_list":[],
        "updated_value_list":{
            "story_list": user["story_list"].clone()
--- a/src/router/tutorial.rs
+++ b/src/router/tutorial.rs
@@ -1,16 +1,13 @@
 use jzon::{array};
-use actix_web::{web, HttpRequest, Responder};
+use actix_web::{web, Responder};

-use crate::router::{userdata, global};
-use crate::encryption;
+use crate::router::{userdata, global, Session, Api};

 pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.route("/tutorial", web::post().to(tutorial));
 }

-async fn tutorial(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn tutorial(Session { key, body }: Session) -> impl Responder {
    let mut user = userdata::get_acc(&key);

    if user["tutorial_step"].as_i32().unwrap() < 130 {
@@ -20,5 +17,5 @@ async fn tutorial(req: HttpRequest, body: String) -> impl Responder {
        userdata::save_acc(&key, user);
    }
    
-    global::api(&req, Some(array![]))
+    Api(Some(array![]))
 }
--- a/src/router/user.rs
+++ b/src/router/user.rs
@@ -2,8 +2,7 @@ use jzon::{array, object, JsonValue};
 use actix_web::{web, HttpRequest, Responder};
 use sha1::{Digest, Sha1};

-use crate::encryption;
-use crate::router::{global, items, userdata};
+use crate::router::{global, items, userdata, Body, Login, Session, Api};
 use crate::include_file;
 use crate::router::tools::guest;

@@ -26,9 +25,7 @@ pub fn routes(cfg: &mut web::ServiceConfig) {
    cfg.route("/album/sif", web::get().to(sif));
 }

-async fn deck(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn deck(Session { key, body }: Session) -> impl Responder {
    let mut user = userdata::get_acc(&key);
    
    for (i, data) in user["deck_list"].clone().members().enumerate() {
@@ -49,7 +46,7 @@ async fn deck(req: HttpRequest, body: String) -> impl Responder {
    }
    userdata::save_acc(&key, user.clone());
    
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "deck": {
            "slot": body["slot"].clone(),
            "leader_role": 0,
@@ -59,8 +56,7 @@ async fn deck(req: HttpRequest, body: String) -> impl Responder {
    }))
 }

-async fn user(req: HttpRequest) -> impl Responder {
-    let key = global::get_login(req.headers(), "");
+async fn user(req: HttpRequest, Login(key): Login) -> impl Responder {
    let mut user = userdata::get_acc(&key);

    user["lottery_list"] = array![];
@@ -71,12 +67,10 @@ async fn user(req: HttpRequest) -> impl Responder {
        }
    }

-    global::api(&req, Some(user))
+    Api(Some(user))
 }

-pub async fn gift(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+pub async fn gift(Session { key, body }: Session) -> impl Responder {
    
    let mut user = userdata::get_acc_home(&key);
    let mut userr = userdata::get_acc(&key);
@@ -119,7 +113,7 @@ pub async fn gift(req: HttpRequest, body: String) -> impl Responder {
    userdata::save_acc(&key, userr.clone());
    let userr = userdata::get_acc(&key);

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "failed_gift_ids": failed,
        "updated_value_list": {
            "gem": userr["gem"].clone(),
@@ -132,9 +126,7 @@ pub async fn gift(req: HttpRequest, body: String) -> impl Responder {
    }))
 }

-async fn user_post(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn user_post(Session { key, body }: Session) -> impl Responder {

    let mut user = userdata::get_acc(&key);
    
@@ -175,14 +167,13 @@ async fn user_post(req: HttpRequest, body: String) -> impl Responder {
    
    userdata::save_acc(&key, user.clone());

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "user": user["user"].clone(),
        "clear_mission_ids": []
    }))
 }

-pub async fn announcement(req: HttpRequest) -> impl Responder {
-    let key = global::get_login(req.headers(), "");
+pub async fn announcement(Login(key): Login) -> impl Responder {
    
    let mut user = userdata::get_acc_home(&key);
    
@@ -190,75 +181,67 @@ pub async fn announcement(req: HttpRequest) -> impl Responder {
    
    userdata::save_acc_home(&key, user);
    
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        new_announcement_flag: 0
    }))
 }

-async fn get_migration_code(req: HttpRequest, body: String) -> impl Responder {
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn get_migration_code(Body(body): Body) -> impl Responder {

-    let Some(user_id) = body["user_id"].as_i64() else { return global::api(&req, None); };
+    let Some(user_id) = body["user_id"].as_i64() else { return Api(None); };
    let code = userdata::user::migration::get_acc_token(user_id);

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "migrationCode": code
    }))
 }

-async fn register_password(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn register_password(Session { key, body }: Session) -> impl Responder {
    
    let user = userdata::get_acc(&key);
    
    userdata::user::migration::save_acc_transfer(user["user"]["id"].as_i64().unwrap(), &body["pass"].to_string());
    
-    global::api(&req, Some(array![]))
+    Api(Some(array![]))
 }

-async fn verify_migration_code(req: HttpRequest, body: String) -> impl Responder {
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn verify_migration_code(Body(body): Body) -> impl Responder {
    
    let user = userdata::user::migration::get_acc_transfer(&body["migrationCode"].to_string(), &body["pass"].to_string());
    
    if !user["success"].as_bool().unwrap() || user["user_id"] == 0 {
-        return global::api(&req, None);
+        return Api(None);
    }

    let data_user = userdata::get_acc(&user["login_token"].to_string());

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "user_id": user["user_id"].clone(),
        "uuid": user["login_token"].to_string(),
        "charge": data_user["gem"]["charge"].clone(),
        "free": data_user["gem"]["free"].clone()
    }))
 }
-async fn request_migration_code(req: HttpRequest, body: String) -> impl Responder {
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn request_migration_code(Body(body): Body) -> impl Responder {
    
    let user = userdata::user::migration::get_acc_transfer(&body["migrationCode"].to_string(), &body["pass"].to_string());
    
    if !user["success"].as_bool().unwrap() || user["user_id"] == 0 {
-        return global::api(&req, None);
+        return Api(None);
    }

-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "twxuid": user["login_token"].to_string()
    }))
 }
-async fn migration(req: HttpRequest, body: String) -> impl Responder {
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn migration(Body(body): Body) -> impl Responder {

    let user = userdata::get_name_and_rank(body["user_id"].to_string().parse::<i64>().unwrap());

-    global::api(&req, Some(user))
+    Api(Some(user))
 }

-async fn detail(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn detail(Session { key, body }: Session) -> impl Responder {
    let friends = userdata::get_acc_friends(&key);
    
    let mut user_detail_list = array![];
@@ -267,13 +250,12 @@ async fn detail(req: HttpRequest, body: String) -> impl Responder {
        let user = guest::get_user(uid, &friends, guest::UserView::Detail);
        user_detail_list.push(user).unwrap();
    }
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        user_detail_list: user_detail_list
    }))
 }

-async fn sif(req: HttpRequest) -> impl Responder {
-    let key = global::get_login(req.headers(), "");
+async fn sif(Login(key): Login) -> impl Responder {
    let mut user = userdata::get_acc(&key);
    let mut cards = userdata::get_acc_sif(&key);
    
@@ -286,13 +268,13 @@ async fn sif(req: HttpRequest) -> impl Responder {
        userdata::save_acc(&key, user);
    }
    
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        cards: cards
    }))
 }

-async fn sifas_migrate(req: HttpRequest, _body: String) -> impl Responder {
-    global::api(&req, Some(object!{
+async fn sifas_migrate() -> impl Responder {
+    Api(Some(object!{
        "ss_migrate_status": 1,
        "user": null,
        "gift_list": null,
@@ -342,15 +324,13 @@ fn clean_sif_data(current: &JsonValue) -> JsonValue {
    rv
 }

-async fn sif_migrate(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
+async fn sif_migrate(Session { key, body }: Session) -> impl Responder {
    let mut user = userdata::get_acc(&key);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();

    let id = generate_passcode_sha1(body["sif_user_id"].to_string(), body["password"].to_string());
    let user_info = npps4_req(id).await;
    if user_info.is_none() {
-        return global::api(&req, Some(object!{
+        return Api(Some(object!{
            sif_migrate_status: 38
        }));
    }
@@ -365,7 +345,7 @@ async fn sif_migrate(req: HttpRequest, body: String) -> impl Responder {
    userdata::save_acc_sif(&key, clean_sif_data(&user_info["units"]));
    userdata::save_acc(&key, user.clone());
    
-    global::api(&req, Some(object!{
+    Api(Some(object!{
        "sif_migrate_status": 0,
        "user": user["user"].clone(),
        "master_title_ids": user["master_title_ids"].clone()
@@ -373,17 +353,15 @@ async fn sif_migrate(req: HttpRequest, body: String) -> impl Responder {

 }

-async fn getregisteredplatformlist(req: HttpRequest, _body: String) -> impl Responder {
-    global::api(&req, Some(object!{
+async fn getregisteredplatformlist() -> impl Responder {
+    Api(Some(object!{
        "google": 0,
        "apple": 0,
        "twitter": 0
    }))
 }

-async fn initialize(req: HttpRequest, body: String) -> impl Responder {
-    let key = global::get_login(req.headers(), &body);
-    let body = jzon::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+async fn initialize(Session { key, body }: Session) -> impl Responder {
    
    let mut user = userdata::get_acc(&key);
    let mut user2 = userdata::get_acc_home(&key);
@@ -421,7 +399,7 @@ async fn initialize(req: HttpRequest, body: String) -> impl Responder {
        cardstoreward = array![40010001, 40020001, 40030001, 40040001, 40050001, 40060001, 40070001, 40080001, 40090001]; //liella
        masterid += 9 + 9 + 12; //nijigasaki
    } else {
-        return global::api(&req, None);
+        return Api(None);
    }
    masterid += userr;
    
@@ -462,5 +440,5 @@ async fn initialize(req: HttpRequest, body: String) -> impl Responder {
    userdata::save_acc_home(&key, user2);
    userdata::save_acc_missions(&key, missions);

-    global::api(&req, Some(user["user"].clone()))
+    Api(Some(user["user"].clone()))
 }
Author	SHA1	Message	Date
Ethan O'Brien	6eec06e164	Move response encryption handler to a response handler	2026-07-24 14:40:12 -05:00
Ethan O'Brien	0b0b50de36	Move all encryption to a session handler	2026-07-24 14:20:26 -05:00