Coverage Report

Created: 2021-02-21 07:20

/src/botan/build/include/botan/mem_ops.h
Line
Count
Source (jump to first uncovered line)
1
/*
2
* Memory Operations
3
* (C) 1999-2009,2012,2015 Jack Lloyd
4
*
5
* Botan is released under the Simplified BSD License (see license.txt)
6
*/
7
8
#ifndef BOTAN_MEMORY_OPS_H_
9
#define BOTAN_MEMORY_OPS_H_
10
11
#include <botan/types.h>
12
#include <cstring>
13
#include <type_traits>
14
#include <vector>
15
16
namespace Botan {
17
18
/**
19
* Allocate a memory buffer by some method. This should only be used for
20
* primitive types (uint8_t, uint32_t, etc).
21
*
22
* @param elems the number of elements
23
* @param elem_size the size of each element
24
* @return pointer to allocated and zeroed memory, or throw std::bad_alloc on failure
25
*/
26
BOTAN_PUBLIC_API(2,3) BOTAN_MALLOC_FN void* allocate_memory(size_t elems, size_t elem_size);
27
28
/**
29
* Free a pointer returned by allocate_memory
30
* @param p the pointer returned by allocate_memory
31
* @param elems the number of elements, as passed to allocate_memory
32
* @param elem_size the size of each element, as passed to allocate_memory
33
*/
34
BOTAN_PUBLIC_API(2,3) void deallocate_memory(void* p, size_t elems, size_t elem_size);
35
36
/**
37
* Ensure the allocator is initialized
38
*/
39
void BOTAN_UNSTABLE_API initialize_allocator();
40
41
class Allocator_Initializer
42
   {
43
   public:
44
9
      Allocator_Initializer() { initialize_allocator(); }
45
   };
46
47
/**
48
* Scrub memory contents in a way that a compiler should not elide,
49
* using some system specific technique. Note that this function might
50
* not zero the memory (for example, in some hypothetical
51
* implementation it might combine the memory contents with the output
52
* of a system PRNG), but if you can detect any difference in behavior
53
* at runtime then the clearing is side-effecting and you can just
54
* use `clear_mem`.
55
*
56
* Use this function to scrub memory just before deallocating it, or on
57
* a stack buffer before returning from the function.
58
*
59
* @param ptr a pointer to memory to scrub
60
* @param n the number of bytes pointed to by ptr
61
*/
62
BOTAN_PUBLIC_API(2,0) void secure_scrub_memory(void* ptr, size_t n);
63
64
/**
65
* Memory comparison, input insensitive
66
* @param x a pointer to an array
67
* @param y a pointer to another array
68
* @param len the number of Ts in x and y
69
* @return 0xFF iff x[i] == y[i] forall i in [0...n) or 0x00 otherwise
70
*/
71
BOTAN_PUBLIC_API(2,9) uint8_t ct_compare_u8(const uint8_t x[],
72
                                            const uint8_t y[],
73
                                            size_t len);
74
75
/**
76
* Memory comparison, input insensitive
77
* @param x a pointer to an array
78
* @param y a pointer to another array
79
* @param len the number of Ts in x and y
80
* @return true iff x[i] == y[i] forall i in [0...n)
81
*/
82
inline bool constant_time_compare(const uint8_t x[],
83
                                  const uint8_t y[],
84
                                  size_t len)
85
865
   {
86
865
   return ct_compare_u8(x, y, len) == 0xFF;
87
865
   }
88
89
/**
90
* Zero out some bytes. Warning: use secure_scrub_memory instead if the
91
* memory is about to be freed or otherwise the compiler thinks it can
92
* elide the writes.
93
*
94
* @param ptr a pointer to memory to zero
95
* @param bytes the number of bytes to zero in ptr
96
*/
97
inline constexpr void clear_bytes(void* ptr, size_t bytes)
98
975M
   {
99
975M
   if(bytes > 0)
100
864M
      {
101
864M
      std::memset(ptr, 0, bytes);
102
864M
      }
103
975M
   }
104
105
/**
106
* Zero memory before use. This simply calls memset and should not be
107
* used in cases where the compiler cannot see the call as a
108
* side-effecting operation (for example, if calling clear_mem before
109
* deallocating memory, the compiler would be allowed to omit the call
110
* to memset entirely under the as-if rule.)
111
*
112
* @param ptr a pointer to an array of Ts to zero
113
* @param n the number of Ts pointed to by ptr
114
*/
115
template<typename T> inline constexpr void clear_mem(T* ptr, size_t n)
116
975M
   {
117
975M
   clear_bytes(ptr, sizeof(T)*n);
118
975M
   }
void Botan::clear_mem<unsigned char>(unsigned char*, unsigned long)
Line
Count
Source
116
1.06M
   {
117
1.06M
   clear_bytes(ptr, sizeof(T)*n);
118
1.06M
   }
void Botan::clear_mem<unsigned long>(unsigned long*, unsigned long)
Line
Count
Source
116
974M
   {
117
974M
   clear_bytes(ptr, sizeof(T)*n);
118
974M
   }
void Botan::clear_mem<unsigned int>(unsigned int*, unsigned long)
Line
Count
Source
116
49.7k
   {
117
49.7k
   clear_bytes(ptr, sizeof(T)*n);
118
49.7k
   }
Unexecuted instantiation: void Botan::clear_mem<unsigned short>(unsigned short*, unsigned long)
Unexecuted instantiation: void Botan::clear_mem<addrinfo>(addrinfo*, unsigned long)
void Botan::clear_mem<int>(int*, unsigned long)
Line
Count
Source
116
188k
   {
117
188k
   clear_bytes(ptr, sizeof(T)*n);
118
188k
   }
119
120
/**
121
* Copy memory
122
* @param out the destination array
123
* @param in the source array
124
* @param n the number of elements of in/out
125
*/
126
template<typename T> inline constexpr void copy_mem(T* out, const T* in, size_t n)
127
282M
   {
128
282M
   static_assert(std::is_trivial<typename std::decay<T>::type>::value, "");
129
282M
   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr,
130
282M
                            "If n > 0 then args are not null");
131
132
282M
   if(in != nullptr && out != nullptr && n > 0)
133
281M
      {
134
281M
      std::memmove(out, in, sizeof(T)*n);
135
281M
      }
136
282M
   }
void Botan::copy_mem<unsigned char>(unsigned char*, unsigned char const*, unsigned long)
Line
Count
Source
127
32.2M
   {
128
32.2M
   static_assert(std::is_trivial<typename std::decay<T>::type>::value, "");
129
32.2M
   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr,
130
32.2M
                            "If n > 0 then args are not null");
131
132
32.2M
   if(in != nullptr && out != nullptr && n > 0)
133
31.7M
      {
134
31.7M
      std::memmove(out, in, sizeof(T)*n);
135
31.7M
      }
136
32.2M
   }
void Botan::copy_mem<unsigned long>(unsigned long*, unsigned long const*, unsigned long)
Line
Count
Source
127
249M
   {
128
249M
   static_assert(std::is_trivial<typename std::decay<T>::type>::value, "");
129
249M
   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr,
130
249M
                            "If n > 0 then args are not null");
131
132
249M
   if(in != nullptr && out != nullptr && n > 0)
133
249M
      {
134
249M
      std::memmove(out, in, sizeof(T)*n);
135
249M
      }
136
249M
   }
Unexecuted instantiation: void Botan::copy_mem<unsigned int>(unsigned int*, unsigned int const*, unsigned long)
Unexecuted instantiation: void Botan::copy_mem<unsigned short>(unsigned short*, unsigned short const*, unsigned long)
void Botan::copy_mem<int>(int*, int const*, unsigned long)
Line
Count
Source
127
9.24k
   {
128
9.24k
   static_assert(std::is_trivial<typename std::decay<T>::type>::value, "");
129
9.24k
   BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr,
130
9.24k
                            "If n > 0 then args are not null");
131
132
9.24k
   if(in != nullptr && out != nullptr && n > 0)
133
9.24k
      {
134
9.24k
      std::memmove(out, in, sizeof(T)*n);
135
9.24k
      }
136
9.24k
   }
137
138
template<typename T> inline constexpr void typecast_copy(uint8_t out[], T in[], size_t N)
139
3.96M
   {
140
3.96M
   static_assert(std::is_trivially_copyable<T>::value, "Safe to memcpy");
141
3.96M
   std::memcpy(out, in, sizeof(T)*N);
142
3.96M
   }
void Botan::typecast_copy<unsigned long>(unsigned char*, unsigned long*, unsigned long)
Line
Count
Source
139
1.44M
   {
140
1.44M
   static_assert(std::is_trivially_copyable<T>::value, "Safe to memcpy");
141
1.44M
   std::memcpy(out, in, sizeof(T)*N);
142
1.44M
   }
void Botan::typecast_copy<unsigned int>(unsigned char*, unsigned int*, unsigned long)
Line
Count
Source
139
2.51M
   {
140
2.51M
   static_assert(std::is_trivially_copyable<T>::value, "Safe to memcpy");
141
2.51M
   std::memcpy(out, in, sizeof(T)*N);
142
2.51M
   }
void Botan::typecast_copy<unsigned short>(unsigned char*, unsigned short*, unsigned long)
Line
Count
Source
139
11
   {
140
11
   static_assert(std::is_trivially_copyable<T>::value, "Safe to memcpy");
141
11
   std::memcpy(out, in, sizeof(T)*N);
142
11
   }
143
144
template<typename T> inline constexpr void typecast_copy(T out[], const uint8_t in[], size_t N)
145
18.3M
   {
146
18.3M
   static_assert(std::is_trivial<T>::value, "Safe to memcpy");
147
18.3M
   std::memcpy(out, in, sizeof(T)*N);
148
18.3M
   }
void Botan::typecast_copy<unsigned long>(unsigned long*, unsigned char const*, unsigned long)
Line
Count
Source
145
5.90M
   {
146
5.90M
   static_assert(std::is_trivial<T>::value, "Safe to memcpy");
147
5.90M
   std::memcpy(out, in, sizeof(T)*N);
148
5.90M
   }
void Botan::typecast_copy<unsigned short>(unsigned short*, unsigned char const*, unsigned long)
Line
Count
Source
145
127k
   {
146
127k
   static_assert(std::is_trivial<T>::value, "Safe to memcpy");
147
127k
   std::memcpy(out, in, sizeof(T)*N);
148
127k
   }
void Botan::typecast_copy<unsigned int>(unsigned int*, unsigned char const*, unsigned long)
Line
Count
Source
145
12.2M
   {
146
12.2M
   static_assert(std::is_trivial<T>::value, "Safe to memcpy");
147
12.2M
   std::memcpy(out, in, sizeof(T)*N);
148
12.2M
   }
149
150
template<typename T> inline constexpr void typecast_copy(uint8_t out[], T in)
151
3.89M
   {
152
3.89M
   typecast_copy(out, &in, 1);
153
3.89M
   }
void Botan::typecast_copy<unsigned int>(unsigned char*, unsigned int)
Line
Count
Source
151
2.51M
   {
152
2.51M
   typecast_copy(out, &in, 1);
153
2.51M
   }
void Botan::typecast_copy<unsigned short>(unsigned char*, unsigned short)
Line
Count
Source
151
11
   {
152
11
   typecast_copy(out, &in, 1);
153
11
   }
void Botan::typecast_copy<unsigned long>(unsigned char*, unsigned long)
Line
Count
Source
151
1.37M
   {
152
1.37M
   typecast_copy(out, &in, 1);
153
1.37M
   }
154
155
template<typename T> inline constexpr void typecast_copy(T& out, const uint8_t in[])
156
18.1M
   {
157
18.1M
   static_assert(std::is_trivial<typename std::decay<T>::type>::value, "Safe case");
158
18.1M
   typecast_copy(&out, in, 1);
159
18.1M
   }
void Botan::typecast_copy<unsigned short>(unsigned short&, unsigned char const*)
Line
Count
Source
156
127k
   {
157
127k
   static_assert(std::is_trivial<typename std::decay<T>::type>::value, "Safe case");
158
127k
   typecast_copy(&out, in, 1);
159
127k
   }
void Botan::typecast_copy<unsigned int>(unsigned int&, unsigned char const*)
Line
Count
Source
156
12.2M
   {
157
12.2M
   static_assert(std::is_trivial<typename std::decay<T>::type>::value, "Safe case");
158
12.2M
   typecast_copy(&out, in, 1);
159
12.2M
   }
void Botan::typecast_copy<unsigned long>(unsigned long&, unsigned char const*)
Line
Count
Source
156
5.74M
   {
157
5.74M
   static_assert(std::is_trivial<typename std::decay<T>::type>::value, "Safe case");
158
5.74M
   typecast_copy(&out, in, 1);
159
5.74M
   }
160
161
template <class To, class From> inline constexpr To typecast_copy(const From *src) noexcept
162
   {
163
   static_assert(std::is_trivially_copyable<From>::value && std::is_trivial<To>::value, "Safe for memcpy");
164
   To dst;
165
   std::memcpy(&dst, src, sizeof(To));
166
   return dst;
167
   }
168
169
/**
170
* Set memory to a fixed value
171
* @param ptr a pointer to an array of bytes
172
* @param n the number of Ts pointed to by ptr
173
* @param val the value to set each byte to
174
*/
175
inline constexpr void set_mem(uint8_t* ptr, size_t n, uint8_t val)
176
5.86k
   {
177
5.86k
   if(n > 0)
178
5.86k
      {
179
5.86k
      std::memset(ptr, val, n);
180
5.86k
      }
181
5.86k
   }
182
183
inline const uint8_t* cast_char_ptr_to_uint8(const char* s)
184
87.9k
   {
185
87.9k
   return reinterpret_cast<const uint8_t*>(s);
186
87.9k
   }
187
188
inline const char* cast_uint8_ptr_to_char(const uint8_t* b)
189
179k
   {
190
179k
   return reinterpret_cast<const char*>(b);
191
179k
   }
192
193
inline uint8_t* cast_char_ptr_to_uint8(char* s)
194
0
   {
195
0
   return reinterpret_cast<uint8_t*>(s);
196
0
   }
197
198
inline char* cast_uint8_ptr_to_char(uint8_t* b)
199
52.1k
   {
200
52.1k
   return reinterpret_cast<char*>(b);
201
52.1k
   }
202
203
/**
204
* Memory comparison, input insensitive
205
* @param p1 a pointer to an array
206
* @param p2 a pointer to another array
207
* @param n the number of Ts in p1 and p2
208
* @return true iff p1[i] == p2[i] forall i in [0...n)
209
*/
210
template<typename T> inline bool same_mem(const T* p1, const T* p2, size_t n)
211
537
   {
212
537
   volatile T difference = 0;
213
214
21.1k
   for(size_t i = 0; i != n; ++i)
215
20.6k
      difference |= (p1[i] ^ p2[i]);
216
217
537
   return difference == 0;
218
537
   }
bool Botan::same_mem<unsigned int>(unsigned int const*, unsigned int const*, unsigned long)
Line
Count
Source
211
22
   {
212
22
   volatile T difference = 0;
213
214
88
   for(size_t i = 0; i != n; ++i)
215
66
      difference |= (p1[i] ^ p2[i]);
216
217
22
   return difference == 0;
218
22
   }
bool Botan::same_mem<unsigned char>(unsigned char const*, unsigned char const*, unsigned long)
Line
Count
Source
211
515
   {
212
515
   volatile T difference = 0;
213
214
21.0k
   for(size_t i = 0; i != n; ++i)
215
20.5k
      difference |= (p1[i] ^ p2[i]);
216
217
515
   return difference == 0;
218
515
   }
219
220
template<typename T, typename Alloc>
221
size_t buffer_insert(std::vector<T, Alloc>& buf,
222
                     size_t buf_offset,
223
                     const T input[],
224
                     size_t input_length)
225
837k
   {
226
837k
   BOTAN_ASSERT_NOMSG(buf_offset <= buf.size());
227
837k
   const size_t to_copy = std::min(input_length, buf.size() - buf_offset);
228
837k
   if(to_copy > 0)
229
548k
      {
230
548k
      copy_mem(&buf[buf_offset], input, to_copy);
231
548k
      }
232
837k
   return to_copy;
233
837k
   }
unsigned long Botan::buffer_insert<unsigned char, Botan::secure_allocator<unsigned char> >(std::__1::vector<unsigned char, Botan::secure_allocator<unsigned char> >&, unsigned long, unsigned char const*, unsigned long)
Line
Count
Source
225
834k
   {
226
834k
   BOTAN_ASSERT_NOMSG(buf_offset <= buf.size());
227
834k
   const size_t to_copy = std::min(input_length, buf.size() - buf_offset);
228
834k
   if(to_copy > 0)
229
546k
      {
230
546k
      copy_mem(&buf[buf_offset], input, to_copy);
231
546k
      }
232
834k
   return to_copy;
233
834k
   }
unsigned long Botan::buffer_insert<unsigned char, std::__1::allocator<unsigned char> >(std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >&, unsigned long, unsigned char const*, unsigned long)
Line
Count
Source
225
3.06k
   {
226
3.06k
   BOTAN_ASSERT_NOMSG(buf_offset <= buf.size());
227
3.06k
   const size_t to_copy = std::min(input_length, buf.size() - buf_offset);
228
3.06k
   if(to_copy > 0)
229
2.09k
      {
230
2.09k
      copy_mem(&buf[buf_offset], input, to_copy);
231
2.09k
      }
232
3.06k
   return to_copy;
233
3.06k
   }
234
235
template<typename T, typename Alloc, typename Alloc2>
236
size_t buffer_insert(std::vector<T, Alloc>& buf,
237
                     size_t buf_offset,
238
                     const std::vector<T, Alloc2>& input)
239
3.09k
   {
240
3.09k
   BOTAN_ASSERT_NOMSG(buf_offset <= buf.size());
241
3.09k
   const size_t to_copy = std::min(input.size(), buf.size() - buf_offset);
242
3.09k
   if(to_copy > 0)
243
3.09k
      {
244
3.09k
      copy_mem(&buf[buf_offset], input.data(), to_copy);
245
3.09k
      }
246
3.09k
   return to_copy;
247
3.09k
   }
unsigned long Botan::buffer_insert<unsigned char, Botan::secure_allocator<unsigned char>, std::__1::allocator<unsigned char> >(std::__1::vector<unsigned char, Botan::secure_allocator<unsigned char> >&, unsigned long, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> > const&)
Line
Count
Source
239
3.06k
   {
240
3.06k
   BOTAN_ASSERT_NOMSG(buf_offset <= buf.size());
241
3.06k
   const size_t to_copy = std::min(input.size(), buf.size() - buf_offset);
242
3.06k
   if(to_copy > 0)
243
3.06k
      {
244
3.06k
      copy_mem(&buf[buf_offset], input.data(), to_copy);
245
3.06k
      }
246
3.06k
   return to_copy;
247
3.06k
   }
unsigned long Botan::buffer_insert<unsigned char, Botan::secure_allocator<unsigned char>, Botan::secure_allocator<unsigned char> >(std::__1::vector<unsigned char, Botan::secure_allocator<unsigned char> >&, unsigned long, std::__1::vector<unsigned char, Botan::secure_allocator<unsigned char> > const&)
Line
Count
Source
239
32
   {
240
32
   BOTAN_ASSERT_NOMSG(buf_offset <= buf.size());
241
32
   const size_t to_copy = std::min(input.size(), buf.size() - buf_offset);
242
32
   if(to_copy > 0)
243
32
      {
244
32
      copy_mem(&buf[buf_offset], input.data(), to_copy);
245
32
      }
246
32
   return to_copy;
247
32
   }
248
249
/**
250
* XOR arrays. Postcondition out[i] = in[i] ^ out[i] forall i = 0...length
251
* @param out the input/output buffer
252
* @param in the read-only input buffer
253
* @param length the length of the buffers
254
*/
255
inline void xor_buf(uint8_t out[],
256
                    const uint8_t in[],
257
                    size_t length)
258
103k
   {
259
103k
   const size_t blocks = length - (length % 32);
260
261
165k
   for(size_t i = 0; i != blocks; i += 32)
262
62.4k
      {
263
62.4k
      uint64_t x[4];
264
62.4k
      uint64_t y[4];
265
266
62.4k
      typecast_copy(x, out + i, 4);
267
62.4k
      typecast_copy(y, in + i, 4);
268
269
62.4k
      x[0] ^= y[0];
270
62.4k
      x[1] ^= y[1];
271
62.4k
      x[2] ^= y[2];
272
62.4k
      x[3] ^= y[3];
273
274
62.4k
      typecast_copy(out + i, x, 4);
275
62.4k
      }
276
277
1.30M
   for(size_t i = blocks; i != length; ++i)
278
1.19M
      {
279
1.19M
      out[i] ^= in[i];
280
1.19M
      }
281
103k
   }
282
283
/**
284
* XOR arrays. Postcondition out[i] = in[i] ^ in2[i] forall i = 0...length
285
* @param out the output buffer
286
* @param in the first input buffer
287
* @param in2 the second output buffer
288
* @param length the length of the three buffers
289
*/
290
inline void xor_buf(uint8_t out[],
291
                    const uint8_t in[],
292
                    const uint8_t in2[],
293
                    size_t length)
294
15.0k
   {
295
15.0k
   const size_t blocks = length - (length % 32);
296
297
28.1k
   for(size_t i = 0; i != blocks; i += 32)
298
13.1k
      {
299
13.1k
      uint64_t x[4];
300
13.1k
      uint64_t y[4];
301
302
13.1k
      typecast_copy(x, in + i, 4);
303
13.1k
      typecast_copy(y, in2 + i, 4);
304
305
13.1k
      x[0] ^= y[0];
306
13.1k
      x[1] ^= y[1];
307
13.1k
      x[2] ^= y[2];
308
13.1k
      x[3] ^= y[3];
309
310
13.1k
      typecast_copy(out + i, x, 4);
311
13.1k
      }
312
313
166k
   for(size_t i = blocks; i != length; ++i)
314
151k
      {
315
151k
      out[i] = in[i] ^ in2[i];
316
151k
      }
317
15.0k
   }
318
319
template<typename Alloc, typename Alloc2>
320
void xor_buf(std::vector<uint8_t, Alloc>& out,
321
             const std::vector<uint8_t, Alloc2>& in,
322
             size_t n)
323
0
   {
324
0
   xor_buf(out.data(), in.data(), n);
325
0
   }
326
327
template<typename Alloc>
328
void xor_buf(std::vector<uint8_t, Alloc>& out,
329
             const uint8_t* in,
330
             size_t n)
331
633
   {
332
633
   xor_buf(out.data(), in, n);
333
633
   }
Unexecuted instantiation: void Botan::xor_buf<Botan::secure_allocator<unsigned char> >(std::__1::vector<unsigned char, Botan::secure_allocator<unsigned char> >&, unsigned char const*, unsigned long)
void Botan::xor_buf<std::__1::allocator<unsigned char> >(std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >&, unsigned char const*, unsigned long)
Line
Count
Source
331
633
   {
332
633
   xor_buf(out.data(), in, n);
333
633
   }
334
335
template<typename Alloc, typename Alloc2>
336
void xor_buf(std::vector<uint8_t, Alloc>& out,
337
             const uint8_t* in,
338
             const std::vector<uint8_t, Alloc2>& in2,
339
             size_t n)
340
   {
341
   xor_buf(out.data(), in, in2.data(), n);
342
   }
343
344
template<typename Alloc, typename Alloc2>
345
std::vector<uint8_t, Alloc>&
346
operator^=(std::vector<uint8_t, Alloc>& out,
347
           const std::vector<uint8_t, Alloc2>& in)
348
2.05k
   {
349
2.05k
   if(out.size() < in.size())
350
0
      out.resize(in.size());
351
352
2.05k
   xor_buf(out.data(), in.data(), in.size());
353
2.05k
   return out;
354
2.05k
   }
355
356
}
357
358
#endif