1 /* 2 * Copyright 2021-2026 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the Apache License 2.0 (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 <openssl/evp.h> 11 #include <openssl/rand.h> 12 #include <openssl/bio.h> 13 #include <openssl/core_names.h> 14 #include <openssl/params.h> 15 #include "crypto/rand.h" 16 #include "testutil.h" 17 18 static char *configfile; 19 20 static int test_rand(void) 21 { 22 EVP_RAND_CTX *privctx; 23 const OSSL_PROVIDER *prov; 24 int indicator = 1; 25 OSSL_PARAM params[2], *p = params; 26 unsigned char entropy1[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 }; 27 unsigned char entropy2[] = { 0xff, 0xfe, 0xfd }; 28 unsigned char nonce[] = { 0x00, 0x01, 0x02, 0x03, 0x04 }; 29 unsigned char outbuf[3]; 30 31 *p++ = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, 32 entropy1, sizeof(entropy1)); 33 *p = OSSL_PARAM_construct_end(); 34 35 if (!TEST_ptr(privctx = RAND_get0_private(NULL)) 36 || !TEST_true(EVP_RAND_CTX_set_params(privctx, params)) 37 || !TEST_int_gt(RAND_priv_bytes(outbuf, sizeof(outbuf)), 0) 38 || !TEST_mem_eq(outbuf, sizeof(outbuf), entropy1, sizeof(outbuf)) 39 || !TEST_int_le(RAND_priv_bytes(outbuf, sizeof(outbuf) + 1), 0) 40 || !TEST_int_gt(RAND_priv_bytes(outbuf, sizeof(outbuf)), 0) 41 || !TEST_mem_eq(outbuf, sizeof(outbuf), 42 entropy1 + sizeof(outbuf), sizeof(outbuf))) 43 return 0; 44 45 *params = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, 46 entropy2, sizeof(entropy2)); 47 if (!TEST_true(EVP_RAND_CTX_set_params(privctx, params)) 48 || !TEST_int_gt(RAND_priv_bytes(outbuf, sizeof(outbuf)), 0) 49 || !TEST_mem_eq(outbuf, sizeof(outbuf), entropy2, sizeof(outbuf))) 50 return 0; 51 52 *params = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_NONCE, 53 nonce, sizeof(nonce)); 54 if (!TEST_true(EVP_RAND_CTX_set_params(privctx, params)) 55 || !TEST_true(EVP_RAND_nonce(privctx, outbuf, sizeof(outbuf))) 56 || !TEST_mem_eq(outbuf, sizeof(outbuf), nonce, sizeof(outbuf))) 57 return 0; 58 59 if (fips_provider_version_lt(NULL, 3, 4, 0)) { 60 /* Skip the rest and pass the test */ 61 return 1; 62 } 63 /* Verify that the FIPS indicator can be read and is false */ 64 prov = EVP_RAND_get0_provider(EVP_RAND_CTX_get0_rand(privctx)); 65 if (prov != NULL 66 && strcmp(OSSL_PROVIDER_get0_name(prov), "fips") == 0) { 67 params[0] = OSSL_PARAM_construct_int(OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR, 68 &indicator); 69 if (!TEST_true(EVP_RAND_CTX_get_params(privctx, params)) 70 || !TEST_int_eq(indicator, 0)) 71 return 0; 72 } 73 return 1; 74 } 75 76 #ifndef OPENSSL_NO_FIPS_JITTER 77 static int test_jitter_fips_indicator(void) 78 { 79 EVP_RAND *rand = NULL; 80 EVP_RAND_CTX *ctx = NULL; 81 const OSSL_PROVIDER *prov; 82 const OSSL_PARAM *gettables; 83 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END }; 84 int indicator = 0; 85 int ret = 0; 86 87 if (!TEST_ptr(rand = EVP_RAND_fetch(NULL, "JITTER", NULL))) 88 goto err; 89 90 prov = EVP_RAND_get0_provider(rand); 91 if (prov == NULL || strcmp(OSSL_PROVIDER_get0_name(prov), "fips") != 0) { 92 ret = 1; 93 goto err; 94 } 95 96 if (!TEST_ptr(ctx = EVP_RAND_CTX_new(rand, NULL)) 97 || !TEST_ptr(gettables = EVP_RAND_CTX_gettable_params(ctx)) 98 || !TEST_ptr(OSSL_PARAM_locate_const(gettables, 99 OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR))) 100 goto err; 101 102 params[0] = OSSL_PARAM_construct_int(OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR, 103 &indicator); 104 if (!TEST_true(EVP_RAND_CTX_get_params(ctx, params)) 105 || !TEST_true(OSSL_PARAM_modified(params)) 106 || !TEST_int_eq(indicator, 1)) 107 goto err; 108 109 ret = 1; 110 err: 111 EVP_RAND_CTX_free(ctx); 112 EVP_RAND_free(rand); 113 return ret; 114 } 115 #endif 116 117 static int test_rand_uniform(void) 118 { 119 uint32_t x, i, j; 120 int err = 0, res = 0; 121 OSSL_LIB_CTX *ctx; 122 123 if (!test_get_libctx(&ctx, NULL, NULL, NULL, NULL)) 124 goto err; 125 126 for (i = 1; i < 100; i += 13) { 127 x = ossl_rand_uniform_uint32(ctx, i, &err); 128 if (!TEST_int_eq(err, 0) 129 || !TEST_uint_ge(x, 0) 130 || !TEST_uint_lt(x, i)) 131 return 0; 132 } 133 for (i = 1; i < 100; i += 17) 134 for (j = i + 1; j < 150; j += 11) { 135 x = ossl_rand_range_uint32(ctx, i, j, &err); 136 if (!TEST_int_eq(err, 0) 137 || !TEST_uint_ge(x, i) 138 || !TEST_uint_lt(x, j)) 139 return 0; 140 } 141 142 res = 1; 143 err: 144 OSSL_LIB_CTX_free(ctx); 145 return res; 146 } 147 148 /* Test the FIPS health tests */ 149 static int fips_health_test_one(const uint8_t *buf, size_t n, size_t gen) 150 { 151 int res = 0; 152 EVP_RAND *crngt_alg = NULL, *parent_alg = NULL; 153 EVP_RAND_CTX *crngt = NULL, *parent = NULL; 154 OSSL_PARAM p[2]; 155 uint8_t out[1000]; 156 int indicator = -1; 157 158 p[0] = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, 159 (void *)buf, n); 160 p[1] = OSSL_PARAM_construct_end(); 161 162 if (!TEST_ptr(parent_alg = EVP_RAND_fetch(NULL, "TEST-RAND", "-fips")) 163 || !TEST_ptr(crngt_alg = EVP_RAND_fetch(NULL, "CRNG-TEST", "-fips")) 164 || !TEST_ptr(parent = EVP_RAND_CTX_new(parent_alg, NULL)) 165 || !TEST_ptr(crngt = EVP_RAND_CTX_new(crngt_alg, parent)) 166 || !TEST_true(EVP_RAND_instantiate(parent, 0, 0, 167 (unsigned char *)"abc", 3, p)) 168 || !TEST_true(EVP_RAND_instantiate(crngt, 0, 0, 169 (unsigned char *)"def", 3, NULL)) 170 || !TEST_size_t_le(gen, sizeof(out))) 171 goto err; 172 173 /* Verify that the FIPS indicator is negative */ 174 p[0] = OSSL_PARAM_construct_int(OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR, 175 &indicator); 176 if (!TEST_true(EVP_RAND_CTX_get_params(crngt, p)) 177 || !TEST_int_le(indicator, 0)) 178 goto err; 179 180 ERR_set_mark(); 181 res = EVP_RAND_generate(crngt, out, gen, 0, 0, NULL, 0); 182 ERR_pop_to_mark(); 183 err: 184 EVP_RAND_CTX_free(crngt); 185 EVP_RAND_CTX_free(parent); 186 EVP_RAND_free(crngt_alg); 187 EVP_RAND_free(parent_alg); 188 return res; 189 } 190 191 static int fips_health_tests(void) 192 { 193 uint8_t buf[1000]; 194 size_t i; 195 196 /* Verify tests can pass */ 197 for (i = 0; i < sizeof(buf); i++) 198 buf[i] = 0xff & i; 199 if (!TEST_true(fips_health_test_one(buf, i, i))) 200 return 0; 201 202 /* Verify RCT can fail */ 203 for (i = 0; i < 20; i++) 204 buf[i] = 0xff & (i > 10 ? 200 : i); 205 if (!TEST_false(fips_health_test_one(buf, i, i))) 206 return 0; 207 208 /* Verify APT can fail */ 209 for (i = 0; i < sizeof(buf); i++) 210 buf[i] = 0xff & (i >= 512 && i % 8 == 0 ? 0x80 : i); 211 if (!TEST_false(fips_health_test_one(buf, i, i))) 212 return 0; 213 return 1; 214 } 215 216 typedef struct r_test_ctx { 217 const OSSL_CORE_HANDLE *handle; 218 } R_TEST_CTX; 219 220 static void r_teardown(void *provctx) 221 { 222 R_TEST_CTX *ctx = (R_TEST_CTX *)provctx; 223 224 free(ctx); 225 } 226 227 static int r_random_bytes(ossl_unused void *vprov, ossl_unused int which, 228 void *buf, size_t n, ossl_unused unsigned int strength) 229 { 230 while (n-- > 0) 231 ((unsigned char *)buf)[n] = 0xff & n; 232 return 1; 233 } 234 235 static const OSSL_DISPATCH r_test_table[] = { 236 { OSSL_FUNC_PROVIDER_RANDOM_BYTES, (void (*)(void))r_random_bytes }, 237 { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))r_teardown }, 238 OSSL_DISPATCH_END 239 }; 240 241 static int r_init(const OSSL_CORE_HANDLE *handle, 242 ossl_unused const OSSL_DISPATCH *oin, 243 const OSSL_DISPATCH **out, 244 void **provctx) 245 { 246 R_TEST_CTX *ctx; 247 248 ctx = malloc(sizeof(*ctx)); 249 if (ctx == NULL) 250 return 0; 251 ctx->handle = handle; 252 253 *provctx = (void *)ctx; 254 *out = r_test_table; 255 return 1; 256 } 257 258 static int test_rand_random_provider(void) 259 { 260 OSSL_LIB_CTX *ctx = NULL; 261 OSSL_PROVIDER *prov = NULL; 262 int res = 0; 263 static const unsigned char data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 264 unsigned char buf[sizeof(data)], privbuf[sizeof(data)]; 265 266 memset(buf, 255, sizeof(buf)); 267 memset(privbuf, 255, sizeof(privbuf)); 268 269 if (!test_get_libctx(&ctx, NULL, NULL, NULL, NULL) 270 || !TEST_true(OSSL_PROVIDER_add_builtin(ctx, "r_prov", &r_init)) 271 || !TEST_ptr(prov = OSSL_PROVIDER_try_load(ctx, "r_prov", 1)) 272 || !TEST_true(RAND_set1_random_provider(ctx, prov)) 273 || !RAND_bytes_ex(ctx, buf, sizeof(buf), 256) 274 || !TEST_mem_eq(buf, sizeof(buf), data, sizeof(data)) 275 || !RAND_priv_bytes_ex(ctx, privbuf, sizeof(privbuf), 256) 276 || !TEST_mem_eq(privbuf, sizeof(privbuf), data, sizeof(data))) 277 goto err; 278 279 /* Test we can revert to not using the provider based randomness */ 280 if (!TEST_true(RAND_set1_random_provider(ctx, NULL)) 281 || !RAND_bytes_ex(ctx, buf, sizeof(buf), 256) 282 || !TEST_mem_ne(buf, sizeof(buf), data, sizeof(data))) 283 goto err; 284 285 /* And back to the provided randomness */ 286 if (!TEST_true(RAND_set1_random_provider(ctx, prov)) 287 || !RAND_bytes_ex(ctx, buf, sizeof(buf), 256) 288 || !TEST_mem_eq(buf, sizeof(buf), data, sizeof(data))) 289 goto err; 290 291 res = 1; 292 err: 293 OSSL_PROVIDER_unload(prov); 294 OSSL_LIB_CTX_free(ctx); 295 return res; 296 } 297 298 static int test_rand_get0_primary(void) 299 { 300 OSSL_LIB_CTX *ctx = OSSL_LIB_CTX_new(); 301 int res = 0; 302 303 if (!TEST_ptr(ctx)) 304 return 0; 305 306 if (!TEST_true(OSSL_LIB_CTX_load_config(ctx, configfile))) 307 goto err; 308 309 /* We simply test that we get a valid primary */ 310 if (!TEST_ptr(RAND_get0_primary(ctx))) 311 goto err; 312 313 res = 1; 314 err: 315 OSSL_LIB_CTX_free(ctx); 316 return res; 317 } 318 319 int setup_tests(void) 320 { 321 if (!test_skip_common_options()) { 322 TEST_error("Error parsing test options\n"); 323 return 0; 324 } 325 326 if (!TEST_ptr(configfile = test_get_argument(0)) 327 || !TEST_true(RAND_set_DRBG_type(NULL, "TEST-RAND", "fips=no", 328 NULL, NULL)) 329 || (fips_provider_version_ge(NULL, 3, 0, 8) 330 && !TEST_true(OSSL_LIB_CTX_load_config(NULL, configfile)))) 331 return 0; 332 333 ADD_TEST(test_rand); 334 #ifndef OPENSSL_NO_FIPS_JITTER 335 ADD_TEST(test_jitter_fips_indicator); 336 #endif 337 ADD_TEST(test_rand_uniform); 338 339 if (OSSL_PROVIDER_available(NULL, "fips") 340 && fips_provider_version_ge(NULL, 3, 4, 0)) 341 ADD_TEST(fips_health_tests); 342 343 ADD_TEST(test_rand_random_provider); 344 345 if (!OSSL_PROVIDER_available(NULL, "fips") 346 || fips_provider_version_ge(NULL, 3, 5, 1)) 347 ADD_TEST(test_rand_get0_primary); 348 return 1; 349 } 350