/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 | 8 | 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 | 313 | { |
86 | 313 | return ct_compare_u8(x, y, len) == 0xFF; |
87 | 313 | } |
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 | 1.21G | { |
99 | 1.21G | if(bytes > 0) |
100 | 1.07G | { |
101 | 1.07G | std::memset(ptr, 0, bytes); |
102 | 1.07G | } |
103 | 1.21G | } |
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 | 1.21G | { |
117 | 1.21G | clear_bytes(ptr, sizeof(T)*n); |
118 | 1.21G | } void Botan::clear_mem<unsigned char>(unsigned char*, unsigned long) Line | Count | Source | 116 | 1.13M | { | 117 | 1.13M | clear_bytes(ptr, sizeof(T)*n); | 118 | 1.13M | } |
void Botan::clear_mem<unsigned long>(unsigned long*, unsigned long) Line | Count | Source | 116 | 1.20G | { | 117 | 1.20G | clear_bytes(ptr, sizeof(T)*n); | 118 | 1.20G | } |
void Botan::clear_mem<unsigned int>(unsigned int*, unsigned long) Line | Count | Source | 116 | 42.7k | { | 117 | 42.7k | clear_bytes(ptr, sizeof(T)*n); | 118 | 42.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 | 2.65k | { | 117 | 2.65k | clear_bytes(ptr, sizeof(T)*n); | 118 | 2.65k | } |
|
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 | 347M | { |
128 | 347M | static_assert(std::is_trivial<typename std::decay<T>::type>::value, ""); |
129 | 347M | BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, |
130 | 347M | "If n > 0 then args are not null"); |
131 | | |
132 | 347M | if(in != nullptr && out != nullptr && n > 0) |
133 | 346M | { |
134 | 346M | std::memmove(out, in, sizeof(T)*n); |
135 | 346M | } |
136 | 347M | } void Botan::copy_mem<unsigned long>(unsigned long*, unsigned long const*, unsigned long) Line | Count | Source | 127 | 312M | { | 128 | 312M | static_assert(std::is_trivial<typename std::decay<T>::type>::value, ""); | 129 | 312M | BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, | 130 | 312M | "If n > 0 then args are not null"); | 131 | | | 132 | 312M | if(in != nullptr && out != nullptr && n > 0) | 133 | 312M | { | 134 | 312M | std::memmove(out, in, sizeof(T)*n); | 135 | 312M | } | 136 | 312M | } |
void Botan::copy_mem<unsigned char>(unsigned char*, unsigned char const*, unsigned long) Line | Count | Source | 127 | 34.4M | { | 128 | 34.4M | static_assert(std::is_trivial<typename std::decay<T>::type>::value, ""); | 129 | 34.4M | BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, | 130 | 34.4M | "If n > 0 then args are not null"); | 131 | | | 132 | 34.4M | if(in != nullptr && out != nullptr && n > 0) | 133 | 33.9M | { | 134 | 33.9M | std::memmove(out, in, sizeof(T)*n); | 135 | 33.9M | } | 136 | 34.4M | } |
Unexecuted instantiation: void Botan::copy_mem<unsigned int>(unsigned int*, unsigned int const*, unsigned long) void Botan::copy_mem<int>(int*, int const*, unsigned long) Line | Count | Source | 127 | 9.21k | { | 128 | 9.21k | static_assert(std::is_trivial<typename std::decay<T>::type>::value, ""); | 129 | 9.21k | BOTAN_ASSERT_IMPLICATION(n > 0, in != nullptr && out != nullptr, | 130 | 9.21k | "If n > 0 then args are not null"); | 131 | | | 132 | 9.21k | if(in != nullptr && out != nullptr && n > 0) | 133 | 9.21k | { | 134 | 9.21k | std::memmove(out, in, sizeof(T)*n); | 135 | 9.21k | } | 136 | 9.21k | } |
Unexecuted instantiation: void Botan::copy_mem<unsigned short>(unsigned short*, unsigned short const*, unsigned long) |
137 | | |
138 | | template<typename T> inline constexpr void typecast_copy(uint8_t out[], T in[], size_t N) |
139 | 4.35M | { |
140 | 4.35M | static_assert(std::is_trivially_copyable<T>::value, "Safe to memcpy"); |
141 | 4.35M | std::memcpy(out, in, sizeof(T)*N); |
142 | 4.35M | } void Botan::typecast_copy<unsigned long>(unsigned char*, unsigned long*, unsigned long) Line | Count | Source | 139 | 1.42M | { | 140 | 1.42M | static_assert(std::is_trivially_copyable<T>::value, "Safe to memcpy"); | 141 | 1.42M | std::memcpy(out, in, sizeof(T)*N); | 142 | 1.42M | } |
void Botan::typecast_copy<unsigned int>(unsigned char*, unsigned int*, unsigned long) Line | Count | Source | 139 | 2.92M | { | 140 | 2.92M | static_assert(std::is_trivially_copyable<T>::value, "Safe to memcpy"); | 141 | 2.92M | std::memcpy(out, in, sizeof(T)*N); | 142 | 2.92M | } |
void Botan::typecast_copy<unsigned short>(unsigned char*, unsigned short*, unsigned long) Line | Count | Source | 139 | 50 | { | 140 | 50 | static_assert(std::is_trivially_copyable<T>::value, "Safe to memcpy"); | 141 | 50 | std::memcpy(out, in, sizeof(T)*N); | 142 | 50 | } |
|
143 | | |
144 | | template<typename T> inline constexpr void typecast_copy(T out[], const uint8_t in[], size_t N) |
145 | 21.3M | { |
146 | 21.3M | static_assert(std::is_trivial<T>::value, "Safe to memcpy"); |
147 | 21.3M | std::memcpy(out, in, sizeof(T)*N); |
148 | 21.3M | } void Botan::typecast_copy<unsigned long>(unsigned long*, unsigned char const*, unsigned long) Line | Count | Source | 145 | 6.45M | { | 146 | 6.45M | static_assert(std::is_trivial<T>::value, "Safe to memcpy"); | 147 | 6.45M | std::memcpy(out, in, sizeof(T)*N); | 148 | 6.45M | } |
void Botan::typecast_copy<unsigned int>(unsigned int*, unsigned char const*, unsigned long) Line | Count | Source | 145 | 14.7M | { | 146 | 14.7M | static_assert(std::is_trivial<T>::value, "Safe to memcpy"); | 147 | 14.7M | std::memcpy(out, in, sizeof(T)*N); | 148 | 14.7M | } |
void Botan::typecast_copy<unsigned short>(unsigned short*, unsigned char const*, unsigned long) Line | Count | Source | 145 | 122k | { | 146 | 122k | static_assert(std::is_trivial<T>::value, "Safe to memcpy"); | 147 | 122k | std::memcpy(out, in, sizeof(T)*N); | 148 | 122k | } |
|
149 | | |
150 | | template<typename T> inline constexpr void typecast_copy(uint8_t out[], T in) |
151 | 4.28M | { |
152 | 4.28M | typecast_copy(out, &in, 1); |
153 | 4.28M | } void Botan::typecast_copy<unsigned long>(unsigned char*, unsigned long) Line | Count | Source | 151 | 1.35M | { | 152 | 1.35M | typecast_copy(out, &in, 1); | 153 | 1.35M | } |
void Botan::typecast_copy<unsigned int>(unsigned char*, unsigned int) Line | Count | Source | 151 | 2.92M | { | 152 | 2.92M | typecast_copy(out, &in, 1); | 153 | 2.92M | } |
void Botan::typecast_copy<unsigned short>(unsigned char*, unsigned short) Line | Count | Source | 151 | 50 | { | 152 | 50 | typecast_copy(out, &in, 1); | 153 | 50 | } |
|
154 | | |
155 | | template<typename T> inline constexpr void typecast_copy(T& out, const uint8_t in[]) |
156 | 21.1M | { |
157 | 21.1M | static_assert(std::is_trivial<typename std::decay<T>::type>::value, "Safe case"); |
158 | 21.1M | typecast_copy(&out, in, 1); |
159 | 21.1M | } void Botan::typecast_copy<unsigned long>(unsigned long&, unsigned char const*) Line | Count | Source | 156 | 6.31M | { | 157 | 6.31M | static_assert(std::is_trivial<typename std::decay<T>::type>::value, "Safe case"); | 158 | 6.31M | typecast_copy(&out, in, 1); | 159 | 6.31M | } |
void Botan::typecast_copy<unsigned int>(unsigned int&, unsigned char const*) Line | Count | Source | 156 | 14.7M | { | 157 | 14.7M | static_assert(std::is_trivial<typename std::decay<T>::type>::value, "Safe case"); | 158 | 14.7M | typecast_copy(&out, in, 1); | 159 | 14.7M | } |
void Botan::typecast_copy<unsigned short>(unsigned short&, unsigned char const*) Line | Count | Source | 156 | 122k | { | 157 | 122k | static_assert(std::is_trivial<typename std::decay<T>::type>::value, "Safe case"); | 158 | 122k | typecast_copy(&out, in, 1); | 159 | 122k | } |
|
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.56k | { |
177 | 5.56k | if(n > 0) |
178 | 5.56k | { |
179 | 5.56k | std::memset(ptr, val, n); |
180 | 5.56k | } |
181 | 5.56k | } |
182 | | |
183 | | inline const uint8_t* cast_char_ptr_to_uint8(const char* s) |
184 | 69.2k | { |
185 | 69.2k | return reinterpret_cast<const uint8_t*>(s); |
186 | 69.2k | } |
187 | | |
188 | | inline const char* cast_uint8_ptr_to_char(const uint8_t* b) |
189 | 171k | { |
190 | 171k | return reinterpret_cast<const char*>(b); |
191 | 171k | } |
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 | 24.2k | { |
200 | 24.2k | return reinterpret_cast<char*>(b); |
201 | 24.2k | } |
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 | 351 | { |
212 | 351 | volatile T difference = 0; |
213 | | |
214 | 6.85k | for(size_t i = 0; i != n; ++i) |
215 | 6.50k | difference = difference | (p1[i] ^ p2[i]); |
216 | | |
217 | 351 | return difference == 0; |
218 | 351 | } 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 = 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 | 329 | { | 212 | 329 | volatile T difference = 0; | 213 | | | 214 | 6.77k | for(size_t i = 0; i != n; ++i) | 215 | 6.44k | difference = difference | (p1[i] ^ p2[i]); | 216 | | | 217 | 329 | return difference == 0; | 218 | 329 | } |
|
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 | 949k | { |
226 | 949k | BOTAN_ASSERT_NOMSG(buf_offset <= buf.size()); |
227 | 949k | const size_t to_copy = std::min(input_length, buf.size() - buf_offset); |
228 | 949k | if(to_copy > 0) |
229 | 602k | { |
230 | 602k | copy_mem(&buf[buf_offset], input, to_copy); |
231 | 602k | } |
232 | 949k | return to_copy; |
233 | 949k | } 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 | 948k | { | 226 | 948k | BOTAN_ASSERT_NOMSG(buf_offset <= buf.size()); | 227 | 948k | const size_t to_copy = std::min(input_length, buf.size() - buf_offset); | 228 | 948k | if(to_copy > 0) | 229 | 601k | { | 230 | 601k | copy_mem(&buf[buf_offset], input, to_copy); | 231 | 601k | } | 232 | 948k | return to_copy; | 233 | 948k | } |
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 | 1.05k | { | 226 | 1.05k | BOTAN_ASSERT_NOMSG(buf_offset <= buf.size()); | 227 | 1.05k | const size_t to_copy = std::min(input_length, buf.size() - buf_offset); | 228 | 1.05k | if(to_copy > 0) | 229 | 708 | { | 230 | 708 | copy_mem(&buf[buf_offset], input, to_copy); | 231 | 708 | } | 232 | 1.05k | return to_copy; | 233 | 1.05k | } |
|
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 | 1.08k | { |
240 | 1.08k | BOTAN_ASSERT_NOMSG(buf_offset <= buf.size()); |
241 | 1.08k | const size_t to_copy = std::min(input.size(), buf.size() - buf_offset); |
242 | 1.08k | if(to_copy > 0) |
243 | 1.08k | { |
244 | 1.08k | copy_mem(&buf[buf_offset], input.data(), to_copy); |
245 | 1.08k | } |
246 | 1.08k | return to_copy; |
247 | 1.08k | } 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 | 26 | { | 240 | 26 | BOTAN_ASSERT_NOMSG(buf_offset <= buf.size()); | 241 | 26 | const size_t to_copy = std::min(input.size(), buf.size() - buf_offset); | 242 | 26 | if(to_copy > 0) | 243 | 26 | { | 244 | 26 | copy_mem(&buf[buf_offset], input.data(), to_copy); | 245 | 26 | } | 246 | 26 | return to_copy; | 247 | 26 | } |
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 | 1.05k | { | 240 | 1.05k | BOTAN_ASSERT_NOMSG(buf_offset <= buf.size()); | 241 | 1.05k | const size_t to_copy = std::min(input.size(), buf.size() - buf_offset); | 242 | 1.05k | if(to_copy > 0) | 243 | 1.05k | { | 244 | 1.05k | copy_mem(&buf[buf_offset], input.data(), to_copy); | 245 | 1.05k | } | 246 | 1.05k | return to_copy; | 247 | 1.05k | } |
|
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 | 91.6k | { |
259 | 91.6k | const size_t blocks = length - (length % 32); |
260 | | |
261 | 157k | for(size_t i = 0; i != blocks; i += 32) |
262 | 66.0k | { |
263 | 66.0k | uint64_t x[4]; |
264 | 66.0k | uint64_t y[4]; |
265 | | |
266 | 66.0k | typecast_copy(x, out + i, 4); |
267 | 66.0k | typecast_copy(y, in + i, 4); |
268 | | |
269 | 66.0k | x[0] ^= y[0]; |
270 | 66.0k | x[1] ^= y[1]; |
271 | 66.0k | x[2] ^= y[2]; |
272 | 66.0k | x[3] ^= y[3]; |
273 | | |
274 | 66.0k | typecast_copy(out + i, x, 4); |
275 | 66.0k | } |
276 | | |
277 | 794k | for(size_t i = blocks; i != length; ++i) |
278 | 702k | { |
279 | 702k | out[i] ^= in[i]; |
280 | 702k | } |
281 | 91.6k | } |
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 | 4.20k | { |
295 | 4.20k | const size_t blocks = length - (length % 32); |
296 | | |
297 | 8.51k | for(size_t i = 0; i != blocks; i += 32) |
298 | 4.31k | { |
299 | 4.31k | uint64_t x[4]; |
300 | 4.31k | uint64_t y[4]; |
301 | | |
302 | 4.31k | typecast_copy(x, in + i, 4); |
303 | 4.31k | typecast_copy(y, in2 + i, 4); |
304 | | |
305 | 4.31k | x[0] ^= y[0]; |
306 | 4.31k | x[1] ^= y[1]; |
307 | 4.31k | x[2] ^= y[2]; |
308 | 4.31k | x[3] ^= y[3]; |
309 | | |
310 | 4.31k | typecast_copy(out + i, x, 4); |
311 | 4.31k | } |
312 | | |
313 | 49.5k | for(size_t i = blocks; i != length; ++i) |
314 | 45.3k | { |
315 | 45.3k | out[i] = in[i] ^ in2[i]; |
316 | 45.3k | } |
317 | 4.20k | } |
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 | 246 | { |
332 | 246 | xor_buf(out.data(), in, n); |
333 | 246 | } 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 | 246 | { | 332 | 246 | xor_buf(out.data(), in, n); | 333 | 246 | } |
|
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 | 697 | { |
349 | 697 | if(out.size() < in.size()) |
350 | 0 | out.resize(in.size()); |
351 | | |
352 | 697 | xor_buf(out.data(), in.data(), in.size()); |
353 | 697 | return out; |
354 | 697 | } |
355 | | |
356 | | } |
357 | | |
358 | | #endif |