rustls 0.18.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

use crate::msgs::enums::{ContentType, HandshakeType};
use crate::msgs::message::{Message, MessagePayload};
use crate::error::TLSError;
#[cfg(feature = "logging")]
use crate::log::warn;

/// For a Message $m, and a HandshakePayload enum member $payload_type,
/// return Ok(payload) if $m is both a handshake message and one that
/// has the given $payload_type.  If not, return Err(TLSError) quoting
/// $handshake_type as the expected handshake type.
macro_rules! require_handshake_msg(
  ( $m:expr, $handshake_type:path, $payload_type:path ) => (
    match $m.payload {
        MessagePayload::Handshake(ref hsp) => match hsp.payload {
            $payload_type(ref hm) => Ok(hm),
            _ => Err(TLSError::InappropriateHandshakeMessage {
                     expect_types: vec![ $handshake_type ],
                     got_type: hsp.typ})
        }
        _ => Err(TLSError::InappropriateMessage {
                 expect_types: vec![ ContentType::Handshake ],
                 got_type: $m.typ})
    }
  )
);

/// Like require_handshake_msg, but moves the payload out of $m.
macro_rules! require_handshake_msg_mut(
  ( $m:expr, $handshake_type:path, $payload_type:path ) => (
    match $m.payload {
        MessagePayload::Handshake(hsp) => match hsp.payload {
            $payload_type(hm) => Ok(hm),
            _ => Err(TLSError::InappropriateHandshakeMessage {
                     expect_types: vec![ $handshake_type ],
                     got_type: hsp.typ})
        }
        _ => Err(TLSError::InappropriateMessage {
                 expect_types: vec![ ContentType::Handshake ],
                 got_type: $m.typ})
    }
  )
);

/// Validate the message `m`: return an error if:
///
/// - the type of m does not appear in `content_types`.
/// - if m is a handshake message, the handshake message type does
///   not appear in `handshake_types`.
pub fn check_message(m: &Message,
                     content_types: &[ContentType],
                     handshake_types: &[HandshakeType]) -> Result<(), TLSError> {
    if !content_types.contains(&m.typ) {
        warn!("Received a {:?} message while expecting {:?}",
              m.typ,
              content_types);
        return Err(TLSError::InappropriateMessage {
            expect_types: content_types.to_vec(),
            got_type: m.typ,
        });
    }

    if let MessagePayload::Handshake(ref hsp) = m.payload {
        if !handshake_types.is_empty() && !handshake_types.contains(&hsp.typ) {
            warn!("Received a {:?} handshake message while expecting {:?}",
                  hsp.typ,
                  handshake_types);
            return Err(TLSError::InappropriateHandshakeMessage {
                expect_types: handshake_types.to_vec(),
                got_type: hsp.typ,
            });
        }
    }

    Ok(())
}