|
Platform Security Architecture — cryptography and keystore interface
beta 2 — 2019-02-22
|
Macros | |
| #define | PSA_KEY_TYPE_NONE ((psa_key_type_t)0x00000000) |
| #define | PSA_KEY_TYPE_VENDOR_FLAG ((psa_key_type_t)0x80000000) |
| #define | PSA_KEY_TYPE_CATEGORY_MASK ((psa_key_type_t)0x70000000) |
| #define | PSA_KEY_TYPE_CATEGORY_SYMMETRIC ((psa_key_type_t)0x40000000) |
| #define | PSA_KEY_TYPE_CATEGORY_RAW ((psa_key_type_t)0x50000000) |
| #define | PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY ((psa_key_type_t)0x60000000) |
| #define | PSA_KEY_TYPE_CATEGORY_KEY_PAIR ((psa_key_type_t)0x70000000) |
| #define | PSA_KEY_TYPE_CATEGORY_FLAG_PAIR ((psa_key_type_t)0x10000000) |
| #define | PSA_KEY_TYPE_IS_VENDOR_DEFINED(type) (((type) & PSA_KEY_TYPE_VENDOR_FLAG) != 0) |
| #define | PSA_KEY_TYPE_IS_UNSTRUCTURED(type) |
| #define | PSA_KEY_TYPE_IS_ASYMMETRIC(type) |
| #define | PSA_KEY_TYPE_IS_PUBLIC_KEY(type) (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY) |
| #define | PSA_KEY_TYPE_IS_KEYPAIR(type) (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_KEY_PAIR) |
| #define | PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY(type) ((type) | PSA_KEY_TYPE_CATEGORY_FLAG_PAIR) |
| #define | PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) ((type) & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR) |
| #define | PSA_KEY_TYPE_RAW_DATA ((psa_key_type_t)0x50000001) |
| #define | PSA_KEY_TYPE_HMAC ((psa_key_type_t)0x51000000) |
| #define | PSA_KEY_TYPE_DERIVE ((psa_key_type_t)0x52000000) |
| #define | PSA_KEY_TYPE_AES ((psa_key_type_t)0x40000001) |
| #define | PSA_KEY_TYPE_DES ((psa_key_type_t)0x40000002) |
| #define | PSA_KEY_TYPE_CAMELLIA ((psa_key_type_t)0x40000003) |
| #define | PSA_KEY_TYPE_ARC4 ((psa_key_type_t)0x40000004) |
| #define | PSA_KEY_TYPE_RSA_PUBLIC_KEY ((psa_key_type_t)0x60010000) |
| #define | PSA_KEY_TYPE_RSA_KEYPAIR ((psa_key_type_t)0x70010000) |
| #define | PSA_KEY_TYPE_IS_RSA(type) (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) == PSA_KEY_TYPE_RSA_PUBLIC_KEY) |
| #define | PSA_KEY_TYPE_DSA_PUBLIC_KEY ((psa_key_type_t)0x60020000) |
| #define | PSA_KEY_TYPE_DSA_KEYPAIR ((psa_key_type_t)0x70020000) |
| #define | PSA_KEY_TYPE_IS_DSA(type) (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) == PSA_KEY_TYPE_DSA_PUBLIC_KEY) |
| #define | PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE ((psa_key_type_t)0x60030000) |
| #define | PSA_KEY_TYPE_ECC_KEYPAIR_BASE ((psa_key_type_t)0x70030000) |
| #define | PSA_KEY_TYPE_ECC_CURVE_MASK ((psa_key_type_t)0x0000ffff) |
| #define | PSA_KEY_TYPE_ECC_KEYPAIR(curve) (PSA_KEY_TYPE_ECC_KEYPAIR_BASE | (curve)) |
| #define | PSA_KEY_TYPE_ECC_PUBLIC_KEY(curve) (PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE | (curve)) |
| #define | PSA_KEY_TYPE_IS_ECC(type) |
| #define | PSA_KEY_TYPE_IS_ECC_KEYPAIR(type) |
| #define | PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(type) |
| #define | PSA_KEY_TYPE_GET_CURVE(type) |
| #define | PSA_ECC_CURVE_SECT163K1 ((psa_ecc_curve_t) 0x0001) |
| #define | PSA_ECC_CURVE_SECT163R1 ((psa_ecc_curve_t) 0x0002) |
| #define | PSA_ECC_CURVE_SECT163R2 ((psa_ecc_curve_t) 0x0003) |
| #define | PSA_ECC_CURVE_SECT193R1 ((psa_ecc_curve_t) 0x0004) |
| #define | PSA_ECC_CURVE_SECT193R2 ((psa_ecc_curve_t) 0x0005) |
| #define | PSA_ECC_CURVE_SECT233K1 ((psa_ecc_curve_t) 0x0006) |
| #define | PSA_ECC_CURVE_SECT233R1 ((psa_ecc_curve_t) 0x0007) |
| #define | PSA_ECC_CURVE_SECT239K1 ((psa_ecc_curve_t) 0x0008) |
| #define | PSA_ECC_CURVE_SECT283K1 ((psa_ecc_curve_t) 0x0009) |
| #define | PSA_ECC_CURVE_SECT283R1 ((psa_ecc_curve_t) 0x000a) |
| #define | PSA_ECC_CURVE_SECT409K1 ((psa_ecc_curve_t) 0x000b) |
| #define | PSA_ECC_CURVE_SECT409R1 ((psa_ecc_curve_t) 0x000c) |
| #define | PSA_ECC_CURVE_SECT571K1 ((psa_ecc_curve_t) 0x000d) |
| #define | PSA_ECC_CURVE_SECT571R1 ((psa_ecc_curve_t) 0x000e) |
| #define | PSA_ECC_CURVE_SECP160K1 ((psa_ecc_curve_t) 0x000f) |
| #define | PSA_ECC_CURVE_SECP160R1 ((psa_ecc_curve_t) 0x0010) |
| #define | PSA_ECC_CURVE_SECP160R2 ((psa_ecc_curve_t) 0x0011) |
| #define | PSA_ECC_CURVE_SECP192K1 ((psa_ecc_curve_t) 0x0012) |
| #define | PSA_ECC_CURVE_SECP192R1 ((psa_ecc_curve_t) 0x0013) |
| #define | PSA_ECC_CURVE_SECP224K1 ((psa_ecc_curve_t) 0x0014) |
| #define | PSA_ECC_CURVE_SECP224R1 ((psa_ecc_curve_t) 0x0015) |
| #define | PSA_ECC_CURVE_SECP256K1 ((psa_ecc_curve_t) 0x0016) |
| #define | PSA_ECC_CURVE_SECP256R1 ((psa_ecc_curve_t) 0x0017) |
| #define | PSA_ECC_CURVE_SECP384R1 ((psa_ecc_curve_t) 0x0018) |
| #define | PSA_ECC_CURVE_SECP521R1 ((psa_ecc_curve_t) 0x0019) |
| #define | PSA_ECC_CURVE_BRAINPOOL_P256R1 ((psa_ecc_curve_t) 0x001a) |
| #define | PSA_ECC_CURVE_BRAINPOOL_P384R1 ((psa_ecc_curve_t) 0x001b) |
| #define | PSA_ECC_CURVE_BRAINPOOL_P512R1 ((psa_ecc_curve_t) 0x001c) |
| #define | PSA_ECC_CURVE_CURVE25519 ((psa_ecc_curve_t) 0x001d) |
| #define | PSA_ECC_CURVE_CURVE448 ((psa_ecc_curve_t) 0x001e) |
| #define | PSA_KEY_TYPE_DH_PUBLIC_KEY ((psa_key_type_t)0x60040000) |
| #define | PSA_KEY_TYPE_DH_KEYPAIR ((psa_key_type_t)0x70040000) |
| #define | PSA_KEY_TYPE_IS_DH(type) (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) == PSA_KEY_TYPE_DH_PUBLIC_KEY) |
| #define | PSA_BLOCK_CIPHER_BLOCK_SIZE(type) |
| #define | PSA_ALG_VENDOR_FLAG ((psa_algorithm_t)0x80000000) |
| #define | PSA_ALG_CATEGORY_MASK ((psa_algorithm_t)0x7f000000) |
| #define | PSA_ALG_CATEGORY_HASH ((psa_algorithm_t)0x01000000) |
| #define | PSA_ALG_CATEGORY_MAC ((psa_algorithm_t)0x02000000) |
| #define | PSA_ALG_CATEGORY_CIPHER ((psa_algorithm_t)0x04000000) |
| #define | PSA_ALG_CATEGORY_AEAD ((psa_algorithm_t)0x06000000) |
| #define | PSA_ALG_CATEGORY_SIGN ((psa_algorithm_t)0x10000000) |
| #define | PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION ((psa_algorithm_t)0x12000000) |
| #define | PSA_ALG_CATEGORY_KEY_DERIVATION ((psa_algorithm_t)0x20000000) |
| #define | PSA_ALG_CATEGORY_KEY_AGREEMENT ((psa_algorithm_t)0x30000000) |
| #define | PSA_ALG_IS_VENDOR_DEFINED(alg) (((alg) & PSA_ALG_VENDOR_FLAG) != 0) |
| #define | PSA_ALG_IS_HASH(alg) (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_HASH) |
| #define | PSA_ALG_IS_MAC(alg) (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_MAC) |
| #define | PSA_ALG_IS_CIPHER(alg) (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_CIPHER) |
| #define | PSA_ALG_IS_AEAD(alg) (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_AEAD) |
| #define | PSA_ALG_IS_SIGN(alg) (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_SIGN) |
| #define | PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg) (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION) |
| #define | PSA_ALG_IS_KEY_AGREEMENT(alg) (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_AGREEMENT) |
| #define | PSA_ALG_IS_KEY_DERIVATION(alg) (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_DERIVATION) |
| #define | PSA_ALG_HASH_MASK ((psa_algorithm_t)0x000000ff) |
| #define | PSA_ALG_MD2 ((psa_algorithm_t)0x01000001) |
| #define | PSA_ALG_MD4 ((psa_algorithm_t)0x01000002) |
| #define | PSA_ALG_MD5 ((psa_algorithm_t)0x01000003) |
| #define | PSA_ALG_RIPEMD160 ((psa_algorithm_t)0x01000004) |
| #define | PSA_ALG_SHA_1 ((psa_algorithm_t)0x01000005) |
| #define | PSA_ALG_SHA_224 ((psa_algorithm_t)0x01000008) |
| #define | PSA_ALG_SHA_256 ((psa_algorithm_t)0x01000009) |
| #define | PSA_ALG_SHA_384 ((psa_algorithm_t)0x0100000a) |
| #define | PSA_ALG_SHA_512 ((psa_algorithm_t)0x0100000b) |
| #define | PSA_ALG_SHA_512_224 ((psa_algorithm_t)0x0100000c) |
| #define | PSA_ALG_SHA_512_256 ((psa_algorithm_t)0x0100000d) |
| #define | PSA_ALG_SHA3_224 ((psa_algorithm_t)0x01000010) |
| #define | PSA_ALG_SHA3_256 ((psa_algorithm_t)0x01000011) |
| #define | PSA_ALG_SHA3_384 ((psa_algorithm_t)0x01000012) |
| #define | PSA_ALG_SHA3_512 ((psa_algorithm_t)0x01000013) |
| #define | PSA_ALG_ANY_HASH ((psa_algorithm_t)0x010000ff) |
| #define | PSA_ALG_MAC_SUBCATEGORY_MASK ((psa_algorithm_t)0x00c00000) |
| #define | PSA_ALG_HMAC_BASE ((psa_algorithm_t)0x02800000) |
| #define | PSA_ALG_HMAC(hash_alg) (PSA_ALG_HMAC_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_HMAC_GET_HASH(hmac_alg) (PSA_ALG_CATEGORY_HASH | ((hmac_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_IS_HMAC(alg) |
| #define | PSA_ALG_MAC_TRUNCATION_MASK ((psa_algorithm_t)0x00003f00) |
| #define | PSA_MAC_TRUNCATION_OFFSET 8 |
| #define | PSA_ALG_TRUNCATED_MAC(alg, mac_length) |
| #define | PSA_ALG_FULL_LENGTH_MAC(alg) ((alg) & ~PSA_ALG_MAC_TRUNCATION_MASK) |
| #define | PSA_MAC_TRUNCATED_LENGTH(alg) (((alg) & PSA_ALG_MAC_TRUNCATION_MASK) >> PSA_MAC_TRUNCATION_OFFSET) |
| #define | PSA_ALG_CIPHER_MAC_BASE ((psa_algorithm_t)0x02c00000) |
| #define | PSA_ALG_CBC_MAC ((psa_algorithm_t)0x02c00001) |
| #define | PSA_ALG_CMAC ((psa_algorithm_t)0x02c00002) |
| #define | PSA_ALG_GMAC ((psa_algorithm_t)0x02c00003) |
| #define | PSA_ALG_IS_BLOCK_CIPHER_MAC(alg) |
| #define | PSA_ALG_CIPHER_STREAM_FLAG ((psa_algorithm_t)0x00800000) |
| #define | PSA_ALG_CIPHER_FROM_BLOCK_FLAG ((psa_algorithm_t)0x00400000) |
| #define | PSA_ALG_IS_STREAM_CIPHER(alg) |
| #define | PSA_ALG_ARC4 ((psa_algorithm_t)0x04800001) |
| #define | PSA_ALG_CTR ((psa_algorithm_t)0x04c00001) |
| #define | PSA_ALG_CFB ((psa_algorithm_t)0x04c00002) |
| #define | PSA_ALG_OFB ((psa_algorithm_t)0x04c00003) |
| #define | PSA_ALG_XTS ((psa_algorithm_t)0x044000ff) |
| #define | PSA_ALG_CBC_NO_PADDING ((psa_algorithm_t)0x04600100) |
| #define | PSA_ALG_CBC_PKCS7 ((psa_algorithm_t)0x04600101) |
| #define | PSA_ALG_CCM ((psa_algorithm_t)0x06001001) |
| #define | PSA_ALG_GCM ((psa_algorithm_t)0x06001002) |
| #define | PSA_ALG_AEAD_TAG_LENGTH_MASK ((psa_algorithm_t)0x00003f00) |
| #define | PSA_AEAD_TAG_LENGTH_OFFSET 8 |
| #define | PSA_ALG_AEAD_WITH_TAG_LENGTH(alg, tag_length) |
| #define | PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH(alg) |
| #define | PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(alg, ref) |
| #define | PSA_ALG_RSA_PKCS1V15_SIGN_BASE ((psa_algorithm_t)0x10020000) |
| #define | PSA_ALG_RSA_PKCS1V15_SIGN(hash_alg) (PSA_ALG_RSA_PKCS1V15_SIGN_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_RSA_PKCS1V15_SIGN_RAW PSA_ALG_RSA_PKCS1V15_SIGN_BASE |
| #define | PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PKCS1V15_SIGN_BASE) |
| #define | PSA_ALG_RSA_PSS_BASE ((psa_algorithm_t)0x10030000) |
| #define | PSA_ALG_RSA_PSS(hash_alg) (PSA_ALG_RSA_PSS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_IS_RSA_PSS(alg) (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PSS_BASE) |
| #define | PSA_ALG_DSA_BASE ((psa_algorithm_t)0x10040000) |
| #define | PSA_ALG_DSA(hash_alg) (PSA_ALG_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_DETERMINISTIC_DSA_BASE ((psa_algorithm_t)0x10050000) |
| #define | PSA_ALG_DSA_DETERMINISTIC_FLAG ((psa_algorithm_t)0x00010000) |
| #define | PSA_ALG_DETERMINISTIC_DSA(hash_alg) (PSA_ALG_DETERMINISTIC_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_IS_DSA(alg) |
| #define | PSA_ALG_DSA_IS_DETERMINISTIC(alg) (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0) |
| #define | PSA_ALG_IS_DETERMINISTIC_DSA(alg) (PSA_ALG_IS_DSA(alg) && PSA_ALG_DSA_IS_DETERMINISTIC(alg)) |
| #define | PSA_ALG_IS_RANDOMIZED_DSA(alg) (PSA_ALG_IS_DSA(alg) && !PSA_ALG_DSA_IS_DETERMINISTIC(alg)) |
| #define | PSA_ALG_ECDSA_BASE ((psa_algorithm_t)0x10060000) |
| #define | PSA_ALG_ECDSA(hash_alg) (PSA_ALG_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_ECDSA_ANY PSA_ALG_ECDSA_BASE |
| #define | PSA_ALG_DETERMINISTIC_ECDSA_BASE ((psa_algorithm_t)0x10070000) |
| #define | PSA_ALG_DETERMINISTIC_ECDSA(hash_alg) (PSA_ALG_DETERMINISTIC_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_IS_ECDSA(alg) |
| #define | PSA_ALG_ECDSA_IS_DETERMINISTIC(alg) (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0) |
| #define | PSA_ALG_IS_DETERMINISTIC_ECDSA(alg) (PSA_ALG_IS_ECDSA(alg) && PSA_ALG_ECDSA_IS_DETERMINISTIC(alg)) |
| #define | PSA_ALG_IS_RANDOMIZED_ECDSA(alg) (PSA_ALG_IS_ECDSA(alg) && !PSA_ALG_ECDSA_IS_DETERMINISTIC(alg)) |
| #define | PSA_ALG_IS_HASH_AND_SIGN(alg) |
| #define | PSA_ALG_SIGN_GET_HASH(alg) |
| #define | PSA_ALG_RSA_PKCS1V15_CRYPT ((psa_algorithm_t)0x12020000) |
| #define | PSA_ALG_RSA_OAEP_BASE ((psa_algorithm_t)0x12030000) |
| #define | PSA_ALG_RSA_OAEP(hash_alg) (PSA_ALG_RSA_OAEP_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_IS_RSA_OAEP(alg) (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_OAEP_BASE) |
| #define | PSA_ALG_RSA_OAEP_GET_HASH(alg) |
| #define | PSA_ALG_HKDF_BASE ((psa_algorithm_t)0x20000100) |
| #define | PSA_ALG_HKDF(hash_alg) (PSA_ALG_HKDF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_IS_HKDF(alg) (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_HKDF_BASE) |
| #define | PSA_ALG_HKDF_GET_HASH(hkdf_alg) (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_TLS12_PRF_BASE ((psa_algorithm_t)0x20000200) |
| #define | PSA_ALG_TLS12_PRF(hash_alg) (PSA_ALG_TLS12_PRF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_IS_TLS12_PRF(alg) (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PRF_BASE) |
| #define | PSA_ALG_TLS12_PRF_GET_HASH(hkdf_alg) (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_TLS12_PSK_TO_MS_BASE ((psa_algorithm_t)0x20000300) |
| #define | PSA_ALG_TLS12_PSK_TO_MS(hash_alg) (PSA_ALG_TLS12_PSK_TO_MS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_IS_TLS12_PSK_TO_MS(alg) (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PSK_TO_MS_BASE) |
| #define | PSA_ALG_TLS12_PSK_TO_MS_GET_HASH(hkdf_alg) (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK)) |
| #define | PSA_ALG_KEY_DERIVATION_MASK ((psa_algorithm_t)0x080fffff) |
| #define | PSA_ALG_KEY_AGREEMENT_MASK ((psa_algorithm_t)0x10f00000) |
| #define | PSA_ALG_KEY_AGREEMENT(ka_alg, kdf_alg) ((ka_alg) | (kdf_alg)) |
| #define | PSA_ALG_KEY_AGREEMENT_GET_KDF(alg) (((alg) & PSA_ALG_KEY_DERIVATION_MASK) | PSA_ALG_CATEGORY_KEY_DERIVATION) |
| #define | PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) (((alg) & PSA_ALG_KEY_AGREEMENT_MASK) | PSA_ALG_CATEGORY_KEY_AGREEMENT) |
| #define | PSA_ALG_IS_RAW_KEY_AGREEMENT(alg) |
| #define | PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT(alg) ((PSA_ALG_IS_KEY_DERIVATION(alg) || PSA_ALG_IS_KEY_AGREEMENT(alg))) |
| #define | PSA_ALG_FFDH ((psa_algorithm_t)0x30100000) |
| #define | PSA_ALG_IS_FFDH(alg) (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_FFDH) |
| #define | PSA_ALG_ECDH ((psa_algorithm_t)0x30200000) |
| #define | PSA_ALG_IS_ECDH(alg) (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_ECDH) |
| #define | PSA_ALG_IS_WILDCARD(alg) |
Typedefs | |
| typedef uint32_t | psa_key_type_t |
| Encoding of a key type. | |
| typedef uint16_t | psa_ecc_curve_t |
| typedef uint32_t | psa_algorithm_t |
| Encoding of a cryptographic algorithm. More... | |
| #define PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE | ( | alg, | |
| ref | |||
| ) |
| #define PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH | ( | alg | ) |
Calculate the corresponding AEAD algorithm with the default tag length.
| alg | An AEAD algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_AEAD(alg) is true). |
| #define PSA_ALG_AEAD_WITH_TAG_LENGTH | ( | alg, | |
| tag_length | |||
| ) |
Macro to build a shortened AEAD algorithm.
A shortened AEAD algorithm is similar to the corresponding AEAD algorithm, but has an authentication tag that consists of fewer bytes. Depending on the algorithm, the tag length may affect the calculation of the ciphertext.
| alg | A AEAD algorithm identifier (value of type psa_algorithm_t such that PSA_ALG_IS_AEAD(alg) is true). |
| tag_length | Desired length of the authentication tag in bytes. |
alg is not a supported AEAD algorithm or if tag_length is not valid for the specified AEAD algorithm. | #define PSA_ALG_ANY_HASH ((psa_algorithm_t)0x010000ff) |
Allow any hash algorithm.
This value may only be used to form the algorithm usage field of a policy for a signature algorithm that is parametrized by a hash. That is, suppose that PSA_xxx_SIGNATURE is one of the following macros:
PSA_xxx_SIGNATURE and a specific hash. Each call to sign or verify a message may use a different hash. This value may not be used to build other algorithms that are parametrized over a hash. For any valid use of this macro to build an algorithm \p alg, PSA_ALG_IS_HASH_AND_SIGN(alg) is true.
This value may not be used to build an algorithm specification to perform an operation. It is only valid to build policies.
| #define PSA_ALG_ARC4 ((psa_algorithm_t)0x04800001) |
The ARC4 stream cipher algorithm.
| #define PSA_ALG_CBC_NO_PADDING ((psa_algorithm_t)0x04600100) |
The CBC block cipher chaining mode, with no padding.
The underlying block cipher is determined by the key type.
This symmetric cipher mode can only be used with messages whose lengths are whole number of blocks for the chosen block cipher.
| #define PSA_ALG_CBC_PKCS7 ((psa_algorithm_t)0x04600101) |
The CBC block cipher chaining mode with PKCS#7 padding.
The underlying block cipher is determined by the key type.
This is the padding method defined by PKCS#7 (RFC 2315) §10.3.
| #define PSA_ALG_CCM ((psa_algorithm_t)0x06001001) |
The CCM authenticated encryption algorithm.
| #define PSA_ALG_CTR ((psa_algorithm_t)0x04c00001) |
The CTR stream cipher mode.
CTR is a stream cipher which is built from a block cipher. The underlying block cipher is determined by the key type. For example, to use AES-128-CTR, use this algorithm with a key of type PSA_KEY_TYPE_AES and a length of 128 bits (16 bytes).
| #define PSA_ALG_DETERMINISTIC_DSA | ( | hash_alg | ) | (PSA_ALG_DETERMINISTIC_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
Deterministic DSA signature with hashing.
This is the deterministic variant defined by RFC 6979 of the signature scheme defined by FIPS 186-4.
| hash_alg | A hash algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_HASH(hash_alg) is true). This includes PSA_ALG_ANY_HASH when specifying the algorithm in a usage policy. |
alg is not a supported hash algorithm. | #define PSA_ALG_DETERMINISTIC_ECDSA | ( | hash_alg | ) | (PSA_ALG_DETERMINISTIC_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
Deterministic ECDSA signature with hashing.
This is the deterministic ECDSA signature scheme defined by RFC 6979.
The representation of a signature is the same as with PSA_ALG_ECDSA().
Note that when this algorithm is used for verification, signatures made with randomized ECDSA (PSA_ALG_ECDSA(hash_alg)) with the same private key are accepted. In other words, PSA_ALG_DETERMINISTIC_ECDSA(hash_alg) differs from PSA_ALG_ECDSA(hash_alg) only for signature, not for verification.
| hash_alg | A hash algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_HASH(hash_alg) is true). This includes PSA_ALG_ANY_HASH when specifying the algorithm in a usage policy. |
alg is not a supported hash algorithm. | #define PSA_ALG_DSA | ( | hash_alg | ) | (PSA_ALG_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
DSA signature with hashing.
This is the signature scheme defined by FIPS 186-4, with a random per-message secret number (k).
| hash_alg | A hash algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_HASH(hash_alg) is true). This includes PSA_ALG_ANY_HASH when specifying the algorithm in a usage policy. |
alg is not a supported hash algorithm. | #define PSA_ALG_ECDH ((psa_algorithm_t)0x30200000) |
The elliptic curve Diffie-Hellman (ECDH) key agreement algorithm.
The shared secret produced by key agreement is the x-coordinate of the shared secret point. It is always ceiling(m / 8) bytes long where m is the bit size associated with the curve, i.e. the bit size of the order of the curve's coordinate field. When m is not a multiple of 8, the byte containing the most significant bit of the shared secret is padded with zero bits. The byte order is either little-endian or big-endian depending on the curve type.
PSA_ECC_CURVE_CURVEXXX), the shared secret is the x-coordinate of d_A Q_B = d_B Q_A in little-endian byte order. The bit size is 448 for Curve448 and 255 for Curve25519.PSA_ECC_CURVE_SECPXXX and PSA_ECC_CURVE_BRAINPOOL_PXXX), the shared secret is the x-coordinate of d_A Q_B = d_B Q_A in big-endian byte order. The bit size is m = ceiling(log_2(p)) for the field F_p.PSA_ECC_CURVE_SECTXXX), the shared secret is the x-coordinate of d_A Q_B = d_B Q_A in big-endian byte order. The bit size is m for the field F_{2^m}. | #define PSA_ALG_ECDSA | ( | hash_alg | ) | (PSA_ALG_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
ECDSA signature with hashing.
This is the ECDSA signature scheme defined by ANSI X9.62, with a random per-message secret number (k).
The representation of the signature as a byte string consists of the concatentation of the signature values r and s. Each of r and s is encoded as an N-octet string, where N is the length of the base point of the curve in octets. Each value is represented in big-endian order (most significant octet first).
| hash_alg | A hash algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_HASH(hash_alg) is true). This includes PSA_ALG_ANY_HASH when specifying the algorithm in a usage policy. |
alg is not a supported hash algorithm. | #define PSA_ALG_ECDSA_ANY PSA_ALG_ECDSA_BASE |
ECDSA signature without hashing.
This is the same signature scheme as PSA_ALG_ECDSA(), but without specifying a hash algorithm. This algorithm may only be used to sign or verify a sequence of bytes that should be an already-calculated hash. Note that the input is padded with zeros on the left or truncated on the left as required to fit the curve size.
| #define PSA_ALG_FFDH ((psa_algorithm_t)0x30100000) |
The finite-field Diffie-Hellman (DH) key agreement algorithm.
The shared secret produced by key agreement and passed as input to the derivation or selection algorithm kdf_alg is the shared secret g^{ab} in big-endian format. It is ceiling(m / 8) bytes long where m is the size of the prime p in bits.
| #define PSA_ALG_FULL_LENGTH_MAC | ( | alg | ) | ((alg) & ~PSA_ALG_MAC_TRUNCATION_MASK) |
Macro to build the base MAC algorithm corresponding to a truncated MAC algorithm.
| alg | A MAC algorithm identifier (value of type psa_algorithm_t such that PSA_ALG_IS_MAC(alg) is true). This may be a truncated or untruncated MAC algorithm. |
alg is not a supported MAC algorithm. | #define PSA_ALG_GCM ((psa_algorithm_t)0x06001002) |
The GCM authenticated encryption algorithm.
| #define PSA_ALG_HKDF | ( | hash_alg | ) | (PSA_ALG_HKDF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
Macro to build an HKDF algorithm.
For example, PSA_ALG_HKDF(PSA_ALG_SHA256) is HKDF using HMAC-SHA-256.
This key derivation algorithm uses the following inputs:
| hash_alg | A hash algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_HASH(hash_alg) is true). |
alg is not a supported hash algorithm. | #define PSA_ALG_HMAC | ( | hash_alg | ) | (PSA_ALG_HMAC_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
Macro to build an HMAC algorithm.
For example, PSA_ALG_HMAC(PSA_ALG_SHA_256) is HMAC-SHA-256.
| hash_alg | A hash algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_HASH(hash_alg) is true). |
alg is not a supported hash algorithm. | #define PSA_ALG_IS_AEAD | ( | alg | ) | (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_AEAD) |
Whether the specified algorithm is an authenticated encryption with associated data (AEAD) algorithm.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is an AEAD algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier. | #define PSA_ALG_IS_ASYMMETRIC_ENCRYPTION | ( | alg | ) | (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION) |
Whether the specified algorithm is a public-key encryption algorithm.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a public-key encryption algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier. | #define PSA_ALG_IS_BLOCK_CIPHER_MAC | ( | alg | ) |
Whether the specified algorithm is a MAC algorithm based on a block cipher.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a MAC algorithm based on a block cipher, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier. | #define PSA_ALG_IS_CIPHER | ( | alg | ) | (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_CIPHER) |
Whether the specified algorithm is a symmetric cipher algorithm.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a symmetric cipher algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier. | #define PSA_ALG_IS_DSA | ( | alg | ) |
| #define PSA_ALG_IS_ECDH | ( | alg | ) | (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_ECDH) |
Whether the specified algorithm is an elliptic curve Diffie-Hellman algorithm.
This includes every supported key selection or key agreement algorithm for the output of the Diffie-Hellman calculation.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is an elliptic curve Diffie-Hellman algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported key agreement algorithm identifier. | #define PSA_ALG_IS_ECDSA | ( | alg | ) |
| #define PSA_ALG_IS_FFDH | ( | alg | ) | (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_FFDH) |
Whether the specified algorithm is a finite field Diffie-Hellman algorithm.
This includes every supported key selection or key agreement algorithm for the output of the Diffie-Hellman calculation.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a finite field Diffie-Hellman algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported key agreement algorithm identifier. | #define PSA_ALG_IS_HASH | ( | alg | ) | (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_HASH) |
Whether the specified algorithm is a hash algorithm.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a hash algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier. | #define PSA_ALG_IS_HASH_AND_SIGN | ( | alg | ) |
Whether the specified algorithm is a hash-and-sign algorithm.
Hash-and-sign algorithms are public-key signature algorithms structured in two parts: first the calculation of a hash in a way that does not depend on the key, then the calculation of a signature from the hash value and the key.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a hash-and-sign algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier. | #define PSA_ALG_IS_HKDF | ( | alg | ) | (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_HKDF_BASE) |
Whether the specified algorithm is an HKDF algorithm.
HKDF is a family of key derivation algorithms that are based on a hash function and the HMAC construction.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is an HKDF algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported key derivation algorithm identifier. | #define PSA_ALG_IS_HMAC | ( | alg | ) |
Whether the specified algorithm is an HMAC algorithm.
HMAC is a family of MAC algorithms that are based on a hash function.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is an HMAC algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier. | #define PSA_ALG_IS_KEY_AGREEMENT | ( | alg | ) | (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_AGREEMENT) |
Whether the specified algorithm is a key agreement algorithm.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a key agreement algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier. | #define PSA_ALG_IS_KEY_DERIVATION | ( | alg | ) | (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_DERIVATION) |
Whether the specified algorithm is a key derivation algorithm.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a key derivation algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier. | #define PSA_ALG_IS_MAC | ( | alg | ) | (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_MAC) |
Whether the specified algorithm is a MAC algorithm.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a MAC algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier. | #define PSA_ALG_IS_RAW_KEY_AGREEMENT | ( | alg | ) |
Whether the specified algorithm is a raw key agreement algorithm.
A raw key agreement algorithm is one that does not specify a key derivation function. Usually, raw key agreement algorithms are constructed directly with a PSA_ALG_xxx macro while non-raw key agreement algorithms are constructed with PSA_ALG_KEY_AGREEMENT().
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a raw key agreement algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier. | #define PSA_ALG_IS_SIGN | ( | alg | ) | (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_SIGN) |
Whether the specified algorithm is a public-key signature algorithm.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a public-key signature algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier. | #define PSA_ALG_IS_STREAM_CIPHER | ( | alg | ) |
Whether the specified algorithm is a stream cipher.
A stream cipher is a symmetric cipher that encrypts or decrypts messages by applying a bitwise-xor with a stream of bytes that is generated from a key.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a stream cipher algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier or if it is not a symmetric cipher algorithm. | #define PSA_ALG_IS_TLS12_PRF | ( | alg | ) | (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PRF_BASE) |
Whether the specified algorithm is a TLS-1.2 PRF algorithm.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a TLS-1.2 PRF algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported key derivation algorithm identifier. | #define PSA_ALG_IS_TLS12_PSK_TO_MS | ( | alg | ) | (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PSK_TO_MS_BASE) |
Whether the specified algorithm is a TLS-1.2 PSK to MS algorithm.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a TLS-1.2 PSK to MS algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported key derivation algorithm identifier. | #define PSA_ALG_IS_WILDCARD | ( | alg | ) |
Whether the specified algorithm encoding is a wildcard.
Wildcard values may only be used to set the usage algorithm field in a policy, not to perform an operation.
| alg | An algorithm identifier (value of type psa_algorithm_t). |
alg is a wildcard algorithm encoding. alg is a non-wildcard algorithm encoding (suitable for an operation). alg is not a supported algorithm identifier. | #define PSA_ALG_KEY_AGREEMENT | ( | ka_alg, | |
| kdf_alg | |||
| ) | ((ka_alg) | (kdf_alg)) |
Macro to build a combined algorithm that chains a key agreement with a key derivation.
| ka_alg | A key agreement algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_KEY_AGREEMENT(ka_alg) is true). |
| kdf_alg | A key derivation algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_KEY_DERIVATION(kdf_alg) is true). |
ka_alg is not a supported key agreement algorithm or kdf_alg is not a supported key derivation algorithm. | #define PSA_ALG_RSA_OAEP | ( | hash_alg | ) | (PSA_ALG_RSA_OAEP_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
RSA OAEP encryption.
This is the encryption scheme defined by RFC 8017 (PKCS#1: RSA Cryptography Specifications) under the name RSAES-OAEP, with the message generation function MGF1.
| hash_alg | The hash algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_HASH(hash_alg) is true) to use for MGF1. |
alg is not a supported hash algorithm. | #define PSA_ALG_RSA_OAEP_GET_HASH | ( | alg | ) |
| #define PSA_ALG_RSA_PKCS1V15_CRYPT ((psa_algorithm_t)0x12020000) |
RSA PKCS#1 v1.5 encryption.
| #define PSA_ALG_RSA_PKCS1V15_SIGN | ( | hash_alg | ) | (PSA_ALG_RSA_PKCS1V15_SIGN_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
RSA PKCS#1 v1.5 signature with hashing.
This is the signature scheme defined by RFC 8017 (PKCS#1: RSA Cryptography Specifications) under the name RSASSA-PKCS1-v1_5.
| hash_alg | A hash algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_HASH(hash_alg) is true). This includes PSA_ALG_ANY_HASH when specifying the algorithm in a usage policy. |
alg is not a supported hash algorithm. | #define PSA_ALG_RSA_PKCS1V15_SIGN_RAW PSA_ALG_RSA_PKCS1V15_SIGN_BASE |
Raw PKCS#1 v1.5 signature.
The input to this algorithm is the DigestInfo structure used by RFC 8017 (PKCS#1: RSA Cryptography Specifications), §9.2 steps 3–6.
| #define PSA_ALG_RSA_PSS | ( | hash_alg | ) | (PSA_ALG_RSA_PSS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
RSA PSS signature with hashing.
This is the signature scheme defined by RFC 8017 (PKCS#1: RSA Cryptography Specifications) under the name RSASSA-PSS, with the message generation function MGF1, and with a salt length equal to the length of the hash. The specified hash algorithm is used to hash the input message, to create the salted hash, and for the mask generation.
| hash_alg | A hash algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_HASH(hash_alg) is true). This includes PSA_ALG_ANY_HASH when specifying the algorithm in a usage policy. |
alg is not a supported hash algorithm. | #define PSA_ALG_SHA3_224 ((psa_algorithm_t)0x01000010) |
SHA3-224
| #define PSA_ALG_SHA3_256 ((psa_algorithm_t)0x01000011) |
SHA3-256
| #define PSA_ALG_SHA3_384 ((psa_algorithm_t)0x01000012) |
SHA3-384
| #define PSA_ALG_SHA3_512 ((psa_algorithm_t)0x01000013) |
SHA3-512
| #define PSA_ALG_SHA_224 ((psa_algorithm_t)0x01000008) |
SHA2-224
| #define PSA_ALG_SHA_256 ((psa_algorithm_t)0x01000009) |
SHA2-256
| #define PSA_ALG_SHA_384 ((psa_algorithm_t)0x0100000a) |
SHA2-384
| #define PSA_ALG_SHA_512 ((psa_algorithm_t)0x0100000b) |
SHA2-512
| #define PSA_ALG_SHA_512_224 ((psa_algorithm_t)0x0100000c) |
SHA2-512/224
| #define PSA_ALG_SHA_512_256 ((psa_algorithm_t)0x0100000d) |
SHA2-512/256
| #define PSA_ALG_SIGN_GET_HASH | ( | alg | ) |
Get the hash used by a hash-and-sign signature algorithm.
A hash-and-sign algorithm is a signature algorithm which is composed of two phases: first a hashing phase which does not use the key and produces a hash of the input message, then a signing phase which only uses the hash and the key and not the message itself.
| alg | A signature algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_SIGN(alg) is true). |
alg is a hash-and-sign algorithm. alg is a signature algorithm that does not follow the hash-and-sign structure. alg is not a signature algorithm or if it is not supported by the implementation. | #define PSA_ALG_TLS12_PRF | ( | hash_alg | ) | (PSA_ALG_TLS12_PRF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
Macro to build a TLS-1.2 PRF algorithm.
TLS 1.2 uses a custom pseudorandom function (PRF) for key schedule, specified in Section 5 of RFC 5246. It is based on HMAC and can be used with either SHA-256 or SHA-384.
For the application to TLS-1.2, the salt and label arguments passed to psa_key_derivation() are what's called 'seed' and 'label' in RFC 5246, respectively. For example, for TLS key expansion, the salt is the concatenation of ServerHello.Random + ClientHello.Random, while the label is "key expansion".
For example, PSA_ALG_TLS12_PRF(PSA_ALG_SHA256) represents the TLS 1.2 PRF using HMAC-SHA-256.
| hash_alg | A hash algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_HASH(hash_alg) is true). |
alg is not a supported hash algorithm. | #define PSA_ALG_TLS12_PSK_TO_MS | ( | hash_alg | ) | (PSA_ALG_TLS12_PSK_TO_MS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK)) |
Macro to build a TLS-1.2 PSK-to-MasterSecret algorithm.
In a pure-PSK handshake in TLS 1.2, the master secret is derived from the PreSharedKey (PSK) through the application of padding (RFC 4279, Section 2) and the TLS-1.2 PRF (RFC 5246, Section 5). The latter is based on HMAC and can be used with either SHA-256 or SHA-384.
For the application to TLS-1.2, the salt passed to psa_key_derivation() (and forwarded to the TLS-1.2 PRF) is the concatenation of the ClientHello.Random + ServerHello.Random, while the label is "master secret" or "extended master secret".
For example, PSA_ALG_TLS12_PSK_TO_MS(PSA_ALG_SHA256) represents the TLS-1.2 PSK to MasterSecret derivation PRF using HMAC-SHA-256.
| hash_alg | A hash algorithm (PSA_ALG_XXX value such that PSA_ALG_IS_HASH(hash_alg) is true). |
alg is not a supported hash algorithm. | #define PSA_ALG_TRUNCATED_MAC | ( | alg, | |
| mac_length | |||
| ) |
Macro to build a truncated MAC algorithm.
A truncated MAC algorithm is identical to the corresponding MAC algorithm except that the MAC value for the truncated algorithm consists of only the first mac_length bytes of the MAC value for the untruncated algorithm.
| alg | A MAC algorithm identifier (value of type psa_algorithm_t such that PSA_ALG_IS_MAC(alg) is true). This may be a truncated or untruncated MAC algorithm. |
| mac_length | Desired length of the truncated MAC in bytes. This must be at most the full length of the MAC and must be at least an implementation-specified minimum. The implementation-specified minimum shall not be zero. |
alg is not a supported MAC algorithm or if mac_length is too small or too large for the specified MAC algorithm. | #define PSA_ALG_XTS ((psa_algorithm_t)0x044000ff) |
The XTS cipher mode.
XTS is a cipher mode which is built from a block cipher. It requires at least one full block of input, but beyond this minimum the input does not need to be a whole number of blocks.
| #define PSA_BLOCK_CIPHER_BLOCK_SIZE | ( | type | ) |
The block size of a block cipher.
| type | A cipher key type (value of type psa_key_type_t). |
type is not a supported cipher key type.| #define PSA_KEY_TYPE_AES ((psa_key_type_t)0x40000001) |
Key for an cipher, AEAD or MAC algorithm based on the AES block cipher.
The size of the key can be 16 bytes (AES-128), 24 bytes (AES-192) or 32 bytes (AES-256).
| #define PSA_KEY_TYPE_ARC4 ((psa_key_type_t)0x40000004) |
Key for the RC4 stream cipher.
Note that RC4 is weak and deprecated and should only be used in legacy protocols.
| #define PSA_KEY_TYPE_CAMELLIA ((psa_key_type_t)0x40000003) |
Key for an cipher, AEAD or MAC algorithm based on the Camellia block cipher.
| #define PSA_KEY_TYPE_DERIVE ((psa_key_type_t)0x52000000) |
A secret for key derivation.
The key policy determines which key derivation algorithm the key can be used for.
| #define PSA_KEY_TYPE_DES ((psa_key_type_t)0x40000002) |
Key for a cipher or MAC algorithm based on DES or 3DES (Triple-DES).
The size of the key can be 8 bytes (single DES), 16 bytes (2-key 3DES) or 24 bytes (3-key 3DES).
Note that single DES and 2-key 3DES are weak and strongly deprecated and should only be used to decrypt legacy data. 3-key 3DES is weak and deprecated and should only be used in legacy protocols.
| #define PSA_KEY_TYPE_DH_KEYPAIR ((psa_key_type_t)0x70040000) |
Diffie-Hellman key exchange key pair (private and public key).
| #define PSA_KEY_TYPE_DH_PUBLIC_KEY ((psa_key_type_t)0x60040000) |
Diffie-Hellman key exchange public key.
| #define PSA_KEY_TYPE_DSA_KEYPAIR ((psa_key_type_t)0x70020000) |
DSA key pair (private and public key).
| #define PSA_KEY_TYPE_DSA_PUBLIC_KEY ((psa_key_type_t)0x60020000) |
DSA public key.
| #define PSA_KEY_TYPE_ECC_KEYPAIR | ( | curve | ) | (PSA_KEY_TYPE_ECC_KEYPAIR_BASE | (curve)) |
Elliptic curve key pair.
| #define PSA_KEY_TYPE_ECC_PUBLIC_KEY | ( | curve | ) | (PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE | (curve)) |
Elliptic curve public key.
| #define PSA_KEY_TYPE_GET_CURVE | ( | type | ) |
Extract the curve from an elliptic curve key type.
| #define PSA_KEY_TYPE_HMAC ((psa_key_type_t)0x51000000) |
HMAC key.
The key policy determines which underlying hash algorithm the key can be used for.
HMAC keys should generally have the same size as the underlying hash. This size can be calculated with PSA_HASH_SIZE(alg) where alg is the HMAC algorithm or the underlying hash algorithm.
| #define PSA_KEY_TYPE_IS_ASYMMETRIC | ( | type | ) |
Whether a key type is asymmetric: either a key pair or a public key.
| #define PSA_KEY_TYPE_IS_DH | ( | type | ) | (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) == PSA_KEY_TYPE_DH_PUBLIC_KEY) |
Whether a key type is a Diffie-Hellman key exchange key (pair or public-only).
| #define PSA_KEY_TYPE_IS_DSA | ( | type | ) | (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) == PSA_KEY_TYPE_DSA_PUBLIC_KEY) |
Whether a key type is an DSA key (pair or public-only).
| #define PSA_KEY_TYPE_IS_ECC | ( | type | ) |
Whether a key type is an elliptic curve key (pair or public-only).
| #define PSA_KEY_TYPE_IS_ECC_KEYPAIR | ( | type | ) |
Whether a key type is an elliptic curve key pair.
| #define PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY | ( | type | ) |
Whether a key type is an elliptic curve public key.
| #define PSA_KEY_TYPE_IS_KEYPAIR | ( | type | ) | (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_KEY_PAIR) |
Whether a key type is a key pair containing a private part and a public part.
| #define PSA_KEY_TYPE_IS_PUBLIC_KEY | ( | type | ) | (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY) |
Whether a key type is the public part of a key pair.
| #define PSA_KEY_TYPE_IS_RSA | ( | type | ) | (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) == PSA_KEY_TYPE_RSA_PUBLIC_KEY) |
Whether a key type is an RSA key (pair or public-only).
| #define PSA_KEY_TYPE_IS_UNSTRUCTURED | ( | type | ) |
Whether a key type is an unstructured array of bytes.
This encompasses both symmetric keys and non-key data.
| #define PSA_KEY_TYPE_IS_VENDOR_DEFINED | ( | type | ) | (((type) & PSA_KEY_TYPE_VENDOR_FLAG) != 0) |
Whether a key type is vendor-defined.
| #define PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY | ( | type | ) | ((type) | PSA_KEY_TYPE_CATEGORY_FLAG_PAIR) |
The key pair type corresponding to a public key type.
You may also pass a key pair type as type, it will be left unchanged.
| type | A public key type or key pair type. |
type is not a public key or a key pair, the return value is undefined. | #define PSA_KEY_TYPE_NONE ((psa_key_type_t)0x00000000) |
An invalid key type value.
Zero is not the encoding of any key type.
| #define PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR | ( | type | ) | ((type) & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR) |
The public key type corresponding to a key pair type.
You may also pass a key pair type as type, it will be left unchanged.
| type | A public key type or key pair type. |
type is not a public key or a key pair, the return value is undefined. | #define PSA_KEY_TYPE_RAW_DATA ((psa_key_type_t)0x50000001) |
Raw data.
A "key" of this type cannot be used for any cryptographic operation. Applications may use this type to store arbitrary data in the keystore.
| #define PSA_KEY_TYPE_RSA_KEYPAIR ((psa_key_type_t)0x70010000) |
RSA key pair (private and public key).
| #define PSA_KEY_TYPE_RSA_PUBLIC_KEY ((psa_key_type_t)0x60010000) |
RSA public key.
| #define PSA_KEY_TYPE_VENDOR_FLAG ((psa_key_type_t)0x80000000) |
Vendor-defined flag
Key types defined by this standard will never have the PSA_KEY_TYPE_VENDOR_FLAG bit set. Vendors who define additional key types must use an encoding with the PSA_KEY_TYPE_VENDOR_FLAG bit set and should respect the bitwise structure used by standard encodings whenever practical.
| #define PSA_MAC_TRUNCATED_LENGTH | ( | alg | ) | (((alg) & PSA_ALG_MAC_TRUNCATION_MASK) >> PSA_MAC_TRUNCATION_OFFSET) |
Length to which a MAC algorithm is truncated.
| alg | A MAC algorithm identifier (value of type psa_algorithm_t such that PSA_ALG_IS_MAC(alg) is true). |
alg is a non-truncated MAC algorithm. alg is not a supported MAC algorithm. | typedef uint32_t psa_algorithm_t |
Encoding of a cryptographic algorithm.
For algorithms that can be applied to multiple key types, this type does not encode the key type. For example, for symmetric ciphers based on a block cipher, psa_algorithm_t encodes the block cipher mode and the padding mode while the block cipher itself is encoded via psa_key_type_t.
| typedef uint16_t psa_ecc_curve_t |
The type of PSA elliptic curve identifiers.
1.8.11