feat: authlite command

sdgb-api/Cargo.toml

@@ -8,6 +8,7 @@ license = "GPL-3.0"
 [dependencies]
 snafu = { workspace = true }
 serde_json = { workspace = true }
+strum = {workspace = true}
 
 # hashing
 digest = "0.10.7"
@@ -16,7 +17,6 @@ md5 = "0.8.0"
 
 # other utils
 chrono = "0.4.41"
-strum = { version = "0.27.2", features = ["derive"] }
 
 # network request
 nyquest = { version = "0.2.0", features = ["async", "json"] }

sdgb-api/src/auth_lite/mod.rs

@@ -10,42 +10,71 @@ use nyquest::{
 
 use crate::error::ApiError;
 
-const AES_KEY: &[u8; 16] = br#"/?jo+"L&\Cr9(=kG"#;
 const AES_IV: &[u8; 16] = b"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
 
-pub async fn delivery_raw(
+pub trait Delivery {
+    const AES_KEY: &[u8; 16];
+    const TITLE_ID: &str;
+    const USER_AGENT: &str;
+}
+
+/// only for fun
+pub struct SDHJ;
+pub struct SDGB;
+
+impl Delivery for SDHJ {
+    const AES_KEY: &[u8; 16] = b"-a57UX4y9/h(ImAQ";
+    const TITLE_ID: &str = "SDHJ";
+    const USER_AGENT: &str = "SDHJ;Windows/Lite";
+}
+
+impl Delivery for SDGB {
+    const AES_KEY: &[u8; 16] = br#"/?jo+"L&\Cr9(=kG"#;
+    const TITLE_ID: &str = "SDGB";
+    const USER_AGENT: &str = "SDGB;Windows/Lite";
+}
+
+pub async fn delivery_raw<D>(
     client: &AsyncClient,
     title_ver: impl AsRef<str>,
-) -> Result<Vec<u8>, ApiError> {
+) -> Result<Vec<u8>, ApiError>
+where
+    D: Delivery,
+{
     let title_ver = title_ver.as_ref();
-    let params = format!("title_id=SDGB&title_ver={title_ver}&client_id=A63E01C2805");
-    let enc_data = encrypt(params, AES_KEY, AES_IV)?;
+    let params = format!(
+        "title_id={}&title_ver={title_ver}&client_id=A63E01C2805",
+        D::TITLE_ID
+    );
+    let enc_data = encrypt(params, D::AES_KEY, AES_IV)?;
 
     let req = Request::post("http://at.sys-allnet.cn/net/delivery/instruction")
         .with_body(Body::bytes(enc_data, "application/xxx-form-urlencoded"))
-        .with_header(USER_AGENT, "SDGB;Windows/Lite")
+        .with_header(USER_AGENT, D::USER_AGENT)
         .with_header("Pragma", "DFI");
 
     let mut resp = client.request(req).await?.bytes().await?;
-    let dec_len = decrypt(&mut resp, AES_KEY, AES_IV)?.len();
-    resp.truncate(dec_len);
-    Ok(resp)
+    let dec_len = decrypt(&mut resp, D::AES_KEY, AES_IV)?.len();
+    Ok(resp[16..dec_len].to_vec())
 }
 
 type Aes128CbcEnc = cbc::Encryptor<aes::Aes128>;
 type Aes128CbcDec = cbc::Decryptor<aes::Aes128>;
 
 fn encrypt(data: impl AsRef<[u8]>, key: &[u8; 16], iv: &[u8; 16]) -> Result<Vec<u8>, ApiError> {
+    let mut headed_data = vec![0u8; 16];
+    headed_data.extend_from_slice(data.as_ref());
+
     let key = GenericArray::from_slice(key);
     let iv = GenericArray::from_slice(iv);
     let encryptor = Aes128CbcEnc::new(key, iv);
-    let data = data.as_ref();
-    let bs = aes::Aes256::block_size();
-    let pad_len = bs - data.len() % bs;
 
-    let mut buf = vec![0; pad_len + data.len()];
-    buf[..data.len()].copy_from_slice(&data);
-    encryptor.encrypt_padded_mut::<Pkcs7>(&mut buf, data.len())?;
+    let bs = aes::Aes128::block_size();
+    let pad_len = bs - headed_data.len() % bs;
+
+    let mut buf = vec![0; pad_len + headed_data.len()];
+    buf[..headed_data.len()].copy_from_slice(&headed_data);
+    encryptor.encrypt_padded_mut::<Pkcs7>(&mut buf, headed_data.len())?;
     Ok(buf)
 }