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 (name)
 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         const char *key_pass;
 342         ENGINE *e;
 343         int ret;
 344
 345         ENGINE_load_builtin_engines();
 346
 347         e = ENGINE_by_id(engine_id);
 348         if (!e) {
 349                 fprintf(stderr, "Engine isn't available\n");
 350                 ret = -1;
 351                 goto err_engine_by_id;
 352         }
 353
 354         if (!ENGINE_init(e)) {
 355                 fprintf(stderr, "Couldn't initialize engine\n");
 356                 ret = -1;
 357                 goto err_engine_init;
 358         }
 359
 360         if (!ENGINE_set_default_RSA(e)) {
 361                 fprintf(stderr, "Couldn't set engine as default for RSA\n");
 362                 ret = -1;
 363                 goto err_set_rsa;
 364         }
 365
 366         key_pass = getenv("MKIMAGE_SIGN_PIN");
 367         if (key_pass) {
 368                 if (!ENGINE_ctrl_cmd_string(e, "PIN", key_pass, 0)) {
 369                         fprintf(stderr, "Couldn't set PIN\n");
 370                         ret = -1;
 371                         goto err_set_pin;
 372                 }
 373         }
 374
 375         *pe = e;
 376
 377         return 0;
 378
 379 err_set_pin:
 380 err_set_rsa:
 381         ENGINE_finish(e);
 382 err_engine_init:
 383         ENGINE_free(e);
 384 err_engine_by_id:
 385 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \
 386         (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x02070000fL)
 387         ENGINE_cleanup();
 388 #endif
 389         return ret;
 390 }
 391
 392 static void rsa_remove(void)
 393 {
 394 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \
 395         (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x02070000fL)
 396         CRYPTO_cleanup_all_ex_data();
 397         ERR_free_strings();
 398 #ifdef HAVE_ERR_REMOVE_THREAD_STATE
 399         ERR_remove_thread_state(NULL);
 400 #else
 401         ERR_remove_state(0);
 402 #endif
 403         EVP_cleanup();
 404 #endif
 405 }
 406
 407 static void rsa_engine_remove(ENGINE *e)
 408 {
 409         if (e) {
 410                 ENGINE_finish(e);
 411                 ENGINE_free(e);
 412         }
 413 }
 414
 415 static int rsa_sign_with_key(EVP_PKEY *pkey, struct padding_algo *padding_algo,
 416                              struct checksum_algo *checksum_algo,
 417                 const struct image_region region[], int region_count,
 418                 uint8_t **sigp, uint *sig_size)
 419 {
 420         EVP_PKEY_CTX *ckey;
 421         EVP_MD_CTX *context;
 422         int ret = 0;
 423         size_t size;
 424         uint8_t *sig;
 425         int i;
 426
 427         size = EVP_PKEY_size(pkey);
 428         sig = malloc(size);
 429         if (!sig) {
 430                 fprintf(stderr, "Out of memory for signature (%zu bytes)\n",
 431                         size);
 432                 ret = -ENOMEM;
 433                 goto err_alloc;
 434         }
 435
 436         context = EVP_MD_CTX_create();
 437         if (!context) {
 438                 ret = rsa_err("EVP context creation failed");
 439                 goto err_create;
 440         }
 441         EVP_MD_CTX_init(context);
 442
 443         ckey = EVP_PKEY_CTX_new(pkey, NULL);
 444         if (!ckey) {
 445                 ret = rsa_err("EVP key context creation failed");
 446                 goto err_create;
 447         }
 448
 449         if (EVP_DigestSignInit(context, &ckey,
 450                                checksum_algo->calculate_sign(),
 451                                NULL, pkey) <= 0) {
 452                 ret = rsa_err("Signer setup failed");
 453                 goto err_sign;
 454         }
 455
 456 #ifdef CONFIG_FIT_RSASSA_PSS
 457         if (padding_algo && !strcmp(padding_algo->name, "pss")) {
 458                 if (EVP_PKEY_CTX_set_rsa_padding(ckey,
 459                                                  RSA_PKCS1_PSS_PADDING) <= 0) {
 460                         ret = rsa_err("Signer padding setup failed");
 461                         goto err_sign;
 462                 }
 463         }
 464 #endif /* CONFIG_FIT_RSASSA_PSS */
 465
 466         for (i = 0; i < region_count; i++) {
 467                 if (!EVP_DigestSignUpdate(context, region[i].data,
 468                                           region[i].size)) {
 469                         ret = rsa_err("Signing data failed");
 470                         goto err_sign;
 471                 }
 472         }
 473
 474         if (!EVP_DigestSignFinal(context, sig, &size)) {
 475                 ret = rsa_err("Could not obtain signature");
 476                 goto err_sign;
 477         }
 478
 479         #if OPENSSL_VERSION_NUMBER < 0x10100000L || \
 480                 (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x02070000fL)
 481                 EVP_MD_CTX_cleanup(context);
 482         #else
 483                 EVP_MD_CTX_reset(context);
 484         #endif
 485         EVP_MD_CTX_destroy(context);
 486
 487         debug("Got signature: %zu bytes, expected %d\n", size, EVP_PKEY_size(pkey));
 488         *sigp = sig;
 489         *sig_size = size;
 490
 491         return 0;
 492
 493 err_sign:
 494         EVP_MD_CTX_destroy(context);
 495 err_create:
 496         free(sig);
 497 err_alloc:
 498         return ret;
 499 }
 500
 501 int rsa_sign(struct image_sign_info *info,
 502              const struct image_region region[], int region_count,
 503              uint8_t **sigp, uint *sig_len)
 504 {
 505         EVP_PKEY *pkey = NULL;
 506         ENGINE *e = NULL;
 507         int ret;
 508
 509         ret = rsa_init();
 510         if (ret)
 511                 return ret;
 512
 513         if (info->engine_id) {
 514                 ret = rsa_engine_init(info->engine_id, &e);
 515                 if (ret)
 516                         goto err_engine;
 517         }
 518
 519         ret = rsa_get_priv_key(info->keydir, info->keyname, info->keyfile,
 520                                e, &pkey);
 521         if (ret)
 522                 goto err_priv;
 523         ret = rsa_sign_with_key(pkey, info->padding, info->checksum, region,
 524                                 region_count, sigp, sig_len);
 525         if (ret)
 526                 goto err_sign;
 527
 528         EVP_PKEY_free(pkey);
 529         if (info->engine_id)
 530                 rsa_engine_remove(e);
 531         rsa_remove();
 532
 533         return ret;
 534
 535 err_sign:
 536         EVP_PKEY_free(pkey);
 537 err_priv:
 538         if (info->engine_id)
 539                 rsa_engine_remove(e);
 540 err_engine:
 541         rsa_remove();
 542         return ret;
 543 }
 544
 545 /*
 546  * rsa_get_exponent(): - Get the public exponent from an RSA key
 547  */
 548 static int rsa_get_exponent(RSA *key, uint64_t *e)
 549 {
 550         int ret;
 551         BIGNUM *bn_te;
 552         const BIGNUM *key_e;
 553         uint64_t te;
 554
 555         ret = -EINVAL;
 556         bn_te = NULL;
 557
 558         if (!e)
 559                 goto cleanup;
 560
 561         RSA_get0_key(key, NULL, &key_e, NULL);
 562         if (BN_num_bits(key_e) > 64)
 563                 goto cleanup;
 564
 565         *e = BN_get_word(key_e);
 566
 567         if (BN_num_bits(key_e) < 33) {
 568                 ret = 0;
 569                 goto cleanup;
 570         }
 571
 572         bn_te = BN_dup(key_e);
 573         if (!bn_te)
 574                 goto cleanup;
 575
 576         if (!BN_rshift(bn_te, bn_te, 32))
 577                 goto cleanup;
 578
 579         if (!BN_mask_bits(bn_te, 32))
 580                 goto cleanup;
 581
 582         te = BN_get_word(bn_te);
 583         te <<= 32;
 584         *e |= te;
 585         ret = 0;
 586
 587 cleanup:
 588         if (bn_te)
 589                 BN_free(bn_te);
 590
 591         return ret;
 592 }
 593
 594 /*
 595  * rsa_get_params(): - Get the important parameters of an RSA public key
 596  */
 597 int rsa_get_params(RSA *key, uint64_t *exponent, uint32_t *n0_invp,
 598                    BIGNUM **modulusp, BIGNUM **r_squaredp)
 599 {
 600         BIGNUM *big1, *big2, *big32, *big2_32;
 601         BIGNUM *n, *r, *r_squared, *tmp;
 602         const BIGNUM *key_n;
 603         BN_CTX *bn_ctx = BN_CTX_new();
 604         int ret = 0;
 605
 606         /* Initialize BIGNUMs */
 607         big1 = BN_new();
 608         big2 = BN_new();
 609         big32 = BN_new();
 610         r = BN_new();
 611         r_squared = BN_new();
 612         tmp = BN_new();
 613         big2_32 = BN_new();
 614         n = BN_new();
 615         if (!big1 || !big2 || !big32 || !r || !r_squared || !tmp || !big2_32 ||
 616             !n) {
 617                 fprintf(stderr, "Out of memory (bignum)\n");
 618                 return -ENOMEM;
 619         }
 620
 621         if (0 != rsa_get_exponent(key, exponent))
 622                 ret = -1;
 623
 624         RSA_get0_key(key, &key_n, NULL, NULL);
 625         if (!BN_copy(n, key_n) || !BN_set_word(big1, 1L) ||
 626             !BN_set_word(big2, 2L) || !BN_set_word(big32, 32L))
 627                 ret = -1;
 628
 629         /* big2_32 = 2^32 */
 630         if (!BN_exp(big2_32, big2, big32, bn_ctx))
 631                 ret = -1;
 632
 633         /* Calculate n0_inv = -1 / n[0] mod 2^32 */
 634         if (!BN_mod_inverse(tmp, n, big2_32, bn_ctx) ||
 635             !BN_sub(tmp, big2_32, tmp))
 636                 ret = -1;
 637         *n0_invp = BN_get_word(tmp);
 638
 639         /* Calculate R = 2^(# of key bits) */
 640         if (!BN_set_word(tmp, BN_num_bits(n)) ||
 641             !BN_exp(r, big2, tmp, bn_ctx))
 642                 ret = -1;
 643
 644         /* Calculate r_squared = R^2 mod n */
 645         if (!BN_copy(r_squared, r) ||
 646             !BN_mul(tmp, r_squared, r, bn_ctx) ||
 647             !BN_mod(r_squared, tmp, n, bn_ctx))
 648                 ret = -1;
 649
 650         *modulusp = n;
 651         *r_squaredp = r_squared;
 652
 653         BN_free(big1);
 654         BN_free(big2);
 655         BN_free(big32);
 656         BN_free(r);
 657         BN_free(tmp);
 658         BN_free(big2_32);
 659         if (ret) {
 660                 fprintf(stderr, "Bignum operations failed\n");
 661                 return -ENOMEM;
 662         }
 663
 664         return ret;
 665 }
 666
 667 int rsa_add_verify_data(struct image_sign_info *info, void *keydest)
 668 {
 669         BIGNUM *modulus, *r_squared;
 670         uint64_t exponent;
 671         uint32_t n0_inv;
 672         int parent, node;
 673         char name[100];
 674         int ret;
 675         int bits;
 676         RSA *rsa;
 677         EVP_PKEY *pkey = NULL;
 678         ENGINE *e = NULL;
 679
 680         debug("%s: Getting verification data\n", __func__);
 681         if (info->engine_id) {
 682                 ret = rsa_engine_init(info->engine_id, &e);
 683                 if (ret)
 684                         return ret;
 685         }
 686         ret = rsa_get_pub_key(info->keydir, info->keyname, e, &pkey);
 687         if (ret)
 688                 goto err_get_pub_key;
 689 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \
 690         (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x02070000fL)
 691         rsa = EVP_PKEY_get1_RSA(pkey);
 692 #else
 693         rsa = EVP_PKEY_get0_RSA(pkey);
 694 #endif
 695         ret = rsa_get_params(rsa, &exponent, &n0_inv, &modulus, &r_squared);
 696         if (ret)
 697                 goto err_get_params;
 698         bits = BN_num_bits(modulus);
 699         parent = fdt_subnode_offset(keydest, 0, FIT_SIG_NODENAME);
 700         if (parent == -FDT_ERR_NOTFOUND) {
 701                 parent = fdt_add_subnode(keydest, 0, FIT_SIG_NODENAME);
 702                 if (parent < 0) {
 703                         ret = parent;
 704                         if (ret != -FDT_ERR_NOSPACE) {
 705                                 fprintf(stderr, "Couldn't create signature node: %s\n",
 706                                         fdt_strerror(parent));
 707                         }
 708                 }
 709         }
 710         if (ret)
 711                 goto done;
 712
 713         /* Either create or overwrite the named key node */
 714         snprintf(name, sizeof(name), "key-%s", info->keyname);
 715         node = fdt_subnode_offset(keydest, parent, name);
 716         if (node == -FDT_ERR_NOTFOUND) {
 717                 node = fdt_add_subnode(keydest, parent, name);
 718                 if (node < 0) {
 719                         ret = node;
 720                         if (ret != -FDT_ERR_NOSPACE) {
 721                                 fprintf(stderr, "Could not create key subnode: %s\n",
 722                                         fdt_strerror(node));
 723                         }
 724                 }
 725         } else if (node < 0) {
 726                 fprintf(stderr, "Cannot select keys parent: %s\n",
 727                         fdt_strerror(node));
 728                 ret = node;
 729         }
 730
 731         if (!ret) {
 732                 ret = fdt_setprop_string(keydest, node, FIT_KEY_HINT,
 733                                          info->keyname);
 734         }
 735         if (!ret)
 736                 ret = fdt_setprop_u32(keydest, node, "rsa,num-bits", bits);
 737         if (!ret)
 738                 ret = fdt_setprop_u32(keydest, node, "rsa,n0-inverse", n0_inv);
 739         if (!ret) {
 740                 ret = fdt_setprop_u64(keydest, node, "rsa,exponent", exponent);
 741         }
 742         if (!ret) {
 743                 ret = fdt_add_bignum(keydest, node, "rsa,modulus", modulus,
 744                                      bits);
 745         }
 746         if (!ret) {
 747                 ret = fdt_add_bignum(keydest, node, "rsa,r-squared", r_squared,
 748                                      bits);
 749         }
 750         if (!ret) {
 751                 ret = fdt_setprop_string(keydest, node, FIT_ALGO_PROP,
 752                                          info->name);
 753         }
 754         if (!ret && info->require_keys) {
 755                 ret = fdt_setprop_string(keydest, node, FIT_KEY_REQUIRED,
 756                                          info->require_keys);
 757         }
 758 done:
 759         BN_free(modulus);
 760         BN_free(r_squared);
 761         if (ret)
 762                 ret = ret == -FDT_ERR_NOSPACE ? -ENOSPC : -EIO;
 763 err_get_params:
 764 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \
 765         (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x02070000fL)
 766         RSA_free(rsa);
 767 #endif
 768         EVP_PKEY_free(pkey);
 769 err_get_pub_key:
 770         if (info->engine_id)
 771                 rsa_engine_remove(e);
 772
 773         return ret;
 774 }