Skip to main content

wechat_protocol/
group_inventory.rs

1//! Separate group catalog and lossless read-only metadata response receipts.
2use super::*;
3use std::collections::HashSet;
4
5#[derive(Clone, Serialize, Deserialize)]
6pub struct MetadataReply<T> {
7    pub value: T,
8    pub raw: Vec<u8>,
9}
10#[derive(Clone, Serialize, Deserialize)]
11pub struct GroupMetadataPage {
12    pub contacts: Vec<ContactRecord>,
13    pub next_cursor: Option<Vec<u8>>,
14    pub more: bool,
15    pub wait_seconds: u32,
16    pub raw: Vec<u8>,
17}
18pub fn group_inventory_request(state: &AccountState, cursor: &[u8]) -> Result<Vec<u8>> {
19    ensure!(
20        !cursor.is_empty() && cursor.len() <= 65536,
21        "Invalid raw group cursor"
22    );
23    p::message(&[
24        p::bytes(1, &wire::base_request(&state.device, state.uin, 0)?),
25        p::bytes(2, cursor),
26    ])
27}
28pub fn decode_group_inventory(raw: &[u8]) -> Result<GroupMetadataPage> {
29    let fields = p::decode(raw)?;
30    let code = p::base_code(&fields)?;
31    ensure!(code == 0, "Group metadata service returned {code}");
32    let mut contacts = vec![];
33    let mut seen = HashSet::new();
34    for field in fields.iter().filter(|f| f.number == 2) {
35        let p::Value::Bytes(raw) = &field.value else {
36            bail!("Invalid group contact field")
37        };
38        let record = wire::decode_contact_record(raw)?;
39        ensure!(
40            seen.insert(record.username.clone()) && contacts.len() < 5000,
41            "Duplicate or excessive group metadata"
42        );
43        contacts.push(record);
44    }
45    let next_cursor = p::optional_data(&fields, 3)?.map(Vec::from);
46    ensure!(
47        next_cursor
48            .as_ref()
49            .is_none_or(|c| !c.is_empty() && c.len() <= 65536),
50        "Invalid next group cursor"
51    );
52    let control = p::optional_data(&fields, 4)?
53        .map(p::decode)
54        .transpose()?
55        .unwrap_or_default();
56    let scalar = |n| -> Result<u32> {
57        match p::optional(&control, n)? {
58            None => Ok(0),
59            Some(p::Value::Varint(n)) => Ok(u32::try_from(*n)?),
60            _ => bail!("Invalid group control"),
61        }
62    };
63    let more = scalar(1)? != 0;
64    let wait_seconds = scalar(2)?;
65    ensure!(
66        !more || next_cursor.is_some(),
67        "Continuing group page has no cursor"
68    );
69    Ok(GroupMetadataPage {
70        contacts,
71        next_cursor,
72        more,
73        wait_seconds,
74        raw: raw.to_vec(),
75    })
76}
77impl NativeClient {
78    #[doc(hidden)]
79    pub(crate) fn group_inventory_snapshot(
80        &self,
81        state: &mut AccountState,
82        cursor: &[u8],
83    ) -> Result<GroupMetadataPage> {
84        let request = group_inventory_request(state, cursor)?;
85        let raw = self.authenticated_rpc(
86            state,
87            15595,
88            "/cgi-bin/micromsg-bin/syncsimplechatroomdata",
89            &request,
90        )?;
91        let page = decode_group_inventory(&raw)?;
92        ensure!(
93            !page.more || page.next_cursor.as_deref() != Some(cursor),
94            "Group metadata made no cursor progress"
95        );
96        Ok(page)
97    }
98    /// Verified native business payload, retained before strict contact decoding.
99    /// Callers must protect this account data at rest. The transport's global
100    /// message bound applies; no identities or opaque fields are exposed in logs.
101    #[doc(hidden)]
102    pub(crate) fn lookup_contacts_raw_snapshot(
103        &self,
104        state: &mut AccountState,
105        ids: &[String],
106    ) -> Result<Vec<u8>> {
107        let request = wire::contact_request(state, ids)?;
108        let raw =
109            self.authenticated_rpc(state, 182, "/cgi-bin/micromsg-bin/getcontact", &request)?;
110        ensure!(
111            raw.len() <= crate::MAX_MESSAGE_BYTES,
112            "Contact response exceeds bound"
113        );
114        Ok(raw)
115    }
116    #[doc(hidden)]
117    pub(crate) fn lookup_contacts_receipt_snapshot(
118        &self,
119        state: &mut AccountState,
120        ids: &[String],
121    ) -> Result<MetadataReply<ContactLookup>> {
122        let raw = self.lookup_contacts_raw_snapshot(state, ids)?;
123        Ok(MetadataReply {
124            value: wire::decode_contacts(&raw, ids)?,
125            raw,
126        })
127    }
128    #[doc(hidden)]
129    pub(crate) fn lookup_room_receipt_snapshot(
130        &self,
131        state: &mut AccountState,
132        id: &str,
133        version: u32,
134    ) -> Result<MetadataReply<RoomRoster>> {
135        let raw = self.lookup_room_raw_snapshot(state, id, version)?;
136        Ok(MetadataReply {
137            value: wire::decode_room(&raw, id)?,
138            raw,
139        })
140    }
141    #[doc(hidden)]
142    pub(crate) fn lookup_room_raw_snapshot(
143        &self,
144        state: &mut AccountState,
145        id: &str,
146        version: u32,
147    ) -> Result<Vec<u8>> {
148        let request = wire::room_request(state, id, version)?;
149        self.authenticated_rpc(
150            state,
151            551,
152            "/cgi-bin/micromsg-bin/getchatroommemberdetail",
153            &request,
154        )
155    }
156    #[doc(hidden)]
157    pub(crate) fn init_contacts_receipt_snapshot(
158        &self,
159        state: &mut AccountState,
160        a: u32,
161        b: u32,
162    ) -> Result<MetadataReply<InitContactPage>> {
163        let request = wire::init_contacts_request(&state.own_username, a, b)?;
164        let raw =
165            self.authenticated_rpc(state, 851, "/cgi-bin/micromsg-bin/initcontact", &request)?;
166        let value = wire::decode_init_contacts(&raw)?;
167        ensure!(
168            !value.more || value.contact_sequence != a || value.room_sequence != b,
169            "Contact bootstrap made no cursor progress"
170        );
171        Ok(MetadataReply { value, raw })
172    }
173}
174#[cfg(test)]
175mod tests {
176    use super::*;
177    #[test]
178    fn group_cursor_is_raw_and_control_presence_is_optional() {
179        let raw = p::message(&[p::bytes(1, &p::uint(1, 0)), p::bytes(3, &[0, 255, 1])]).unwrap();
180        let page = decode_group_inventory(&raw).unwrap();
181        assert_eq!(page.next_cursor, Some(vec![0, 255, 1]));
182        assert!(!page.more);
183        assert_eq!(page.wait_seconds, 0);
184        assert_eq!(page.raw, raw);
185        let bad = p::message(&[p::bytes(1, &p::uint(1, 0)), p::bytes(4, &p::uint(1, 1))]).unwrap();
186        assert!(decode_group_inventory(&bad).is_err());
187    }
188    #[test]
189    fn rejection_does_not_require_success_fields() {
190        assert!(decode_group_inventory(&p::bytes(1, &p::int32(1, -13)))
191            .err()
192            .unwrap()
193            .to_string()
194            .contains("-13"));
195    }
196}