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