v0.3.5

src/protocol/crypto.rs

@@ -2,9 +2,14 @@ use aes::{Aes128, cipher::{BlockDecrypt, BlockEncrypt, KeyInit, generic_array::G
 use aes_gcm::{Aes128Gcm, Nonce, aead::{AeadInPlace, KeyInit as AeadKeyInit}};
 use anyhow::{anyhow, bail, Context, Result};
 use base64::{engine::general_purpose::STANDARD, Engine};
-use rand::RngCore;
 
-pub const GENERIC_GREE_KEY: &str = "a3K8Bx%2r8Y7cB!a";
+/// Shared discovery/bind key used by the original AES-128-ECB protocol.
+pub const GENERIC_GREE_V1_KEY: &str = "a3K8Bx%2r8Y7#xDh";
+/// Shared discovery/bind key used by AES-128-GCM capable Wi-Fi modules.
+pub const GENERIC_GREE_V2_KEY: &str = "{yxAHAY_Lm6pbC/<";
+/// GREE protocol v2 uses a fixed nonce and AAD, matching the EWPE/GREE LAN protocol.
+const GCM_NONCE: [u8; 12] = [0x54, 0x40, 0x78, 0x44, 0x49, 0x67, 0x5a, 0x51, 0x6c, 0x5e, 0x63, 0x13];
+const GCM_AAD: &[u8] = b"qualcomm-test";
 
 pub fn normalize_key(key: &str) -> Result<[u8; 16]> {
     let bytes = key.as_bytes();
@@ -57,37 +62,31 @@ pub fn decrypt_v1(key: &str, ciphertext_b64: &str) -> Result<Vec<u8>> {
 #[derive(Debug, Clone)]
 pub struct V2Encrypted {
     pub ciphertext: String,
-    pub nonce: String,
     pub tag: String,
 }
 
 pub fn encrypt_v2(key: &str, plaintext: &[u8]) -> Result<V2Encrypted> {
     let key = normalize_key(key)?;
     let cipher = <Aes128Gcm as AeadKeyInit>::new_from_slice(&key).map_err(|_| anyhow!("invalid AES-GCM key"))?;
-    let mut nonce_bytes = [0_u8; 12];
-    rand::thread_rng().fill_bytes(&mut nonce_bytes);
-    let nonce = Nonce::from_slice(&nonce_bytes);
+    let nonce = Nonce::from_slice(&GCM_NONCE);
     let mut buffer = plaintext.to_vec();
-    let tag = cipher.encrypt_in_place_detached(nonce, b"", &mut buffer)
+    let tag = cipher.encrypt_in_place_detached(nonce, GCM_AAD, &mut buffer)
         .map_err(|_| anyhow!("AES-GCM encryption failed"))?;
     Ok(V2Encrypted {
         ciphertext: STANDARD.encode(buffer),
-        nonce: STANDARD.encode(nonce_bytes),
         tag: STANDARD.encode(tag),
     })
 }
 
-pub fn decrypt_v2(key: &str, ciphertext_b64: &str, nonce_b64: &str, tag_b64: &str) -> Result<Vec<u8>> {
+pub fn decrypt_v2(key: &str, ciphertext_b64: &str, tag_b64: &str) -> Result<Vec<u8>> {
     let key = normalize_key(key)?;
     let cipher = <Aes128Gcm as AeadKeyInit>::new_from_slice(&key).map_err(|_| anyhow!("invalid AES-GCM key"))?;
-    let nonce_bytes = STANDARD.decode(nonce_b64).context("invalid GCM nonce")?;
-    if nonce_bytes.len() != 12 { bail!("invalid GCM nonce length") }
     let tag_bytes = STANDARD.decode(tag_b64).context("invalid GCM tag")?;
     if tag_bytes.len() != 16 { bail!("invalid GCM tag length") }
     let mut data = STANDARD.decode(ciphertext_b64).context("invalid GCM ciphertext")?;
-    let nonce = Nonce::from_slice(&nonce_bytes);
+    let nonce = Nonce::from_slice(&GCM_NONCE);
     let tag = GenericArray::from_slice(&tag_bytes);
-    cipher.decrypt_in_place_detached(nonce, b"", &mut data, tag)
+    cipher.decrypt_in_place_detached(nonce, GCM_AAD, &mut data, tag)
         .map_err(|_| anyhow!("AES-GCM authentication failed"))?;
     Ok(data)
 }
@@ -99,14 +98,14 @@ mod tests {
     #[test]
     fn v1_round_trip() {
         let value = br#"{"t":"status","mac":"112233445566"}"#;
-        let encrypted = encrypt_v1(GENERIC_GREE_KEY, value).unwrap();
-        assert_eq!(decrypt_v1(GENERIC_GREE_KEY, &encrypted).unwrap(), value);
+        let encrypted = encrypt_v1(GENERIC_GREE_V1_KEY, value).unwrap();
+        assert_eq!(decrypt_v1(GENERIC_GREE_V1_KEY, &encrypted).unwrap(), value);
     }
 
     #[test]
     fn v2_round_trip() {
         let value = b"gree-gcm-test";
-        let encrypted = encrypt_v2(GENERIC_GREE_KEY, value).unwrap();
-        assert_eq!(decrypt_v2(GENERIC_GREE_KEY, &encrypted.ciphertext, &encrypted.nonce, &encrypted.tag).unwrap(), value);
+        let encrypted = encrypt_v2(GENERIC_GREE_V2_KEY, value).unwrap();
+        assert_eq!(decrypt_v2(GENERIC_GREE_V2_KEY, &encrypted.ciphertext, &encrypted.tag).unwrap(), value);
     }
 }