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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
pub mod extension_server_name;
pub mod extension_supported_elliptic_curves;
pub mod extension_supported_point_formats;
pub mod extension_supported_signature_algorithms;
pub mod extension_use_extended_master_secret;
pub mod extension_use_srtp;
use extension_server_name::*;
use extension_supported_elliptic_curves::*;
use extension_supported_point_formats::*;
use extension_supported_signature_algorithms::*;
use extension_use_extended_master_secret::*;
use extension_use_srtp::*;
use crate::error::*;
use std::io::{Read, Write};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
#[derive(Clone, Debug, PartialEq)]
pub enum ExtensionValue {
ServerName = 0,
SupportedEllipticCurves = 10,
SupportedPointFormats = 11,
SupportedSignatureAlgorithms = 13,
UseSrtp = 14,
UseExtendedMasterSecret = 23,
Unsupported,
}
impl From<u16> for ExtensionValue {
fn from(val: u16) -> Self {
match val {
0 => ExtensionValue::ServerName,
10 => ExtensionValue::SupportedEllipticCurves,
11 => ExtensionValue::SupportedPointFormats,
13 => ExtensionValue::SupportedSignatureAlgorithms,
14 => ExtensionValue::UseSrtp,
23 => ExtensionValue::UseExtendedMasterSecret,
_ => ExtensionValue::Unsupported,
}
}
}
#[derive(PartialEq, Debug, Clone)]
pub enum Extension {
ServerName(ExtensionServerName),
SupportedEllipticCurves(ExtensionSupportedEllipticCurves),
SupportedPointFormats(ExtensionSupportedPointFormats),
SupportedSignatureAlgorithms(ExtensionSupportedSignatureAlgorithms),
UseSrtp(ExtensionUseSrtp),
UseExtendedMasterSecret(ExtensionUseExtendedMasterSecret),
}
impl Extension {
pub fn extension_value(&self) -> ExtensionValue {
match self {
Extension::ServerName(ext) => ext.extension_value(),
Extension::SupportedEllipticCurves(ext) => ext.extension_value(),
Extension::SupportedPointFormats(ext) => ext.extension_value(),
Extension::SupportedSignatureAlgorithms(ext) => ext.extension_value(),
Extension::UseSrtp(ext) => ext.extension_value(),
Extension::UseExtendedMasterSecret(ext) => ext.extension_value(),
}
}
pub fn size(&self) -> usize {
let mut len = 2;
len += match self {
Extension::ServerName(ext) => ext.size(),
Extension::SupportedEllipticCurves(ext) => ext.size(),
Extension::SupportedPointFormats(ext) => ext.size(),
Extension::SupportedSignatureAlgorithms(ext) => ext.size(),
Extension::UseSrtp(ext) => ext.size(),
Extension::UseExtendedMasterSecret(ext) => ext.size(),
};
len
}
pub fn marshal<W: Write>(&self, writer: &mut W) -> Result<(), Error> {
writer.write_u16::<BigEndian>(self.extension_value() as u16)?;
match self {
Extension::ServerName(ext) => ext.marshal(writer),
Extension::SupportedEllipticCurves(ext) => ext.marshal(writer),
Extension::SupportedPointFormats(ext) => ext.marshal(writer),
Extension::SupportedSignatureAlgorithms(ext) => ext.marshal(writer),
Extension::UseSrtp(ext) => ext.marshal(writer),
Extension::UseExtendedMasterSecret(ext) => ext.marshal(writer),
}
}
pub fn unmarshal<R: Read>(reader: &mut R) -> Result<Self, Error> {
let extension_value: ExtensionValue = reader.read_u16::<BigEndian>()?.into();
match extension_value {
ExtensionValue::ServerName => Ok(Extension::ServerName(
ExtensionServerName::unmarshal(reader)?,
)),
ExtensionValue::SupportedEllipticCurves => Ok(Extension::SupportedEllipticCurves(
ExtensionSupportedEllipticCurves::unmarshal(reader)?,
)),
ExtensionValue::SupportedPointFormats => Ok(Extension::SupportedPointFormats(
ExtensionSupportedPointFormats::unmarshal(reader)?,
)),
ExtensionValue::SupportedSignatureAlgorithms => {
Ok(Extension::SupportedSignatureAlgorithms(
ExtensionSupportedSignatureAlgorithms::unmarshal(reader)?,
))
}
ExtensionValue::UseSrtp => Ok(Extension::UseSrtp(ExtensionUseSrtp::unmarshal(reader)?)),
ExtensionValue::UseExtendedMasterSecret => Ok(Extension::UseExtendedMasterSecret(
ExtensionUseExtendedMasterSecret::unmarshal(reader)?,
)),
_ => Err(Error::ErrInvalidExtensionType),
}
}
}