Skip to main content

wechat_protocol/
business.rs

1//! Business encryption is separate from authenticated MMTLS records.
2use crate::errors::{Service, ServiceRejected};
3use crate::{crypto::*, protobuf as p, MAX_MESSAGE_BYTES};
4use anyhow::{bail, ensure, Result};
5use openssl::{nid::Nid, symm::Mode};
6use zeroize::Zeroize;
7
8pub struct PublicProfile {
9    pub version: u16,
10    pub point: Vec<u8>,
11    pub signature_pem: String,
12}
13pub fn profile_for_region(region: u32) -> Result<PublicProfile> {
14    let version = match region {
15        1 => 10014,
16        2 => 50005,
17        _ => bail!("Unsupported business certificate region"),
18    };
19    let pins: serde_json::Value =
20        serde_json::from_str(include_str!("../fixtures/business-public-keys.json"))?;
21    let pin = pins["profiles"]
22        .as_array()
23        .unwrap()
24        .iter()
25        .find(|p| p["certVersion"].as_u64() == Some(version))
26        .ok_or_else(|| anyhow::anyhow!("Missing business pin"))?;
27    Ok(PublicProfile {
28        version: version as u16,
29        point: hex::decode(pin["ecdhPointHex"].as_str().unwrap())?,
30        signature_pem: pin["ecdsaPEM"].as_str().unwrap().to_string(),
31    })
32}
33pub struct Prelogin {
34    pub request: Vec<u8>,
35    local: Ecdh,
36    plain: Vec<u8>,
37    derived: Vec<u8>,
38    encrypted_payload: Vec<u8>,
39    signature_pem: String,
40    has_auth_key: bool,
41}
42impl Drop for Prelogin {
43    fn drop(&mut self) {
44        self.plain.zeroize();
45        self.derived.zeroize();
46    }
47}
48impl Prelogin {
49    pub fn prepare(plain: &[u8], profile: &PublicProfile, auth_key: &[u8]) -> Result<Self> {
50        ensure!(
51            plain.len() <= MAX_MESSAGE_BYTES,
52            "Prelogin plaintext too large"
53        );
54        ensure!(
55            profile.point.len() == 65 && profile.point[0] == 4,
56            "Invalid business pin"
57        );
58        ensure!(
59            auth_key.is_empty() || auth_key.len() >= 24,
60            "Invalid saved Hybrid auth key"
61        );
62        let local = Ecdh::generate(Nid::X9_62_PRIME256V1)?;
63        let point = local.public()?;
64        let prefix = [b"1415".as_slice(), &point].concat();
65        let aad = sha256(&prefix);
66        let mut shared = sha256(&local.derive(&profile.point)?);
67        let mut random32 = random::<32>()?;
68        let encrypted_random = envelope_seal(&random32, &shared[..24], &aad, random()?)?;
69        shared.zeroize();
70        let auth_block = if auth_key.is_empty() {
71            vec![]
72        } else {
73            envelope_seal(&random32, &auth_key[..24], &aad, random()?)?
74        };
75        let mut extracted = hmac(b"security hdkf expand", &random32)?;
76        let derived = expand(&extracted, &aad, 56)?;
77        random32.zeroize();
78        extracted.zeroize();
79        let payload_aad = sha256(&[prefix, encrypted_random.clone(), auth_block.clone()].concat());
80        let encrypted_payload = envelope_seal(plain, &derived[..24], &payload_aad, random()?)?;
81        let request = p::message(&[
82            p::uint(1, 1),
83            p::bytes(2, &p::message(&[p::uint(1, 415), p::bytes(2, &point)])?),
84            p::bytes(3, &encrypted_random),
85            p::bytes(4, &auth_block),
86            p::bytes(5, &encrypted_payload),
87        ])?;
88        Ok(Self {
89            request,
90            local,
91            plain: plain.to_vec(),
92            derived,
93            encrypted_payload,
94            signature_pem: profile.signature_pem.clone(),
95            has_auth_key: !auth_key.is_empty(),
96        })
97    }
98    pub fn decrypt_reply(&self, reply: &[u8]) -> Result<Vec<u8>> {
99        let f = p::decode(reply)?;
100        let key = p::decode(p::data(&f, 1)?)?;
101        ensure!(p::scalar(&key, 1)? == 415, "Unsupported business curve");
102        let point = p::data(&key, 2)?;
103        let credential = p::scalar(&f, 2)?;
104        ensure!(
105            point.len() == 65
106                && point[0] == 4
107                && [1, 2].contains(&credential)
108                && (credential != 2 || self.has_auth_key),
109            "Unsupported business credential"
110        );
111        let ciphertext = p::data(&f, 3)?;
112        if credential == 1 {
113            verify_signature(
114                &self.signature_pem,
115                &sha256(&[self.encrypted_payload.as_slice(), ciphertext].concat()),
116                p::data(&f, 4)?,
117            )?;
118        }
119        let mut shared = sha256(&self.local.derive(point)?);
120        let aad = sha256(
121            &[
122                &self.derived[24..],
123                &self.plain,
124                b"415",
125                point,
126                credential.to_string().as_bytes(),
127            ]
128            .concat(),
129        );
130        let plain = envelope_open(ciphertext, &shared[..24], &aad);
131        shared.zeroize();
132        plain
133    }
134}
135pub struct PacketPolicy<'a> {
136    pub client_version: u32,
137    pub uin: u32,
138    pub cookie: &'a [u8],
139    pub cgi: u16,
140    pub original_length: usize,
141    pub pre_encryption_length: usize,
142    pub key_version: u16,
143    pub cert_version: u16,
144    pub checksum: u32,
145    pub compression: u8,
146    pub encryption: u8,
147    pub notice_id: u32,
148    pub sequence: u16,
149}
150pub fn pack(policy: PacketPolicy<'_>, encrypted: &[u8]) -> Result<Vec<u8>> {
151    ensure!(
152        policy.cookie.len() <= 15 && policy.compression <= 3 && policy.encryption <= 15,
153        "Invalid business policy"
154    );
155    ensure!(
156        policy.original_length <= MAX_MESSAGE_BYTES
157            && policy.pre_encryption_length <= MAX_MESSAGE_BYTES,
158        "Business payload too large"
159    );
160    let tail = [
161        policy.client_version.to_be_bytes().to_vec(),
162        policy.uin.to_be_bytes().to_vec(),
163        policy.cookie.to_vec(),
164        p::varint(policy.cgi as u64),
165        p::varint(policy.original_length as u64),
166        p::varint(policy.pre_encryption_length as u64),
167        p::varint(policy.key_version as u64),
168        p::varint(policy.cert_version as u64),
169        p::varint(policy.checksum as u64),
170        vec![0xff],
171        p::varint(policy.notice_id as u64),
172        vec![0, 0],
173        p::varint(0),
174        policy.sequence.to_be_bytes().to_vec(),
175    ]
176    .concat();
177    let length = tail.len() + 3;
178    ensure!(length <= 63, "Unsupported extended business header");
179    let flags = ((length as u16) << 2)
180        | policy.compression as u16
181        | ((policy.cookie.len() as u16) << 8)
182        | ((policy.encryption as u16) << 12);
183    Ok([
184        vec![0xbf],
185        flags.to_le_bytes().to_vec(),
186        tail,
187        encrypted.to_vec(),
188    ]
189    .concat())
190}
191pub fn prelogin_packet(
192    prelogin: &Prelogin,
193    cgi: u16,
194    key_version: u16,
195    cookie: &[u8],
196) -> Result<Vec<u8>> {
197    pack(
198        PacketPolicy {
199            client_version: 0,
200            uin: 0,
201            cookie,
202            cgi,
203            original_length: prelogin.plain.len(),
204            pre_encryption_length: prelogin.plain.len(),
205            key_version,
206            cert_version: 0,
207            checksum: 0,
208            compression: 2,
209            encryption: 12,
210            notice_id: crate::notice::notice_id(&prelogin.request)?,
211            sequence: u16::from_be_bytes(random()?),
212        },
213        &prelogin.request,
214    )
215}
216pub struct Envelope {
217    pub return_code: i32,
218    pub cgi: u64,
219    pub original_length: usize,
220    pub pre_encryption_length: usize,
221    pub compression: u8,
222    pub encryption: u8,
223    pub cookie: Vec<u8>,
224    pub payload: Vec<u8>,
225}
226pub fn split(input: &[u8]) -> Result<Envelope> {
227    ensure!(input.len() >= 10, "Truncated business response");
228    let base = usize::from(input[0] == 0xbf);
229    let flags = u16::from_le_bytes(input[base..base + 2].try_into()?);
230    let header = ((flags >> 2) & 63) as usize;
231    let cookie_len = ((flags >> 8) & 15) as usize;
232    let cookie_offset = base + 10;
233    ensure!(
234        header >= cookie_offset + cookie_len && header <= input.len(),
235        "Invalid business boundary"
236    );
237    let return_code = i32::from_be_bytes(input[base + 2..base + 6].try_into()?);
238    let mut offset = cookie_offset + cookie_len;
239    let cgi = p::read_varint(&input[..header], &mut offset)?;
240    let original_length = usize::try_from(p::read_varint(&input[..header], &mut offset)?)?;
241    let pre_encryption_length = usize::try_from(p::read_varint(&input[..header], &mut offset)?)?;
242    p::read_varint(&input[..header], &mut offset)?;
243    p::read_varint(&input[..header], &mut offset)?;
244    if base == 0 {
245        ensure!(offset == header, "Unknown business response extension");
246    }
247    ensure!(
248        original_length <= MAX_MESSAGE_BYTES && pre_encryption_length <= MAX_MESSAGE_BYTES,
249        "Response too large"
250    );
251    Ok(Envelope {
252        return_code,
253        cgi,
254        original_length,
255        pre_encryption_length,
256        compression: (flags & 3) as u8,
257        encryption: (flags >> 12) as u8,
258        cookie: input[cookie_offset..cookie_offset + cookie_len].to_vec(),
259        payload: input[header..].to_vec(),
260    })
261}
262pub fn checksum(uin: u32, payload: &[u8]) -> u32 {
263    let mut input = (payload.len() as u32).to_be_bytes().to_vec();
264    input.extend(md5(&uin.to_be_bytes()));
265    let prefix = md5(&input);
266    let mut a = 1u32;
267    let mut b = 0u32;
268    for byte in prefix.iter().chain(payload) {
269        a = (a + *byte as u32) % 65521;
270        b = (b + a) % 65521;
271    }
272    (b << 16) | a
273}
274pub struct AuthenticatedPacket {
275    pub packet: Vec<u8>,
276    cgi: u16,
277    mode: u8,
278    key: Vec<u8>,
279}
280impl Drop for AuthenticatedPacket {
281    fn drop(&mut self) {
282        self.key.zeroize();
283    }
284}
285impl AuthenticatedPacket {
286    pub fn prepare(state: &crate::AccountState, cgi: u16, plain: &[u8]) -> Result<Self> {
287        state.validate()?;
288        ensure!(
289            plain.len() <= MAX_MESSAGE_BYTES,
290            "Authenticated request too large"
291        );
292        let mode = if !state.request_key.is_empty() && !state.response_key.is_empty() {
293            13
294        } else {
295            5
296        };
297        let zipped = if mode == 5 {
298            deflate(plain)?
299        } else {
300            plain.to_vec()
301        };
302        let compressed = mode == 5 && zipped.len() < plain.len();
303        let body = if compressed { zipped.as_slice() } else { plain };
304        let key = if mode == 13 {
305            ensure!(
306                state.request_key.len() == 24 && state.response_key.len() == 24,
307                "Invalid main session keys"
308            );
309            state.response_key.clone()
310        } else {
311            ensure!(state.session_key.len() == 16, "Invalid origin session key");
312            state.session_key.clone()
313        };
314        let encrypted = if mode == 13 {
315            envelope_seal(body, &state.request_key, b"", random()?)?
316        } else {
317            cbc(body, &key, Mode::Encrypt)?
318        };
319        let packet = pack(
320            PacketPolicy {
321                client_version: state.device.client_version as u32,
322                uin: state.uin,
323                cookie: &state.cookie,
324                cgi,
325                original_length: plain.len(),
326                pre_encryption_length: body.len(),
327                key_version: 0,
328                cert_version: 39,
329                checksum: checksum(state.uin, plain),
330                compression: if compressed { 1 } else { 2 },
331                encryption: mode,
332                notice_id: crate::notice::notice_id(&encrypted)?,
333                sequence: u16::from_be_bytes(random()?),
334            },
335            &encrypted,
336        )?;
337        Ok(Self {
338            packet,
339            cgi,
340            mode,
341            key,
342        })
343    }
344    /// Call only on the plaintext returned by the authenticated MMTLS transport.
345    pub fn decode_verified_transport_reply(&self, input: &[u8]) -> Result<(Vec<u8>, Vec<u8>)> {
346        let envelope = split(input)?;
347        ServiceRejected::check(Service::NativeEnvelope, envelope.return_code)?;
348        ensure!(
349            envelope.cgi == self.cgi as u64
350                && envelope.encryption == self.mode
351                && [1, 2].contains(&envelope.compression),
352            "Unsupported authenticated response policy"
353        );
354        let body = if self.mode == 13 {
355            envelope_open(&envelope.payload, &self.key, b"")?
356        } else {
357            cbc(&envelope.payload, &self.key, Mode::Decrypt)?
358        };
359        ensure!(
360            body.len() == envelope.pre_encryption_length,
361            "Authenticated body length mismatch"
362        );
363        let plain = if envelope.compression == 1 {
364            inflate(&body)?
365        } else {
366            body
367        };
368        ensure!(
369            plain.len() == envelope.original_length,
370            "Authenticated plaintext length mismatch"
371        );
372        Ok((plain, envelope.cookie))
373    }
374}
375pub fn account_keys(inner: &Ecdh, auth: &[u8]) -> Result<(Vec<u8>, Vec<u8>, Vec<u8>)> {
376    let f = p::decode(auth)?;
377    let flags = match p::optional(&f, 19)? {
378        Some(p::Value::Varint(v)) => *v,
379        None => 0,
380        _ => bail!("Invalid auth flags"),
381    };
382    let raw = p::unbuffer(p::data(&f, 3)?)?;
383    let session = if flags & 4 != 0 {
384        let e = p::decode(p::data(&f, 2)?)?;
385        ensure!(p::scalar(&e, 1)? == 713, "Unsupported account curve");
386        let point = p::unbuffer(p::data(&e, 2)?)?;
387        ensure!(point.len() == 57 && point[0] == 4, "Invalid account point");
388        let mut secret = inner.derive(&point)?;
389        ensure!(secret.len() == 28, "Invalid P224 secret");
390        let mut key = md5(&secret);
391        secret.zeroize();
392        let result = cbc(&raw, &key, Mode::Decrypt);
393        key.zeroize();
394        result?
395    } else {
396        raw
397    };
398    ensure!(
399        !session.is_empty() && session.len() <= 65536,
400        "Invalid derived session key"
401    );
402    let get = |n| -> Result<Vec<u8>> {
403        Ok(match p::optional_data(&f, n)? {
404            Some(b) => p::unbuffer(b)?,
405            None => vec![],
406        })
407    };
408    Ok((session, get(23)?, get(24)?))
409}
410
411#[cfg(test)]
412mod tests {
413    use super::*;
414    #[test]
415    fn independent_checksum_vectors() {
416        for (uin, payload, expected) in [
417            (0, vec![], 0x4e970913),
418            (1, b"a".to_vec(), 0x39d20759),
419            (0x12345678, b"abc".to_vec(), 0x69430a30),
420            (u32::MAX, (0..=255).collect(), 0xf74e868e),
421        ] {
422            assert_eq!(checksum(uin, &payload), expected);
423        }
424    }
425    #[test]
426    fn prelogin_profiles_validate() {
427        for region in [1, 2] {
428            let profile = profile_for_region(region).unwrap();
429            assert!(
430                Prelogin::prepare(b"synthetic", &profile, &[])
431                    .unwrap()
432                    .request
433                    .len()
434                    > 100
435            );
436        }
437        assert!(profile_for_region(3).is_err());
438    }
439    #[test]
440    fn encrypted_envelope_rejects_aad() {
441        let key = [3; 24];
442        let aad = sha256(b"a");
443        let e = envelope_seal(b"synthetic", &key, &aad, [4; 12]).unwrap();
444        assert_eq!(envelope_open(&e, &key, &aad).unwrap(), b"synthetic");
445        assert!(envelope_open(&e, &key, &sha256(b"b")).is_err());
446    }
447    #[test]
448    fn synthetic_signed_peer_and_saved_credential() {
449        use openssl::{
450            ec::{EcGroup, EcKey},
451            hash::MessageDigest,
452            pkey::PKey,
453            sign::Signer,
454        };
455        let static_key = Ecdh::generate(Nid::X9_62_PRIME256V1).unwrap();
456        let signing = PKey::from_ec_key(
457            EcKey::generate(&EcGroup::from_curve_name(Nid::X9_62_PRIME256V1).unwrap()).unwrap(),
458        )
459        .unwrap();
460        let profile = PublicProfile {
461            version: 1,
462            point: static_key.public().unwrap(),
463            signature_pem: String::from_utf8(signing.public_key_to_pem().unwrap()).unwrap(),
464        };
465        for credential in [1, 2] {
466            let auth = if credential == 2 {
467                vec![11; 380]
468            } else {
469                vec![]
470            };
471            let request = b"synthetic login";
472            let local = Prelogin::prepare(request, &profile, &auth).unwrap();
473            let f = p::decode(&local.request).unwrap();
474            let key = p::decode(p::data(&f, 2).unwrap()).unwrap();
475            let point = p::data(&key, 2).unwrap();
476            let prefix = [b"1415".as_slice(), point].concat();
477            let aad = sha256(&prefix);
478            let random = envelope_open(
479                p::data(&f, 3).unwrap(),
480                &sha256(&static_key.derive(point).unwrap())[..24],
481                &aad,
482            )
483            .unwrap();
484            let derived =
485                expand(&hmac(b"security hdkf expand", &random).unwrap(), &aad, 56).unwrap();
486            assert_eq!(
487                envelope_open(
488                    p::data(&f, 5).unwrap(),
489                    &derived[..24],
490                    &sha256(
491                        &[
492                            prefix,
493                            p::data(&f, 3).unwrap().to_vec(),
494                            p::data(&f, 4).unwrap().to_vec()
495                        ]
496                        .concat()
497                    )
498                )
499                .unwrap(),
500                request
501            );
502            if credential == 2 {
503                assert_eq!(
504                    envelope_open(p::data(&f, 4).unwrap(), &auth[..24], &aad).unwrap(),
505                    random
506                );
507            }
508            let ephemeral = Ecdh::generate(Nid::X9_62_PRIME256V1).unwrap();
509            let server_point = ephemeral.public().unwrap();
510            let response_aad = sha256(
511                &[
512                    &derived[24..],
513                    request,
514                    b"415",
515                    &server_point,
516                    credential.to_string().as_bytes(),
517                ]
518                .concat(),
519            );
520            let ciphertext = envelope_seal(
521                b"synthetic authenticated reply",
522                &sha256(&ephemeral.derive(point).unwrap())[..24],
523                &response_aad,
524                [4; 12],
525            )
526            .unwrap();
527            let mut fields = vec![
528                p::bytes(
529                    1,
530                    &p::message(&[p::uint(1, 415), p::bytes(2, &server_point)]).unwrap(),
531                ),
532                p::uint(2, credential),
533                p::bytes(3, &ciphertext),
534            ];
535            if credential == 1 {
536                let mut signer = Signer::new(MessageDigest::sha256(), &signing).unwrap();
537                signer
538                    .update(&sha256(&[p::data(&f, 5).unwrap(), &ciphertext].concat()))
539                    .unwrap();
540                fields.push(p::bytes(4, &signer.sign_to_vec().unwrap()));
541            }
542            let response = p::message(&fields).unwrap();
543            assert_eq!(
544                local.decrypt_reply(&response).unwrap(),
545                b"synthetic authenticated reply"
546            );
547            let mut corrupt = response;
548            let n = corrupt.len();
549            corrupt[n - 1] ^= 1;
550            assert!(local.decrypt_reply(&corrupt).is_err());
551        }
552    }
553}