1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (c) 2013, Google Inc. 4 */ 5 6 #include "mkimage.h" 7 #include <stdio.h> 8 #include <string.h> 9 #include <image.h> 10 #include <time.h> 11 #include <openssl/bn.h> 12 #include <openssl/rsa.h> 13 #include <openssl/pem.h> 14 #include <openssl/err.h> 15 #include <openssl/ssl.h> 16 #include <openssl/evp.h> 17 #include <openssl/engine.h> 18 19 #if OPENSSL_VERSION_NUMBER >= 0x10000000L 20 #define HAVE_ERR_REMOVE_THREAD_STATE 21 #endif 22 23 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \ 24 (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x02070000fL) 25 static void RSA_get0_key(const RSA *r, 26 const BIGNUM **n, const BIGNUM **e, const BIGNUM **d) 27 { 28 if (n != NULL) 29 *n = r->n; 30 if (e != NULL) 31 *e = r->e; 32 if (d != NULL) 33 *d = r->d; 34 } 35 #endif 36 37 static int rsa_err(const char *msg) 38 { 39 unsigned long sslErr = ERR_get_error(); 40 41 fprintf(stderr, "%s", msg); 42 fprintf(stderr, ": %s\n", 43 ERR_error_string(sslErr, 0)); 44 45 return -1; 46 } 47 48 /** 49 * rsa_pem_get_pub_key() - read a public key from a .crt file 50 * 51 * @keydir: Directory containins the key 52 * @name Name of key file (will have a .crt extension) 53 * @rsap Returns RSA object, or NULL on failure 54 * @return 0 if ok, -ve on error (in which case *rsap will be set to NULL) 55 */ 56 static int rsa_pem_get_pub_key(const char *keydir, const char *name, RSA **rsap) 57 { 58 char path[1024]; 59 EVP_PKEY *key; 60 X509 *cert; 61 RSA *rsa; 62 FILE *f; 63 int ret; 64 65 *rsap = NULL; 66 snprintf(path, sizeof(path), "%s/%s.crt", keydir, name); 67 f = fopen(path, "r"); 68 if (!f) { 69 fprintf(stderr, "Couldn't open RSA certificate: '%s': %s\n", 70 path, strerror(errno)); 71 return -EACCES; 72 } 73 74 /* Read the certificate */ 75 cert = NULL; 76 if (!PEM_read_X509(f, &cert, NULL, NULL)) { 77 rsa_err("Couldn't read certificate"); 78 ret = -EINVAL; 79 goto err_cert; 80 } 81 82 /* Get the public key from the certificate. */ 83 key = X509_get_pubkey(cert); 84 if (!key) { 85 rsa_err("Couldn't read public key\n"); 86 ret = -EINVAL; 87 goto err_pubkey; 88 } 89 90 /* Convert to a RSA_style key. */ 91 rsa = EVP_PKEY_get1_RSA(key); 92 if (!rsa) { 93 rsa_err("Couldn't convert to a RSA style key"); 94 ret = -EINVAL; 95 goto err_rsa; 96 } 97 fclose(f); 98 EVP_PKEY_free(key); 99 X509_free(cert); 100 *rsap = rsa; 101 102 return 0; 103 104 err_rsa: 105 EVP_PKEY_free(key); 106 err_pubkey: 107 X509_free(cert); 108 err_cert: 109 fclose(f); 110 return ret; 111 } 112 113 /** 114 * rsa_engine_get_pub_key() - read a public key from given engine 115 * 116 * @keydir: Key prefix 117 * @name Name of key 118 * @engine Engine to use 119 * @rsap Returns RSA object, or NULL on failure 120 * @return 0 if ok, -ve on error (in which case *rsap will be set to NULL) 121 */ 122 static int rsa_engine_get_pub_key(const char *keydir, const char *name, 123 ENGINE *engine, RSA **rsap) 124 { 125 const char *engine_id; 126 char key_id[1024]; 127 EVP_PKEY *key; 128 RSA *rsa; 129 int ret; 130 131 *rsap = NULL; 132 133 engine_id = ENGINE_get_id(engine); 134 135 if (engine_id && !strcmp(engine_id, "pkcs11")) { 136 if (keydir) 137 snprintf(key_id, sizeof(key_id), 138 "pkcs11:%s;object=%s;type=public", 139 keydir, name); 140 else 141 snprintf(key_id, sizeof(key_id), 142 "pkcs11:object=%s;type=public", 143 name); 144 } else { 145 fprintf(stderr, "Engine not supported\n"); 146 return -ENOTSUP; 147 } 148 149 key = ENGINE_load_public_key(engine, key_id, NULL, NULL); 150 if (!key) 151 return rsa_err("Failure loading public key from engine"); 152 153 /* Convert to a RSA_style key. */ 154 rsa = EVP_PKEY_get1_RSA(key); 155 if (!rsa) { 156 rsa_err("Couldn't convert to a RSA style key"); 157 ret = -EINVAL; 158 goto err_rsa; 159 } 160 161 EVP_PKEY_free(key); 162 *rsap = rsa; 163 164 return 0; 165 166 err_rsa: 167 EVP_PKEY_free(key); 168 return ret; 169 } 170 171 /** 172 * rsa_get_pub_key() - read a public key 173 * 174 * @keydir: Directory containing the key (PEM file) or key prefix (engine) 175 * @name Name of key file (will have a .crt extension) 176 * @engine Engine to use 177 * @rsap Returns RSA object, or NULL on failure 178 * @return 0 if ok, -ve on error (in which case *rsap will be set to NULL) 179 */ 180 static int rsa_get_pub_key(const char *keydir, const char *name, 181 ENGINE *engine, RSA **rsap) 182 { 183 if (engine) 184 return rsa_engine_get_pub_key(keydir, name, engine, rsap); 185 return rsa_pem_get_pub_key(keydir, name, rsap); 186 } 187 188 /** 189 * rsa_pem_get_priv_key() - read a private key from a .key file 190 * 191 * @keydir: Directory containing the key 192 * @name Name of key file (will have a .key extension) 193 * @rsap Returns RSA object, or NULL on failure 194 * @return 0 if ok, -ve on error (in which case *rsap will be set to NULL) 195 */ 196 static int rsa_pem_get_priv_key(const char *keydir, const char *name, 197 RSA **rsap) 198 { 199 char path[1024]; 200 RSA *rsa; 201 FILE *f; 202 203 *rsap = NULL; 204 snprintf(path, sizeof(path), "%s/%s.key", keydir, name); 205 f = fopen(path, "r"); 206 if (!f) { 207 fprintf(stderr, "Couldn't open RSA private key: '%s': %s\n", 208 path, strerror(errno)); 209 return -ENOENT; 210 } 211 212 rsa = PEM_read_RSAPrivateKey(f, 0, NULL, path); 213 if (!rsa) { 214 rsa_err("Failure reading private key"); 215 fclose(f); 216 return -EPROTO; 217 } 218 fclose(f); 219 *rsap = rsa; 220 221 return 0; 222 } 223 224 /** 225 * rsa_engine_get_priv_key() - read a private key from given engine 226 * 227 * @keydir: Key prefix 228 * @name Name of key 229 * @engine Engine to use 230 * @rsap Returns RSA object, or NULL on failure 231 * @return 0 if ok, -ve on error (in which case *rsap will be set to NULL) 232 */ 233 static int rsa_engine_get_priv_key(const char *keydir, const char *name, 234 ENGINE *engine, RSA **rsap) 235 { 236 const char *engine_id; 237 char key_id[1024]; 238 EVP_PKEY *key; 239 RSA *rsa; 240 int ret; 241 242 *rsap = NULL; 243 244 engine_id = ENGINE_get_id(engine); 245 246 if (engine_id && !strcmp(engine_id, "pkcs11")) { 247 if (keydir) 248 snprintf(key_id, sizeof(key_id), 249 "pkcs11:%s;object=%s;type=private", 250 keydir, name); 251 else 252 snprintf(key_id, sizeof(key_id), 253 "pkcs11:object=%s;type=private", 254 name); 255 } else { 256 fprintf(stderr, "Engine not supported\n"); 257 return -ENOTSUP; 258 } 259 260 key = ENGINE_load_private_key(engine, key_id, NULL, NULL); 261 if (!key) 262 return rsa_err("Failure loading private key from engine"); 263 264 /* Convert to a RSA_style key. */ 265 rsa = EVP_PKEY_get1_RSA(key); 266 if (!rsa) { 267 rsa_err("Couldn't convert to a RSA style key"); 268 ret = -EINVAL; 269 goto err_rsa; 270 } 271 272 EVP_PKEY_free(key); 273 *rsap = rsa; 274 275 return 0; 276 277 err_rsa: 278 EVP_PKEY_free(key); 279 return ret; 280 } 281 282 /** 283 * rsa_get_priv_key() - read a private key 284 * 285 * @keydir: Directory containing the key (PEM file) or key prefix (engine) 286 * @name Name of key 287 * @engine Engine to use for signing 288 * @rsap Returns RSA object, or NULL on failure 289 * @return 0 if ok, -ve on error (in which case *rsap will be set to NULL) 290 */ 291 static int rsa_get_priv_key(const char *keydir, const char *name, 292 ENGINE *engine, RSA **rsap) 293 { 294 if (engine) 295 return rsa_engine_get_priv_key(keydir, name, engine, rsap); 296 return rsa_pem_get_priv_key(keydir, name, rsap); 297 } 298 299 static int rsa_init(void) 300 { 301 int ret; 302 303 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \ 304 (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x02070000fL) 305 ret = SSL_library_init(); 306 #else 307 ret = OPENSSL_init_ssl(0, NULL); 308 #endif 309 if (!ret) { 310 fprintf(stderr, "Failure to init SSL library\n"); 311 return -1; 312 } 313 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \ 314 (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x02070000fL) 315 SSL_load_error_strings(); 316 317 OpenSSL_add_all_algorithms(); 318 OpenSSL_add_all_digests(); 319 OpenSSL_add_all_ciphers(); 320 #endif 321 322 return 0; 323 } 324 325 static int rsa_engine_init(const char *engine_id, ENGINE **pe) 326 { 327 ENGINE *e; 328 int ret; 329 330 ENGINE_load_builtin_engines(); 331 332 e = ENGINE_by_id(engine_id); 333 if (!e) { 334 fprintf(stderr, "Engine isn't available\n"); 335 ret = -1; 336 goto err_engine_by_id; 337 } 338 339 if (!ENGINE_init(e)) { 340 fprintf(stderr, "Couldn't initialize engine\n"); 341 ret = -1; 342 goto err_engine_init; 343 } 344 345 if (!ENGINE_set_default_RSA(e)) { 346 fprintf(stderr, "Couldn't set engine as default for RSA\n"); 347 ret = -1; 348 goto err_set_rsa; 349 } 350 351 *pe = e; 352 353 return 0; 354 355 err_set_rsa: 356 ENGINE_finish(e); 357 err_engine_init: 358 ENGINE_free(e); 359 err_engine_by_id: 360 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \ 361 (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x02070000fL) 362 ENGINE_cleanup(); 363 #endif 364 return ret; 365 } 366 367 static void rsa_remove(void) 368 { 369 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \ 370 (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x02070000fL) 371 CRYPTO_cleanup_all_ex_data(); 372 ERR_free_strings(); 373 #ifdef HAVE_ERR_REMOVE_THREAD_STATE 374 ERR_remove_thread_state(NULL); 375 #else 376 ERR_remove_state(0); 377 #endif 378 EVP_cleanup(); 379 #endif 380 } 381 382 static void rsa_engine_remove(ENGINE *e) 383 { 384 if (e) { 385 ENGINE_finish(e); 386 ENGINE_free(e); 387 } 388 } 389 390 static int rsa_sign_with_key(RSA *rsa, struct padding_algo *padding_algo, 391 struct checksum_algo *checksum_algo, 392 const struct image_region region[], int region_count, 393 uint8_t **sigp, uint *sig_size) 394 { 395 EVP_PKEY *key; 396 EVP_PKEY_CTX *ckey; 397 EVP_MD_CTX *context; 398 int ret = 0; 399 size_t size; 400 uint8_t *sig; 401 int i; 402 403 key = EVP_PKEY_new(); 404 if (!key) 405 return rsa_err("EVP_PKEY object creation failed"); 406 407 if (!EVP_PKEY_set1_RSA(key, rsa)) { 408 ret = rsa_err("EVP key setup failed"); 409 goto err_set; 410 } 411 412 size = EVP_PKEY_size(key); 413 sig = malloc(size); 414 if (!sig) { 415 fprintf(stderr, "Out of memory for signature (%zu bytes)\n", 416 size); 417 ret = -ENOMEM; 418 goto err_alloc; 419 } 420 421 context = EVP_MD_CTX_create(); 422 if (!context) { 423 ret = rsa_err("EVP context creation failed"); 424 goto err_create; 425 } 426 EVP_MD_CTX_init(context); 427 428 ckey = EVP_PKEY_CTX_new(key, NULL); 429 if (!ckey) { 430 ret = rsa_err("EVP key context creation failed"); 431 goto err_create; 432 } 433 434 if (EVP_DigestSignInit(context, &ckey, 435 checksum_algo->calculate_sign(), 436 NULL, key) <= 0) { 437 ret = rsa_err("Signer setup failed"); 438 goto err_sign; 439 } 440 441 #ifdef CONFIG_FIT_ENABLE_RSASSA_PSS_SUPPORT 442 if (padding_algo && !strcmp(padding_algo->name, "pss")) { 443 if (EVP_PKEY_CTX_set_rsa_padding(ckey, 444 RSA_PKCS1_PSS_PADDING) <= 0) { 445 ret = rsa_err("Signer padding setup failed"); 446 goto err_sign; 447 } 448 } 449 #endif /* CONFIG_FIT_ENABLE_RSASSA_PSS_SUPPORT */ 450 451 for (i = 0; i < region_count; i++) { 452 if (!EVP_DigestSignUpdate(context, region[i].data, 453 region[i].size)) { 454 ret = rsa_err("Signing data failed"); 455 goto err_sign; 456 } 457 } 458 459 if (!EVP_DigestSignFinal(context, sig, &size)) { 460 ret = rsa_err("Could not obtain signature"); 461 goto err_sign; 462 } 463 464 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \ 465 (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x02070000fL) 466 EVP_MD_CTX_cleanup(context); 467 #else 468 EVP_MD_CTX_reset(context); 469 #endif 470 EVP_MD_CTX_destroy(context); 471 EVP_PKEY_free(key); 472 473 debug("Got signature: %d bytes, expected %zu\n", *sig_size, size); 474 *sigp = sig; 475 *sig_size = size; 476 477 return 0; 478 479 err_sign: 480 EVP_MD_CTX_destroy(context); 481 err_create: 482 free(sig); 483 err_alloc: 484 err_set: 485 EVP_PKEY_free(key); 486 return ret; 487 } 488 489 int rsa_sign(struct image_sign_info *info, 490 const struct image_region region[], int region_count, 491 uint8_t **sigp, uint *sig_len) 492 { 493 RSA *rsa; 494 ENGINE *e = NULL; 495 int ret; 496 497 ret = rsa_init(); 498 if (ret) 499 return ret; 500 501 if (info->engine_id) { 502 ret = rsa_engine_init(info->engine_id, &e); 503 if (ret) 504 goto err_engine; 505 } 506 507 ret = rsa_get_priv_key(info->keydir, info->keyname, e, &rsa); 508 if (ret) 509 goto err_priv; 510 ret = rsa_sign_with_key(rsa, info->padding, info->checksum, region, 511 region_count, sigp, sig_len); 512 if (ret) 513 goto err_sign; 514 515 RSA_free(rsa); 516 if (info->engine_id) 517 rsa_engine_remove(e); 518 rsa_remove(); 519 520 return ret; 521 522 err_sign: 523 RSA_free(rsa); 524 err_priv: 525 if (info->engine_id) 526 rsa_engine_remove(e); 527 err_engine: 528 rsa_remove(); 529 return ret; 530 } 531 532 /* 533 * rsa_get_exponent(): - Get the public exponent from an RSA key 534 */ 535 static int rsa_get_exponent(RSA *key, uint64_t *e) 536 { 537 int ret; 538 BIGNUM *bn_te; 539 const BIGNUM *key_e; 540 uint64_t te; 541 542 ret = -EINVAL; 543 bn_te = NULL; 544 545 if (!e) 546 goto cleanup; 547 548 RSA_get0_key(key, NULL, &key_e, NULL); 549 if (BN_num_bits(key_e) > 64) 550 goto cleanup; 551 552 *e = BN_get_word(key_e); 553 554 if (BN_num_bits(key_e) < 33) { 555 ret = 0; 556 goto cleanup; 557 } 558 559 bn_te = BN_dup(key_e); 560 if (!bn_te) 561 goto cleanup; 562 563 if (!BN_rshift(bn_te, bn_te, 32)) 564 goto cleanup; 565 566 if (!BN_mask_bits(bn_te, 32)) 567 goto cleanup; 568 569 te = BN_get_word(bn_te); 570 te <<= 32; 571 *e |= te; 572 ret = 0; 573 574 cleanup: 575 if (bn_te) 576 BN_free(bn_te); 577 578 return ret; 579 } 580 581 /* 582 * rsa_get_params(): - Get the important parameters of an RSA public key 583 */ 584 int rsa_get_params(RSA *key, uint64_t *exponent, uint32_t *n0_invp, 585 BIGNUM **modulusp, BIGNUM **r_squaredp) 586 { 587 BIGNUM *big1, *big2, *big32, *big2_32; 588 BIGNUM *n, *r, *r_squared, *tmp; 589 const BIGNUM *key_n; 590 BN_CTX *bn_ctx = BN_CTX_new(); 591 int ret = 0; 592 593 /* Initialize BIGNUMs */ 594 big1 = BN_new(); 595 big2 = BN_new(); 596 big32 = BN_new(); 597 r = BN_new(); 598 r_squared = BN_new(); 599 tmp = BN_new(); 600 big2_32 = BN_new(); 601 n = BN_new(); 602 if (!big1 || !big2 || !big32 || !r || !r_squared || !tmp || !big2_32 || 603 !n) { 604 fprintf(stderr, "Out of memory (bignum)\n"); 605 return -ENOMEM; 606 } 607 608 if (0 != rsa_get_exponent(key, exponent)) 609 ret = -1; 610 611 RSA_get0_key(key, &key_n, NULL, NULL); 612 if (!BN_copy(n, key_n) || !BN_set_word(big1, 1L) || 613 !BN_set_word(big2, 2L) || !BN_set_word(big32, 32L)) 614 ret = -1; 615 616 /* big2_32 = 2^32 */ 617 if (!BN_exp(big2_32, big2, big32, bn_ctx)) 618 ret = -1; 619 620 /* Calculate n0_inv = -1 / n[0] mod 2^32 */ 621 if (!BN_mod_inverse(tmp, n, big2_32, bn_ctx) || 622 !BN_sub(tmp, big2_32, tmp)) 623 ret = -1; 624 *n0_invp = BN_get_word(tmp); 625 626 /* Calculate R = 2^(# of key bits) */ 627 if (!BN_set_word(tmp, BN_num_bits(n)) || 628 !BN_exp(r, big2, tmp, bn_ctx)) 629 ret = -1; 630 631 /* Calculate r_squared = R^2 mod n */ 632 if (!BN_copy(r_squared, r) || 633 !BN_mul(tmp, r_squared, r, bn_ctx) || 634 !BN_mod(r_squared, tmp, n, bn_ctx)) 635 ret = -1; 636 637 *modulusp = n; 638 *r_squaredp = r_squared; 639 640 BN_free(big1); 641 BN_free(big2); 642 BN_free(big32); 643 BN_free(r); 644 BN_free(tmp); 645 BN_free(big2_32); 646 if (ret) { 647 fprintf(stderr, "Bignum operations failed\n"); 648 return -ENOMEM; 649 } 650 651 return ret; 652 } 653 654 static int fdt_add_bignum(void *blob, int noffset, const char *prop_name, 655 BIGNUM *num, int num_bits) 656 { 657 int nwords = num_bits / 32; 658 int size; 659 uint32_t *buf, *ptr; 660 BIGNUM *tmp, *big2, *big32, *big2_32; 661 BN_CTX *ctx; 662 int ret; 663 664 tmp = BN_new(); 665 big2 = BN_new(); 666 big32 = BN_new(); 667 big2_32 = BN_new(); 668 669 /* 670 * Note: This code assumes that all of the above succeed, or all fail. 671 * In practice memory allocations generally do not fail (unless the 672 * process is killed), so it does not seem worth handling each of these 673 * as a separate case. Technicaly this could leak memory on failure, 674 * but a) it won't happen in practice, and b) it doesn't matter as we 675 * will immediately exit with a failure code. 676 */ 677 if (!tmp || !big2 || !big32 || !big2_32) { 678 fprintf(stderr, "Out of memory (bignum)\n"); 679 return -ENOMEM; 680 } 681 ctx = BN_CTX_new(); 682 if (!tmp) { 683 fprintf(stderr, "Out of memory (bignum context)\n"); 684 return -ENOMEM; 685 } 686 BN_set_word(big2, 2L); 687 BN_set_word(big32, 32L); 688 BN_exp(big2_32, big2, big32, ctx); /* B = 2^32 */ 689 690 size = nwords * sizeof(uint32_t); 691 buf = malloc(size); 692 if (!buf) { 693 fprintf(stderr, "Out of memory (%d bytes)\n", size); 694 return -ENOMEM; 695 } 696 697 /* Write out modulus as big endian array of integers */ 698 for (ptr = buf + nwords - 1; ptr >= buf; ptr--) { 699 BN_mod(tmp, num, big2_32, ctx); /* n = N mod B */ 700 *ptr = cpu_to_fdt32(BN_get_word(tmp)); 701 BN_rshift(num, num, 32); /* N = N/B */ 702 } 703 704 /* 705 * We try signing with successively increasing size values, so this 706 * might fail several times 707 */ 708 ret = fdt_setprop(blob, noffset, prop_name, buf, size); 709 free(buf); 710 BN_free(tmp); 711 BN_free(big2); 712 BN_free(big32); 713 BN_free(big2_32); 714 715 return ret ? -FDT_ERR_NOSPACE : 0; 716 } 717 718 int rsa_add_verify_data(struct image_sign_info *info, void *keydest) 719 { 720 BIGNUM *modulus, *r_squared; 721 uint64_t exponent; 722 uint32_t n0_inv; 723 int parent, node; 724 char name[100]; 725 int ret; 726 int bits; 727 RSA *rsa; 728 ENGINE *e = NULL; 729 730 debug("%s: Getting verification data\n", __func__); 731 if (info->engine_id) { 732 ret = rsa_engine_init(info->engine_id, &e); 733 if (ret) 734 return ret; 735 } 736 ret = rsa_get_pub_key(info->keydir, info->keyname, e, &rsa); 737 if (ret) 738 goto err_get_pub_key; 739 ret = rsa_get_params(rsa, &exponent, &n0_inv, &modulus, &r_squared); 740 if (ret) 741 goto err_get_params; 742 bits = BN_num_bits(modulus); 743 parent = fdt_subnode_offset(keydest, 0, FIT_SIG_NODENAME); 744 if (parent == -FDT_ERR_NOTFOUND) { 745 parent = fdt_add_subnode(keydest, 0, FIT_SIG_NODENAME); 746 if (parent < 0) { 747 ret = parent; 748 if (ret != -FDT_ERR_NOSPACE) { 749 fprintf(stderr, "Couldn't create signature node: %s\n", 750 fdt_strerror(parent)); 751 } 752 } 753 } 754 if (ret) 755 goto done; 756 757 /* Either create or overwrite the named key node */ 758 snprintf(name, sizeof(name), "key-%s", info->keyname); 759 node = fdt_subnode_offset(keydest, parent, name); 760 if (node == -FDT_ERR_NOTFOUND) { 761 node = fdt_add_subnode(keydest, parent, name); 762 if (node < 0) { 763 ret = node; 764 if (ret != -FDT_ERR_NOSPACE) { 765 fprintf(stderr, "Could not create key subnode: %s\n", 766 fdt_strerror(node)); 767 } 768 } 769 } else if (node < 0) { 770 fprintf(stderr, "Cannot select keys parent: %s\n", 771 fdt_strerror(node)); 772 ret = node; 773 } 774 775 if (!ret) { 776 ret = fdt_setprop_string(keydest, node, "key-name-hint", 777 info->keyname); 778 } 779 if (!ret) 780 ret = fdt_setprop_u32(keydest, node, "rsa,num-bits", bits); 781 if (!ret) 782 ret = fdt_setprop_u32(keydest, node, "rsa,n0-inverse", n0_inv); 783 if (!ret) { 784 ret = fdt_setprop_u64(keydest, node, "rsa,exponent", exponent); 785 } 786 if (!ret) { 787 ret = fdt_add_bignum(keydest, node, "rsa,modulus", modulus, 788 bits); 789 } 790 if (!ret) { 791 ret = fdt_add_bignum(keydest, node, "rsa,r-squared", r_squared, 792 bits); 793 } 794 if (!ret) { 795 ret = fdt_setprop_string(keydest, node, FIT_ALGO_PROP, 796 info->name); 797 } 798 if (!ret && info->require_keys) { 799 ret = fdt_setprop_string(keydest, node, "required", 800 info->require_keys); 801 } 802 done: 803 BN_free(modulus); 804 BN_free(r_squared); 805 if (ret) 806 ret = ret == -FDT_ERR_NOSPACE ? -ENOSPC : -EIO; 807 err_get_params: 808 RSA_free(rsa); 809 err_get_pub_key: 810 if (info->engine_id) 811 rsa_engine_remove(e); 812 813 return ret; 814 } 815