Coverage Report

Created: 2020-11-21 08:34

/src/botan/build/include/botan/internal/ct_utils.h
Line
Count
Source
1
/*
2
* Functions for constant time operations on data and testing of
3
* constant time annotations using valgrind.
4
*
5
* For more information about constant time programming see
6
* Wagner, Molnar, et al "The Program Counter Security Model"
7
*
8
* (C) 2010 Falko Strenzke
9
* (C) 2015,2016,2018 Jack Lloyd
10
*
11
* Botan is released under the Simplified BSD License (see license.txt)
12
*/
13
14
#ifndef BOTAN_CT_UTILS_H_
15
#define BOTAN_CT_UTILS_H_
16
17
#include <botan/secmem.h>
18
#include <botan/internal/bit_ops.h>
19
#include <type_traits>
20
#include <vector>
21
22
#if defined(BOTAN_HAS_VALGRIND)
23
  #include <valgrind/memcheck.h>
24
#endif
25
26
namespace Botan {
27
28
namespace CT {
29
30
/**
31
* Use valgrind to mark the contents of memory as being undefined.
32
* Valgrind will accept operations which manipulate undefined values,
33
* but will warn if an undefined value is used to decided a conditional
34
* jump or a load/store address. So if we poison all of our inputs we
35
* can confirm that the operations in question are truly const time
36
* when compiled by whatever compiler is in use.
37
*
38
* Even better, the VALGRIND_MAKE_MEM_* macros work even when the
39
* program is not run under valgrind (though with a few cycles of
40
* overhead, which is unfortunate in final binaries as these
41
* annotations tend to be used in fairly important loops).
42
*
43
* This approach was first used in ctgrind (https://github.com/agl/ctgrind)
44
* but calling the valgrind mecheck API directly works just as well and
45
* doesn't require a custom patched valgrind.
46
*/
47
template<typename T>
48
inline void poison(const T* p, size_t n)
49
59.1k
   {
50
#if defined(BOTAN_HAS_VALGRIND)
51
   VALGRIND_MAKE_MEM_UNDEFINED(p, n * sizeof(T));
52
#else
53
59.1k
   BOTAN_UNUSED(p);
54
59.1k
   BOTAN_UNUSED(n);
55
59.1k
#endif
56
59.1k
   }
void Botan::CT::poison<unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
49
4.72k
   {
50
#if defined(BOTAN_HAS_VALGRIND)
51
   VALGRIND_MAKE_MEM_UNDEFINED(p, n * sizeof(T));
52
#else
53
4.72k
   BOTAN_UNUSED(p);
54
4.72k
   BOTAN_UNUSED(n);
55
4.72k
#endif
56
4.72k
   }
Unexecuted instantiation: void Botan::CT::poison<unsigned short>(unsigned short const*, unsigned long)
void Botan::CT::poison<unsigned long>(unsigned long const*, unsigned long)
Line
Count
Source
49
54.4k
   {
50
#if defined(BOTAN_HAS_VALGRIND)
51
   VALGRIND_MAKE_MEM_UNDEFINED(p, n * sizeof(T));
52
#else
53
54.4k
   BOTAN_UNUSED(p);
54
54.4k
   BOTAN_UNUSED(n);
55
54.4k
#endif
56
54.4k
   }
57
58
template<typename T>
59
inline void unpoison(const T* p, size_t n)
60
60.1k
   {
61
#if defined(BOTAN_HAS_VALGRIND)
62
   VALGRIND_MAKE_MEM_DEFINED(p, n * sizeof(T));
63
#else
64
60.1k
   BOTAN_UNUSED(p);
65
60.1k
   BOTAN_UNUSED(n);
66
60.1k
#endif
67
60.1k
   }
void Botan::CT::unpoison<unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
60
6.94k
   {
61
#if defined(BOTAN_HAS_VALGRIND)
62
   VALGRIND_MAKE_MEM_DEFINED(p, n * sizeof(T));
63
#else
64
6.94k
   BOTAN_UNUSED(p);
65
6.94k
   BOTAN_UNUSED(n);
66
6.94k
#endif
67
6.94k
   }
Unexecuted instantiation: void Botan::CT::unpoison<unsigned short>(unsigned short const*, unsigned long)
void Botan::CT::unpoison<unsigned long>(unsigned long const*, unsigned long)
Line
Count
Source
60
53.2k
   {
61
#if defined(BOTAN_HAS_VALGRIND)
62
   VALGRIND_MAKE_MEM_DEFINED(p, n * sizeof(T));
63
#else
64
53.2k
   BOTAN_UNUSED(p);
65
53.2k
   BOTAN_UNUSED(n);
66
53.2k
#endif
67
53.2k
   }
Unexecuted instantiation: void Botan::CT::unpoison<unsigned int>(unsigned int const*, unsigned long)
68
69
template<typename T>
70
inline void unpoison(T& p)
71
286M
   {
72
#if defined(BOTAN_HAS_VALGRIND)
73
   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
74
#else
75
286M
   BOTAN_UNUSED(p);
76
286M
#endif
77
286M
   }
void Botan::CT::unpoison<unsigned long>(unsigned long&)
Line
Count
Source
71
179M
   {
72
#if defined(BOTAN_HAS_VALGRIND)
73
   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
74
#else
75
179M
   BOTAN_UNUSED(p);
76
179M
#endif
77
179M
   }
void Botan::CT::unpoison<unsigned long const>(unsigned long const&)
Line
Count
Source
71
7.67M
   {
72
#if defined(BOTAN_HAS_VALGRIND)
73
   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
74
#else
75
7.67M
   BOTAN_UNUSED(p);
76
7.67M
#endif
77
7.67M
   }
void Botan::CT::unpoison<unsigned int>(unsigned int&)
Line
Count
Source
71
374k
   {
72
#if defined(BOTAN_HAS_VALGRIND)
73
   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
74
#else
75
374k
   BOTAN_UNUSED(p);
76
374k
#endif
77
374k
   }
void Botan::CT::unpoison<long>(long&)
Line
Count
Source
71
98.9M
   {
72
#if defined(BOTAN_HAS_VALGRIND)
73
   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
74
#else
75
98.9M
   BOTAN_UNUSED(p);
76
98.9M
#endif
77
98.9M
   }
Unexecuted instantiation: void Botan::CT::unpoison<Botan::CT::Mask<unsigned char> >(Botan::CT::Mask<unsigned char>&)
void Botan::CT::unpoison<unsigned char>(unsigned char&)
Line
Count
Source
71
559
   {
72
#if defined(BOTAN_HAS_VALGRIND)
73
   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
74
#else
75
559
   BOTAN_UNUSED(p);
76
559
#endif
77
559
   }
void Botan::CT::unpoison<unsigned char const>(unsigned char const&)
Line
Count
Source
71
1.15k
   {
72
#if defined(BOTAN_HAS_VALGRIND)
73
   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
74
#else
75
1.15k
   BOTAN_UNUSED(p);
76
1.15k
#endif
77
1.15k
   }
void Botan::CT::unpoison<unsigned short>(unsigned short&)
Line
Count
Source
71
528
   {
72
#if defined(BOTAN_HAS_VALGRIND)
73
   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
74
#else
75
528
   BOTAN_UNUSED(p);
76
528
#endif
77
528
   }
void Botan::CT::unpoison<Botan::CT::Mask<unsigned short> const>(Botan::CT::Mask<unsigned short> const&)
Line
Count
Source
71
264
   {
72
#if defined(BOTAN_HAS_VALGRIND)
73
   VALGRIND_MAKE_MEM_DEFINED(&p, sizeof(T));
74
#else
75
264
   BOTAN_UNUSED(p);
76
264
#endif
77
264
   }
78
79
/**
80
* A Mask type used for constant-time operations. A Mask<T> always has value
81
* either 0 (all bits cleared) or ~0 (all bits set). All operations in a Mask<T>
82
* are intended to compile to code which does not contain conditional jumps.
83
* This must be verified with tooling (eg binary disassembly or using valgrind)
84
* since you never know what a compiler might do.
85
*/
86
template<typename T>
87
class Mask
88
   {
89
   public:
90
      static_assert(std::is_unsigned<T>::value, "CT::Mask only defined for unsigned integer types");
91
92
      Mask(const Mask<T>& other) = default;
93
      Mask<T>& operator=(const Mask<T>& other) = default;
94
95
      /**
96
      * Derive a Mask from a Mask of a larger type
97
      */
98
      template<typename U>
99
      Mask(Mask<U> o) : m_mask(static_cast<T>(o.value()))
100
21.7k
         {
101
21.7k
         static_assert(sizeof(U) > sizeof(T), "sizes ok");
102
21.7k
         }
Unexecuted instantiation: Botan::CT::Mask<unsigned short>::Mask<unsigned int>(Botan::CT::Mask<unsigned int>)
Botan::CT::Mask<unsigned char>::Mask<unsigned long>(Botan::CT::Mask<unsigned long>)
Line
Count
Source
100
21.7k
         {
101
21.7k
         static_assert(sizeof(U) > sizeof(T), "sizes ok");
102
21.7k
         }
103
104
      /**
105
      * Return a Mask<T> with all bits set
106
      */
107
      static Mask<T> set()
108
55.9k
         {
109
55.9k
         return Mask<T>(static_cast<T>(~0));
110
55.9k
         }
Botan::CT::Mask<unsigned long>::set()
Line
Count
Source
108
53.2k
         {
109
53.2k
         return Mask<T>(static_cast<T>(~0));
110
53.2k
         }
Botan::CT::Mask<unsigned char>::set()
Line
Count
Source
108
2.66k
         {
109
2.66k
         return Mask<T>(static_cast<T>(~0));
110
2.66k
         }
111
112
      /**
113
      * Return a Mask<T> with all bits cleared
114
      */
115
      static Mask<T> cleared()
116
3.65M
         {
117
3.65M
         return Mask<T>(0);
118
3.65M
         }
Botan::CT::Mask<unsigned long>::cleared()
Line
Count
Source
116
3.65M
         {
117
3.65M
         return Mask<T>(0);
118
3.65M
         }
Botan::CT::Mask<unsigned char>::cleared()
Line
Count
Source
116
3.45k
         {
117
3.45k
         return Mask<T>(0);
118
3.45k
         }
119
120
      /**
121
      * Return a Mask<T> which is set if v is != 0
122
      */
123
      static Mask<T> expand(T v)
124
1.60G
         {
125
1.60G
         return ~Mask<T>::is_zero(v);
126
1.60G
         }
Botan::CT::Mask<unsigned long>::expand(unsigned long)
Line
Count
Source
124
1.58G
         {
125
1.58G
         return ~Mask<T>::is_zero(v);
126
1.58G
         }
Botan::CT::Mask<unsigned char>::expand(unsigned char)
Line
Count
Source
124
21.1M
         {
125
21.1M
         return ~Mask<T>::is_zero(v);
126
21.1M
         }
Botan::CT::Mask<unsigned short>::expand(unsigned short)
Line
Count
Source
124
528
         {
125
528
         return ~Mask<T>::is_zero(v);
126
528
         }
127
128
      /**
129
      * Return a Mask<T> which is set if m is set
130
      */
131
      template<typename U>
132
      static Mask<T> expand(Mask<U> m)
133
215
         {
134
215
         static_assert(sizeof(U) < sizeof(T), "sizes ok");
135
215
         return ~Mask<T>::is_zero(m.value());
136
215
         }
137
138
      /**
139
      * Return a Mask<T> which is set if v is == 0 or cleared otherwise
140
      */
141
      static Mask<T> is_zero(T x)
142
5.03G
         {
143
5.03G
         return Mask<T>(ct_is_zero<T>(x));
144
5.03G
         }
Botan::CT::Mask<unsigned long>::is_zero(unsigned long)
Line
Count
Source
142
5.00G
         {
143
5.00G
         return Mask<T>(ct_is_zero<T>(x));
144
5.00G
         }
Botan::CT::Mask<unsigned char>::is_zero(unsigned char)
Line
Count
Source
142
22.8M
         {
143
22.8M
         return Mask<T>(ct_is_zero<T>(x));
144
22.8M
         }
Unexecuted instantiation: Botan::CT::Mask<unsigned int>::is_zero(unsigned int)
Botan::CT::Mask<unsigned short>::is_zero(unsigned short)
Line
Count
Source
142
74.8k
         {
143
74.8k
         return Mask<T>(ct_is_zero<T>(x));
144
74.8k
         }
145
146
      /**
147
      * Return a Mask<T> which is set if x == y
148
      */
149
      static Mask<T> is_equal(T x, T y)
150
3.37G
         {
151
3.37G
         return Mask<T>::is_zero(static_cast<T>(x ^ y));
152
3.37G
         }
Botan::CT::Mask<unsigned long>::is_equal(unsigned long, unsigned long)
Line
Count
Source
150
3.37G
         {
151
3.37G
         return Mask<T>::is_zero(static_cast<T>(x ^ y));
152
3.37G
         }
Botan::CT::Mask<unsigned char>::is_equal(unsigned char, unsigned char)
Line
Count
Source
150
396k
         {
151
396k
         return Mask<T>::is_zero(static_cast<T>(x ^ y));
152
396k
         }
Botan::CT::Mask<unsigned short>::is_equal(unsigned short, unsigned short)
Line
Count
Source
150
74.3k
         {
151
74.3k
         return Mask<T>::is_zero(static_cast<T>(x ^ y));
152
74.3k
         }
153
154
      /**
155
      * Return a Mask<T> which is set if x < y
156
      */
157
      static Mask<T> is_lt(T x, T y)
158
1.54G
         {
159
1.54G
         return Mask<T>(expand_top_bit<T>(x^((x^y) | ((x-y)^x))));
160
1.54G
         }
Botan::CT::Mask<unsigned long>::is_lt(unsigned long, unsigned long)
Line
Count
Source
158
1.54G
         {
159
1.54G
         return Mask<T>(expand_top_bit<T>(x^((x^y) | ((x-y)^x))));
160
1.54G
         }
Botan::CT::Mask<unsigned int>::is_lt(unsigned int, unsigned int)
Line
Count
Source
158
374k
         {
159
374k
         return Mask<T>(expand_top_bit<T>(x^((x^y) | ((x-y)^x))));
160
374k
         }
Botan::CT::Mask<unsigned short>::is_lt(unsigned short, unsigned short)
Line
Count
Source
158
74.8k
         {
159
74.8k
         return Mask<T>(expand_top_bit<T>(x^((x^y) | ((x-y)^x))));
160
74.8k
         }
Botan::CT::Mask<unsigned char>::is_lt(unsigned char, unsigned char)
Line
Count
Source
158
158
         {
159
158
         return Mask<T>(expand_top_bit<T>(x^((x^y) | ((x-y)^x))));
160
158
         }
161
162
      /**
163
      * Return a Mask<T> which is set if x > y
164
      */
165
      static Mask<T> is_gt(T x, T y)
166
2.72M
         {
167
2.72M
         return Mask<T>::is_lt(y, x);
168
2.72M
         }
Botan::CT::Mask<unsigned long>::is_gt(unsigned long, unsigned long)
Line
Count
Source
166
2.64M
         {
167
2.64M
         return Mask<T>::is_lt(y, x);
168
2.64M
         }
Botan::CT::Mask<unsigned short>::is_gt(unsigned short, unsigned short)
Line
Count
Source
166
74.3k
         {
167
74.3k
         return Mask<T>::is_lt(y, x);
168
74.3k
         }
Botan::CT::Mask<unsigned char>::is_gt(unsigned char, unsigned char)
Line
Count
Source
166
158
         {
167
158
         return Mask<T>::is_lt(y, x);
168
158
         }
169
170
      /**
171
      * Return a Mask<T> which is set if x <= y
172
      */
173
      static Mask<T> is_lte(T x, T y)
174
2.71M
         {
175
2.71M
         return ~Mask<T>::is_gt(x, y);
176
2.71M
         }
Botan::CT::Mask<unsigned long>::is_lte(unsigned long, unsigned long)
Line
Count
Source
174
2.64M
         {
175
2.64M
         return ~Mask<T>::is_gt(x, y);
176
2.64M
         }
Botan::CT::Mask<unsigned short>::is_lte(unsigned short, unsigned short)
Line
Count
Source
174
74.3k
         {
175
74.3k
         return ~Mask<T>::is_gt(x, y);
176
74.3k
         }
177
178
      /**
179
      * Return a Mask<T> which is set if x >= y
180
      */
181
      static Mask<T> is_gte(T x, T y)
182
403k
         {
183
403k
         return ~Mask<T>::is_lt(x, y);
184
403k
         }
Botan::CT::Mask<unsigned int>::is_gte(unsigned int, unsigned int)
Line
Count
Source
182
374k
         {
183
374k
         return ~Mask<T>::is_lt(x, y);
184
374k
         }
Botan::CT::Mask<unsigned long>::is_gte(unsigned long, unsigned long)
Line
Count
Source
182
28.4k
         {
183
28.4k
         return ~Mask<T>::is_lt(x, y);
184
28.4k
         }
185
186
      /**
187
      * AND-combine two masks
188
      */
189
      Mask<T>& operator&=(Mask<T> o)
190
1.81M
         {
191
1.81M
         m_mask &= o.value();
192
1.81M
         return (*this);
193
1.81M
         }
Botan::CT::Mask<unsigned long>::operator&=(Botan::CT::Mask<unsigned long>)
Line
Count
Source
190
974k
         {
191
974k
         m_mask &= o.value();
192
974k
         return (*this);
193
974k
         }
Botan::CT::Mask<unsigned char>::operator&=(Botan::CT::Mask<unsigned char>)
Line
Count
Source
190
836k
         {
191
836k
         m_mask &= o.value();
192
836k
         return (*this);
193
836k
         }
194
195
      /**
196
      * XOR-combine two masks
197
      */
198
      Mask<T>& operator^=(Mask<T> o)
199
         {
200
         m_mask ^= o.value();
201
         return (*this);
202
         }
203
204
      /**
205
      * OR-combine two masks
206
      */
207
      Mask<T>& operator|=(Mask<T> o)
208
61.4M
         {
209
61.4M
         m_mask |= o.value();
210
61.4M
         return (*this);
211
61.4M
         }
Botan::CT::Mask<unsigned long>::operator|=(Botan::CT::Mask<unsigned long>)
Line
Count
Source
208
60.6M
         {
209
60.6M
         m_mask |= o.value();
210
60.6M
         return (*this);
211
60.6M
         }
Botan::CT::Mask<unsigned char>::operator|=(Botan::CT::Mask<unsigned char>)
Line
Count
Source
208
806k
         {
209
806k
         m_mask |= o.value();
210
806k
         return (*this);
211
806k
         }
Botan::CT::Mask<unsigned short>::operator|=(Botan::CT::Mask<unsigned short>)
Line
Count
Source
208
74.0k
         {
209
74.0k
         m_mask |= o.value();
210
74.0k
         return (*this);
211
74.0k
         }
212
213
      /**
214
      * AND-combine two masks
215
      */
216
      friend Mask<T> operator&(Mask<T> x, Mask<T> y)
217
165M
         {
218
165M
         return Mask<T>(x.value() & y.value());
219
165M
         }
Botan::CT::operator&(Botan::CT::Mask<unsigned long>, Botan::CT::Mask<unsigned long>)
Line
Count
Source
217
164M
         {
218
164M
         return Mask<T>(x.value() & y.value());
219
164M
         }
Botan::CT::operator&(Botan::CT::Mask<unsigned char>, Botan::CT::Mask<unsigned char>)
Line
Count
Source
217
598k
         {
218
598k
         return Mask<T>(x.value() & y.value());
219
598k
         }
Botan::CT::operator&(Botan::CT::Mask<unsigned short>, Botan::CT::Mask<unsigned short>)
Line
Count
Source
217
74.5k
         {
218
74.5k
         return Mask<T>(x.value() & y.value());
219
74.5k
         }
220
221
      /**
222
      * XOR-combine two masks
223
      */
224
      friend Mask<T> operator^(Mask<T> x, Mask<T> y)
225
4.24M
         {
226
4.24M
         return Mask<T>(x.value() ^ y.value());
227
4.24M
         }
228
229
      /**
230
      * OR-combine two masks
231
      */
232
      friend Mask<T> operator|(Mask<T> x, Mask<T> y)
233
164M
         {
234
164M
         return Mask<T>(x.value() | y.value());
235
164M
         }
Botan::CT::operator|(Botan::CT::Mask<unsigned long>, Botan::CT::Mask<unsigned long>)
Line
Count
Source
233
164M
         {
234
164M
         return Mask<T>(x.value() | y.value());
235
164M
         }
Botan::CT::operator|(Botan::CT::Mask<unsigned char>, Botan::CT::Mask<unsigned char>)
Line
Count
Source
233
202k
         {
234
202k
         return Mask<T>(x.value() | y.value());
235
202k
         }
236
237
      /**
238
      * Negate this mask
239
      */
240
      Mask<T> operator~() const
241
1.61G
         {
242
1.61G
         return Mask<T>(~value());
243
1.61G
         }
Botan::CT::Mask<unsigned long>::operator~() const
Line
Count
Source
241
1.59G
         {
242
1.59G
         return Mask<T>(~value());
243
1.59G
         }
Botan::CT::Mask<unsigned char>::operator~() const
Line
Count
Source
241
21.7M
         {
242
21.7M
         return Mask<T>(~value());
243
21.7M
         }
Botan::CT::Mask<unsigned int>::operator~() const
Line
Count
Source
241
374k
         {
242
374k
         return Mask<T>(~value());
243
374k
         }
Botan::CT::Mask<unsigned short>::operator~() const
Line
Count
Source
241
148k
         {
242
148k
         return Mask<T>(~value());
243
148k
         }
244
245
      /**
246
      * Return x if the mask is set, or otherwise zero
247
      */
248
      T if_set_return(T x) const
249
9.90G
         {
250
9.90G
         return m_mask & x;
251
9.90G
         }
Botan::CT::Mask<unsigned long>::if_set_return(unsigned long) const
Line
Count
Source
249
9.90G
         {
250
9.90G
         return m_mask & x;
251
9.90G
         }
Botan::CT::Mask<unsigned char>::if_set_return(unsigned char) const
Line
Count
Source
249
836k
         {
250
836k
         return m_mask & x;
251
836k
         }
Botan::CT::Mask<unsigned short>::if_set_return(unsigned short) const
Line
Count
Source
249
528
         {
250
528
         return m_mask & x;
251
528
         }
252
253
      /**
254
      * Return x if the mask is cleared, or otherwise zero
255
      */
256
      T if_not_set_return(T x) const
257
62.2M
         {
258
62.2M
         return ~m_mask & x;
259
62.2M
         }
Botan::CT::Mask<unsigned long>::if_not_set_return(unsigned long) const
Line
Count
Source
257
60.7M
         {
258
60.7M
         return ~m_mask & x;
259
60.7M
         }
Botan::CT::Mask<unsigned char>::if_not_set_return(unsigned char) const
Line
Count
Source
257
1.47M
         {
258
1.47M
         return ~m_mask & x;
259
1.47M
         }
Botan::CT::Mask<unsigned short>::if_not_set_return(unsigned short) const
Line
Count
Source
257
496
         {
258
496
         return ~m_mask & x;
259
496
         }
260
261
      /**
262
      * If this mask is set, return x, otherwise return y
263
      */
264
      T select(T x, T y) const
265
28.2G
         {
266
         // (x & value()) | (y & ~value())
267
28.2G
         return static_cast<T>(y ^ (value() & (x ^ y)));
268
28.2G
         }
Botan::CT::Mask<unsigned long>::select(unsigned long, unsigned long) const
Line
Count
Source
265
28.2G
         {
266
         // (x & value()) | (y & ~value())
267
28.2G
         return static_cast<T>(y ^ (value() & (x ^ y)));
268
28.2G
         }
Botan::CT::Mask<unsigned char>::select(unsigned char, unsigned char) const
Line
Count
Source
265
21.2M
         {
266
         // (x & value()) | (y & ~value())
267
21.2M
         return static_cast<T>(y ^ (value() & (x ^ y)));
268
21.2M
         }
Botan::CT::Mask<unsigned int>::select(unsigned int, unsigned int) const
Line
Count
Source
265
374k
         {
266
         // (x & value()) | (y & ~value())
267
374k
         return static_cast<T>(y ^ (value() & (x ^ y)));
268
374k
         }
Unexecuted instantiation: Botan::CT::Mask<unsigned short>::select(unsigned short, unsigned short) const
269
270
      T select_and_unpoison(T x, T y) const
271
689
         {
272
689
         T r = this->select(x, y);
273
689
         CT::unpoison(r);
274
689
         return r;
275
689
         }
Botan::CT::Mask<unsigned long>::select_and_unpoison(unsigned long, unsigned long) const
Line
Count
Source
271
531
         {
272
531
         T r = this->select(x, y);
273
531
         CT::unpoison(r);
274
531
         return r;
275
531
         }
Botan::CT::Mask<unsigned char>::select_and_unpoison(unsigned char, unsigned char) const
Line
Count
Source
271
158
         {
272
158
         T r = this->select(x, y);
273
158
         CT::unpoison(r);
274
158
         return r;
275
158
         }
276
277
      /**
278
      * If this mask is set, return x, otherwise return y
279
      */
280
      Mask<T> select_mask(Mask<T> x, Mask<T> y) const
281
1.04G
         {
282
1.04G
         return Mask<T>(select(x.value(), y.value()));
283
1.04G
         }
284
285
      /**
286
      * Conditionally set output to x or y, depending on if mask is set or
287
      * cleared (resp)
288
      */
289
      void select_n(T output[], const T x[], const T y[], size_t len) const
290
602M
         {
291
6.15G
         for(size_t i = 0; i != len; ++i)
292
5.55G
            output[i] = this->select(x[i], y[i]);
293
602M
         }
Botan::CT::Mask<unsigned long>::select_n(unsigned long*, unsigned long const*, unsigned long const*, unsigned long) const
Line
Count
Source
290
602M
         {
291
6.15G
         for(size_t i = 0; i != len; ++i)
292
5.55G
            output[i] = this->select(x[i], y[i]);
293
602M
         }
Unexecuted instantiation: Botan::CT::Mask<unsigned char>::select_n(unsigned char*, unsigned char const*, unsigned char const*, unsigned long) const
294
295
      /**
296
      * If this mask is set, zero out buf, otherwise do nothing
297
      */
298
      void if_set_zero_out(T buf[], size_t elems)
299
56.1k
         {
300
1.47M
         for(size_t i = 0; i != elems; ++i)
301
1.41M
            {
302
1.41M
            buf[i] = this->if_not_set_return(buf[i]);
303
1.41M
            }
304
56.1k
         }
Botan::CT::Mask<unsigned long>::if_set_zero_out(unsigned long*, unsigned long)
Line
Count
Source
299
53.2k
         {
300
409k
         for(size_t i = 0; i != elems; ++i)
301
356k
            {
302
356k
            buf[i] = this->if_not_set_return(buf[i]);
303
356k
            }
304
53.2k
         }
Botan::CT::Mask<unsigned char>::if_set_zero_out(unsigned char*, unsigned long)
Line
Count
Source
299
2.84k
         {
300
1.06M
         for(size_t i = 0; i != elems; ++i)
301
1.06M
            {
302
1.06M
            buf[i] = this->if_not_set_return(buf[i]);
303
1.06M
            }
304
2.84k
         }
305
306
      /**
307
      * Return the value of the mask, unpoisoned
308
      */
309
      T unpoisoned_value() const
310
12.2M
         {
311
12.2M
         T r = value();
312
12.2M
         CT::unpoison(r);
313
12.2M
         return r;
314
12.2M
         }
Botan::CT::Mask<unsigned long>::unpoisoned_value() const
Line
Count
Source
310
11.8M
         {
311
11.8M
         T r = value();
312
11.8M
         CT::unpoison(r);
313
11.8M
         return r;
314
11.8M
         }
Botan::CT::Mask<unsigned int>::unpoisoned_value() const
Line
Count
Source
310
374k
         {
311
374k
         T r = value();
312
374k
         CT::unpoison(r);
313
374k
         return r;
314
374k
         }
Botan::CT::Mask<unsigned char>::unpoisoned_value() const
Line
Count
Source
310
401
         {
311
401
         T r = value();
312
401
         CT::unpoison(r);
313
401
         return r;
314
401
         }
Botan::CT::Mask<unsigned short>::unpoisoned_value() const
Line
Count
Source
310
264
         {
311
264
         T r = value();
312
264
         CT::unpoison(r);
313
264
         return r;
314
264
         }
315
316
      /**
317
      * Return true iff this mask is set
318
      */
319
      bool is_set() const
320
12.2M
         {
321
12.2M
         return unpoisoned_value() != 0;
322
12.2M
         }
Botan::CT::Mask<unsigned long>::is_set() const
Line
Count
Source
320
11.8M
         {
321
11.8M
         return unpoisoned_value() != 0;
322
11.8M
         }
Botan::CT::Mask<unsigned int>::is_set() const
Line
Count
Source
320
374k
         {
321
374k
         return unpoisoned_value() != 0;
322
374k
         }
Unexecuted instantiation: Botan::CT::Mask<unsigned char>::is_set() const
Botan::CT::Mask<unsigned short>::is_set() const
Line
Count
Source
320
264
         {
321
264
         return unpoisoned_value() != 0;
322
264
         }
323
324
      /**
325
      * Return the underlying value of the mask
326
      */
327
      T value() const
328
32.9G
         {
329
32.9G
         return m_mask;
330
32.9G
         }
Botan::CT::Mask<unsigned long>::value() const
Line
Count
Source
328
32.8G
         {
329
32.8G
         return m_mask;
330
32.8G
         }
Botan::CT::Mask<unsigned char>::value() const
Line
Count
Source
328
46.2M
         {
329
46.2M
         return m_mask;
330
46.2M
         }
Botan::CT::Mask<unsigned int>::value() const
Line
Count
Source
328
1.12M
         {
329
1.12M
         return m_mask;
330
1.12M
         }
Botan::CT::Mask<unsigned short>::value() const
Line
Count
Source
328
372k
         {
329
372k
         return m_mask;
330
372k
         }
331
332
   private:
333
9.57G
      Mask(T m) : m_mask(m) {}
Botan::CT::Mask<unsigned long>::Mask(unsigned long)
Line
Count
Source
333
9.52G
      Mask(T m) : m_mask(m) {}
Botan::CT::Mask<unsigned char>::Mask(unsigned char)
Line
Count
Source
333
45.4M
      Mask(T m) : m_mask(m) {}
Botan::CT::Mask<unsigned int>::Mask(unsigned int)
Line
Count
Source
333
749k
      Mask(T m) : m_mask(m) {}
Botan::CT::Mask<unsigned short>::Mask(unsigned short)
Line
Count
Source
333
373k
      Mask(T m) : m_mask(m) {}
334
335
      T m_mask;
336
   };
337
338
template<typename T>
339
inline Mask<T> conditional_copy_mem(T cnd,
340
                                    T* to,
341
                                    const T* from0,
342
                                    const T* from1,
343
                                    size_t elems)
344
124M
   {
345
124M
   const auto mask = CT::Mask<T>::expand(cnd);
346
124M
   mask.select_n(to, from0, from1, elems);
347
124M
   return mask;
348
124M
   }
349
350
template<typename T>
351
inline void conditional_swap(bool cnd, T& x, T& y)
352
33.8M
   {
353
33.8M
   const auto swap = CT::Mask<T>::expand(cnd);
354
355
33.8M
   T t0 = swap.select(y, x);
356
33.8M
   T t1 = swap.select(x, y);
357
33.8M
   x = t0;
358
33.8M
   y = t1;
359
33.8M
   }
360
361
template<typename T>
362
inline void conditional_swap_ptr(bool cnd, T& x, T& y)
363
16.9M
   {
364
16.9M
   uintptr_t xp = reinterpret_cast<uintptr_t>(x);
365
16.9M
   uintptr_t yp = reinterpret_cast<uintptr_t>(y);
366
367
16.9M
   conditional_swap<uintptr_t>(cnd, xp, yp);
368
369
16.9M
   x = reinterpret_cast<T>(xp);
370
16.9M
   y = reinterpret_cast<T>(yp);
371
16.9M
   }
372
373
/**
374
* If bad_mask is unset, return in[delim_idx:input_length] copied to
375
* new buffer. If bad_mask is set, return an all zero vector of
376
* unspecified length.
377
*/
378
secure_vector<uint8_t> copy_output(CT::Mask<uint8_t> bad_input,
379
                                   const uint8_t input[],
380
                                   size_t input_length,
381
                                   size_t delim_idx);
382
383
secure_vector<uint8_t> strip_leading_zeros(const uint8_t in[], size_t length);
384
385
inline secure_vector<uint8_t> strip_leading_zeros(const secure_vector<uint8_t>& in)
386
2.44k
   {
387
2.44k
   return strip_leading_zeros(in.data(), in.size());
388
2.44k
   }
389
390
}
391
392
}
393
394
#endif