rustls 0.1.0

Rustls is a modern TLS library written in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99


use std::collections::VecDeque;
use msgs::message::{Message, MessagePayload};

pub const MAX_FRAGMENT_LEN: usize = 16384;
pub const PACKET_OVERHEAD: usize = 1 + 2 + 2;

pub struct MessageFragmenter {
  max_frag: usize
}

impl MessageFragmenter {
  /// Make a new fragmenter.  `max_fragment_len` is the maximum
  /// fragment size that will be produced -- this does not
  /// include overhead (so a `max_fragment_len` of 5 will produce
  /// 10 byte packets).
  pub fn new(max_fragment_len: usize) -> MessageFragmenter {
    assert!(max_fragment_len <= MAX_FRAGMENT_LEN);
    MessageFragmenter {
      max_frag: max_fragment_len
    }
  }

  /// Take the Message `msg` and re-fragment it into new
  /// messages whose fragment is no more than max_frag.
  /// The new messages are appended to the `out` deque.
  pub fn fragment(&self, msg: &Message, out: &mut VecDeque<Message>) {
    // Non-fragment path
    if msg.payload.len() <= self.max_frag {
      out.push_back(msg.to_opaque());
      return;
    }

    let mut payload = Vec::new();
    msg.payload.encode(&mut payload);

    for chunk in payload.chunks(self.max_frag) {
      let cm = Message {
        typ: msg.typ.clone(),
        version: msg.version.clone(),
        payload: MessagePayload::opaque(chunk.to_vec())
      };
      out.push_back(cm);
    }
  }
}

#[cfg(test)]
mod tests {
  use super::{MessageFragmenter, PACKET_OVERHEAD};
  use msgs::message::{MessagePayload, Message};
  use msgs::enums::{ContentType, ProtocolVersion};
  use std::collections::VecDeque;

  fn msg_eq(mm: Option<Message>, total_len: usize, typ: &ContentType, version: &ProtocolVersion, bytes: &[u8]) {
    let m = mm.unwrap();

    assert_eq!(&m.typ, typ);
    assert_eq!(&m.version, version);
    assert_eq!(m.get_opaque_payload().unwrap().0, bytes.to_vec());

    let mut buf = Vec::new();
    m.encode(&mut buf);
    assert_eq!(total_len, buf.len());
  }

  #[test]
  fn smoke() {
    let m = Message {
      typ: ContentType::Handshake,
      version: ProtocolVersion::TLSv1_2,
      payload: MessagePayload::opaque(b"\x01\x02\x03\x04\x05\x06\x07\x08".to_vec())
    };

    let frag = MessageFragmenter::new(3);
    let mut q = VecDeque::new();
    frag.fragment(&m, &mut q);
    msg_eq(q.pop_front(), PACKET_OVERHEAD + 3, &m.typ, &m.version, b"\x01\x02\x03");
    msg_eq(q.pop_front(), PACKET_OVERHEAD + 3, &m.typ, &m.version, b"\x04\x05\x06");
    msg_eq(q.pop_front(), PACKET_OVERHEAD + 2, &m.typ, &m.version, b"\x07\x08");
    assert_eq!(q.len(), 0);
  }

  #[test]
  fn non_fragment() {
    let m = Message {
      typ: ContentType::Handshake,
      version: ProtocolVersion::TLSv1_2,
      payload: MessagePayload::opaque(b"\x01\x02\x03\x04\x05\x06\x07\x08".to_vec())
    };

    let frag = MessageFragmenter::new(8);
    let mut q = VecDeque::new();
    frag.fragment(&m, &mut q);
    msg_eq(q.pop_front(), PACKET_OVERHEAD + 8,
           &m.typ, &m.version, b"\x01\x02\x03\x04\x05\x06\x07\x08");
    assert_eq!(q.len(), 0);
  }
}