blob: b2a21199e485b2d47b396422c85531f7e00d11c9 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glass19c402a2013-06-13 15:10:02 -07002/*
3 * Copyright (c) 2013, Google Inc.
Simon Glass19c402a2013-06-13 15:10:02 -07004 */
5
Heinrich Schuchardt3a8b9192021-12-18 11:25:12 +01006#define OPENSSL_API_COMPAT 0x10101000L
7
Simon Glass19c402a2013-06-13 15:10:02 -07008#include "mkimage.h"
Jonathan Gray0ff042d2020-05-15 22:20:34 +10009#include <stdlib.h>
Simon Glass19c402a2013-06-13 15:10:02 -070010#include <stdio.h>
11#include <string.h>
Simon Glass19c402a2013-06-13 15:10:02 -070012#include <image.h>
13#include <time.h>
Alexandru Gagniuc4c17e5f2021-02-19 12:45:11 -060014#include <u-boot/fdt-libcrypto.h>
Jelle van der Waac3b43282017-05-08 21:31:19 +020015#include <openssl/bn.h>
Chan, Donaldfbc77742021-04-01 22:42:36 +000016#include <openssl/ec.h>
Simon Glass19c402a2013-06-13 15:10:02 -070017#include <openssl/rsa.h>
18#include <openssl/pem.h>
19#include <openssl/err.h>
20#include <openssl/ssl.h>
21#include <openssl/evp.h>
George McCollisterf1ca1fd2017-01-06 13:14:17 -060022#include <openssl/engine.h>
Simon Glass19c402a2013-06-13 15:10:02 -070023
Simon Glass19c402a2013-06-13 15:10:02 -070024static int rsa_err(const char *msg)
25{
26 unsigned long sslErr = ERR_get_error();
27
28 fprintf(stderr, "%s", msg);
29 fprintf(stderr, ": %s\n",
30 ERR_error_string(sslErr, 0));
31
32 return -1;
33}
34
35/**
George McCollisterf1ca1fd2017-01-06 13:14:17 -060036 * rsa_pem_get_pub_key() - read a public key from a .crt file
Simon Glass19c402a2013-06-13 15:10:02 -070037 *
38 * @keydir: Directory containins the key
39 * @name Name of key file (will have a .crt extension)
Chan, Donaldfbc77742021-04-01 22:42:36 +000040 * @evpp Returns EVP_PKEY object, or NULL on failure
Heinrich Schuchardt185f8122022-01-19 18:05:50 +010041 * Return: 0 if ok, -ve on error (in which case *evpp will be set to NULL)
Simon Glass19c402a2013-06-13 15:10:02 -070042 */
Chan, Donaldfbc77742021-04-01 22:42:36 +000043static int rsa_pem_get_pub_key(const char *keydir, const char *name, EVP_PKEY **evpp)
Simon Glass19c402a2013-06-13 15:10:02 -070044{
45 char path[1024];
Chan, Donaldfbc77742021-04-01 22:42:36 +000046 EVP_PKEY *key = NULL;
Simon Glass19c402a2013-06-13 15:10:02 -070047 X509 *cert;
Simon Glass19c402a2013-06-13 15:10:02 -070048 FILE *f;
49 int ret;
50
Chan, Donaldfbc77742021-04-01 22:42:36 +000051 if (!evpp)
52 return -EINVAL;
53
54 *evpp = NULL;
Simon Glass19c402a2013-06-13 15:10:02 -070055 snprintf(path, sizeof(path), "%s/%s.crt", keydir, name);
56 f = fopen(path, "r");
57 if (!f) {
58 fprintf(stderr, "Couldn't open RSA certificate: '%s': %s\n",
59 path, strerror(errno));
60 return -EACCES;
61 }
62
63 /* Read the certificate */
64 cert = NULL;
65 if (!PEM_read_X509(f, &cert, NULL, NULL)) {
66 rsa_err("Couldn't read certificate");
67 ret = -EINVAL;
68 goto err_cert;
69 }
70
71 /* Get the public key from the certificate. */
72 key = X509_get_pubkey(cert);
73 if (!key) {
74 rsa_err("Couldn't read public key\n");
75 ret = -EINVAL;
76 goto err_pubkey;
77 }
78
Simon Glass19c402a2013-06-13 15:10:02 -070079 fclose(f);
Chan, Donaldfbc77742021-04-01 22:42:36 +000080 *evpp = key;
Simon Glass19c402a2013-06-13 15:10:02 -070081 X509_free(cert);
Simon Glass19c402a2013-06-13 15:10:02 -070082
83 return 0;
84
Simon Glass19c402a2013-06-13 15:10:02 -070085err_pubkey:
86 X509_free(cert);
87err_cert:
88 fclose(f);
89 return ret;
90}
91
92/**
George McCollisterf1ca1fd2017-01-06 13:14:17 -060093 * rsa_engine_get_pub_key() - read a public key from given engine
Simon Glass19c402a2013-06-13 15:10:02 -070094 *
George McCollisterf1ca1fd2017-01-06 13:14:17 -060095 * @keydir: Key prefix
96 * @name Name of key
97 * @engine Engine to use
Chan, Donaldfbc77742021-04-01 22:42:36 +000098 * @evpp Returns EVP_PKEY object, or NULL on failure
Heinrich Schuchardt185f8122022-01-19 18:05:50 +010099 * Return: 0 if ok, -ve on error (in which case *evpp will be set to NULL)
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600100 */
101static int rsa_engine_get_pub_key(const char *keydir, const char *name,
Chan, Donaldfbc77742021-04-01 22:42:36 +0000102 ENGINE *engine, EVP_PKEY **evpp)
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600103{
104 const char *engine_id;
105 char key_id[1024];
Chan, Donaldfbc77742021-04-01 22:42:36 +0000106 EVP_PKEY *key = NULL;
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600107
Chan, Donaldfbc77742021-04-01 22:42:36 +0000108 if (!evpp)
109 return -EINVAL;
110
111 *evpp = NULL;
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600112
113 engine_id = ENGINE_get_id(engine);
114
115 if (engine_id && !strcmp(engine_id, "pkcs11")) {
116 if (keydir)
Jan Luebbe24bf6e82020-05-13 12:26:24 +0200117 if (strstr(keydir, "object="))
118 snprintf(key_id, sizeof(key_id),
119 "pkcs11:%s;type=public",
120 keydir);
121 else
122 snprintf(key_id, sizeof(key_id),
123 "pkcs11:%s;object=%s;type=public",
124 keydir, name);
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600125 else
126 snprintf(key_id, sizeof(key_id),
127 "pkcs11:object=%s;type=public",
128 name);
Vesa Jääskeläinen5b123e02019-06-16 20:53:38 +0300129 } else if (engine_id) {
130 if (keydir)
131 snprintf(key_id, sizeof(key_id),
132 "%s%s",
133 keydir, name);
134 else
135 snprintf(key_id, sizeof(key_id),
136 "%s",
137 name);
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600138 } else {
139 fprintf(stderr, "Engine not supported\n");
140 return -ENOTSUP;
141 }
142
143 key = ENGINE_load_public_key(engine, key_id, NULL, NULL);
144 if (!key)
145 return rsa_err("Failure loading public key from engine");
146
Chan, Donaldfbc77742021-04-01 22:42:36 +0000147 *evpp = key;
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600148
149 return 0;
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600150}
151
152/**
153 * rsa_get_pub_key() - read a public key
154 *
155 * @keydir: Directory containing the key (PEM file) or key prefix (engine)
156 * @name Name of key file (will have a .crt extension)
157 * @engine Engine to use
Chan, Donaldfbc77742021-04-01 22:42:36 +0000158 * @evpp Returns EVP_PKEY object, or NULL on failure
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100159 * Return: 0 if ok, -ve on error (in which case *evpp will be set to NULL)
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600160 */
161static int rsa_get_pub_key(const char *keydir, const char *name,
Chan, Donaldfbc77742021-04-01 22:42:36 +0000162 ENGINE *engine, EVP_PKEY **evpp)
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600163{
164 if (engine)
Chan, Donaldfbc77742021-04-01 22:42:36 +0000165 return rsa_engine_get_pub_key(keydir, name, engine, evpp);
166 return rsa_pem_get_pub_key(keydir, name, evpp);
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600167}
168
169/**
170 * rsa_pem_get_priv_key() - read a private key from a .key file
171 *
172 * @keydir: Directory containing the key
Simon Glass19c402a2013-06-13 15:10:02 -0700173 * @name Name of key file (will have a .key extension)
Chan, Donaldfbc77742021-04-01 22:42:36 +0000174 * @evpp Returns EVP_PKEY object, or NULL on failure
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100175 * Return: 0 if ok, -ve on error (in which case *evpp will be set to NULL)
Simon Glass19c402a2013-06-13 15:10:02 -0700176 */
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600177static int rsa_pem_get_priv_key(const char *keydir, const char *name,
Chan, Donaldfbc77742021-04-01 22:42:36 +0000178 const char *keyfile, EVP_PKEY **evpp)
Simon Glass19c402a2013-06-13 15:10:02 -0700179{
Chan, Donaldfbc77742021-04-01 22:42:36 +0000180 char path[1024] = {0};
181 FILE *f = NULL;
Simon Glass19c402a2013-06-13 15:10:02 -0700182
Chan, Donaldfbc77742021-04-01 22:42:36 +0000183 if (!evpp)
184 return -EINVAL;
185
186 *evpp = NULL;
Alexandru Gagniuc824ee742021-02-19 12:45:18 -0600187 if (keydir && name)
188 snprintf(path, sizeof(path), "%s/%s.key", keydir, name);
189 else if (keyfile)
190 snprintf(path, sizeof(path), "%s", keyfile);
191 else
192 return -EINVAL;
193
Simon Glass19c402a2013-06-13 15:10:02 -0700194 f = fopen(path, "r");
195 if (!f) {
196 fprintf(stderr, "Couldn't open RSA private key: '%s': %s\n",
197 path, strerror(errno));
198 return -ENOENT;
199 }
200
Chan, Donaldfbc77742021-04-01 22:42:36 +0000201 if (!PEM_read_PrivateKey(f, evpp, NULL, path)) {
Simon Glass19c402a2013-06-13 15:10:02 -0700202 rsa_err("Failure reading private key");
203 fclose(f);
204 return -EPROTO;
205 }
206 fclose(f);
Simon Glass19c402a2013-06-13 15:10:02 -0700207
208 return 0;
209}
210
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600211/**
212 * rsa_engine_get_priv_key() - read a private key from given engine
213 *
214 * @keydir: Key prefix
215 * @name Name of key
216 * @engine Engine to use
Chan, Donaldfbc77742021-04-01 22:42:36 +0000217 * @evpp Returns EVP_PKEY object, or NULL on failure
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100218 * Return: 0 if ok, -ve on error (in which case *evpp will be set to NULL)
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600219 */
220static int rsa_engine_get_priv_key(const char *keydir, const char *name,
Alexandru Gagniuc824ee742021-02-19 12:45:18 -0600221 const char *keyfile,
Chan, Donaldfbc77742021-04-01 22:42:36 +0000222 ENGINE *engine, EVP_PKEY **evpp)
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600223{
224 const char *engine_id;
225 char key_id[1024];
Chan, Donaldfbc77742021-04-01 22:42:36 +0000226 EVP_PKEY *key = NULL;
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600227
Chan, Donaldfbc77742021-04-01 22:42:36 +0000228 if (!evpp)
229 return -EINVAL;
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600230
231 engine_id = ENGINE_get_id(engine);
232
233 if (engine_id && !strcmp(engine_id, "pkcs11")) {
Alexandru Gagniuc824ee742021-02-19 12:45:18 -0600234 if (!keydir && !name) {
235 fprintf(stderr, "Please use 'keydir' with PKCS11\n");
236 return -EINVAL;
237 }
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600238 if (keydir)
Jan Luebbe24bf6e82020-05-13 12:26:24 +0200239 if (strstr(keydir, "object="))
240 snprintf(key_id, sizeof(key_id),
241 "pkcs11:%s;type=private",
242 keydir);
243 else
244 snprintf(key_id, sizeof(key_id),
245 "pkcs11:%s;object=%s;type=private",
246 keydir, name);
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600247 else
248 snprintf(key_id, sizeof(key_id),
249 "pkcs11:object=%s;type=private",
250 name);
Vesa Jääskeläinen5b123e02019-06-16 20:53:38 +0300251 } else if (engine_id) {
Alexandru Gagniuc824ee742021-02-19 12:45:18 -0600252 if (keydir && name)
Vesa Jääskeläinen5b123e02019-06-16 20:53:38 +0300253 snprintf(key_id, sizeof(key_id),
254 "%s%s",
255 keydir, name);
Heinrich Schuchardtd607dfd2021-08-28 12:13:05 +0200256 else if (name)
Vesa Jääskeläinen5b123e02019-06-16 20:53:38 +0300257 snprintf(key_id, sizeof(key_id),
258 "%s",
Heinrich Schuchardt295ab732021-07-30 17:05:07 +0200259 name ? name : "");
Alexandru Gagniuc824ee742021-02-19 12:45:18 -0600260 else if (keyfile)
261 snprintf(key_id, sizeof(key_id), "%s", keyfile);
262 else
263 return -EINVAL;
264
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600265 } else {
266 fprintf(stderr, "Engine not supported\n");
267 return -ENOTSUP;
268 }
269
270 key = ENGINE_load_private_key(engine, key_id, NULL, NULL);
271 if (!key)
272 return rsa_err("Failure loading private key from engine");
273
Chan, Donaldfbc77742021-04-01 22:42:36 +0000274 *evpp = key;
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600275
276 return 0;
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600277}
278
279/**
280 * rsa_get_priv_key() - read a private key
281 *
282 * @keydir: Directory containing the key (PEM file) or key prefix (engine)
283 * @name Name of key
284 * @engine Engine to use for signing
Chan, Donaldfbc77742021-04-01 22:42:36 +0000285 * @evpp Returns EVP_PKEY object, or NULL on failure
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100286 * Return: 0 if ok, -ve on error (in which case *evpp will be set to NULL)
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600287 */
288static int rsa_get_priv_key(const char *keydir, const char *name,
Chan, Donaldfbc77742021-04-01 22:42:36 +0000289 const char *keyfile, ENGINE *engine, EVP_PKEY **evpp)
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600290{
291 if (engine)
Alexandru Gagniuc824ee742021-02-19 12:45:18 -0600292 return rsa_engine_get_priv_key(keydir, name, keyfile, engine,
Chan, Donaldfbc77742021-04-01 22:42:36 +0000293 evpp);
294 return rsa_pem_get_priv_key(keydir, name, keyfile, evpp);
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600295}
296
Simon Glass19c402a2013-06-13 15:10:02 -0700297static int rsa_init(void)
298{
299 int ret;
300
Jelle van der Waac3b43282017-05-08 21:31:19 +0200301 ret = OPENSSL_init_ssl(0, NULL);
Simon Glass19c402a2013-06-13 15:10:02 -0700302 if (!ret) {
303 fprintf(stderr, "Failure to init SSL library\n");
304 return -1;
305 }
Simon Glass19c402a2013-06-13 15:10:02 -0700306
307 return 0;
308}
309
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600310static int rsa_engine_init(const char *engine_id, ENGINE **pe)
311{
Marc Kleine-Budde62b27a52021-07-23 22:17:50 +0200312 const char *key_pass;
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600313 ENGINE *e;
314 int ret;
315
316 ENGINE_load_builtin_engines();
317
318 e = ENGINE_by_id(engine_id);
319 if (!e) {
320 fprintf(stderr, "Engine isn't available\n");
Alexandru Gagniucfe68a672021-07-29 13:31:21 -0500321 return -1;
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600322 }
323
324 if (!ENGINE_init(e)) {
325 fprintf(stderr, "Couldn't initialize engine\n");
326 ret = -1;
327 goto err_engine_init;
328 }
329
330 if (!ENGINE_set_default_RSA(e)) {
331 fprintf(stderr, "Couldn't set engine as default for RSA\n");
332 ret = -1;
333 goto err_set_rsa;
334 }
335
Marc Kleine-Budde62b27a52021-07-23 22:17:50 +0200336 key_pass = getenv("MKIMAGE_SIGN_PIN");
337 if (key_pass) {
338 if (!ENGINE_ctrl_cmd_string(e, "PIN", key_pass, 0)) {
339 fprintf(stderr, "Couldn't set PIN\n");
340 ret = -1;
341 goto err_set_pin;
342 }
343 }
344
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600345 *pe = e;
346
347 return 0;
348
Marc Kleine-Budde62b27a52021-07-23 22:17:50 +0200349err_set_pin:
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600350err_set_rsa:
351 ENGINE_finish(e);
352err_engine_init:
353 ENGINE_free(e);
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600354 return ret;
355}
356
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600357static void rsa_engine_remove(ENGINE *e)
358{
359 if (e) {
360 ENGINE_finish(e);
361 ENGINE_free(e);
362 }
363}
364
Chan, Donaldfbc77742021-04-01 22:42:36 +0000365static int rsa_sign_with_key(EVP_PKEY *pkey, struct padding_algo *padding_algo,
Philippe Reynes20031562018-11-14 13:51:00 +0100366 struct checksum_algo *checksum_algo,
Heiko Schocher646257d2014-03-03 12:19:26 +0100367 const struct image_region region[], int region_count,
368 uint8_t **sigp, uint *sig_size)
Simon Glass19c402a2013-06-13 15:10:02 -0700369{
Philippe Reynes20031562018-11-14 13:51:00 +0100370 EVP_PKEY_CTX *ckey;
Simon Glass19c402a2013-06-13 15:10:02 -0700371 EVP_MD_CTX *context;
Philippe Reynes3b5d6972018-11-14 13:50:59 +0100372 int ret = 0;
373 size_t size;
Simon Glass19c402a2013-06-13 15:10:02 -0700374 uint8_t *sig;
375 int i;
376
Chan, Donaldfbc77742021-04-01 22:42:36 +0000377 size = EVP_PKEY_size(pkey);
Simon Glass19c402a2013-06-13 15:10:02 -0700378 sig = malloc(size);
379 if (!sig) {
Philippe Reynes3b5d6972018-11-14 13:50:59 +0100380 fprintf(stderr, "Out of memory for signature (%zu bytes)\n",
Simon Glass19c402a2013-06-13 15:10:02 -0700381 size);
382 ret = -ENOMEM;
383 goto err_alloc;
384 }
385
Yann Droneaud9b5ad4f2022-03-01 16:12:34 +0100386 context = EVP_MD_CTX_new();
Simon Glass19c402a2013-06-13 15:10:02 -0700387 if (!context) {
388 ret = rsa_err("EVP context creation failed");
389 goto err_create;
390 }
Philippe Reynes20031562018-11-14 13:51:00 +0100391
Chan, Donaldfbc77742021-04-01 22:42:36 +0000392 ckey = EVP_PKEY_CTX_new(pkey, NULL);
Philippe Reynes20031562018-11-14 13:51:00 +0100393 if (!ckey) {
394 ret = rsa_err("EVP key context creation failed");
395 goto err_create;
396 }
397
398 if (EVP_DigestSignInit(context, &ckey,
Philippe Reynes3b5d6972018-11-14 13:50:59 +0100399 checksum_algo->calculate_sign(),
Chan, Donaldfbc77742021-04-01 22:42:36 +0000400 NULL, pkey) <= 0) {
Simon Glass19c402a2013-06-13 15:10:02 -0700401 ret = rsa_err("Signer setup failed");
402 goto err_sign;
403 }
404
Simon Glass2bbed3f2021-09-25 19:43:23 -0600405 if (CONFIG_IS_ENABLED(FIT_RSASSA_PSS) && padding_algo &&
406 !strcmp(padding_algo->name, "pss")) {
Philippe Reynes061daa02018-11-14 13:51:01 +0100407 if (EVP_PKEY_CTX_set_rsa_padding(ckey,
408 RSA_PKCS1_PSS_PADDING) <= 0) {
409 ret = rsa_err("Signer padding setup failed");
410 goto err_sign;
411 }
412 }
Philippe Reynes061daa02018-11-14 13:51:01 +0100413
Simon Glass19c402a2013-06-13 15:10:02 -0700414 for (i = 0; i < region_count; i++) {
Philippe Reynes3b5d6972018-11-14 13:50:59 +0100415 if (!EVP_DigestSignUpdate(context, region[i].data,
416 region[i].size)) {
Simon Glass19c402a2013-06-13 15:10:02 -0700417 ret = rsa_err("Signing data failed");
418 goto err_sign;
419 }
420 }
421
Philippe Reynes3b5d6972018-11-14 13:50:59 +0100422 if (!EVP_DigestSignFinal(context, sig, &size)) {
Simon Glass19c402a2013-06-13 15:10:02 -0700423 ret = rsa_err("Could not obtain signature");
424 goto err_sign;
425 }
Philippe Reynes3b5d6972018-11-14 13:50:59 +0100426
Yann Droneaud9b5ad4f2022-03-01 16:12:34 +0100427 EVP_MD_CTX_free(context);
Simon Glass19c402a2013-06-13 15:10:02 -0700428
Chan, Donald6d59ace2021-07-19 09:18:54 -0700429 debug("Got signature: %zu bytes, expected %d\n", size, EVP_PKEY_size(pkey));
Simon Glass19c402a2013-06-13 15:10:02 -0700430 *sigp = sig;
431 *sig_size = size;
432
433 return 0;
434
435err_sign:
Yann Droneaud9b5ad4f2022-03-01 16:12:34 +0100436 EVP_MD_CTX_free(context);
Simon Glass19c402a2013-06-13 15:10:02 -0700437err_create:
438 free(sig);
439err_alloc:
Simon Glass19c402a2013-06-13 15:10:02 -0700440 return ret;
441}
442
443int rsa_sign(struct image_sign_info *info,
444 const struct image_region region[], int region_count,
445 uint8_t **sigp, uint *sig_len)
446{
Chan, Donaldfbc77742021-04-01 22:42:36 +0000447 EVP_PKEY *pkey = NULL;
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600448 ENGINE *e = NULL;
Simon Glass19c402a2013-06-13 15:10:02 -0700449 int ret;
450
451 ret = rsa_init();
452 if (ret)
453 return ret;
454
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600455 if (info->engine_id) {
456 ret = rsa_engine_init(info->engine_id, &e);
457 if (ret)
Alexandru Gagniucfe68a672021-07-29 13:31:21 -0500458 return ret;
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600459 }
460
Alexandru Gagniuc824ee742021-02-19 12:45:18 -0600461 ret = rsa_get_priv_key(info->keydir, info->keyname, info->keyfile,
Chan, Donaldfbc77742021-04-01 22:42:36 +0000462 e, &pkey);
Simon Glass19c402a2013-06-13 15:10:02 -0700463 if (ret)
464 goto err_priv;
Chan, Donaldfbc77742021-04-01 22:42:36 +0000465 ret = rsa_sign_with_key(pkey, info->padding, info->checksum, region,
Heiko Schocher646257d2014-03-03 12:19:26 +0100466 region_count, sigp, sig_len);
Simon Glass19c402a2013-06-13 15:10:02 -0700467 if (ret)
468 goto err_sign;
469
Chan, Donaldfbc77742021-04-01 22:42:36 +0000470 EVP_PKEY_free(pkey);
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600471 if (info->engine_id)
472 rsa_engine_remove(e);
Simon Glass19c402a2013-06-13 15:10:02 -0700473
474 return ret;
475
476err_sign:
Chan, Donaldfbc77742021-04-01 22:42:36 +0000477 EVP_PKEY_free(pkey);
Simon Glass19c402a2013-06-13 15:10:02 -0700478err_priv:
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600479 if (info->engine_id)
480 rsa_engine_remove(e);
Simon Glass19c402a2013-06-13 15:10:02 -0700481 return ret;
482}
483
484/*
Michael van der Westhuizene0f2f152014-07-02 10:17:26 +0200485 * rsa_get_exponent(): - Get the public exponent from an RSA key
486 */
487static int rsa_get_exponent(RSA *key, uint64_t *e)
488{
489 int ret;
490 BIGNUM *bn_te;
Jelle van der Waac3b43282017-05-08 21:31:19 +0200491 const BIGNUM *key_e;
Michael van der Westhuizene0f2f152014-07-02 10:17:26 +0200492 uint64_t te;
493
494 ret = -EINVAL;
495 bn_te = NULL;
496
497 if (!e)
498 goto cleanup;
499
Jelle van der Waac3b43282017-05-08 21:31:19 +0200500 RSA_get0_key(key, NULL, &key_e, NULL);
501 if (BN_num_bits(key_e) > 64)
Michael van der Westhuizene0f2f152014-07-02 10:17:26 +0200502 goto cleanup;
503
Jelle van der Waac3b43282017-05-08 21:31:19 +0200504 *e = BN_get_word(key_e);
Michael van der Westhuizene0f2f152014-07-02 10:17:26 +0200505
Jelle van der Waac3b43282017-05-08 21:31:19 +0200506 if (BN_num_bits(key_e) < 33) {
Michael van der Westhuizene0f2f152014-07-02 10:17:26 +0200507 ret = 0;
508 goto cleanup;
509 }
510
Jelle van der Waac3b43282017-05-08 21:31:19 +0200511 bn_te = BN_dup(key_e);
Michael van der Westhuizene0f2f152014-07-02 10:17:26 +0200512 if (!bn_te)
513 goto cleanup;
514
515 if (!BN_rshift(bn_te, bn_te, 32))
516 goto cleanup;
517
518 if (!BN_mask_bits(bn_te, 32))
519 goto cleanup;
520
521 te = BN_get_word(bn_te);
522 te <<= 32;
523 *e |= te;
524 ret = 0;
525
526cleanup:
527 if (bn_te)
528 BN_free(bn_te);
529
530 return ret;
531}
532
533/*
Simon Glass19c402a2013-06-13 15:10:02 -0700534 * rsa_get_params(): - Get the important parameters of an RSA public key
535 */
Michael van der Westhuizene0f2f152014-07-02 10:17:26 +0200536int rsa_get_params(RSA *key, uint64_t *exponent, uint32_t *n0_invp,
537 BIGNUM **modulusp, BIGNUM **r_squaredp)
Simon Glass19c402a2013-06-13 15:10:02 -0700538{
539 BIGNUM *big1, *big2, *big32, *big2_32;
540 BIGNUM *n, *r, *r_squared, *tmp;
Jelle van der Waac3b43282017-05-08 21:31:19 +0200541 const BIGNUM *key_n;
Simon Glass19c402a2013-06-13 15:10:02 -0700542 BN_CTX *bn_ctx = BN_CTX_new();
543 int ret = 0;
544
545 /* Initialize BIGNUMs */
546 big1 = BN_new();
547 big2 = BN_new();
548 big32 = BN_new();
549 r = BN_new();
550 r_squared = BN_new();
551 tmp = BN_new();
552 big2_32 = BN_new();
553 n = BN_new();
554 if (!big1 || !big2 || !big32 || !r || !r_squared || !tmp || !big2_32 ||
555 !n) {
556 fprintf(stderr, "Out of memory (bignum)\n");
557 return -ENOMEM;
558 }
559
Michael van der Westhuizene0f2f152014-07-02 10:17:26 +0200560 if (0 != rsa_get_exponent(key, exponent))
561 ret = -1;
562
Jelle van der Waac3b43282017-05-08 21:31:19 +0200563 RSA_get0_key(key, &key_n, NULL, NULL);
564 if (!BN_copy(n, key_n) || !BN_set_word(big1, 1L) ||
Simon Glass19c402a2013-06-13 15:10:02 -0700565 !BN_set_word(big2, 2L) || !BN_set_word(big32, 32L))
566 ret = -1;
567
568 /* big2_32 = 2^32 */
569 if (!BN_exp(big2_32, big2, big32, bn_ctx))
570 ret = -1;
571
572 /* Calculate n0_inv = -1 / n[0] mod 2^32 */
573 if (!BN_mod_inverse(tmp, n, big2_32, bn_ctx) ||
574 !BN_sub(tmp, big2_32, tmp))
575 ret = -1;
576 *n0_invp = BN_get_word(tmp);
577
578 /* Calculate R = 2^(# of key bits) */
579 if (!BN_set_word(tmp, BN_num_bits(n)) ||
580 !BN_exp(r, big2, tmp, bn_ctx))
581 ret = -1;
582
583 /* Calculate r_squared = R^2 mod n */
584 if (!BN_copy(r_squared, r) ||
585 !BN_mul(tmp, r_squared, r, bn_ctx) ||
586 !BN_mod(r_squared, tmp, n, bn_ctx))
587 ret = -1;
588
589 *modulusp = n;
590 *r_squaredp = r_squared;
591
592 BN_free(big1);
593 BN_free(big2);
594 BN_free(big32);
595 BN_free(r);
596 BN_free(tmp);
597 BN_free(big2_32);
598 if (ret) {
599 fprintf(stderr, "Bignum operations failed\n");
600 return -ENOMEM;
601 }
602
603 return ret;
604}
605
Simon Glass19c402a2013-06-13 15:10:02 -0700606int rsa_add_verify_data(struct image_sign_info *info, void *keydest)
607{
608 BIGNUM *modulus, *r_squared;
Michael van der Westhuizene0f2f152014-07-02 10:17:26 +0200609 uint64_t exponent;
Simon Glass19c402a2013-06-13 15:10:02 -0700610 uint32_t n0_inv;
611 int parent, node;
612 char name[100];
613 int ret;
614 int bits;
615 RSA *rsa;
Chan, Donaldfbc77742021-04-01 22:42:36 +0000616 EVP_PKEY *pkey = NULL;
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600617 ENGINE *e = NULL;
Simon Glass19c402a2013-06-13 15:10:02 -0700618
619 debug("%s: Getting verification data\n", __func__);
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600620 if (info->engine_id) {
621 ret = rsa_engine_init(info->engine_id, &e);
622 if (ret)
623 return ret;
624 }
Chan, Donaldfbc77742021-04-01 22:42:36 +0000625 ret = rsa_get_pub_key(info->keydir, info->keyname, e, &pkey);
Simon Glass19c402a2013-06-13 15:10:02 -0700626 if (ret)
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600627 goto err_get_pub_key;
Alexandru Gagniucfe68a672021-07-29 13:31:21 -0500628
Heinrich Schuchardt675c3cc2022-01-09 15:39:40 +0100629 rsa = (RSA *)EVP_PKEY_get0_RSA(pkey);
Michael van der Westhuizene0f2f152014-07-02 10:17:26 +0200630 ret = rsa_get_params(rsa, &exponent, &n0_inv, &modulus, &r_squared);
Simon Glass19c402a2013-06-13 15:10:02 -0700631 if (ret)
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600632 goto err_get_params;
Simon Glass19c402a2013-06-13 15:10:02 -0700633 bits = BN_num_bits(modulus);
634 parent = fdt_subnode_offset(keydest, 0, FIT_SIG_NODENAME);
635 if (parent == -FDT_ERR_NOTFOUND) {
636 parent = fdt_add_subnode(keydest, 0, FIT_SIG_NODENAME);
637 if (parent < 0) {
Simon Glass597a8b22014-06-12 07:24:42 -0600638 ret = parent;
639 if (ret != -FDT_ERR_NOSPACE) {
640 fprintf(stderr, "Couldn't create signature node: %s\n",
641 fdt_strerror(parent));
642 }
Simon Glass19c402a2013-06-13 15:10:02 -0700643 }
644 }
Simon Glass597a8b22014-06-12 07:24:42 -0600645 if (ret)
646 goto done;
Simon Glass19c402a2013-06-13 15:10:02 -0700647
648 /* Either create or overwrite the named key node */
649 snprintf(name, sizeof(name), "key-%s", info->keyname);
650 node = fdt_subnode_offset(keydest, parent, name);
651 if (node == -FDT_ERR_NOTFOUND) {
652 node = fdt_add_subnode(keydest, parent, name);
653 if (node < 0) {
Simon Glass597a8b22014-06-12 07:24:42 -0600654 ret = node;
655 if (ret != -FDT_ERR_NOSPACE) {
656 fprintf(stderr, "Could not create key subnode: %s\n",
657 fdt_strerror(node));
658 }
Simon Glass19c402a2013-06-13 15:10:02 -0700659 }
660 } else if (node < 0) {
661 fprintf(stderr, "Cannot select keys parent: %s\n",
662 fdt_strerror(node));
Simon Glass597a8b22014-06-12 07:24:42 -0600663 ret = node;
Simon Glass19c402a2013-06-13 15:10:02 -0700664 }
665
Simon Glass597a8b22014-06-12 07:24:42 -0600666 if (!ret) {
Simon Glass72188f52020-03-18 11:44:06 -0600667 ret = fdt_setprop_string(keydest, node, FIT_KEY_HINT,
668 info->keyname);
Simon Glass597a8b22014-06-12 07:24:42 -0600669 }
Simon Glass4f427a42014-06-02 22:04:51 -0600670 if (!ret)
671 ret = fdt_setprop_u32(keydest, node, "rsa,num-bits", bits);
672 if (!ret)
673 ret = fdt_setprop_u32(keydest, node, "rsa,n0-inverse", n0_inv);
674 if (!ret) {
Michael van der Westhuizene0f2f152014-07-02 10:17:26 +0200675 ret = fdt_setprop_u64(keydest, node, "rsa,exponent", exponent);
676 }
677 if (!ret) {
Simon Glass4f427a42014-06-02 22:04:51 -0600678 ret = fdt_add_bignum(keydest, node, "rsa,modulus", modulus,
679 bits);
680 }
681 if (!ret) {
682 ret = fdt_add_bignum(keydest, node, "rsa,r-squared", r_squared,
683 bits);
684 }
685 if (!ret) {
686 ret = fdt_setprop_string(keydest, node, FIT_ALGO_PROP,
Andrew Duda83dd98e2016-11-08 18:53:41 +0000687 info->name);
Simon Glass4f427a42014-06-02 22:04:51 -0600688 }
mario.six@gdsys.cc2b9ec762016-07-19 11:07:07 +0200689 if (!ret && info->require_keys) {
Simon Glass72188f52020-03-18 11:44:06 -0600690 ret = fdt_setprop_string(keydest, node, FIT_KEY_REQUIRED,
Simon Glass4f427a42014-06-02 22:04:51 -0600691 info->require_keys);
Simon Glass19c402a2013-06-13 15:10:02 -0700692 }
Simon Glass597a8b22014-06-12 07:24:42 -0600693done:
Simon Glass19c402a2013-06-13 15:10:02 -0700694 BN_free(modulus);
695 BN_free(r_squared);
696 if (ret)
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600697 ret = ret == -FDT_ERR_NOSPACE ? -ENOSPC : -EIO;
698err_get_params:
Chan, Donaldfbc77742021-04-01 22:42:36 +0000699 EVP_PKEY_free(pkey);
George McCollisterf1ca1fd2017-01-06 13:14:17 -0600700err_get_pub_key:
701 if (info->engine_id)
702 rsa_engine_remove(e);
Simon Glass19c402a2013-06-13 15:10:02 -0700703
Simon Glassc033dc82021-11-12 12:28:11 -0700704 if (ret)
705 return ret;
706
707 return node;
Simon Glass19c402a2013-06-13 15:10:02 -0700708}