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