1use 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 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 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 §ion(&[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 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 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#[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 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 §ion(&[0, 1, 1]),
795 &keys[..16],
796 &keys[16..],
797 sequence,
798 )?);
799 Ok((hello, extensions, wire))
800}
801
802pub(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 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}