lib/rsa/rsa-verify.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2013, Google Inc.
   4  */
   5
   6 #ifndef USE_HOSTCC
   7 #include <common.h>
   8 #include <fdtdec.h>
   9 #include <malloc.h>
  10 #include <asm/types.h>
  11 #include <asm/byteorder.h>
  12 #include <linux/errno.h>
  13 #include <asm/types.h>
  14 #include <asm/unaligned.h>
  15 #include <dm.h>
  16 #else
  17 #include "fdt_host.h"
  18 #include "mkimage.h"
  19 #include <fdt_support.h>
  20 #endif
  21 #include <u-boot/rsa-mod-exp.h>
  22 #include <u-boot/rsa.h>
  23
  24 /* Default public exponent for backward compatibility */
  25 #define RSA_DEFAULT_PUBEXP      65537
  26
  27 /**
  28  * rsa_verify_padding() - Verify RSA message padding is valid
  29  *
  30  * Verify a RSA message's padding is consistent with PKCS1.5
  31  * padding as described in the RSA PKCS#1 v2.1 standard.
  32  *
  33  * @msg:        Padded message
  34  * @pad_len:    Number of expected padding bytes
  35  * @algo:       Checksum algo structure having information on DER encoding etc.
  36  * @return 0 on success, != 0 on failure
  37  */
  38 static int rsa_verify_padding(const uint8_t *msg, const int pad_len,
  39                               struct checksum_algo *algo)
  40 {
  41         int ff_len;
  42         int ret;
  43
  44         /* first byte must be 0x00 */
  45         ret = *msg++;
  46         /* second byte must be 0x01 */
  47         ret |= *msg++ ^ 0x01;
  48         /* next ff_len bytes must be 0xff */
  49         ff_len = pad_len - algo->der_len - 3;
  50         ret |= *msg ^ 0xff;
  51         ret |= memcmp(msg, msg+1, ff_len-1);
  52         msg += ff_len;
  53         /* next byte must be 0x00 */
  54         ret |= *msg++;
  55         /* next der_len bytes must match der_prefix */
  56         ret |= memcmp(msg, algo->der_prefix, algo->der_len);
  57
  58         return ret;
  59 }
  60
  61 int padding_pkcs_15_verify(struct image_sign_info *info,
  62                            uint8_t *msg, int msg_len,
  63                            const uint8_t *hash, int hash_len)
  64 {
  65         struct checksum_algo *checksum = info->checksum;
  66         int ret, pad_len = msg_len - checksum->checksum_len;
  67
  68         /* Check pkcs1.5 padding bytes. */
  69         ret = rsa_verify_padding(msg, pad_len, checksum);
  70         if (ret) {
  71                 debug("In RSAVerify(): Padding check failed!\n");
  72                 return -EINVAL;
  73         }
  74
  75         /* Check hash. */
  76         if (memcmp((uint8_t *)msg + pad_len, hash, msg_len - pad_len)) {
  77                 debug("In RSAVerify(): Hash check failed!\n");
  78                 return -EACCES;
  79         }
  80
  81         return 0;
  82 }
  83
  84 #ifdef CONFIG_FIT_ENABLE_RSASSA_PSS_SUPPORT
  85 static void u32_i2osp(uint32_t val, uint8_t *buf)
  86 {
  87         buf[0] = (uint8_t)((val >> 24) & 0xff);
  88         buf[1] = (uint8_t)((val >> 16) & 0xff);
  89         buf[2] = (uint8_t)((val >>  8) & 0xff);
  90         buf[3] = (uint8_t)((val >>  0) & 0xff);
  91 }
  92
  93 /**
  94  * mask_generation_function1() - generate an octet string
  95  *
  96  * Generate an octet string used to check rsa signature.
  97  * It use an input octet string and a hash function.
  98  *
  99  * @checksum:   A Hash function
 100  * @seed:       Specifies an input variable octet string
 101  * @seed_len:   Size of the input octet string
 102  * @output:     Specifies the output octet string
 103  * @output_len: Size of the output octet string
 104  * @return 0 if the octet string was correctly generated, others on error
 105  */
 106 static int mask_generation_function1(struct checksum_algo *checksum,
 107                                      uint8_t *seed, int seed_len,
 108                                      uint8_t *output, int output_len)
 109 {
 110         struct image_region region[2];
 111         int ret = 0, i, i_output = 0, region_count = 2;
 112         uint32_t counter = 0;
 113         uint8_t buf_counter[4], *tmp;
 114         int hash_len = checksum->checksum_len;
 115
 116         memset(output, 0, output_len);
 117
 118         region[0].data = seed;
 119         region[0].size = seed_len;
 120         region[1].data = &buf_counter[0];
 121         region[1].size = 4;
 122
 123         tmp = malloc(hash_len);
 124         if (!tmp) {
 125                 debug("%s: can't allocate array tmp\n", __func__);
 126                 ret = -ENOMEM;
 127                 goto out;
 128         }
 129
 130         while (i_output < output_len) {
 131                 u32_i2osp(counter, &buf_counter[0]);
 132
 133                 ret = checksum->calculate(checksum->name,
 134                                           region, region_count,
 135                                           tmp);
 136                 if (ret < 0) {
 137                         debug("%s: Error in checksum calculation\n", __func__);
 138                         goto out;
 139                 }
 140
 141                 i = 0;
 142                 while ((i_output < output_len) && (i < hash_len)) {
 143                         output[i_output] = tmp[i];
 144                         i_output++;
 145                         i++;
 146                 }
 147
 148                 counter++;
 149         }
 150
 151 out:
 152         free(tmp);
 153
 154         return ret;
 155 }
 156
 157 static int compute_hash_prime(struct checksum_algo *checksum,
 158                               uint8_t *pad, int pad_len,
 159                               uint8_t *hash, int hash_len,
 160                               uint8_t *salt, int salt_len,
 161                               uint8_t *hprime)
 162 {
 163         struct image_region region[3];
 164         int ret, region_count = 3;
 165
 166         region[0].data = pad;
 167         region[0].size = pad_len;
 168         region[1].data = hash;
 169         region[1].size = hash_len;
 170         region[2].data = salt;
 171         region[2].size = salt_len;
 172
 173         ret = checksum->calculate(checksum->name, region, region_count, hprime);
 174         if (ret < 0) {
 175                 debug("%s: Error in checksum calculation\n", __func__);
 176                 goto out;
 177         }
 178
 179 out:
 180         return ret;
 181 }
 182
 183 int padding_pss_verify(struct image_sign_info *info,
 184                        uint8_t *msg, int msg_len,
 185                        const uint8_t *hash, int hash_len)
 186 {
 187         uint8_t *masked_db = NULL;
 188         int masked_db_len = msg_len - hash_len - 1;
 189         uint8_t *h = NULL, *hprime = NULL;
 190         int h_len = hash_len;
 191         uint8_t *db_mask = NULL;
 192         int db_mask_len = masked_db_len;
 193         uint8_t *db = NULL, *salt = NULL;
 194         int db_len = masked_db_len, salt_len = msg_len - hash_len - 2;
 195         uint8_t pad_zero[8] = { 0 };
 196         int ret, i, leftmost_bits = 1;
 197         uint8_t leftmost_mask;
 198         struct checksum_algo *checksum = info->checksum;
 199
 200         /* first, allocate everything */
 201         masked_db = malloc(masked_db_len);
 202         h = malloc(h_len);
 203         db_mask = malloc(db_mask_len);
 204         db = malloc(db_len);
 205         salt = malloc(salt_len);
 206         hprime = malloc(hash_len);
 207         if (!masked_db || !h || !db_mask || !db || !salt || !hprime) {
 208                 printf("%s: can't allocate some buffer\n", __func__);
 209                 ret = -ENOMEM;
 210                 goto out;
 211         }
 212
 213         /* step 4: check if the last byte is 0xbc */
 214         if (msg[msg_len - 1] != 0xbc) {
 215                 printf("%s: invalid pss padding (0xbc is missing)\n", __func__);
 216                 ret = -EINVAL;
 217                 goto out;
 218         }
 219
 220         /* step 5 */
 221         memcpy(masked_db, msg, masked_db_len);
 222         memcpy(h, msg + masked_db_len, h_len);
 223
 224         /* step 6 */
 225         leftmost_mask = (0xff >> (8 - leftmost_bits)) << (8 - leftmost_bits);
 226         if (masked_db[0] & leftmost_mask) {
 227                 printf("%s: invalid pss padding ", __func__);
 228                 printf("(leftmost bit of maskedDB not zero)\n");
 229                 ret = -EINVAL;
 230                 goto out;
 231         }
 232
 233         /* step 7 */
 234         mask_generation_function1(checksum, h, h_len, db_mask, db_mask_len);
 235
 236         /* step 8 */
 237         for (i = 0; i < db_len; i++)
 238                 db[i] = masked_db[i] ^ db_mask[i];
 239
 240         /* step 9 */
 241         db[0] &= 0xff >> leftmost_bits;
 242
 243         /* step 10 */
 244         if (db[0] != 0x01) {
 245                 printf("%s: invalid pss padding ", __func__);
 246                 printf("(leftmost byte of db isn't 0x01)\n");
 247                 ret = EINVAL;
 248                 goto out;
 249         }
 250
 251         /* step 11 */
 252         memcpy(salt, &db[1], salt_len);
 253
 254         /* step 12 & 13 */
 255         compute_hash_prime(checksum, pad_zero, 8,
 256                            (uint8_t *)hash, hash_len,
 257                            salt, salt_len, hprime);
 258
 259         /* step 14 */
 260         ret = memcmp(h, hprime, hash_len);
 261
 262 out:
 263         free(hprime);
 264         free(salt);
 265         free(db);
 266         free(db_mask);
 267         free(h);
 268         free(masked_db);
 269
 270         return ret;
 271 }
 272 #endif
 273
 274 #if CONFIG_IS_ENABLED(FIT_SIGNATURE)
 275 /**
 276  * rsa_verify_key() - Verify a signature against some data using RSA Key
 277  *
 278  * Verify a RSA PKCS1.5 signature against an expected hash using
 279  * the RSA Key properties in prop structure.
 280  *
 281  * @info:       Specifies key and FIT information
 282  * @prop:       Specifies key
 283  * @sig:        Signature
 284  * @sig_len:    Number of bytes in signature
 285  * @hash:       Pointer to the expected hash
 286  * @key_len:    Number of bytes in rsa key
 287  * @return 0 if verified, -ve on error
 288  */
 289 static int rsa_verify_key(struct image_sign_info *info,
 290                           struct key_prop *prop, const uint8_t *sig,
 291                           const uint32_t sig_len, const uint8_t *hash,
 292                           const uint32_t key_len)
 293 {
 294         int ret;
 295 #if !defined(USE_HOSTCC)
 296         struct udevice *mod_exp_dev;
 297 #endif
 298         struct checksum_algo *checksum = info->checksum;
 299         struct padding_algo *padding = info->padding;
 300         int hash_len;
 301
 302         if (!prop || !sig || !hash || !checksum)
 303                 return -EIO;
 304
 305         if (sig_len != (prop->num_bits / 8)) {
 306                 debug("Signature is of incorrect length %d\n", sig_len);
 307                 return -EINVAL;
 308         }
 309
 310         debug("Checksum algorithm: %s", checksum->name);
 311
 312         /* Sanity check for stack size */
 313         if (sig_len > RSA_MAX_SIG_BITS / 8) {
 314                 debug("Signature length %u exceeds maximum %d\n", sig_len,
 315                       RSA_MAX_SIG_BITS / 8);
 316                 return -EINVAL;
 317         }
 318
 319         uint8_t buf[sig_len];
 320         hash_len = checksum->checksum_len;
 321
 322 #if !defined(USE_HOSTCC)
 323         ret = uclass_get_device(UCLASS_MOD_EXP, 0, &mod_exp_dev);
 324         if (ret) {
 325                 printf("RSA: Can't find Modular Exp implementation\n");
 326                 return -EINVAL;
 327         }
 328
 329         ret = rsa_mod_exp(mod_exp_dev, sig, sig_len, prop, buf);
 330 #else
 331         ret = rsa_mod_exp_sw(sig, sig_len, prop, buf);
 332 #endif
 333         if (ret) {
 334                 debug("Error in Modular exponentation\n");
 335                 return ret;
 336         }
 337
 338         ret = padding->verify(info, buf, key_len, hash, hash_len);
 339         if (ret) {
 340                 debug("In RSAVerify(): padding check failed!\n");
 341                 return ret;
 342         }
 343
 344         return 0;
 345 }
 346 #endif
 347
 348 #if CONFIG_IS_ENABLED(FIT_SIGNATURE)
 349 /**
 350  * rsa_verify_with_keynode() - Verify a signature against some data using
 351  * information in node with prperties of RSA Key like modulus, exponent etc.
 352  *
 353  * Parse sign-node and fill a key_prop structure with properties of the
 354  * key.  Verify a RSA PKCS1.5 signature against an expected hash using
 355  * the properties parsed
 356  *
 357  * @info:       Specifies key and FIT information
 358  * @hash:       Pointer to the expected hash
 359  * @sig:        Signature
 360  * @sig_len:    Number of bytes in signature
 361  * @node:       Node having the RSA Key properties
 362  * @return 0 if verified, -ve on error
 363  */
 364 static int rsa_verify_with_keynode(struct image_sign_info *info,
 365                                    const void *hash, uint8_t *sig,
 366                                    uint sig_len, int node)
 367 {
 368         const void *blob = info->fdt_blob;
 369         struct key_prop prop;
 370         int length;
 371         int ret = 0;
 372
 373         if (node < 0) {
 374                 debug("%s: Skipping invalid node", __func__);
 375                 return -EBADF;
 376         }
 377
 378         prop.num_bits = fdtdec_get_int(blob, node, "rsa,num-bits", 0);
 379
 380         prop.n0inv = fdtdec_get_int(blob, node, "rsa,n0-inverse", 0);
 381
 382         prop.public_exponent = fdt_getprop(blob, node, "rsa,exponent", &length);
 383         if (!prop.public_exponent || length < sizeof(uint64_t))
 384                 prop.public_exponent = NULL;
 385
 386         prop.exp_len = sizeof(uint64_t);
 387
 388         prop.modulus = fdt_getprop(blob, node, "rsa,modulus", NULL);
 389
 390         prop.rr = fdt_getprop(blob, node, "rsa,r-squared", NULL);
 391
 392         if (!prop.num_bits || !prop.modulus) {
 393                 debug("%s: Missing RSA key info", __func__);
 394                 return -EFAULT;
 395         }
 396
 397         ret = rsa_verify_key(info, &prop, sig, sig_len, hash,
 398                              info->crypto->key_len);
 399
 400         return ret;
 401 }
 402 #else
 403 static int rsa_verify_with_keynode(struct image_sign_info *info,
 404                                    const void *hash, uint8_t *sig,
 405                                    uint sig_len, int node)
 406 {
 407         return -EACCES;
 408 }
 409 #endif
 410
 411 int rsa_verify(struct image_sign_info *info,
 412                const struct image_region region[], int region_count,
 413                uint8_t *sig, uint sig_len)
 414 {
 415         /* Reserve memory for maximum checksum-length */
 416         uint8_t hash[info->crypto->key_len];
 417         int ret = -EACCES;
 418
 419         /*
 420          * Verify that the checksum-length does not exceed the
 421          * rsa-signature-length
 422          */
 423         if (info->checksum->checksum_len >
 424             info->crypto->key_len) {
 425                 debug("%s: invlaid checksum-algorithm %s for %s\n",
 426                       __func__, info->checksum->name, info->crypto->name);
 427                 return -EINVAL;
 428         }
 429
 430         /* Calculate checksum with checksum-algorithm */
 431         ret = info->checksum->calculate(info->checksum->name,
 432                                         region, region_count, hash);
 433         if (ret < 0) {
 434                 debug("%s: Error in checksum calculation\n", __func__);
 435                 return -EINVAL;
 436         }
 437
 438         if (CONFIG_IS_ENABLED(FIT_SIGNATURE)) {
 439                 const void *blob = info->fdt_blob;
 440                 int ndepth, noffset;
 441                 int sig_node, node;
 442                 char name[100];
 443
 444                 sig_node = fdt_subnode_offset(blob, 0, FIT_SIG_NODENAME);
 445                 if (sig_node < 0) {
 446                         debug("%s: No signature node found\n", __func__);
 447                         return -ENOENT;
 448                 }
 449
 450                 /* See if we must use a particular key */
 451                 if (info->required_keynode != -1) {
 452                         ret = rsa_verify_with_keynode(info, hash, sig, sig_len,
 453                                                       info->required_keynode);
 454                         return ret;
 455                 }
 456
 457                 /* Look for a key that matches our hint */
 458                 snprintf(name, sizeof(name), "key-%s", info->keyname);
 459                 node = fdt_subnode_offset(blob, sig_node, name);
 460                 ret = rsa_verify_with_keynode(info, hash, sig, sig_len, node);
 461                 if (!ret)
 462                         return ret;
 463
 464                 /* No luck, so try each of the keys in turn */
 465                 for (ndepth = 0, noffset = fdt_next_node(info->fit, sig_node,
 466                                                          &ndepth);
 467                      (noffset >= 0) && (ndepth > 0);
 468                      noffset = fdt_next_node(info->fit, noffset, &ndepth)) {
 469                         if (ndepth == 1 && noffset != node) {
 470                                 ret = rsa_verify_with_keynode(info, hash,
 471                                                               sig, sig_len,
 472                                                               noffset);
 473                                 if (!ret)
 474                                         break;
 475                         }
 476                 }
 477         }
 478
 479         return ret;
 480 }