Skip to main content

wechat_protocol/
channels.rs

1//! Authenticated lookup of a WeChat Channels post's playable video.
2//!
3//! A received Channels card names its post by object ID and nonce. Fresh playback material (a
4//! signed address, its token and the prefix decode key) comes from three authenticated requests:
5//! an H5 ticket, an authenticated page address for the post, and the post detail carried through
6//! the H5 transfer proxy. Each request is submitted once; callers decide whether to renew and
7//! retry. Tickets, page addresses, tokens and keys are credential material: they never appear in
8//! `Debug` output or error text.
9use 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";
15/// Unsigned H5 context the client sends with its H5 ticket request.
16const 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";
22/// Proxy control value; unrelated to the H5 context above.
23const 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/// A post this client may resolve: its object ID and the card's full nonce.
31#[derive(Clone, PartialEq, Eq)]
32pub struct ChannelsPost {
33    /// Post object ID from the card.
34    pub object_id: u64,
35    /// The card's full `objectNonceId`; requests use its numeric prefix.
36    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    /// Numeric prefix of the nonce, before the first `_`.
47    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    /// The unsigned page address for the post, as the client builds it locally.
59    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
72/// A current H5 ticket for the transfer proxy.
73pub struct ChannelsTicket {
74    ticket: Zeroizing<Vec<u8>>,
75    /// Seconds the ticket stays valid, when the reply says.
76    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
97/// The authenticated page address for one post. Credential material, not a share link.
98pub 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
106/// Fresh playback material for a post's single video, kept together as returned.
107pub struct ChannelsMedia {
108    url: Zeroizing<String>,
109    url_token: Zeroizing<String>,
110    decode_key: u64,
111    /// Byte length the reply advertises for the video, when present.
112    pub file_size: Option<u64>,
113    /// Byte length the reply advertises for the CDN copy, when present.
114    pub cdn_file_size: Option<u64>,
115    /// Video width in pixels, when present.
116    pub width: Option<u32>,
117    /// Video height in pixels, when present.
118    pub height: Option<u32>,
119    /// Play length in seconds, when present.
120    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    /// Synthetic material for tests of code that downloads or decodes a video.
141    #[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    /// Address and token as returned, for building the download request.
155    pub fn transport(&self) -> (&str, &str) {
156        (&self.url, &self.url_token)
157    }
158    /// Seed of the prefix keystream.
159    pub fn decode_key(&self) -> u64 {
160        self.decode_key
161    }
162}
163
164/// An opaque credential value echoed back to WeChat unchanged. It is bounded but not parsed:
165/// a ticket can contain line breaks, and neither value is ever opened as an address here.
166fn 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
176/// The first bytes value of a field number, ignoring values of other wire types.
177fn 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
186/// Candidate route entries in the H5 ticket reply's field 5: the field itself and each embedded
187/// message inside it. Values that do not decode as messages are skipped.
188fn 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    // Field 5 is the transfer-route configuration: a count and repeated per-scope entries. Only
232    // the fixed route this client uses is accepted; a server-supplied path is never used as a
233    // destination. Entries are found directly in field 5 or one level inside it.
234    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        // The initial address is a nested string message, not raw bytes.
266        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    // Milliseconds since the epoch followed by six random digits, as the web client forms it.
291    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
376/// Read the detail reply. It must name the requested post and carry exactly one video entry with
377/// usable playback material.
378fn 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    // A seed of "0" is valid; only an absent or malformed key is rejected.
413    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    /// Request a new H5 ticket. Submitted once, without renewal or retry.
432    #[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    /// Request the authenticated page address for a post. Submitted once.
442    #[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    /// Request the post detail and return its single video's playback material. Submitted once.
453    #[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        // An unsigned uint32 varint takes five bytes; a sign-extended int32 would take ten.
543        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        // The route configuration may also be one container with a count and nested entries.
574        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        // A wrapped Base64 ticket keeps its line breaks and is echoed back unchanged.
617        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        // Field 7 wraps the initial address as {1: URL}; it is not the URL bytes themselves.
663        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}