blob: a6538c4e5cad510bf45e365cccae157d7b8fac22 [file] [log] [blame]
Juan Castillo8e55d932015-04-02 09:48:16 +01001/*
Ambroise Vincenta88a35d2019-02-14 09:48:21 +00002 * Copyright (c) 2015-2019, ARM Limited and Contributors. All rights reserved.
Juan Castillo8e55d932015-04-02 09:48:16 +01003 *
dp-armfa3cf0b2017-05-03 09:38:09 +01004 * SPDX-License-Identifier: BSD-3-Clause
Juan Castillo8e55d932015-04-02 09:48:16 +01005 */
6
7#include <assert.h>
Juan Castillo8e55d932015-04-02 09:48:16 +01008#include <stdint.h>
9#include <string.h>
10
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000011#include <platform_def.h>
12
13#include <common/debug.h>
14#include <common/tbbr/cot_def.h>
15#include <drivers/auth/auth_common.h>
16#include <drivers/auth/auth_mod.h>
17#include <drivers/auth/crypto_mod.h>
18#include <drivers/auth/img_parser_mod.h>
19#include <plat/common/platform.h>
20
Juan Castillobfb7fa62016-01-22 11:05:57 +000021/* ASN.1 tags */
22#define ASN1_INTEGER 0x02
23
Juan Castillo8e55d932015-04-02 09:48:16 +010024#define return_if_error(rc) \
25 do { \
26 if (rc != 0) { \
27 return rc; \
28 } \
29 } while (0)
30
dp-armb3e85802016-12-12 14:48:13 +000031#pragma weak plat_set_nv_ctr2
32
Joel Huttone9919bb2019-02-20 11:56:46 +000033/* Pointer to CoT */
Sandrine Bailleux25532c72019-06-07 14:33:51 +020034extern const auth_img_desc_t *const *const cot_desc_ptr;
Joel Huttone9919bb2019-02-20 11:56:46 +000035extern unsigned int auth_img_flags[MAX_NUMBER_IDS];
36
Juan Castillo8e55d932015-04-02 09:48:16 +010037static int cmp_auth_param_type_desc(const auth_param_type_desc_t *a,
38 const auth_param_type_desc_t *b)
39{
40 if ((a->type == b->type) && (a->cookie == b->cookie)) {
41 return 0;
42 }
43 return 1;
44}
45
46/*
47 * This function obtains the requested authentication parameter data from the
48 * information extracted from the parent image after its authentication.
49 */
50static int auth_get_param(const auth_param_type_desc_t *param_type_desc,
51 const auth_img_desc_t *img_desc,
52 void **param, unsigned int *len)
53{
54 int i;
55
Joel Hutton69931af2019-03-11 11:37:38 +000056 if (img_desc->authenticated_data == NULL)
57 return 1;
58
Juan Castillo8e55d932015-04-02 09:48:16 +010059 for (i = 0 ; i < COT_MAX_VERIFIED_PARAMS ; i++) {
60 if (0 == cmp_auth_param_type_desc(param_type_desc,
61 img_desc->authenticated_data[i].type_desc)) {
62 *param = img_desc->authenticated_data[i].data.ptr;
63 *len = img_desc->authenticated_data[i].data.len;
64 return 0;
65 }
66 }
67
68 return 1;
69}
70
71/*
72 * Authenticate an image by matching the data hash
73 *
74 * This function implements 'AUTH_METHOD_HASH'. To authenticate an image using
75 * this method, the image must contain:
76 *
77 * - The data to calculate the hash from
78 *
79 * The parent image must contain:
80 *
81 * - The hash to be matched with (including hash algorithm)
82 *
83 * For a successful authentication, both hashes must match. The function calls
84 * the crypto-module to check this matching.
85 *
86 * Parameters:
87 * param: parameters to perform the hash authentication
88 * img_desc: pointer to image descriptor so we can know the image type
89 * and parent image
90 * img: pointer to image in memory
91 * img_len: length of image (in bytes)
92 *
93 * Return:
94 * 0 = success, Otherwise = error
95 */
96static int auth_hash(const auth_method_param_hash_t *param,
97 const auth_img_desc_t *img_desc,
98 void *img, unsigned int img_len)
99{
100 void *data_ptr, *hash_der_ptr;
101 unsigned int data_len, hash_der_len;
102 int rc = 0;
103
104 /* Get the hash from the parent image. This hash will be DER encoded
105 * and contain the hash algorithm */
106 rc = auth_get_param(param->hash, img_desc->parent,
107 &hash_der_ptr, &hash_der_len);
108 return_if_error(rc);
109
110 /* Get the data to be hashed from the current image */
111 rc = img_parser_get_auth_param(img_desc->img_type, param->data,
112 img, img_len, &data_ptr, &data_len);
113 return_if_error(rc);
114
115 /* Ask the crypto module to verify this hash */
116 rc = crypto_mod_verify_hash(data_ptr, data_len,
117 hash_der_ptr, hash_der_len);
118
119 return rc;
120}
121
122/*
123 * Authenticate by digital signature
124 *
125 * This function implements 'AUTH_METHOD_SIG'. To authenticate an image using
126 * this method, the image must contain:
127 *
128 * - Data to be signed
129 * - Signature
130 * - Signature algorithm
131 *
132 * We rely on the image parser module to extract this data from the image.
133 * The parent image must contain:
134 *
135 * - Public key (or a hash of it)
136 *
137 * If the parent image contains only a hash of the key, we will try to obtain
138 * the public key from the image itself (i.e. self-signed certificates). In that
139 * case, the signature verification is considered just an integrity check and
140 * the authentication is established by calculating the hash of the key and
141 * comparing it with the hash obtained from the parent.
142 *
143 * If the image has no parent (NULL), it means it has to be authenticated using
144 * the ROTPK stored in the platform. Again, this ROTPK could be the key itself
145 * or a hash of it.
146 *
147 * Return: 0 = success, Otherwise = error
148 */
149static int auth_signature(const auth_method_param_sig_t *param,
150 const auth_img_desc_t *img_desc,
151 void *img, unsigned int img_len)
152{
153 void *data_ptr, *pk_ptr, *pk_hash_ptr, *sig_ptr, *sig_alg_ptr;
154 unsigned int data_len, pk_len, pk_hash_len, sig_len, sig_alg_len;
155 unsigned int flags = 0;
156 int rc = 0;
157
158 /* Get the data to be signed from current image */
159 rc = img_parser_get_auth_param(img_desc->img_type, param->data,
160 img, img_len, &data_ptr, &data_len);
161 return_if_error(rc);
162
163 /* Get the signature from current image */
164 rc = img_parser_get_auth_param(img_desc->img_type, param->sig,
165 img, img_len, &sig_ptr, &sig_len);
166 return_if_error(rc);
167
168 /* Get the signature algorithm from current image */
169 rc = img_parser_get_auth_param(img_desc->img_type, param->alg,
170 img, img_len, &sig_alg_ptr, &sig_alg_len);
171 return_if_error(rc);
172
173 /* Get the public key from the parent. If there is no parent (NULL),
174 * the certificate has been signed with the ROTPK, so we have to get
175 * the PK from the platform */
176 if (img_desc->parent) {
177 rc = auth_get_param(param->pk, img_desc->parent,
178 &pk_ptr, &pk_len);
179 } else {
180 rc = plat_get_rotpk_info(param->pk->cookie, &pk_ptr, &pk_len,
181 &flags);
182 }
183 return_if_error(rc);
184
Soby Mathew2f7ed052016-05-24 15:05:15 +0100185 if (flags & (ROTPK_IS_HASH | ROTPK_NOT_DEPLOYED)) {
186 /* If the PK is a hash of the key or if the ROTPK is not
187 deployed on the platform, retrieve the key from the image */
Juan Castillo8e55d932015-04-02 09:48:16 +0100188 pk_hash_ptr = pk_ptr;
189 pk_hash_len = pk_len;
190 rc = img_parser_get_auth_param(img_desc->img_type,
191 param->pk, img, img_len,
192 &pk_ptr, &pk_len);
193 return_if_error(rc);
194
195 /* Ask the crypto module to verify the signature */
196 rc = crypto_mod_verify_signature(data_ptr, data_len,
197 sig_ptr, sig_len,
198 sig_alg_ptr, sig_alg_len,
199 pk_ptr, pk_len);
200 return_if_error(rc);
201
Soby Mathew2f7ed052016-05-24 15:05:15 +0100202 if (flags & ROTPK_NOT_DEPLOYED) {
203 NOTICE("ROTPK is not deployed on platform. "
204 "Skipping ROTPK verification.\n");
205 } else {
206 /* Ask the crypto-module to verify the key hash */
207 rc = crypto_mod_verify_hash(pk_ptr, pk_len,
208 pk_hash_ptr, pk_hash_len);
209 }
Juan Castillo8e55d932015-04-02 09:48:16 +0100210 } else {
211 /* Ask the crypto module to verify the signature */
212 rc = crypto_mod_verify_signature(data_ptr, data_len,
213 sig_ptr, sig_len,
214 sig_alg_ptr, sig_alg_len,
215 pk_ptr, pk_len);
216 }
217
218 return rc;
219}
220
221/*
Juan Castillobfb7fa62016-01-22 11:05:57 +0000222 * Authenticate by Non-Volatile counter
223 *
224 * To protect the system against rollback, the platform includes a non-volatile
225 * counter whose value can only be increased. All certificates include a counter
226 * value that should not be lower than the value stored in the platform. If the
227 * value is larger, the counter in the platform must be updated to the new
228 * value.
229 *
230 * Return: 0 = success, Otherwise = error
231 */
232static int auth_nvctr(const auth_method_param_nv_ctr_t *param,
233 const auth_img_desc_t *img_desc,
234 void *img, unsigned int img_len)
235{
236 char *p;
237 void *data_ptr = NULL;
238 unsigned int data_len, len, i;
239 unsigned int cert_nv_ctr, plat_nv_ctr;
240 int rc = 0;
241
242 /* Get the counter value from current image. The AM expects the IPM
243 * to return the counter value as a DER encoded integer */
244 rc = img_parser_get_auth_param(img_desc->img_type, param->cert_nv_ctr,
245 img, img_len, &data_ptr, &data_len);
246 return_if_error(rc);
247
248 /* Parse the DER encoded integer */
249 assert(data_ptr);
250 p = (char *)data_ptr;
251 if (*p != ASN1_INTEGER) {
252 /* Invalid ASN.1 integer */
253 return 1;
254 }
255 p++;
256
257 /* NV-counters are unsigned integers up to 32-bit */
258 len = (unsigned int)(*p & 0x7f);
259 if ((*p & 0x80) || (len > 4)) {
260 return 1;
261 }
262 p++;
263
264 /* Check the number is not negative */
265 if (*p & 0x80) {
266 return 1;
267 }
268
269 /* Convert to unsigned int. This code is for a little-endian CPU */
270 cert_nv_ctr = 0;
271 for (i = 0; i < len; i++) {
272 cert_nv_ctr = (cert_nv_ctr << 8) | *p++;
273 }
274
275 /* Get the counter from the platform */
276 rc = plat_get_nv_ctr(param->plat_nv_ctr->cookie, &plat_nv_ctr);
277 return_if_error(rc);
278
279 if (cert_nv_ctr < plat_nv_ctr) {
280 /* Invalid NV-counter */
281 return 1;
282 } else if (cert_nv_ctr > plat_nv_ctr) {
dp-armb3e85802016-12-12 14:48:13 +0000283 rc = plat_set_nv_ctr2(param->plat_nv_ctr->cookie,
284 img_desc, cert_nv_ctr);
285 return_if_error(rc);
Juan Castillobfb7fa62016-01-22 11:05:57 +0000286 }
287
288 return 0;
289}
290
dp-armb3e85802016-12-12 14:48:13 +0000291int plat_set_nv_ctr2(void *cookie, const auth_img_desc_t *img_desc __unused,
292 unsigned int nv_ctr)
293{
294 return plat_set_nv_ctr(cookie, nv_ctr);
295}
296
Juan Castillobfb7fa62016-01-22 11:05:57 +0000297/*
Juan Castillo8e55d932015-04-02 09:48:16 +0100298 * Return the parent id in the output parameter '*parent_id'
299 *
300 * Return value:
301 * 0 = Image has parent, 1 = Image has no parent or parent is authenticated
302 */
303int auth_mod_get_parent_id(unsigned int img_id, unsigned int *parent_id)
304{
305 const auth_img_desc_t *img_desc = NULL;
306
307 assert(parent_id != NULL);
308
309 /* Get the image descriptor */
Joel Huttone9919bb2019-02-20 11:56:46 +0000310 img_desc = cot_desc_ptr[img_id];
Juan Castillo8e55d932015-04-02 09:48:16 +0100311
312 /* Check if the image has no parent (ROT) */
313 if (img_desc->parent == NULL) {
314 *parent_id = 0;
315 return 1;
316 }
317
318 /* Check if the parent has already been authenticated */
319 if (auth_img_flags[img_desc->parent->img_id] & IMG_FLAG_AUTHENTICATED) {
320 *parent_id = 0;
321 return 1;
322 }
323
324 *parent_id = img_desc->parent->img_id;
325 return 0;
326}
327
328/*
329 * Initialize the different modules in the authentication framework
330 */
331void auth_mod_init(void)
332{
333 /* Check we have a valid CoT registered */
334 assert(cot_desc_ptr != NULL);
335
336 /* Crypto module */
337 crypto_mod_init();
338
339 /* Image parser module */
340 img_parser_init();
341}
342
343/*
344 * Authenticate a certificate/image
345 *
346 * Return: 0 = success, Otherwise = error
347 */
348int auth_mod_verify_img(unsigned int img_id,
349 void *img_ptr,
350 unsigned int img_len)
351{
352 const auth_img_desc_t *img_desc = NULL;
353 const auth_method_desc_t *auth_method = NULL;
354 void *param_ptr;
355 unsigned int param_len;
356 int rc, i;
357
358 /* Get the image descriptor from the chain of trust */
Joel Huttone9919bb2019-02-20 11:56:46 +0000359 img_desc = cot_desc_ptr[img_id];
Juan Castillo8e55d932015-04-02 09:48:16 +0100360
361 /* Ask the parser to check the image integrity */
362 rc = img_parser_check_integrity(img_desc->img_type, img_ptr, img_len);
363 return_if_error(rc);
364
365 /* Authenticate the image using the methods indicated in the image
366 * descriptor. */
Joel Hutton8634cff2019-04-09 09:25:55 +0100367 if (img_desc->img_auth_methods == NULL)
Joel Hutton69931af2019-03-11 11:37:38 +0000368 return 1;
Juan Castillo8e55d932015-04-02 09:48:16 +0100369 for (i = 0 ; i < AUTH_METHOD_NUM ; i++) {
370 auth_method = &img_desc->img_auth_methods[i];
371 switch (auth_method->type) {
372 case AUTH_METHOD_NONE:
373 rc = 0;
374 break;
375 case AUTH_METHOD_HASH:
376 rc = auth_hash(&auth_method->param.hash,
377 img_desc, img_ptr, img_len);
378 break;
379 case AUTH_METHOD_SIG:
380 rc = auth_signature(&auth_method->param.sig,
381 img_desc, img_ptr, img_len);
382 break;
Juan Castillobfb7fa62016-01-22 11:05:57 +0000383 case AUTH_METHOD_NV_CTR:
384 rc = auth_nvctr(&auth_method->param.nv_ctr,
385 img_desc, img_ptr, img_len);
386 break;
Juan Castillo8e55d932015-04-02 09:48:16 +0100387 default:
388 /* Unknown authentication method */
389 rc = 1;
390 break;
391 }
392 return_if_error(rc);
393 }
394
395 /* Extract the parameters indicated in the image descriptor to
396 * authenticate the children images. */
Joel Hutton69931af2019-03-11 11:37:38 +0000397 if (img_desc->authenticated_data != NULL) {
398 for (i = 0 ; i < COT_MAX_VERIFIED_PARAMS ; i++) {
399 if (img_desc->authenticated_data[i].type_desc == NULL) {
400 continue;
401 }
Juan Castillo8e55d932015-04-02 09:48:16 +0100402
Joel Hutton69931af2019-03-11 11:37:38 +0000403 /* Get the parameter from the image parser module */
404 rc = img_parser_get_auth_param(img_desc->img_type,
405 img_desc->authenticated_data[i].type_desc,
406 img_ptr, img_len, &param_ptr, &param_len);
407 return_if_error(rc);
Juan Castillo8e55d932015-04-02 09:48:16 +0100408
Joel Hutton69931af2019-03-11 11:37:38 +0000409 /* Check parameter size */
410 if (param_len > img_desc->authenticated_data[i].data.len) {
411 return 1;
412 }
Juan Castillo8e55d932015-04-02 09:48:16 +0100413
Joel Hutton69931af2019-03-11 11:37:38 +0000414 /* Copy the parameter for later use */
415 memcpy((void *)img_desc->authenticated_data[i].data.ptr,
416 (void *)param_ptr, param_len);
417 }
Juan Castillo8e55d932015-04-02 09:48:16 +0100418 }
419
420 /* Mark image as authenticated */
421 auth_img_flags[img_desc->img_id] |= IMG_FLAG_AUTHENTICATED;
422
423 return 0;
424}