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
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
/*
* Memory Operations
* (C) 1999-2009,2012 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/
#ifndef BOTAN_MEMORY_OPS_H__
#define BOTAN_MEMORY_OPS_H__
#include <botan/types.h>
#include <cstring>
#include <vector>
namespace Botan {
/**
* Zeroize memory
* @param ptr a pointer to memory to zero out
* @param n the number of bytes pointed to by ptr
*/
BOTAN_DLL void zero_mem(void* ptr, size_t n);
/**
* Zeroize memory
* @param ptr a pointer to an array
* @param n the number of Ts pointed to by ptr
*/
template<typename T> inline void clear_mem(T* ptr, size_t n)
{
std::memset(ptr, 0, sizeof(T)*n);
}
/**
* Copy memory
* @param out the destination array
* @param in the source array
* @param n the number of elements of in/out
*/
template<typename T> inline void copy_mem(T* out, const T* in, size_t n)
{
std::memmove(out, in, sizeof(T)*n);
}
/**
* Set memory to a fixed value
* @param ptr a pointer to an array
* @param n the number of Ts pointed to by ptr
* @param val the value to set each byte to
*/
template<typename T>
inline void set_mem(T* ptr, size_t n, byte val)
{
std::memset(ptr, val, sizeof(T)*n);
}
/**
* Memory comparison, input insensitive
* @param p1 a pointer to an array
* @param p2 a pointer to another array
* @param n the number of Ts in p1 and p2
* @return true iff p1[i] == p2[i] forall i in [0...n)
*/
template<typename T> inline bool same_mem(const T* p1, const T* p2, size_t n)
{
volatile T difference = 0;
for(size_t i = 0; i != n; ++i)
difference |= (p1[i] ^ p2[i]);
return difference == 0;
}
/**
* XOR arrays. Postcondition out[i] = in[i] ^ out[i] forall i = 0...length
* @param out the input/output buffer
* @param in the read-only input buffer
* @param length the length of the buffers
*/
template<typename T>
void xor_buf(T out[], const T in[], size_t length)
{
while(length >= 8)
{
out[0] ^= in[0]; out[1] ^= in[1];
out[2] ^= in[2]; out[3] ^= in[3];
out[4] ^= in[4]; out[5] ^= in[5];
out[6] ^= in[6]; out[7] ^= in[7];
out += 8; in += 8; length -= 8;
}
for(size_t i = 0; i != length; ++i)
out[i] ^= in[i];
}
/**
* XOR arrays. Postcondition out[i] = in[i] ^ in2[i] forall i = 0...length
* @param out the output buffer
* @param in the first input buffer
* @param in2 the second output buffer
* @param length the length of the three buffers
*/
template<typename T> void xor_buf(T out[],
const T in[],
const T in2[],
size_t length)
{
while(length >= 8)
{
out[0] = in[0] ^ in2[0];
out[1] = in[1] ^ in2[1];
out[2] = in[2] ^ in2[2];
out[3] = in[3] ^ in2[3];
out[4] = in[4] ^ in2[4];
out[5] = in[5] ^ in2[5];
out[6] = in[6] ^ in2[6];
out[7] = in[7] ^ in2[7];
in += 8; in2 += 8; out += 8; length -= 8;
}
for(size_t i = 0; i != length; ++i)
out[i] = in[i] ^ in2[i];
}
#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
template<>
inline void xor_buf<byte>(byte out[], const byte in[], size_t length)
{
while(length >= 8)
{
*reinterpret_cast<u64bit*>(out) ^= *reinterpret_cast<const u64bit*>(in);
out += 8; in += 8; length -= 8;
}
for(size_t i = 0; i != length; ++i)
out[i] ^= in[i];
}
template<>
inline void xor_buf<byte>(byte out[],
const byte in[],
const byte in2[],
size_t length)
{
while(length >= 8)
{
*reinterpret_cast<u64bit*>(out) =
*reinterpret_cast<const u64bit*>(in) ^
*reinterpret_cast<const u64bit*>(in2);
in += 8; in2 += 8; out += 8; length -= 8;
}
for(size_t i = 0; i != length; ++i)
out[i] = in[i] ^ in2[i];
}
#endif
template<typename Alloc, typename Alloc2>
void xor_buf(std::vector<byte, Alloc>& out,
const std::vector<byte, Alloc2>& in,
size_t n)
{
xor_buf(out.data(), in.data(), n);
}
template<typename Alloc>
void xor_buf(std::vector<byte, Alloc>& out,
const byte* in,
size_t n)
{
xor_buf(out.data(), in, n);
}
template<typename Alloc, typename Alloc2>
void xor_buf(std::vector<byte, Alloc>& out,
const byte* in,
const std::vector<byte, Alloc2>& in2,
size_t n)
{
xor_buf(out.data(), in, in2.data(), n);
}
template<typename T, typename Alloc, typename Alloc2>
std::vector<T, Alloc>&
operator^=(std::vector<T, Alloc>& out,
const std::vector<T, Alloc2>& in)
{
if(out.size() < in.size())
out.resize(in.size());
xor_buf(out.data(), in.data(), in.size());
return out;
}
}
#endif
|
