Skip to main content

wechat_protocol/
mmtls.rs

1//! Fresh pinned MMTLS handshake and authenticated shortlink exchange.
2use crate::crypto::*;
3use anyhow::{ensure, Context, Result};
4use openssl::{memcmp, nid::Nid};
5use serde::{Deserialize, Serialize};
6use std::{
7    io::{Read, Write},
8    net::TcpStream,
9    time::{Duration, Instant},
10};
11use zeroize::Zeroize;
12
13pub const VERSION: u16 = 0xf104;
14pub struct Cursor<'a> {
15    bytes: &'a [u8],
16    offset: usize,
17}
18impl<'a> Cursor<'a> {
19    pub fn new(bytes: &'a [u8]) -> Self {
20        Self { bytes, offset: 0 }
21    }
22    pub fn take(&mut self, n: usize) -> Result<&'a [u8]> {
23        ensure!(n <= self.bytes.len() - self.offset, "Truncated structure");
24        let b = &self.bytes[self.offset..self.offset + n];
25        self.offset += n;
26        Ok(b)
27    }
28    pub fn uint(&mut self, n: usize) -> Result<u64> {
29        ensure!(n <= 8, "Integer too wide");
30        Ok(self.take(n)?.iter().fold(0, |a, &b| (a << 8) | b as u64))
31    }
32    pub fn sized(&mut self, width: usize) -> Result<&'a [u8]> {
33        let n = usize::try_from(self.uint(width)?)?;
34        self.take(n)
35    }
36    pub fn end(&self) -> Result<()> {
37        ensure!(self.offset == self.bytes.len(), "Trailing structure bytes");
38        Ok(())
39    }
40}
41pub fn section(b: &[u8]) -> Vec<u8> {
42    [(b.len() as u32).to_be_bytes().as_slice(), b].concat()
43}
44fn sized(b: &[u8]) -> Result<Vec<u8>> {
45    ensure!(b.len() <= u16::MAX as usize, "Section too large");
46    Ok([(b.len() as u16).to_be_bytes().as_slice(), b].concat())
47}
48#[derive(Clone)]
49pub struct Record {
50    pub header: [u8; 5],
51    pub body: Vec<u8>,
52}
53pub fn frame(kind: u8, body: &[u8]) -> Result<Vec<u8>> {
54    ensure!(
55        (0x15..=0x19).contains(&kind) && body.len() <= 65535,
56        "Invalid MMTLS record"
57    );
58    Ok([
59        vec![kind],
60        VERSION.to_be_bytes().to_vec(),
61        (body.len() as u16).to_be_bytes().to_vec(),
62        body.to_vec(),
63    ]
64    .concat())
65}
66pub fn nonce(iv: &[u8], sequence: u64) -> Result<[u8; 12]> {
67    ensure!(iv.len() == 12, "Invalid IV");
68    let mut b: [u8; 12] = iv.try_into()?;
69    for (i, v) in sequence.to_be_bytes().iter().enumerate() {
70        b[i + 4] ^= v;
71    }
72    Ok(b)
73}
74pub fn seal(kind: u8, plain: &[u8], key: &[u8], iv: &[u8], sequence: u64) -> Result<Vec<u8>> {
75    ensure!(plain.len() <= 65519, "MMTLS plaintext too large");
76    let header = frame(kind, &vec![0; plain.len() + 16])?[..5].to_vec();
77    let aad = [sequence.to_be_bytes().as_slice(), &header].concat();
78    let (cipher, tag) = gcm_seal(key, &nonce(iv, sequence)?, &aad, plain)?;
79    Ok([header, cipher, tag.to_vec()].concat())
80}
81pub fn open(record: &Record, key: &[u8], iv: &[u8], sequence: u64) -> Result<Vec<u8>> {
82    ensure!(record.body.len() >= 16, "Missing authentication tag");
83    let n = record.body.len() - 16;
84    gcm_open(
85        key,
86        &nonce(iv, sequence)?,
87        &[sequence.to_be_bytes().as_slice(), &record.header].concat(),
88        &record.body[..n],
89        &record.body[n..],
90    )
91}
92struct Traffic {
93    client_key: Vec<u8>,
94    server_key: Vec<u8>,
95    client_iv: Vec<u8>,
96    server_iv: Vec<u8>,
97}
98impl Drop for Traffic {
99    fn drop(&mut self) {
100        self.client_key.zeroize();
101        self.server_key.zeroize();
102        self.client_iv.zeroize();
103        self.server_iv.zeroize();
104    }
105}
106fn traffic(secret: &[u8], label: &str, transcript: &[u8]) -> Result<Traffic> {
107    let mut b = expand(
108        secret,
109        &[label.as_bytes(), &sha256(transcript)].concat(),
110        56,
111    )?;
112    let t = Traffic {
113        client_key: b[..16].to_vec(),
114        server_key: b[16..32].to_vec(),
115        client_iv: b[32..44].to_vec(),
116        server_iv: b[44..].to_vec(),
117    };
118    b.zeroize();
119    Ok(t)
120}
121fn handshake_secret(shared_x: &[u8]) -> Result<Vec<u8>> {
122    ensure!(
123        shared_x.len() == 32,
124        "Invalid MMTLS P256 shared secret width"
125    );
126    // The P256 coordinate has a fixed width. A leading zero is part of the
127    // shared secret and must participate in the key schedule.
128    Ok(sha256(shared_x))
129}
130fn signed_payload(bytes: &[u8], kind: u8) -> Result<Vec<u8>> {
131    let mut top = Cursor::new(bytes);
132    let mut body = Cursor::new(top.sized(4)?);
133    top.end()?;
134    ensure!(body.uint(1)? == kind as u64, "Unexpected handshake message");
135    let value = body.sized(2)?.to_vec();
136    body.end()?;
137    Ok(value)
138}
139
140#[derive(Clone, Serialize, Deserialize)]
141pub struct Ticket {
142    pub kind: u8,
143    pub lifetime: u32,
144    pub reserved: u32,
145    pub nonce: Vec<u8>,
146    pub opaque: Vec<u8>,
147}
148#[derive(Clone, Serialize, Deserialize)]
149pub struct ShortSession {
150    pub access_psk: Vec<u8>,
151    pub ticket: Ticket,
152}
153impl Drop for ShortSession {
154    fn drop(&mut self) {
155        self.access_psk.zeroize();
156        self.ticket.opaque.zeroize();
157        self.ticket.nonce.zeroize();
158    }
159}
160pub struct Session {
161    socket: TcpStream,
162    deadline: Instant,
163    received: usize,
164    receive_budget: usize,
165    pub short: ShortSession,
166    pub certificate_region: u32,
167    pub certificate_version: u32,
168    traffic: Traffic,
169    outgoing: u64,
170    incoming: u64,
171    record_pending: Vec<u8>,
172    application_pending: LonglinkDecoder,
173}
174
175fn host_valid(name: &str) -> bool {
176    !name.is_empty()
177        && name.len() <= 253
178        && name.is_ascii()
179        && name.split('.').all(|s| {
180            !s.is_empty()
181                && s.len() <= 63
182                && s.bytes()
183                    .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == b'-')
184                && !s.starts_with('-')
185                && !s.ends_with('-')
186        })
187        && (name.ends_with(".wechat.com") || name.ends_with(".weixin.qq.com"))
188}
189pub fn validate_host(name: &str) -> Result<()> {
190    ensure!(host_valid(name), "Unsupported native server host");
191    Ok(())
192}
193fn read_exact_deadline(
194    socket: &mut TcpStream,
195    mut bytes: &mut [u8],
196    deadline: Instant,
197) -> Result<()> {
198    while !bytes.is_empty() {
199        let remaining = deadline.saturating_duration_since(Instant::now());
200        ensure!(!remaining.is_zero(), "MMTLS deadline exceeded");
201        socket.set_read_timeout(Some(remaining))?;
202        match socket.read(bytes) {
203            Ok(0) => anyhow::bail!("MMTLS connection closed"),
204            Ok(n) => bytes = &mut bytes[n..],
205            Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
206            Err(e) => return Err(e.into()),
207        }
208    }
209    Ok(())
210}
211fn read_record(
212    socket: &mut TcpStream,
213    deadline: Instant,
214    received: &mut usize,
215    budget: usize,
216) -> Result<Record> {
217    let mut h = [0; 5];
218    read_exact_deadline(socket, &mut h, deadline)?;
219    ensure!(
220        (0x15..=0x19).contains(&h[0]) && u16::from_be_bytes([h[1], h[2]]) == VERSION,
221        "Unexpected MMTLS header"
222    );
223    let n = u16::from_be_bytes([h[3], h[4]]) as usize;
224    *received = received
225        .checked_add(n + 5)
226        .ok_or_else(|| anyhow::anyhow!("Receive overflow"))?;
227    ensure!(*received <= budget, "MMTLS receive budget exceeded");
228    let mut body = vec![0; n];
229    read_exact_deadline(socket, &mut body, deadline)?;
230    ensure!(h[0] != 0x15, "Server returned MMTLS alert");
231    Ok(Record { header: h, body })
232}
233
234impl Session {
235    pub fn connect(host: &str, timeout: Duration, receive_budget: usize) -> Result<Self> {
236        validate_host(host)?;
237        ensure!(
238            (1024..=crate::MAX_MESSAGE_BYTES).contains(&receive_budget),
239            "Invalid receive budget"
240        );
241        ensure!(
242            !timeout.is_zero() && timeout <= Duration::from_secs(120),
243            "Invalid MMTLS timeout"
244        );
245        let deadline = Instant::now() + timeout;
246        // Resolver and connect are constrained by the caller's blocking worker. Socket
247        // read/write deadlines bound every subsequent protocol operation.
248        use std::net::ToSocketAddrs;
249        let addresses = (host, 80).to_socket_addrs()?;
250        let mut socket = None;
251        for addr in addresses {
252            let remaining = deadline.saturating_duration_since(Instant::now());
253            if remaining.is_zero() {
254                break;
255            }
256            if let Ok(s) = TcpStream::connect_timeout(&addr, remaining) {
257                socket = Some(s);
258                break;
259            }
260        }
261        let mut socket = socket.ok_or_else(|| anyhow::anyhow!("Native connection failed"))?;
262        socket.set_write_timeout(Some(timeout))?;
263        let keys = [
264            Ecdh::generate(Nid::X9_62_PRIME256V1).context("MMTLS key generation")?,
265            Ecdh::generate(Nid::X9_62_PRIME256V1).context("MMTLS key generation")?,
266        ];
267        let mut shares = vec![];
268        for (i, k) in keys.iter().enumerate() {
269            let point = k.public().context("MMTLS public key encoding")?;
270            shares.extend(section(
271                &[((i + 5) as u32).to_be_bytes().to_vec(), sized(&point)?].concat(),
272            ));
273        }
274        let mut extra = vec![0; 4];
275        extra.push(2);
276        extra.extend(5u32.to_be_bytes());
277        extra.extend(1000u32.to_be_bytes());
278        let extension = section(&[0x10u16.to_be_bytes().to_vec(), vec![2], shares, extra].concat());
279        let hello = section(
280            &[
281                vec![1],
282                VERSION.to_le_bytes().to_vec(),
283                vec![1],
284                0xc02bu16.to_be_bytes().to_vec(),
285                random::<32>().context("MMTLS hello random")?.to_vec(),
286                crate::wire::unix_time()?.to_be_bytes().to_vec(),
287                section(&[vec![1], extension].concat()),
288            ]
289            .concat(),
290        );
291        socket.write_all(&frame(0x16, &hello)?)?;
292        let mut received = 0;
293        let server_record = read_record(&mut socket, deadline, &mut received, receive_budget)?;
294        ensure!(server_record.header[0] == 0x16, "Expected handshake");
295        let server = parse_server_hello(&server_record.body)?;
296        let index = server
297            .key_id
298            .checked_sub(5)
299            .ok_or_else(|| anyhow::anyhow!("Unoffered key"))? as usize;
300        ensure!(index < 2, "Unoffered key");
301        let mut x = keys[index]
302            .derive(&server.point)
303            .context("MMTLS shared secret derivation")?;
304        let mut secret = handshake_secret(&x)?;
305        x.zeroize();
306        let mut transcript = [hello, server_record.body].concat();
307        let handshake = traffic(&secret, "handshake key expansion", &transcript)
308            .context("MMTLS handshake key derivation")?;
309        let r = read_record(&mut socket, deadline, &mut received, receive_budget)?;
310        ensure!(r.header[0] == 0x16, "Expected signature record");
311        let signature_body = open(&r, &handshake.server_key, &handshake.server_iv, 1)
312            .context("MMTLS signature record authentication")?;
313        let signature = signed_payload(&signature_body, 0x0f)?;
314        let pins: serde_json::Value =
315            serde_json::from_str(include_str!("../fixtures/mmtls-public-keys.json"))?;
316        let pin = pins["profiles"]
317            .as_array()
318            .unwrap()
319            .iter()
320            .find(|p| p["version"].as_u64() == Some(server.version as u64))
321            .ok_or_else(|| anyhow::anyhow!("Unsupported MMTLS certificate version"))?;
322        ensure!([5, 1000].contains(&server.version), "Unoffered MMTLS pin");
323        verify_signature(
324            pin["ecdsaPEM"].as_str().unwrap(),
325            &sha256(&transcript),
326            &signature,
327        )
328        .context("MMTLS signature verification")?;
329        transcript.extend(signature_body);
330        let r = read_record(&mut socket, deadline, &mut received, receive_budget)?;
331        ensure!(r.header[0] == 0x16, "Expected ticket record");
332        let ticket_body = open(&r, &handshake.server_key, &handshake.server_iv, 2)
333            .context("MMTLS ticket record authentication")?;
334        let tickets = parse_tickets(&ticket_body)?;
335        let access_psk = expand(
336            &secret,
337            &[b"PSK_ACCESS".as_slice(), &sha256(&transcript)].concat(),
338            32,
339        )?;
340        transcript.extend(ticket_body);
341        let r = read_record(&mut socket, deadline, &mut received, receive_budget)?;
342        ensure!(r.header[0] == 0x16, "Expected Finished");
343        let finish = signed_payload(
344            &open(&r, &handshake.server_key, &handshake.server_iv, 3)
345                .context("MMTLS finished record authentication")?,
346            0x14,
347        )?;
348        let expected = hmac(
349            &expand(&secret, b"server finished", 32)?,
350            &sha256(&transcript),
351        )?;
352        ensure!(
353            finish.len() == expected.len() && memcmp::eq(&finish, &expected),
354            "Server Finished verification failed"
355        );
356        let client_finish = hmac(
357            &expand(&secret, b"client finished", 32)?,
358            &sha256(&transcript),
359        )?;
360        socket.write_all(&seal(
361            0x16,
362            &section(&[vec![0x14], sized(&client_finish)?].concat()),
363            &handshake.client_key,
364            &handshake.client_iv,
365            1,
366        )?)?;
367        let mut expanded = expand(
368            &secret,
369            &[b"expanded secret".as_slice(), &sha256(&transcript)].concat(),
370            32,
371        )?;
372        let application = traffic(&expanded, "application data key expansion", &transcript)
373            .context("MMTLS application key derivation")?;
374        secret.zeroize();
375        expanded.zeroize();
376        let noop = pack_longlink(6, u32::MAX, &[])?;
377        socket.write_all(
378            &seal(
379                0x17,
380                &noop,
381                &application.client_key,
382                &application.client_iv,
383                2,
384            )
385            .context("MMTLS noop record sealing")?,
386        )?;
387        let r = read_record(&mut socket, deadline, &mut received, receive_budget)?;
388        ensure!(r.header[0] == 0x17, "Expected NOOP reply");
389        let p = unpack_longlink(
390            &open(&r, &application.server_key, &application.server_iv, 4)
391                .context("MMTLS noop record authentication")?,
392        )?;
393        ensure!(
394            p.command == 0x3b9aca06 && p.sequence == u32::MAX && p.payload.is_empty(),
395            "Unexpected NOOP reply"
396        );
397        Ok(Self {
398            socket,
399            deadline,
400            received,
401            receive_budget,
402            short: ShortSession {
403                access_psk,
404                ticket: tickets[0].clone(),
405            },
406            certificate_region: server.region,
407            certificate_version: server.version,
408            traffic: application,
409            outgoing: 3,
410            incoming: 5,
411            record_pending: Vec::new(),
412            application_pending: LonglinkDecoder {
413                pending: Vec::new(),
414                max_payload: receive_budget,
415            },
416        })
417    }
418    pub fn send_application(&mut self, command: u32, sequence: u32, payload: &[u8]) -> Result<()> {
419        let bytes = seal(
420            0x17,
421            &pack_longlink(command, sequence, payload)?,
422            &self.traffic.client_key,
423            &self.traffic.client_iv,
424            self.outgoing,
425        )?;
426        self.socket.write_all(&bytes)?;
427        self.outgoing = self
428            .outgoing
429            .checked_add(1)
430            .ok_or_else(|| anyhow::anyhow!("Sequence exhausted"))?;
431        Ok(())
432    }
433    pub fn receive_application(&mut self) -> Result<Longlink> {
434        let r = read_record(
435            &mut self.socket,
436            self.deadline,
437            &mut self.received,
438            self.receive_budget,
439        )?;
440        ensure!(r.header[0] == 0x17, "Expected application record");
441        let plain = open(
442            &r,
443            &self.traffic.server_key,
444            &self.traffic.server_iv,
445            self.incoming,
446        )?;
447        self.incoming = self
448            .incoming
449            .checked_add(1)
450            .ok_or_else(|| anyhow::anyhow!("Sequence exhausted"))?;
451        unpack_longlink(&plain)
452    }
453
454    /// A bounded idle wait on an established connection. Partial encrypted
455    /// records and application packets survive a timeout; MMTLS record
456    /// boundaries need not coincide with longlink packet boundaries.
457    pub fn poll_application(&mut self, timeout: Duration) -> Result<Option<Longlink>> {
458        ensure!(
459            !timeout.is_zero() && timeout <= Duration::from_secs(120),
460            "Invalid longlink poll timeout"
461        );
462        let deadline = Instant::now() + timeout;
463        loop {
464            if let Some(packet) = self.application_pending.next_packet()? {
465                return Ok(Some(packet));
466            }
467            if self.record_pending.len() >= 5 {
468                let h: [u8; 5] = self.record_pending[..5].try_into()?;
469                ensure!(
470                    (0x15..=0x19).contains(&h[0]) && u16::from_be_bytes([h[1], h[2]]) == VERSION,
471                    "Unexpected MMTLS header"
472                );
473                let n = u16::from_be_bytes([h[3], h[4]]) as usize;
474                if self.record_pending.len() >= n + 5 {
475                    ensure!(h[0] == 0x17, "Unexpected persistent MMTLS record");
476                    let record = Record {
477                        header: h,
478                        body: self.record_pending[5..n + 5].to_vec(),
479                    };
480                    let plain = open(
481                        &record,
482                        &self.traffic.server_key,
483                        &self.traffic.server_iv,
484                        self.incoming,
485                    )?;
486                    self.incoming = self
487                        .incoming
488                        .checked_add(1)
489                        .ok_or_else(|| anyhow::anyhow!("Sequence exhausted"))?;
490                    self.record_pending.drain(..n + 5);
491                    self.application_pending.feed(&plain)?;
492                    continue;
493                }
494            }
495            let remaining = deadline.saturating_duration_since(Instant::now());
496            if remaining.is_zero() {
497                return Ok(None);
498            }
499            self.socket.set_read_timeout(Some(remaining))?;
500            let mut bytes = [0u8; 65540];
501            match self.socket.read(&mut bytes) {
502                Ok(0) => anyhow::bail!("MMTLS connection closed"),
503                Ok(n) => {
504                    // At most one incomplete record precedes a socket read.
505                    ensure!(
506                        self.record_pending.len() + n <= 131080,
507                        "MMTLS pending record limit"
508                    );
509                    self.record_pending.extend_from_slice(&bytes[..n]);
510                }
511                Err(e)
512                    if matches!(
513                        e.kind(),
514                        std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut
515                    ) =>
516                {
517                    return Ok(None)
518                }
519                Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
520                Err(e) => return Err(e.into()),
521            }
522        }
523    }
524}
525struct ServerHello {
526    key_id: u32,
527    point: Vec<u8>,
528    region: u32,
529    version: u32,
530}
531fn parse_server_hello(bytes: &[u8]) -> Result<ServerHello> {
532    let mut top = Cursor::new(bytes);
533    let mut b = Cursor::new(top.sized(4)?);
534    top.end()?;
535    ensure!(
536        b.uint(1)? == 2 && b.take(2)? == VERSION.to_le_bytes() && b.uint(2)? == 0xc02b,
537        "Unsupported ServerHello"
538    );
539    b.take(32)?;
540    let mut e = Cursor::new(b.sized(4)?);
541    b.end()?;
542    let count = e.uint(1)?;
543    let mut seen = std::collections::HashSet::new();
544    let mut share = None;
545    let mut cert = None;
546    for _ in 0..count {
547        let mut x = Cursor::new(e.sized(4)?);
548        let kind = x.uint(2)?;
549        ensure!(seen.insert(kind), "Duplicate extension");
550        match kind {
551            0x11 => {
552                let id = x.uint(4)? as u32;
553                let point = x.sized(2)?.to_vec();
554                ensure!(point.len() == 65 && point[0] == 4, "Invalid ECDH point");
555                x.end()?;
556                share = Some((id, point));
557            }
558            0x13 => {
559                let region = x.uint(4)? as u32;
560                let version = x.uint(4)? as u32;
561                x.end()?;
562                cert = Some((region, version));
563            }
564            _ => {}
565        }
566    }
567    e.end()?;
568    let (key_id, point) = share.ok_or_else(|| anyhow::anyhow!("Missing ECDH selection"))?;
569    let (region, version) = cert.ok_or_else(|| anyhow::anyhow!("Missing certificate selection"))?;
570    Ok(ServerHello {
571        key_id,
572        point,
573        region,
574        version,
575    })
576}
577fn parse_tickets(input: &[u8]) -> Result<Vec<Ticket>> {
578    let mut top = Cursor::new(input);
579    let mut b = Cursor::new(top.sized(4)?);
580    top.end()?;
581    ensure!(b.uint(1)? == 4, "Expected tickets");
582    let count = b.uint(1)?;
583    ensure!((1..=4).contains(&count), "Invalid ticket count");
584    let mut out = vec![];
585    for _ in 0..count {
586        let mut t = Cursor::new(b.sized(4)?);
587        let kind = t.uint(1)? as u8;
588        let lifetime = t.uint(4)? as u32;
589        t.sized(2)?;
590        let reserved = t.uint(4)? as u32;
591        let nonce = t.sized(2)?.to_vec();
592        let opaque = t.sized(2)?.to_vec();
593        t.end()?;
594        ensure!(
595            nonce.len() == 12 && !opaque.is_empty(),
596            "Invalid shortlink ticket"
597        );
598        out.push(Ticket {
599            kind,
600            lifetime,
601            reserved,
602            nonce,
603            opaque,
604        });
605    }
606    b.end()?;
607    Ok(out)
608}
609pub struct Longlink {
610    pub command: u32,
611    pub sequence: u32,
612    pub payload: Vec<u8>,
613}
614struct LonglinkDecoder {
615    pending: Vec<u8>,
616    max_payload: usize,
617}
618impl Default for LonglinkDecoder {
619    fn default() -> Self {
620        Self {
621            pending: Vec::new(),
622            max_payload: crate::MAX_MESSAGE_BYTES,
623        }
624    }
625}
626impl LonglinkDecoder {
627    fn feed(&mut self, bytes: &[u8]) -> Result<()> {
628        ensure!(
629            self.pending.len().saturating_add(bytes.len()) <= self.max_payload + 65540,
630            "Longlink pending packet limit"
631        );
632        self.pending.extend_from_slice(bytes);
633        Ok(())
634    }
635    fn next_packet(&mut self) -> Result<Option<Longlink>> {
636        if self.pending.len() < 4 {
637            return Ok(None);
638        }
639        let n = u32::from_be_bytes(self.pending[..4].try_into()?) as usize;
640        ensure!(
641            (16..=self.max_payload + 16).contains(&n),
642            "Invalid longlink packet length"
643        );
644        if self.pending.len() >= 8 {
645            ensure!(
646                self.pending[4..8] == [0, 16, 0, 1],
647                "Invalid longlink envelope"
648            );
649        }
650        if self.pending.len() < n {
651            return Ok(None);
652        }
653        let packet = unpack_longlink(&self.pending[..n])?;
654        self.pending.drain(..n);
655        Ok(Some(packet))
656    }
657}
658pub fn pack_longlink(command: u32, sequence: u32, payload: &[u8]) -> Result<Vec<u8>> {
659    ensure!(payload.len() <= 65503, "Longlink body too large");
660    Ok([
661        ((16 + payload.len()) as u32).to_be_bytes().to_vec(),
662        0x10u16.to_be_bytes().to_vec(),
663        1u16.to_be_bytes().to_vec(),
664        command.to_be_bytes().to_vec(),
665        sequence.to_be_bytes().to_vec(),
666        payload.to_vec(),
667    ]
668    .concat())
669}
670pub fn unpack_longlink(input: &[u8]) -> Result<Longlink> {
671    let mut c = Cursor::new(input);
672    ensure!(
673        c.uint(4)? == input.len() as u64 && c.uint(2)? == 0x10 && c.uint(2)? == 1,
674        "Invalid longlink envelope"
675    );
676    let command = c.uint(4)? as u32;
677    let sequence = c.uint(4)? as u32;
678    let payload = c.take(input.len() - 16)?.to_vec();
679    Ok(Longlink {
680        command,
681        sequence,
682        payload,
683    })
684}
685
686/// A route rejected locally before any short-link request bytes are submitted.
687#[derive(Debug)]
688pub(crate) struct UnsupportedNativeRoute;
689impl std::fmt::Display for UnsupportedNativeRoute {
690    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
691        f.write_str("Unsupported native route")
692    }
693}
694impl std::error::Error for UnsupportedNativeRoute {}
695pub(crate) fn validate_short_route(path: &str) -> Result<()> {
696    let ordinary = path.starts_with("/cgi-bin/micromsg-bin/")
697        && path
698            .bytes()
699            .all(|b| b.is_ascii_alphanumeric() || b == b'/' || b == b'-');
700    if ordinary || path == "/cgi-bin/micromsg-bin/mm_ilink_cloud_app_auth" {
701        Ok(())
702    } else {
703        Err(UnsupportedNativeRoute.into())
704    }
705}
706
707pub fn short_exchange(
708    session: &ShortSession,
709    host: &str,
710    path: &str,
711    payload: &[u8],
712    timeout: Duration,
713) -> Result<Vec<u8>> {
714    let (hello, extensions, wire) = prepare_short_exchange(session, host, path, payload)?;
715    let client = reqwest::blocking::Client::builder()
716        .timeout(timeout)
717        .connect_timeout(timeout.min(Duration::from_secs(10)))
718        .redirect(reqwest::redirect::Policy::none())
719        .no_proxy()
720        .build()?;
721    let mut response = client
722        .post(format!(
723            "http://{host}/mmtls/{}",
724            hex::encode(random::<4>()?)
725        ))
726        .header("Content-Type", "application/octet-stream")
727        .header("User-Agent", "MicroMessenger Client")
728        .header("Upgrade", "mmtls")
729        .header("Accept", "*/*")
730        .header("Cache-Control", "no-cache")
731        .header("Connection", "close")
732        .body(wire)
733        .send()?;
734    ensure!(
735        response.status() == 200,
736        "Native shortlink HTTP status {}",
737        response.status().as_u16()
738    );
739    let mut bytes = Vec::new();
740    response
741        .by_ref()
742        .take((crate::MAX_MESSAGE_BYTES + 1) as u64)
743        .read_to_end(&mut bytes)?;
744    ensure!(
745        bytes.len() <= crate::MAX_MESSAGE_BYTES,
746        "Shortlink receive budget exceeded"
747    );
748    decode_short_reply(&bytes, session, &hello, &extensions)
749}
750fn prepare_short_exchange(
751    session: &ShortSession,
752    host: &str,
753    path: &str,
754    payload: &[u8],
755) -> Result<(Vec<u8>, Vec<u8>, Vec<u8>)> {
756    validate_host(host)?;
757    validate_short_route(path)?;
758    ensure!(
759        payload.len() <= crate::MAX_MESSAGE_BYTES,
760        "Payload too large"
761    );
762    let (hello, extensions) = early_hello(&session.ticket)?;
763    let keys = expand(
764        &session.access_psk,
765        &[b"early data key expansion".as_slice(), &sha256(&hello)].concat(),
766        28,
767    )?;
768    let route = section(
769        &[
770            sized(path.as_bytes())?,
771            sized(host.as_bytes())?,
772            section(payload),
773        ]
774        .concat(),
775    );
776    let wire = [
777        frame(0x19, &hello)?,
778        seal(0x19, &extensions, &keys[..16], &keys[16..], 1)?,
779        seal(0x17, &route, &keys[..16], &keys[16..], 2)?,
780        seal(0x15, &section(&[0, 1, 1]), &keys[..16], &keys[16..], 3)?,
781    ]
782    .concat();
783    Ok((hello, extensions, wire))
784}
785
786/// The pre-answer poll can stop waiting without applying a late reply.
787pub(crate) async fn short_exchange_interruptible(
788    session: &ShortSession,
789    host: &str,
790    path: &str,
791    payload: &[u8],
792    timeout: Duration,
793) -> Result<Vec<u8>> {
794    let (hello, extensions, wire) = prepare_short_exchange(session, host, path, payload)?;
795    let client = reqwest::Client::builder()
796        .timeout(timeout)
797        .connect_timeout(timeout.min(Duration::from_secs(10)))
798        .redirect(reqwest::redirect::Policy::none())
799        .no_proxy()
800        .build()?;
801    let mut response = client
802        .post(format!(
803            "http://{host}/mmtls/{}",
804            hex::encode(random::<4>()?)
805        ))
806        .header("Content-Type", "application/octet-stream")
807        .header("User-Agent", "MicroMessenger Client")
808        .header("Upgrade", "mmtls")
809        .header("Accept", "*/*")
810        .header("Cache-Control", "no-cache")
811        .header("Connection", "close")
812        .body(wire)
813        .send()
814        .await?;
815    ensure!(
816        response.status() == 200,
817        "Native shortlink HTTP status {}",
818        response.status().as_u16()
819    );
820    let mut bytes = Vec::new();
821    while let Some(chunk) = response.chunk().await? {
822        ensure!(
823            chunk.len() <= crate::MAX_MESSAGE_BYTES - bytes.len(),
824            "Shortlink receive budget exceeded"
825        );
826        bytes.extend_from_slice(&chunk);
827    }
828    decode_short_reply(&bytes, session, &hello, &extensions)
829}
830fn early_hello(ticket: &Ticket) -> Result<(Vec<u8>, Vec<u8>)> {
831    ensure!(
832        ticket.nonce.len() == 12 && !ticket.opaque.is_empty(),
833        "Invalid short ticket"
834    );
835    let now = crate::wire::unix_time()?;
836    let encoded = [
837        vec![ticket.kind],
838        ticket.lifetime.to_be_bytes().to_vec(),
839        sized(&[])?,
840        ticket.reserved.to_be_bytes().to_vec(),
841        sized(&ticket.nonce)?,
842        sized(&ticket.opaque)?,
843    ]
844    .concat();
845    let ext = section(&[0x0fu16.to_be_bytes().to_vec(), vec![1], section(&encoded)].concat());
846    let hello = section(
847        &[
848            vec![1],
849            VERSION.to_le_bytes().to_vec(),
850            vec![1],
851            0xa8u16.to_be_bytes().to_vec(),
852            random::<32>()?.to_vec(),
853            now.to_be_bytes().to_vec(),
854            section(&[vec![1], ext].concat()),
855        ]
856        .concat(),
857    );
858    let extensions = section(
859        &[
860            vec![8],
861            section(
862                &[
863                    vec![1],
864                    section(&[0x12u16.to_be_bytes().to_vec(), now.to_be_bytes().to_vec()].concat()),
865                ]
866                .concat(),
867            ),
868        ]
869        .concat(),
870    );
871    Ok((hello, extensions))
872}
873fn decode_short_reply(
874    input: &[u8],
875    session: &ShortSession,
876    hello: &[u8],
877    extensions: &[u8],
878) -> Result<Vec<u8>> {
879    let mut c = Cursor::new(input);
880    let mut records = vec![];
881    while c.offset < input.len() {
882        let h: [u8; 5] = c.take(5)?.try_into()?;
883        ensure!(
884            (0x15..=0x19).contains(&h[0]) && u16::from_be_bytes([h[1], h[2]]) == VERSION,
885            "Invalid shortlink header"
886        );
887        records.push(Record {
888            header: h,
889            body: c.take(u16::from_be_bytes([h[3], h[4]]) as usize)?.to_vec(),
890        });
891    }
892    ensure!(
893        records.len() >= 4
894            && records[0].header[0] == 0x16
895            && records[1].header[0] == 0x16
896            && records.last().unwrap().header[0] == 0x15
897            && records[2..records.len() - 1]
898                .iter()
899                .all(|r| r.header[0] == 0x17),
900        "Invalid shortlink sequence"
901    );
902    let server = &records[0];
903    let mut top = Cursor::new(&server.body);
904    let mut b = Cursor::new(top.sized(4)?);
905    top.end()?;
906    ensure!(
907        b.uint(1)? == 2 && b.take(2)? == VERSION.to_le_bytes() && b.uint(2)? == 0xa8,
908        "Unsupported shortlink selection"
909    );
910    b.take(32)?;
911    let mut e = Cursor::new(b.sized(4)?);
912    b.end()?;
913    ensure!(e.uint(1)? == 0, "Unsupported shortlink extensions");
914    e.end()?;
915    let transcript = [hello, extensions, &server.body].concat();
916    let keys = expand(
917        &session.access_psk,
918        &[b"handshake key expansion".as_slice(), &sha256(&transcript)].concat(),
919        28,
920    )?;
921    let finish = signed_payload(&open(&records[1], &keys[..16], &keys[16..], 1)?, 0x14)?;
922    let expected = hmac(
923        &expand(&session.access_psk, b"server finished", 32)?,
924        &sha256(&transcript),
925    )?;
926    ensure!(
927        finish.len() == expected.len() && memcmp::eq(&finish, &expected),
928        "Shortlink Finished failed"
929    );
930    let mut plain = vec![];
931    for (i, r) in records[2..records.len() - 1].iter().enumerate() {
932        plain.extend(open(r, &keys[..16], &keys[16..], i as u64 + 2)?);
933        ensure!(
934            plain.len() <= crate::MAX_MESSAGE_BYTES,
935            "Shortlink plaintext too large"
936        );
937    }
938    ensure!(
939        open(
940            records.last().unwrap(),
941            &keys[..16],
942            &keys[16..],
943            records.len() as u64 - 1
944        )? == section(&[0, 1, 1]),
945        "Unexpected shortlink close"
946    );
947    Ok(plain)
948}
949
950#[cfg(test)]
951mod tests {
952    #[test]
953    fn fresh_handshake_secret_requires_the_selected_p256_width() {
954        for wrong in [0, 28, 31, 33] {
955            assert!(handshake_secret(&vec![1; wrong]).is_err());
956        }
957        assert_eq!(handshake_secret(&[1; 32]).unwrap(), sha256(&[1; 32]));
958    }
959    #[test]
960    fn zero_prefixed_p256_secret_authenticates_an_independent_server_record() {
961        // Synthetic P256 private scalars 1 and 379. The shared coordinate and
962        // record were calculated independently using Python cryptography,
963        // hashlib and hmac. No account data or captured traffic is used.
964        let own = Ecdh::from_private(Nid::X9_62_PRIME256V1, &[1]).unwrap();
965        let peer = Ecdh::from_private(Nid::X9_62_PRIME256V1, &[1, 123]).unwrap();
966        let shared = own.derive(&peer.public().unwrap()).unwrap();
967        assert_eq!(
968            hex::encode(&shared),
969            "005543894af3d00ed7d740abdbd75c96b06877b787db5f70eea78b90a8d7c00a"
970        );
971        let keys = traffic(
972            &handshake_secret(&shared).unwrap(),
973            "handshake key expansion",
974            b"synthetic client hellosynthetic server hello",
975        )
976        .unwrap();
977        let wire = hex::decode("16f10400314bbd4e0fa2f28903e143496cf3f42dd756b3e792e8359afb180b5bfaff820fcb03742b63ba60e98e9e3ac32f99f851f031").unwrap();
978        let record = Record {
979            header: wire[..5].try_into().unwrap(),
980            body: wire[5..].to_vec(),
981        };
982        assert_eq!(
983            open(&record, &keys.server_key, &keys.server_iv, 1).unwrap(),
984            b"synthetic server signature record"
985        );
986        assert!(open(&record, &keys.server_key, &keys.server_iv, 2).is_err());
987        let mut tampered = record;
988        *tampered.body.last_mut().unwrap() ^= 1;
989        assert!(open(&tampered, &keys.server_key, &keys.server_iv, 1).is_err());
990    }
991    #[test]
992    fn exact_call_app_auth_route_does_not_admit_arbitrary_route_bytes() {
993        assert!(validate_short_route("/cgi-bin/micromsg-bin/mm_ilink_cloud_app_auth").is_ok());
994        assert!(validate_short_route("/cgi-bin/micromsg-bin/heartbeat").is_ok());
995        assert!(validate_short_route("/cgi-bin/micromsg-bin/voipilinkack").is_ok());
996        for bad in [
997            "/cgi-bin/micromsg-bin/another_route",
998            "/cgi-bin/micromsg-bin/mm_ilink_cloud_app_auth/extra",
999            "/cgi-bin/micromsg-bin/mm_ilink_cloud_app_auth?x=1",
1000            "/cgi-bin/micromsg-bin/mm_ilink_cloud_app_auth#x",
1001            "/cgi-bin/micromsg-bin/mm_ilink_cloud_app_auth\r\nX: y",
1002            "/cgi-bin/micromsg-bin/mm_ilink_cloud_app_auth\0",
1003            "/cgi-bin/micromsg-bin/%2e%2e",
1004            "/cgi-bin/micromsg-bin/../x",
1005            "/cgi-bin/micromsg-bin/\\x",
1006            "/cgi-bin/micromsg-bin/音",
1007            "http://example.test/cgi-bin/micromsg-bin/heartbeat",
1008        ] {
1009            assert!(validate_short_route(bad)
1010                .unwrap_err()
1011                .is::<UnsupportedNativeRoute>());
1012        }
1013    }
1014    use super::*;
1015    #[test]
1016    fn longlink_frames_can_split_or_share_records_and_reject_bad_lengths_early() {
1017        let a = pack_longlink(24, 0, &6u32.to_be_bytes()).unwrap();
1018        let b = pack_longlink(1000000238, 23, &[2; 256]).unwrap();
1019        let both = [a.as_slice(), b.as_slice()].concat();
1020        for cut in 0..a.len() {
1021            let mut decoder = LonglinkDecoder::default();
1022            decoder.feed(&both[..cut]).unwrap();
1023            assert!(decoder.next_packet().unwrap().is_none());
1024            decoder.feed(&both[cut..]).unwrap();
1025            assert_eq!(decoder.next_packet().unwrap().unwrap().command, 24);
1026            assert_eq!(decoder.next_packet().unwrap().unwrap().sequence, 23);
1027            assert!(decoder.next_packet().unwrap().is_none());
1028        }
1029        for n in [0u32, 15, (crate::MAX_MESSAGE_BYTES + 17) as u32, u32::MAX] {
1030            let mut decoder = LonglinkDecoder::default();
1031            decoder.feed(&n.to_be_bytes()).unwrap();
1032            assert!(decoder.next_packet().is_err());
1033        }
1034        let mut invalid = a.clone();
1035        invalid[7] = 2;
1036        let mut decoder = LonglinkDecoder::default();
1037        decoder.feed(&invalid[..8]).unwrap();
1038        assert!(decoder.next_packet().is_err());
1039        let mut limited = LonglinkDecoder {
1040            pending: Vec::new(),
1041            max_payload: 128,
1042        };
1043        limited.feed(&b[..4]).unwrap();
1044        assert!(limited.next_packet().is_err());
1045        let payload = vec![7; 200_000];
1046        let large = [
1047            (payload.len() as u32 + 16).to_be_bytes().to_vec(),
1048            vec![0, 16, 0, 1],
1049            1000000121u32.to_be_bytes().to_vec(),
1050            9u32.to_be_bytes().to_vec(),
1051            payload.clone(),
1052        ]
1053        .concat();
1054        let mut decoder = LonglinkDecoder::default();
1055        for part in large.chunks(20_000) {
1056            decoder.feed(part).unwrap();
1057        }
1058        assert_eq!(decoder.next_packet().unwrap().unwrap().payload, payload);
1059    }
1060    #[test]
1061    fn encrypted_idle_timeout_keeps_partial_record_and_packet_bytes() {
1062        use std::{net::TcpListener, sync::mpsc, thread};
1063        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
1064        let socket = TcpStream::connect(listener.local_addr().unwrap()).unwrap();
1065        let (mut peer, _) = listener.accept().unwrap();
1066        let first = pack_longlink(24, 0, &6u32.to_be_bytes()).unwrap();
1067        let second = pack_longlink(1000000006, u32::MAX, &[]).unwrap();
1068        let key = vec![1; 16];
1069        let iv = vec![2; 12];
1070        let r1 = seal(0x17, &first[..10], &key, &iv, 5).unwrap();
1071        let r2 = seal(0x17, &[first[10..].to_vec(), second].concat(), &key, &iv, 6).unwrap();
1072        let mut corrupt = seal(0x17, &first, &key, &iv, 7).unwrap();
1073        *corrupt.last_mut().unwrap() ^= 1;
1074        let (sent, observed) = mpsc::channel();
1075        let (resume, waiting) = mpsc::channel();
1076        let writer = thread::spawn(move || {
1077            peer.write_all(&r1[..3]).unwrap();
1078            sent.send(()).unwrap();
1079            waiting.recv().unwrap();
1080            peer.write_all(&r1[3..]).unwrap();
1081            peer.write_all(&r2).unwrap();
1082            peer.write_all(&corrupt).unwrap();
1083        });
1084        let mut session = Session {
1085            socket,
1086            deadline: Instant::now(),
1087            received: 0,
1088            receive_budget: 1024,
1089            short: ShortSession {
1090                access_psk: vec![],
1091                ticket: Ticket {
1092                    kind: 1,
1093                    lifetime: 0,
1094                    reserved: 0,
1095                    nonce: vec![],
1096                    opaque: vec![],
1097                },
1098            },
1099            certificate_region: 0,
1100            certificate_version: 0,
1101            traffic: Traffic {
1102                client_key: key.clone(),
1103                server_key: key,
1104                client_iv: iv.clone(),
1105                server_iv: iv,
1106            },
1107            outgoing: 3,
1108            incoming: 5,
1109            record_pending: Vec::new(),
1110            application_pending: LonglinkDecoder::default(),
1111        };
1112        observed.recv().unwrap();
1113        assert!(session
1114            .poll_application(Duration::from_millis(10))
1115            .unwrap()
1116            .is_none());
1117        assert_eq!(session.record_pending.len(), 3);
1118        resume.send(()).unwrap();
1119        assert_eq!(
1120            session
1121                .poll_application(Duration::from_secs(1))
1122                .unwrap()
1123                .unwrap()
1124                .command,
1125            24
1126        );
1127        assert_eq!(
1128            session
1129                .poll_application(Duration::from_secs(1))
1130                .unwrap()
1131                .unwrap()
1132                .sequence,
1133            u32::MAX
1134        );
1135        assert!(session.poll_application(Duration::from_secs(1)).is_err());
1136        assert_eq!(session.incoming, 7);
1137        writer.join().unwrap();
1138    }
1139    #[test]
1140    fn published_mmtls_vector() {
1141        let key = hex::decode("29b37affd98238fb0370c564d8fa992e").unwrap();
1142        let wire_nonce = hex::decode("36ee037a258fbb83ca1f9762").unwrap();
1143        let base = nonce(&wire_nonce, 1).unwrap();
1144        let plain = hex::decode(
1145            "0000002314002009d6fc43a65a48dd64e3b6846562d13752f5abc2cb254539906ecd429df71082",
1146        )
1147        .unwrap();
1148        let expected=hex::decode("16f1040037e4bdea652cd80a273fd2ef549df4c87c1083c23f658fcc2d4152d163bc809f35a56fd0f4a62caa138d765a086eec02e21704892a981cf7").unwrap();
1149        assert_eq!(seal(0x16, &plain, &key, &base, 1).unwrap(), expected);
1150        let r = Record {
1151            header: expected[..5].try_into().unwrap(),
1152            body: expected[5..].to_vec(),
1153        };
1154        assert_eq!(open(&r, &key, &base, 1).unwrap(), plain);
1155        assert!(open(&r, &key, &base, 2).is_err());
1156    }
1157    #[test]
1158    fn hosts_restricted() {
1159        for s in [
1160            "localhost",
1161            "127.0.0.1",
1162            "long.weixin.qq.com.attacker.org",
1163            "-x.wechat.com",
1164            "x.wechat.com:80",
1165        ] {
1166            assert!(validate_host(s).is_err());
1167        }
1168        assert!(validate_host("long.weixin.qq.com").is_ok());
1169    }
1170    #[test]
1171    fn malformed_envelopes() {
1172        assert!(unpack_longlink(&[]).is_err());
1173        assert!(parse_server_hello(&[0; 4]).is_err());
1174        let mut v = pack_longlink(6, 123, &[1, 2]).unwrap();
1175        v[3] ^= 1;
1176        assert!(unpack_longlink(&v).is_err());
1177    }
1178}