Skip to main content

wechat_protocol/
file_upload.rs

1//! File-upload message reservation. This authenticated request can affect the
2//! account's message state; callers must persist its receipt and never retry an
3//! uncertain response automatically.
4use crate::errors::{Service, ServiceRejected};
5use crate::{protobuf as p, wire::base_request, AccountState};
6use anyhow::{ensure, Result};
7use base64::{engine::general_purpose::STANDARD, Engine};
8use serde::{Deserialize, Serialize};
9use std::fmt;
10use zeroize::Zeroize;
11
12pub const MAX_RESERVED_FILE_BYTES: usize = crate::media::MAX_LARGE_FILE_BYTES;
13const MAX_FILE_UPLOAD_TOKEN_BYTES: usize = 16 * 1024;
14
15#[derive(Clone, Serialize, Deserialize)]
16#[serde(rename_all = "camelCase")]
17pub struct FileUploadReservation {
18    pub file_upload_token: String,
19    pub overwrite_newmsgid: u64,
20}
21impl Drop for FileUploadReservation {
22    fn drop(&mut self) {
23        self.file_upload_token.zeroize();
24        self.overwrite_newmsgid.zeroize();
25    }
26}
27impl fmt::Debug for FileUploadReservation {
28    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
29        f.debug_struct("FileUploadReservation")
30            .field("receipt", &"[redacted]")
31            .finish()
32    }
33}
34impl FileUploadReservation {
35    pub fn validate(&self) -> Result<()> {
36        ensure!(
37            self.overwrite_newmsgid != 0
38                && self.file_upload_token.len() <= MAX_FILE_UPLOAD_TOKEN_BYTES,
39            "Invalid file upload reservation"
40        );
41        let encoded = self
42            .file_upload_token
43            .strip_prefix("v1_")
44            .ok_or_else(|| anyhow::anyhow!("Unsupported file upload token"))?;
45        ensure!(!encoded.is_empty(), "Empty file upload token");
46        let mut decoded = STANDARD.decode(encoded)?;
47        let nonempty = !decoded.is_empty();
48        decoded.zeroize();
49        ensure!(nonempty, "Empty file upload token");
50        Ok(())
51    }
52}
53
54pub(crate) fn file_metadata<'a>(
55    file_name: &'a str,
56    plaintext_bytes: usize,
57    md5: &str,
58) -> Result<(&'a str, String)> {
59    ensure!(
60        !file_name.is_empty()
61            && file_name.len() <= 255
62            && !file_name.chars().any(char::is_control)
63            && !matches!(file_name, "." | "..")
64            && !file_name.contains(['/', '\\']),
65        "Expected a single filename component"
66    );
67    ensure!(
68        plaintext_bytes > 0 && plaintext_bytes <= MAX_RESERVED_FILE_BYTES,
69        "Invalid reserved file size"
70    );
71    ensure!(
72        md5.len() == 32 && md5.bytes().all(|b| b.is_ascii_hexdigit()),
73        "Invalid file MD5"
74    );
75    let extension = file_name
76        .rsplit_once('.')
77        .filter(|(base, _)| !base.is_empty())
78        .map(|(_, extension)| extension)
79        .unwrap_or("");
80    Ok((extension, md5.to_ascii_lowercase()))
81}
82
83pub fn file_upload_request(
84    state: &AccountState,
85    destination: &str,
86    progress_client_id: &str,
87    file_name: &str,
88    plaintext_bytes: usize,
89    md5: &str,
90) -> Result<Vec<u8>> {
91    for (value, max) in [(destination, 256), (progress_client_id, 1024)] {
92        ensure!(
93            !value.is_empty() && value.len() <= max && !value.chars().any(char::is_control),
94            "Invalid file upload destination or progress identity"
95        );
96    }
97    let (extension, md5) = file_metadata(file_name, plaintext_bytes, md5)?;
98    let info = p::message(&[
99        p::bytes(1, file_name.as_bytes()),
100        p::bytes(2, extension.as_bytes()),
101        p::bytes(3, md5.as_bytes()),
102        p::uint(4, plaintext_bytes as u64),
103    ])?;
104    p::message(&[
105        p::bytes(1, &base_request(&state.device, state.uin, 0)?),
106        p::bytes(2, destination.as_bytes()),
107        p::bytes(3, progress_client_id.as_bytes()),
108        p::uint(4, 1),
109        p::bytes(5, &info),
110        p::uint(7, 0),
111        p::uint(12, 0),
112    ])
113}
114
115/// Decode the receipt from one authenticated CGI6691 response. This response
116/// has no client-ID echo; the caller must retain its association with the intent.
117pub fn decode_file_upload_reservation(input: &[u8]) -> Result<FileUploadReservation> {
118    ensure!(
119        input.len() <= 64 * 1024,
120        "File upload reservation response too large"
121    );
122    let fields = p::decode(input)?;
123    let base = p::decode(p::data(&fields, 1)?)?;
124    let code = p::scalar(&base, 1)?;
125    if code != 0 {
126        // The untruncated value decides; the signed 32-bit form is reported.
127        return Err(
128            ServiceRejected::new(Service::FileUploadReservation, code as u32 as i32).into(),
129        );
130    }
131    let receipt = FileUploadReservation {
132        file_upload_token: std::str::from_utf8(p::data(&fields, 2)?)?.to_owned(),
133        overwrite_newmsgid: p::scalar(&fields, 3)?,
134    };
135    receipt.validate()?;
136    Ok(receipt)
137}
138
139#[cfg(test)]
140mod tests {
141    use super::*;
142
143    fn reply(token: &[u8], id: u64) -> Vec<u8> {
144        p::message(&[
145            p::bytes(1, &p::int32(1, 0)),
146            p::bytes(2, token),
147            p::uint(3, id),
148        ])
149        .unwrap()
150    }
151
152    #[test]
153    fn receipt_roundtrip_redacts_and_retains_full_id() {
154        let reservation =
155            decode_file_upload_reservation(&reply(b"v1_c3ludGhldGlj", u64::MAX)).unwrap();
156        assert_eq!(reservation.overwrite_newmsgid, u64::MAX);
157        let stored = serde_json::to_vec(&reservation).unwrap();
158        let restored: FileUploadReservation = serde_json::from_slice(&stored).unwrap();
159        restored.validate().unwrap();
160        assert_eq!(restored.file_upload_token, reservation.file_upload_token);
161        assert!(!format!("{restored:?}").contains("c3ludGhldGlj"));
162        assert!(!format!("{restored:?}").contains(&u64::MAX.to_string()));
163    }
164
165    #[test]
166    fn receipt_rejects_ambiguous_missing_invalid_and_rejected_fields() {
167        for input in [
168            reply(b"v1_c3ludGhldGlj", 0),
169            reply(b"v2_c3ludGhldGlj", 1),
170            reply(b"v1_", 1),
171            reply(b"v1_!!!", 1),
172            reply(&vec![b'a'; MAX_FILE_UPLOAD_TOKEN_BYTES + 1], 1),
173            p::message(&[p::bytes(1, &p::int32(1, -13))]).unwrap(),
174            p::message(&[
175                p::bytes(1, &p::uint(1, 1 << 32)),
176                p::bytes(2, b"v1_c3ludGhldGlj"),
177                p::uint(3, 1),
178            ])
179            .unwrap(),
180            p::message(&[p::bytes(1, &p::int32(1, 0)), p::uint(3, 1)]).unwrap(),
181            [reply(b"v1_c3ludGhldGlj", 1), p::uint(3, 2)].concat(),
182            [reply(b"v1_c3ludGhldGlj", 1), p::bytes(2, b"v1_YQ==")].concat(),
183        ] {
184            assert!(decode_file_upload_reservation(&input).is_err());
185        }
186    }
187
188    #[test]
189    fn metadata_bounds_and_extension() {
190        assert_eq!(
191            file_metadata("sample.TXT", MAX_RESERVED_FILE_BYTES, &"A".repeat(32)).unwrap(),
192            ("TXT", "a".repeat(32))
193        );
194        for name in ["", ".", "..", "a/b", "a\\b", "a\n.txt"] {
195            assert!(file_metadata(name, 1, &"0".repeat(32)).is_err());
196        }
197        for size in [0, MAX_RESERVED_FILE_BYTES + 1] {
198            assert!(file_metadata("sample.txt", size, &"0".repeat(32)).is_err());
199        }
200        assert!(file_metadata("sample.txt", 1, &"z".repeat(32)).is_err());
201        assert!(file_metadata(&"a".repeat(256), 1, &"0".repeat(32)).is_err());
202    }
203}