1 /* 2 * DRBG: Deterministic Random Bits Generator 3 * Based on NIST Recommended DRBG from NIST SP800-90A with the following 4 * properties: 5 * * CTR DRBG with DF with AES-128, AES-192, AES-256 cores 6 * * Hash DRBG with DF with SHA-1, SHA-256, SHA-384, SHA-512 cores 7 * * HMAC DRBG with DF with SHA-1, SHA-256, SHA-384, SHA-512 cores 8 * * with and without prediction resistance 9 * 10 * Copyright Stephan Mueller <smueller@chronox.de>, 2014 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, and the entire permission notice in its entirety, 17 * including the disclaimer of warranties. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. The name of the author may not be used to endorse or promote 22 * products derived from this software without specific prior 23 * written permission. 24 * 25 * ALTERNATIVELY, this product may be distributed under the terms of 26 * the GNU General Public License, in which case the provisions of the GPL are 27 * required INSTEAD OF the above restrictions. (This clause is 28 * necessary due to a potential bad interaction between the GPL and 29 * the restrictions contained in a BSD-style copyright.) 30 * 31 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 32 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 33 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF 34 * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE 35 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 36 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 37 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 38 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 39 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 40 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 41 * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH 42 * DAMAGE. 43 * 44 * DRBG Usage 45 * ========== 46 * The SP 800-90A DRBG allows the user to specify a personalization string 47 * for initialization as well as an additional information string for each 48 * random number request. The following code fragments show how a caller 49 * uses the kernel crypto API to use the full functionality of the DRBG. 50 * 51 * Usage without any additional data 52 * --------------------------------- 53 * struct crypto_rng *drng; 54 * int err; 55 * char data[DATALEN]; 56 * 57 * drng = crypto_alloc_rng(drng_name, 0, 0); 58 * err = crypto_rng_get_bytes(drng, &data, DATALEN); 59 * crypto_free_rng(drng); 60 * 61 * 62 * Usage with personalization string during initialization 63 * ------------------------------------------------------- 64 * struct crypto_rng *drng; 65 * int err; 66 * char data[DATALEN]; 67 * struct drbg_string pers; 68 * char personalization[11] = "some-string"; 69 * 70 * drbg_string_fill(&pers, personalization, strlen(personalization)); 71 * drng = crypto_alloc_rng(drng_name, 0, 0); 72 * // The reset completely re-initializes the DRBG with the provided 73 * // personalization string 74 * err = crypto_rng_reset(drng, &personalization, strlen(personalization)); 75 * err = crypto_rng_get_bytes(drng, &data, DATALEN); 76 * crypto_free_rng(drng); 77 * 78 * 79 * Usage with additional information string during random number request 80 * --------------------------------------------------------------------- 81 * struct crypto_rng *drng; 82 * int err; 83 * char data[DATALEN]; 84 * char addtl_string[11] = "some-string"; 85 * string drbg_string addtl; 86 * 87 * drbg_string_fill(&addtl, addtl_string, strlen(addtl_string)); 88 * drng = crypto_alloc_rng(drng_name, 0, 0); 89 * // The following call is a wrapper to crypto_rng_get_bytes() and returns 90 * // the same error codes. 91 * err = crypto_drbg_get_bytes_addtl(drng, &data, DATALEN, &addtl); 92 * crypto_free_rng(drng); 93 * 94 * 95 * Usage with personalization and additional information strings 96 * ------------------------------------------------------------- 97 * Just mix both scenarios above. 98 */ 99 100 #include <crypto/drbg.h> 101 #include <crypto/internal/cipher.h> 102 #include <linux/kernel.h> 103 #include <linux/jiffies.h> 104 105 /*************************************************************** 106 * Backend cipher definitions available to DRBG 107 ***************************************************************/ 108 109 /* 110 * The order of the DRBG definitions here matter: every DRBG is registered 111 * as stdrng. Each DRBG receives an increasing cra_priority values the later 112 * they are defined in this array (see drbg_fill_array). 113 * 114 * HMAC DRBGs are favored over Hash DRBGs over CTR DRBGs, and 115 * the SHA256 / AES 256 over other ciphers. Thus, the favored 116 * DRBGs are the latest entries in this array. 117 */ 118 static const struct drbg_core drbg_cores[] = { 119 #ifdef CONFIG_CRYPTO_DRBG_CTR 120 { 121 .flags = DRBG_CTR | DRBG_STRENGTH128, 122 .statelen = 32, /* 256 bits as defined in 10.2.1 */ 123 .blocklen_bytes = 16, 124 .cra_name = "ctr_aes128", 125 .backend_cra_name = "aes", 126 }, { 127 .flags = DRBG_CTR | DRBG_STRENGTH192, 128 .statelen = 40, /* 320 bits as defined in 10.2.1 */ 129 .blocklen_bytes = 16, 130 .cra_name = "ctr_aes192", 131 .backend_cra_name = "aes", 132 }, { 133 .flags = DRBG_CTR | DRBG_STRENGTH256, 134 .statelen = 48, /* 384 bits as defined in 10.2.1 */ 135 .blocklen_bytes = 16, 136 .cra_name = "ctr_aes256", 137 .backend_cra_name = "aes", 138 }, 139 #endif /* CONFIG_CRYPTO_DRBG_CTR */ 140 #ifdef CONFIG_CRYPTO_DRBG_HASH 141 { 142 .flags = DRBG_HASH | DRBG_STRENGTH128, 143 .statelen = 55, /* 440 bits */ 144 .blocklen_bytes = 20, 145 .cra_name = "sha1", 146 .backend_cra_name = "sha1", 147 }, { 148 .flags = DRBG_HASH | DRBG_STRENGTH256, 149 .statelen = 111, /* 888 bits */ 150 .blocklen_bytes = 48, 151 .cra_name = "sha384", 152 .backend_cra_name = "sha384", 153 }, { 154 .flags = DRBG_HASH | DRBG_STRENGTH256, 155 .statelen = 111, /* 888 bits */ 156 .blocklen_bytes = 64, 157 .cra_name = "sha512", 158 .backend_cra_name = "sha512", 159 }, { 160 .flags = DRBG_HASH | DRBG_STRENGTH256, 161 .statelen = 55, /* 440 bits */ 162 .blocklen_bytes = 32, 163 .cra_name = "sha256", 164 .backend_cra_name = "sha256", 165 }, 166 #endif /* CONFIG_CRYPTO_DRBG_HASH */ 167 #ifdef CONFIG_CRYPTO_DRBG_HMAC 168 { 169 .flags = DRBG_HMAC | DRBG_STRENGTH128, 170 .statelen = 20, /* block length of cipher */ 171 .blocklen_bytes = 20, 172 .cra_name = "hmac_sha1", 173 .backend_cra_name = "hmac(sha1)", 174 }, { 175 .flags = DRBG_HMAC | DRBG_STRENGTH256, 176 .statelen = 48, /* block length of cipher */ 177 .blocklen_bytes = 48, 178 .cra_name = "hmac_sha384", 179 .backend_cra_name = "hmac(sha384)", 180 }, { 181 .flags = DRBG_HMAC | DRBG_STRENGTH256, 182 .statelen = 32, /* block length of cipher */ 183 .blocklen_bytes = 32, 184 .cra_name = "hmac_sha256", 185 .backend_cra_name = "hmac(sha256)", 186 }, { 187 .flags = DRBG_HMAC | DRBG_STRENGTH256, 188 .statelen = 64, /* block length of cipher */ 189 .blocklen_bytes = 64, 190 .cra_name = "hmac_sha512", 191 .backend_cra_name = "hmac(sha512)", 192 }, 193 #endif /* CONFIG_CRYPTO_DRBG_HMAC */ 194 }; 195 196 static int drbg_uninstantiate(struct drbg_state *drbg); 197 198 /****************************************************************** 199 * Generic helper functions 200 ******************************************************************/ 201 202 /* 203 * Return strength of DRBG according to SP800-90A section 8.4 204 * 205 * @flags DRBG flags reference 206 * 207 * Return: normalized strength in *bytes* value or 32 as default 208 * to counter programming errors 209 */ 210 static inline unsigned short drbg_sec_strength(drbg_flag_t flags) 211 { 212 switch (flags & DRBG_STRENGTH_MASK) { 213 case DRBG_STRENGTH128: 214 return 16; 215 case DRBG_STRENGTH192: 216 return 24; 217 case DRBG_STRENGTH256: 218 return 32; 219 default: 220 return 32; 221 } 222 } 223 224 /* 225 * FIPS 140-2 continuous self test for the noise source 226 * The test is performed on the noise source input data. Thus, the function 227 * implicitly knows the size of the buffer to be equal to the security 228 * strength. 229 * 230 * Note, this function disregards the nonce trailing the entropy data during 231 * initial seeding. 232 * 233 * drbg->drbg_mutex must have been taken. 234 * 235 * @drbg DRBG handle 236 * @entropy buffer of seed data to be checked 237 * 238 * return: 239 * 0 on success 240 * -EAGAIN on when the CTRNG is not yet primed 241 * < 0 on error 242 */ 243 static int drbg_fips_continuous_test(struct drbg_state *drbg, 244 const unsigned char *entropy) 245 { 246 unsigned short entropylen = drbg_sec_strength(drbg->core->flags); 247 int ret = 0; 248 249 if (!IS_ENABLED(CONFIG_CRYPTO_FIPS)) 250 return 0; 251 252 /* skip test if we test the overall system */ 253 if (list_empty(&drbg->test_data.list)) 254 return 0; 255 /* only perform test in FIPS mode */ 256 if (!fips_enabled) 257 return 0; 258 259 if (!drbg->fips_primed) { 260 /* Priming of FIPS test */ 261 memcpy(drbg->prev, entropy, entropylen); 262 drbg->fips_primed = true; 263 /* priming: another round is needed */ 264 return -EAGAIN; 265 } 266 ret = memcmp(drbg->prev, entropy, entropylen); 267 if (!ret) 268 panic("DRBG continuous self test failed\n"); 269 memcpy(drbg->prev, entropy, entropylen); 270 271 /* the test shall pass when the two values are not equal */ 272 return 0; 273 } 274 275 /* 276 * Convert an integer into a byte representation of this integer. 277 * The byte representation is big-endian 278 * 279 * @val value to be converted 280 * @buf buffer holding the converted integer -- caller must ensure that 281 * buffer size is at least 32 bit 282 */ 283 #if (defined(CONFIG_CRYPTO_DRBG_HASH) || defined(CONFIG_CRYPTO_DRBG_CTR)) 284 static inline void drbg_cpu_to_be32(__u32 val, unsigned char *buf) 285 { 286 struct s { 287 __be32 conv; 288 }; 289 struct s *conversion = (struct s *) buf; 290 291 conversion->conv = cpu_to_be32(val); 292 } 293 #endif /* defined(CONFIG_CRYPTO_DRBG_HASH) || defined(CONFIG_CRYPTO_DRBG_CTR) */ 294 295 /****************************************************************** 296 * CTR DRBG callback functions 297 ******************************************************************/ 298 299 #ifdef CONFIG_CRYPTO_DRBG_CTR 300 #define CRYPTO_DRBG_CTR_STRING "CTR " 301 MODULE_ALIAS_CRYPTO("drbg_pr_ctr_aes256"); 302 MODULE_ALIAS_CRYPTO("drbg_nopr_ctr_aes256"); 303 MODULE_ALIAS_CRYPTO("drbg_pr_ctr_aes192"); 304 MODULE_ALIAS_CRYPTO("drbg_nopr_ctr_aes192"); 305 MODULE_ALIAS_CRYPTO("drbg_pr_ctr_aes128"); 306 MODULE_ALIAS_CRYPTO("drbg_nopr_ctr_aes128"); 307 308 static void drbg_kcapi_symsetkey(struct drbg_state *drbg, 309 const unsigned char *key); 310 static int drbg_kcapi_sym(struct drbg_state *drbg, unsigned char *outval, 311 const struct drbg_string *in); 312 static int drbg_init_sym_kernel(struct drbg_state *drbg); 313 static int drbg_fini_sym_kernel(struct drbg_state *drbg); 314 static int drbg_kcapi_sym_ctr(struct drbg_state *drbg, 315 u8 *inbuf, u32 inbuflen, 316 u8 *outbuf, u32 outlen); 317 #define DRBG_OUTSCRATCHLEN 256 318 319 /* BCC function for CTR DRBG as defined in 10.4.3 */ 320 static int drbg_ctr_bcc(struct drbg_state *drbg, 321 unsigned char *out, const unsigned char *key, 322 struct list_head *in) 323 { 324 int ret = 0; 325 struct drbg_string *curr = NULL; 326 struct drbg_string data; 327 short cnt = 0; 328 329 drbg_string_fill(&data, out, drbg_blocklen(drbg)); 330 331 /* 10.4.3 step 2 / 4 */ 332 drbg_kcapi_symsetkey(drbg, key); 333 list_for_each_entry(curr, in, list) { 334 const unsigned char *pos = curr->buf; 335 size_t len = curr->len; 336 /* 10.4.3 step 4.1 */ 337 while (len) { 338 /* 10.4.3 step 4.2 */ 339 if (drbg_blocklen(drbg) == cnt) { 340 cnt = 0; 341 ret = drbg_kcapi_sym(drbg, out, &data); 342 if (ret) 343 return ret; 344 } 345 out[cnt] ^= *pos; 346 pos++; 347 cnt++; 348 len--; 349 } 350 } 351 /* 10.4.3 step 4.2 for last block */ 352 if (cnt) 353 ret = drbg_kcapi_sym(drbg, out, &data); 354 355 return ret; 356 } 357 358 /* 359 * scratchpad usage: drbg_ctr_update is interlinked with drbg_ctr_df 360 * (and drbg_ctr_bcc, but this function does not need any temporary buffers), 361 * the scratchpad is used as follows: 362 * drbg_ctr_update: 363 * temp 364 * start: drbg->scratchpad 365 * length: drbg_statelen(drbg) + drbg_blocklen(drbg) 366 * note: the cipher writing into this variable works 367 * blocklen-wise. Now, when the statelen is not a multiple 368 * of blocklen, the generateion loop below "spills over" 369 * by at most blocklen. Thus, we need to give sufficient 370 * memory. 371 * df_data 372 * start: drbg->scratchpad + 373 * drbg_statelen(drbg) + drbg_blocklen(drbg) 374 * length: drbg_statelen(drbg) 375 * 376 * drbg_ctr_df: 377 * pad 378 * start: df_data + drbg_statelen(drbg) 379 * length: drbg_blocklen(drbg) 380 * iv 381 * start: pad + drbg_blocklen(drbg) 382 * length: drbg_blocklen(drbg) 383 * temp 384 * start: iv + drbg_blocklen(drbg) 385 * length: drbg_satelen(drbg) + drbg_blocklen(drbg) 386 * note: temp is the buffer that the BCC function operates 387 * on. BCC operates blockwise. drbg_statelen(drbg) 388 * is sufficient when the DRBG state length is a multiple 389 * of the block size. For AES192 (and maybe other ciphers) 390 * this is not correct and the length for temp is 391 * insufficient (yes, that also means for such ciphers, 392 * the final output of all BCC rounds are truncated). 393 * Therefore, add drbg_blocklen(drbg) to cover all 394 * possibilities. 395 */ 396 397 /* Derivation Function for CTR DRBG as defined in 10.4.2 */ 398 static int drbg_ctr_df(struct drbg_state *drbg, 399 unsigned char *df_data, size_t bytes_to_return, 400 struct list_head *seedlist) 401 { 402 int ret = -EFAULT; 403 unsigned char L_N[8]; 404 /* S3 is input */ 405 struct drbg_string S1, S2, S4, cipherin; 406 LIST_HEAD(bcc_list); 407 unsigned char *pad = df_data + drbg_statelen(drbg); 408 unsigned char *iv = pad + drbg_blocklen(drbg); 409 unsigned char *temp = iv + drbg_blocklen(drbg); 410 size_t padlen = 0; 411 unsigned int templen = 0; 412 /* 10.4.2 step 7 */ 413 unsigned int i = 0; 414 /* 10.4.2 step 8 */ 415 const unsigned char *K = (unsigned char *) 416 "\x00\x01\x02\x03\x04\x05\x06\x07" 417 "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" 418 "\x10\x11\x12\x13\x14\x15\x16\x17" 419 "\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"; 420 unsigned char *X; 421 size_t generated_len = 0; 422 size_t inputlen = 0; 423 struct drbg_string *seed = NULL; 424 425 memset(pad, 0, drbg_blocklen(drbg)); 426 memset(iv, 0, drbg_blocklen(drbg)); 427 428 /* 10.4.2 step 1 is implicit as we work byte-wise */ 429 430 /* 10.4.2 step 2 */ 431 if ((512/8) < bytes_to_return) 432 return -EINVAL; 433 434 /* 10.4.2 step 2 -- calculate the entire length of all input data */ 435 list_for_each_entry(seed, seedlist, list) 436 inputlen += seed->len; 437 drbg_cpu_to_be32(inputlen, &L_N[0]); 438 439 /* 10.4.2 step 3 */ 440 drbg_cpu_to_be32(bytes_to_return, &L_N[4]); 441 442 /* 10.4.2 step 5: length is L_N, input_string, one byte, padding */ 443 padlen = (inputlen + sizeof(L_N) + 1) % (drbg_blocklen(drbg)); 444 /* wrap the padlen appropriately */ 445 if (padlen) 446 padlen = drbg_blocklen(drbg) - padlen; 447 /* 448 * pad / padlen contains the 0x80 byte and the following zero bytes. 449 * As the calculated padlen value only covers the number of zero 450 * bytes, this value has to be incremented by one for the 0x80 byte. 451 */ 452 padlen++; 453 pad[0] = 0x80; 454 455 /* 10.4.2 step 4 -- first fill the linked list and then order it */ 456 drbg_string_fill(&S1, iv, drbg_blocklen(drbg)); 457 list_add_tail(&S1.list, &bcc_list); 458 drbg_string_fill(&S2, L_N, sizeof(L_N)); 459 list_add_tail(&S2.list, &bcc_list); 460 list_splice_tail(seedlist, &bcc_list); 461 drbg_string_fill(&S4, pad, padlen); 462 list_add_tail(&S4.list, &bcc_list); 463 464 /* 10.4.2 step 9 */ 465 while (templen < (drbg_keylen(drbg) + (drbg_blocklen(drbg)))) { 466 /* 467 * 10.4.2 step 9.1 - the padding is implicit as the buffer 468 * holds zeros after allocation -- even the increment of i 469 * is irrelevant as the increment remains within length of i 470 */ 471 drbg_cpu_to_be32(i, iv); 472 /* 10.4.2 step 9.2 -- BCC and concatenation with temp */ 473 ret = drbg_ctr_bcc(drbg, temp + templen, K, &bcc_list); 474 if (ret) 475 goto out; 476 /* 10.4.2 step 9.3 */ 477 i++; 478 templen += drbg_blocklen(drbg); 479 } 480 481 /* 10.4.2 step 11 */ 482 X = temp + (drbg_keylen(drbg)); 483 drbg_string_fill(&cipherin, X, drbg_blocklen(drbg)); 484 485 /* 10.4.2 step 12: overwriting of outval is implemented in next step */ 486 487 /* 10.4.2 step 13 */ 488 drbg_kcapi_symsetkey(drbg, temp); 489 while (generated_len < bytes_to_return) { 490 short blocklen = 0; 491 /* 492 * 10.4.2 step 13.1: the truncation of the key length is 493 * implicit as the key is only drbg_blocklen in size based on 494 * the implementation of the cipher function callback 495 */ 496 ret = drbg_kcapi_sym(drbg, X, &cipherin); 497 if (ret) 498 goto out; 499 blocklen = (drbg_blocklen(drbg) < 500 (bytes_to_return - generated_len)) ? 501 drbg_blocklen(drbg) : 502 (bytes_to_return - generated_len); 503 /* 10.4.2 step 13.2 and 14 */ 504 memcpy(df_data + generated_len, X, blocklen); 505 generated_len += blocklen; 506 } 507 508 ret = 0; 509 510 out: 511 memset(iv, 0, drbg_blocklen(drbg)); 512 memset(temp, 0, drbg_statelen(drbg) + drbg_blocklen(drbg)); 513 memset(pad, 0, drbg_blocklen(drbg)); 514 return ret; 515 } 516 517 /* 518 * update function of CTR DRBG as defined in 10.2.1.2 519 * 520 * The reseed variable has an enhanced meaning compared to the update 521 * functions of the other DRBGs as follows: 522 * 0 => initial seed from initialization 523 * 1 => reseed via drbg_seed 524 * 2 => first invocation from drbg_ctr_update when addtl is present. In 525 * this case, the df_data scratchpad is not deleted so that it is 526 * available for another calls to prevent calling the DF function 527 * again. 528 * 3 => second invocation from drbg_ctr_update. When the update function 529 * was called with addtl, the df_data memory already contains the 530 * DFed addtl information and we do not need to call DF again. 531 */ 532 static int drbg_ctr_update(struct drbg_state *drbg, struct list_head *seed, 533 int reseed) 534 { 535 int ret = -EFAULT; 536 /* 10.2.1.2 step 1 */ 537 unsigned char *temp = drbg->scratchpad; 538 unsigned char *df_data = drbg->scratchpad + drbg_statelen(drbg) + 539 drbg_blocklen(drbg); 540 541 if (3 > reseed) 542 memset(df_data, 0, drbg_statelen(drbg)); 543 544 if (!reseed) { 545 /* 546 * The DRBG uses the CTR mode of the underlying AES cipher. The 547 * CTR mode increments the counter value after the AES operation 548 * but SP800-90A requires that the counter is incremented before 549 * the AES operation. Hence, we increment it at the time we set 550 * it by one. 551 */ 552 crypto_inc(drbg->V, drbg_blocklen(drbg)); 553 554 ret = crypto_skcipher_setkey(drbg->ctr_handle, drbg->C, 555 drbg_keylen(drbg)); 556 if (ret) 557 goto out; 558 } 559 560 /* 10.2.1.3.2 step 2 and 10.2.1.4.2 step 2 */ 561 if (seed) { 562 ret = drbg_ctr_df(drbg, df_data, drbg_statelen(drbg), seed); 563 if (ret) 564 goto out; 565 } 566 567 ret = drbg_kcapi_sym_ctr(drbg, df_data, drbg_statelen(drbg), 568 temp, drbg_statelen(drbg)); 569 if (ret) 570 return ret; 571 572 /* 10.2.1.2 step 5 */ 573 ret = crypto_skcipher_setkey(drbg->ctr_handle, temp, 574 drbg_keylen(drbg)); 575 if (ret) 576 goto out; 577 /* 10.2.1.2 step 6 */ 578 memcpy(drbg->V, temp + drbg_keylen(drbg), drbg_blocklen(drbg)); 579 /* See above: increment counter by one to compensate timing of CTR op */ 580 crypto_inc(drbg->V, drbg_blocklen(drbg)); 581 ret = 0; 582 583 out: 584 memset(temp, 0, drbg_statelen(drbg) + drbg_blocklen(drbg)); 585 if (2 != reseed) 586 memset(df_data, 0, drbg_statelen(drbg)); 587 return ret; 588 } 589 590 /* 591 * scratchpad use: drbg_ctr_update is called independently from 592 * drbg_ctr_extract_bytes. Therefore, the scratchpad is reused 593 */ 594 /* Generate function of CTR DRBG as defined in 10.2.1.5.2 */ 595 static int drbg_ctr_generate(struct drbg_state *drbg, 596 unsigned char *buf, unsigned int buflen, 597 struct list_head *addtl) 598 { 599 int ret; 600 int len = min_t(int, buflen, INT_MAX); 601 602 /* 10.2.1.5.2 step 2 */ 603 if (addtl && !list_empty(addtl)) { 604 ret = drbg_ctr_update(drbg, addtl, 2); 605 if (ret) 606 return 0; 607 } 608 609 /* 10.2.1.5.2 step 4.1 */ 610 ret = drbg_kcapi_sym_ctr(drbg, NULL, 0, buf, len); 611 if (ret) 612 return ret; 613 614 /* 10.2.1.5.2 step 6 */ 615 ret = drbg_ctr_update(drbg, NULL, 3); 616 if (ret) 617 len = ret; 618 619 return len; 620 } 621 622 static const struct drbg_state_ops drbg_ctr_ops = { 623 .update = drbg_ctr_update, 624 .generate = drbg_ctr_generate, 625 .crypto_init = drbg_init_sym_kernel, 626 .crypto_fini = drbg_fini_sym_kernel, 627 }; 628 #endif /* CONFIG_CRYPTO_DRBG_CTR */ 629 630 /****************************************************************** 631 * HMAC DRBG callback functions 632 ******************************************************************/ 633 634 #if defined(CONFIG_CRYPTO_DRBG_HASH) || defined(CONFIG_CRYPTO_DRBG_HMAC) 635 static int drbg_kcapi_hash(struct drbg_state *drbg, unsigned char *outval, 636 const struct list_head *in); 637 static void drbg_kcapi_hmacsetkey(struct drbg_state *drbg, 638 const unsigned char *key); 639 static int drbg_init_hash_kernel(struct drbg_state *drbg); 640 static int drbg_fini_hash_kernel(struct drbg_state *drbg); 641 #endif /* (CONFIG_CRYPTO_DRBG_HASH || CONFIG_CRYPTO_DRBG_HMAC) */ 642 643 #ifdef CONFIG_CRYPTO_DRBG_HMAC 644 #define CRYPTO_DRBG_HMAC_STRING "HMAC " 645 MODULE_ALIAS_CRYPTO("drbg_pr_hmac_sha512"); 646 MODULE_ALIAS_CRYPTO("drbg_nopr_hmac_sha512"); 647 MODULE_ALIAS_CRYPTO("drbg_pr_hmac_sha384"); 648 MODULE_ALIAS_CRYPTO("drbg_nopr_hmac_sha384"); 649 MODULE_ALIAS_CRYPTO("drbg_pr_hmac_sha256"); 650 MODULE_ALIAS_CRYPTO("drbg_nopr_hmac_sha256"); 651 MODULE_ALIAS_CRYPTO("drbg_pr_hmac_sha1"); 652 MODULE_ALIAS_CRYPTO("drbg_nopr_hmac_sha1"); 653 654 /* update function of HMAC DRBG as defined in 10.1.2.2 */ 655 static int drbg_hmac_update(struct drbg_state *drbg, struct list_head *seed, 656 int reseed) 657 { 658 int ret = -EFAULT; 659 int i = 0; 660 struct drbg_string seed1, seed2, vdata; 661 LIST_HEAD(seedlist); 662 LIST_HEAD(vdatalist); 663 664 if (!reseed) { 665 /* 10.1.2.3 step 2 -- memset(0) of C is implicit with kzalloc */ 666 memset(drbg->V, 1, drbg_statelen(drbg)); 667 drbg_kcapi_hmacsetkey(drbg, drbg->C); 668 } 669 670 drbg_string_fill(&seed1, drbg->V, drbg_statelen(drbg)); 671 list_add_tail(&seed1.list, &seedlist); 672 /* buffer of seed2 will be filled in for loop below with one byte */ 673 drbg_string_fill(&seed2, NULL, 1); 674 list_add_tail(&seed2.list, &seedlist); 675 /* input data of seed is allowed to be NULL at this point */ 676 if (seed) 677 list_splice_tail(seed, &seedlist); 678 679 drbg_string_fill(&vdata, drbg->V, drbg_statelen(drbg)); 680 list_add_tail(&vdata.list, &vdatalist); 681 for (i = 2; 0 < i; i--) { 682 /* first round uses 0x0, second 0x1 */ 683 unsigned char prefix = DRBG_PREFIX0; 684 if (1 == i) 685 prefix = DRBG_PREFIX1; 686 /* 10.1.2.2 step 1 and 4 -- concatenation and HMAC for key */ 687 seed2.buf = &prefix; 688 ret = drbg_kcapi_hash(drbg, drbg->C, &seedlist); 689 if (ret) 690 return ret; 691 drbg_kcapi_hmacsetkey(drbg, drbg->C); 692 693 /* 10.1.2.2 step 2 and 5 -- HMAC for V */ 694 ret = drbg_kcapi_hash(drbg, drbg->V, &vdatalist); 695 if (ret) 696 return ret; 697 698 /* 10.1.2.2 step 3 */ 699 if (!seed) 700 return ret; 701 } 702 703 return 0; 704 } 705 706 /* generate function of HMAC DRBG as defined in 10.1.2.5 */ 707 static int drbg_hmac_generate(struct drbg_state *drbg, 708 unsigned char *buf, 709 unsigned int buflen, 710 struct list_head *addtl) 711 { 712 int len = 0; 713 int ret = 0; 714 struct drbg_string data; 715 LIST_HEAD(datalist); 716 717 /* 10.1.2.5 step 2 */ 718 if (addtl && !list_empty(addtl)) { 719 ret = drbg_hmac_update(drbg, addtl, 1); 720 if (ret) 721 return ret; 722 } 723 724 drbg_string_fill(&data, drbg->V, drbg_statelen(drbg)); 725 list_add_tail(&data.list, &datalist); 726 while (len < buflen) { 727 unsigned int outlen = 0; 728 /* 10.1.2.5 step 4.1 */ 729 ret = drbg_kcapi_hash(drbg, drbg->V, &datalist); 730 if (ret) 731 return ret; 732 outlen = (drbg_blocklen(drbg) < (buflen - len)) ? 733 drbg_blocklen(drbg) : (buflen - len); 734 735 /* 10.1.2.5 step 4.2 */ 736 memcpy(buf + len, drbg->V, outlen); 737 len += outlen; 738 } 739 740 /* 10.1.2.5 step 6 */ 741 if (addtl && !list_empty(addtl)) 742 ret = drbg_hmac_update(drbg, addtl, 1); 743 else 744 ret = drbg_hmac_update(drbg, NULL, 1); 745 if (ret) 746 return ret; 747 748 return len; 749 } 750 751 static const struct drbg_state_ops drbg_hmac_ops = { 752 .update = drbg_hmac_update, 753 .generate = drbg_hmac_generate, 754 .crypto_init = drbg_init_hash_kernel, 755 .crypto_fini = drbg_fini_hash_kernel, 756 }; 757 #endif /* CONFIG_CRYPTO_DRBG_HMAC */ 758 759 /****************************************************************** 760 * Hash DRBG callback functions 761 ******************************************************************/ 762 763 #ifdef CONFIG_CRYPTO_DRBG_HASH 764 #define CRYPTO_DRBG_HASH_STRING "HASH " 765 MODULE_ALIAS_CRYPTO("drbg_pr_sha512"); 766 MODULE_ALIAS_CRYPTO("drbg_nopr_sha512"); 767 MODULE_ALIAS_CRYPTO("drbg_pr_sha384"); 768 MODULE_ALIAS_CRYPTO("drbg_nopr_sha384"); 769 MODULE_ALIAS_CRYPTO("drbg_pr_sha256"); 770 MODULE_ALIAS_CRYPTO("drbg_nopr_sha256"); 771 MODULE_ALIAS_CRYPTO("drbg_pr_sha1"); 772 MODULE_ALIAS_CRYPTO("drbg_nopr_sha1"); 773 774 /* 775 * Increment buffer 776 * 777 * @dst buffer to increment 778 * @add value to add 779 */ 780 static inline void drbg_add_buf(unsigned char *dst, size_t dstlen, 781 const unsigned char *add, size_t addlen) 782 { 783 /* implied: dstlen > addlen */ 784 unsigned char *dstptr; 785 const unsigned char *addptr; 786 unsigned int remainder = 0; 787 size_t len = addlen; 788 789 dstptr = dst + (dstlen-1); 790 addptr = add + (addlen-1); 791 while (len) { 792 remainder += *dstptr + *addptr; 793 *dstptr = remainder & 0xff; 794 remainder >>= 8; 795 len--; dstptr--; addptr--; 796 } 797 len = dstlen - addlen; 798 while (len && remainder > 0) { 799 remainder = *dstptr + 1; 800 *dstptr = remainder & 0xff; 801 remainder >>= 8; 802 len--; dstptr--; 803 } 804 } 805 806 /* 807 * scratchpad usage: as drbg_hash_update and drbg_hash_df are used 808 * interlinked, the scratchpad is used as follows: 809 * drbg_hash_update 810 * start: drbg->scratchpad 811 * length: drbg_statelen(drbg) 812 * drbg_hash_df: 813 * start: drbg->scratchpad + drbg_statelen(drbg) 814 * length: drbg_blocklen(drbg) 815 * 816 * drbg_hash_process_addtl uses the scratchpad, but fully completes 817 * before either of the functions mentioned before are invoked. Therefore, 818 * drbg_hash_process_addtl does not need to be specifically considered. 819 */ 820 821 /* Derivation Function for Hash DRBG as defined in 10.4.1 */ 822 static int drbg_hash_df(struct drbg_state *drbg, 823 unsigned char *outval, size_t outlen, 824 struct list_head *entropylist) 825 { 826 int ret = 0; 827 size_t len = 0; 828 unsigned char input[5]; 829 unsigned char *tmp = drbg->scratchpad + drbg_statelen(drbg); 830 struct drbg_string data; 831 832 /* 10.4.1 step 3 */ 833 input[0] = 1; 834 drbg_cpu_to_be32((outlen * 8), &input[1]); 835 836 /* 10.4.1 step 4.1 -- concatenation of data for input into hash */ 837 drbg_string_fill(&data, input, 5); 838 list_add(&data.list, entropylist); 839 840 /* 10.4.1 step 4 */ 841 while (len < outlen) { 842 short blocklen = 0; 843 /* 10.4.1 step 4.1 */ 844 ret = drbg_kcapi_hash(drbg, tmp, entropylist); 845 if (ret) 846 goto out; 847 /* 10.4.1 step 4.2 */ 848 input[0]++; 849 blocklen = (drbg_blocklen(drbg) < (outlen - len)) ? 850 drbg_blocklen(drbg) : (outlen - len); 851 memcpy(outval + len, tmp, blocklen); 852 len += blocklen; 853 } 854 855 out: 856 memset(tmp, 0, drbg_blocklen(drbg)); 857 return ret; 858 } 859 860 /* update function for Hash DRBG as defined in 10.1.1.2 / 10.1.1.3 */ 861 static int drbg_hash_update(struct drbg_state *drbg, struct list_head *seed, 862 int reseed) 863 { 864 int ret = 0; 865 struct drbg_string data1, data2; 866 LIST_HEAD(datalist); 867 LIST_HEAD(datalist2); 868 unsigned char *V = drbg->scratchpad; 869 unsigned char prefix = DRBG_PREFIX1; 870 871 if (!seed) 872 return -EINVAL; 873 874 if (reseed) { 875 /* 10.1.1.3 step 1 */ 876 memcpy(V, drbg->V, drbg_statelen(drbg)); 877 drbg_string_fill(&data1, &prefix, 1); 878 list_add_tail(&data1.list, &datalist); 879 drbg_string_fill(&data2, V, drbg_statelen(drbg)); 880 list_add_tail(&data2.list, &datalist); 881 } 882 list_splice_tail(seed, &datalist); 883 884 /* 10.1.1.2 / 10.1.1.3 step 2 and 3 */ 885 ret = drbg_hash_df(drbg, drbg->V, drbg_statelen(drbg), &datalist); 886 if (ret) 887 goto out; 888 889 /* 10.1.1.2 / 10.1.1.3 step 4 */ 890 prefix = DRBG_PREFIX0; 891 drbg_string_fill(&data1, &prefix, 1); 892 list_add_tail(&data1.list, &datalist2); 893 drbg_string_fill(&data2, drbg->V, drbg_statelen(drbg)); 894 list_add_tail(&data2.list, &datalist2); 895 /* 10.1.1.2 / 10.1.1.3 step 4 */ 896 ret = drbg_hash_df(drbg, drbg->C, drbg_statelen(drbg), &datalist2); 897 898 out: 899 memset(drbg->scratchpad, 0, drbg_statelen(drbg)); 900 return ret; 901 } 902 903 /* processing of additional information string for Hash DRBG */ 904 static int drbg_hash_process_addtl(struct drbg_state *drbg, 905 struct list_head *addtl) 906 { 907 int ret = 0; 908 struct drbg_string data1, data2; 909 LIST_HEAD(datalist); 910 unsigned char prefix = DRBG_PREFIX2; 911 912 /* 10.1.1.4 step 2 */ 913 if (!addtl || list_empty(addtl)) 914 return 0; 915 916 /* 10.1.1.4 step 2a */ 917 drbg_string_fill(&data1, &prefix, 1); 918 drbg_string_fill(&data2, drbg->V, drbg_statelen(drbg)); 919 list_add_tail(&data1.list, &datalist); 920 list_add_tail(&data2.list, &datalist); 921 list_splice_tail(addtl, &datalist); 922 ret = drbg_kcapi_hash(drbg, drbg->scratchpad, &datalist); 923 if (ret) 924 goto out; 925 926 /* 10.1.1.4 step 2b */ 927 drbg_add_buf(drbg->V, drbg_statelen(drbg), 928 drbg->scratchpad, drbg_blocklen(drbg)); 929 930 out: 931 memset(drbg->scratchpad, 0, drbg_blocklen(drbg)); 932 return ret; 933 } 934 935 /* Hashgen defined in 10.1.1.4 */ 936 static int drbg_hash_hashgen(struct drbg_state *drbg, 937 unsigned char *buf, 938 unsigned int buflen) 939 { 940 int len = 0; 941 int ret = 0; 942 unsigned char *src = drbg->scratchpad; 943 unsigned char *dst = drbg->scratchpad + drbg_statelen(drbg); 944 struct drbg_string data; 945 LIST_HEAD(datalist); 946 947 /* 10.1.1.4 step hashgen 2 */ 948 memcpy(src, drbg->V, drbg_statelen(drbg)); 949 950 drbg_string_fill(&data, src, drbg_statelen(drbg)); 951 list_add_tail(&data.list, &datalist); 952 while (len < buflen) { 953 unsigned int outlen = 0; 954 /* 10.1.1.4 step hashgen 4.1 */ 955 ret = drbg_kcapi_hash(drbg, dst, &datalist); 956 if (ret) { 957 len = ret; 958 goto out; 959 } 960 outlen = (drbg_blocklen(drbg) < (buflen - len)) ? 961 drbg_blocklen(drbg) : (buflen - len); 962 /* 10.1.1.4 step hashgen 4.2 */ 963 memcpy(buf + len, dst, outlen); 964 len += outlen; 965 /* 10.1.1.4 hashgen step 4.3 */ 966 if (len < buflen) 967 crypto_inc(src, drbg_statelen(drbg)); 968 } 969 970 out: 971 memset(drbg->scratchpad, 0, 972 (drbg_statelen(drbg) + drbg_blocklen(drbg))); 973 return len; 974 } 975 976 /* generate function for Hash DRBG as defined in 10.1.1.4 */ 977 static int drbg_hash_generate(struct drbg_state *drbg, 978 unsigned char *buf, unsigned int buflen, 979 struct list_head *addtl) 980 { 981 int len = 0; 982 int ret = 0; 983 union { 984 unsigned char req[8]; 985 __be64 req_int; 986 } u; 987 unsigned char prefix = DRBG_PREFIX3; 988 struct drbg_string data1, data2; 989 LIST_HEAD(datalist); 990 991 /* 10.1.1.4 step 2 */ 992 ret = drbg_hash_process_addtl(drbg, addtl); 993 if (ret) 994 return ret; 995 /* 10.1.1.4 step 3 */ 996 len = drbg_hash_hashgen(drbg, buf, buflen); 997 998 /* this is the value H as documented in 10.1.1.4 */ 999 /* 10.1.1.4 step 4 */ 1000 drbg_string_fill(&data1, &prefix, 1); 1001 list_add_tail(&data1.list, &datalist); 1002 drbg_string_fill(&data2, drbg->V, drbg_statelen(drbg)); 1003 list_add_tail(&data2.list, &datalist); 1004 ret = drbg_kcapi_hash(drbg, drbg->scratchpad, &datalist); 1005 if (ret) { 1006 len = ret; 1007 goto out; 1008 } 1009 1010 /* 10.1.1.4 step 5 */ 1011 drbg_add_buf(drbg->V, drbg_statelen(drbg), 1012 drbg->scratchpad, drbg_blocklen(drbg)); 1013 drbg_add_buf(drbg->V, drbg_statelen(drbg), 1014 drbg->C, drbg_statelen(drbg)); 1015 u.req_int = cpu_to_be64(drbg->reseed_ctr); 1016 drbg_add_buf(drbg->V, drbg_statelen(drbg), u.req, 8); 1017 1018 out: 1019 memset(drbg->scratchpad, 0, drbg_blocklen(drbg)); 1020 return len; 1021 } 1022 1023 /* 1024 * scratchpad usage: as update and generate are used isolated, both 1025 * can use the scratchpad 1026 */ 1027 static const struct drbg_state_ops drbg_hash_ops = { 1028 .update = drbg_hash_update, 1029 .generate = drbg_hash_generate, 1030 .crypto_init = drbg_init_hash_kernel, 1031 .crypto_fini = drbg_fini_hash_kernel, 1032 }; 1033 #endif /* CONFIG_CRYPTO_DRBG_HASH */ 1034 1035 /****************************************************************** 1036 * Functions common for DRBG implementations 1037 ******************************************************************/ 1038 1039 static inline int __drbg_seed(struct drbg_state *drbg, struct list_head *seed, 1040 int reseed, enum drbg_seed_state new_seed_state) 1041 { 1042 int ret = drbg->d_ops->update(drbg, seed, reseed); 1043 1044 if (ret) 1045 return ret; 1046 1047 drbg->seeded = new_seed_state; 1048 drbg->last_seed_time = jiffies; 1049 /* 10.1.1.2 / 10.1.1.3 step 5 */ 1050 drbg->reseed_ctr = 1; 1051 1052 switch (drbg->seeded) { 1053 case DRBG_SEED_STATE_UNSEEDED: 1054 /* Impossible, but handle it to silence compiler warnings. */ 1055 fallthrough; 1056 case DRBG_SEED_STATE_PARTIAL: 1057 /* 1058 * Require frequent reseeds until the seed source is 1059 * fully initialized. 1060 */ 1061 drbg->reseed_threshold = 50; 1062 break; 1063 1064 case DRBG_SEED_STATE_FULL: 1065 /* 1066 * Seed source has become fully initialized, frequent 1067 * reseeds no longer required. 1068 */ 1069 drbg->reseed_threshold = drbg_max_requests(drbg); 1070 break; 1071 } 1072 1073 return ret; 1074 } 1075 1076 static inline int drbg_get_random_bytes(struct drbg_state *drbg, 1077 unsigned char *entropy, 1078 unsigned int entropylen) 1079 { 1080 int ret; 1081 1082 do { 1083 get_random_bytes(entropy, entropylen); 1084 ret = drbg_fips_continuous_test(drbg, entropy); 1085 if (ret && ret != -EAGAIN) 1086 return ret; 1087 } while (ret); 1088 1089 return 0; 1090 } 1091 1092 static int drbg_seed_from_random(struct drbg_state *drbg) 1093 { 1094 struct drbg_string data; 1095 LIST_HEAD(seedlist); 1096 unsigned int entropylen = drbg_sec_strength(drbg->core->flags); 1097 unsigned char entropy[32]; 1098 int ret; 1099 1100 BUG_ON(!entropylen); 1101 BUG_ON(entropylen > sizeof(entropy)); 1102 1103 drbg_string_fill(&data, entropy, entropylen); 1104 list_add_tail(&data.list, &seedlist); 1105 1106 ret = drbg_get_random_bytes(drbg, entropy, entropylen); 1107 if (ret) 1108 goto out; 1109 1110 ret = __drbg_seed(drbg, &seedlist, true, DRBG_SEED_STATE_FULL); 1111 1112 out: 1113 memzero_explicit(entropy, entropylen); 1114 return ret; 1115 } 1116 1117 static bool drbg_nopr_reseed_interval_elapsed(struct drbg_state *drbg) 1118 { 1119 unsigned long next_reseed; 1120 1121 /* Don't ever reseed from get_random_bytes() in test mode. */ 1122 if (list_empty(&drbg->test_data.list)) 1123 return false; 1124 1125 /* 1126 * Obtain fresh entropy for the nopr DRBGs after 300s have 1127 * elapsed in order to still achieve sort of partial 1128 * prediction resistance over the time domain at least. Note 1129 * that the period of 300s has been chosen to match the 1130 * CRNG_RESEED_INTERVAL of the get_random_bytes()' chacha 1131 * rngs. 1132 */ 1133 next_reseed = drbg->last_seed_time + 300 * HZ; 1134 return time_after(jiffies, next_reseed); 1135 } 1136 1137 /* 1138 * Seeding or reseeding of the DRBG 1139 * 1140 * @drbg: DRBG state struct 1141 * @pers: personalization / additional information buffer 1142 * @reseed: 0 for initial seed process, 1 for reseeding 1143 * 1144 * return: 1145 * 0 on success 1146 * error value otherwise 1147 */ 1148 static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, 1149 bool reseed) 1150 { 1151 int ret; 1152 unsigned char entropy[((32 + 16) * 2)]; 1153 unsigned int entropylen = drbg_sec_strength(drbg->core->flags); 1154 struct drbg_string data1; 1155 LIST_HEAD(seedlist); 1156 enum drbg_seed_state new_seed_state = DRBG_SEED_STATE_FULL; 1157 1158 /* 9.1 / 9.2 / 9.3.1 step 3 */ 1159 if (pers && pers->len > (drbg_max_addtl(drbg))) { 1160 pr_devel("DRBG: personalization string too long %zu\n", 1161 pers->len); 1162 return -EINVAL; 1163 } 1164 1165 if (list_empty(&drbg->test_data.list)) { 1166 drbg_string_fill(&data1, drbg->test_data.buf, 1167 drbg->test_data.len); 1168 pr_devel("DRBG: using test entropy\n"); 1169 } else { 1170 /* 1171 * Gather entropy equal to the security strength of the DRBG. 1172 * With a derivation function, a nonce is required in addition 1173 * to the entropy. A nonce must be at least 1/2 of the security 1174 * strength of the DRBG in size. Thus, entropy + nonce is 3/2 1175 * of the strength. The consideration of a nonce is only 1176 * applicable during initial seeding. 1177 */ 1178 BUG_ON(!entropylen); 1179 if (!reseed) 1180 entropylen = ((entropylen + 1) / 2) * 3; 1181 BUG_ON((entropylen * 2) > sizeof(entropy)); 1182 1183 /* Get seed from in-kernel /dev/urandom */ 1184 if (!rng_is_initialized()) 1185 new_seed_state = DRBG_SEED_STATE_PARTIAL; 1186 1187 ret = drbg_get_random_bytes(drbg, entropy, entropylen); 1188 if (ret) 1189 goto out; 1190 1191 if (!drbg->jent) { 1192 drbg_string_fill(&data1, entropy, entropylen); 1193 pr_devel("DRBG: (re)seeding with %u bytes of entropy\n", 1194 entropylen); 1195 } else { 1196 /* 1197 * Get seed from Jitter RNG, failures are 1198 * fatal only in FIPS mode. 1199 */ 1200 ret = crypto_rng_get_bytes(drbg->jent, 1201 entropy + entropylen, 1202 entropylen); 1203 if (fips_enabled && ret) { 1204 pr_devel("DRBG: jent failed with %d\n", ret); 1205 1206 /* 1207 * Do not treat the transient failure of the 1208 * Jitter RNG as an error that needs to be 1209 * reported. The combined number of the 1210 * maximum reseed threshold times the maximum 1211 * number of Jitter RNG transient errors is 1212 * less than the reseed threshold required by 1213 * SP800-90A allowing us to treat the 1214 * transient errors as such. 1215 * 1216 * However, we mandate that at least the first 1217 * seeding operation must succeed with the 1218 * Jitter RNG. 1219 */ 1220 if (!reseed || ret != -EAGAIN) 1221 goto out; 1222 } 1223 1224 drbg_string_fill(&data1, entropy, entropylen * 2); 1225 pr_devel("DRBG: (re)seeding with %u bytes of entropy\n", 1226 entropylen * 2); 1227 } 1228 } 1229 list_add_tail(&data1.list, &seedlist); 1230 1231 /* 1232 * concatenation of entropy with personalization str / addtl input) 1233 * the variable pers is directly handed in by the caller, so check its 1234 * contents whether it is appropriate 1235 */ 1236 if (pers && pers->buf && 0 < pers->len) { 1237 list_add_tail(&pers->list, &seedlist); 1238 pr_devel("DRBG: using personalization string\n"); 1239 } 1240 1241 if (!reseed) { 1242 memset(drbg->V, 0, drbg_statelen(drbg)); 1243 memset(drbg->C, 0, drbg_statelen(drbg)); 1244 } 1245 1246 ret = __drbg_seed(drbg, &seedlist, reseed, new_seed_state); 1247 1248 out: 1249 memzero_explicit(entropy, entropylen * 2); 1250 1251 return ret; 1252 } 1253 1254 /* Free all substructures in a DRBG state without the DRBG state structure */ 1255 static inline void drbg_dealloc_state(struct drbg_state *drbg) 1256 { 1257 if (!drbg) 1258 return; 1259 kfree_sensitive(drbg->Vbuf); 1260 drbg->Vbuf = NULL; 1261 drbg->V = NULL; 1262 kfree_sensitive(drbg->Cbuf); 1263 drbg->Cbuf = NULL; 1264 drbg->C = NULL; 1265 kfree_sensitive(drbg->scratchpadbuf); 1266 drbg->scratchpadbuf = NULL; 1267 drbg->reseed_ctr = 0; 1268 drbg->d_ops = NULL; 1269 drbg->core = NULL; 1270 if (IS_ENABLED(CONFIG_CRYPTO_FIPS)) { 1271 kfree_sensitive(drbg->prev); 1272 drbg->prev = NULL; 1273 drbg->fips_primed = false; 1274 } 1275 } 1276 1277 /* 1278 * Allocate all sub-structures for a DRBG state. 1279 * The DRBG state structure must already be allocated. 1280 */ 1281 static inline int drbg_alloc_state(struct drbg_state *drbg) 1282 { 1283 int ret = -ENOMEM; 1284 unsigned int sb_size = 0; 1285 1286 switch (drbg->core->flags & DRBG_TYPE_MASK) { 1287 #ifdef CONFIG_CRYPTO_DRBG_HMAC 1288 case DRBG_HMAC: 1289 drbg->d_ops = &drbg_hmac_ops; 1290 break; 1291 #endif /* CONFIG_CRYPTO_DRBG_HMAC */ 1292 #ifdef CONFIG_CRYPTO_DRBG_HASH 1293 case DRBG_HASH: 1294 drbg->d_ops = &drbg_hash_ops; 1295 break; 1296 #endif /* CONFIG_CRYPTO_DRBG_HASH */ 1297 #ifdef CONFIG_CRYPTO_DRBG_CTR 1298 case DRBG_CTR: 1299 drbg->d_ops = &drbg_ctr_ops; 1300 break; 1301 #endif /* CONFIG_CRYPTO_DRBG_CTR */ 1302 default: 1303 ret = -EOPNOTSUPP; 1304 goto err; 1305 } 1306 1307 ret = drbg->d_ops->crypto_init(drbg); 1308 if (ret < 0) 1309 goto err; 1310 1311 drbg->Vbuf = kmalloc(drbg_statelen(drbg) + ret, GFP_KERNEL); 1312 if (!drbg->Vbuf) { 1313 ret = -ENOMEM; 1314 goto fini; 1315 } 1316 drbg->V = PTR_ALIGN(drbg->Vbuf, ret + 1); 1317 drbg->Cbuf = kmalloc(drbg_statelen(drbg) + ret, GFP_KERNEL); 1318 if (!drbg->Cbuf) { 1319 ret = -ENOMEM; 1320 goto fini; 1321 } 1322 drbg->C = PTR_ALIGN(drbg->Cbuf, ret + 1); 1323 /* scratchpad is only generated for CTR and Hash */ 1324 if (drbg->core->flags & DRBG_HMAC) 1325 sb_size = 0; 1326 else if (drbg->core->flags & DRBG_CTR) 1327 sb_size = drbg_statelen(drbg) + drbg_blocklen(drbg) + /* temp */ 1328 drbg_statelen(drbg) + /* df_data */ 1329 drbg_blocklen(drbg) + /* pad */ 1330 drbg_blocklen(drbg) + /* iv */ 1331 drbg_statelen(drbg) + drbg_blocklen(drbg); /* temp */ 1332 else 1333 sb_size = drbg_statelen(drbg) + drbg_blocklen(drbg); 1334 1335 if (0 < sb_size) { 1336 drbg->scratchpadbuf = kzalloc(sb_size + ret, GFP_KERNEL); 1337 if (!drbg->scratchpadbuf) { 1338 ret = -ENOMEM; 1339 goto fini; 1340 } 1341 drbg->scratchpad = PTR_ALIGN(drbg->scratchpadbuf, ret + 1); 1342 } 1343 1344 if (IS_ENABLED(CONFIG_CRYPTO_FIPS)) { 1345 drbg->prev = kzalloc(drbg_sec_strength(drbg->core->flags), 1346 GFP_KERNEL); 1347 if (!drbg->prev) { 1348 ret = -ENOMEM; 1349 goto fini; 1350 } 1351 drbg->fips_primed = false; 1352 } 1353 1354 return 0; 1355 1356 fini: 1357 drbg->d_ops->crypto_fini(drbg); 1358 err: 1359 drbg_dealloc_state(drbg); 1360 return ret; 1361 } 1362 1363 /************************************************************************* 1364 * DRBG interface functions 1365 *************************************************************************/ 1366 1367 /* 1368 * DRBG generate function as required by SP800-90A - this function 1369 * generates random numbers 1370 * 1371 * @drbg DRBG state handle 1372 * @buf Buffer where to store the random numbers -- the buffer must already 1373 * be pre-allocated by caller 1374 * @buflen Length of output buffer - this value defines the number of random 1375 * bytes pulled from DRBG 1376 * @addtl Additional input that is mixed into state, may be NULL -- note 1377 * the entropy is pulled by the DRBG internally unconditionally 1378 * as defined in SP800-90A. The additional input is mixed into 1379 * the state in addition to the pulled entropy. 1380 * 1381 * return: 0 when all bytes are generated; < 0 in case of an error 1382 */ 1383 static int drbg_generate(struct drbg_state *drbg, 1384 unsigned char *buf, unsigned int buflen, 1385 struct drbg_string *addtl) 1386 { 1387 int len = 0; 1388 LIST_HEAD(addtllist); 1389 1390 if (!drbg->core) { 1391 pr_devel("DRBG: not yet seeded\n"); 1392 return -EINVAL; 1393 } 1394 if (0 == buflen || !buf) { 1395 pr_devel("DRBG: no output buffer provided\n"); 1396 return -EINVAL; 1397 } 1398 if (addtl && NULL == addtl->buf && 0 < addtl->len) { 1399 pr_devel("DRBG: wrong format of additional information\n"); 1400 return -EINVAL; 1401 } 1402 1403 /* 9.3.1 step 2 */ 1404 len = -EINVAL; 1405 if (buflen > (drbg_max_request_bytes(drbg))) { 1406 pr_devel("DRBG: requested random numbers too large %u\n", 1407 buflen); 1408 goto err; 1409 } 1410 1411 /* 9.3.1 step 3 is implicit with the chosen DRBG */ 1412 1413 /* 9.3.1 step 4 */ 1414 if (addtl && addtl->len > (drbg_max_addtl(drbg))) { 1415 pr_devel("DRBG: additional information string too long %zu\n", 1416 addtl->len); 1417 goto err; 1418 } 1419 /* 9.3.1 step 5 is implicit with the chosen DRBG */ 1420 1421 /* 1422 * 9.3.1 step 6 and 9 supplemented by 9.3.2 step c is implemented 1423 * here. The spec is a bit convoluted here, we make it simpler. 1424 */ 1425 if (drbg->reseed_threshold < drbg->reseed_ctr) 1426 drbg->seeded = DRBG_SEED_STATE_UNSEEDED; 1427 1428 if (drbg->pr || drbg->seeded == DRBG_SEED_STATE_UNSEEDED) { 1429 pr_devel("DRBG: reseeding before generation (prediction " 1430 "resistance: %s, state %s)\n", 1431 drbg->pr ? "true" : "false", 1432 (drbg->seeded == DRBG_SEED_STATE_FULL ? 1433 "seeded" : "unseeded")); 1434 /* 9.3.1 steps 7.1 through 7.3 */ 1435 len = drbg_seed(drbg, addtl, true); 1436 if (len) 1437 goto err; 1438 /* 9.3.1 step 7.4 */ 1439 addtl = NULL; 1440 } else if (rng_is_initialized() && 1441 (drbg->seeded == DRBG_SEED_STATE_PARTIAL || 1442 drbg_nopr_reseed_interval_elapsed(drbg))) { 1443 len = drbg_seed_from_random(drbg); 1444 if (len) 1445 goto err; 1446 } 1447 1448 if (addtl && 0 < addtl->len) 1449 list_add_tail(&addtl->list, &addtllist); 1450 /* 9.3.1 step 8 and 10 */ 1451 len = drbg->d_ops->generate(drbg, buf, buflen, &addtllist); 1452 1453 /* 10.1.1.4 step 6, 10.1.2.5 step 7, 10.2.1.5.2 step 7 */ 1454 drbg->reseed_ctr++; 1455 if (0 >= len) 1456 goto err; 1457 1458 /* 1459 * Section 11.3.3 requires to re-perform self tests after some 1460 * generated random numbers. The chosen value after which self 1461 * test is performed is arbitrary, but it should be reasonable. 1462 * However, we do not perform the self tests because of the following 1463 * reasons: it is mathematically impossible that the initial self tests 1464 * were successfully and the following are not. If the initial would 1465 * pass and the following would not, the kernel integrity is violated. 1466 * In this case, the entire kernel operation is questionable and it 1467 * is unlikely that the integrity violation only affects the 1468 * correct operation of the DRBG. 1469 * 1470 * Albeit the following code is commented out, it is provided in 1471 * case somebody has a need to implement the test of 11.3.3. 1472 */ 1473 #if 0 1474 if (drbg->reseed_ctr && !(drbg->reseed_ctr % 4096)) { 1475 int err = 0; 1476 pr_devel("DRBG: start to perform self test\n"); 1477 if (drbg->core->flags & DRBG_HMAC) 1478 err = alg_test("drbg_pr_hmac_sha256", 1479 "drbg_pr_hmac_sha256", 0, 0); 1480 else if (drbg->core->flags & DRBG_CTR) 1481 err = alg_test("drbg_pr_ctr_aes128", 1482 "drbg_pr_ctr_aes128", 0, 0); 1483 else 1484 err = alg_test("drbg_pr_sha256", 1485 "drbg_pr_sha256", 0, 0); 1486 if (err) { 1487 pr_err("DRBG: periodical self test failed\n"); 1488 /* 1489 * uninstantiate implies that from now on, only errors 1490 * are returned when reusing this DRBG cipher handle 1491 */ 1492 drbg_uninstantiate(drbg); 1493 return 0; 1494 } else { 1495 pr_devel("DRBG: self test successful\n"); 1496 } 1497 } 1498 #endif 1499 1500 /* 1501 * All operations were successful, return 0 as mandated by 1502 * the kernel crypto API interface. 1503 */ 1504 len = 0; 1505 err: 1506 return len; 1507 } 1508 1509 /* 1510 * Wrapper around drbg_generate which can pull arbitrary long strings 1511 * from the DRBG without hitting the maximum request limitation. 1512 * 1513 * Parameters: see drbg_generate 1514 * Return codes: see drbg_generate -- if one drbg_generate request fails, 1515 * the entire drbg_generate_long request fails 1516 */ 1517 static int drbg_generate_long(struct drbg_state *drbg, 1518 unsigned char *buf, unsigned int buflen, 1519 struct drbg_string *addtl) 1520 { 1521 unsigned int len = 0; 1522 unsigned int slice = 0; 1523 do { 1524 int err = 0; 1525 unsigned int chunk = 0; 1526 slice = ((buflen - len) / drbg_max_request_bytes(drbg)); 1527 chunk = slice ? drbg_max_request_bytes(drbg) : (buflen - len); 1528 mutex_lock(&drbg->drbg_mutex); 1529 err = drbg_generate(drbg, buf + len, chunk, addtl); 1530 mutex_unlock(&drbg->drbg_mutex); 1531 if (0 > err) 1532 return err; 1533 len += chunk; 1534 } while (slice > 0 && (len < buflen)); 1535 return 0; 1536 } 1537 1538 static int drbg_prepare_hrng(struct drbg_state *drbg) 1539 { 1540 /* We do not need an HRNG in test mode. */ 1541 if (list_empty(&drbg->test_data.list)) 1542 return 0; 1543 1544 drbg->jent = crypto_alloc_rng("jitterentropy_rng", 0, 0); 1545 if (IS_ERR(drbg->jent)) { 1546 const int err = PTR_ERR(drbg->jent); 1547 1548 drbg->jent = NULL; 1549 if (fips_enabled) 1550 return err; 1551 pr_info("DRBG: Continuing without Jitter RNG\n"); 1552 } 1553 1554 return 0; 1555 } 1556 1557 /* 1558 * DRBG instantiation function as required by SP800-90A - this function 1559 * sets up the DRBG handle, performs the initial seeding and all sanity 1560 * checks required by SP800-90A 1561 * 1562 * @drbg memory of state -- if NULL, new memory is allocated 1563 * @pers Personalization string that is mixed into state, may be NULL -- note 1564 * the entropy is pulled by the DRBG internally unconditionally 1565 * as defined in SP800-90A. The additional input is mixed into 1566 * the state in addition to the pulled entropy. 1567 * @coreref reference to core 1568 * @pr prediction resistance enabled 1569 * 1570 * return 1571 * 0 on success 1572 * error value otherwise 1573 */ 1574 static int drbg_instantiate(struct drbg_state *drbg, struct drbg_string *pers, 1575 int coreref, bool pr) 1576 { 1577 int ret; 1578 bool reseed = true; 1579 1580 pr_devel("DRBG: Initializing DRBG core %d with prediction resistance " 1581 "%s\n", coreref, pr ? "enabled" : "disabled"); 1582 mutex_lock(&drbg->drbg_mutex); 1583 1584 /* 9.1 step 1 is implicit with the selected DRBG type */ 1585 1586 /* 1587 * 9.1 step 2 is implicit as caller can select prediction resistance 1588 * and the flag is copied into drbg->flags -- 1589 * all DRBG types support prediction resistance 1590 */ 1591 1592 /* 9.1 step 4 is implicit in drbg_sec_strength */ 1593 1594 if (!drbg->core) { 1595 drbg->core = &drbg_cores[coreref]; 1596 drbg->pr = pr; 1597 drbg->seeded = DRBG_SEED_STATE_UNSEEDED; 1598 drbg->last_seed_time = 0; 1599 drbg->reseed_threshold = drbg_max_requests(drbg); 1600 1601 ret = drbg_alloc_state(drbg); 1602 if (ret) 1603 goto unlock; 1604 1605 ret = drbg_prepare_hrng(drbg); 1606 if (ret) 1607 goto free_everything; 1608 1609 reseed = false; 1610 } 1611 1612 ret = drbg_seed(drbg, pers, reseed); 1613 1614 if (ret && !reseed) 1615 goto free_everything; 1616 1617 mutex_unlock(&drbg->drbg_mutex); 1618 return ret; 1619 1620 unlock: 1621 mutex_unlock(&drbg->drbg_mutex); 1622 return ret; 1623 1624 free_everything: 1625 mutex_unlock(&drbg->drbg_mutex); 1626 drbg_uninstantiate(drbg); 1627 return ret; 1628 } 1629 1630 /* 1631 * DRBG uninstantiate function as required by SP800-90A - this function 1632 * frees all buffers and the DRBG handle 1633 * 1634 * @drbg DRBG state handle 1635 * 1636 * return 1637 * 0 on success 1638 */ 1639 static int drbg_uninstantiate(struct drbg_state *drbg) 1640 { 1641 if (!IS_ERR_OR_NULL(drbg->jent)) 1642 crypto_free_rng(drbg->jent); 1643 drbg->jent = NULL; 1644 1645 if (drbg->d_ops) 1646 drbg->d_ops->crypto_fini(drbg); 1647 drbg_dealloc_state(drbg); 1648 /* no scrubbing of test_data -- this shall survive an uninstantiate */ 1649 return 0; 1650 } 1651 1652 /* 1653 * Helper function for setting the test data in the DRBG 1654 * 1655 * @drbg DRBG state handle 1656 * @data test data 1657 * @len test data length 1658 */ 1659 static void drbg_kcapi_set_entropy(struct crypto_rng *tfm, 1660 const u8 *data, unsigned int len) 1661 { 1662 struct drbg_state *drbg = crypto_rng_ctx(tfm); 1663 1664 mutex_lock(&drbg->drbg_mutex); 1665 drbg_string_fill(&drbg->test_data, data, len); 1666 mutex_unlock(&drbg->drbg_mutex); 1667 } 1668 1669 /*************************************************************** 1670 * Kernel crypto API cipher invocations requested by DRBG 1671 ***************************************************************/ 1672 1673 #if defined(CONFIG_CRYPTO_DRBG_HASH) || defined(CONFIG_CRYPTO_DRBG_HMAC) 1674 struct sdesc { 1675 struct shash_desc shash; 1676 char ctx[]; 1677 }; 1678 1679 static int drbg_init_hash_kernel(struct drbg_state *drbg) 1680 { 1681 struct sdesc *sdesc; 1682 struct crypto_shash *tfm; 1683 1684 tfm = crypto_alloc_shash(drbg->core->backend_cra_name, 0, 0); 1685 if (IS_ERR(tfm)) { 1686 pr_info("DRBG: could not allocate digest TFM handle: %s\n", 1687 drbg->core->backend_cra_name); 1688 return PTR_ERR(tfm); 1689 } 1690 BUG_ON(drbg_blocklen(drbg) != crypto_shash_digestsize(tfm)); 1691 sdesc = kzalloc(sizeof(struct shash_desc) + crypto_shash_descsize(tfm), 1692 GFP_KERNEL); 1693 if (!sdesc) { 1694 crypto_free_shash(tfm); 1695 return -ENOMEM; 1696 } 1697 1698 sdesc->shash.tfm = tfm; 1699 drbg->priv_data = sdesc; 1700 1701 return crypto_shash_alignmask(tfm); 1702 } 1703 1704 static int drbg_fini_hash_kernel(struct drbg_state *drbg) 1705 { 1706 struct sdesc *sdesc = drbg->priv_data; 1707 if (sdesc) { 1708 crypto_free_shash(sdesc->shash.tfm); 1709 kfree_sensitive(sdesc); 1710 } 1711 drbg->priv_data = NULL; 1712 return 0; 1713 } 1714 1715 static void drbg_kcapi_hmacsetkey(struct drbg_state *drbg, 1716 const unsigned char *key) 1717 { 1718 struct sdesc *sdesc = drbg->priv_data; 1719 1720 crypto_shash_setkey(sdesc->shash.tfm, key, drbg_statelen(drbg)); 1721 } 1722 1723 static int drbg_kcapi_hash(struct drbg_state *drbg, unsigned char *outval, 1724 const struct list_head *in) 1725 { 1726 struct sdesc *sdesc = drbg->priv_data; 1727 struct drbg_string *input = NULL; 1728 1729 crypto_shash_init(&sdesc->shash); 1730 list_for_each_entry(input, in, list) 1731 crypto_shash_update(&sdesc->shash, input->buf, input->len); 1732 return crypto_shash_final(&sdesc->shash, outval); 1733 } 1734 #endif /* (CONFIG_CRYPTO_DRBG_HASH || CONFIG_CRYPTO_DRBG_HMAC) */ 1735 1736 #ifdef CONFIG_CRYPTO_DRBG_CTR 1737 static int drbg_fini_sym_kernel(struct drbg_state *drbg) 1738 { 1739 struct crypto_cipher *tfm = 1740 (struct crypto_cipher *)drbg->priv_data; 1741 if (tfm) 1742 crypto_free_cipher(tfm); 1743 drbg->priv_data = NULL; 1744 1745 if (drbg->ctr_handle) 1746 crypto_free_skcipher(drbg->ctr_handle); 1747 drbg->ctr_handle = NULL; 1748 1749 if (drbg->ctr_req) 1750 skcipher_request_free(drbg->ctr_req); 1751 drbg->ctr_req = NULL; 1752 1753 kfree(drbg->outscratchpadbuf); 1754 drbg->outscratchpadbuf = NULL; 1755 1756 return 0; 1757 } 1758 1759 static int drbg_init_sym_kernel(struct drbg_state *drbg) 1760 { 1761 struct crypto_cipher *tfm; 1762 struct crypto_skcipher *sk_tfm; 1763 struct skcipher_request *req; 1764 unsigned int alignmask; 1765 char ctr_name[CRYPTO_MAX_ALG_NAME]; 1766 1767 tfm = crypto_alloc_cipher(drbg->core->backend_cra_name, 0, 0); 1768 if (IS_ERR(tfm)) { 1769 pr_info("DRBG: could not allocate cipher TFM handle: %s\n", 1770 drbg->core->backend_cra_name); 1771 return PTR_ERR(tfm); 1772 } 1773 BUG_ON(drbg_blocklen(drbg) != crypto_cipher_blocksize(tfm)); 1774 drbg->priv_data = tfm; 1775 1776 if (snprintf(ctr_name, CRYPTO_MAX_ALG_NAME, "ctr(%s)", 1777 drbg->core->backend_cra_name) >= CRYPTO_MAX_ALG_NAME) { 1778 drbg_fini_sym_kernel(drbg); 1779 return -EINVAL; 1780 } 1781 sk_tfm = crypto_alloc_skcipher(ctr_name, 0, 0); 1782 if (IS_ERR(sk_tfm)) { 1783 pr_info("DRBG: could not allocate CTR cipher TFM handle: %s\n", 1784 ctr_name); 1785 drbg_fini_sym_kernel(drbg); 1786 return PTR_ERR(sk_tfm); 1787 } 1788 drbg->ctr_handle = sk_tfm; 1789 crypto_init_wait(&drbg->ctr_wait); 1790 1791 req = skcipher_request_alloc(sk_tfm, GFP_KERNEL); 1792 if (!req) { 1793 pr_info("DRBG: could not allocate request queue\n"); 1794 drbg_fini_sym_kernel(drbg); 1795 return -ENOMEM; 1796 } 1797 drbg->ctr_req = req; 1798 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG | 1799 CRYPTO_TFM_REQ_MAY_SLEEP, 1800 crypto_req_done, &drbg->ctr_wait); 1801 1802 alignmask = crypto_skcipher_alignmask(sk_tfm); 1803 drbg->outscratchpadbuf = kmalloc(DRBG_OUTSCRATCHLEN + alignmask, 1804 GFP_KERNEL); 1805 if (!drbg->outscratchpadbuf) { 1806 drbg_fini_sym_kernel(drbg); 1807 return -ENOMEM; 1808 } 1809 drbg->outscratchpad = (u8 *)PTR_ALIGN(drbg->outscratchpadbuf, 1810 alignmask + 1); 1811 1812 sg_init_table(&drbg->sg_in, 1); 1813 sg_init_one(&drbg->sg_out, drbg->outscratchpad, DRBG_OUTSCRATCHLEN); 1814 1815 return alignmask; 1816 } 1817 1818 static void drbg_kcapi_symsetkey(struct drbg_state *drbg, 1819 const unsigned char *key) 1820 { 1821 struct crypto_cipher *tfm = drbg->priv_data; 1822 1823 crypto_cipher_setkey(tfm, key, (drbg_keylen(drbg))); 1824 } 1825 1826 static int drbg_kcapi_sym(struct drbg_state *drbg, unsigned char *outval, 1827 const struct drbg_string *in) 1828 { 1829 struct crypto_cipher *tfm = drbg->priv_data; 1830 1831 /* there is only component in *in */ 1832 BUG_ON(in->len < drbg_blocklen(drbg)); 1833 crypto_cipher_encrypt_one(tfm, outval, in->buf); 1834 return 0; 1835 } 1836 1837 static int drbg_kcapi_sym_ctr(struct drbg_state *drbg, 1838 u8 *inbuf, u32 inlen, 1839 u8 *outbuf, u32 outlen) 1840 { 1841 struct scatterlist *sg_in = &drbg->sg_in, *sg_out = &drbg->sg_out; 1842 u32 scratchpad_use = min_t(u32, outlen, DRBG_OUTSCRATCHLEN); 1843 int ret; 1844 1845 if (inbuf) { 1846 /* Use caller-provided input buffer */ 1847 sg_set_buf(sg_in, inbuf, inlen); 1848 } else { 1849 /* Use scratchpad for in-place operation */ 1850 inlen = scratchpad_use; 1851 memset(drbg->outscratchpad, 0, scratchpad_use); 1852 sg_set_buf(sg_in, drbg->outscratchpad, scratchpad_use); 1853 } 1854 1855 while (outlen) { 1856 u32 cryptlen = min3(inlen, outlen, (u32)DRBG_OUTSCRATCHLEN); 1857 1858 /* Output buffer may not be valid for SGL, use scratchpad */ 1859 skcipher_request_set_crypt(drbg->ctr_req, sg_in, sg_out, 1860 cryptlen, drbg->V); 1861 ret = crypto_wait_req(crypto_skcipher_encrypt(drbg->ctr_req), 1862 &drbg->ctr_wait); 1863 if (ret) 1864 goto out; 1865 1866 crypto_init_wait(&drbg->ctr_wait); 1867 1868 memcpy(outbuf, drbg->outscratchpad, cryptlen); 1869 memzero_explicit(drbg->outscratchpad, cryptlen); 1870 1871 outlen -= cryptlen; 1872 outbuf += cryptlen; 1873 } 1874 ret = 0; 1875 1876 out: 1877 return ret; 1878 } 1879 #endif /* CONFIG_CRYPTO_DRBG_CTR */ 1880 1881 /*************************************************************** 1882 * Kernel crypto API interface to register DRBG 1883 ***************************************************************/ 1884 1885 /* 1886 * Look up the DRBG flags by given kernel crypto API cra_name 1887 * The code uses the drbg_cores definition to do this 1888 * 1889 * @cra_name kernel crypto API cra_name 1890 * @coreref reference to integer which is filled with the pointer to 1891 * the applicable core 1892 * @pr reference for setting prediction resistance 1893 * 1894 * return: flags 1895 */ 1896 static inline void drbg_convert_tfm_core(const char *cra_driver_name, 1897 int *coreref, bool *pr) 1898 { 1899 int i = 0; 1900 size_t start = 0; 1901 int len = 0; 1902 1903 *pr = true; 1904 /* disassemble the names */ 1905 if (!memcmp(cra_driver_name, "drbg_nopr_", 10)) { 1906 start = 10; 1907 *pr = false; 1908 } else if (!memcmp(cra_driver_name, "drbg_pr_", 8)) { 1909 start = 8; 1910 } else { 1911 return; 1912 } 1913 1914 /* remove the first part */ 1915 len = strlen(cra_driver_name) - start; 1916 for (i = 0; ARRAY_SIZE(drbg_cores) > i; i++) { 1917 if (!memcmp(cra_driver_name + start, drbg_cores[i].cra_name, 1918 len)) { 1919 *coreref = i; 1920 return; 1921 } 1922 } 1923 } 1924 1925 static int drbg_kcapi_init(struct crypto_tfm *tfm) 1926 { 1927 struct drbg_state *drbg = crypto_tfm_ctx(tfm); 1928 1929 mutex_init(&drbg->drbg_mutex); 1930 1931 return 0; 1932 } 1933 1934 static void drbg_kcapi_cleanup(struct crypto_tfm *tfm) 1935 { 1936 drbg_uninstantiate(crypto_tfm_ctx(tfm)); 1937 } 1938 1939 /* 1940 * Generate random numbers invoked by the kernel crypto API: 1941 * The API of the kernel crypto API is extended as follows: 1942 * 1943 * src is additional input supplied to the RNG. 1944 * slen is the length of src. 1945 * dst is the output buffer where random data is to be stored. 1946 * dlen is the length of dst. 1947 */ 1948 static int drbg_kcapi_random(struct crypto_rng *tfm, 1949 const u8 *src, unsigned int slen, 1950 u8 *dst, unsigned int dlen) 1951 { 1952 struct drbg_state *drbg = crypto_rng_ctx(tfm); 1953 struct drbg_string *addtl = NULL; 1954 struct drbg_string string; 1955 1956 if (slen) { 1957 /* linked list variable is now local to allow modification */ 1958 drbg_string_fill(&string, src, slen); 1959 addtl = &string; 1960 } 1961 1962 return drbg_generate_long(drbg, dst, dlen, addtl); 1963 } 1964 1965 /* 1966 * Seed the DRBG invoked by the kernel crypto API 1967 */ 1968 static int drbg_kcapi_seed(struct crypto_rng *tfm, 1969 const u8 *seed, unsigned int slen) 1970 { 1971 struct drbg_state *drbg = crypto_rng_ctx(tfm); 1972 struct crypto_tfm *tfm_base = crypto_rng_tfm(tfm); 1973 bool pr = false; 1974 struct drbg_string string; 1975 struct drbg_string *seed_string = NULL; 1976 int coreref = 0; 1977 1978 drbg_convert_tfm_core(crypto_tfm_alg_driver_name(tfm_base), &coreref, 1979 &pr); 1980 if (0 < slen) { 1981 drbg_string_fill(&string, seed, slen); 1982 seed_string = &string; 1983 } 1984 1985 return drbg_instantiate(drbg, seed_string, coreref, pr); 1986 } 1987 1988 /*************************************************************** 1989 * Kernel module: code to load the module 1990 ***************************************************************/ 1991 1992 /* 1993 * Tests as defined in 11.3.2 in addition to the cipher tests: testing 1994 * of the error handling. 1995 * 1996 * Note: testing of failing seed source as defined in 11.3.2 is not applicable 1997 * as seed source of get_random_bytes does not fail. 1998 * 1999 * Note 2: There is no sensible way of testing the reseed counter 2000 * enforcement, so skip it. 2001 */ 2002 static inline int __init drbg_healthcheck_sanity(void) 2003 { 2004 int len = 0; 2005 #define OUTBUFLEN 16 2006 unsigned char buf[OUTBUFLEN]; 2007 struct drbg_state *drbg = NULL; 2008 int ret; 2009 int rc = -EFAULT; 2010 bool pr = false; 2011 int coreref = 0; 2012 struct drbg_string addtl; 2013 size_t max_addtllen, max_request_bytes; 2014 2015 /* only perform test in FIPS mode */ 2016 if (!fips_enabled) 2017 return 0; 2018 2019 #ifdef CONFIG_CRYPTO_DRBG_CTR 2020 drbg_convert_tfm_core("drbg_nopr_ctr_aes128", &coreref, &pr); 2021 #elif defined CONFIG_CRYPTO_DRBG_HASH 2022 drbg_convert_tfm_core("drbg_nopr_sha256", &coreref, &pr); 2023 #else 2024 drbg_convert_tfm_core("drbg_nopr_hmac_sha256", &coreref, &pr); 2025 #endif 2026 2027 drbg = kzalloc(sizeof(struct drbg_state), GFP_KERNEL); 2028 if (!drbg) 2029 return -ENOMEM; 2030 2031 mutex_init(&drbg->drbg_mutex); 2032 drbg->core = &drbg_cores[coreref]; 2033 drbg->reseed_threshold = drbg_max_requests(drbg); 2034 2035 /* 2036 * if the following tests fail, it is likely that there is a buffer 2037 * overflow as buf is much smaller than the requested or provided 2038 * string lengths -- in case the error handling does not succeed 2039 * we may get an OOPS. And we want to get an OOPS as this is a 2040 * grave bug. 2041 */ 2042 2043 max_addtllen = drbg_max_addtl(drbg); 2044 max_request_bytes = drbg_max_request_bytes(drbg); 2045 drbg_string_fill(&addtl, buf, max_addtllen + 1); 2046 /* overflow addtllen with additonal info string */ 2047 len = drbg_generate(drbg, buf, OUTBUFLEN, &addtl); 2048 BUG_ON(0 < len); 2049 /* overflow max_bits */ 2050 len = drbg_generate(drbg, buf, (max_request_bytes + 1), NULL); 2051 BUG_ON(0 < len); 2052 2053 /* overflow max addtllen with personalization string */ 2054 ret = drbg_seed(drbg, &addtl, false); 2055 BUG_ON(0 == ret); 2056 /* all tests passed */ 2057 rc = 0; 2058 2059 pr_devel("DRBG: Sanity tests for failure code paths successfully " 2060 "completed\n"); 2061 2062 kfree(drbg); 2063 return rc; 2064 } 2065 2066 static struct rng_alg drbg_algs[22]; 2067 2068 /* 2069 * Fill the array drbg_algs used to register the different DRBGs 2070 * with the kernel crypto API. To fill the array, the information 2071 * from drbg_cores[] is used. 2072 */ 2073 static inline void __init drbg_fill_array(struct rng_alg *alg, 2074 const struct drbg_core *core, int pr) 2075 { 2076 int pos = 0; 2077 static int priority = 200; 2078 2079 memcpy(alg->base.cra_name, "stdrng", 6); 2080 if (pr) { 2081 memcpy(alg->base.cra_driver_name, "drbg_pr_", 8); 2082 pos = 8; 2083 } else { 2084 memcpy(alg->base.cra_driver_name, "drbg_nopr_", 10); 2085 pos = 10; 2086 } 2087 memcpy(alg->base.cra_driver_name + pos, core->cra_name, 2088 strlen(core->cra_name)); 2089 2090 alg->base.cra_priority = priority; 2091 priority++; 2092 /* 2093 * If FIPS mode enabled, the selected DRBG shall have the 2094 * highest cra_priority over other stdrng instances to ensure 2095 * it is selected. 2096 */ 2097 if (fips_enabled) 2098 alg->base.cra_priority += 200; 2099 2100 alg->base.cra_ctxsize = sizeof(struct drbg_state); 2101 alg->base.cra_module = THIS_MODULE; 2102 alg->base.cra_init = drbg_kcapi_init; 2103 alg->base.cra_exit = drbg_kcapi_cleanup; 2104 alg->generate = drbg_kcapi_random; 2105 alg->seed = drbg_kcapi_seed; 2106 alg->set_ent = drbg_kcapi_set_entropy; 2107 alg->seedsize = 0; 2108 } 2109 2110 static int __init drbg_init(void) 2111 { 2112 unsigned int i = 0; /* pointer to drbg_algs */ 2113 unsigned int j = 0; /* pointer to drbg_cores */ 2114 int ret; 2115 2116 ret = drbg_healthcheck_sanity(); 2117 if (ret) 2118 return ret; 2119 2120 if (ARRAY_SIZE(drbg_cores) * 2 > ARRAY_SIZE(drbg_algs)) { 2121 pr_info("DRBG: Cannot register all DRBG types" 2122 "(slots needed: %zu, slots available: %zu)\n", 2123 ARRAY_SIZE(drbg_cores) * 2, ARRAY_SIZE(drbg_algs)); 2124 return -EFAULT; 2125 } 2126 2127 /* 2128 * each DRBG definition can be used with PR and without PR, thus 2129 * we instantiate each DRBG in drbg_cores[] twice. 2130 * 2131 * As the order of placing them into the drbg_algs array matters 2132 * (the later DRBGs receive a higher cra_priority) we register the 2133 * prediction resistance DRBGs first as the should not be too 2134 * interesting. 2135 */ 2136 for (j = 0; ARRAY_SIZE(drbg_cores) > j; j++, i++) 2137 drbg_fill_array(&drbg_algs[i], &drbg_cores[j], 1); 2138 for (j = 0; ARRAY_SIZE(drbg_cores) > j; j++, i++) 2139 drbg_fill_array(&drbg_algs[i], &drbg_cores[j], 0); 2140 return crypto_register_rngs(drbg_algs, (ARRAY_SIZE(drbg_cores) * 2)); 2141 } 2142 2143 static void __exit drbg_exit(void) 2144 { 2145 crypto_unregister_rngs(drbg_algs, (ARRAY_SIZE(drbg_cores) * 2)); 2146 } 2147 2148 subsys_initcall(drbg_init); 2149 module_exit(drbg_exit); 2150 #ifndef CRYPTO_DRBG_HASH_STRING 2151 #define CRYPTO_DRBG_HASH_STRING "" 2152 #endif 2153 #ifndef CRYPTO_DRBG_HMAC_STRING 2154 #define CRYPTO_DRBG_HMAC_STRING "" 2155 #endif 2156 #ifndef CRYPTO_DRBG_CTR_STRING 2157 #define CRYPTO_DRBG_CTR_STRING "" 2158 #endif 2159 MODULE_LICENSE("GPL"); 2160 MODULE_AUTHOR("Stephan Mueller <smueller@chronox.de>"); 2161 MODULE_DESCRIPTION("NIST SP800-90A Deterministic Random Bit Generator (DRBG) " 2162 "using following cores: " 2163 CRYPTO_DRBG_HASH_STRING 2164 CRYPTO_DRBG_HMAC_STRING 2165 CRYPTO_DRBG_CTR_STRING); 2166 MODULE_ALIAS_CRYPTO("stdrng"); 2167 MODULE_IMPORT_NS(CRYPTO_INTERNAL); 2168