1 // SPDX-License-Identifier: BSD-2-Clause 2 /* 3 * Copyright (c) 2018-2020, Linaro Limited 4 */ 5 6 #include <pkcs11_ta.h> 7 #include <string.h> 8 #include <tee_internal_api.h> 9 #include <util.h> 10 11 #include "attributes.h" 12 #include "object.h" 13 #include "pkcs11_attributes.h" 14 #include "pkcs11_helpers.h" 15 16 static const char __maybe_unused unknown[] = "<unknown-identifier>"; 17 18 struct attr_size { 19 uint32_t id; 20 uint32_t size; 21 #if CFG_TEE_TA_LOG_LEVEL > 0 22 const char *string; 23 #endif 24 }; 25 26 #if CFG_TEE_TA_LOG_LEVEL > 0 27 #define PKCS11_ID_SZ(_id, _sz) \ 28 { .id = (uint32_t)(_id), .size = (_sz), .string = #_id } 29 #else 30 #define PKCS11_ID_SZ(_id, _sz) \ 31 { .id = (uint32_t)(_id), .size = (_sz) } 32 #endif 33 34 static const struct attr_size attr_ids[] = { 35 PKCS11_ID_SZ(PKCS11_CKA_CLASS, 4), 36 PKCS11_ID_SZ(PKCS11_CKA_KEY_TYPE, 4), 37 PKCS11_ID_SZ(PKCS11_CKA_VALUE, 0), 38 PKCS11_ID_SZ(PKCS11_CKA_VALUE_LEN, 4), 39 PKCS11_ID_SZ(PKCS11_CKA_LABEL, 0), 40 PKCS11_ID_SZ(PKCS11_CKA_WRAP_TEMPLATE, 0), 41 PKCS11_ID_SZ(PKCS11_CKA_UNWRAP_TEMPLATE, 0), 42 PKCS11_ID_SZ(PKCS11_CKA_DERIVE_TEMPLATE, 0), 43 PKCS11_ID_SZ(PKCS11_CKA_START_DATE, 4), 44 PKCS11_ID_SZ(PKCS11_CKA_END_DATE, 4), 45 PKCS11_ID_SZ(PKCS11_CKA_OBJECT_ID, 0), 46 PKCS11_ID_SZ(PKCS11_CKA_APPLICATION, 0), 47 PKCS11_ID_SZ(PKCS11_CKA_MECHANISM_TYPE, 4), 48 PKCS11_ID_SZ(PKCS11_CKA_ID, 0), 49 PKCS11_ID_SZ(PKCS11_CKA_ALLOWED_MECHANISMS, 0), 50 PKCS11_ID_SZ(PKCS11_CKA_EC_POINT, 0), 51 PKCS11_ID_SZ(PKCS11_CKA_EC_PARAMS, 0), 52 PKCS11_ID_SZ(PKCS11_CKA_MODULUS, 0), 53 PKCS11_ID_SZ(PKCS11_CKA_MODULUS_BITS, 4), 54 PKCS11_ID_SZ(PKCS11_CKA_PUBLIC_EXPONENT, 0), 55 PKCS11_ID_SZ(PKCS11_CKA_PRIVATE_EXPONENT, 0), 56 PKCS11_ID_SZ(PKCS11_CKA_PRIME_1, 0), 57 PKCS11_ID_SZ(PKCS11_CKA_PRIME_2, 0), 58 PKCS11_ID_SZ(PKCS11_CKA_EXPONENT_1, 0), 59 PKCS11_ID_SZ(PKCS11_CKA_EXPONENT_2, 0), 60 PKCS11_ID_SZ(PKCS11_CKA_COEFFICIENT, 0), 61 PKCS11_ID_SZ(PKCS11_CKA_SUBJECT, 0), 62 PKCS11_ID_SZ(PKCS11_CKA_PUBLIC_KEY_INFO, 0), 63 /* Below are boolean attributes */ 64 PKCS11_ID_SZ(PKCS11_CKA_TOKEN, 1), 65 PKCS11_ID_SZ(PKCS11_CKA_PRIVATE, 1), 66 PKCS11_ID_SZ(PKCS11_CKA_TRUSTED, 1), 67 PKCS11_ID_SZ(PKCS11_CKA_SENSITIVE, 1), 68 PKCS11_ID_SZ(PKCS11_CKA_ENCRYPT, 1), 69 PKCS11_ID_SZ(PKCS11_CKA_DECRYPT, 1), 70 PKCS11_ID_SZ(PKCS11_CKA_WRAP, 1), 71 PKCS11_ID_SZ(PKCS11_CKA_UNWRAP, 1), 72 PKCS11_ID_SZ(PKCS11_CKA_SIGN, 1), 73 PKCS11_ID_SZ(PKCS11_CKA_SIGN_RECOVER, 1), 74 PKCS11_ID_SZ(PKCS11_CKA_VERIFY, 1), 75 PKCS11_ID_SZ(PKCS11_CKA_VERIFY_RECOVER, 1), 76 PKCS11_ID_SZ(PKCS11_CKA_DERIVE, 1), 77 PKCS11_ID_SZ(PKCS11_CKA_EXTRACTABLE, 1), 78 PKCS11_ID_SZ(PKCS11_CKA_LOCAL, 1), 79 PKCS11_ID_SZ(PKCS11_CKA_NEVER_EXTRACTABLE, 1), 80 PKCS11_ID_SZ(PKCS11_CKA_ALWAYS_SENSITIVE, 1), 81 PKCS11_ID_SZ(PKCS11_CKA_MODIFIABLE, 1), 82 PKCS11_ID_SZ(PKCS11_CKA_COPYABLE, 1), 83 PKCS11_ID_SZ(PKCS11_CKA_DESTROYABLE, 1), 84 PKCS11_ID_SZ(PKCS11_CKA_ALWAYS_AUTHENTICATE, 1), 85 PKCS11_ID_SZ(PKCS11_CKA_WRAP_WITH_TRUSTED, 1), 86 /* Specific PKCS11 TA internal attribute ID */ 87 PKCS11_ID_SZ(PKCS11_CKA_UNDEFINED_ID, 0), 88 }; 89 90 struct any_id { 91 uint32_t id; 92 #if CFG_TEE_TA_LOG_LEVEL > 0 93 const char *string; 94 #endif 95 }; 96 97 /* 98 * Macro PKCS11_ID() can be used to define cells in ID list arrays 99 * or ID/string conversion arrays. 100 */ 101 #if CFG_TEE_TA_LOG_LEVEL > 0 102 #define PKCS11_ID(_id) { .id = _id, .string = #_id } 103 #else 104 #define PKCS11_ID(_id) { .id = _id } 105 #endif 106 107 #define ID2STR(id, table, prefix) \ 108 id2str(id, table, ARRAY_SIZE(table), prefix) 109 110 #if CFG_TEE_TA_LOG_LEVEL > 0 111 /* Convert a PKCS11 ID into its label string */ 112 static const char *id2str(uint32_t id, const struct any_id *table, 113 size_t count, const char *prefix) 114 { 115 size_t n = 0; 116 const char *str = NULL; 117 118 for (n = 0; n < count; n++) { 119 if (id != table[n].id) 120 continue; 121 122 str = table[n].string; 123 124 /* Skip prefix provided matches found */ 125 if (prefix && !TEE_MemCompare(str, prefix, strlen(prefix))) 126 str += strlen(prefix); 127 128 return str; 129 } 130 131 return unknown; 132 } 133 #endif /* CFG_TEE_TA_LOG_LEVEL > 0 */ 134 135 /* 136 * TA command IDs: used only as ID/string conversion for debug trace support 137 */ 138 static const struct any_id __maybe_unused string_ta_cmd[] = { 139 PKCS11_ID(PKCS11_CMD_PING), 140 PKCS11_ID(PKCS11_CMD_SLOT_LIST), 141 PKCS11_ID(PKCS11_CMD_SLOT_INFO), 142 PKCS11_ID(PKCS11_CMD_TOKEN_INFO), 143 PKCS11_ID(PKCS11_CMD_MECHANISM_IDS), 144 PKCS11_ID(PKCS11_CMD_MECHANISM_INFO), 145 PKCS11_ID(PKCS11_CMD_OPEN_SESSION), 146 PKCS11_ID(PKCS11_CMD_SESSION_INFO), 147 PKCS11_ID(PKCS11_CMD_CLOSE_SESSION), 148 PKCS11_ID(PKCS11_CMD_CLOSE_ALL_SESSIONS), 149 PKCS11_ID(PKCS11_CMD_INIT_TOKEN), 150 PKCS11_ID(PKCS11_CMD_INIT_PIN), 151 PKCS11_ID(PKCS11_CMD_SET_PIN), 152 PKCS11_ID(PKCS11_CMD_LOGIN), 153 PKCS11_ID(PKCS11_CMD_LOGOUT), 154 PKCS11_ID(PKCS11_CMD_CREATE_OBJECT), 155 PKCS11_ID(PKCS11_CMD_DESTROY_OBJECT), 156 PKCS11_ID(PKCS11_CMD_ENCRYPT_INIT), 157 PKCS11_ID(PKCS11_CMD_DECRYPT_INIT), 158 PKCS11_ID(PKCS11_CMD_ENCRYPT_UPDATE), 159 PKCS11_ID(PKCS11_CMD_DECRYPT_UPDATE), 160 PKCS11_ID(PKCS11_CMD_ENCRYPT_FINAL), 161 PKCS11_ID(PKCS11_CMD_DECRYPT_FINAL), 162 PKCS11_ID(PKCS11_CMD_ENCRYPT_ONESHOT), 163 PKCS11_ID(PKCS11_CMD_DECRYPT_ONESHOT), 164 }; 165 166 static const struct any_id __maybe_unused string_slot_flags[] = { 167 PKCS11_ID(PKCS11_CKFS_TOKEN_PRESENT), 168 PKCS11_ID(PKCS11_CKFS_REMOVABLE_DEVICE), 169 PKCS11_ID(PKCS11_CKFS_HW_SLOT), 170 }; 171 172 static const struct any_id __maybe_unused string_token_flags[] = { 173 PKCS11_ID(PKCS11_CKFT_RNG), 174 PKCS11_ID(PKCS11_CKFT_WRITE_PROTECTED), 175 PKCS11_ID(PKCS11_CKFT_LOGIN_REQUIRED), 176 PKCS11_ID(PKCS11_CKFT_USER_PIN_INITIALIZED), 177 PKCS11_ID(PKCS11_CKFT_RESTORE_KEY_NOT_NEEDED), 178 PKCS11_ID(PKCS11_CKFT_CLOCK_ON_TOKEN), 179 PKCS11_ID(PKCS11_CKFT_PROTECTED_AUTHENTICATION_PATH), 180 PKCS11_ID(PKCS11_CKFT_DUAL_CRYPTO_OPERATIONS), 181 PKCS11_ID(PKCS11_CKFT_TOKEN_INITIALIZED), 182 PKCS11_ID(PKCS11_CKFT_USER_PIN_COUNT_LOW), 183 PKCS11_ID(PKCS11_CKFT_USER_PIN_FINAL_TRY), 184 PKCS11_ID(PKCS11_CKFT_USER_PIN_LOCKED), 185 PKCS11_ID(PKCS11_CKFT_USER_PIN_TO_BE_CHANGED), 186 PKCS11_ID(PKCS11_CKFT_SO_PIN_COUNT_LOW), 187 PKCS11_ID(PKCS11_CKFT_SO_PIN_FINAL_TRY), 188 PKCS11_ID(PKCS11_CKFT_SO_PIN_LOCKED), 189 PKCS11_ID(PKCS11_CKFT_SO_PIN_TO_BE_CHANGED), 190 PKCS11_ID(PKCS11_CKFT_ERROR_STATE), 191 }; 192 193 static const struct any_id __maybe_unused string_session_flags[] = { 194 PKCS11_ID(PKCS11_CKFSS_RW_SESSION), 195 PKCS11_ID(PKCS11_CKFSS_SERIAL_SESSION), 196 }; 197 198 static const struct any_id __maybe_unused string_session_state[] = { 199 PKCS11_ID(PKCS11_CKS_RO_PUBLIC_SESSION), 200 PKCS11_ID(PKCS11_CKS_RO_USER_FUNCTIONS), 201 PKCS11_ID(PKCS11_CKS_RW_PUBLIC_SESSION), 202 PKCS11_ID(PKCS11_CKS_RW_USER_FUNCTIONS), 203 PKCS11_ID(PKCS11_CKS_RW_SO_FUNCTIONS), 204 }; 205 206 static const struct any_id __maybe_unused string_rc[] = { 207 PKCS11_ID(PKCS11_CKR_OK), 208 PKCS11_ID(PKCS11_CKR_GENERAL_ERROR), 209 PKCS11_ID(PKCS11_CKR_DEVICE_MEMORY), 210 PKCS11_ID(PKCS11_CKR_ARGUMENTS_BAD), 211 PKCS11_ID(PKCS11_CKR_BUFFER_TOO_SMALL), 212 PKCS11_ID(PKCS11_CKR_FUNCTION_FAILED), 213 PKCS11_ID(PKCS11_CKR_SIGNATURE_INVALID), 214 PKCS11_ID(PKCS11_CKR_ATTRIBUTE_TYPE_INVALID), 215 PKCS11_ID(PKCS11_CKR_ATTRIBUTE_VALUE_INVALID), 216 PKCS11_ID(PKCS11_CKR_OBJECT_HANDLE_INVALID), 217 PKCS11_ID(PKCS11_CKR_KEY_HANDLE_INVALID), 218 PKCS11_ID(PKCS11_CKR_MECHANISM_INVALID), 219 PKCS11_ID(PKCS11_CKR_SESSION_HANDLE_INVALID), 220 PKCS11_ID(PKCS11_CKR_SLOT_ID_INVALID), 221 PKCS11_ID(PKCS11_CKR_MECHANISM_PARAM_INVALID), 222 PKCS11_ID(PKCS11_CKR_TEMPLATE_INCONSISTENT), 223 PKCS11_ID(PKCS11_CKR_TEMPLATE_INCOMPLETE), 224 PKCS11_ID(PKCS11_CKR_PIN_INCORRECT), 225 PKCS11_ID(PKCS11_CKR_PIN_LOCKED), 226 PKCS11_ID(PKCS11_CKR_PIN_EXPIRED), 227 PKCS11_ID(PKCS11_CKR_PIN_INVALID), 228 PKCS11_ID(PKCS11_CKR_PIN_LEN_RANGE), 229 PKCS11_ID(PKCS11_CKR_SESSION_EXISTS), 230 PKCS11_ID(PKCS11_CKR_SESSION_READ_ONLY), 231 PKCS11_ID(PKCS11_CKR_SESSION_READ_WRITE_SO_EXISTS), 232 PKCS11_ID(PKCS11_CKR_OPERATION_ACTIVE), 233 PKCS11_ID(PKCS11_CKR_KEY_FUNCTION_NOT_PERMITTED), 234 PKCS11_ID(PKCS11_CKR_OPERATION_NOT_INITIALIZED), 235 PKCS11_ID(PKCS11_CKR_TOKEN_WRITE_PROTECTED), 236 PKCS11_ID(PKCS11_CKR_TOKEN_NOT_PRESENT), 237 PKCS11_ID(PKCS11_CKR_TOKEN_NOT_RECOGNIZED), 238 PKCS11_ID(PKCS11_CKR_ACTION_PROHIBITED), 239 PKCS11_ID(PKCS11_CKR_ATTRIBUTE_READ_ONLY), 240 PKCS11_ID(PKCS11_CKR_PIN_TOO_WEAK), 241 PKCS11_ID(PKCS11_CKR_CURVE_NOT_SUPPORTED), 242 PKCS11_ID(PKCS11_CKR_DOMAIN_PARAMS_INVALID), 243 PKCS11_ID(PKCS11_CKR_USER_ALREADY_LOGGED_IN), 244 PKCS11_ID(PKCS11_CKR_USER_ANOTHER_ALREADY_LOGGED_IN), 245 PKCS11_ID(PKCS11_CKR_USER_NOT_LOGGED_IN), 246 PKCS11_ID(PKCS11_CKR_USER_PIN_NOT_INITIALIZED), 247 PKCS11_ID(PKCS11_CKR_USER_TOO_MANY_TYPES), 248 PKCS11_ID(PKCS11_CKR_USER_TYPE_INVALID), 249 PKCS11_ID(PKCS11_CKR_SESSION_READ_ONLY_EXISTS), 250 PKCS11_ID(PKCS11_RV_NOT_FOUND), 251 PKCS11_ID(PKCS11_RV_NOT_IMPLEMENTED), 252 }; 253 254 static const struct any_id __maybe_unused string_class[] = { 255 PKCS11_ID(PKCS11_CKO_SECRET_KEY), 256 PKCS11_ID(PKCS11_CKO_PUBLIC_KEY), 257 PKCS11_ID(PKCS11_CKO_PRIVATE_KEY), 258 PKCS11_ID(PKCS11_CKO_OTP_KEY), 259 PKCS11_ID(PKCS11_CKO_CERTIFICATE), 260 PKCS11_ID(PKCS11_CKO_DATA), 261 PKCS11_ID(PKCS11_CKO_DOMAIN_PARAMETERS), 262 PKCS11_ID(PKCS11_CKO_HW_FEATURE), 263 PKCS11_ID(PKCS11_CKO_MECHANISM), 264 PKCS11_ID(PKCS11_CKO_UNDEFINED_ID) 265 }; 266 267 static const struct any_id __maybe_unused string_key_type[] = { 268 PKCS11_ID(PKCS11_CKK_AES), 269 PKCS11_ID(PKCS11_CKK_GENERIC_SECRET), 270 PKCS11_ID(PKCS11_CKK_MD5_HMAC), 271 PKCS11_ID(PKCS11_CKK_SHA_1_HMAC), 272 PKCS11_ID(PKCS11_CKK_SHA224_HMAC), 273 PKCS11_ID(PKCS11_CKK_SHA256_HMAC), 274 PKCS11_ID(PKCS11_CKK_SHA384_HMAC), 275 PKCS11_ID(PKCS11_CKK_SHA512_HMAC), 276 PKCS11_ID(PKCS11_CKK_EC), 277 PKCS11_ID(PKCS11_CKK_RSA), 278 PKCS11_ID(PKCS11_CKK_UNDEFINED_ID) 279 }; 280 281 /* 282 * Processing IDs not exported in the TA API. 283 * PKCS11_CKM_* mechanism IDs are looked up from mechanism_string_id(). 284 */ 285 static const struct any_id __maybe_unused string_internal_processing[] = { 286 PKCS11_ID(PKCS11_PROCESSING_IMPORT), 287 }; 288 289 static const struct any_id __maybe_unused string_functions[] = { 290 PKCS11_ID(PKCS11_FUNCTION_IMPORT), 291 }; 292 293 /* 294 * Conversion between PKCS11 TA and GPD TEE return codes 295 */ 296 enum pkcs11_rc tee2pkcs_error(TEE_Result res) 297 { 298 switch (res) { 299 case TEE_SUCCESS: 300 return PKCS11_CKR_OK; 301 302 case TEE_ERROR_BAD_PARAMETERS: 303 return PKCS11_CKR_ARGUMENTS_BAD; 304 305 case TEE_ERROR_OUT_OF_MEMORY: 306 return PKCS11_CKR_DEVICE_MEMORY; 307 308 case TEE_ERROR_SHORT_BUFFER: 309 return PKCS11_CKR_BUFFER_TOO_SMALL; 310 311 case TEE_ERROR_MAC_INVALID: 312 case TEE_ERROR_SIGNATURE_INVALID: 313 return PKCS11_CKR_SIGNATURE_INVALID; 314 315 default: 316 return PKCS11_CKR_GENERAL_ERROR; 317 } 318 } 319 320 /* 321 * Helper functions to analyse PKCS11 identifiers 322 */ 323 324 /* Check attribute ID is known and size matches if fixed */ 325 bool valid_pkcs11_attribute_id(uint32_t id, uint32_t size) 326 { 327 size_t n = 0; 328 329 for (n = 0; n < ARRAY_SIZE(attr_ids); n++) 330 if (id == attr_ids[n].id) 331 return !attr_ids[n].size || size == attr_ids[n].size; 332 333 return false; 334 } 335 336 size_t pkcs11_attr_is_type(uint32_t attribute_id) 337 { 338 enum pkcs11_attr_id id = attribute_id; 339 340 switch (id) { 341 case PKCS11_CKA_KEY_TYPE: 342 case PKCS11_CKA_MECHANISM_TYPE: 343 case PKCS11_CKA_KEY_GEN_MECHANISM: 344 return sizeof(uint32_t); 345 default: 346 return 0; 347 } 348 } 349 350 bool pkcs11_class_has_type(uint32_t class) 351 { 352 enum pkcs11_class_id class_id = class; 353 354 switch (class_id) { 355 case PKCS11_CKO_CERTIFICATE: 356 case PKCS11_CKO_PUBLIC_KEY: 357 case PKCS11_CKO_PRIVATE_KEY: 358 case PKCS11_CKO_SECRET_KEY: 359 case PKCS11_CKO_MECHANISM: 360 case PKCS11_CKO_HW_FEATURE: 361 return true; 362 default: 363 return false; 364 } 365 } 366 367 bool pkcs11_attr_class_is_key(uint32_t class) 368 { 369 enum pkcs11_class_id class_id = class; 370 371 switch (class_id) { 372 case PKCS11_CKO_SECRET_KEY: 373 case PKCS11_CKO_PUBLIC_KEY: 374 case PKCS11_CKO_PRIVATE_KEY: 375 return true; 376 default: 377 return false; 378 } 379 } 380 381 bool key_type_is_symm_key(uint32_t id) 382 { 383 enum pkcs11_key_type key_type = id; 384 385 switch (key_type) { 386 case PKCS11_CKK_AES: 387 case PKCS11_CKK_GENERIC_SECRET: 388 case PKCS11_CKK_MD5_HMAC: 389 case PKCS11_CKK_SHA_1_HMAC: 390 case PKCS11_CKK_SHA224_HMAC: 391 case PKCS11_CKK_SHA256_HMAC: 392 case PKCS11_CKK_SHA384_HMAC: 393 case PKCS11_CKK_SHA512_HMAC: 394 return true; 395 default: 396 return false; 397 } 398 } 399 400 bool key_type_is_asymm_key(uint32_t id) 401 { 402 enum pkcs11_key_type key_type = id; 403 404 switch (key_type) { 405 case PKCS11_CKK_EC: 406 case PKCS11_CKK_RSA: 407 return true; 408 default: 409 return false; 410 } 411 } 412 413 /* 414 * Returns shift position or -1 on error. 415 * Mainly used when PKCS11_SHEAD_WITH_BOOLPROPS is enabled 416 */ 417 int pkcs11_attr2boolprop_shift(uint32_t attr) 418 { 419 static const uint32_t bpa[] = { 420 [BPA_TOKEN] = PKCS11_CKA_TOKEN, 421 [BPA_PRIVATE] = PKCS11_CKA_PRIVATE, 422 [BPA_TRUSTED] = PKCS11_CKA_TRUSTED, 423 [BPA_SENSITIVE] = PKCS11_CKA_SENSITIVE, 424 [BPA_ENCRYPT] = PKCS11_CKA_ENCRYPT, 425 [BPA_DECRYPT] = PKCS11_CKA_DECRYPT, 426 [BPA_WRAP] = PKCS11_CKA_WRAP, 427 [BPA_UNWRAP] = PKCS11_CKA_UNWRAP, 428 [BPA_SIGN] = PKCS11_CKA_SIGN, 429 [BPA_SIGN_RECOVER] = PKCS11_CKA_SIGN_RECOVER, 430 [BPA_VERIFY] = PKCS11_CKA_VERIFY, 431 [BPA_VERIFY_RECOVER] = PKCS11_CKA_VERIFY_RECOVER, 432 [BPA_DERIVE] = PKCS11_CKA_DERIVE, 433 [BPA_EXTRACTABLE] = PKCS11_CKA_EXTRACTABLE, 434 [BPA_LOCAL] = PKCS11_CKA_LOCAL, 435 [BPA_NEVER_EXTRACTABLE] = PKCS11_CKA_NEVER_EXTRACTABLE, 436 [BPA_ALWAYS_SENSITIVE] = PKCS11_CKA_ALWAYS_SENSITIVE, 437 [BPA_MODIFIABLE] = PKCS11_CKA_MODIFIABLE, 438 [BPA_COPYABLE] = PKCS11_CKA_COPYABLE, 439 [BPA_DESTROYABLE] = PKCS11_CKA_DESTROYABLE, 440 [BPA_ALWAYS_AUTHENTICATE] = PKCS11_CKA_ALWAYS_AUTHENTICATE, 441 [BPA_WRAP_WITH_TRUSTED] = PKCS11_CKA_WRAP_WITH_TRUSTED, 442 }; 443 size_t pos = 0; 444 445 for (pos = 0; pos < ARRAY_SIZE(bpa); pos++) 446 if (bpa[pos] == attr) 447 return (int)pos; 448 449 return -1; 450 } 451 452 /* Initialize a TEE attribute for a target PKCS11 TA attribute in an object */ 453 bool pkcs2tee_load_attr(TEE_Attribute *tee_ref, uint32_t tee_id, 454 struct pkcs11_object *obj, 455 enum pkcs11_attr_id pkcs11_id) 456 { 457 void *a_ptr = NULL; 458 uint32_t a_size = 0; 459 460 if (get_attribute_ptr(obj->attributes, pkcs11_id, &a_ptr, &a_size)) 461 return false; 462 463 TEE_InitRefAttribute(tee_ref, tee_id, a_ptr, a_size); 464 465 return true; 466 } 467 468 /* Easy conversion between PKCS11 TA function of TEE crypto mode */ 469 void pkcs2tee_mode(uint32_t *tee_id, enum processing_func function) 470 { 471 switch (function) { 472 case PKCS11_FUNCTION_ENCRYPT: 473 *tee_id = TEE_MODE_ENCRYPT; 474 break; 475 case PKCS11_FUNCTION_DECRYPT: 476 *tee_id = TEE_MODE_DECRYPT; 477 break; 478 case PKCS11_FUNCTION_SIGN: 479 *tee_id = TEE_MODE_SIGN; 480 break; 481 case PKCS11_FUNCTION_VERIFY: 482 *tee_id = TEE_MODE_VERIFY; 483 break; 484 case PKCS11_FUNCTION_DERIVE: 485 *tee_id = TEE_MODE_DERIVE; 486 break; 487 default: 488 TEE_Panic(function); 489 } 490 } 491 492 #if CFG_TEE_TA_LOG_LEVEL > 0 493 const char *id2str_rc(uint32_t id) 494 { 495 return ID2STR(id, string_rc, "PKCS11_CKR_"); 496 } 497 498 const char *id2str_ta_cmd(uint32_t id) 499 { 500 return ID2STR(id, string_ta_cmd, NULL); 501 } 502 503 const char *id2str_slot_flag(uint32_t id) 504 { 505 return ID2STR(id, string_slot_flags, "PKCS11_CKFS_"); 506 } 507 508 const char *id2str_token_flag(uint32_t id) 509 { 510 return ID2STR(id, string_token_flags, "PKCS11_CKFT_"); 511 } 512 513 const char *id2str_session_flag(uint32_t id) 514 { 515 return ID2STR(id, string_session_flags, "PKCS11_CKFSS_"); 516 } 517 518 const char *id2str_session_state(uint32_t id) 519 { 520 return ID2STR(id, string_session_state, "PKCS11_CKS_"); 521 } 522 523 const char *id2str_attr(uint32_t id) 524 { 525 size_t n = 0; 526 527 for (n = 0; n < ARRAY_SIZE(attr_ids); n++) { 528 if (id == attr_ids[n].id) { 529 /* Skip PKCS11_CKA_ prefix */ 530 return attr_ids[n].string + strlen("PKCS11_CKA_"); 531 } 532 } 533 534 return unknown; 535 } 536 537 const char *id2str_class(uint32_t id) 538 { 539 return ID2STR(id, string_class, "PKCS11_CKO_"); 540 } 541 542 const char *id2str_type(uint32_t id, uint32_t class) 543 { 544 enum pkcs11_class_id class_id = class; 545 enum pkcs11_key_type key_type = id; 546 547 switch (class_id) { 548 case PKCS11_CKO_SECRET_KEY: 549 case PKCS11_CKO_PUBLIC_KEY: 550 case PKCS11_CKO_PRIVATE_KEY: 551 return id2str_key_type(key_type); 552 default: 553 return unknown; 554 } 555 } 556 557 const char *id2str_key_type(uint32_t id) 558 { 559 return ID2STR(id, string_key_type, "PKCS11_CKK_"); 560 } 561 562 const char *id2str_attr_value(uint32_t id, size_t size, void *value) 563 { 564 static const char str_true[] = "TRUE"; 565 static const char str_false[] = "FALSE"; 566 static const char str_unknown[] = "*"; 567 uint32_t type = 0; 568 569 if (pkcs11_attr2boolprop_shift(id) >= 0) 570 return *(uint8_t *)value ? str_true : str_false; 571 572 if (size < sizeof(uint32_t)) 573 return str_unknown; 574 575 TEE_MemMove(&type, value, sizeof(uint32_t)); 576 577 switch (id) { 578 case PKCS11_CKA_CLASS: 579 return id2str_class(type); 580 case PKCS11_CKA_KEY_TYPE: 581 return id2str_key_type(type); 582 case PKCS11_CKA_MECHANISM_TYPE: 583 return id2str_mechanism(type); 584 default: 585 return str_unknown; 586 } 587 } 588 589 const char *id2str_proc(uint32_t id) 590 { 591 const char *str = ID2STR(id, string_internal_processing, 592 "PKCS11_PROCESSING_"); 593 594 if (str != unknown) 595 return str; 596 597 return id2str_mechanism(id); 598 } 599 600 const char *id2str_function(uint32_t id) 601 { 602 return ID2STR(id, string_functions, "PKCS11_FUNCTION_"); 603 } 604 #endif /*CFG_TEE_TA_LOG_LEVEL*/ 605