ydclient: fix new api fetch

Cargo.toml

@@ -20,7 +20,7 @@ atty = "^0.2"
 htmlescape = "0.3"
 reqwest = {version = "0.11", default-features = false, features = ["socks", "blocking"]}
 rand = "0.8"
-md-5 = "0.10"
+sha2 = "0.10"
 copypasta = {version = "0.8", optional = true}
 
 [target.'cfg(windows)'.dependencies]

src/ydclient.rs

@@ -2,20 +2,22 @@
 
 use super::ydresponse::YdResponse;
 use crate::lang::is_chinese;
+use lazy_static::lazy_static;
 use log::debug;
-use md5::{Md5, Digest};
 use rand::{thread_rng, Rng};
 use reqwest::blocking::Client;
 use reqwest::Url;
 use serde_json::{self, Error as SerdeError};
+use sha2::Sha256;
 use std::env::var;
-use lazy_static::lazy_static;
 use std::error::Error;
 use std::fmt::{self, Debug};
 use std::io::Read;
+use std::time::SystemTime;
+use sha2::Digest;
 
-const NEW_API_KEY: Option<&str> = option_env!("YD_NEW_APP_KEY");
-const NEW_APP_SEC: Option<&str> = option_env!("YD_NEW_APP_SEC");
+const NEW_API_ID: Option<&str> = option_env!("YD_NEW_APP_ID");
+const NEW_APP_KEY: Option<&str> = option_env!("YD_NEW_APP_KEY");
 
 lazy_static! {
     /// API name
@@ -29,11 +31,11 @@ lazy_static! {
         .unwrap_or_else(|_| String::from("1323298384")));
 
     /// New API APPKEY in Runtime
-    static ref NEW_API_KEY_RT: String = var("YD_NEW_APP_KEY")
+    static ref NEW_API_KEY_ID: String = var("YD_NEW_APP_ID")
         .unwrap_or_else(|_| String::from("ydcv-rs"));
 
     /// New API APPSEC in Runtime
-    static ref NEW_APP_SEC_RT: String = var("YD_NEW_APP_SEC")
+    static ref NEW_APP_KEY_RT: String = var("YD_NEW_APP_KEY")
         .unwrap_or_else(|_| String::from("ydcv-rs"));
 }
 
@@ -89,30 +91,38 @@ impl YdClient for Client {
 
     /// lookup a word on YD and returns a `YdResponse`
     fn lookup_word(&mut self, word: &str, raw: bool) -> Result<YdResponse, Box<dyn Error>> {
-        let body = lookup_word_old_api(word, self);
-
-        let body = if let Err(old_api_err) = body {
-            let body = lookup_word_new_api(word, self);
-
-            if let Err(new_api_err) = body {
+        let resp = lookup_word_old_api(word, self).and_then(|body| {
+            if raw {
+                YdResponse::new_raw(body).map_err(|e| Box::new(e) as Box<dyn Error>)
+            } else {
+                self.decode_result(&body)
+                    .map_err(|e| Box::new(e) as Box<dyn Error>)
+            }
+        });
+
+        let resp = if let Err(old_api_err) = resp {
+            let resp = lookup_word_new_api(word, self).and_then(|body| {
+                if raw {
+                    YdResponse::new_raw(body).map_err(|e| Box::new(e) as Box<dyn Error>)
+                } else {
+                    self.decode_result(&body)
+                        .map_err(|e| Box::new(e) as Box<dyn Error>)
+                }
+            });
+
+            if let Err(new_api_err) = resp {
                 return Err(Box::new(YdClientErr::NewAndOldAPIError(
                     new_api_err.to_string(),
                     old_api_err.to_string(),
                 )));
             }
 
-            body
+            resp
         } else {
-            body
+            resp
         }?;
 
-        let raw_result = YdResponse::new_raw(body.clone());
-
-        if raw {
-            raw_result.map_err(Into::into)
-        } else {
-            self.decode_result(&body).map_err(Into::into)
-        }
+        Ok(resp)
     }
 }
 
@@ -134,34 +144,42 @@ fn lookup_word_old_api(word: &str, client: &Client) -> Result<String, Box<dyn Er
         .get(url)
         // .header(Connection::close())
         .send()?
+        .error_for_status()?
         .read_to_string(&mut body)?;
 
     Ok(body)
 }
 
 fn lookup_word_new_api(word: &str, client: &Client) -> Result<String, Box<dyn Error>> {
-    let (new_api_key, new_app_sec) =
-        if let (Some(new_api_key), Some(new_app_sec)) = (NEW_API_KEY, NEW_APP_SEC) {
-            (new_api_key, new_app_sec)
-        } else if NEW_API_KEY_RT.as_str() != "ydcv-rs" && NEW_APP_SEC_RT.as_str() != "ydcv-rs" {
-            (NEW_API_KEY_RT.as_str(), NEW_APP_SEC_RT.as_str())
+    let (new_api_id, new_app_key) =
+        if let (Some(new_api_id), Some(new_app_key)) = (NEW_API_ID, NEW_APP_KEY) {
+            (new_api_id, new_app_key)
+        } else if NEW_API_KEY_ID.as_str() != "ydcv-rs" && NEW_APP_KEY_RT.as_str() != "ydcv-rs" {
+            (NEW_API_KEY_ID.as_str(), NEW_APP_KEY_RT.as_str())
         } else {
             return Err(Box::new(YdClientErr::NewApiValueError));
         };
 
     let to = get_translation_lang(word);
+    let ts = SystemTime::now()
+        .duration_since(SystemTime::UNIX_EPOCH)?
+        .as_secs()
+        .to_string();
+
     let salt = get_salt();
-    let sign = get_sign(new_api_key, word, &salt, new_app_sec);
+    let sign = get_sign(new_api_id, word, &salt, new_app_key, &ts);
 
     let url = api(
         "https://openapi.youdao.com/api",
         &[
-            ("appKey", new_api_key),
+            ("appKey", new_api_id),
             ("q", word),
             ("from", "auto"),
             ("to", to),
             ("salt", &salt),
             ("sign", &sign),
+            ("signType", "v3"),
+            ("curtime", &ts),
         ],
     )?;
 
@@ -179,14 +197,16 @@ fn api(url: &str, query: &[(&str, &str)]) -> Result<Url, Box<dyn Error>> {
     let mut url = Url::parse(url)?;
     url.query_pairs_mut().extend_pairs(query.iter());
 
+    debug!("url: {url}");
+
     Ok(url)
 }
 
-fn get_sign(api_key: &str, word: &str, salt: &str, app_sec: &str) -> String {
-    let sign_no_md5 = format!("{}{}{}{}", api_key, word, &salt, app_sec);
+fn get_sign(api_id: &str, word: &str, salt: &str, app_key: &str, curtime: &str) -> String {
+    let sign = format!("{}{}{}{}{}", api_id, word, &salt, curtime, app_key);
 
-    let mut hasher = Md5::new();
-    hasher.update(sign_no_md5);
+    let mut hasher = Sha256::new();
+    hasher.update(sign);
 
     let sign = hasher.finalize();
     let sign = format!("{:2x}", sign);