test/constant_time_test.c

   1 /*
   2  * Copyright 2014-2017 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 uint64_t CONSTTIME_TRUE_64 = (uint64_t)(~(uint64_t)0);
  25 static uint64_t CONSTTIME_FALSE_64 = 0;
  26
  27 static int test_binary_op(unsigned int (*op) (unsigned int a, unsigned int b),
  28                           const char *op_name, unsigned int a, unsigned int b,
  29                           int is_true)
  30 {
  31     if (is_true && !TEST_uint_eq(op(a, b), CONSTTIME_TRUE))
  32         return 0;
  33     if (!is_true && !TEST_uint_eq(op(a, b), CONSTTIME_FALSE))
  34         return 0;
  35     return 1;
  36 }
  37
  38 static int test_binary_op_8(unsigned
  39                             char (*op) (unsigned int a, unsigned int b),
  40                             const char *op_name, unsigned int a,
  41                             unsigned int b, int is_true)
  42 {
  43     if (is_true && !TEST_uint_eq(op(a, b), CONSTTIME_TRUE_8))
  44         return 0;
  45     if (!is_true && !TEST_uint_eq(op(a, b), CONSTTIME_FALSE_8))
  46         return 0;
  47     return 1;
  48 }
  49
  50 static int test_binary_op_s(size_t (*op) (size_t a, size_t b),
  51                             const char *op_name, size_t a, size_t b,
  52                             int is_true)
  53 {
  54     if (is_true && !TEST_size_t_eq(op(a,b), CONSTTIME_TRUE_S))
  55         return 0;
  56     if (!is_true && !TEST_uint_eq(op(a,b), CONSTTIME_FALSE_S))
  57         return 0;
  58     return 1;
  59 }
  60
  61 static int test_binary_op_64(uint64_t (*op)(uint64_t a, uint64_t b),
  62                              const char *op_name, uint64_t a, uint64_t b,
  63                              int is_true)
  64 {
  65     uint64_t c = op(a, b);
  66
  67     if (is_true && c != CONSTTIME_TRUE_64) {
  68         TEST_error("TRUE %s op failed", op_name);
  69         BIO_printf(bio_err, "a=%jx b=%jx\n", a, b);
  70         return 0;
  71     } else if (!is_true && c != CONSTTIME_FALSE_64) {
  72         TEST_error("FALSE %s op failed", op_name);
  73         BIO_printf(bio_err, "a=%jx b=%jx\n", a, b);
  74         return 0;
  75     }
  76     return 1;
  77 }
  78
  79
  80 static int test_is_zero(unsigned int a)
  81 {
  82     if (a == 0 && !TEST_uint_eq(constant_time_is_zero(a), CONSTTIME_TRUE))
  83         return 0;
  84     if (a != 0 && !TEST_uint_eq(constant_time_is_zero(a), CONSTTIME_FALSE))
  85         return 0;
  86     return 1;
  87 }
  88
  89 static int test_is_zero_8(unsigned int a)
  90 {
  91     if (a == 0 && !TEST_uint_eq(constant_time_is_zero_8(a), CONSTTIME_TRUE_8))
  92         return 0;
  93     if (a != 0 && !TEST_uint_eq(constant_time_is_zero_8(a), CONSTTIME_FALSE_8))
  94         return 0;
  95     return 1;
  96 }
  97
  98 static int test_is_zero_s(unsigned int a)
  99 {
 100     if (a == 0 && !TEST_size_t_eq(constant_time_is_zero_s(a), CONSTTIME_TRUE_S))
 101         return 0;
 102     if (a != 0 && !TEST_uint_eq(constant_time_is_zero_s(a), CONSTTIME_FALSE_S))
 103         return 0;
 104     return 1;
 105 }
 106
 107 static int test_select(unsigned int a, unsigned int b)
 108 {
 109     if (!TEST_uint_eq(constant_time_select(CONSTTIME_TRUE, a, b), a))
 110         return 0;
 111     if (!TEST_uint_eq(constant_time_select(CONSTTIME_FALSE, a, b), b))
 112         return 0;
 113     return 1;
 114 }
 115
 116 static int test_select_8(unsigned char a, unsigned char b)
 117 {
 118     if (!TEST_uint_eq(constant_time_select_8(CONSTTIME_TRUE_8, a, b), a))
 119         return 0;
 120     if (!TEST_uint_eq(constant_time_select_8(CONSTTIME_FALSE_8, a, b), b))
 121         return 0;
 122     return 1;
 123 }
 124
 125 static int test_select_s(unsigned char a, unsigned char b)
 126 {
 127     if (!TEST_uint_eq(constant_time_select_s(CONSTTIME_TRUE_S, a, b), a))
 128         return 0;
 129     if (!TEST_uint_eq(constant_time_select_s(CONSTTIME_FALSE_S, a, b), b))
 130         return 0;
 131     return 1;
 132 }
 133
 134 static int test_select_64(uint64_t a, uint64_t b)
 135 {
 136     uint64_t selected = constant_time_select_64(CONSTTIME_TRUE_64, a, b);
 137
 138     if (selected != a) {
 139         TEST_error("test_select_64 TRUE failed");
 140         BIO_printf(bio_err, "a=%jx b=%jx got %jx wanted a\n", a, b, selected);
 141         return 0;
 142     }
 143     selected = constant_time_select_64(CONSTTIME_FALSE_64, a, b);
 144     if (selected != b) {
 145         BIO_printf(bio_err, "a=%jx b=%jx got %jx wanted b\n", a, b, selected);
 146         return 0;
 147     }
 148     return 1;
 149 }
 150
 151 static int test_select_int(int a, int b)
 152 {
 153     if (!TEST_int_eq(constant_time_select_int(CONSTTIME_TRUE, a, b), a))
 154         return 0;
 155     if (!TEST_int_eq(constant_time_select_int(CONSTTIME_FALSE, a, b), b))
 156         return 0;
 157     return 1;
 158 }
 159
 160 static int test_eq_int_8(int a, int b)
 161 {
 162     if (a == b && !TEST_int_eq(constant_time_eq_int_8(a, b), CONSTTIME_TRUE_8))
 163         return 0;
 164     if (a != b && !TEST_int_eq(constant_time_eq_int_8(a, b), CONSTTIME_FALSE_8))
 165         return 0;
 166     return 1;
 167 }
 168
 169 static int test_eq_s(size_t a, size_t b)
 170 {
 171     if (a == b && !TEST_size_t_eq(constant_time_eq_s(a, b), CONSTTIME_TRUE_S))
 172         return 0;
 173     if (a != b && !TEST_int_eq(constant_time_eq_s(a, b), CONSTTIME_FALSE_S))
 174         return 0;
 175     return 1;
 176 }
 177
 178 static int test_eq_int(int a, int b)
 179 {
 180     if (a == b && !TEST_uint_eq(constant_time_eq_int(a, b), CONSTTIME_TRUE))
 181         return 0;
 182     if (a != b && !TEST_uint_eq(constant_time_eq_int(a, b), CONSTTIME_FALSE))
 183         return 0;
 184     return 1;
 185 }
 186
 187 static unsigned int test_values[] = {
 188     0, 1, 1024, 12345, 32000, UINT_MAX / 2 - 1,
 189     UINT_MAX / 2, UINT_MAX / 2 + 1, UINT_MAX - 1,
 190     UINT_MAX
 191 };
 192
 193 static unsigned char test_values_8[] = {
 194     0, 1, 2, 20, 32, 127, 128, 129, 255
 195 };
 196
 197 static int signed_test_values[] = {
 198     0, 1, -1, 1024, -1024, 12345, -12345,
 199     32000, -32000, INT_MAX, INT_MIN, INT_MAX - 1,
 200     INT_MIN + 1
 201 };
 202
 203 static size_t test_values_s[] = {
 204     0, 1, 1024, 12345, 32000, SIZE_MAX / 2 - 1,
 205     SIZE_MAX / 2, SIZE_MAX / 2 + 1, SIZE_MAX - 1,
 206     SIZE_MAX
 207 };
 208
 209 static uint64_t test_values_64[] = {
 210     0, 1, 1024, 12345, 32000, 32000000, 32000000001, UINT64_MAX / 2,
 211     UINT64_MAX / 2 + 1, UINT64_MAX - 1, UINT64_MAX
 212 };
 213
 214 static int test_sizeofs(void)
 215 {
 216     if (!TEST_uint_eq(OSSL_NELEM(test_values), OSSL_NELEM(test_values_s)))
 217         return 0;
 218     return 1;
 219 }
 220
 221 static int test_binops(int i)
 222 {
 223     unsigned int a = test_values[i];
 224     unsigned int g = test_values_s[i];
 225     int j;
 226     int ret = 1;
 227
 228     if (!test_is_zero(a) || !test_is_zero_8(a) || !test_is_zero_s(g))
 229         ret = 0;
 230
 231     for (j = 0; j < (int)OSSL_NELEM(test_values); ++j) {
 232         unsigned int b = test_values[j];
 233         unsigned int h = test_values[j];
 234
 235         if (!test_select(a, b)
 236                 || !test_select_s(g, h)
 237                 || !test_eq_s(g, h)
 238                 || !test_binary_op(&constant_time_lt, "ct_lt",
 239                                    a, b, a < b)
 240                 || !test_binary_op_8(&constant_time_lt_8, "constant_time_lt_8",
 241                                      a, b, a < b)
 242                 || !test_binary_op_s(&constant_time_lt_s, "constant_time_lt_s",
 243                                      g, h, g < h)
 244                 || !test_binary_op(&constant_time_lt, "constant_time_lt",
 245                                    b, a, b < a)
 246                 || !test_binary_op_8(&constant_time_lt_8, "constant_time_lt_8",
 247                                      b, a, b < a)
 248                 || !test_binary_op_s(&constant_time_lt_s, "constant_time_lt_s",
 249                                      h, g, h < g)
 250                 || !test_binary_op(&constant_time_ge, "constant_time_ge",
 251                                    a, b, a >= b)
 252                 || !test_binary_op_8(&constant_time_ge_8, "constant_time_ge_8",
 253                                      a, b, a >= b)
 254                 || !test_binary_op_s(&constant_time_ge_s, "constant_time_ge_s",
 255                                      g, h, g >= h)
 256                 || !test_binary_op(&constant_time_ge, "constant_time_ge",
 257                                    b, a, b >= a)
 258                 || !test_binary_op_8(&constant_time_ge_8, "constant_time_ge_8",
 259                                      b, a, b >= a)
 260                 || !test_binary_op_s(&constant_time_ge_s, "constant_time_ge_s",
 261                                      h, g, h >= g)
 262                 || !test_binary_op(&constant_time_eq, "constant_time_eq",
 263                                    a, b, a == b)
 264                 || !test_binary_op_8(&constant_time_eq_8, "constant_time_eq_8",
 265                                      a, b, a == b)
 266                 || !test_binary_op_s(&constant_time_eq_s, "constant_time_eq_s",
 267                                      g, h, g == h)
 268                 || !test_binary_op(&constant_time_eq, "constant_time_eq",
 269                                    b, a, b == a)
 270                 || !test_binary_op_8(&constant_time_eq_8, "constant_time_eq_8",
 271                                      b, a, b == a)
 272                 || !test_binary_op_s(&constant_time_eq_s, "constant_time_eq_s",
 273                                      h, g, h == g)) {
 274             ret = 0;
 275         }
 276     }
 277     return ret;
 278 }
 279
 280 static int test_signed(int i)
 281 {
 282     int c = signed_test_values[i];
 283     unsigned int j;
 284     int ret = 1;
 285
 286     for (j = 0; j < OSSL_NELEM(signed_test_values); ++j) {
 287         int d = signed_test_values[j];
 288
 289         if (!test_select_int(c, d)
 290                 || !test_eq_int(c, d)
 291                 || !test_eq_int_8(c, d))
 292             ret = 0;
 293     }
 294     return ret;
 295 }
 296
 297 static int test_8values(int i)
 298 {
 299     unsigned char e = test_values_8[i];
 300     unsigned int j;
 301     int ret = 1;
 302
 303     for (j = 0; j < sizeof(test_values_8); ++j) {
 304         unsigned char f = test_values_8[j];
 305
 306         if (!test_select_8(e, f))
 307             ret = 0;
 308     }
 309     return ret;
 310 }
 311
 312 static int test_64values(int i)
 313 {
 314     uint64_t g = test_values_64[i];
 315     int j, ret = 1;
 316
 317     for (j = i + 1; j < (int)OSSL_NELEM(test_values_64); j++) {
 318         uint64_t h = test_values_64[j];
 319
 320         if (!test_binary_op_64(&constant_time_lt_64, "constant_time_lt_64",
 321                                g, h, g < h)
 322                 || !test_select_64(g, h)) {
 323             TEST_info("test_64values failed i=%d j=%d", i, j);
 324             ret = 0;
 325         }
 326     }
 327     return ret;
 328 }
 329
 330 int setup_tests(void)
 331 {
 332     ADD_TEST(test_sizeofs);
 333     ADD_ALL_TESTS(test_binops, OSSL_NELEM(test_values));
 334     ADD_ALL_TESTS(test_signed, OSSL_NELEM(signed_test_values));
 335     ADD_ALL_TESTS(test_8values, OSSL_NELEM(test_values_8));
 336     ADD_ALL_TESTS(test_64values, OSSL_NELEM(test_values_64));
 337     return 1;
 338 }