Coverage Report

Created: 2020-02-14 15:38

/src/botan/build/include/botan/internal/tls_reader.h
Line
Count
Source (jump to first uncovered line)
1
/*
2
* TLS Data Reader
3
* (C) 2010-2011,2014 Jack Lloyd
4
*
5
* Botan is released under the Simplified BSD License (see license.txt)
6
*/
7
8
#ifndef BOTAN_TLS_READER_H_
9
#define BOTAN_TLS_READER_H_
10
11
#include <botan/exceptn.h>
12
#include <botan/secmem.h>
13
#include <botan/loadstor.h>
14
#include <string>
15
#include <vector>
16
17
namespace Botan {
18
19
namespace TLS {
20
21
/**
22
* Helper class for decoding TLS protocol messages
23
*/
24
class TLS_Data_Reader final
25
   {
26
   public:
27
      TLS_Data_Reader(const char* type, const std::vector<uint8_t>& buf_in) :
28
53.2k
         m_typename(type), m_buf(buf_in), m_offset(0) {}
29
30
      void assert_done() const
31
14.4k
         {
32
14.4k
         if(has_remaining())
33
110
            throw decode_error("Extra bytes at end of message");
34
14.4k
         }
35
36
687
      size_t read_so_far() const { return m_offset; }
37
38
321k
      size_t remaining_bytes() const { return m_buf.size() - m_offset; }
39
40
285k
      bool has_remaining() const { return (remaining_bytes() > 0); }
41
42
      std::vector<uint8_t> get_remaining()
43
0
         {
44
0
         return std::vector<uint8_t>(m_buf.begin() + m_offset, m_buf.end());
45
0
         }
46
47
      void discard_next(size_t bytes)
48
1.11k
         {
49
1.11k
         assert_at_least(bytes);
50
1.11k
         m_offset += bytes;
51
1.11k
         }
52
53
      uint32_t get_uint32_t()
54
6
         {
55
6
         assert_at_least(4);
56
6
         uint32_t result = make_uint32(m_buf[m_offset  ], m_buf[m_offset+1],
57
6
                                     m_buf[m_offset+2], m_buf[m_offset+3]);
58
6
         m_offset += 4;
59
6
         return result;
60
6
         }
61
62
      uint16_t get_uint16_t()
63
655k
         {
64
655k
         assert_at_least(2);
65
655k
         uint16_t result = make_uint16(m_buf[m_offset], m_buf[m_offset+1]);
66
655k
         m_offset += 2;
67
655k
         return result;
68
655k
         }
69
70
      uint8_t get_byte()
71
212k
         {
72
212k
         assert_at_least(1);
73
212k
         uint8_t result = m_buf[m_offset];
74
212k
         m_offset += 1;
75
212k
         return result;
76
212k
         }
77
78
      template<typename T, typename Container>
79
      Container get_elem(size_t num_elems)
80
359k
         {
81
359k
         assert_at_least(num_elems * sizeof(T));
82
359k
83
359k
         Container result(num_elems);
84
359k
85
3.06M
         for(size_t i = 0; i != num_elems; ++i)
86
2.70M
            result[i] = load_be<T>(&m_buf[m_offset], i);
87
359k
88
359k
         m_offset += num_elems * sizeof(T);
89
359k
90
359k
         return result;
91
359k
         }
std::__1::vector<unsigned char, std::__1::allocator<unsigned char> > Botan::TLS::TLS_Data_Reader::get_elem<unsigned char, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> > >(unsigned long)
Line
Count
Source
80
327k
         {
81
327k
         assert_at_least(num_elems * sizeof(T));
82
327k
83
327k
         Container result(num_elems);
84
327k
85
2.95M
         for(size_t i = 0; i != num_elems; ++i)
86
2.63M
            result[i] = load_be<T>(&m_buf[m_offset], i);
87
327k
88
327k
         m_offset += num_elems * sizeof(T);
89
327k
90
327k
         return result;
91
327k
         }
std::__1::vector<unsigned short, std::__1::allocator<unsigned short> > Botan::TLS::TLS_Data_Reader::get_elem<unsigned short, std::__1::vector<unsigned short, std::__1::allocator<unsigned short> > >(unsigned long)
Line
Count
Source
80
32.3k
         {
81
32.3k
         assert_at_least(num_elems * sizeof(T));
82
32.3k
83
32.3k
         Container result(num_elems);
84
32.3k
85
109k
         for(size_t i = 0; i != num_elems; ++i)
86
77.0k
            result[i] = load_be<T>(&m_buf[m_offset], i);
87
32.3k
88
32.3k
         m_offset += num_elems * sizeof(T);
89
32.3k
90
32.3k
         return result;
91
32.3k
         }
92
93
      template<typename T>
94
      std::vector<T> get_range(size_t len_bytes,
95
                               size_t min_elems,
96
                               size_t max_elems)
97
66.1k
         {
98
66.1k
         const size_t num_elems =
99
66.1k
            get_num_elems(len_bytes, sizeof(T), min_elems, max_elems);
100
66.1k
101
66.1k
         return get_elem<T, std::vector<T>>(num_elems);
102
66.1k
         }
std::__1::vector<unsigned char, std::__1::allocator<unsigned char> > Botan::TLS::TLS_Data_Reader::get_range<unsigned char>(unsigned long, unsigned long, unsigned long)
Line
Count
Source
97
65.9k
         {
98
65.9k
         const size_t num_elems =
99
65.9k
            get_num_elems(len_bytes, sizeof(T), min_elems, max_elems);
100
65.9k
101
65.9k
         return get_elem<T, std::vector<T>>(num_elems);
102
65.9k
         }
std::__1::vector<unsigned short, std::__1::allocator<unsigned short> > Botan::TLS::TLS_Data_Reader::get_range<unsigned short>(unsigned long, unsigned long, unsigned long)
Line
Count
Source
97
239
         {
98
239
         const size_t num_elems =
99
239
            get_num_elems(len_bytes, sizeof(T), min_elems, max_elems);
100
239
101
239
         return get_elem<T, std::vector<T>>(num_elems);
102
239
         }
103
104
      template<typename T>
105
      std::vector<T> get_range_vector(size_t len_bytes,
106
                                      size_t min_elems,
107
                                      size_t max_elems)
108
110k
         {
109
110k
         const size_t num_elems =
110
110k
            get_num_elems(len_bytes, sizeof(T), min_elems, max_elems);
111
110k
112
110k
         return get_elem<T, std::vector<T>>(num_elems);
113
110k
         }
std::__1::vector<unsigned char, std::__1::allocator<unsigned char> > Botan::TLS::TLS_Data_Reader::get_range_vector<unsigned char>(unsigned long, unsigned long, unsigned long)
Line
Count
Source
108
78.5k
         {
109
78.5k
         const size_t num_elems =
110
78.5k
            get_num_elems(len_bytes, sizeof(T), min_elems, max_elems);
111
78.5k
112
78.5k
         return get_elem<T, std::vector<T>>(num_elems);
113
78.5k
         }
std::__1::vector<unsigned short, std::__1::allocator<unsigned short> > Botan::TLS::TLS_Data_Reader::get_range_vector<unsigned short>(unsigned long, unsigned long, unsigned long)
Line
Count
Source
108
32.1k
         {
109
32.1k
         const size_t num_elems =
110
32.1k
            get_num_elems(len_bytes, sizeof(T), min_elems, max_elems);
111
32.1k
112
32.1k
         return get_elem<T, std::vector<T>>(num_elems);
113
32.1k
         }
114
115
      std::string get_string(size_t len_bytes,
116
                             size_t min_bytes,
117
                             size_t max_bytes)
118
46.2k
         {
119
46.2k
         std::vector<uint8_t> v =
120
46.2k
            get_range_vector<uint8_t>(len_bytes, min_bytes, max_bytes);
121
46.2k
122
46.2k
         return std::string(cast_uint8_ptr_to_char(v.data()), v.size());
123
46.2k
         }
124
125
      template<typename T>
126
      std::vector<T> get_fixed(size_t size)
127
180k
         {
128
180k
         return get_elem<T, std::vector<T>>(size);
129
180k
         }
130
131
   private:
132
      size_t get_length_field(size_t len_bytes)
133
176k
         {
134
176k
         assert_at_least(len_bytes);
135
176k
136
176k
         if(len_bytes == 1)
137
124k
            return get_byte();
138
52.0k
         else if(len_bytes == 2)
139
51.8k
            return get_uint16_t();
140
248
141
248
         throw decode_error("Bad length size");
142
248
         }
143
144
      size_t get_num_elems(size_t len_bytes,
145
                           size_t T_size,
146
                           size_t min_elems,
147
                           size_t max_elems)
148
176k
         {
149
176k
         const size_t byte_length = get_length_field(len_bytes);
150
176k
151
176k
         if(byte_length % T_size != 0)
152
25
            throw decode_error("Size isn't multiple of T");
153
176k
154
176k
         const size_t num_elems = byte_length / T_size;
155
176k
156
176k
         if(num_elems < min_elems || num_elems > max_elems)
157
141
            throw decode_error("Length field outside parameters");
158
176k
159
176k
         return num_elems;
160
176k
         }
161
162
      void assert_at_least(size_t n) const
163
1.40M
         {
164
1.40M
         if(m_buf.size() - m_offset < n)
165
1.26k
            throw decode_error("Expected " + std::to_string(n) +
166
1.26k
                               " bytes remaining, only " +
167
1.26k
                               std::to_string(m_buf.size()-m_offset) +
168
1.26k
                               " left");
169
1.40M
         }
170
171
      Decoding_Error decode_error(const std::string& why) const
172
1.54k
         {
173
1.54k
         return Decoding_Error("Invalid " + std::string(m_typename) + ": " + why);
174
1.54k
         }
175
176
      const char* m_typename;
177
      const std::vector<uint8_t>& m_buf;
178
      size_t m_offset;
179
   };
180
181
/**
182
* Helper function for encoding length-tagged vectors
183
*/
184
template<typename T, typename Alloc>
185
void append_tls_length_value(std::vector<uint8_t, Alloc>& buf,
186
                             const T* vals,
187
                             size_t vals_size,
188
                             size_t tag_size)
189
156k
   {
190
156k
   const size_t T_size = sizeof(T);
191
156k
   const size_t val_bytes = T_size * vals_size;
192
156k
193
156k
   if(tag_size != 1 && tag_size != 2)
194
0
      throw Invalid_Argument("append_tls_length_value: invalid tag size");
195
156k
196
156k
   if((tag_size == 1 && val_bytes > 255) ||
197
156k
      (tag_size == 2 && val_bytes > 65535))
198
0
      throw Invalid_Argument("append_tls_length_value: value too large");
199
156k
200
393k
   for(size_t i = 0; i != tag_size; ++i)
201
236k
      buf.push_back(get_byte(sizeof(val_bytes)-tag_size+i, val_bytes));
202
156k
203
9.79M
   for(size_t i = 0; i != vals_size; ++i)
204
20.3M
      for(size_t j = 0; j != T_size; ++j)
205
10.6M
         buf.push_back(get_byte(j, vals[i]));
206
156k
   }
void Botan::TLS::append_tls_length_value<unsigned char, std::__1::allocator<unsigned char> >(std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >&, unsigned char const*, unsigned long, unsigned long)
Line
Count
Source
189
117k
   {
190
117k
   const size_t T_size = sizeof(T);
191
117k
   const size_t val_bytes = T_size * vals_size;
192
117k
193
117k
   if(tag_size != 1 && tag_size != 2)
194
0
      throw Invalid_Argument("append_tls_length_value: invalid tag size");
195
117k
196
117k
   if((tag_size == 1 && val_bytes > 255) ||
197
117k
      (tag_size == 2 && val_bytes > 65535))
198
0
      throw Invalid_Argument("append_tls_length_value: value too large");
199
117k
200
275k
   for(size_t i = 0; i != tag_size; ++i)
201
157k
      buf.push_back(get_byte(sizeof(val_bytes)-tag_size+i, val_bytes));
202
117k
203
7.37M
   for(size_t i = 0; i != vals_size; ++i)
204
14.5M
      for(size_t j = 0; j != T_size; ++j)
205
7.25M
         buf.push_back(get_byte(j, vals[i]));
206
117k
   }
void Botan::TLS::append_tls_length_value<unsigned short, std::__1::allocator<unsigned char> >(std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >&, unsigned short const*, unsigned long, unsigned long)
Line
Count
Source
189
12.5k
   {
190
12.5k
   const size_t T_size = sizeof(T);
191
12.5k
   const size_t val_bytes = T_size * vals_size;
192
12.5k
193
12.5k
   if(tag_size != 1 && tag_size != 2)
194
0
      throw Invalid_Argument("append_tls_length_value: invalid tag size");
195
12.5k
196
12.5k
   if((tag_size == 1 && val_bytes > 255) ||
197
12.5k
      (tag_size == 2 && val_bytes > 65535))
198
0
      throw Invalid_Argument("append_tls_length_value: value too large");
199
12.5k
200
37.6k
   for(size_t i = 0; i != tag_size; ++i)
201
25.0k
      buf.push_back(get_byte(sizeof(val_bytes)-tag_size+i, val_bytes));
202
12.5k
203
1.04M
   for(size_t i = 0; i != vals_size; ++i)
204
3.09M
      for(size_t j = 0; j != T_size; ++j)
205
2.06M
         buf.push_back(get_byte(j, vals[i]));
206
12.5k
   }
void Botan::TLS::append_tls_length_value<unsigned char, Botan::secure_allocator<unsigned char> >(std::__1::vector<unsigned char, Botan::secure_allocator<unsigned char> >&, unsigned char const*, unsigned long, unsigned long)
Line
Count
Source
189
26.6k
   {
190
26.6k
   const size_t T_size = sizeof(T);
191
26.6k
   const size_t val_bytes = T_size * vals_size;
192
26.6k
193
26.6k
   if(tag_size != 1 && tag_size != 2)
194
0
      throw Invalid_Argument("append_tls_length_value: invalid tag size");
195
26.6k
196
26.6k
   if((tag_size == 1 && val_bytes > 255) ||
197
26.6k
      (tag_size == 2 && val_bytes > 65535))
198
0
      throw Invalid_Argument("append_tls_length_value: value too large");
199
26.6k
200
79.8k
   for(size_t i = 0; i != tag_size; ++i)
201
53.2k
      buf.push_back(get_byte(sizeof(val_bytes)-tag_size+i, val_bytes));
202
26.6k
203
1.36M
   for(size_t i = 0; i != vals_size; ++i)
204
2.68M
      for(size_t j = 0; j != T_size; ++j)
205
1.34M
         buf.push_back(get_byte(j, vals[i]));
206
26.6k
   }
207
208
template<typename T, typename Alloc, typename Alloc2>
209
void append_tls_length_value(std::vector<uint8_t, Alloc>& buf,
210
                             const std::vector<T, Alloc2>& vals,
211
                             size_t tag_size)
212
133k
   {
213
133k
   append_tls_length_value(buf, vals.data(), vals.size(), tag_size);
214
133k
   }
void Botan::TLS::append_tls_length_value<unsigned char, std::__1::allocator<unsigned char>, std::__1::allocator<unsigned char> >(std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >&, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> > const&, unsigned long)
Line
Count
Source
212
94.7k
   {
213
94.7k
   append_tls_length_value(buf, vals.data(), vals.size(), tag_size);
214
94.7k
   }
Unexecuted instantiation: void Botan::TLS::append_tls_length_value<unsigned char, std::__1::allocator<unsigned char>, Botan::secure_allocator<unsigned char> >(std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >&, std::__1::vector<unsigned char, Botan::secure_allocator<unsigned char> > const&, unsigned long)
void Botan::TLS::append_tls_length_value<unsigned short, std::__1::allocator<unsigned char>, std::__1::allocator<unsigned short> >(std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >&, std::__1::vector<unsigned short, std::__1::allocator<unsigned short> > const&, unsigned long)
Line
Count
Source
212
12.5k
   {
213
12.5k
   append_tls_length_value(buf, vals.data(), vals.size(), tag_size);
214
12.5k
   }
void Botan::TLS::append_tls_length_value<unsigned char, Botan::secure_allocator<unsigned char>, std::__1::allocator<unsigned char> >(std::__1::vector<unsigned char, Botan::secure_allocator<unsigned char> >&, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> > const&, unsigned long)
Line
Count
Source
212
1.17k
   {
213
1.17k
   append_tls_length_value(buf, vals.data(), vals.size(), tag_size);
214
1.17k
   }
void Botan::TLS::append_tls_length_value<unsigned char, Botan::secure_allocator<unsigned char>, Botan::secure_allocator<unsigned char> >(std::__1::vector<unsigned char, Botan::secure_allocator<unsigned char> >&, std::__1::vector<unsigned char, Botan::secure_allocator<unsigned char> > const&, unsigned long)
Line
Count
Source
212
25.4k
   {
213
25.4k
   append_tls_length_value(buf, vals.data(), vals.size(), tag_size);
214
25.4k
   }
215
216
template<typename Alloc>
217
void append_tls_length_value(std::vector<uint8_t, Alloc>& buf,
218
                             const std::string& str,
219
                             size_t tag_size)
220
19.8k
   {
221
19.8k
   append_tls_length_value(buf,
222
19.8k
                           cast_char_ptr_to_uint8(str.data()),
223
19.8k
                           str.size(),
224
19.8k
                           tag_size);
225
19.8k
   }
226
227
}
228
229
}
230
231
#endif