blob: b1b2ca2e00dc9766c74ca3bf3503e8145f2b59ec (
plain)
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
/*
* TLS Extensions
* (C) 2011 Jack Lloyd
*
* Released under the terms of the Botan license
*/
#ifndef BOTAN_TLS_EXTENSIONS_H__
#define BOTAN_TLS_EXTENSIONS_H__
#include <botan/secmem.h>
#include <botan/tls_magic.h>
#include <vector>
#include <string>
namespace Botan {
class TLS_Data_Reader;
/**
* Base class representing a TLS extension of some kind
*/
class TLS_Extension
{
public:
virtual TLS_Handshake_Extension_Type type() const = 0;
virtual MemoryVector<byte> serialize() const = 0;
virtual bool empty() const = 0;
virtual ~TLS_Extension() {}
};
/**
* Server Name Indicator extension (RFC 3546)
*/
class Server_Name_Indicator : public TLS_Extension
{
public:
TLS_Handshake_Extension_Type type() const
{ return TLSEXT_SERVER_NAME_INDICATION; }
Server_Name_Indicator(const std::string& host_name) :
sni_host_name(host_name) {}
Server_Name_Indicator(TLS_Data_Reader& reader,
u16bit extension_size);
std::string host_name() const { return sni_host_name; }
MemoryVector<byte> serialize() const;
bool empty() const { return sni_host_name == ""; }
private:
std::string sni_host_name;
};
/**
* SRP identifier extension (RFC 5054)
*/
class SRP_Identifier : public TLS_Extension
{
public:
TLS_Handshake_Extension_Type type() const
{ return TLSEXT_SRP_IDENTIFIER; }
SRP_Identifier(const std::string& identifier) :
srp_identifier(identifier) {}
SRP_Identifier(TLS_Data_Reader& reader,
u16bit extension_size);
std::string identifier() const { return srp_identifier; }
MemoryVector<byte> serialize() const;
bool empty() const { return srp_identifier == ""; }
private:
std::string srp_identifier;
};
/**
* Renegotiation Indication Extension (RFC 5746)
*/
class Renegotation_Extension : public TLS_Extension
{
public:
TLS_Handshake_Extension_Type type() const
{ return TLSEXT_SAFE_RENEGOTIATION; }
Renegotation_Extension() {}
Renegotation_Extension(const MemoryRegion<byte>& bits) :
reneg_data(bits) {}
Renegotation_Extension(TLS_Data_Reader& reader,
u16bit extension_size);
const MemoryVector<byte>& renegotiation_info() const
{ return reneg_data; }
MemoryVector<byte> serialize() const;
bool empty() const { return false; } // always send this
private:
MemoryVector<byte> reneg_data;
};
/**
* Maximum Fragment Length Negotiation Extension (RFC 4366 sec 3.2)
*/
class Maximum_Fragment_Length : public TLS_Extension
{
public:
TLS_Handshake_Extension_Type type() const
{ return TLSEXT_MAX_FRAGMENT_LENGTH; }
bool empty() const { return val != 0; }
size_t fragment_size() const;
MemoryVector<byte> serialize() const
{
return MemoryVector<byte>(&val, 1);
}
/**
* @param max_fragment specifies what maximum fragment size to
* advertise. Currently must be one of 512, 1024, 2048, or
* 4096.
*/
Maximum_Fragment_Length(size_t max_fragment);
Maximum_Fragment_Length(TLS_Data_Reader& reader,
u16bit extension_size);
private:
byte val;
};
/**
* Represents a block of extensions in a hello message
*/
class TLS_Extensions
{
public:
size_t count() const { return extensions.size(); }
TLS_Extension* at(size_t idx) { return extensions.at(idx); }
void push_back(TLS_Extension* extn)
{ extensions.push_back(extn); }
MemoryVector<byte> serialize() const;
TLS_Extensions() {}
TLS_Extensions(TLS_Data_Reader& reader); // deserialize
~TLS_Extensions();
private:
TLS_Extensions(const TLS_Extensions&) {}
TLS_Extensions& operator=(const TLS_Extensions&) { return (*this); }
std::vector<TLS_Extension*> extensions;
};
}
#endif
|
