lib/rsa/rsa-sign.c

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