1use 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
115pub 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 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}