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;
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 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 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 §ion(&[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 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 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#[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, §ion(&[0, 1, 1]), &keys[..16], &keys[16..], 3)?,
781 ]
782 .concat();
783 Ok((hello, extensions, wire))
784}
785
786pub(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 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}