1use super::*;
10use base64::Engine as _;
11use zeroize::Zeroizing;
12
13const H5_AUTH_CGI: u16 = 5805;
14const H5_AUTH_PATH: &str = "/cgi-bin/micromsg-bin/h5auth";
15const H5_AUTH_CONTEXT: u64 = 0xe100_1000;
17const PAGE_CGI: u16 = 233;
18const PAGE_PATH: &str = "/cgi-bin/micromsg-bin/geta8key";
19const TRANSFER_CGI: u16 = 6673;
20const TRANSFER_PATH: &str = "/cgi-bin/micromsg-bin/transfer/h5exttransfer";
21const TRANSFER_SCOPE: &str = "finderLive";
22const TRANSFER_CONTROL: u64 = 400;
24const DETAIL_ROUTE: &str = "/cgi-bin/micromsg-bin/pc_findergetcommentdetail";
25const DETAIL_COMMAND: u64 = 5259;
26const PAGE_BASE: &str = "https://channels.weixin.qq.com/web/pages/feed";
27const MAX_CREDENTIAL_TEXT: usize = 8192;
28const MAX_DETAIL_JSON: usize = 4 * 1024 * 1024;
29
30#[derive(Clone, PartialEq, Eq)]
32pub struct ChannelsPost {
33 pub object_id: u64,
35 pub nonce: String,
37}
38
39impl fmt::Debug for ChannelsPost {
40 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
41 f.write_str("ChannelsPost(<redacted>)")
42 }
43}
44
45impl ChannelsPost {
46 pub fn nonce_number(&self) -> Result<u64> {
48 let prefix = self.nonce.split('_').next().unwrap_or_default();
49 ensure!(
50 !prefix.is_empty() && prefix.len() <= 20 && prefix.bytes().all(|b| b.is_ascii_digit()),
51 "channels_unsupported_media"
52 );
53 prefix
54 .parse::<u64>()
55 .map_err(|_| anyhow::anyhow!("channels_unsupported_media"))
56 }
57
58 pub fn page_url(&self) -> Result<String> {
60 ensure!(self.object_id != 0, "channels_unsupported_media");
61 let encode = |value: u64| {
62 base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(value.to_be_bytes())
63 };
64 Ok(format!(
65 "{PAGE_BASE}?oid={}&nid={}&entrance_id=1002",
66 encode(self.object_id),
67 encode(self.nonce_number()?)
68 ))
69 }
70}
71
72pub struct ChannelsTicket {
74 ticket: Zeroizing<Vec<u8>>,
75 pub lifetime_seconds: Option<u64>,
77}
78
79impl fmt::Debug for ChannelsTicket {
80 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
81 f.debug_struct("ChannelsTicket")
82 .field("ticket", &"<redacted>")
83 .field("lifetime_seconds", &self.lifetime_seconds)
84 .finish()
85 }
86}
87
88impl Clone for ChannelsTicket {
89 fn clone(&self) -> Self {
90 Self {
91 ticket: Zeroizing::new(self.ticket.to_vec()),
92 lifetime_seconds: self.lifetime_seconds,
93 }
94 }
95}
96
97pub struct ChannelsPage(Zeroizing<Vec<u8>>);
99
100impl fmt::Debug for ChannelsPage {
101 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
102 f.write_str("ChannelsPage(<redacted>)")
103 }
104}
105
106pub struct ChannelsMedia {
108 url: Zeroizing<String>,
109 url_token: Zeroizing<String>,
110 decode_key: u64,
111 pub file_size: Option<u64>,
113 pub cdn_file_size: Option<u64>,
115 pub width: Option<u32>,
117 pub height: Option<u32>,
119 pub duration_seconds: Option<u32>,
121}
122
123impl fmt::Debug for ChannelsMedia {
124 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
125 f.debug_struct("ChannelsMedia")
126 .field("material", &"<redacted>")
127 .field("file_size", &self.file_size)
128 .field("cdn_file_size", &self.cdn_file_size)
129 .finish()
130 }
131}
132
133impl Drop for ChannelsMedia {
134 fn drop(&mut self) {
135 self.decode_key = 0;
136 }
137}
138
139impl ChannelsMedia {
140 #[doc(hidden)]
142 pub fn for_tests(url: &str, url_token: &str, decode_key: u64, file_size: Option<u64>) -> Self {
143 Self {
144 url: Zeroizing::new(url.into()),
145 url_token: Zeroizing::new(url_token.into()),
146 decode_key,
147 file_size,
148 cdn_file_size: None,
149 width: None,
150 height: None,
151 duration_seconds: None,
152 }
153 }
154 pub fn transport(&self) -> (&str, &str) {
156 (&self.url, &self.url_token)
157 }
158 pub fn decode_key(&self) -> u64 {
160 self.decode_key
161 }
162}
163
164fn opaque(
167 value: Option<&[u8]>,
168 max: usize,
169 unreadable: &'static str,
170) -> Result<Zeroizing<Vec<u8>>> {
171 let value = value.ok_or_else(|| anyhow::anyhow!(unreadable))?;
172 ensure!(!value.is_empty() && value.len() <= max, unreadable);
173 Ok(Zeroizing::new(value.to_vec()))
174}
175
176fn bytes_field(fields: &[p::Field], number: u32) -> Option<&[u8]> {
178 fields
179 .iter()
180 .find_map(|field| match (field.number == number, &field.value) {
181 (true, p::Value::Bytes(value)) => Some(value.as_slice()),
182 _ => None,
183 })
184}
185
186fn route_entries(fields: &[p::Field]) -> Vec<Vec<p::Field>> {
189 let mut entries = vec![];
190 for field in fields.iter().filter(|field| field.number == 5) {
191 let p::Value::Bytes(bytes) = &field.value else {
192 continue;
193 };
194 let Ok(container) = p::decode(bytes) else {
195 continue;
196 };
197 for child in &container {
198 if let p::Value::Bytes(nested) = &child.value {
199 if let Ok(entry) = p::decode(nested) {
200 entries.push(entry);
201 }
202 }
203 }
204 entries.push(container);
205 }
206 entries
207}
208
209fn h5_auth_request(state: &AccountState) -> Result<Vec<u8>> {
210 state.validate()?;
211 p::message(&[
212 p::bytes(1, &wire::base_request(&state.device, state.uin, 0)?),
213 p::uint(2, H5_AUTH_CONTEXT),
214 ])
215}
216
217fn h5_auth_response(bytes: &[u8]) -> Result<ChannelsTicket> {
218 let fields = p::decode(bytes)?;
219 ServiceRejected::check(Service::ChannelsAuthorization, p::base_code(&fields)?)?;
220 let ticket = opaque(
221 bytes_field(&fields, 2),
222 MAX_CREDENTIAL_TEXT,
223 "channels_ticket_unreadable",
224 )?;
225 let lifetime_seconds = fields
226 .iter()
227 .find_map(|field| match (field.number, &field.value) {
228 (3, p::Value::Varint(value)) => Some(*value),
229 _ => None,
230 });
231 let mut routed = false;
235 for entry in route_entries(&fields) {
236 if bytes_field(&entry, 1) != Some(TRANSFER_SCOPE.as_bytes()) {
237 continue;
238 }
239 let cgi = entry
240 .iter()
241 .find_map(|field| match (field.number, &field.value) {
242 (2, p::Value::Varint(value)) => Some(*value),
243 _ => None,
244 });
245 ensure!(
246 cgi == Some(u64::from(TRANSFER_CGI))
247 && bytes_field(&entry, 3) == Some(TRANSFER_PATH.as_bytes()),
248 "channels_route_unsupported"
249 );
250 routed = true;
251 }
252 ensure!(routed, "channels_route_unsupported");
253 Ok(ChannelsTicket {
254 ticket,
255 lifetime_seconds,
256 })
257}
258
259fn page_request(state: &AccountState, post: &ChannelsPost) -> Result<Vec<u8>> {
260 state.validate()?;
261 let url = post.page_url()?;
262 p::message(&[
263 p::bytes(1, &wire::base_request(&state.device, state.uin, 0)?),
264 p::uint(2, 2),
265 p::bytes(7, &p::message(&[p::bytes(1, url.as_bytes())])?),
267 p::uint(10, 7),
268 p::uint(14, 0),
269 p::uint(16, 0),
270 p::uint(18, 0),
271 p::uint(19, 0),
272 p::uint(20, u64::from(state.uin)),
273 p::uint(33, 0),
274 p::uint(34, 0),
275 p::bytes(39, b"en_US"),
276 ])
277}
278
279fn page_response(bytes: &[u8]) -> Result<ChannelsPage> {
280 let fields = p::decode(bytes)?;
281 ServiceRejected::check(Service::ChannelsPage, p::base_code(&fields)?)?;
282 Ok(ChannelsPage(opaque(
283 bytes_field(&fields, 2),
284 MAX_CREDENTIAL_TEXT,
285 "channels_page_unreadable",
286 )?))
287}
288
289fn detail_json(post: &ChannelsPost) -> Result<String> {
290 let millis = std::time::SystemTime::now()
292 .duration_since(std::time::UNIX_EPOCH)
293 .map_err(|_| anyhow::anyhow!("channels_unsupported_media"))?
294 .as_millis() as u64;
295 let suffix = u64::from(u32::from_be_bytes(crate::crypto::random::<4>()?)) % 1_000_000;
296 let request_id = millis * 1_000_000 + suffix;
297 Ok(serde_json::json!({
298 "direction": 2,
299 "finder_basereq": {
300 "ctx_info": {"client_report_buff": "{\"entranceId\":\"1002\"}"},
301 "expt_flag": 1,
302 "request_id": request_id.to_string(),
303 "scene": 140,
304 },
305 "identity_scene": 2,
306 "last_buffer": "",
307 "need_object": 1,
308 "object_nonce_id": post.nonce_number()?.to_string(),
309 "objectid": post.object_id.to_string(),
310 "platform_scene": 2,
311 "pull_scene": 6,
312 "scene": 146,
313 "tolang": "en",
314 })
315 .to_string())
316}
317
318fn transfer_request(
319 state: &AccountState,
320 ticket: &ChannelsTicket,
321 page: &ChannelsPage,
322 json: &str,
323) -> Result<Zeroizing<Vec<u8>>> {
324 state.validate()?;
325 let inner = p::message(&[
326 p::bytes(1, DETAIL_ROUTE.as_bytes()),
327 p::bytes(2, json.as_bytes()),
328 p::uint(3, DETAIL_COMMAND),
329 ])?;
330 Ok(Zeroizing::new(p::message(&[
331 p::bytes(1, &wire::base_request(&state.device, state.uin, 0)?),
332 p::bytes(2, &inner),
333 p::bytes(3, &ticket.ticket),
334 p::bytes(5, &page.0),
335 p::uint(6, TRANSFER_CONTROL),
336 p::bytes(7, TRANSFER_SCOPE.as_bytes()),
337 p::uint(10, 0),
338 ])?))
339}
340
341fn transfer_response(bytes: &[u8]) -> Result<Zeroizing<Vec<u8>>> {
342 let fields = p::decode(bytes)?;
343 ServiceRejected::check(Service::Channels, p::base_code(&fields)?)?;
344 let inner = bytes_field(&fields, 2)
345 .and_then(|inner| p::decode(inner).ok())
346 .ok_or_else(|| anyhow::anyhow!("channels_detail_unreadable"))?;
347 let status = inner
348 .iter()
349 .find_map(|field| match (field.number, &field.value) {
350 (1, p::Value::Varint(raw)) => Some(*raw as u32 as i32),
351 _ => None,
352 })
353 .unwrap_or(0);
354 ServiceRejected::check(Service::ChannelsDetail, status)?;
355 let json =
356 bytes_field(&inner, 3).ok_or_else(|| anyhow::anyhow!("channels_detail_unreadable"))?;
357 ensure!(json.len() <= MAX_DETAIL_JSON, "channels_detail_unreadable");
358 Ok(Zeroizing::new(json.to_vec()))
359}
360
361fn json_u64(value: &serde_json::Value) -> Option<u64> {
362 match value {
363 serde_json::Value::Number(n) => n.as_u64(),
364 serde_json::Value::String(s) => s.parse().ok(),
365 _ => None,
366 }
367}
368
369fn json_u32(value: Option<&serde_json::Value>) -> Option<u32> {
370 value
371 .and_then(json_u64)
372 .and_then(|n| u32::try_from(n).ok())
373 .filter(|n| *n > 0)
374}
375
376fn parse_detail(json: &[u8], post: &ChannelsPost) -> Result<ChannelsMedia> {
379 let reply: serde_json::Value =
380 serde_json::from_slice(json).map_err(|_| anyhow::anyhow!("channels_detail_unreadable"))?;
381 let ret = reply
382 .pointer("/BaseResponse/Ret")
383 .or_else(|| reply.pointer("/base_response/ret"))
384 .and_then(serde_json::Value::as_i64)
385 .unwrap_or(0);
386 ensure!(ret == 0, "channels_post_unavailable");
387 let object = reply
388 .get("object")
389 .filter(|object| object.is_object())
390 .ok_or_else(|| anyhow::anyhow!("channels_post_unavailable"))?;
391 ensure!(
392 object.get("id").and_then(json_u64) == Some(post.object_id),
393 "channels_unsupported_media"
394 );
395 let media = object
396 .pointer("/object_desc/media")
397 .and_then(serde_json::Value::as_array)
398 .ok_or_else(|| anyhow::anyhow!("channels_unsupported_media"))?;
399 let [entry] = media.as_slice() else {
400 bail!("channels_unsupported_media");
401 };
402 let string = |name: &str| {
403 entry
404 .get(name)
405 .and_then(serde_json::Value::as_str)
406 .filter(|s| !s.is_empty() && s.len() <= MAX_CREDENTIAL_TEXT)
407 .filter(|s| !s.chars().any(char::is_control))
408 .map(|s| Zeroizing::new(s.to_owned()))
409 };
410 let url = string("url").ok_or_else(|| anyhow::anyhow!("channels_unsupported_media"))?;
411 let url_token = string("url_token").unwrap_or_else(|| Zeroizing::new(String::new()));
412 let decode_key = entry
414 .get("decode_key")
415 .and_then(json_u64)
416 .ok_or_else(|| anyhow::anyhow!("channels_unsupported_media"))?;
417 let size = |name: &str| entry.get(name).and_then(json_u64).filter(|n| *n > 0);
418 Ok(ChannelsMedia {
419 url,
420 url_token,
421 decode_key,
422 file_size: size("file_size"),
423 cdn_file_size: size("cdn_file_size"),
424 width: json_u32(entry.get("width")),
425 height: json_u32(entry.get("height")),
426 duration_seconds: json_u32(entry.get("video_play_len")),
427 })
428}
429
430impl NativeClient {
431 #[doc(hidden)]
433 pub(crate) fn channels_ticket_snapshot(
434 &self,
435 state: &mut AccountState,
436 ) -> Result<ChannelsTicket> {
437 let body = h5_auth_request(state)?;
438 h5_auth_response(&self.authenticated_rpc(state, H5_AUTH_CGI, H5_AUTH_PATH, &body)?)
439 }
440
441 #[doc(hidden)]
443 pub(crate) fn channels_page_snapshot(
444 &self,
445 state: &mut AccountState,
446 post: &ChannelsPost,
447 ) -> Result<ChannelsPage> {
448 let body = page_request(state, post)?;
449 page_response(&self.authenticated_rpc(state, PAGE_CGI, PAGE_PATH, &body)?)
450 }
451
452 #[doc(hidden)]
454 pub(crate) fn channels_media_snapshot(
455 &self,
456 state: &mut AccountState,
457 post: &ChannelsPost,
458 ticket: &ChannelsTicket,
459 page: &ChannelsPage,
460 ) -> Result<ChannelsMedia> {
461 let json = Zeroizing::new(detail_json(post)?);
462 let body = transfer_request(state, ticket, page, &json)?;
463 let reply = transfer_response(&Zeroizing::new(self.authenticated_rpc(
464 state,
465 TRANSFER_CGI,
466 TRANSFER_PATH,
467 &body,
468 )?))?;
469 parse_detail(&reply, post)
470 }
471}
472
473#[cfg(test)]
474mod tests {
475 use super::*;
476
477 fn post() -> ChannelsPost {
478 ChannelsPost {
479 object_id: 18_446_744_073_709_551_000,
480 nonce: "12345678901234567890_0_38_12_4_context".into(),
481 }
482 }
483
484 fn state() -> AccountState {
485 AccountState {
486 schema: 1,
487 device: DeviceProfile {
488 device_id: b"0123456789abcdef".to_vec(),
489 device_type: "UnifiedPCLinux x86_64".into(),
490 client_version: -227271398,
491 },
492 uin: 123_456,
493 own_username: "synthetic_user".into(),
494 cookie: vec![],
495 session_key: vec![1; 16],
496 request_key: vec![2; 24],
497 response_key: vec![3; 24],
498 auto_auth_key: vec![4; 16],
499 key_info: vec![],
500 database_password: vec![],
501 auth_snapshot: Default::default(),
502 long_host: "long.weixin.qq.com".into(),
503 short_host: "short.weixin.qq.com".into(),
504 }
505 }
506
507 fn base_response(code: i64) -> Vec<u8> {
508 p::bytes(1, &p::uint(1, code as u64))
509 }
510
511 #[test]
512 fn page_url_encodes_big_endian_ids_and_the_numeric_nonce() {
513 let url = post().page_url().unwrap();
514 let expected = |value: u64| {
515 base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(value.to_be_bytes())
516 };
517 assert_eq!(
518 url,
519 format!(
520 "https://channels.weixin.qq.com/web/pages/feed?oid={}&nid={}&entrance_id=1002",
521 expected(18_446_744_073_709_551_000),
522 expected(12_345_678_901_234_567_890)
523 )
524 );
525 assert_eq!(expected(1), "AAAAAAAAAAE");
526 for nonce in ["", "_1", "abc_1", "184467440737095516160_1"] {
527 let bad = ChannelsPost {
528 object_id: 1,
529 nonce: nonce.into(),
530 };
531 assert!(bad.page_url().is_err(), "{nonce}");
532 }
533 assert_eq!(format!("{:?}", post()), "ChannelsPost(<redacted>)");
534 }
535
536 #[test]
537 fn ticket_request_sends_the_h5_context_as_an_unsigned_varint() {
538 let state = state();
539 let fields = p::decode(&h5_auth_request(&state).unwrap()).unwrap();
540 assert_eq!(fields.len(), 2);
541 assert_eq!(p::scalar(&fields, 2).unwrap(), 3_774_877_696);
542 assert!(h5_auth_request(&state)
544 .unwrap()
545 .ends_with(&[0x10, 0x80, 0xa0, 0x80, 0x88, 0x0e]));
546 }
547
548 fn route(scope: &str, cgi: u64, path: &str) -> Vec<u8> {
549 p::bytes(
550 5,
551 &p::message(&[
552 p::bytes(1, scope.as_bytes()),
553 p::uint(2, cgi),
554 p::bytes(3, path.as_bytes()),
555 ])
556 .unwrap(),
557 )
558 }
559
560 #[test]
561 fn ticket_reply_requires_the_known_route_and_keeps_the_ticket_private() {
562 let good = p::message(&[
563 base_response(0),
564 p::bytes(2, b"dGlja2V0"),
565 p::uint(3, 7200),
566 route("finderInteraction", 6673, TRANSFER_PATH),
567 route("finderLive", 6673, TRANSFER_PATH),
568 p::uint(6, 1),
569 ])
570 .unwrap();
571 let ticket = h5_auth_response(&good).unwrap();
572 assert_eq!(ticket.ticket.as_slice(), b"dGlja2V0");
573 let entry = |scope: &str, path: &str| {
575 p::bytes(
576 2,
577 &p::message(&[
578 p::bytes(1, scope.as_bytes()),
579 p::uint(2, 6673),
580 p::bytes(3, path.as_bytes()),
581 p::bytes(4, b"/cgi-bin/micromsg-bin/transfer/"),
582 p::bytes(5, b"h5exttransfer"),
583 ])
584 .unwrap(),
585 )
586 };
587 let nested = p::message(&[
588 base_response(0),
589 p::bytes(2, b"dGlja2V0"),
590 p::bytes(
591 5,
592 &p::message(&[
593 p::uint(1, 2),
594 entry("finderInteraction", TRANSFER_PATH),
595 entry("finderLive", TRANSFER_PATH),
596 ])
597 .unwrap(),
598 ),
599 ])
600 .unwrap();
601 assert!(h5_auth_response(&nested).is_ok());
602 let elsewhere = p::message(&[
603 base_response(0),
604 p::bytes(2, b"dGlja2V0"),
605 p::bytes(
606 5,
607 &p::message(&[p::uint(1, 1), entry("finderLive", "/cgi-bin/elsewhere")]).unwrap(),
608 ),
609 ])
610 .unwrap();
611 assert_eq!(
612 h5_auth_response(&elsewhere).unwrap_err().to_string(),
613 "channels_route_unsupported"
614 );
615 assert_eq!(ticket.lifetime_seconds, Some(7200));
616 let wrapped = p::message(&[
618 base_response(0),
619 p::bytes(2, b"dGlj\na2V0\n"),
620 route("finderLive", 6673, TRANSFER_PATH),
621 ])
622 .unwrap();
623 assert_eq!(
624 h5_auth_response(&wrapped).unwrap().ticket.as_slice(),
625 b"dGlj\na2V0\n"
626 );
627 assert!(!format!("{ticket:?}").contains("dGlja2V0"));
628
629 for routes in [
630 vec![],
631 vec![route("finderLive", 6674, TRANSFER_PATH)],
632 vec![route("finderLive", 6673, "/cgi-bin/elsewhere")],
633 ] {
634 let mut parts = vec![base_response(0), p::bytes(2, b"dGlja2V0")];
635 parts.extend(routes);
636 let error = h5_auth_response(&p::message(&parts).unwrap()).unwrap_err();
637 assert_eq!(error.to_string(), "channels_route_unsupported");
638 }
639
640 let rejected = p::message(&[base_response(-13)]).unwrap();
641 let error = h5_auth_response(&rejected).unwrap_err();
642 let failure = ServiceRejected::find(&error).unwrap();
643 assert_eq!(
644 (failure.service, failure.code),
645 (Service::ChannelsAuthorization, -13)
646 );
647 }
648
649 #[test]
650 fn page_request_carries_the_unsigned_page_and_account() {
651 let state = state();
652 let fields = p::decode(&page_request(&state, &post()).unwrap()).unwrap();
653 let numbers: Vec<u32> = fields.iter().map(|f| f.number).collect();
654 assert_eq!(
655 numbers,
656 [1, 2, 7, 10, 14, 16, 18, 19, 20, 33, 34, 39],
657 "field order"
658 );
659 assert_eq!(p::scalar(&fields, 2).unwrap(), 2);
660 assert_eq!(p::scalar(&fields, 10).unwrap(), 7);
661 assert_eq!(p::scalar(&fields, 20).unwrap(), 123_456);
662 let wrapped = p::data(&fields, 7).unwrap();
664 assert_ne!(wrapped, post().page_url().unwrap().as_bytes());
665 let inner = p::decode(wrapped).unwrap();
666 assert_eq!(inner.len(), 1);
667 assert_eq!(
668 p::data(&inner, 1).unwrap(),
669 post().page_url().unwrap().as_bytes()
670 );
671 assert_eq!(p::data(&fields, 39).unwrap(), b"en_US");
672
673 let reply = p::message(&[
674 base_response(0),
675 p::bytes(
676 2,
677 b"https://channels.weixin.qq.com/web/pages/feed?oid=a&exportkey=secret",
678 ),
679 ])
680 .unwrap();
681 let page = page_response(&reply).unwrap();
682 assert!(!format!("{page:?}").contains("secret"));
683 let missing = p::message(&[base_response(0)]).unwrap();
684 assert_eq!(
685 page_response(&missing).unwrap_err().to_string(),
686 "channels_page_unreadable"
687 );
688 }
689
690 #[test]
691 fn detail_request_rides_the_transfer_proxy_with_the_ticket_and_page() {
692 let state = state();
693 let ticket = ChannelsTicket {
694 ticket: Zeroizing::new(b"ticket".to_vec()),
695 lifetime_seconds: None,
696 };
697 let page = ChannelsPage(Zeroizing::new(
698 b"https://channels.weixin.qq.com/web/pages/feed?x".to_vec(),
699 ));
700 let json = detail_json(&post()).unwrap();
701 let fields = p::decode(&transfer_request(&state, &ticket, &page, &json).unwrap()).unwrap();
702 let numbers: Vec<u32> = fields.iter().map(|f| f.number).collect();
703 assert_eq!(numbers, [1, 2, 3, 5, 6, 7, 10]);
704 assert_eq!(p::data(&fields, 3).unwrap(), b"ticket");
705 assert_eq!(p::data(&fields, 5).unwrap(), page.0.as_slice());
706 assert_eq!(p::scalar(&fields, 6).unwrap(), 400);
707 assert_eq!(p::data(&fields, 7).unwrap(), b"finderLive");
708 assert_eq!(p::scalar(&fields, 10).unwrap(), 0);
709 let inner = p::decode(p::data(&fields, 2).unwrap()).unwrap();
710 assert_eq!(p::data(&inner, 1).unwrap(), DETAIL_ROUTE.as_bytes());
711 assert_eq!(p::scalar(&inner, 3).unwrap(), 5259);
712 let body: serde_json::Value = serde_json::from_slice(p::data(&inner, 2).unwrap()).unwrap();
713 assert_eq!(body["objectid"], "18446744073709551000");
714 assert_eq!(body["object_nonce_id"], "12345678901234567890");
715 assert_eq!(body["scene"], 146);
716 assert_eq!(body["pull_scene"], 6);
717 assert_eq!(body["finder_basereq"]["scene"], 140);
718 assert_eq!(
719 body["finder_basereq"]["ctx_info"]["client_report_buff"],
720 "{\"entranceId\":\"1002\"}"
721 );
722 let request_id: u64 = body["finder_basereq"]["request_id"]
723 .as_str()
724 .unwrap()
725 .parse()
726 .unwrap();
727 assert!(
728 request_id > 1_700_000_000_000 * 1_000_000,
729 "time-based request ID"
730 );
731 }
732
733 fn transfer_reply(status: i64, json: &serde_json::Value) -> Vec<u8> {
734 p::message(&[
735 base_response(0),
736 p::bytes(
737 2,
738 &p::message(&[
739 p::uint(1, status as u64),
740 p::bytes(3, json.to_string().as_bytes()),
741 ])
742 .unwrap(),
743 ),
744 ])
745 .unwrap()
746 }
747
748 fn detail(media: serde_json::Value) -> serde_json::Value {
749 serde_json::json!({
750 "BaseResponse": {"Ret": 0},
751 "object": {"id": "18446744073709551000", "object_desc": {"media": media}},
752 })
753 }
754
755 #[test]
756 fn detail_reply_must_match_the_post_and_carry_one_video() {
757 let entry = serde_json::json!({
758 "url": "http://wxapp.tc.qq.com/251/20302/stodownload?encfilekey=secret-file",
759 "url_token": "&token=secret-token",
760 "decode_key": "0",
761 "file_size": 4796270,
762 "cdn_file_size": "4796270",
763 "md5sum": "not-used",
764 "width": 888,
765 "height": 576,
766 "video_play_len": 59,
767 });
768 let reply =
769 transfer_response(&transfer_reply(0, &detail(serde_json::json!([entry])))).unwrap();
770 let media = parse_detail(&reply, &post()).unwrap();
771 assert_eq!(media.decode_key(), 0);
772 assert_eq!(media.file_size, Some(4_796_270));
773 assert_eq!(media.cdn_file_size, Some(4_796_270));
774 assert_eq!((media.width, media.height), (Some(888), Some(576)));
775 assert_eq!(media.duration_seconds, Some(59));
776 let debug = format!("{media:?}");
777 for secret in ["secret-file", "secret-token"] {
778 assert!(!debug.contains(secret));
779 }
780
781 let cases = [
782 (
783 detail(serde_json::json!([entry.clone(), entry.clone()])),
784 "channels_unsupported_media",
785 ),
786 (detail(serde_json::json!([])), "channels_unsupported_media"),
787 (
788 detail(serde_json::json!([{"url": "x", "url_token": "y"}])),
789 "channels_unsupported_media",
790 ),
791 (
792 serde_json::json!({"BaseResponse": {"Ret": 0},
793 "object": {"id": "1", "object_desc": {"media": [entry.clone()]}}}),
794 "channels_unsupported_media",
795 ),
796 (
797 serde_json::json!({"BaseResponse": {"Ret": -4011}}),
798 "channels_post_unavailable",
799 ),
800 (serde_json::json!({}), "channels_post_unavailable"),
801 ];
802 for (json, code) in cases {
803 let reply = transfer_response(&transfer_reply(0, &json)).unwrap();
804 assert_eq!(parse_detail(&reply, &post()).unwrap_err().to_string(), code);
805 }
806
807 let error = transfer_response(&transfer_reply(-2, &serde_json::json!({}))).unwrap_err();
808 let failure = ServiceRejected::find(&error).unwrap();
809 assert_eq!(
810 (failure.service, failure.code),
811 (Service::ChannelsDetail, -2)
812 );
813 assert_eq!(
814 parse_detail(b"not json", &post()).unwrap_err().to_string(),
815 "channels_detail_unreadable"
816 );
817 }
818}