Skip to main content

wechat_protocol/
sticker_upload.rs

1//! Direct custom-sticker upload chunks. This operation does not send a chat message.
2use crate::{protobuf as p, NativeClient};
3use anyhow::{ensure, Result};
4
5/// Maximum plaintext bytes carried by one direct sticker upload request.
6pub const STICKER_UPLOAD_CHUNK_BYTES: usize = 98_304;
7/// A validated acknowledgement for one direct upload chunk.
8#[derive(Clone, Debug)]
9pub struct StickerUploadAcknowledgement {
10    /// First byte not yet acknowledged by the service.
11    pub next_offset: u32,
12    /// Source size echoed by the service.
13    pub total_bytes: u32,
14    /// Original response, including unassigned optional fields. Protect at rest.
15    pub raw: Vec<u8>,
16}
17/// Encode one direct upload chunk from an owned source. Unlike chat sticker
18/// sends this request carries raw bytes immediately, without a BaseRequest or
19/// a nested builtin buffer. Offsets are bounded signed-32-bit wire scalars.
20pub fn sticker_upload_request(source: &[u8], offset: u32) -> Result<Vec<u8>> {
21    ensure!(
22        !source.is_empty() && source.len() <= wechat_media::MAX_IMAGE_BYTES,
23        "sticker_source_size_limit"
24    );
25    let offset = usize::try_from(offset)?;
26    ensure!(offset < source.len(), "sticker_upload_offset_invalid");
27    let end = source.len().min(offset + STICKER_UPLOAD_CHUNK_BYTES);
28    let identity = hex::encode(crate::crypto::md5(source));
29    let item = p::message(&[
30        p::bytes(1, identity.as_bytes()),
31        p::uint(2, offset as u64),
32        p::uint(3, source.len() as u64),
33        p::bytes(4, &source[offset..end]),
34    ])?;
35    p::message(&[p::bytes(1, &item), p::uint(3, 1)])
36}
37/// Validate progress against the exact chunk submitted. Rejected, stale,
38/// nonadvancing and mismatched replies must not trigger an automatic resend.
39pub fn decode_sticker_upload(
40    raw: &[u8],
41    offset: u32,
42    total: u32,
43    expected_md5: &str,
44) -> Result<StickerUploadAcknowledgement> {
45    let fields = p::decode(raw)?;
46    ensure!(p::base_code(&fields)? == 0, "sticker_upload_rejected");
47    let items = fields
48        .iter()
49        .filter(|field| field.number == 2)
50        .collect::<Vec<_>>();
51    ensure!(items.len() == 1, "sticker_upload_reply_invalid");
52    let item = p::decode(p::data(&fields, 2)?)?;
53    ensure!(p::scalar(&item, 1)? == 0, "sticker_upload_item_rejected");
54    if let Some(identity) = p::optional_data(&item, 4)? {
55        ensure!(
56            std::str::from_utf8(identity)?.eq_ignore_ascii_case(expected_md5),
57            "sticker_upload_identity_mismatch"
58        );
59    }
60    let next_offset = u32::try_from(p::scalar(&item, 2)?)?;
61    let returned_total = u32::try_from(p::scalar(&item, 3)?)?;
62    ensure!(
63        returned_total == total
64            && next_offset > offset
65            && next_offset <= total
66            && next_offset - offset <= STICKER_UPLOAD_CHUNK_BYTES as u32,
67        "sticker_upload_progress_invalid"
68    );
69    Ok(StickerUploadAcknowledgement {
70        next_offset,
71        total_bytes: total,
72        raw: raw.into(),
73    })
74}
75impl NativeClient {
76    pub(crate) fn upload_sticker_chunk_snapshot(
77        &self,
78        state: &mut crate::AccountState,
79        source: &[u8],
80        offset: u32,
81    ) -> Result<StickerUploadAcknowledgement> {
82        let request = sticker_upload_request(source, offset)?;
83        let reply =
84            self.authenticated_rpc(state, 703, "/cgi-bin/micromsg-bin/mmemojiupload", &request)?;
85        decode_sticker_upload(
86            &reply,
87            offset,
88            u32::try_from(source.len())?,
89            &hex::encode(crate::crypto::md5(source)),
90        )
91    }
92}
93
94#[cfg(test)]
95mod tests {
96    use super::*;
97    #[test]
98    fn initial_continuation_and_final_shapes_keep_raw_chunk_boundaries() {
99        assert_eq!(hex::encode(sticker_upload_request(b"abc", 0).unwrap()), "0a2b0a2039303031353039383363643234666230643639363366376432386531376637321000180322036162631801");
100        assert_eq!(hex::encode(sticker_upload_request(b"abc", 1).unwrap()), "0a2a0a20393030313530393833636432346662306436393633663764323865313766373210011803220262631801");
101        let raw = hex::decode("0a0208001206080010031803").unwrap();
102        let reply = decode_sticker_upload(&raw, 0, 3, "900150983cd24fb0d6963f7d28e17f72").unwrap();
103        assert_eq!(reply.next_offset, 3);
104        assert_eq!(reply.raw, raw);
105        assert!(decode_sticker_upload(&raw, 3, 3, "900150983cd24fb0d6963f7d28e17f72").is_err());
106        assert!(decode_sticker_upload(&raw, 0, 4, "900150983cd24fb0d6963f7d28e17f72").is_err());
107        assert!(sticker_upload_request(b"abc", 3).is_err());
108    }
109    #[test]
110    fn oversized_advances_duplicate_results_and_rejections_are_not_success() {
111        for raw in [
112            "0a0208001206080010041803",
113            "0a0208001206080010001803",
114            "0a0208001206080110031803",
115            "0a0208011206080010031803",
116            "0a02080012060800100318031206080010031803",
117        ] {
118            assert!(decode_sticker_upload(
119                &hex::decode(raw).unwrap(),
120                0,
121                3,
122                "900150983cd24fb0d6963f7d28e17f72"
123            )
124            .is_err());
125        }
126        let bytes = vec![0x42; STICKER_UPLOAD_CHUNK_BYTES + 1];
127        let request = p::decode(&sticker_upload_request(&bytes, 0).unwrap()).unwrap();
128        let item = p::decode(p::data(&request, 1).unwrap()).unwrap();
129        assert_eq!(p::data(&item, 4).unwrap().len(), STICKER_UPLOAD_CHUNK_BYTES);
130        let request =
131            p::decode(&sticker_upload_request(&bytes, STICKER_UPLOAD_CHUNK_BYTES as u32).unwrap())
132                .unwrap();
133        let item = p::decode(p::data(&request, 1).unwrap()).unwrap();
134        assert_eq!(p::data(&item, 4).unwrap(), &[0x42]);
135    }
136}