1 /* SPDX-License-Identifier: BSD-2-Clause */ 2 /* 3 * Copyright (c) 2014, STMicroelectronics International N.V. 4 * Copyright (c) 2021, SumUp Services GmbH 5 */ 6 #ifndef UTEE_DEFINES_H 7 #define UTEE_DEFINES_H 8 9 #include <compiler.h> 10 #include <tee_api_defines.h> 11 #include <tee_api_defines_extensions.h> 12 #include <types_ext.h> 13 14 /* 15 * Copied from TEE Internal API specificaion v1.0 table 6-9 "Structure of 16 * Algorithm Identifier". 17 */ 18 #define TEE_MAIN_ALGO_MD5 0x01 19 #define TEE_MAIN_ALGO_SHA1 0x02 20 #define TEE_MAIN_ALGO_SHA224 0x03 21 #define TEE_MAIN_ALGO_SHA256 0x04 22 #define TEE_MAIN_ALGO_SHA384 0x05 23 #define TEE_MAIN_ALGO_SHA512 0x06 24 #define TEE_MAIN_ALGO_SM3 0x07 25 #define TEE_MAIN_ALGO_AES 0x10 26 #define TEE_MAIN_ALGO_DES 0x11 27 #define TEE_MAIN_ALGO_DES2 0x12 28 #define TEE_MAIN_ALGO_DES3 0x13 29 #define TEE_MAIN_ALGO_SM4 0x14 /* Not in v1.2, extrapolated */ 30 #define TEE_MAIN_ALGO_RSA 0x30 31 #define TEE_MAIN_ALGO_DSA 0x31 32 #define TEE_MAIN_ALGO_DH 0x32 33 #define TEE_MAIN_ALGO_ECDSA 0x41 34 #define TEE_MAIN_ALGO_ECDH 0x42 35 #define TEE_MAIN_ALGO_SM2_DSA_SM3 0x45 /* Not in v1.2 spec */ 36 #define TEE_MAIN_ALGO_SM2_KEP 0x46 /* Not in v1.2 spec */ 37 #define TEE_MAIN_ALGO_SM2_PKE 0x47 /* Not in v1.2 spec */ 38 #define TEE_MAIN_ALGO_HKDF 0xC0 /* OP-TEE extension */ 39 #define TEE_MAIN_ALGO_CONCAT_KDF 0xC1 /* OP-TEE extension */ 40 #define TEE_MAIN_ALGO_PBKDF2 0xC2 /* OP-TEE extension */ 41 #define TEE_MAIN_ALGO_X25519 0x44 /* Not in v1.2 spec */ 42 43 44 #define TEE_CHAIN_MODE_ECB_NOPAD 0x0 45 #define TEE_CHAIN_MODE_CBC_NOPAD 0x1 46 #define TEE_CHAIN_MODE_CTR 0x2 47 #define TEE_CHAIN_MODE_CTS 0x3 48 #define TEE_CHAIN_MODE_XTS 0x4 49 #define TEE_CHAIN_MODE_CBC_MAC_PKCS5 0x5 50 #define TEE_CHAIN_MODE_CMAC 0x6 51 #define TEE_CHAIN_MODE_CCM 0x7 52 #define TEE_CHAIN_MODE_GCM 0x8 53 #define TEE_CHAIN_MODE_PKCS1_PSS_MGF1 0x9 /* ??? */ 54 55 56 static inline uint32_t __tee_alg_get_class(uint32_t algo) 57 { 58 if (algo == TEE_ALG_SM2_PKE) 59 return TEE_OPERATION_ASYMMETRIC_CIPHER; 60 if (algo == TEE_ALG_SM2_KEP) 61 return TEE_OPERATION_KEY_DERIVATION; 62 if (algo == TEE_ALG_RSASSA_PKCS1_V1_5) 63 return TEE_OPERATION_ASYMMETRIC_SIGNATURE; 64 if (algo == TEE_ALG_DES3_CMAC) 65 return TEE_OPERATION_MAC; 66 67 return (algo >> 28) & 0xF; /* Bits [31:28] */ 68 } 69 70 #define TEE_ALG_GET_CLASS(algo) __tee_alg_get_class(algo) 71 72 static inline uint32_t __tee_alg_get_main_alg(uint32_t algo) 73 { 74 switch (algo) { 75 case TEE_ALG_SM2_PKE: 76 return TEE_MAIN_ALGO_SM2_PKE; 77 case TEE_ALG_SM2_KEP: 78 return TEE_MAIN_ALGO_SM2_KEP; 79 case TEE_ALG_X25519: 80 return TEE_MAIN_ALGO_X25519; 81 default: 82 break; 83 } 84 85 return algo & 0xff; 86 } 87 88 #define TEE_ALG_GET_MAIN_ALG(algo) __tee_alg_get_main_alg(algo) 89 90 /* Bits [11:8] */ 91 #define TEE_ALG_GET_CHAIN_MODE(algo) (((algo) >> 8) & 0xF) 92 93 /* 94 * Value not defined in the GP spec, and not used as bits 15-12 of any TEE_ALG* 95 * value. TEE_ALG_SM2_DSA_SM3 has value 0x6 for bits 15-12 which would yield the 96 * SHA512 digest if we were to apply the bit masks that were valid up to the TEE 97 * Internal Core API v1.1. 98 */ 99 #define __TEE_MAIN_HASH_SM3 0x7 100 101 static inline uint32_t __tee_alg_get_digest_hash(uint32_t algo) 102 { 103 if (algo == TEE_ALG_SM2_DSA_SM3) 104 return __TEE_MAIN_HASH_SM3; 105 106 /* Bits [15:12] */ 107 return (algo >> 12) & 0xF; 108 } 109 110 #define TEE_ALG_GET_DIGEST_HASH(algo) __tee_alg_get_digest_hash(algo) 111 112 /* Bits [23:20] */ 113 #define TEE_ALG_GET_INTERNAL_HASH(algo) (((algo) >> 20) & 0x7) 114 115 static inline uint32_t __tee_alg_get_key_type(uint32_t algo, bool with_priv) 116 { 117 uint32_t key_type = 0xA0000000 | TEE_ALG_GET_MAIN_ALG(algo); 118 119 if (with_priv) 120 key_type |= 0x01000000; 121 122 return key_type; 123 } 124 125 #define TEE_ALG_GET_KEY_TYPE(algo, with_private_key) \ 126 __tee_alg_get_key_type(algo, with_private_key) 127 128 static inline uint32_t __tee_alg_hash_algo(uint32_t main_hash) 129 { 130 if (main_hash == __TEE_MAIN_HASH_SM3) 131 return TEE_ALG_SM3; 132 133 return (TEE_OPERATION_DIGEST << 28) | main_hash; 134 } 135 136 /* Return hash algorithm based on main hash */ 137 #define TEE_ALG_HASH_ALGO(main_hash) __tee_alg_hash_algo(main_hash) 138 139 /* Extract internal hash and return hash algorithm */ 140 #define TEE_INTERNAL_HASH_TO_ALGO(algo) \ 141 TEE_ALG_HASH_ALGO(TEE_ALG_GET_INTERNAL_HASH(algo)) 142 143 /* Extract digest hash and return hash algorithm */ 144 #define TEE_DIGEST_HASH_TO_ALGO(algo) \ 145 TEE_ALG_HASH_ALGO(TEE_ALG_GET_DIGEST_HASH(algo)) 146 147 /* Return HMAC algorithm based on main hash */ 148 #define TEE_ALG_HMAC_ALGO(main_hash) \ 149 (TEE_OPERATION_MAC << 28 | (main_hash)) 150 151 #define TEE_AES_BLOCK_SIZE 16UL 152 #define TEE_DES_BLOCK_SIZE 8UL 153 #define TEE_SM4_BLOCK_SIZE 16UL 154 155 #define TEE_AES_MAX_KEY_SIZE 32UL 156 157 /* SHA-512 */ 158 #ifndef TEE_MD5_HASH_SIZE 159 typedef enum { 160 TEE_MD5_HASH_SIZE = 16, 161 TEE_SHA1_HASH_SIZE = 20, 162 TEE_SHA224_HASH_SIZE = 28, 163 TEE_SHA256_HASH_SIZE = 32, 164 TEE_SM3_HASH_SIZE = 32, 165 TEE_SHA384_HASH_SIZE = 48, 166 TEE_SHA512_HASH_SIZE = 64, 167 TEE_MD5SHA1_HASH_SIZE = (TEE_MD5_HASH_SIZE + TEE_SHA1_HASH_SIZE), 168 TEE_MAX_HASH_SIZE = 64, 169 } t_hash_size; 170 #endif 171 172 #define TEE_MAC_SIZE_AES_CBC_MAC_NOPAD 173 #define TEE_MAC_SIZE_AES_CBC_MAC_PKCS5 174 #define TEE_MAC_SIZE_AES_CMAC 175 #define TEE_MAC_SIZE_DES_CBC_MAC_PKCS5 176 177 static inline size_t __tee_alg_get_digest_size(uint32_t algo) 178 { 179 switch (algo) { 180 case TEE_ALG_MD5: 181 case TEE_ALG_HMAC_MD5: 182 return TEE_MD5_HASH_SIZE; 183 case TEE_ALG_SHA1: 184 case TEE_ALG_HMAC_SHA1: 185 case TEE_ALG_DSA_SHA1: 186 return TEE_SHA1_HASH_SIZE; 187 case TEE_ALG_SHA224: 188 case TEE_ALG_HMAC_SHA224: 189 case TEE_ALG_DSA_SHA224: 190 return TEE_SHA224_HASH_SIZE; 191 case TEE_ALG_SHA256: 192 case TEE_ALG_HMAC_SHA256: 193 case TEE_ALG_DSA_SHA256: 194 return TEE_SHA256_HASH_SIZE; 195 case TEE_ALG_SHA384: 196 case TEE_ALG_HMAC_SHA384: 197 return TEE_SHA384_HASH_SIZE; 198 case TEE_ALG_SHA512: 199 case TEE_ALG_HMAC_SHA512: 200 return TEE_SHA512_HASH_SIZE; 201 case TEE_ALG_SM3: 202 case TEE_ALG_HMAC_SM3: 203 return TEE_SM3_HASH_SIZE; 204 case TEE_ALG_AES_CBC_MAC_NOPAD: 205 case TEE_ALG_AES_CBC_MAC_PKCS5: 206 case TEE_ALG_AES_CMAC: 207 return TEE_AES_BLOCK_SIZE; 208 case TEE_ALG_DES_CBC_MAC_NOPAD: 209 case TEE_ALG_DES_CBC_MAC_PKCS5: 210 case TEE_ALG_DES3_CBC_MAC_NOPAD: 211 case TEE_ALG_DES3_CBC_MAC_PKCS5: 212 case TEE_ALG_DES3_CMAC: 213 return TEE_DES_BLOCK_SIZE; 214 default: 215 return 0; 216 } 217 } 218 219 /* Return algorithm digest size */ 220 #define TEE_ALG_GET_DIGEST_SIZE(algo) __tee_alg_get_digest_size(algo) 221 222 /* 223 * Bit indicating that the attribute is a value attribute 224 * See TEE Internal API specificaion v1.0 table 6-12 "Partial Structure of 225 * Attribute Identifier" 226 */ 227 228 229 #ifdef __compiler_bswap64 230 #define TEE_U64_BSWAP(x) __compiler_bswap64((x)) 231 #else 232 #define TEE_U64_BSWAP(x) ((uint64_t)( \ 233 (((uint64_t)(x) & UINT64_C(0xff00000000000000ULL)) >> 56) | \ 234 (((uint64_t)(x) & UINT64_C(0x00ff000000000000ULL)) >> 40) | \ 235 (((uint64_t)(x) & UINT64_C(0x0000ff0000000000ULL)) >> 24) | \ 236 (((uint64_t)(x) & UINT64_C(0x000000ff00000000ULL)) >> 8) | \ 237 (((uint64_t)(x) & UINT64_C(0x00000000ff000000ULL)) << 8) | \ 238 (((uint64_t)(x) & UINT64_C(0x0000000000ff0000ULL)) << 24) | \ 239 (((uint64_t)(x) & UINT64_C(0x000000000000ff00ULL)) << 40) | \ 240 (((uint64_t)(x) & UINT64_C(0x00000000000000ffULL)) << 56))) 241 #endif 242 243 #ifdef __compiler_bswap32 244 #define TEE_U32_BSWAP(x) __compiler_bswap32((x)) 245 #else 246 #define TEE_U32_BSWAP(x) ((uint32_t)( \ 247 (((uint32_t)(x) & UINT32_C(0xff000000)) >> 24) | \ 248 (((uint32_t)(x) & UINT32_C(0x00ff0000)) >> 8) | \ 249 (((uint32_t)(x) & UINT32_C(0x0000ff00)) << 8) | \ 250 (((uint32_t)(x) & UINT32_C(0x000000ff)) << 24))) 251 #endif 252 253 #ifdef __compiler_bswap16 254 #define TEE_U16_BSWAP(x) __compiler_bswap16((x)) 255 #else 256 #define TEE_U16_BSWAP(x) ((uint16_t)( \ 257 (((uint16_t)(x) & UINT16_C(0xff00)) >> 8) | \ 258 (((uint16_t)(x) & UINT16_C(0x00ff)) << 8))) 259 #endif 260 261 /* If we we're on a big endian platform we'll have to update these */ 262 #define TEE_U64_FROM_BIG_ENDIAN(x) TEE_U64_BSWAP(x) 263 #define TEE_U32_FROM_BIG_ENDIAN(x) TEE_U32_BSWAP(x) 264 #define TEE_U16_FROM_BIG_ENDIAN(x) TEE_U16_BSWAP(x) 265 #define TEE_U64_TO_BIG_ENDIAN(x) TEE_U64_BSWAP(x) 266 #define TEE_U32_TO_BIG_ENDIAN(x) TEE_U32_BSWAP(x) 267 #define TEE_U16_TO_BIG_ENDIAN(x) TEE_U16_BSWAP(x) 268 269 #define TEE_TIME_MILLIS_BASE 1000 270 271 #define TEE_TIME_LT(t1, t2) \ 272 (((t1).seconds == (t2).seconds) ? \ 273 ((t1).millis < (t2).millis) : \ 274 ((t1).seconds < (t2).seconds)) 275 276 #define TEE_TIME_LE(t1, t2) \ 277 (((t1).seconds == (t2).seconds) ? \ 278 ((t1).millis <= (t2).millis) : \ 279 ((t1).seconds <= (t2).seconds)) 280 281 #define TEE_TIME_ADD(t1, t2, dst) do { \ 282 (dst).seconds = (t1).seconds + (t2).seconds; \ 283 (dst).millis = (t1).millis + (t2).millis; \ 284 if ((dst).millis >= TEE_TIME_MILLIS_BASE) { \ 285 (dst).seconds++; \ 286 (dst).millis -= TEE_TIME_MILLIS_BASE; \ 287 } \ 288 } while (0) 289 290 #define TEE_TIME_SUB(t1, t2, dst) do { \ 291 (dst).seconds = (t1).seconds - (t2).seconds; \ 292 if ((t1).millis < (t2).millis) { \ 293 (dst).seconds--; \ 294 (dst).millis = (t1).millis + TEE_TIME_MILLIS_BASE - (t2).millis;\ 295 } else { \ 296 (dst).millis = (t1).millis - (t2).millis; \ 297 } \ 298 } while (0) 299 300 /* ------------------------------------------------------------ */ 301 /* OTP mapping */ 302 /* ------------------------------------------------------------ */ 303 #define HW_UNIQUE_KEY_WORD1 (8) 304 #define HW_UNIQUE_KEY_LENGTH (16) 305 #define HW_UNIQUE_KEY_WORD2 (HW_UNIQUE_KEY_WORD1 + 1) 306 #define HW_UNIQUE_KEY_WORD3 (HW_UNIQUE_KEY_WORD1 + 2) 307 #define HW_UNIQUE_KEY_WORD4 (HW_UNIQUE_KEY_WORD1 + 3) 308 309 #define UTEE_SE_READER_PRESENT (1 << 0) 310 #define UTEE_SE_READER_TEE_ONLY (1 << 1) 311 #define UTEE_SE_READER_SELECT_RESPONE_ENABLE (1 << 2) 312 313 #endif /* UTEE_DEFINES_H */ 314