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