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