Skip to main content

wechat_protocol/
logout.rs

1//! Authenticated logout for the supported native profile.
2//!
3//! The current typed wrapper uses CGI282; the historical embedded CGI133 table
4//! does not describe this request. Optional request field2 has no assigned
5//! semantics and is deliberately absent. Acceptance does not establish saved
6//! device revocation or deletion from the phone's device inventory.
7use super::*;
8
9const CGI: u16 = 282;
10const PATH: &str = "/cgi-bin/micromsg-bin/logout";
11
12#[derive(Debug, Clone, PartialEq, Eq)]
13pub struct LogoutReply {
14    pub service_code: i32,
15    pub accepted: bool,
16}
17
18fn request(state: &AccountState) -> Result<Vec<u8>> {
19    state.validate()?;
20    Ok(p::bytes(
21        1,
22        &wire::base_request(&state.device, state.uin, 0)?,
23    ))
24}
25
26fn response(bytes: &[u8]) -> Result<LogoutReply> {
27    let fields = p::decode(bytes)?;
28    let base = p::decode(p::data(&fields, 1)?)?;
29    let raw = p::scalar(&base, 1)?;
30    let code = raw as u32 as i32;
31    ensure!(
32        raw <= u32::MAX as u64 || raw == code as i64 as u64,
33        "Invalid logout response status"
34    );
35    Ok(LogoutReply {
36        service_code: code,
37        accepted: code == 0,
38    })
39}
40
41impl NativeClient {
42    /// Submit one authenticated logout without renewal, retry or login fallback.
43    /// An error can follow submission and must be treated as an unknown outcome.
44    #[doc(hidden)]
45    pub(crate) fn logout_snapshot(&self, state: &mut AccountState) -> Result<LogoutReply> {
46        let body = request(state)?;
47        response(&self.authenticated_rpc(state, CGI, PATH, &body)?)
48    }
49}
50
51#[cfg(test)]
52mod tests {
53    use super::*;
54    fn state() -> AccountState {
55        AccountState {
56            schema: 1,
57            device: DeviceProfile {
58                device_id: b"0123456789abcdef".to_vec(),
59                device_type: "UnifiedPCLinux x86_64".into(),
60                client_version: -227271398,
61            },
62            uin: 42,
63            own_username: "synthetic_user".into(),
64            cookie: vec![],
65            session_key: vec![1; 16],
66            request_key: vec![2; 24],
67            response_key: vec![3; 24],
68            auto_auth_key: vec![4; 16],
69            key_info: vec![],
70            database_password: vec![],
71            auth_snapshot: Default::default(),
72            long_host: "long.weixin.qq.com".into(),
73            short_host: "short.weixin.qq.com".into(),
74        }
75    }
76    #[test]
77    fn current_cgi_and_base_only_presence_match_the_typed_wrapper() {
78        assert_eq!(CGI, 282);
79        assert_eq!(PATH, "/cgi-bin/micromsg-bin/logout");
80        let encoded = request(&state()).unwrap();
81        let outer = p::decode(&encoded).unwrap();
82        assert_eq!(outer.len(), 1);
83        assert!(p::optional(&outer, 2).unwrap().is_none());
84        let base = p::decode(p::data(&outer, 1).unwrap()).unwrap();
85        assert_eq!(p::data(&base, 1).unwrap(), &[0]);
86        assert_eq!(p::scalar(&base, 2).unwrap(), 42);
87        assert_eq!(p::data(&base, 3).unwrap(), b"0123456789abcdef");
88        assert_eq!(p::scalar(&base, 4).unwrap() as u32 as i32, -227271398);
89        assert_eq!(p::data(&base, 5).unwrap(), b"UnifiedPCLinux x86_64");
90        assert_eq!(p::scalar(&base, 6).unwrap(), 0);
91    }
92    #[test]
93    fn response_requires_a_unique_initialized_base_and_retains_service_rejection() {
94        let accepted = response(&p::bytes(1, &p::uint(1, 0))).unwrap();
95        assert!(accepted.accepted);
96        let rejected = response(&p::bytes(1, &p::int32(1, -13))).unwrap();
97        assert_eq!(rejected.service_code, -13);
98        assert!(!rejected.accepted);
99        for invalid in [
100            vec![],
101            p::bytes(1, &[]),
102            p::uint(1, 0),
103            p::bytes(1, &p::uint(1, 1u64 << 32)),
104            [p::bytes(1, &p::uint(1, 0)), p::bytes(1, &p::uint(1, 0))].concat(),
105        ] {
106            assert!(response(&invalid).is_err());
107        }
108    }
109    #[test]
110    fn invalid_account_material_fails_before_any_transport() {
111        let mut invalid = state();
112        invalid.uin = 0;
113        assert!(request(&invalid).is_err());
114    }
115}