1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (c) 2013, Google Inc.
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>
22 static int rsa_err(const char *msg)
24 unsigned long sslErr = ERR_get_error();
26 fprintf(stderr, "%s", msg);
27 fprintf(stderr, ": %s\n",
28 ERR_error_string(sslErr, 0));
34 * rsa_pem_get_pub_key() - read a public key from a .crt file
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)
41 static int rsa_pem_get_pub_key(const char *keydir, const char *name, EVP_PKEY **evpp)
53 snprintf(path, sizeof(path), "%s/%s.crt", keydir, name);
56 fprintf(stderr, "Couldn't open RSA certificate: '%s': %s\n",
57 path, strerror(errno));
61 /* Read the certificate */
63 if (!PEM_read_X509(f, &cert, NULL, NULL)) {
64 rsa_err("Couldn't read certificate");
69 /* Get the public key from the certificate. */
70 key = X509_get_pubkey(cert);
72 rsa_err("Couldn't read public key\n");
91 * rsa_engine_get_pub_key() - read a public key from given engine
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)
99 static int rsa_engine_get_pub_key(const char *keydir, const char *name,
100 ENGINE *engine, EVP_PKEY **evpp)
102 const char *engine_id;
104 EVP_PKEY *key = NULL;
111 engine_id = ENGINE_get_id(engine);
113 if (engine_id && !strcmp(engine_id, "pkcs11")) {
115 if (strstr(keydir, "object="))
116 snprintf(key_id, sizeof(key_id),
117 "pkcs11:%s;type=public",
120 snprintf(key_id, sizeof(key_id),
121 "pkcs11:%s;object=%s;type=public",
124 snprintf(key_id, sizeof(key_id),
125 "pkcs11:object=%s;type=public",
127 } else if (engine_id) {
129 snprintf(key_id, sizeof(key_id),
133 snprintf(key_id, sizeof(key_id),
137 fprintf(stderr, "Engine not supported\n");
141 key = ENGINE_load_public_key(engine, key_id, NULL, NULL);
143 return rsa_err("Failure loading public key from engine");
151 * rsa_get_pub_key() - read a public key
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)
159 static int rsa_get_pub_key(const char *keydir, const char *name,
160 ENGINE *engine, EVP_PKEY **evpp)
163 return rsa_engine_get_pub_key(keydir, name, engine, evpp);
164 return rsa_pem_get_pub_key(keydir, name, evpp);
168 * rsa_pem_get_priv_key() - read a private key from a .key file
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)
175 static int rsa_pem_get_priv_key(const char *keydir, const char *name,
176 const char *keyfile, EVP_PKEY **evpp)
178 char path[1024] = {0};
186 snprintf(path, sizeof(path), "%s/%s.key", keydir, name);
188 snprintf(path, sizeof(path), "%s", keyfile);
192 f = fopen(path, "r");
194 fprintf(stderr, "Couldn't open RSA private key: '%s': %s\n",
195 path, strerror(errno));
199 if (!PEM_read_PrivateKey(f, evpp, NULL, path)) {
200 rsa_err("Failure reading private key");
210 * rsa_engine_get_priv_key() - read a private key from given engine
212 * @keydir: Key prefix
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)
218 static int rsa_engine_get_priv_key(const char *keydir, const char *name,
220 ENGINE *engine, EVP_PKEY **evpp)
222 const char *engine_id;
224 EVP_PKEY *key = NULL;
229 engine_id = ENGINE_get_id(engine);
231 if (engine_id && !strcmp(engine_id, "pkcs11")) {
232 if (!keydir && !name) {
233 fprintf(stderr, "Please use 'keydir' with PKCS11\n");
237 if (strstr(keydir, "object="))
238 snprintf(key_id, sizeof(key_id),
239 "pkcs11:%s;type=private",
242 snprintf(key_id, sizeof(key_id),
243 "pkcs11:%s;object=%s;type=private",
246 snprintf(key_id, sizeof(key_id),
247 "pkcs11:object=%s;type=private",
249 } else if (engine_id) {
251 snprintf(key_id, sizeof(key_id),
255 snprintf(key_id, sizeof(key_id),
259 snprintf(key_id, sizeof(key_id), "%s", keyfile);
264 fprintf(stderr, "Engine not supported\n");
268 key = ENGINE_load_private_key(engine, key_id, NULL, NULL);
270 return rsa_err("Failure loading private key from engine");
278 * rsa_get_priv_key() - read a private key
280 * @keydir: Directory containing the key (PEM file) or key prefix (engine)
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)
286 static int rsa_get_priv_key(const char *keydir, const char *name,
287 const char *keyfile, ENGINE *engine, EVP_PKEY **evpp)
290 return rsa_engine_get_priv_key(keydir, name, keyfile, engine,
292 return rsa_pem_get_priv_key(keydir, name, keyfile, evpp);
295 static int rsa_init(void)
299 ret = OPENSSL_init_ssl(0, NULL);
301 fprintf(stderr, "Failure to init SSL library\n");
308 static int rsa_engine_init(const char *engine_id, ENGINE **pe)
310 const char *key_pass;
314 ENGINE_load_builtin_engines();
316 e = ENGINE_by_id(engine_id);
318 fprintf(stderr, "Engine isn't available\n");
322 if (!ENGINE_init(e)) {
323 fprintf(stderr, "Couldn't initialize engine\n");
325 goto err_engine_init;
328 if (!ENGINE_set_default_RSA(e)) {
329 fprintf(stderr, "Couldn't set engine as default for RSA\n");
334 key_pass = getenv("MKIMAGE_SIGN_PIN");
336 if (!ENGINE_ctrl_cmd_string(e, "PIN", key_pass, 0)) {
337 fprintf(stderr, "Couldn't set PIN\n");
355 static void rsa_engine_remove(ENGINE *e)
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)
375 size = EVP_PKEY_size(pkey);
378 fprintf(stderr, "Out of memory for signature (%zu bytes)\n",
384 context = EVP_MD_CTX_create();
386 ret = rsa_err("EVP context creation failed");
389 EVP_MD_CTX_init(context);
391 ckey = EVP_PKEY_CTX_new(pkey, NULL);
393 ret = rsa_err("EVP key context creation failed");
397 if (EVP_DigestSignInit(context, &ckey,
398 checksum_algo->calculate_sign(),
400 ret = rsa_err("Signer setup failed");
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");
412 #endif /* CONFIG_FIT_RSASSA_PSS */
414 for (i = 0; i < region_count; i++) {
415 if (!EVP_DigestSignUpdate(context, region[i].data,
417 ret = rsa_err("Signing data failed");
422 if (!EVP_DigestSignFinal(context, sig, &size)) {
423 ret = rsa_err("Could not obtain signature");
427 EVP_MD_CTX_reset(context);
428 EVP_MD_CTX_destroy(context);
430 debug("Got signature: %zu bytes, expected %d\n", size, EVP_PKEY_size(pkey));
437 EVP_MD_CTX_destroy(context);
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)
448 EVP_PKEY *pkey = NULL;
456 if (info->engine_id) {
457 ret = rsa_engine_init(info->engine_id, &e);
462 ret = rsa_get_priv_key(info->keydir, info->keyname, info->keyfile,
466 ret = rsa_sign_with_key(pkey, info->padding, info->checksum, region,
467 region_count, sigp, sig_len);
473 rsa_engine_remove(e);
481 rsa_engine_remove(e);
486 * rsa_get_exponent(): - Get the public exponent from an RSA key
488 static int rsa_get_exponent(RSA *key, uint64_t *e)
501 RSA_get0_key(key, NULL, &key_e, NULL);
502 if (BN_num_bits(key_e) > 64)
505 *e = BN_get_word(key_e);
507 if (BN_num_bits(key_e) < 33) {
512 bn_te = BN_dup(key_e);
516 if (!BN_rshift(bn_te, bn_te, 32))
519 if (!BN_mask_bits(bn_te, 32))
522 te = BN_get_word(bn_te);
535 * rsa_get_params(): - Get the important parameters of an RSA public key
537 int rsa_get_params(RSA *key, uint64_t *exponent, uint32_t *n0_invp,
538 BIGNUM **modulusp, BIGNUM **r_squaredp)
540 BIGNUM *big1, *big2, *big32, *big2_32;
541 BIGNUM *n, *r, *r_squared, *tmp;
543 BN_CTX *bn_ctx = BN_CTX_new();
546 /* Initialize BIGNUMs */
551 r_squared = BN_new();
555 if (!big1 || !big2 || !big32 || !r || !r_squared || !tmp || !big2_32 ||
557 fprintf(stderr, "Out of memory (bignum)\n");
561 if (0 != rsa_get_exponent(key, exponent))
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))
570 if (!BN_exp(big2_32, big2, big32, bn_ctx))
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))
577 *n0_invp = BN_get_word(tmp);
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))
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))
591 *r_squaredp = r_squared;
600 fprintf(stderr, "Bignum operations failed\n");
607 int rsa_add_verify_data(struct image_sign_info *info, void *keydest)
609 BIGNUM *modulus, *r_squared;
617 EVP_PKEY *pkey = NULL;
620 debug("%s: Getting verification data\n", __func__);
621 if (info->engine_id) {
622 ret = rsa_engine_init(info->engine_id, &e);
626 ret = rsa_get_pub_key(info->keydir, info->keyname, e, &pkey);
628 goto err_get_pub_key;
630 rsa = EVP_PKEY_get0_RSA(pkey);
631 ret = rsa_get_params(rsa, &exponent, &n0_inv, &modulus, &r_squared);
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);
640 if (ret != -FDT_ERR_NOSPACE) {
641 fprintf(stderr, "Couldn't create signature node: %s\n",
642 fdt_strerror(parent));
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);
656 if (ret != -FDT_ERR_NOSPACE) {
657 fprintf(stderr, "Could not create key subnode: %s\n",
661 } else if (node < 0) {
662 fprintf(stderr, "Cannot select keys parent: %s\n",
668 ret = fdt_setprop_string(keydest, node, FIT_KEY_HINT,
672 ret = fdt_setprop_u32(keydest, node, "rsa,num-bits", bits);
674 ret = fdt_setprop_u32(keydest, node, "rsa,n0-inverse", n0_inv);
676 ret = fdt_setprop_u64(keydest, node, "rsa,exponent", exponent);
679 ret = fdt_add_bignum(keydest, node, "rsa,modulus", modulus,
683 ret = fdt_add_bignum(keydest, node, "rsa,r-squared", r_squared,
687 ret = fdt_setprop_string(keydest, node, FIT_ALGO_PROP,
690 if (!ret && info->require_keys) {
691 ret = fdt_setprop_string(keydest, node, FIT_KEY_REQUIRED,
698 ret = ret == -FDT_ERR_NOSPACE ? -ENOSPC : -EIO;
703 rsa_engine_remove(e);