Botan 3.9.0
Crypto and TLS for C&
tls_reader.h
Go to the documentation of this file.
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/internal/fmt.h>
14#include <botan/internal/loadstor.h>
15#include <botan/internal/mem_utils.h>
16#include <span>
17#include <string>
18#include <vector>
19
20namespace Botan::TLS {
21
22/**
23* Helper class for decoding TLS protocol messages
24*/
25class TLS_Data_Reader final {
26 public:
27 TLS_Data_Reader(const char* type, std::span<const uint8_t> buf_in) :
28 m_typename(type), m_buf(buf_in), m_offset(0) {}
29
30 void assert_done() const {
31 if(has_remaining()) {
32 throw_decode_error("Extra bytes at end of message");
33 }
34 }
35
36 size_t read_so_far() const { return m_offset; }
37
38 size_t remaining_bytes() const { return m_buf.size() - m_offset; }
39
40 bool has_remaining() const { return (remaining_bytes() > 0); }
41
42 std::vector<uint8_t> get_remaining() {
43 std::span rest = m_buf.subspan(m_offset);
44 return std::vector<uint8_t>(rest.begin(), rest.end());
45 }
46
47 std::vector<uint8_t> get_data_read_so_far() {
48 std::span first = m_buf.first(m_offset);
49 return std::vector<uint8_t>(first.begin(), first.end());
50 }
51
52 void discard_next(size_t bytes) {
53 assert_at_least(bytes);
54 m_offset += bytes;
55 }
56
57 uint32_t get_uint32_t() {
58 assert_at_least(4);
59 uint32_t result = make_uint32(m_buf[m_offset], m_buf[m_offset + 1], m_buf[m_offset + 2], m_buf[m_offset + 3]);
60 m_offset += 4;
61 return result;
62 }
63
64 uint32_t get_uint24_t() {
65 assert_at_least(3);
66 uint32_t result = make_uint32(0, m_buf[m_offset], m_buf[m_offset + 1], m_buf[m_offset + 2]);
67 m_offset += 3;
68 return result;
69 }
70
71 uint16_t get_uint16_t() {
72 assert_at_least(2);
73 uint16_t result = make_uint16(m_buf[m_offset], m_buf[m_offset + 1]);
74 m_offset += 2;
75 return result;
76 }
77
78 uint16_t peek_uint16_t() const {
79 assert_at_least(2);
80 return make_uint16(m_buf[m_offset], m_buf[m_offset + 1]);
81 }
82
83 uint8_t get_byte() {
84 assert_at_least(1);
85 uint8_t result = m_buf[m_offset];
86 m_offset += 1;
87 return result;
88 }
89
90 template <typename T, typename Container>
91 Container get_elem(size_t num_elems) {
92 assert_at_least(num_elems * sizeof(T));
93
94 Container result(num_elems);
95
96 for(size_t i = 0; i != num_elems; ++i) {
97 result[i] = load_be<T>(&m_buf[m_offset], i);
98 }
99
100 m_offset += num_elems * sizeof(T);
101
102 return result;
103 }
104
105 std::vector<uint8_t> get_tls_length_value(size_t len_bytes) {
106 return get_fixed<uint8_t>(get_length_field(len_bytes));
107 }
108
109 template <typename T>
110 std::vector<T> get_range(size_t len_bytes, size_t min_elems, size_t max_elems) {
111 const size_t num_elems = get_num_elems(len_bytes, sizeof(T), min_elems, max_elems);
112
113 return get_elem<T, std::vector<T>>(num_elems);
114 }
115
116 template <typename T>
117 std::vector<T> get_range_vector(size_t len_bytes, size_t min_elems, size_t max_elems) {
118 const size_t num_elems = get_num_elems(len_bytes, sizeof(T), min_elems, max_elems);
119
120 return get_elem<T, std::vector<T>>(num_elems);
121 }
122
123 std::string get_string(size_t len_bytes, size_t min_bytes, size_t max_bytes) {
124 std::vector<uint8_t> v = get_range_vector<uint8_t>(len_bytes, min_bytes, max_bytes);
125 return bytes_to_string(v);
126 }
127
128 template <typename T>
129 std::vector<T> get_fixed(size_t size) {
130 return get_elem<T, std::vector<T>>(size);
131 }
132
133 private:
134 size_t get_length_field(size_t len_bytes) {
135 assert_at_least(len_bytes);
136
137 if(len_bytes == 1) {
138 return get_byte();
139 } else if(len_bytes == 2) {
140 return get_uint16_t();
141 } else if(len_bytes == 3) {
142 return get_uint24_t();
143 }
144
145 throw_decode_error("Bad length size");
146 }
147
148 size_t get_num_elems(size_t len_bytes, size_t T_size, size_t min_elems, size_t max_elems) {
149 const size_t byte_length = get_length_field(len_bytes);
150
151 if(byte_length % T_size != 0) {
152 throw_decode_error("Size isn't multiple of T");
153 }
154
155 const size_t num_elems = byte_length / T_size;
156
157 if(num_elems < min_elems || num_elems > max_elems) {
158 throw_decode_error("Length field outside parameters");
159 }
160
161 return num_elems;
162 }
163
164 void assert_at_least(size_t n) const {
165 if(m_buf.size() - m_offset < n) {
166 throw_decode_error("Expected " + std::to_string(n) + " bytes remaining, only " +
167 std::to_string(m_buf.size() - m_offset) + " left");
168 }
169 }
170
171 [[noreturn]] void throw_decode_error(std::string_view why) const {
172 throw Decoding_Error(fmt("Invalid {}: {}", m_typename, why));
173 }
174
175 const char* m_typename;
176 std::span<const uint8_t> m_buf;
177 size_t m_offset;
178};
179
180/**
181* Helper function for encoding length-tagged vectors
182*/
183template <typename T, typename Alloc>
184inline void append_tls_length_value(std::vector<uint8_t, Alloc>& buf,
185 const T* vals,
186 size_t vals_size,
187 size_t tag_size) {
188 const size_t T_size = sizeof(T);
189 const size_t val_bytes = T_size * vals_size;
190
191 if(tag_size != 1 && tag_size != 2 && tag_size != 3) {
192 throw Invalid_Argument("append_tls_length_value: invalid tag size");
193 }
194
195 if((tag_size == 1 && val_bytes > 255) || (tag_size == 2 && val_bytes > 65535) ||
196 (tag_size == 3 && val_bytes > 16777215)) {
197 throw Invalid_Argument("append_tls_length_value: value too large");
198 }
199
200 for(size_t i = 0; i != tag_size; ++i) {
201 buf.push_back(get_byte_var(sizeof(val_bytes) - tag_size + i, val_bytes));
202 }
203
204 for(size_t i = 0; i != vals_size; ++i) {
205 for(size_t j = 0; j != T_size; ++j) {
206 buf.push_back(get_byte_var(j, vals[i]));
207 }
208 }
209}
210
211template <typename T, typename Alloc>
212inline void append_tls_length_value(std::vector<uint8_t, Alloc>& buf, std::span<const T> vals, size_t tag_size) {
213 append_tls_length_value(buf, vals.data(), vals.size(), tag_size);
214}
215
216template <typename T, typename Alloc, typename Alloc2>
217inline void append_tls_length_value(std::vector<uint8_t, Alloc>& buf,
218 const std::vector<T, Alloc2>& vals,
219 size_t tag_size) {
220 append_tls_length_value(buf, std::span{vals}, tag_size);
221}
222
223template <typename Alloc>
224inline void append_tls_length_value(std::vector<uint8_t, Alloc>& buf, std::string_view str, size_t tag_size) {
225 append_tls_length_value(buf, as_span_of_bytes(str), tag_size);
226}
227
228} // namespace Botan::TLS
229
230#endif
std::string get_string(size_t len_bytes, size_t min_bytes, size_t max_bytes)
Definition tls_reader.h:123
std::vector< uint8_t > get_remaining()
Definition tls_reader.h:42
size_t read_so_far() const
Definition tls_reader.h:36
void discard_next(size_t bytes)
Definition tls_reader.h:52
TLS_Data_Reader(const char *type, std::span< const uint8_t > buf_in)
Definition tls_reader.h:27
Container get_elem(size_t num_elems)
Definition tls_reader.h:91
std::vector< T > get_range(size_t len_bytes, size_t min_elems, size_t max_elems)
Definition tls_reader.h:110
size_t remaining_bytes() const
Definition tls_reader.h:38
std::vector< uint8_t > get_tls_length_value(size_t len_bytes)
Definition tls_reader.h:105
std::vector< T > get_fixed(size_t size)
Definition tls_reader.h:129
std::vector< uint8_t > get_data_read_so_far()
Definition tls_reader.h:47
uint16_t peek_uint16_t() const
Definition tls_reader.h:78
std::vector< T > get_range_vector(size_t len_bytes, size_t min_elems, size_t max_elems)
Definition tls_reader.h:117
void append_tls_length_value(std::vector< uint8_t, Alloc > &buf, const T *vals, size_t vals_size, size_t tag_size)
Definition tls_reader.h:184
std::span< const uint8_t > as_span_of_bytes(const char *s, size_t len)
Definition mem_utils.h:28
std::string fmt(std::string_view format, const T &... args)
Definition fmt.h:53
std::string bytes_to_string(std::span< const uint8_t > bytes)
Definition mem_utils.h:45
constexpr uint32_t make_uint32(uint8_t i0, uint8_t i1, uint8_t i2, uint8_t i3)
Definition loadstor.h:104
constexpr uint8_t get_byte_var(size_t byte_num, T input)
Definition loadstor.h:69
constexpr auto load_be(ParamTs &&... params)
Definition loadstor.h:504
constexpr uint16_t make_uint16(uint8_t i0, uint8_t i1)
Definition loadstor.h:92