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 */
rsa_verify_padding(const uint8_t * msg,const int pad_len,struct checksum_algo * algo)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 /**
61 * rsa_verify_key() - Verify a signature against some data using RSA Key
62 *
63 * Verify a RSA PKCS1.5 signature against an expected hash using
64 * the RSA Key properties in prop structure.
65 *
66 * @prop: Specifies key
67 * @sig: Signature
68 * @sig_len: Number of bytes in signature
69 * @hash: Pointer to the expected hash
70 * @key_len: Number of bytes in rsa key
71 * @algo: Checksum algo structure having information on DER encoding etc.
72 * @return 0 if verified, -ve on error
73 */
rsa_verify_key(struct key_prop * prop,const uint8_t * sig,const uint32_t sig_len,const uint8_t * hash,const uint32_t key_len,struct checksum_algo * algo)74 static int rsa_verify_key(struct key_prop *prop, const uint8_t *sig,
75 const uint32_t sig_len, const uint8_t *hash,
76 const uint32_t key_len, struct checksum_algo *algo)
77 {
78 int pad_len;
79 int ret;
80 #if !defined(USE_HOSTCC)
81 struct udevice *mod_exp_dev;
82 #endif
83
84 if (!prop || !sig || !hash || !algo)
85 return -EIO;
86
87 if (sig_len != (prop->num_bits / 8)) {
88 debug("Signature is of incorrect length %d\n", sig_len);
89 return -EINVAL;
90 }
91
92 debug("Checksum algorithm: %s", algo->name);
93
94 /* Sanity check for stack size */
95 if (sig_len > RSA_MAX_SIG_BITS / 8) {
96 debug("Signature length %u exceeds maximum %d\n", sig_len,
97 RSA_MAX_SIG_BITS / 8);
98 return -EINVAL;
99 }
100
101 uint8_t buf[sig_len];
102
103 #if !defined(USE_HOSTCC)
104 ret = uclass_get_device(UCLASS_MOD_EXP, 0, &mod_exp_dev);
105 if (ret) {
106 printf("RSA: Can't find Modular Exp implementation\n");
107 return -EINVAL;
108 }
109
110 ret = rsa_mod_exp(mod_exp_dev, sig, sig_len, prop, buf);
111 #else
112 ret = rsa_mod_exp_sw(sig, sig_len, prop, buf);
113 #endif
114 if (ret) {
115 debug("Error in Modular exponentation\n");
116 return ret;
117 }
118
119 pad_len = key_len - algo->checksum_len;
120
121 /* Check pkcs1.5 padding bytes. */
122 ret = rsa_verify_padding(buf, pad_len, algo);
123 if (ret) {
124 debug("In RSAVerify(): Padding check failed!\n");
125 return -EINVAL;
126 }
127
128 /* Check hash. */
129 if (memcmp((uint8_t *)buf + pad_len, hash, sig_len - pad_len)) {
130 debug("In RSAVerify(): Hash check failed!\n");
131 return -EACCES;
132 }
133
134 return 0;
135 }
136
137 /**
138 * rsa_verify_with_keynode() - Verify a signature against some data using
139 * information in node with prperties of RSA Key like modulus, exponent etc.
140 *
141 * Parse sign-node and fill a key_prop structure with properties of the
142 * key. Verify a RSA PKCS1.5 signature against an expected hash using
143 * the properties parsed
144 *
145 * @info: Specifies key and FIT information
146 * @hash: Pointer to the expected hash
147 * @sig: Signature
148 * @sig_len: Number of bytes in signature
149 * @node: Node having the RSA Key properties
150 * @return 0 if verified, -ve on error
151 */
rsa_verify_with_keynode(struct image_sign_info * info,const void * hash,uint8_t * sig,uint sig_len,int node)152 static int rsa_verify_with_keynode(struct image_sign_info *info,
153 const void *hash, uint8_t *sig,
154 uint sig_len, int node)
155 {
156 const void *blob = info->fdt_blob;
157 struct key_prop prop;
158 int length;
159 int ret = 0;
160
161 if (node < 0) {
162 debug("%s: Skipping invalid node", __func__);
163 return -EBADF;
164 }
165
166 prop.num_bits = fdtdec_get_int(blob, node, "rsa,num-bits", 0);
167
168 prop.n0inv = fdtdec_get_int(blob, node, "rsa,n0-inverse", 0);
169
170 prop.public_exponent = fdt_getprop(blob, node, "rsa,exponent", &length);
171 if (!prop.public_exponent || length < sizeof(uint64_t))
172 prop.public_exponent = NULL;
173
174 prop.exp_len = sizeof(uint64_t);
175
176 prop.modulus = fdt_getprop(blob, node, "rsa,modulus", NULL);
177
178 prop.rr = fdt_getprop(blob, node, "rsa,r-squared", NULL);
179
180 if (!prop.num_bits || !prop.modulus) {
181 debug("%s: Missing RSA key info", __func__);
182 return -EFAULT;
183 }
184
185 ret = rsa_verify_key(&prop, sig, sig_len, hash,
186 info->crypto->key_len, info->checksum);
187
188 return ret;
189 }
190
rsa_verify(struct image_sign_info * info,const struct image_region region[],int region_count,uint8_t * sig,uint sig_len)191 int rsa_verify(struct image_sign_info *info,
192 const struct image_region region[], int region_count,
193 uint8_t *sig, uint sig_len)
194 {
195 const void *blob = info->fdt_blob;
196 /* Reserve memory for maximum checksum-length */
197 uint8_t hash[info->crypto->key_len];
198 int ndepth, noffset;
199 int sig_node, node;
200 char name[100];
201 int ret;
202
203 /*
204 * Verify that the checksum-length does not exceed the
205 * rsa-signature-length
206 */
207 if (info->checksum->checksum_len >
208 info->crypto->key_len) {
209 debug("%s: invlaid checksum-algorithm %s for %s\n",
210 __func__, info->checksum->name, info->crypto->name);
211 return -EINVAL;
212 }
213
214 sig_node = fdt_subnode_offset(blob, 0, FIT_SIG_NODENAME);
215 if (sig_node < 0) {
216 debug("%s: No signature node found\n", __func__);
217 return -ENOENT;
218 }
219
220 /* Calculate checksum with checksum-algorithm */
221 ret = info->checksum->calculate(info->checksum->name,
222 region, region_count, hash);
223 if (ret < 0) {
224 debug("%s: Error in checksum calculation\n", __func__);
225 return -EINVAL;
226 }
227
228 /* See if we must use a particular key */
229 if (info->required_keynode != -1) {
230 ret = rsa_verify_with_keynode(info, hash, sig, sig_len,
231 info->required_keynode);
232 if (!ret)
233 return ret;
234 }
235
236 /* Look for a key that matches our hint */
237 snprintf(name, sizeof(name), "key-%s", info->keyname);
238 node = fdt_subnode_offset(blob, sig_node, name);
239 ret = rsa_verify_with_keynode(info, hash, sig, sig_len, node);
240 if (!ret)
241 return ret;
242
243 /* No luck, so try each of the keys in turn */
244 for (ndepth = 0, noffset = fdt_next_node(info->fit, sig_node, &ndepth);
245 (noffset >= 0) && (ndepth > 0);
246 noffset = fdt_next_node(info->fit, noffset, &ndepth)) {
247 if (ndepth == 1 && noffset != node) {
248 ret = rsa_verify_with_keynode(info, hash, sig, sig_len,
249 noffset);
250 if (!ret)
251 break;
252 }
253 }
254
255 return ret;
256 }
257