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 <asm/types.h>
  10 #include <asm/byteorder.h>
  11 #include <linux/errno.h>
  12 #include <asm/types.h>
  13 #include <asm/unaligned.h>
  14 #include <dm.h>
  15 #else
  16 #include "fdt_host.h"
  17 #include "mkimage.h"
  18 #include <fdt_support.h>
  19 #endif
  20 #include <u-boot/rsa-mod-exp.h>
  21 #include <u-boot/rsa.h>
  22
  23 /* Default public exponent for backward compatibility */
  24 #define RSA_DEFAULT_PUBEXP      65537
  25
  26 /**
  27  * rsa_verify_padding() - Verify RSA message padding is valid
  28  *
  29  * Verify a RSA message's padding is consistent with PKCS1.5
  30  * padding as described in the RSA PKCS#1 v2.1 standard.
  31  *
  32  * @msg:        Padded message
  33  * @pad_len:    Number of expected padding bytes
  34  * @algo:       Checksum algo structure having information on DER encoding etc.
  35  * @return 0 on success, != 0 on failure
  36  */
  37 static int rsa_verify_padding(const uint8_t *msg, const int pad_len,
  38                               struct checksum_algo *algo)
  39 {
  40         int ff_len;
  41         int ret;
  42
  43         /* first byte must be 0x00 */
  44         ret = *msg++;
  45         /* second byte must be 0x01 */
  46         ret |= *msg++ ^ 0x01;
  47         /* next ff_len bytes must be 0xff */
  48         ff_len = pad_len - algo->der_len - 3;
  49         ret |= *msg ^ 0xff;
  50         ret |= memcmp(msg, msg+1, ff_len-1);
  51         msg += ff_len;
  52         /* next byte must be 0x00 */
  53         ret |= *msg++;
  54         /* next der_len bytes must match der_prefix */
  55         ret |= memcmp(msg, algo->der_prefix, algo->der_len);
  56
  57         return ret;
  58 }
  59
  60 int padding_pkcs_15_verify(struct image_sign_info *info,
  61                            uint8_t *msg, int msg_len,
  62                            const uint8_t *hash, int hash_len)
  63 {
  64         struct checksum_algo *checksum = info->checksum;
  65         int ret, pad_len = msg_len - checksum->checksum_len;
  66
  67         /* Check pkcs1.5 padding bytes. */
  68         ret = rsa_verify_padding(msg, pad_len, checksum);
  69         if (ret) {
  70                 debug("In RSAVerify(): Padding check failed!\n");
  71                 return -EINVAL;
  72         }
  73
  74         /* Check hash. */
  75         if (memcmp((uint8_t *)msg + pad_len, hash, msg_len - pad_len)) {
  76                 debug("In RSAVerify(): Hash check failed!\n");
  77                 return -EACCES;
  78         }
  79
  80         return 0;
  81 }
  82
  83 /**
  84  * rsa_verify_key() - Verify a signature against some data using RSA Key
  85  *
  86  * Verify a RSA PKCS1.5 signature against an expected hash using
  87  * the RSA Key properties in prop structure.
  88  *
  89  * @info:       Specifies key and FIT information
  90  * @prop:       Specifies key
  91  * @sig:        Signature
  92  * @sig_len:    Number of bytes in signature
  93  * @hash:       Pointer to the expected hash
  94  * @key_len:    Number of bytes in rsa key
  95  * @return 0 if verified, -ve on error
  96  */
  97 static int rsa_verify_key(struct image_sign_info *info,
  98                           struct key_prop *prop, const uint8_t *sig,
  99                           const uint32_t sig_len, const uint8_t *hash,
 100                           const uint32_t key_len)
 101 {
 102         int ret;
 103 #if !defined(USE_HOSTCC)
 104         struct udevice *mod_exp_dev;
 105 #endif
 106         struct checksum_algo *checksum = info->checksum;
 107         struct padding_algo *padding = info->padding;
 108         int hash_len = checksum->checksum_len;
 109
 110         if (!prop || !sig || !hash || !checksum)
 111                 return -EIO;
 112
 113         if (sig_len != (prop->num_bits / 8)) {
 114                 debug("Signature is of incorrect length %d\n", sig_len);
 115                 return -EINVAL;
 116         }
 117
 118         debug("Checksum algorithm: %s", checksum->name);
 119
 120         /* Sanity check for stack size */
 121         if (sig_len > RSA_MAX_SIG_BITS / 8) {
 122                 debug("Signature length %u exceeds maximum %d\n", sig_len,
 123                       RSA_MAX_SIG_BITS / 8);
 124                 return -EINVAL;
 125         }
 126
 127         uint8_t buf[sig_len];
 128
 129 #if !defined(USE_HOSTCC)
 130         ret = uclass_get_device(UCLASS_MOD_EXP, 0, &mod_exp_dev);
 131         if (ret) {
 132                 printf("RSA: Can't find Modular Exp implementation\n");
 133                 return -EINVAL;
 134         }
 135
 136         ret = rsa_mod_exp(mod_exp_dev, sig, sig_len, prop, buf);
 137 #else
 138         ret = rsa_mod_exp_sw(sig, sig_len, prop, buf);
 139 #endif
 140         if (ret) {
 141                 debug("Error in Modular exponentation\n");
 142                 return ret;
 143         }
 144
 145         ret = padding->verify(info, buf, key_len, hash, hash_len);
 146         if (ret) {
 147                 debug("In RSAVerify(): padding check failed!\n");
 148                 return ret;
 149         }
 150
 151         return 0;
 152 }
 153
 154 /**
 155  * rsa_verify_with_keynode() - Verify a signature against some data using
 156  * information in node with prperties of RSA Key like modulus, exponent etc.
 157  *
 158  * Parse sign-node and fill a key_prop structure with properties of the
 159  * key.  Verify a RSA PKCS1.5 signature against an expected hash using
 160  * the properties parsed
 161  *
 162  * @info:       Specifies key and FIT information
 163  * @hash:       Pointer to the expected hash
 164  * @sig:        Signature
 165  * @sig_len:    Number of bytes in signature
 166  * @node:       Node having the RSA Key properties
 167  * @return 0 if verified, -ve on error
 168  */
 169 static int rsa_verify_with_keynode(struct image_sign_info *info,
 170                                    const void *hash, uint8_t *sig,
 171                                    uint sig_len, int node)
 172 {
 173         const void *blob = info->fdt_blob;
 174         struct key_prop prop;
 175         int length;
 176         int ret = 0;
 177
 178         if (node < 0) {
 179                 debug("%s: Skipping invalid node", __func__);
 180                 return -EBADF;
 181         }
 182
 183         prop.num_bits = fdtdec_get_int(blob, node, "rsa,num-bits", 0);
 184
 185         prop.n0inv = fdtdec_get_int(blob, node, "rsa,n0-inverse", 0);
 186
 187         prop.public_exponent = fdt_getprop(blob, node, "rsa,exponent", &length);
 188         if (!prop.public_exponent || length < sizeof(uint64_t))
 189                 prop.public_exponent = NULL;
 190
 191         prop.exp_len = sizeof(uint64_t);
 192
 193         prop.modulus = fdt_getprop(blob, node, "rsa,modulus", NULL);
 194
 195         prop.rr = fdt_getprop(blob, node, "rsa,r-squared", NULL);
 196
 197         if (!prop.num_bits || !prop.modulus) {
 198                 debug("%s: Missing RSA key info", __func__);
 199                 return -EFAULT;
 200         }
 201
 202         ret = rsa_verify_key(info, &prop, sig, sig_len, hash,
 203                              info->crypto->key_len);
 204
 205         return ret;
 206 }
 207
 208 int rsa_verify(struct image_sign_info *info,
 209                const struct image_region region[], int region_count,
 210                uint8_t *sig, uint sig_len)
 211 {
 212         const void *blob = info->fdt_blob;
 213         /* Reserve memory for maximum checksum-length */
 214         uint8_t hash[info->crypto->key_len];
 215         int ndepth, noffset;
 216         int sig_node, node;
 217         char name[100];
 218         int ret;
 219
 220         /*
 221          * Verify that the checksum-length does not exceed the
 222          * rsa-signature-length
 223          */
 224         if (info->checksum->checksum_len >
 225             info->crypto->key_len) {
 226                 debug("%s: invlaid checksum-algorithm %s for %s\n",
 227                       __func__, info->checksum->name, info->crypto->name);
 228                 return -EINVAL;
 229         }
 230
 231         sig_node = fdt_subnode_offset(blob, 0, FIT_SIG_NODENAME);
 232         if (sig_node < 0) {
 233                 debug("%s: No signature node found\n", __func__);
 234                 return -ENOENT;
 235         }
 236
 237         /* Calculate checksum with checksum-algorithm */
 238         ret = info->checksum->calculate(info->checksum->name,
 239                                         region, region_count, hash);
 240         if (ret < 0) {
 241                 debug("%s: Error in checksum calculation\n", __func__);
 242                 return -EINVAL;
 243         }
 244
 245         /* See if we must use a particular key */
 246         if (info->required_keynode != -1) {
 247                 ret = rsa_verify_with_keynode(info, hash, sig, sig_len,
 248                         info->required_keynode);
 249                 if (!ret)
 250                         return ret;
 251         }
 252
 253         /* Look for a key that matches our hint */
 254         snprintf(name, sizeof(name), "key-%s", info->keyname);
 255         node = fdt_subnode_offset(blob, sig_node, name);
 256         ret = rsa_verify_with_keynode(info, hash, sig, sig_len, node);
 257         if (!ret)
 258                 return ret;
 259
 260         /* No luck, so try each of the keys in turn */
 261         for (ndepth = 0, noffset = fdt_next_node(info->fit, sig_node, &ndepth);
 262                         (noffset >= 0) && (ndepth > 0);
 263                         noffset = fdt_next_node(info->fit, noffset, &ndepth)) {
 264                 if (ndepth == 1 && noffset != node) {
 265                         ret = rsa_verify_with_keynode(info, hash, sig, sig_len,
 266                                                       noffset);
 267                         if (!ret)
 268                                 break;
 269                 }
 270         }
 271
 272         return ret;
 273 }