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