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