1/* 2 * Copyright 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "attestation_record.h" 18 19#include <assert.h> 20 21#include <openssl/asn1t.h> 22 23#include "openssl_err.h" 24#include "openssl_utils.h" 25 26#include <keymaster/android_keymaster_utils.h> 27#include <keymaster/keymaster_context.h> 28 29namespace keymaster { 30 31namespace { 32 33bool Uint64ToBignum(uint64_t value, BIGNUM* bn) { 34 static_assert(sizeof(unsigned long) == sizeof(uint64_t) || 35 sizeof(unsigned long) == sizeof(uint32_t), 36 "Only 32 and 64-bit platforms supported"); 37 38 if (sizeof(unsigned long) == sizeof(uint64_t)) { 39 return BN_set_word(bn, value); 40 } else if (sizeof(unsigned long) == sizeof(uint32_t)) { 41 uint32_t low_order = value & 0xFFFFFFFF; 42 uint32_t high_order = value >> 32; 43 return BN_set_word(bn, high_order) && // 44 BN_lshift(bn, bn, 32) && // 45 BN_add_word(bn, low_order); 46 } else { 47 return false; 48 } 49} 50 51} // anonymous namespace 52 53struct stack_st_ASN1_TYPE_Delete { 54 void operator()(stack_st_ASN1_TYPE* p) { sk_ASN1_TYPE_free(p); } 55}; 56 57struct ASN1_STRING_Delete { 58 void operator()(ASN1_STRING* p) { ASN1_STRING_free(p); } 59}; 60 61struct ASN1_TYPE_Delete { 62 void operator()(ASN1_TYPE* p) { ASN1_TYPE_free(p); } 63}; 64 65#define ASN1_INTEGER_SET STACK_OF(ASN1_INTEGER) 66 67typedef struct km_root_of_trust { 68 ASN1_OCTET_STRING* verified_boot_key; 69 ASN1_BOOLEAN* device_locked; 70 ASN1_ENUMERATED* verified_boot_state; 71} KM_ROOT_OF_TRUST; 72 73ASN1_SEQUENCE(KM_ROOT_OF_TRUST) = { 74 ASN1_SIMPLE(KM_ROOT_OF_TRUST, verified_boot_key, ASN1_OCTET_STRING), 75 ASN1_SIMPLE(KM_ROOT_OF_TRUST, device_locked, ASN1_BOOLEAN), 76 ASN1_SIMPLE(KM_ROOT_OF_TRUST, verified_boot_state, ASN1_ENUMERATED), 77} ASN1_SEQUENCE_END(KM_ROOT_OF_TRUST); 78IMPLEMENT_ASN1_FUNCTIONS(KM_ROOT_OF_TRUST); 79 80typedef struct km_auth_list { 81 ASN1_INTEGER_SET* purpose; 82 ASN1_INTEGER* algorithm; 83 ASN1_INTEGER* key_size; 84 ASN1_INTEGER_SET* digest; 85 ASN1_INTEGER_SET* padding; 86 ASN1_INTEGER_SET* kdf; 87 ASN1_INTEGER* ec_curve; 88 ASN1_INTEGER* rsa_public_exponent; 89 ASN1_INTEGER* active_date_time; 90 ASN1_INTEGER* origination_expire_date_time; 91 ASN1_INTEGER* usage_expire_date_time; 92 ASN1_NULL* no_auth_required; 93 ASN1_INTEGER* user_auth_type; 94 ASN1_INTEGER* auth_timeout; 95 ASN1_NULL* allow_while_on_body; 96 ASN1_NULL* all_applications; 97 ASN1_OCTET_STRING* application_id; 98 ASN1_INTEGER* creation_date_time; 99 ASN1_INTEGER* origin; 100 ASN1_NULL* rollback_resistant; 101 KM_ROOT_OF_TRUST* root_of_trust; 102 ASN1_INTEGER* os_version; 103 ASN1_INTEGER* os_patchlevel; 104} KM_AUTH_LIST; 105 106ASN1_SEQUENCE(KM_AUTH_LIST) = { 107 ASN1_EXP_SET_OF_OPT(KM_AUTH_LIST, purpose, ASN1_INTEGER, TAG_PURPOSE.masked_tag()), 108 ASN1_EXP_OPT(KM_AUTH_LIST, algorithm, ASN1_INTEGER, TAG_ALGORITHM.masked_tag()), 109 ASN1_EXP_OPT(KM_AUTH_LIST, key_size, ASN1_INTEGER, TAG_KEY_SIZE.masked_tag()), 110 ASN1_EXP_SET_OF_OPT(KM_AUTH_LIST, digest, ASN1_INTEGER, TAG_DIGEST.masked_tag()), 111 ASN1_EXP_SET_OF_OPT(KM_AUTH_LIST, padding, ASN1_INTEGER, TAG_PADDING.masked_tag()), 112 ASN1_EXP_SET_OF_OPT(KM_AUTH_LIST, kdf, ASN1_INTEGER, TAG_KDF.masked_tag()), 113 ASN1_EXP_OPT(KM_AUTH_LIST, ec_curve, ASN1_INTEGER, TAG_EC_CURVE.masked_tag()), 114 ASN1_EXP_OPT(KM_AUTH_LIST, rsa_public_exponent, ASN1_INTEGER, 115 TAG_RSA_PUBLIC_EXPONENT.masked_tag()), 116 ASN1_EXP_OPT(KM_AUTH_LIST, active_date_time, ASN1_INTEGER, TAG_ACTIVE_DATETIME.masked_tag()), 117 ASN1_EXP_OPT(KM_AUTH_LIST, origination_expire_date_time, ASN1_INTEGER, 118 TAG_ORIGINATION_EXPIRE_DATETIME.masked_tag()), 119 ASN1_EXP_OPT(KM_AUTH_LIST, usage_expire_date_time, ASN1_INTEGER, 120 TAG_USAGE_EXPIRE_DATETIME.masked_tag()), 121 ASN1_EXP_OPT(KM_AUTH_LIST, no_auth_required, ASN1_NULL, TAG_NO_AUTH_REQUIRED.masked_tag()), 122 ASN1_EXP_OPT(KM_AUTH_LIST, user_auth_type, ASN1_INTEGER, TAG_USER_AUTH_TYPE.masked_tag()), 123 ASN1_EXP_OPT(KM_AUTH_LIST, auth_timeout, ASN1_INTEGER, TAG_AUTH_TIMEOUT.masked_tag()), 124 ASN1_EXP_OPT(KM_AUTH_LIST, allow_while_on_body, ASN1_NULL, 125 TAG_ALLOW_WHILE_ON_BODY.masked_tag()), 126 ASN1_EXP_OPT(KM_AUTH_LIST, all_applications, ASN1_NULL, TAG_ALL_APPLICATIONS.masked_tag()), 127 ASN1_EXP_OPT(KM_AUTH_LIST, application_id, ASN1_OCTET_STRING, TAG_APPLICATION_ID.masked_tag()), 128 ASN1_EXP_OPT(KM_AUTH_LIST, creation_date_time, ASN1_INTEGER, 129 TAG_CREATION_DATETIME.masked_tag()), 130 ASN1_EXP_OPT(KM_AUTH_LIST, origin, ASN1_INTEGER, TAG_ORIGIN.masked_tag()), 131 ASN1_EXP_OPT(KM_AUTH_LIST, rollback_resistant, ASN1_NULL, TAG_ROLLBACK_RESISTANT.masked_tag()), 132 ASN1_EXP_OPT(KM_AUTH_LIST, root_of_trust, KM_ROOT_OF_TRUST, TAG_ROOT_OF_TRUST.masked_tag()), 133 ASN1_EXP_OPT(KM_AUTH_LIST, os_version, ASN1_INTEGER, TAG_OS_VERSION.masked_tag()), 134 ASN1_EXP_OPT(KM_AUTH_LIST, os_patchlevel, ASN1_INTEGER, TAG_OS_PATCHLEVEL.masked_tag()), 135} ASN1_SEQUENCE_END(KM_AUTH_LIST); 136IMPLEMENT_ASN1_FUNCTIONS(KM_AUTH_LIST); 137 138typedef struct km_key_description { 139 ASN1_INTEGER* attestation_version; 140 ASN1_ENUMERATED* attestation_security_level; 141 ASN1_INTEGER* keymaster_version; 142 ASN1_ENUMERATED* keymaster_security_level; 143 ASN1_OCTET_STRING* attestation_challenge; 144 KM_AUTH_LIST* software_enforced; 145 KM_AUTH_LIST* tee_enforced; 146 ASN1_INTEGER* unique_id; 147} KM_KEY_DESCRIPTION; 148 149ASN1_SEQUENCE(KM_KEY_DESCRIPTION) = { 150 ASN1_SIMPLE(KM_KEY_DESCRIPTION, attestation_version, ASN1_INTEGER), 151 ASN1_SIMPLE(KM_KEY_DESCRIPTION, attestation_security_level, ASN1_ENUMERATED), 152 ASN1_SIMPLE(KM_KEY_DESCRIPTION, keymaster_version, ASN1_INTEGER), 153 ASN1_SIMPLE(KM_KEY_DESCRIPTION, keymaster_security_level, ASN1_ENUMERATED), 154 ASN1_SIMPLE(KM_KEY_DESCRIPTION, attestation_challenge, ASN1_OCTET_STRING), 155 ASN1_SIMPLE(KM_KEY_DESCRIPTION, unique_id, ASN1_OCTET_STRING), 156 ASN1_SIMPLE(KM_KEY_DESCRIPTION, software_enforced, KM_AUTH_LIST), 157 ASN1_SIMPLE(KM_KEY_DESCRIPTION, tee_enforced, KM_AUTH_LIST), 158} ASN1_SEQUENCE_END(KM_KEY_DESCRIPTION); 159IMPLEMENT_ASN1_FUNCTIONS(KM_KEY_DESCRIPTION); 160 161struct KM_AUTH_LIST_Delete { 162 void operator()(KM_AUTH_LIST* p) { KM_AUTH_LIST_free(p); } 163}; 164 165struct KM_KEY_DESCRIPTION_Delete { 166 void operator()(KM_KEY_DESCRIPTION* p) { KM_KEY_DESCRIPTION_free(p); } 167}; 168 169static uint32_t get_uint32_value(const keymaster_key_param_t& param) { 170 switch (keymaster_tag_get_type(param.tag)) { 171 case KM_ENUM: 172 case KM_ENUM_REP: 173 return param.enumerated; 174 case KM_UINT: 175 case KM_UINT_REP: 176 return param.integer; 177 default: 178 assert(false); 179 return 0xFFFFFFFF; 180 } 181} 182 183// Insert value in either the dest_integer or the dest_integer_set, whichever is provided. 184static keymaster_error_t insert_integer(ASN1_INTEGER* value, ASN1_INTEGER** dest_integer, 185 ASN1_INTEGER_SET** dest_integer_set) { 186 assert((dest_integer == nullptr) ^ (dest_integer_set == nullptr)); 187 assert(value); 188 189 if (dest_integer_set) { 190 if (!*dest_integer_set) 191 *dest_integer_set = sk_ASN1_INTEGER_new_null(); 192 if (!*dest_integer_set) 193 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 194 if (!sk_ASN1_INTEGER_push(*dest_integer_set, value)) 195 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 196 return KM_ERROR_OK; 197 198 } else if (dest_integer) { 199 if (*dest_integer) 200 ASN1_INTEGER_free(*dest_integer); 201 *dest_integer = value; 202 return KM_ERROR_OK; 203 } 204 205 assert(false); // Should never get here. 206 return KM_ERROR_OK; 207} 208 209// Put the contents of the keymaster AuthorizationSet auth_list in to the ASN.1 record structure, 210// record. 211static keymaster_error_t build_auth_list(const AuthorizationSet& auth_list, KM_AUTH_LIST* record) { 212 assert(record); 213 214 if (auth_list.empty()) 215 return KM_ERROR_OK; 216 217 for (auto entry : auth_list) { 218 219 ASN1_INTEGER_SET** integer_set = nullptr; 220 ASN1_INTEGER** integer_ptr = nullptr; 221 ASN1_OCTET_STRING** string_ptr = nullptr; 222 ASN1_NULL** bool_ptr = nullptr; 223 224 switch (entry.tag) { 225 226 /* Ignored tags */ 227 case KM_TAG_INVALID: 228 case KM_TAG_ASSOCIATED_DATA: 229 case KM_TAG_NONCE: 230 case KM_TAG_AUTH_TOKEN: 231 case KM_TAG_MAC_LENGTH: 232 case KM_TAG_ALL_USERS: 233 case KM_TAG_USER_ID: 234 case KM_TAG_USER_SECURE_ID: 235 case KM_TAG_EXPORTABLE: 236 case KM_TAG_RESET_SINCE_ID_ROTATION: 237 case KM_TAG_ATTESTATION_CHALLENGE: 238 case KM_TAG_BLOCK_MODE: 239 case KM_TAG_CALLER_NONCE: 240 case KM_TAG_MIN_MAC_LENGTH: 241 case KM_TAG_ECIES_SINGLE_HASH_MODE: 242 case KM_TAG_INCLUDE_UNIQUE_ID: 243 case KM_TAG_BLOB_USAGE_REQUIREMENTS: 244 case KM_TAG_BOOTLOADER_ONLY: 245 case KM_TAG_MIN_SECONDS_BETWEEN_OPS: 246 case KM_TAG_MAX_USES_PER_BOOT: 247 case KM_TAG_APPLICATION_DATA: 248 case KM_TAG_UNIQUE_ID: 249 case KM_TAG_ROOT_OF_TRUST: 250 continue; 251 252 /* Non-repeating enumerations */ 253 case KM_TAG_ALGORITHM: 254 integer_ptr = &record->algorithm; 255 break; 256 case KM_TAG_EC_CURVE: 257 integer_ptr = &record->ec_curve; 258 break; 259 case KM_TAG_USER_AUTH_TYPE: 260 integer_ptr = &record->user_auth_type; 261 break; 262 case KM_TAG_ORIGIN: 263 integer_ptr = &record->origin; 264 break; 265 266 /* Repeating enumerations */ 267 case KM_TAG_PURPOSE: 268 integer_set = &record->purpose; 269 break; 270 case KM_TAG_PADDING: 271 integer_set = &record->padding; 272 break; 273 case KM_TAG_DIGEST: 274 integer_set = &record->digest; 275 break; 276 case KM_TAG_KDF: 277 integer_set = &record->kdf; 278 break; 279 280 /* Non-repeating unsigned integers */ 281 case KM_TAG_KEY_SIZE: 282 integer_ptr = &record->key_size; 283 break; 284 case KM_TAG_AUTH_TIMEOUT: 285 integer_ptr = &record->auth_timeout; 286 break; 287 case KM_TAG_OS_VERSION: 288 integer_ptr = &record->os_version; 289 break; 290 case KM_TAG_OS_PATCHLEVEL: 291 integer_ptr = &record->os_patchlevel; 292 break; 293 294 /* Non-repeating long unsigned integers */ 295 case KM_TAG_RSA_PUBLIC_EXPONENT: 296 integer_ptr = &record->rsa_public_exponent; 297 break; 298 299 /* Dates */ 300 case KM_TAG_ACTIVE_DATETIME: 301 integer_ptr = &record->active_date_time; 302 break; 303 case KM_TAG_ORIGINATION_EXPIRE_DATETIME: 304 integer_ptr = &record->origination_expire_date_time; 305 break; 306 case KM_TAG_USAGE_EXPIRE_DATETIME: 307 integer_ptr = &record->usage_expire_date_time; 308 break; 309 case KM_TAG_CREATION_DATETIME: 310 integer_ptr = &record->creation_date_time; 311 break; 312 313 /* Booleans */ 314 case KM_TAG_NO_AUTH_REQUIRED: 315 bool_ptr = &record->no_auth_required; 316 break; 317 case KM_TAG_ALL_APPLICATIONS: 318 bool_ptr = &record->all_applications; 319 break; 320 case KM_TAG_ROLLBACK_RESISTANT: 321 bool_ptr = &record->rollback_resistant; 322 break; 323 case KM_TAG_ALLOW_WHILE_ON_BODY: 324 bool_ptr = &record->allow_while_on_body; 325 break; 326 327 /* Byte arrays*/ 328 case KM_TAG_APPLICATION_ID: 329 string_ptr = &record->application_id; 330 break; 331 } 332 333 keymaster_tag_type_t type = keymaster_tag_get_type(entry.tag); 334 switch (type) { 335 case KM_ENUM: 336 case KM_ENUM_REP: 337 case KM_UINT: 338 case KM_UINT_REP: { 339 assert((keymaster_tag_repeatable(entry.tag) && integer_set) || 340 (!keymaster_tag_repeatable(entry.tag) && integer_ptr)); 341 342 UniquePtr<ASN1_INTEGER, ASN1_INTEGER_Delete> value(ASN1_INTEGER_new()); 343 if (!value.get()) 344 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 345 if (!ASN1_INTEGER_set(value.get(), get_uint32_value(entry))) 346 return TranslateLastOpenSslError(); 347 348 insert_integer(value.release(), integer_ptr, integer_set); 349 break; 350 } 351 352 case KM_ULONG: 353 case KM_ULONG_REP: 354 case KM_DATE: { 355 assert((keymaster_tag_repeatable(entry.tag) && integer_set) || 356 (!keymaster_tag_repeatable(entry.tag) && integer_ptr)); 357 358 UniquePtr<BIGNUM, BIGNUM_Delete> bn_value(BN_new()); 359 if (!bn_value.get()) 360 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 361 362 if (type == KM_DATE) { 363 if (!Uint64ToBignum(entry.date_time, bn_value.get())) { 364 return TranslateLastOpenSslError(); 365 } 366 } else { 367 if (!Uint64ToBignum(entry.long_integer, bn_value.get())) { 368 return TranslateLastOpenSslError(); 369 } 370 } 371 372 UniquePtr<ASN1_INTEGER, ASN1_INTEGER_Delete> value( 373 BN_to_ASN1_INTEGER(bn_value.get(), nullptr)); 374 if (!value.get()) 375 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 376 377 insert_integer(value.release(), integer_ptr, integer_set); 378 break; 379 } 380 381 case KM_BOOL: 382 assert(bool_ptr); 383 if (!*bool_ptr) 384 *bool_ptr = ASN1_NULL_new(); 385 if (!*bool_ptr) 386 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 387 break; 388 389 /* Byte arrays*/ 390 case KM_BYTES: 391 assert(string_ptr); 392 if (!*string_ptr) 393 *string_ptr = ASN1_OCTET_STRING_new(); 394 if (!*string_ptr) 395 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 396 if (!ASN1_OCTET_STRING_set(*string_ptr, entry.blob.data, entry.blob.data_length)) 397 return TranslateLastOpenSslError(); 398 break; 399 400 default: 401 return KM_ERROR_UNIMPLEMENTED; 402 } 403 } 404 405 keymaster_ec_curve_t ec_curve; 406 uint32_t key_size; 407 if (auth_list.Contains(TAG_ALGORITHM, KM_ALGORITHM_EC) && // 408 !auth_list.Contains(TAG_EC_CURVE) && // 409 auth_list.GetTagValue(TAG_KEY_SIZE, &key_size)) { 410 // This must be a keymaster1 key. It's an EC key with no curve. Insert the curve. 411 412 keymaster_error_t error = EcKeySizeToCurve(key_size, &ec_curve); 413 if (error != KM_ERROR_OK) 414 return error; 415 416 UniquePtr<ASN1_INTEGER, ASN1_INTEGER_Delete> value(ASN1_INTEGER_new()); 417 if (!value.get()) 418 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 419 420 if (!ASN1_INTEGER_set(value.get(), ec_curve)) 421 return TranslateLastOpenSslError(); 422 423 insert_integer(value.release(), &record->ec_curve, nullptr); 424 } 425 426 return KM_ERROR_OK; 427} 428 429// Construct an ASN1.1 DER-encoded attestation record containing the values from sw_enforced and 430// tee_enforced. 431keymaster_error_t build_attestation_record(const AuthorizationSet& attestation_params, 432 const AuthorizationSet& sw_enforced, 433 const AuthorizationSet& tee_enforced, 434 const KeymasterContext& context, 435 UniquePtr<uint8_t[]>* asn1_key_desc, 436 size_t* asn1_key_desc_len) { 437 assert(asn1_key_desc && asn1_key_desc_len); 438 439 UniquePtr<KM_KEY_DESCRIPTION, KM_KEY_DESCRIPTION_Delete> key_desc(KM_KEY_DESCRIPTION_new()); 440 if (!key_desc.get()) 441 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 442 443 keymaster_security_level_t keymaster_security_level; 444 uint32_t keymaster_version = UINT32_MAX; 445 if (tee_enforced.empty()) { 446 // Software key. 447 keymaster_security_level = KM_SECURITY_LEVEL_SOFTWARE; 448 keymaster_version = 2; 449 } else { 450 keymaster_security_level = KM_SECURITY_LEVEL_TRUSTED_ENVIRONMENT; 451 switch (context.GetSecurityLevel()) { 452 case KM_SECURITY_LEVEL_TRUSTED_ENVIRONMENT: 453 // We're running in a TEE, so the key is KM2. 454 keymaster_version = 2; 455 break; 456 457 case KM_SECURITY_LEVEL_SOFTWARE: 458 // We're running in software, wrapping some KM hardware. Is it KM0 or KM1? KM1 keys 459 // have the purpose in the tee_enforced list. It's possible that a key could be created 460 // without a purpose, which would fool this test into reporting it's a KM0 key. That 461 // corner case doesn't matter much, because purpose-less keys are not usable anyway. 462 // Also, KM1 TEEs should disappear rapidly. 463 keymaster_version = tee_enforced.Contains(TAG_PURPOSE) ? 1 : 0; 464 break; 465 } 466 467 if (keymaster_version == UINT32_MAX) 468 return KM_ERROR_UNKNOWN_ERROR; 469 } 470 471 if (!ASN1_INTEGER_set(key_desc->attestation_version, 1) || 472 !ASN1_ENUMERATED_set(key_desc->attestation_security_level, context.GetSecurityLevel()) || 473 !ASN1_INTEGER_set(key_desc->keymaster_version, keymaster_version) || 474 !ASN1_ENUMERATED_set(key_desc->keymaster_security_level, keymaster_security_level)) 475 return TranslateLastOpenSslError(); 476 477 keymaster_blob_t attestation_challenge = {nullptr, 0}; 478 if (!attestation_params.GetTagValue(TAG_ATTESTATION_CHALLENGE, &attestation_challenge)) 479 return KM_ERROR_ATTESTATION_CHALLENGE_MISSING; 480 if (!ASN1_OCTET_STRING_set(key_desc->attestation_challenge, attestation_challenge.data, 481 attestation_challenge.data_length)) 482 return TranslateLastOpenSslError(); 483 484 keymaster_error_t error = build_auth_list(sw_enforced, key_desc->software_enforced); 485 if (error != KM_ERROR_OK) 486 return error; 487 488 error = build_auth_list(tee_enforced, key_desc->tee_enforced); 489 if (error != KM_ERROR_OK) 490 return error; 491 492 // Only check tee_enforced for TAG_INCLUDE_UNIQUE_ID. If we don't have hardware we can't 493 // generate unique IDs. 494 if (tee_enforced.GetTagValue(TAG_INCLUDE_UNIQUE_ID)) { 495 uint64_t creation_datetime; 496 // Only check sw_enforced for TAG_CREATION_DATETIME, since it shouldn't be in tee_enforced, 497 // since this implementation has no secure wall clock. 498 if (!sw_enforced.GetTagValue(TAG_CREATION_DATETIME, &creation_datetime)) { 499 LOG_E("Unique ID cannot be created without creation datetime", 0); 500 return KM_ERROR_INVALID_KEY_BLOB; 501 } 502 503 keymaster_blob_t application_id = {nullptr, 0}; 504 sw_enforced.GetTagValue(TAG_APPLICATION_ID, &application_id); 505 506 Buffer unique_id; 507 error = context.GenerateUniqueId( 508 creation_datetime, application_id, 509 attestation_params.GetTagValue(TAG_RESET_SINCE_ID_ROTATION), &unique_id); 510 if (error != KM_ERROR_OK) 511 return error; 512 513 key_desc->unique_id = ASN1_OCTET_STRING_new(); 514 if (!key_desc->unique_id || 515 !ASN1_OCTET_STRING_set(key_desc->unique_id, unique_id.peek_read(), 516 unique_id.available_read())) 517 return TranslateLastOpenSslError(); 518 } 519 520 int len = i2d_KM_KEY_DESCRIPTION(key_desc.get(), nullptr); 521 if (len < 0) 522 return TranslateLastOpenSslError(); 523 *asn1_key_desc_len = len; 524 asn1_key_desc->reset(new uint8_t[*asn1_key_desc_len]); 525 if (!asn1_key_desc->get()) 526 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 527 uint8_t* p = asn1_key_desc->get(); 528 len = i2d_KM_KEY_DESCRIPTION(key_desc.get(), &p); 529 if (len < 0) 530 return TranslateLastOpenSslError(); 531 532 return KM_ERROR_OK; 533} 534 535// Copy all enumerated values with the specified tag from stack to auth_list. 536static bool get_repeated_enums(const stack_st_ASN1_INTEGER* stack, keymaster_tag_t tag, 537 AuthorizationSet* auth_list) { 538 assert(keymaster_tag_get_type(tag) == KM_ENUM_REP); 539 for (size_t i = 0; i < sk_ASN1_INTEGER_num(stack); ++i) { 540 if (!auth_list->push_back( 541 keymaster_param_enum(tag, ASN1_INTEGER_get(sk_ASN1_INTEGER_value(stack, i))))) 542 return false; 543 } 544 return true; 545} 546 547// Add the specified integer tag/value pair to auth_list. 548template <keymaster_tag_type_t Type, keymaster_tag_t Tag, typename KeymasterEnum> 549static bool get_enum(const ASN1_INTEGER* asn1_int, TypedEnumTag<Type, Tag, KeymasterEnum> tag, 550 AuthorizationSet* auth_list) { 551 if (!asn1_int) 552 return true; 553 return auth_list->push_back(tag, static_cast<KeymasterEnum>(ASN1_INTEGER_get(asn1_int))); 554} 555 556// Add the specified ulong tag/value pair to auth_list. 557static bool get_ulong(const ASN1_INTEGER* asn1_int, keymaster_tag_t tag, 558 AuthorizationSet* auth_list) { 559 if (!asn1_int) 560 return true; 561 UniquePtr<BIGNUM, BIGNUM_Delete> bn(ASN1_INTEGER_to_BN(asn1_int, nullptr)); 562 if (!bn.get()) 563 return false; 564 uint64_t ulong = BN_get_word(bn.get()); 565 return auth_list->push_back(keymaster_param_long(tag, ulong)); 566} 567 568// Extract the values from the specified ASN.1 record and place them in auth_list. 569static keymaster_error_t extract_auth_list(const KM_AUTH_LIST* record, 570 AuthorizationSet* auth_list) { 571 if (!record) 572 return KM_ERROR_OK; 573 574 // Purpose 575 if (!get_repeated_enums(record->purpose, TAG_PURPOSE, auth_list)) 576 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 577 578 // Algorithm 579 if (!get_enum(record->algorithm, TAG_ALGORITHM, auth_list)) 580 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 581 582 // Key size 583 if (record->key_size && !auth_list->push_back(TAG_KEY_SIZE, ASN1_INTEGER_get(record->key_size))) 584 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 585 586 // Digest 587 if (!get_repeated_enums(record->digest, TAG_DIGEST, auth_list)) 588 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 589 590 // Padding 591 if (!get_repeated_enums(record->padding, TAG_PADDING, auth_list)) 592 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 593 594 // EC curve 595 if (!get_enum(record->ec_curve, TAG_EC_CURVE, auth_list)) 596 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 597 598 // RSA public exponent 599 if (!get_ulong(record->rsa_public_exponent, TAG_RSA_PUBLIC_EXPONENT, auth_list)) 600 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 601 602 // Active date time 603 if (!get_ulong(record->active_date_time, TAG_ACTIVE_DATETIME, auth_list)) 604 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 605 606 // Origination expire date time 607 if (!get_ulong(record->origination_expire_date_time, TAG_ORIGINATION_EXPIRE_DATETIME, 608 auth_list)) 609 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 610 611 // Usage Expire date time 612 if (!get_ulong(record->usage_expire_date_time, TAG_USAGE_EXPIRE_DATETIME, auth_list)) 613 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 614 615 // No auth required 616 if (record->no_auth_required && !auth_list->push_back(TAG_NO_AUTH_REQUIRED)) 617 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 618 619 // User auth type 620 if (!get_enum(record->user_auth_type, TAG_USER_AUTH_TYPE, auth_list)) 621 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 622 623 // Auth timeout 624 if (record->auth_timeout && 625 !auth_list->push_back(TAG_AUTH_TIMEOUT, ASN1_INTEGER_get(record->auth_timeout))) 626 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 627 628 // All applications 629 if (record->all_applications && !auth_list->push_back(TAG_ALL_APPLICATIONS)) 630 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 631 632 // Application ID 633 if (record->application_id && 634 !auth_list->push_back(TAG_APPLICATION_ID, record->application_id->data, 635 record->application_id->length)) 636 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 637 638 // Creation date time 639 if (!get_ulong(record->creation_date_time, TAG_CREATION_DATETIME, auth_list)) 640 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 641 642 // Origin 643 if (!get_enum(record->origin, TAG_ORIGIN, auth_list)) 644 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 645 646 // Rollback resistant 647 if (record->rollback_resistant && !auth_list->push_back(TAG_ROLLBACK_RESISTANT)) 648 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 649 650 // Root of trust 651 if (record->root_of_trust) { 652 KM_ROOT_OF_TRUST* rot = record->root_of_trust; 653 if (!rot->verified_boot_key) 654 return KM_ERROR_INVALID_KEY_BLOB; 655 656 // Other root of trust fields are not mapped to auth set entries. 657 } 658 659 // OS Version 660 if (record->os_version && 661 !auth_list->push_back(TAG_OS_VERSION, ASN1_INTEGER_get(record->os_version))) 662 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 663 664 // OS Patch level 665 if (record->os_patchlevel && 666 !auth_list->push_back(TAG_OS_PATCHLEVEL, ASN1_INTEGER_get(record->os_patchlevel))) 667 return KM_ERROR_MEMORY_ALLOCATION_FAILED; 668 669 return KM_ERROR_OK; 670} 671 672// Parse the DER-encoded attestation record, placing the results in keymaster_version, 673// attestation_challenge, software_enforced, tee_enforced and unique_id. 674keymaster_error_t parse_attestation_record(const uint8_t* asn1_key_desc, size_t asn1_key_desc_len, 675 uint32_t* attestation_version, // 676 keymaster_security_level_t* attestation_security_level, 677 uint32_t* keymaster_version, 678 keymaster_security_level_t* keymaster_security_level, 679 keymaster_blob_t* attestation_challenge, 680 AuthorizationSet* software_enforced, 681 AuthorizationSet* tee_enforced, 682 keymaster_blob_t* unique_id) { 683 const uint8_t* p = asn1_key_desc; 684 UniquePtr<KM_KEY_DESCRIPTION, KM_KEY_DESCRIPTION_Delete> record( 685 d2i_KM_KEY_DESCRIPTION(nullptr, &p, asn1_key_desc_len)); 686 if (!record.get()) 687 return TranslateLastOpenSslError(); 688 689 *attestation_version = ASN1_INTEGER_get(record->attestation_version); 690 *attestation_security_level = static_cast<keymaster_security_level_t>( 691 ASN1_ENUMERATED_get(record->attestation_security_level)); 692 *keymaster_version = ASN1_INTEGER_get(record->keymaster_version); 693 *keymaster_security_level = static_cast<keymaster_security_level_t>( 694 ASN1_ENUMERATED_get(record->keymaster_security_level)); 695 696 attestation_challenge->data = 697 dup_buffer(record->attestation_challenge->data, record->attestation_challenge->length); 698 attestation_challenge->data_length = record->attestation_challenge->length; 699 700 unique_id->data = dup_buffer(record->unique_id->data, record->unique_id->length); 701 unique_id->data_length = record->unique_id->length; 702 703 keymaster_error_t error = extract_auth_list(record->software_enforced, software_enforced); 704 if (error != KM_ERROR_OK) 705 return error; 706 707 return extract_auth_list(record->tee_enforced, tee_enforced); 708} 709 710} // namepace keymaster 711