Skip to main content

wechat_protocol/
contact_sync.rs

1//! Linux 4.1.13.26 contact stream (CGI8674). This stream has its own
2//! `rs_config`/`sync_11` cursor; the message SyncKey is only request context.
3use crate::errors::{Service, ServiceRejected};
4use crate::{protobuf as p, wire, AccountState, NativeClient};
5use anyhow::{bail, ensure, Result};
6use serde::{Deserialize, Serialize};
7use std::collections::HashSet;
8
9pub const CONTACT_SELECTOR: u64 = 0x20004;
10
11#[derive(Clone, Serialize, Deserialize)]
12pub struct ContactSyncBatch {
13    pub cursor: Vec<u8>,
14    pub continuation: Vec<u64>,
15    pub commands: Vec<wire::SyncCommand>,
16    pub raw: Vec<u8>,
17}
18
19/// SyncKeyBuffer: repeated field1 SyncKeyPair { key1:u32, value2:u64 }.
20/// Keep the supplied encoding intact, including unknown fields, for publication.
21pub fn validate_cursor(input: &[u8]) -> Result<()> {
22    ensure!(input.len() <= 65536, "Contact cursor exceeds limit");
23    let fields = p::decode(input)?;
24    let mut keys = HashSet::new();
25    for field in fields.iter().filter(|field| field.number == 1) {
26        let p::Value::Bytes(raw) = &field.value else {
27            bail!("Invalid contact cursor pair");
28        };
29        let pair = p::decode(raw)?;
30        let key = u32::try_from(p::scalar(&pair, 1)?)?;
31        p::scalar(&pair, 2)?;
32        ensure!(
33            keys.insert(key) && keys.len() <= 256,
34            "Invalid contact cursor keys"
35        );
36    }
37    Ok(())
38}
39
40pub fn request(
41    state: &AccountState,
42    cursor: &[u8],
43    message_cursor: &[u8],
44    continuation: bool,
45) -> Result<Vec<u8>> {
46    validate_cursor(cursor)?;
47    ensure!(
48        message_cursor.len() <= 65536,
49        "Message cursor exceeds limit"
50    );
51    ensure!(
52        !cursor.is_empty() || !message_cursor.is_empty(),
53        "Contact sync has no cursor context"
54    );
55    // The drain at 0x6202310 uses scene3 initially and scene4 after a response
56    // with nonzero continuation selectors. Request3 is repeated uint64.
57    let mut fields = vec![
58        p::bytes(1, &wire::base_request(&state.device, state.uin, 0)?),
59        p::uint(2, if continuation { 4 } else { 3 }),
60        p::uint(3, CONTACT_SELECTOR),
61        p::bytes(4, cursor),
62    ];
63    fields.push(p::bytes(5, message_cursor));
64    p::message(&fields)
65}
66
67pub fn decode(input: &[u8]) -> Result<ContactSyncBatch> {
68    ensure!(
69        input.len() <= 16 * 1024 * 1024,
70        "Contact response exceeds limit"
71    );
72    let fields = p::decode(input)?;
73    let code = p::base_code(&fields)?;
74    ServiceRejected::check(Service::ContactSync, code)?;
75    let cursor = p::data(&fields, 3)?.to_vec();
76    validate_cursor(&cursor)?;
77    let mut continuation = Vec::new();
78    let mut commands = Vec::new();
79    for field in fields {
80        match (field.number, field.value) {
81            (2, p::Value::Varint(value)) => {
82                continuation.push(value);
83                ensure!(
84                    continuation.len() <= 64,
85                    "Contact continuation exceeds limit"
86                );
87            }
88            (4, p::Value::Bytes(raw)) => {
89                let item = p::decode(&raw)?;
90                // This stream carries raw CmdItem payloads; NewSync uses SKBuffer.
91                commands.push(wire::SyncCommand {
92                    id: i32::try_from(p::scalar(&item, 1)?)?,
93                    payload: p::data(&item, 2)?.to_vec(),
94                });
95                ensure!(commands.len() <= 10000, "Contact command limit");
96            }
97            (2 | 4, _) => bail!("Invalid contact response field type"),
98            _ => {}
99        }
100    }
101    Ok(ContactSyncBatch {
102        cursor,
103        continuation,
104        commands,
105        raw: input.to_vec(),
106    })
107}
108
109impl NativeClient {
110    #[doc(hidden)]
111    pub(crate) fn contact_sync_snapshot(
112        &self,
113        state: &mut AccountState,
114        cursor: &[u8],
115        message_cursor: &[u8],
116        continuation: bool,
117    ) -> Result<ContactSyncBatch> {
118        let request = request(state, cursor, message_cursor, continuation)?;
119        decode(&self.authenticated_rpc(
120            state,
121            8674,
122            "/cgi-bin/micromsg-bin/contactsync",
123            &request,
124        )?)
125    }
126}
127
128#[cfg(test)]
129mod tests {
130    use super::*;
131    fn pair(key: u64, value: u64) -> Vec<u8> {
132        p::bytes(
133            1,
134            &p::message(&[p::uint(1, key), p::uint(2, value)]).unwrap(),
135        )
136    }
137    #[test]
138    fn cursor_values_keep_u64_and_reject_duplicate_or_malformed_keys() {
139        validate_cursor(&pair(11, u64::MAX)).unwrap();
140        assert!(validate_cursor(&[pair(11, 1), pair(11, 2)].concat()).is_err());
141        assert!(validate_cursor(&p::uint(1, 11)).is_err());
142        assert!(validate_cursor(&pair(u32::MAX as u64 + 1, 0)).is_err());
143    }
144    #[test]
145    fn final_and_continuing_pages_retain_unknown_commands_and_raw_bytes() {
146        for flags in [vec![0], vec![0, CONTACT_SELECTOR]] {
147            let mut fields = vec![
148                p::bytes(1, &p::message(&[p::int32(1, 0)]).unwrap()),
149                p::bytes(3, &pair(11, 7)),
150                p::bytes(
151                    4,
152                    &p::message(&[p::uint(1, 912), p::bytes(2, b"unknown")]).unwrap(),
153                ),
154            ];
155            fields.extend(flags.iter().map(|value| p::uint(2, *value)));
156            let raw = p::message(&fields).unwrap();
157            let batch = decode(&raw).unwrap();
158            assert_eq!(batch.continuation, flags);
159            assert_eq!(batch.commands[0].id, 912);
160            assert_eq!(batch.commands[0].payload, b"unknown");
161            assert_eq!(batch.raw, raw);
162        }
163    }
164}