Key and algorithm types

DSA public key.

The import and export format is the representation of the public key y = g^x mod p as a big-endian byte string. The length of the byte string is the length of the base prime p in bytes.

DSA key pair (private and public key).

The import and export format is the representation of the private key x as a big-endian byte string. The length of the byte string is the private key size in bytes (leading zeroes are not stripped).

Determinstic DSA key derivation with psa_generate_derived_key follows FIPS 186-4 §B.1.2: interpret the byte string as integer in big-endian order. Discard it if it is not in the range [0, N - 2] where N is the boundary of the private key domain (the prime p for Diffie-Hellman, the subprime q for DSA, or the order of the curve's base point for ECC). Add 1 to the resulting integer and use this as the private key x .

Whether a key type is an DSA key (pair or public-only).

DSA signature with hashing.

This is the signature scheme defined by FIPS 186-4, with a random per-message secret number ( k ).

Parameters

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.

Returns

The corresponding DSA signature algorithm.

Unspecified if hash_alg is not a supported hash algorithm.

Deterministic DSA signature with hashing.

This is the deterministic variant defined by RFC 6979 of the signature scheme defined by FIPS 186-4.

Parameters

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.

Returns

The corresponding DSA signature algorithm.

Unspecified if hash_alg is not a supported hash algorithm.

Whether the specified algorithm is a password-authenticated key exchange.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is a password-authenticated key exchange (PAKE) algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier.

The Password-authenticated key exchange by juggling (J-PAKE) algorithm.

This is J-PAKE as defined by RFC 8236, instantiated with the following parameters:

• The group can be either an elliptic curve or defined over a finite field.
• Schnorr NIZK proof as defined by RFC 8235 and using the same group as the J-PAKE algorithm.
• A cryptographic hash function.

To select these parameters and set up the cipher suite, call these functions in any order:

For more information on how to set a specific curve or field, refer to the documentation of the individual PSA_PAKE_PRIMITIVE_TYPE_XXX constants.

After initializing a J-PAKE operation, call

The password is read as a byte array and must be non-empty. This can be the password itself (in some pre-defined character encoding) or some value derived from the password as mandated by some higher level protocol.

(The implementation converts this byte array to a number as described in Section 2.3.8 of SEC 1: Elliptic Curve Cryptography ( https://www.secg.org/sec1-v2.pdf ), before reducing it modulo q . Here q is order of the group defined by the primitive set in the cipher suite. The psa_pake_set_password_xxx() functions return an error if the result of the reduction is 0.)

The key exchange flow for J-PAKE is as follows:

1. To get the first round data that needs to be sent to the peer, call
   // Get g1

   psa_pake_output (operation, # PSA_PAKE_STEP_KEY_SHARE , ...);

   // Get the ZKP public key for x1

   psa_pake_output (operation, # PSA_PAKE_STEP_ZK_PUBLIC , ...);

   // Get the ZKP proof for x1

   psa_pake_output (operation, # PSA_PAKE_STEP_ZK_PROOF , ...);

   // Get g2

   psa_pake_output (operation, # PSA_PAKE_STEP_KEY_SHARE , ...);

   // Get the ZKP public key for x2

   psa_pake_output (operation, # PSA_PAKE_STEP_ZK_PUBLIC , ...);

   // Get the ZKP proof for x2

   psa_pake_output (operation, # PSA_PAKE_STEP_ZK_PROOF , ...);
2. To provide the first round data received from the peer to the operation, call
   // Set g3

   psa_pake_input (operation, # PSA_PAKE_STEP_KEY_SHARE , ...);

   // Set the ZKP public key for x3

   psa_pake_input (operation, # PSA_PAKE_STEP_ZK_PUBLIC , ...);

   // Set the ZKP proof for x3

   psa_pake_input (operation, # PSA_PAKE_STEP_ZK_PROOF , ...);

   // Set g4

   psa_pake_input (operation, # PSA_PAKE_STEP_KEY_SHARE , ...);

   // Set the ZKP public key for x4

   psa_pake_input (operation, # PSA_PAKE_STEP_ZK_PUBLIC , ...);

   // Set the ZKP proof for x4

   psa_pake_input (operation, # PSA_PAKE_STEP_ZK_PROOF , ...);
3. To get the second round data that needs to be sent to the peer, call
   // Get A

   psa_pake_output (operation, # PSA_PAKE_STEP_KEY_SHARE , ...);

   // Get ZKP public key for x2*s

   psa_pake_output (operation, # PSA_PAKE_STEP_ZK_PUBLIC , ...);

   // Get ZKP proof for x2*s

   psa_pake_output (operation, # PSA_PAKE_STEP_ZK_PROOF , ...);
4. To provide the second round data received from the peer to the operation, call
   // Set B

   psa_pake_input (operation, # PSA_PAKE_STEP_KEY_SHARE , ...);

   // Set ZKP public key for x4*s

   psa_pake_input (operation, # PSA_PAKE_STEP_ZK_PUBLIC , ...);

   // Set ZKP proof for x4*s

   psa_pake_input (operation, # PSA_PAKE_STEP_ZK_PROOF , ...);
5. To access the shared secret call
   // Get Ka=Kb=K

   psa_pake_get_implicit_key ()

For more information consult the documentation of the individual PSA_PAKE_STEP_XXX constants.

At this point there is a cryptographic guarantee that only the authenticated party who used the same password is able to compute the key. But there is no guarantee that the peer is the party it claims to be and was able to do so.

That is, the authentication is only implicit (the peer is not authenticated at this point, and no action should be taken that assume that they are - like for example accessing restricted files).

To make the authentication explicit there are various methods, see Section 5 of RFC 8236 for two examples.

An invalid key type value.

Zero is not the encoding of any key type.

Vendor-defined key type 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.

Whether a key type is vendor-defined.

See also PSA_KEY_TYPE_VENDOR_FLAG .

Whether a key type is an unstructured array of bytes.

This encompasses both symmetric keys and non-key data.

Whether a key type is asymmetric: either a key pair or a public key.

Whether a key type is the public part of a key pair.

Whether a key type is a key pair containing a private part and a public part.

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.

Parameters

type	A public key type or key pair type.

Returns

The corresponding key pair type. If type is not a public key or a key pair, the return value is undefined.

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.

Parameters

type	A public key type or key pair type.

Returns

The corresponding public key type. If type is not a public key or a key pair, the return value is undefined.

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.

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_LENGTH( alg ) where alg is the HMAC algorithm or the underlying hash algorithm.

A secret for key derivation.

This key type is for high-entropy secrets only. For low-entropy secrets, PSA_KEY_TYPE_PASSWORD should be used instead.

These keys can be used as the PSA_KEY_DERIVATION_INPUT_SECRET or PSA_KEY_DERIVATION_INPUT_PASSWORD input of key derivation algorithms.

The key policy determines which key derivation algorithm the key can be used for.

A low-entropy secret for password hashing or key derivation.

This key type is suitable for passwords and passphrases which are typically intended to be memorizable by humans, and have a low entropy relative to their size. It can be used for randomly generated or derived keys with maximum or near-maximum entropy, but PSA_KEY_TYPE_DERIVE is more suitable for such keys. It is not suitable for passwords with extremely low entropy, such as numerical PINs.

These keys can be used as the PSA_KEY_DERIVATION_INPUT_PASSWORD input of key derivation algorithms. Algorithms that accept such an input were designed to accept low-entropy secret and are known as password hashing or key stretching algorithms.

These keys cannot be used as the PSA_KEY_DERIVATION_INPUT_SECRET input of key derivation algorithms, as the algorithms that take such an input expect it to be high-entropy.

The key policy determines which key derivation algorithm the key can be used for, among the permissible subset defined above.

A secret value that can be used to verify a password hash.

The key policy determines which key derivation algorithm the key can be used for, among the same permissible subset as for PSA_KEY_TYPE_PASSWORD .

A secret value that can be used in when computing a password hash.

The key policy determines which key derivation algorithm the key can be used for, among the subset of algorithms that can use pepper.

Key for a 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).

Key for a cipher, AEAD or MAC algorithm based on the ARIA block cipher.

Key for a cipher or MAC algorithm based on DES or 3DES (Triple-DES).

The size of the key can be 64 bits (single DES), 128 bits (2-key 3DES) or 192 bits (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.

Key for a cipher, AEAD or MAC algorithm based on the Camellia block cipher.

Key for the ChaCha20 stream cipher or the Chacha20-Poly1305 AEAD algorithm.

ChaCha20 and the ChaCha20_Poly1305 construction are defined in RFC 7539.

Implementations must support 12-byte nonces, may support 8-byte nonces, and should reject other sizes.

RSA public key.

The size of an RSA key is the bit size of the modulus.

RSA key pair (private and public key).

The size of an RSA key is the bit size of the modulus.

Whether a key type is an RSA key (pair or public-only).

Elliptic curve key pair.

The size of an elliptic curve key is the bit size associated with the curve, i.e. the bit size of q for a curve over a field F _q . See the documentation of PSA_ECC_FAMILY_xxx curve families for details.

Parameters

curve

A value of type psa_ecc_family_t that identifies the ECC curve to be used.

Elliptic curve public key.

The size of an elliptic curve public key is the same as the corresponding private key (see PSA_KEY_TYPE_ECC_KEY_PAIR and the documentation of PSA_ECC_FAMILY_xxx curve families).

Parameters

curve

A value of type psa_ecc_family_t that identifies the ECC curve to be used.

Whether a key type is an elliptic curve key (pair or public-only).

Whether a key type is an elliptic curve key pair.

Whether a key type is an elliptic curve public key.

Extract the curve from an elliptic curve key type.

SEC Koblitz curves over prime fields.

This family comprises the following curves: secp192k1, secp224k1, secp256k1. They are defined in Standards for Efficient Cryptography , SEC 2: Recommended Elliptic Curve Domain Parameters . https://www.secg.org/sec2-v2.pdf

SEC random curves over prime fields.

This family comprises the following curves: secp192k1, secp224r1, secp256r1, secp384r1, secp521r1. They are defined in Standards for Efficient Cryptography , SEC 2: Recommended Elliptic Curve Domain Parameters . https://www.secg.org/sec2-v2.pdf

SEC Koblitz curves over binary fields.

This family comprises the following curves: sect163k1, sect233k1, sect239k1, sect283k1, sect409k1, sect571k1. They are defined in Standards for Efficient Cryptography , SEC 2: Recommended Elliptic Curve Domain Parameters . https://www.secg.org/sec2-v2.pdf

SEC random curves over binary fields.

This family comprises the following curves: sect163r1, sect233r1, sect283r1, sect409r1, sect571r1. They are defined in Standards for Efficient Cryptography , SEC 2: Recommended Elliptic Curve Domain Parameters . https://www.secg.org/sec2-v2.pdf

SEC additional random curves over binary fields.

This family comprises the following curve: sect163r2. It is defined in Standards for Efficient Cryptography , SEC 2: Recommended Elliptic Curve Domain Parameters . https://www.secg.org/sec2-v2.pdf

Brainpool P random curves.

This family comprises the following curves: brainpoolP160r1, brainpoolP192r1, brainpoolP224r1, brainpoolP256r1, brainpoolP320r1, brainpoolP384r1, brainpoolP512r1. It is defined in RFC 5639.

Curve25519 and Curve448.

This family comprises the following Montgomery curves:

• 255-bit: Bernstein et al., Curve25519: new Diffie-Hellman speed records , LNCS 3958, 2006. The algorithm PSA_ALG_ECDH performs X25519 when used with this curve.
• 448-bit: Hamburg, Ed448-Goldilocks, a new elliptic curve , NIST ECC Workshop, 2015. The algorithm PSA_ALG_ECDH performs X448 when used with this curve.

The twisted Edwards curves Ed25519 and Ed448.

These curves are suitable for EdDSA ( PSA_ALG_PURE_EDDSA for both curves, PSA_ALG_ED25519PH for the 255-bit curve, PSA_ALG_ED448PH for the 448-bit curve).

This family comprises the following twisted Edwards curves:

• 255-bit: Edwards25519, the twisted Edwards curve birationally equivalent to Curve25519. Bernstein et al., Twisted Edwards curves , Africacrypt 2008.
• 448-bit: Edwards448, the twisted Edwards curve birationally equivalent to Curve448. Hamburg, Ed448-Goldilocks, a new elliptic curve , NIST ECC Workshop, 2015.

Diffie-Hellman key pair.

Parameters

group

A value of type psa_dh_family_t that identifies the Diffie-Hellman group to be used.

Diffie-Hellman public key.

Parameters

group

A value of type psa_dh_family_t that identifies the Diffie-Hellman group to be used.

Whether a key type is a Diffie-Hellman key (pair or public-only).

Whether a key type is a Diffie-Hellman key pair.

Whether a key type is a Diffie-Hellman public key.

Extract the group from a Diffie-Hellman key type.

Diffie-Hellman groups defined in RFC 7919 Appendix A.

This family includes groups with the following key sizes (in bits): 2048, 3072, 4096, 6144, 8192. A given implementation may support all of these sizes or only a subset.

The block size of a block cipher.

Parameters

type	A cipher key type (value of type psa_key_type_t ).

Returns

The block size for a block cipher, or 1 for a stream cipher. The return value is undefined if type is not a supported cipher key type.

Note

It is possible to build stream cipher algorithms on top of a block cipher, for example CTR mode ( PSA_ALG_CTR ). This macro only takes the key type into account, so it cannot be used to determine the size of the data that psa_cipher_update() might buffer for future processing in general.

This macro returns a compile-time constant if its argument is one.

Warning

This macro may evaluate its argument multiple times.

Vendor-defined algorithm flag.

Algorithms defined by this standard will never have the PSA_ALG_VENDOR_FLAG bit set. Vendors who define additional algorithms must use an encoding with the PSA_ALG_VENDOR_FLAG bit set and should respect the bitwise structure used by standard encodings whenever practical.

Whether an algorithm is vendor-defined.

See also PSA_ALG_VENDOR_FLAG .

Whether the specified algorithm is a hash algorithm.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is a hash algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier.

Whether the specified algorithm is a MAC algorithm.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is a MAC algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier.

Whether the specified algorithm is a symmetric cipher algorithm.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is a symmetric cipher algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier.

Whether the specified algorithm is an authenticated encryption with associated data (AEAD) algorithm.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is an AEAD algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier.

Whether the specified algorithm is an asymmetric signature algorithm, also known as public-key signature algorithm.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is an asymmetric signature algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier.

Whether the specified algorithm is an asymmetric encryption algorithm, also known as public-key encryption algorithm.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is an asymmetric encryption algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier.

Whether the specified algorithm is a key agreement algorithm.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is a key agreement algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier.

Whether the specified algorithm is a key derivation algorithm.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is a key derivation algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier.

Whether the specified algorithm is a key stretching / password hashing algorithm.

A key stretching / password hashing algorithm is a key derivation algorithm that is suitable for use with a low-entropy secret such as a password. Equivalently, it's a key derivation algorithm that uses a PSA_KEY_DERIVATION_INPUT_PASSWORD input step.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is a key stretching / password hashing algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier.

An invalid algorithm identifier value.

MD5.

PSA_ALG_RIPEMD160.

SHA1.

SHA2-224.

SHA2-256.

SHA2-384.

SHA2-512.

SHA2-512/224.

SHA2-512/256.

SHA3-224.

SHA3-256.

SHA3-384.

SHA3-512.

The first 512 bits (64 bytes) of the SHAKE256 output.

This is the prehashing for Ed448ph (see PSA_ALG_ED448PH ). For other scenarios where a hash function based on SHA3/SHAKE is desired, SHA3-512 has the same output size and a (theoretically) higher security strength.

In a hash-and-sign algorithm policy, allow any hash algorithm.

This value may be used to form the algorithm usage field of a policy for a signature algorithm that is parametrized by a hash. The key may then be used to perform operations using the same signature algorithm parametrized with any supported hash.

That is, suppose that PSA_xxx_SIGNATURE is one of the following macros:

• PSA_ALG_RSA_PKCS1V15_SIGN , PSA_ALG_RSA_PSS , PSA_ALG_RSA_PSS_ANY_SALT ,
• PSA_ALG_ECDSA , PSA_ALG_DETERMINISTIC_ECDSA . Then you may create and use a key as follows:
• Set the key usage field using PSA_ALG_ANY_HASH , for example:
  psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH ); // or VERIFY

  psa_set_key_algorithm(&attributes, PSA_xxx_SIGNATURE( PSA_ALG_ANY_HASH ));
• Import or generate key material.
• Call psa_sign_hash() or psa_verify_hash() , passing an algorithm built from PSA_xxx_SIGNATURE and a specific hash. Each call to sign or verify a message may use a different hash.
  psa_sign_hash (key, PSA_xxx_SIGNATURE( PSA_ALG_SHA_256 ), ...);

  psa_sign_hash (key, PSA_xxx_SIGNATURE( PSA_ALG_SHA_512 ), ...);

  psa_sign_hash (key, PSA_xxx_SIGNATURE( PSA_ALG_SHA3_256 ), ...);

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 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.

Macro to build an HMAC algorithm.

For example, PSA_ALG_HMAC ( PSA_ALG_SHA_256 ) is HMAC-SHA-256.

Parameters

hash_alg

A hash algorithm ( PSA_ALG_XXX value such that PSA_ALG_IS_HASH ( hash_alg ) is true).

Returns

The corresponding HMAC algorithm.

Unspecified if hash_alg is not a supported hash algorithm.

Whether the specified algorithm is an HMAC algorithm.

HMAC is a family of MAC algorithms that are based on a hash function.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is an HMAC algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier.

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.

Note

This macro may allow constructing algorithm identifiers that are not valid, either because the specified length is larger than the untruncated MAC or because the specified length is smaller than permitted by the implementation.

It is implementation-defined whether a truncated MAC that is truncated to the same length as the MAC of the untruncated algorithm is considered identical to the untruncated algorithm for policy comparison purposes.

Parameters

mac_alg	A MAC algorithm identifier (value of type psa_algorithm_t such that PSA_ALG_IS_MAC ( 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.

Returns

The corresponding MAC algorithm with the specified length.

Unspecified if mac_alg is not a supported MAC algorithm or if mac_length is too small or too large for the specified MAC algorithm.

Macro to build the base MAC algorithm corresponding to a truncated MAC algorithm.

Parameters

mac_alg

A MAC algorithm identifier (value of type psa_algorithm_t such that PSA_ALG_IS_MAC ( mac_alg ) is true). This may be a truncated or untruncated MAC algorithm.

Returns

The corresponding base MAC algorithm.

Unspecified if mac_alg is not a supported MAC algorithm.

Length to which a MAC algorithm is truncated.

Parameters

mac_alg

A MAC algorithm identifier (value of type psa_algorithm_t such that PSA_ALG_IS_MAC ( mac_alg ) is true).

Returns

Length of the truncated MAC in bytes.

0 if mac_alg is a non-truncated MAC algorithm.

Unspecified if mac_alg is not a supported MAC algorithm.

Macro to build a MAC minimum-MAC-length wildcard algorithm.

A minimum-MAC-length MAC wildcard algorithm permits all MAC algorithms sharing the same base algorithm, and where the (potentially truncated) MAC length of the specific algorithm is equal to or larger then the wildcard algorithm's minimum MAC length.

Note

When setting the minimum required MAC length to less than the smallest MAC length allowed by the base algorithm, this effectively becomes an 'any-MAC-length-allowed' policy for that base algorithm.

Parameters

mac_alg	A MAC algorithm identifier (value of type psa_algorithm_t such that PSA_ALG_IS_MAC ( mac_alg ) is true).
min_mac_length	Desired minimum length of the message authentication code in bytes. This must be at most the untruncated length of the MAC and must be at least 1.

Returns

The corresponding MAC wildcard algorithm with the specified minimum length.

Unspecified if mac_alg is not a supported MAC algorithm or if min_mac_length is less than 1 or too large for the specified MAC algorithm.

The CBC-MAC construction over a block cipher.

Warning

CBC-MAC is insecure in many cases. A more secure mode, such as PSA_ALG_CMAC , is recommended.

The CMAC construction over a block cipher.

Whether the specified algorithm is a MAC algorithm based on a block cipher.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if 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.

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.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if 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.

The stream cipher mode of a stream cipher algorithm.

The underlying stream cipher is determined by the key type.

• To use ChaCha20, use a key type of PSA_KEY_TYPE_CHACHA20 .

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).

The CFB stream cipher mode.

The underlying block cipher is determined by the key type.

The OFB stream cipher mode.

The underlying block cipher is determined by the key type.

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.

The Electronic Code Book (ECB) mode of a block cipher, with no padding.

Warning

ECB mode does not protect the confidentiality of the encrypted data except in extremely narrow circumstances. It is recommended that applications only use ECB if they need to construct an operating mode that the implementation does not provide. Implementations are encouraged to provide the modes that applications need in preference to supporting direct access to ECB.

The underlying block cipher is determined by the key type.

This symmetric cipher mode can only be used with messages whose lengths are a multiple of the block size of the chosen block cipher.

ECB mode does not accept an initialization vector (IV). When using a multi-part cipher operation with this algorithm, psa_cipher_generate_iv() and psa_cipher_set_iv() must not be called.

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.

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.

Whether the specified algorithm is an AEAD mode on a block cipher.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is an AEAD algorithm which is an AEAD mode based on a block cipher, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier.

The CCM authenticated encryption algorithm.

The underlying block cipher is determined by the key type.

The CCM* cipher mode without authentication.

This is CCM* as specified in IEEE 802.15.4 §7, with a tag length of 0. For CCM* with a nonzero tag length, use the AEAD algorithm PSA_ALG_CCM .

The underlying block cipher is determined by the key type.

Currently only 13-byte long IV's are supported.

The GCM authenticated encryption algorithm.

The underlying block cipher is determined by the key type.

The Chacha20-Poly1305 AEAD algorithm.

The ChaCha20_Poly1305 construction is defined in RFC 7539.

Implementations must support 12-byte nonces, may support 8-byte nonces, and should reject other sizes.

Implementations must support 16-byte tags and should reject other sizes.

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.

Parameters

aead_alg	An AEAD algorithm identifier (value of type psa_algorithm_t such that PSA_ALG_IS_AEAD ( aead_alg ) is true).
tag_length	Desired length of the authentication tag in bytes.

Returns

The corresponding AEAD algorithm with the specified length.

Unspecified if aead_alg is not a supported AEAD algorithm or if tag_length is not valid for the specified AEAD algorithm.

Retrieve the tag length of a specified AEAD algorithm.

Parameters

aead_alg

An AEAD algorithm identifier (value of type psa_algorithm_t such that PSA_ALG_IS_AEAD ( aead_alg ) is true).

Returns

The tag length specified by the input algorithm.

Unspecified if aead_alg is not a supported AEAD algorithm.

Calculate the corresponding AEAD algorithm with the default tag length.

Parameters

aead_alg

An AEAD algorithm ( PSA_ALG_XXX value such that PSA_ALG_IS_AEAD ( aead_alg ) is true).

Returns

The corresponding AEAD algorithm with the default tag length for that algorithm.

Macro to build an AEAD minimum-tag-length wildcard algorithm.

A minimum-tag-length AEAD wildcard algorithm permits all AEAD algorithms sharing the same base algorithm, and where the tag length of the specific algorithm is equal to or larger then the minimum tag length specified by the wildcard algorithm.

Note

When setting the minimum required tag length to less than the smallest tag length allowed by the base algorithm, this effectively becomes an 'any-tag-length-allowed' policy for that base algorithm.

Parameters

aead_alg	An AEAD algorithm identifier (value of type psa_algorithm_t such that PSA_ALG_IS_AEAD ( aead_alg ) is true).
min_tag_length	Desired minimum length of the authentication tag in bytes. This must be at least 1 and at most the largest allowed tag length of the algorithm.

Returns

The corresponding AEAD wildcard algorithm with the specified minimum length.

Unspecified if aead_alg is not a supported AEAD algorithm or if min_tag_length is less than 1 or too large for the specified AEAD algorithm.

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.

Parameters

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.

Returns

The corresponding RSA PKCS#1 v1.5 signature algorithm.

Unspecified if hash_alg is not a supported hash algorithm.

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.

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.

Parameters

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.

Returns

The corresponding RSA PSS signature algorithm.

Unspecified if hash_alg is not a supported hash algorithm.

RSA PSS signature with hashing with relaxed verification.

This algorithm has the same behavior as PSA_ALG_RSA_PSS when signing, but allows an arbitrary salt length (including 0 ) when verifying a signature.

Parameters

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.

Returns

The corresponding RSA PSS signature algorithm.

Unspecified if hash_alg is not a supported hash algorithm.

Whether the specified algorithm is RSA PSS with standard salt.

Parameters

alg	An algorithm value or an algorithm policy wildcard.

Returns

1 if alg is of the form PSA_ALG_RSA_PSS ( hash_alg ), where hash_alg is a hash algorithm or PSA_ALG_ANY_HASH . 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier or policy.

Whether the specified algorithm is RSA PSS with any salt.

Parameters

alg	An algorithm value or an algorithm policy wildcard.

Returns

1 if alg is of the form #PSA_ALG_RSA_PSS_ANY_SALT_BASE( hash_alg ), where hash_alg is a hash algorithm or PSA_ALG_ANY_HASH . 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier or policy.

Whether the specified algorithm is RSA PSS.

This includes any of the RSA PSS algorithm variants, regardless of the constraints on salt length.

Parameters

alg	An algorithm value or an algorithm policy wildcard.

Returns

1 if alg is of the form PSA_ALG_RSA_PSS ( hash_alg ) or #PSA_ALG_RSA_PSS_ANY_SALT_BASE( hash_alg ), where hash_alg is a hash algorithm or PSA_ALG_ANY_HASH . 0 otherwise. This macro may return either 0 or 1 if alg is not a supported algorithm identifier or policy.

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).

Parameters

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.

Returns

The corresponding ECDSA signature algorithm.

Unspecified if hash_alg is not a supported hash algorithm.

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.

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.

Parameters

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.

Returns

The corresponding deterministic ECDSA signature algorithm.

Unspecified if hash_alg is not a supported hash algorithm.

Edwards-curve digital signature algorithm without prehashing (PureEdDSA), using standard parameters.

Contexts are not supported in the current version of this specification because there is no suitable signature interface that can take the context as a parameter. A future version of this specification may add suitable functions and extend this algorithm to support contexts.

PureEdDSA requires an elliptic curve key on a twisted Edwards curve. In this specification, the following curves are supported:

• PSA_ECC_FAMILY_TWISTED_EDWARDS , 255-bit: Ed25519 as specified in RFC 8032. The curve is Edwards25519. The hash function used internally is SHA-512.
• PSA_ECC_FAMILY_TWISTED_EDWARDS , 448-bit: Ed448 as specified in RFC 8032. The curve is Edwards448. The hash function used internally is the first 114 bytes of the SHAKE256 output.

This algorithm can be used with psa_sign_message() and psa_verify_message() . Since there is no prehashing, it cannot be used with psa_sign_hash() or psa_verify_hash() .

The signature format is the concatenation of R and S as defined by RFC 8032 §5.1.6 and §5.2.6 (a 64-byte string for Ed25519, a 114-byte string for Ed448).

Edwards-curve digital signature algorithm with prehashing (HashEdDSA), using SHA-512 and the Edwards25519 curve.

See PSA_ALG_PURE_EDDSA regarding context support and the signature format.

This algorithm is Ed25519 as specified in RFC 8032. The curve is Edwards25519. The prehash is SHA-512. The hash function used internally is SHA-512.

This is a hash-and-sign algorithm: to calculate a signature, you can either:

• call psa_sign_message() on the message;
• or calculate the SHA-512 hash of the message with psa_hash_compute() or with a multi-part hash operation started with psa_hash_setup() , using the hash algorithm PSA_ALG_SHA_512 , then sign the calculated hash with psa_sign_hash() . Verifying a signature is similar, using psa_verify_message() or psa_verify_hash() instead of the signature function.

Edwards-curve digital signature algorithm with prehashing (HashEdDSA), using SHAKE256 and the Edwards448 curve.

See PSA_ALG_PURE_EDDSA regarding context support and the signature format.

This algorithm is Ed448 as specified in RFC 8032. The curve is Edwards448. The prehash is the first 64 bytes of the SHAKE256 output. The hash function used internally is the first 114 bytes of the SHAKE256 output.

This is a hash-and-sign algorithm: to calculate a signature, you can either:

• call psa_sign_message() on the message;
• or calculate the first 64 bytes of the SHAKE256 output of the message with psa_hash_compute() or with a multi-part hash operation started with psa_hash_setup() , using the hash algorithm PSA_ALG_SHAKE256_512 , then sign the calculated hash with psa_sign_hash() . Verifying a signature is similar, using psa_verify_message() or psa_verify_hash() instead of the signature function.

Whether the specified algorithm is a signature algorithm that can be used with psa_sign_hash() and psa_verify_hash() .

This encompasses all strict hash-and-sign algorithms categorized by PSA_ALG_IS_HASH_AND_SIGN() , as well as algorithms that follow the paradigm more loosely:

• PSA_ALG_RSA_PKCS1V15_SIGN_RAW (expects its input to be an encoded hash)
• PSA_ALG_ECDSA_ANY (doesn't specify what kind of hash the input is)

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t).

Returns

1 if alg is a signature algorithm that can be used to sign a hash. 0 if alg is a signature algorithm that can only be used to sign a message. 0 if alg is not a signature algorithm. This macro can return either 0 or 1 if alg is not a supported algorithm identifier.

Whether the specified algorithm is a signature algorithm that can be used with psa_sign_message() and psa_verify_message() .

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is a signature algorithm that can be used to sign a message. 0 if alg is a signature algorithm that can only be used to sign an already-calculated hash. 0 if alg is not a signature algorithm. This macro can return either 0 or 1 if alg is not a supported algorithm identifier.

Whether the specified algorithm is a hash-and-sign algorithm.

Hash-and-sign algorithms are asymmetric (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. Hash-and-sign algorithms encode the hash used for the hashing step, and you can call PSA_ALG_SIGN_GET_HASH to extract this algorithm.

Thus, for a hash-and-sign algorithm, psa_sign_message(key, alg, input, ...) is equivalent to

Most usefully, separating the hash from the signature allows the hash to be calculated in multiple steps with psa_hash_setup() , psa_hash_update() and psa_hash_finish() . Likewise psa_verify_message() is equivalent to calculating the hash and then calling psa_verify_hash() .

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if 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.

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.

Parameters

alg	A signature algorithm ( PSA_ALG_XXX value such that PSA_ALG_IS_SIGN ( alg ) is true).

Returns

The underlying hash algorithm if alg is a hash-and-sign algorithm.

0 if alg is a signature algorithm that does not follow the hash-and-sign structure.

Unspecified if alg is not a signature algorithm or if it is not supported by the implementation.

RSA PKCS#1 v1.5 encryption.

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.

Parameters

hash_alg

The hash algorithm ( PSA_ALG_XXX value such that PSA_ALG_IS_HASH ( hash_alg ) is true) to use for MGF1.

Returns

The corresponding RSA OAEP encryption algorithm.

Unspecified if hash_alg is not a supported hash algorithm.

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:

• PSA_KEY_DERIVATION_INPUT_SALT is the salt used in the "extract" step. It is optional; if omitted, the derivation uses an empty salt.
• PSA_KEY_DERIVATION_INPUT_SECRET is the secret key used in the "extract" step.
• PSA_KEY_DERIVATION_INPUT_INFO is the info string used in the "expand" step. You must pass PSA_KEY_DERIVATION_INPUT_SALT before PSA_KEY_DERIVATION_INPUT_SECRET . You may pass PSA_KEY_DERIVATION_INPUT_INFO at any time after steup and before starting to generate output.

Parameters

hash_alg

A hash algorithm ( PSA_ALG_XXX value such that PSA_ALG_IS_HASH ( hash_alg ) is true).

Returns

The corresponding HKDF algorithm.

Unspecified if hash_alg is not a supported hash algorithm.

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.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if 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.

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.

This key derivation algorithm uses the following inputs, which must be passed in the order given here:

• PSA_KEY_DERIVATION_INPUT_SEED is the seed.
• PSA_KEY_DERIVATION_INPUT_SECRET is the secret key.
• PSA_KEY_DERIVATION_INPUT_LABEL is the label.

For the application to TLS-1.2 key expansion, the seed is the concatenation of ServerHello.Random + ClientHello.Random, and the label is "key expansion".

For example, PSA_ALG_TLS12_PRF(PSA_ALG_SHA256) represents the TLS 1.2 PRF using HMAC-SHA-256.

Parameters

hash_alg

A hash algorithm ( PSA_ALG_XXX value such that PSA_ALG_IS_HASH ( hash_alg ) is true).

Returns

The corresponding TLS-1.2 PRF algorithm.

Unspecified if hash_alg is not a supported hash algorithm.

Whether the specified algorithm is a TLS-1.2 PRF algorithm.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if 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.

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.

This key derivation algorithm uses the following inputs, which must be passed in the order given here:

• PSA_KEY_DERIVATION_INPUT_SEED is the seed.
• PSA_KEY_DERIVATION_INPUT_SECRET is the secret key.
• PSA_KEY_DERIVATION_INPUT_LABEL is the label.

For the application to TLS-1.2, the seed (which is forwarded to the TLS-1.2 PRF) is the concatenation of the ClientHello.Random + ServerHello.Random, and 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.

Parameters

hash_alg

A hash algorithm ( PSA_ALG_XXX value such that PSA_ALG_IS_HASH ( hash_alg ) is true).

Returns

The corresponding TLS-1.2 PSK to MS algorithm.

Unspecified if hash_alg is not a supported hash algorithm.

Whether the specified algorithm is a TLS-1.2 PSK to MS algorithm.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if 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.

Macro to build a PBKDF2-HMAC password hashing / key stretching algorithm.

PBKDF2 is defined by PKCS#5, republished as RFC 8018 (section 5.2). This macro specifies the PBKDF2 algorithm constructed using a PRF based on HMAC with the specified hash. For example, PSA_ALG_PBKDF2_HMAC(PSA_ALG_SHA256) specifies PBKDF2 using the PRF HMAC-SHA-256.

This key derivation algorithm uses the following inputs, which must be provided in the following order:

• PSA_KEY_DERIVATION_INPUT_COST is the iteration count. This input step must be used exactly once.
• PSA_KEY_DERIVATION_INPUT_SALT is the salt. This input step must be used one or more times; if used several times, the inputs will be concatenated. This can be used to build the final salt from multiple sources, both public and secret (also known as pepper).
• PSA_KEY_DERIVATION_INPUT_PASSWORD is the password to be hashed. This input step must be used exactly once.

Parameters

hash_alg

A hash algorithm ( PSA_ALG_XXX value such that PSA_ALG_IS_HASH ( hash_alg ) is true).

Returns

The corresponding PBKDF2-HMAC-XXX algorithm.

Unspecified if hash_alg is not a supported hash algorithm.

Whether the specified algorithm is a PBKDF2-HMAC algorithm.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is a PBKDF2-HMAC algorithm, 0 otherwise. This macro may return either 0 or 1 if alg is not a supported key derivation algorithm identifier.

The PBKDF2-AES-CMAC-PRF-128 password hashing / key stretching algorithm.

PBKDF2 is defined by PKCS#5, republished as RFC 8018 (section 5.2). This macro specifies the PBKDF2 algorithm constructed using the AES-CMAC-PRF-128 PRF specified by RFC 4615.

This key derivation algorithm uses the same inputs as PSA_ALG_PBKDF2_HMAC() with the same constraints.

Macro to build a combined algorithm that chains a key agreement with a key derivation.

Parameters

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).

Returns

The corresponding key agreement and derivation algorithm.

Unspecified if ka_alg is not a supported key agreement algorithm or kdf_alg is not a supported key derivation algorithm.

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() .

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if 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.

The finite-field Diffie-Hellman (DH) key agreement algorithm.

The shared secret produced by key agreement is g^{ab} in big-endian format. It is ceiling(m / 8) bytes long where m is the size of the prime p in bits.

Whether the specified algorithm is a finite field Diffie-Hellman algorithm.

This includes the raw finite field Diffie-Hellman algorithm as well as finite-field Diffie-Hellman followed by any supporter key derivation algorithm.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if 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.

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.

• For Montgomery curves (curve types PSA_ECC_FAMILY_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.
• For Weierstrass curves over prime fields (curve types PSA_ECC_FAMILY_SECPXXX and PSA_ECC_FAMILY_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 .
• For Weierstrass curves over binary fields (curve types PSA_ECC_FAMILY_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} .

Whether the specified algorithm is an elliptic curve Diffie-Hellman algorithm.

This includes the raw elliptic curve Diffie-Hellman algorithm as well as elliptic curve Diffie-Hellman followed by any supporter key derivation algorithm.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if 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.

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.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

1 if alg is a wildcard algorithm encoding.

0 if alg is a non-wildcard algorithm encoding (suitable for an operation).

This macro may return either 0 or 1 if alg is not a supported algorithm identifier.

Get the hash used by a composite algorithm.

Parameters

alg	An algorithm identifier (value of type psa_algorithm_t ).

Returns

The underlying hash algorithm if alg is a composite algorithm that uses a hash algorithm.

0 if alg is not a composite algorithm that uses a hash.

Encoding of a key type.

The type of PSA elliptic curve family identifiers.

The curve identifier is required to create an ECC key using the PSA_KEY_TYPE_ECC_KEY_PAIR() or PSA_KEY_TYPE_ECC_PUBLIC_KEY() macros.

Values defined by this standard will never be in the range 0x80-0xff. Vendors who define additional families must use an encoding in this range.

The type of PSA Diffie-Hellman group family identifiers.

The group identifier is required to create an Diffie-Hellman key using the PSA_KEY_TYPE_DH_KEY_PAIR() or PSA_KEY_TYPE_DH_PUBLIC_KEY() macros.

Values defined by this standard will never be in the range 0x80-0xff. Vendors who define additional families must use an encoding in this range.

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 .