Add a test to verify the ClientHello version is the same in a reneg
[openssl.git] / test / constant_time_test.c
1 /*
2  * Copyright 2014-2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include <stdlib.h>
12
13 #include "internal/nelem.h"
14 #include "internal/constant_time_locl.h"
15 #include "testutil.h"
16 #include "internal/numbers.h"
17
18 static const unsigned int CONSTTIME_TRUE = (unsigned)(~0);
19 static const unsigned int CONSTTIME_FALSE = 0;
20 static const unsigned char CONSTTIME_TRUE_8 = 0xff;
21 static const unsigned char CONSTTIME_FALSE_8 = 0;
22 static const size_t CONSTTIME_TRUE_S = ~((size_t)0);
23 static const size_t CONSTTIME_FALSE_S = 0;
24 static uint32_t CONSTTIME_TRUE_32 = (uint32_t)(~(uint32_t)0);
25 static uint32_t CONSTTIME_FALSE_32 = 0;
26 static uint64_t CONSTTIME_TRUE_64 = (uint64_t)(~(uint64_t)0);
27 static uint64_t CONSTTIME_FALSE_64 = 0;
28
29 static unsigned int test_values[] = {
30     0, 1, 1024, 12345, 32000, UINT_MAX / 2 - 1,
31     UINT_MAX / 2, UINT_MAX / 2 + 1, UINT_MAX - 1,
32     UINT_MAX
33 };
34
35 static unsigned char test_values_8[] = {
36     0, 1, 2, 20, 32, 127, 128, 129, 255
37 };
38
39 static int signed_test_values[] = {
40     0, 1, -1, 1024, -1024, 12345, -12345,
41     32000, -32000, INT_MAX, INT_MIN, INT_MAX - 1,
42     INT_MIN + 1
43 };
44
45 static size_t test_values_s[] = {
46     0, 1, 1024, 12345, 32000, SIZE_MAX / 2 - 1,
47     SIZE_MAX / 2, SIZE_MAX / 2 + 1, SIZE_MAX - 1,
48     SIZE_MAX
49 };
50
51 static uint32_t test_values_32[] = {
52     0, 1, 1024, 12345, 32000, UINT32_MAX / 2, UINT32_MAX / 2 + 1,
53     UINT32_MAX - 1, UINT32_MAX
54 };
55
56 static uint64_t test_values_64[] = {
57     0, 1, 1024, 12345, 32000, 32000000, 32000000001, UINT64_MAX / 2,
58     UINT64_MAX / 2 + 1, UINT64_MAX - 1, UINT64_MAX
59 };
60
61 static int test_binary_op(unsigned int (*op) (unsigned int a, unsigned int b),
62                           const char *op_name, unsigned int a, unsigned int b,
63                           int is_true)
64 {
65     if (is_true && !TEST_uint_eq(op(a, b), CONSTTIME_TRUE))
66         return 0;
67     if (!is_true && !TEST_uint_eq(op(a, b), CONSTTIME_FALSE))
68         return 0;
69     return 1;
70 }
71
72 static int test_binary_op_8(unsigned
73                             char (*op) (unsigned int a, unsigned int b),
74                             const char *op_name, unsigned int a,
75                             unsigned int b, int is_true)
76 {
77     if (is_true && !TEST_uint_eq(op(a, b), CONSTTIME_TRUE_8))
78         return 0;
79     if (!is_true && !TEST_uint_eq(op(a, b), CONSTTIME_FALSE_8))
80         return 0;
81     return 1;
82 }
83
84 static int test_binary_op_s(size_t (*op) (size_t a, size_t b),
85                             const char *op_name, size_t a, size_t b,
86                             int is_true)
87 {
88     if (is_true && !TEST_size_t_eq(op(a,b), CONSTTIME_TRUE_S))
89         return 0;
90     if (!is_true && !TEST_uint_eq(op(a,b), CONSTTIME_FALSE_S))
91         return 0;
92     return 1;
93 }
94
95 static int test_binary_op_64(uint64_t (*op)(uint64_t a, uint64_t b),
96                              const char *op_name, uint64_t a, uint64_t b,
97                              int is_true)
98 {
99     uint64_t c = op(a, b);
100
101     if (is_true && c != CONSTTIME_TRUE_64) {
102         TEST_error("TRUE %s op failed", op_name);
103         BIO_printf(bio_err, "a=%jx b=%jx\n", a, b);
104         return 0;
105     } else if (!is_true && c != CONSTTIME_FALSE_64) {
106         TEST_error("FALSE %s op failed", op_name);
107         BIO_printf(bio_err, "a=%jx b=%jx\n", a, b);
108         return 0;
109     }
110     return 1;
111 }
112
113 static int test_is_zero(int i)
114 {
115     unsigned int a = test_values[i];
116
117     if (a == 0 && !TEST_uint_eq(constant_time_is_zero(a), CONSTTIME_TRUE))
118         return 0;
119     if (a != 0 && !TEST_uint_eq(constant_time_is_zero(a), CONSTTIME_FALSE))
120         return 0;
121     return 1;
122 }
123
124 static int test_is_zero_8(int i)
125 {
126     unsigned int a = test_values_8[i];
127
128     if (a == 0 && !TEST_uint_eq(constant_time_is_zero_8(a), CONSTTIME_TRUE_8))
129         return 0;
130     if (a != 0 && !TEST_uint_eq(constant_time_is_zero_8(a), CONSTTIME_FALSE_8))
131         return 0;
132     return 1;
133 }
134
135 static int test_is_zero_32(int i)
136 {
137     uint32_t a = test_values_32[i];
138
139     if (a == 0 && !TEST_true(constant_time_is_zero_32(a) == CONSTTIME_TRUE_32))
140         return 0;
141     if (a != 0 && !TEST_true(constant_time_is_zero_32(a) == CONSTTIME_FALSE_32))
142         return 0;
143     return 1;
144 }
145
146 static int test_is_zero_s(int i)
147 {
148     size_t a = test_values_s[i];
149
150     if (a == 0 && !TEST_size_t_eq(constant_time_is_zero_s(a), CONSTTIME_TRUE_S))
151         return 0;
152     if (a != 0 && !TEST_uint_eq(constant_time_is_zero_s(a), CONSTTIME_FALSE_S))
153         return 0;
154     return 1;
155 }
156
157 static int test_select(unsigned int a, unsigned int b)
158 {
159     if (!TEST_uint_eq(constant_time_select(CONSTTIME_TRUE, a, b), a))
160         return 0;
161     if (!TEST_uint_eq(constant_time_select(CONSTTIME_FALSE, a, b), b))
162         return 0;
163     return 1;
164 }
165
166 static int test_select_8(unsigned char a, unsigned char b)
167 {
168     if (!TEST_uint_eq(constant_time_select_8(CONSTTIME_TRUE_8, a, b), a))
169         return 0;
170     if (!TEST_uint_eq(constant_time_select_8(CONSTTIME_FALSE_8, a, b), b))
171         return 0;
172     return 1;
173 }
174
175 static int test_select_32(uint32_t a, uint32_t b)
176 {
177     if (!TEST_true(constant_time_select_32(CONSTTIME_TRUE_32, a, b) == a))
178         return 0;
179     if (!TEST_true(constant_time_select_32(CONSTTIME_FALSE_32, a, b) == b))
180         return 0;
181     return 1;
182 }
183
184 static int test_select_s(size_t a, size_t b)
185 {
186     if (!TEST_uint_eq(constant_time_select_s(CONSTTIME_TRUE_S, a, b), a))
187         return 0;
188     if (!TEST_uint_eq(constant_time_select_s(CONSTTIME_FALSE_S, a, b), b))
189         return 0;
190     return 1;
191 }
192
193 static int test_select_64(uint64_t a, uint64_t b)
194 {
195     uint64_t selected = constant_time_select_64(CONSTTIME_TRUE_64, a, b);
196
197     if (selected != a) {
198         TEST_error("test_select_64 TRUE failed");
199         BIO_printf(bio_err, "a=%jx b=%jx got %jx wanted a\n", a, b, selected);
200         return 0;
201     }
202     selected = constant_time_select_64(CONSTTIME_FALSE_64, a, b);
203     if (selected != b) {
204         BIO_printf(bio_err, "a=%jx b=%jx got %jx wanted b\n", a, b, selected);
205         return 0;
206     }
207     return 1;
208 }
209
210 static int test_select_int(int a, int b)
211 {
212     if (!TEST_int_eq(constant_time_select_int(CONSTTIME_TRUE, a, b), a))
213         return 0;
214     if (!TEST_int_eq(constant_time_select_int(CONSTTIME_FALSE, a, b), b))
215         return 0;
216     return 1;
217 }
218
219 static int test_eq_int_8(int a, int b)
220 {
221     if (a == b && !TEST_int_eq(constant_time_eq_int_8(a, b), CONSTTIME_TRUE_8))
222         return 0;
223     if (a != b && !TEST_int_eq(constant_time_eq_int_8(a, b), CONSTTIME_FALSE_8))
224         return 0;
225     return 1;
226 }
227
228 static int test_eq_s(size_t a, size_t b)
229 {
230     if (a == b && !TEST_size_t_eq(constant_time_eq_s(a, b), CONSTTIME_TRUE_S))
231         return 0;
232     if (a != b && !TEST_int_eq(constant_time_eq_s(a, b), CONSTTIME_FALSE_S))
233         return 0;
234     return 1;
235 }
236
237 static int test_eq_int(int a, int b)
238 {
239     if (a == b && !TEST_uint_eq(constant_time_eq_int(a, b), CONSTTIME_TRUE))
240         return 0;
241     if (a != b && !TEST_uint_eq(constant_time_eq_int(a, b), CONSTTIME_FALSE))
242         return 0;
243     return 1;
244 }
245
246 static int test_sizeofs(void)
247 {
248     if (!TEST_uint_eq(OSSL_NELEM(test_values), OSSL_NELEM(test_values_s)))
249         return 0;
250     return 1;
251 }
252
253 static int test_binops(int i)
254 {
255     unsigned int a = test_values[i];
256     int j;
257     int ret = 1;
258
259     for (j = 0; j < (int)OSSL_NELEM(test_values); ++j) {
260         unsigned int b = test_values[j];
261
262         if (!test_select(a, b)
263                 || !test_binary_op(&constant_time_lt, "ct_lt",
264                                    a, b, a < b)
265                 || !test_binary_op(&constant_time_lt, "constant_time_lt",
266                                    b, a, b < a)
267                 || !test_binary_op(&constant_time_ge, "constant_time_ge",
268                                    a, b, a >= b)
269                 || !test_binary_op(&constant_time_ge, "constant_time_ge",
270                                    b, a, b >= a)
271                 || !test_binary_op(&constant_time_eq, "constant_time_eq",
272                                    a, b, a == b)
273                 || !test_binary_op(&constant_time_eq, "constant_time_eq",
274                                    b, a, b == a))
275             ret = 0;
276     }
277     return ret;
278 }
279
280 static int test_binops_8(int i)
281 {
282     unsigned int a = test_values_8[i];
283     int j;
284     int ret = 1;
285
286     for (j = 0; j < (int)OSSL_NELEM(test_values_8); ++j) {
287         unsigned int b = test_values_8[j];
288
289         if (!test_binary_op_8(&constant_time_lt_8, "constant_time_lt_8",
290                                      a, b, a < b)
291                 || !test_binary_op_8(&constant_time_lt_8, "constant_time_lt_8",
292                                      b, a, b < a)
293                 || !test_binary_op_8(&constant_time_ge_8, "constant_time_ge_8",
294                                      a, b, a >= b)
295                 || !test_binary_op_8(&constant_time_ge_8, "constant_time_ge_8",
296                                      b, a, b >= a)
297                 || !test_binary_op_8(&constant_time_eq_8, "constant_time_eq_8",
298                                      a, b, a == b)
299                 || !test_binary_op_8(&constant_time_eq_8, "constant_time_eq_8",
300                                      b, a, b == a))
301             ret = 0;
302     }
303     return ret;
304 }
305
306 static int test_binops_s(int i)
307 {
308     size_t a = test_values_s[i];
309     int j;
310     int ret = 1;
311
312     for (j = 0; j < (int)OSSL_NELEM(test_values_s); ++j) {
313         size_t b = test_values_s[j];
314
315         if (!test_select_s(a, b)
316                 || !test_eq_s(a, b)
317                 || !test_binary_op_s(&constant_time_lt_s, "constant_time_lt_s",
318                                      a, b, a < b)
319                 || !test_binary_op_s(&constant_time_lt_s, "constant_time_lt_s",
320                                      b, a, b < a)
321                 || !test_binary_op_s(&constant_time_ge_s, "constant_time_ge_s",
322                                      a, b, a >= b)
323                 || !test_binary_op_s(&constant_time_ge_s, "constant_time_ge_s",
324                                      b, a, b >= a)
325                 || !test_binary_op_s(&constant_time_eq_s, "constant_time_eq_s",
326                                      a, b, a == b)
327                 || !test_binary_op_s(&constant_time_eq_s, "constant_time_eq_s",
328                                      b, a, b == a))
329             ret = 0;
330     }
331     return ret;
332 }
333
334 static int test_signed(int i)
335 {
336     int c = signed_test_values[i];
337     unsigned int j;
338     int ret = 1;
339
340     for (j = 0; j < OSSL_NELEM(signed_test_values); ++j) {
341         int d = signed_test_values[j];
342
343         if (!test_select_int(c, d)
344                 || !test_eq_int(c, d)
345                 || !test_eq_int_8(c, d))
346             ret = 0;
347     }
348     return ret;
349 }
350
351 static int test_8values(int i)
352 {
353     unsigned char e = test_values_8[i];
354     unsigned int j;
355     int ret = 1;
356
357     for (j = 0; j < sizeof(test_values_8); ++j) {
358         unsigned char f = test_values_8[j];
359
360         if (!test_select_8(e, f))
361             ret = 0;
362     }
363     return ret;
364 }
365
366 static int test_32values(int i)
367 {
368     uint32_t e = test_values_32[i];
369     size_t j;
370     int ret = 1;
371
372     for (j = 0; j < OSSL_NELEM(test_values_32); j++) {
373         uint32_t f = test_values_32[j];
374
375         if (!test_select_32(e, f))
376             ret = 0;
377     }
378     return ret;
379 }
380
381 static int test_64values(int i)
382 {
383     uint64_t g = test_values_64[i];
384     int j, ret = 1;
385
386     for (j = i + 1; j < (int)OSSL_NELEM(test_values_64); j++) {
387         uint64_t h = test_values_64[j];
388
389         if (!test_binary_op_64(&constant_time_lt_64, "constant_time_lt_64",
390                                g, h, g < h)
391                 || !test_select_64(g, h)) {
392             TEST_info("test_64values failed i=%d j=%d", i, j);
393             ret = 0;
394         }
395     }
396     return ret;
397 }
398
399 int setup_tests(void)
400 {
401     ADD_TEST(test_sizeofs);
402     ADD_ALL_TESTS(test_is_zero, OSSL_NELEM(test_values));
403     ADD_ALL_TESTS(test_is_zero_8, OSSL_NELEM(test_values_8));
404     ADD_ALL_TESTS(test_is_zero_32, OSSL_NELEM(test_values_32));
405     ADD_ALL_TESTS(test_is_zero_s, OSSL_NELEM(test_values_s));
406     ADD_ALL_TESTS(test_binops, OSSL_NELEM(test_values));
407     ADD_ALL_TESTS(test_binops_8, OSSL_NELEM(test_values_8));
408     ADD_ALL_TESTS(test_binops_s, OSSL_NELEM(test_values_s));
409     ADD_ALL_TESTS(test_signed, OSSL_NELEM(signed_test_values));
410     ADD_ALL_TESTS(test_8values, OSSL_NELEM(test_values_8));
411     ADD_ALL_TESTS(test_32values, OSSL_NELEM(test_values_32));
412     ADD_ALL_TESTS(test_64values, OSSL_NELEM(test_values_64));
413     return 1;
414 }