yuzu/mbedtls
1
0
Fork 0
mirror of https://github.com/yuzu-emu/mbedtls.git synced 2024-12-23 22:55:32 +00:00
Code Issues Packages Projects Releases Wiki Activity
mbedtls/tests/suites/test_suite_psa_crypto_metadata.function

474 lines
19 KiB
Plaintext
Raw Normal View History

Create infrastructure for metadata validation unit tests
2018-08-21 16:20:20 +00:00
/* BEGIN_HEADER */
/* Test macros that provide metadata about algorithms and key types.
* This test suite only contains tests that don't require executing
* code. Other test suites validate macros that require creating a key
* and using it. */
#if defined(MBEDTLS_PSA_CRYPTO_SPM)
#include "spm/psa_defs.h"
#endif
#include "psa/crypto.h"
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
/* Flags for algorithm classification macros. There is a flag for every
* algorithm classification macro PSA_ALG_IS_xxx except for the
* category test macros, which are hard-coded in each
* category-specific function. The name of the flag is the name of the
* classification macro without the PSA_ prefix. */
#define ALG_IS_VENDOR_DEFINED ( 1u << 0 )
#define ALG_IS_HMAC ( 1u << 1 )
#define ALG_IS_BLOCK_CIPHER_MAC ( 1u << 2 )
#define ALG_IS_STREAM_CIPHER ( 1u << 3 )
#define ALG_IS_RSA_PKCS1V15_SIGN ( 1u << 4 )
#define ALG_IS_RSA_PSS ( 1u << 5 )
#define ALG_IS_DSA ( 1u << 6 )
#define ALG_DSA_IS_DETERMINISTIC ( 1u << 7 )
#define ALG_IS_DETERMINISTIC_DSA ( 1u << 8 )
#define ALG_IS_RANDOMIZED_DSA ( 1u << 9 )
#define ALG_IS_ECDSA ( 1u << 10 )
#define ALG_ECDSA_IS_DETERMINISTIC ( 1u << 11 )
#define ALG_IS_DETERMINISTIC_ECDSA ( 1u << 12 )
#define ALG_IS_RANDOMIZED_ECDSA ( 1u << 13 )
#define ALG_IS_RSA_OAEP ( 1u << 14 )
#define ALG_IS_HKDF ( 1u << 15 )
Key agreement: macros for finite-field Diffie-Hellman, ECDH Declare macros to represent key agreement algorithms.
2018-09-18 09:54:43 +00:00
#define ALG_IS_FFDH ( 1u << 16 )
#define ALG_IS_ECDH ( 1u << 17 )
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
Key type validation tests For all key types, validate feature test macros (PSA_KEY_TYPE_IS_xxx). For asymmetric keys (public key or key pair), validate the corresponding public/pair type. For ECC keys, validate GET_CURVE.
2018-08-22 16:43:09 +00:00
/* Flags for key type classification macros. There is a flag for every
* key type classification macro PSA_KEY_TYPE_IS_xxx except for some that
* are tested as derived from other macros. The name of the flag is
* the name of the classification macro without the PSA_ prefix. */
#define KEY_TYPE_IS_VENDOR_DEFINED ( 1u << 0 )
#define KEY_TYPE_IS_UNSTRUCTURED ( 1u << 1 )
#define KEY_TYPE_IS_PUBLIC_KEY ( 1u << 2 )
#define KEY_TYPE_IS_KEYPAIR ( 1u << 3 )
#define KEY_TYPE_IS_RSA ( 1u << 4 )
#define KEY_TYPE_IS_DSA ( 1u << 5 )
#define KEY_TYPE_IS_ECC ( 1u << 6 )
Indent PSA tests according to K&R rules with Mbed TLS tweaks Only whitespace changes in this commit.
2018-12-17 22:35:42 +00:00
#define TEST_CLASSIFICATION_MACRO( flag, alg, flags ) \
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
TEST_ASSERT( PSA_##flag( alg ) == !! ( ( flags ) & flag ) )
void algorithm_classification( psa_algorithm_t alg, unsigned flags )
{
TEST_CLASSIFICATION_MACRO( ALG_IS_VENDOR_DEFINED, alg, flags );
TEST_CLASSIFICATION_MACRO( ALG_IS_HMAC, alg, flags );
TEST_CLASSIFICATION_MACRO( ALG_IS_BLOCK_CIPHER_MAC, alg, flags );
TEST_CLASSIFICATION_MACRO( ALG_IS_STREAM_CIPHER, alg, flags );
TEST_CLASSIFICATION_MACRO( ALG_IS_RSA_PKCS1V15_SIGN, alg, flags );
TEST_CLASSIFICATION_MACRO( ALG_IS_RSA_PSS, alg, flags );
TEST_CLASSIFICATION_MACRO( ALG_IS_DSA, alg, flags );
if ( PSA_ALG_IS_DSA( alg ) )
TEST_CLASSIFICATION_MACRO( ALG_DSA_IS_DETERMINISTIC, alg, flags );
TEST_CLASSIFICATION_MACRO( ALG_IS_DETERMINISTIC_DSA, alg, flags );
TEST_CLASSIFICATION_MACRO( ALG_IS_RANDOMIZED_DSA, alg, flags );
TEST_CLASSIFICATION_MACRO( ALG_IS_ECDSA, alg, flags );
if ( PSA_ALG_IS_ECDSA( alg ) )
TEST_CLASSIFICATION_MACRO( ALG_ECDSA_IS_DETERMINISTIC, alg, flags );
TEST_CLASSIFICATION_MACRO( ALG_IS_DETERMINISTIC_ECDSA, alg, flags );
TEST_CLASSIFICATION_MACRO( ALG_IS_RANDOMIZED_ECDSA, alg, flags );
TEST_CLASSIFICATION_MACRO( ALG_IS_RSA_OAEP, alg, flags );
TEST_CLASSIFICATION_MACRO( ALG_IS_HKDF, alg, flags );
exit: ;
}
Key type validation tests For all key types, validate feature test macros (PSA_KEY_TYPE_IS_xxx). For asymmetric keys (public key or key pair), validate the corresponding public/pair type. For ECC keys, validate GET_CURVE.
2018-08-22 16:43:09 +00:00
void key_type_classification( psa_key_type_t type, unsigned flags )
{
/* Macros tested based on the test case parameter */
TEST_CLASSIFICATION_MACRO( KEY_TYPE_IS_VENDOR_DEFINED, type, flags );
TEST_CLASSIFICATION_MACRO( KEY_TYPE_IS_UNSTRUCTURED, type, flags );
TEST_CLASSIFICATION_MACRO( KEY_TYPE_IS_PUBLIC_KEY, type, flags );
TEST_CLASSIFICATION_MACRO( KEY_TYPE_IS_KEYPAIR, type, flags );
TEST_CLASSIFICATION_MACRO( KEY_TYPE_IS_RSA, type, flags );
TEST_CLASSIFICATION_MACRO( KEY_TYPE_IS_ECC, type, flags );
/* Macros with derived semantics */
TEST_ASSERT( PSA_KEY_TYPE_IS_ASYMMETRIC( type ) ==
( PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ||
PSA_KEY_TYPE_IS_KEYPAIR( type ) ) );
TEST_ASSERT( PSA_KEY_TYPE_IS_ECC_KEYPAIR( type ) ==
( PSA_KEY_TYPE_IS_ECC( type ) &&
PSA_KEY_TYPE_IS_KEYPAIR( type ) ) );
TEST_ASSERT( PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY( type ) ==
( PSA_KEY_TYPE_IS_ECC( type ) &&
PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ) );
exit: ;
}
Add metadata tests for truncated MAC and short-tag AEAD
2018-09-24 20:09:46 +00:00
void mac_algorithm_core( psa_algorithm_t alg, int classification_flags,
psa_key_type_t key_type, size_t key_bits,
size_t length )
{
/* Algorithm classification */
TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
TEST_ASSERT( PSA_ALG_IS_MAC( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
New algorithm category: key selection A key selection algorithm is similar to a key derivation algorithm in that it takes a secret input and produces a secret output stream. However, unlike key derivation algorithms, there is no expectation that the input cannot be reconstructed from the output. Key selection algorithms are exclusively meant to be used on the output of a key agreement algorithm to select chunks of the shared secret.
2018-09-18 09:52:10 +00:00
TEST_ASSERT( ! PSA_ALG_IS_KEY_SELECTION( alg ) );
Add metadata tests for truncated MAC and short-tag AEAD
2018-09-24 20:09:46 +00:00
algorithm_classification( alg, classification_flags );
/* Length */
TEST_ASSERT( length == PSA_MAC_FINAL_SIZE( key_type, key_bits, alg ) );
exit: ;
}
void aead_algorithm_core( psa_algorithm_t alg, int classification_flags,
size_t tag_length )
{
/* Algorithm classification */
TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
TEST_ASSERT( PSA_ALG_IS_AEAD( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
New algorithm category: key selection A key selection algorithm is similar to a key derivation algorithm in that it takes a secret input and produces a secret output stream. However, unlike key derivation algorithms, there is no expectation that the input cannot be reconstructed from the output. Key selection algorithms are exclusively meant to be used on the output of a key agreement algorithm to select chunks of the shared secret.
2018-09-18 09:52:10 +00:00
TEST_ASSERT( ! PSA_ALG_IS_KEY_SELECTION( alg ) );
Add metadata tests for truncated MAC and short-tag AEAD
2018-09-24 20:09:46 +00:00
algorithm_classification( alg, classification_flags );
/* Tag length */
TEST_ASSERT( tag_length == PSA_AEAD_TAG_LENGTH( alg ) );
exit: ;
}
Create infrastructure for metadata validation unit tests
2018-08-21 16:20:20 +00:00
/* END_HEADER */
/* BEGIN_DEPENDENCIES
* depends_on:MBEDTLS_PSA_CRYPTO_C
* END_DEPENDENCIES
*/
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
/* BEGIN_CASE */
void hash_algorithm( int alg_arg, int length_arg )
{
psa_algorithm_t alg = alg_arg;
size_t length = length_arg;
psa_algorithm_t hmac_alg = PSA_ALG_HMAC( alg );
psa_algorithm_t rsa_pkcs1v15_sign_alg = PSA_ALG_RSA_PKCS1V15_SIGN( alg );
psa_algorithm_t rsa_pss_alg = PSA_ALG_RSA_PSS( alg );
psa_algorithm_t dsa_alg = PSA_ALG_DSA( alg );
psa_algorithm_t deterministic_dsa_alg = PSA_ALG_DETERMINISTIC_DSA( alg );
psa_algorithm_t ecdsa_alg = PSA_ALG_ECDSA( alg );
psa_algorithm_t deterministic_ecdsa_alg = PSA_ALG_DETERMINISTIC_ECDSA( alg );
psa_algorithm_t rsa_oaep_alg = PSA_ALG_RSA_OAEP( alg );
psa_algorithm_t hkdf_alg = PSA_ALG_HKDF( alg );
/* Algorithm classification */
TEST_ASSERT( PSA_ALG_IS_HASH( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
New algorithm category: key selection A key selection algorithm is similar to a key derivation algorithm in that it takes a secret input and produces a secret output stream. However, unlike key derivation algorithms, there is no expectation that the input cannot be reconstructed from the output. Key selection algorithms are exclusively meant to be used on the output of a key agreement algorithm to select chunks of the shared secret.
2018-09-18 09:52:10 +00:00
TEST_ASSERT( ! PSA_ALG_IS_KEY_SELECTION( alg ) );
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
algorithm_classification( alg, 0 );
/* Dependent algorithms */
TEST_ASSERT( PSA_ALG_HMAC_GET_HASH( hmac_alg ) == alg );
TEST_ASSERT( PSA_ALG_SIGN_GET_HASH( rsa_pkcs1v15_sign_alg ) == alg );
TEST_ASSERT( PSA_ALG_SIGN_GET_HASH( rsa_pss_alg ) == alg );
TEST_ASSERT( PSA_ALG_SIGN_GET_HASH( dsa_alg ) == alg );
TEST_ASSERT( PSA_ALG_SIGN_GET_HASH( deterministic_dsa_alg ) == alg );
TEST_ASSERT( PSA_ALG_SIGN_GET_HASH( ecdsa_alg ) == alg );
TEST_ASSERT( PSA_ALG_SIGN_GET_HASH( deterministic_ecdsa_alg ) == alg );
TEST_ASSERT( PSA_ALG_RSA_OAEP_GET_HASH( rsa_oaep_alg ) == alg );
TEST_ASSERT( PSA_ALG_HKDF_GET_HASH( hkdf_alg ) == alg );
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
/* Hash length */
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
TEST_ASSERT( length == PSA_HASH_SIZE( alg ) );
TEST_ASSERT( length <= PSA_HASH_MAX_SIZE );
}
/* END_CASE */
/* BEGIN_CASE */
void mac_algorithm( int alg_arg, int classification_flags,
int length_arg,
int key_type_arg, int key_bits_arg )
{
psa_algorithm_t alg = alg_arg;
size_t length = length_arg;
Add metadata tests for truncated MAC and short-tag AEAD
2018-09-24 20:09:46 +00:00
size_t n;
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
size_t key_type = key_type_arg;
size_t key_bits = key_bits_arg;
Add metadata tests for truncated MAC and short-tag AEAD
2018-09-24 20:09:46 +00:00
mac_algorithm_core( alg, classification_flags,
key_type, key_bits, length );
New macro PSA_ALG_FULL_LENGTH_MAC Provide a documented way of constructing the full-length MAC algorithm from a truncated version.
2018-10-17 16:28:05 +00:00
TEST_ASSERT( PSA_ALG_FULL_LENGTH_MAC( alg ) == alg );
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
TEST_ASSERT( length <= PSA_MAC_MAX_SIZE );
Add metadata tests for truncated MAC and short-tag AEAD
2018-09-24 20:09:46 +00:00
/* Truncated versions */
for( n = 1; n <= length; n++ )
{
psa_algorithm_t truncated_alg = PSA_ALG_TRUNCATED_MAC( alg, n );
mac_algorithm_core( truncated_alg, classification_flags,
key_type, key_bits, n );
New macro PSA_ALG_FULL_LENGTH_MAC Provide a documented way of constructing the full-length MAC algorithm from a truncated version.
2018-10-17 16:28:05 +00:00
TEST_ASSERT( PSA_ALG_FULL_LENGTH_MAC( truncated_alg ) == alg );
Add metadata tests for truncated MAC and short-tag AEAD
2018-09-24 20:09:46 +00:00
/* Check that calling PSA_ALG_TRUNCATED_MAC twice gives the length
* of the outer truncation (even if the outer length is smaller than
* the inner length). */
TEST_ASSERT( PSA_ALG_TRUNCATED_MAC( truncated_alg, 1 ) ==
PSA_ALG_TRUNCATED_MAC( alg, 1 ) );
TEST_ASSERT( PSA_ALG_TRUNCATED_MAC( truncated_alg, length - 1 ) ==
PSA_ALG_TRUNCATED_MAC( alg, length - 1) );
TEST_ASSERT( PSA_ALG_TRUNCATED_MAC( truncated_alg, length ) ==
PSA_ALG_TRUNCATED_MAC( alg, length ) );
}
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
}
/* END_CASE */
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
/* BEGIN_CASE */
void hmac_algorithm( int alg_arg,
int length_arg,
int block_size_arg )
{
psa_algorithm_t alg = alg_arg;
psa_algorithm_t hash_alg = PSA_ALG_HMAC_GET_HASH( alg );
size_t block_size = block_size_arg;
Add metadata tests for truncated MAC and short-tag AEAD
2018-09-24 20:09:46 +00:00
size_t length = length_arg;
size_t n;
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
TEST_ASSERT( PSA_ALG_IS_HASH( hash_alg ) );
TEST_ASSERT( PSA_ALG_HMAC( hash_alg ) == alg );
TEST_ASSERT( block_size <= PSA_HMAC_MAX_HASH_BLOCK_SIZE );
Add metadata tests for truncated MAC and short-tag AEAD
2018-09-24 20:09:46 +00:00
test_mac_algorithm( alg_arg, ALG_IS_HMAC, length,
PSA_KEY_TYPE_HMAC, PSA_BYTES_TO_BITS( length ) );
for( n = 1; n <= length; n++ )
{
psa_algorithm_t truncated_alg = PSA_ALG_TRUNCATED_MAC( alg, n );
TEST_ASSERT( PSA_ALG_HMAC_GET_HASH( truncated_alg ) == hash_alg );
}
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
}
/* END_CASE */
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
/* BEGIN_CASE */
void cipher_algorithm( int alg_arg, int classification_flags )
{
psa_algorithm_t alg = alg_arg;
/* Algorithm classification */
TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
TEST_ASSERT( PSA_ALG_IS_CIPHER( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
New algorithm category: key selection A key selection algorithm is similar to a key derivation algorithm in that it takes a secret input and produces a secret output stream. However, unlike key derivation algorithms, there is no expectation that the input cannot be reconstructed from the output. Key selection algorithms are exclusively meant to be used on the output of a key agreement algorithm to select chunks of the shared secret.
2018-09-18 09:52:10 +00:00
TEST_ASSERT( ! PSA_ALG_IS_KEY_SELECTION( alg ) );
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
algorithm_classification( alg, classification_flags );
}
/* END_CASE */
/* BEGIN_CASE */
void aead_algorithm( int alg_arg, int classification_flags,
int tag_length_arg )
{
psa_algorithm_t alg = alg_arg;
size_t tag_length = tag_length_arg;
Add metadata tests for truncated MAC and short-tag AEAD
2018-09-24 20:09:46 +00:00
size_t n;
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
Add metadata tests for truncated MAC and short-tag AEAD
2018-09-24 20:09:46 +00:00
aead_algorithm_core( alg, classification_flags, tag_length );
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
Add metadata tests for truncated MAC and short-tag AEAD
2018-09-24 20:09:46 +00:00
/* Truncated versions */
for( n = 1; n <= tag_length; n++ )
{
psa_algorithm_t truncated_alg = PSA_ALG_AEAD_WITH_TAG_LENGTH( alg, n );
aead_algorithm_core( truncated_alg, classification_flags, n );
TEST_ASSERT(
PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH( truncated_alg ) == alg );
/* Check that calling PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH twice gives
* the length of the outer truncation (even if the outer length is
* smaller than the inner length). */
TEST_ASSERT(
PSA_ALG_AEAD_WITH_TAG_LENGTH( truncated_alg, 1 ) ==
PSA_ALG_AEAD_WITH_TAG_LENGTH( alg, 1 ) );
TEST_ASSERT(
PSA_ALG_AEAD_WITH_TAG_LENGTH( truncated_alg, tag_length - 1 ) ==
PSA_ALG_AEAD_WITH_TAG_LENGTH( alg, tag_length - 1) );
TEST_ASSERT(
PSA_ALG_AEAD_WITH_TAG_LENGTH( truncated_alg, tag_length ) ==
PSA_ALG_AEAD_WITH_TAG_LENGTH( alg, tag_length ) );
}
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
}
/* END_CASE */
/* BEGIN_CASE */
void asymmetric_signature_algorithm( int alg_arg, int classification_flags )
{
psa_algorithm_t alg = alg_arg;
/* Algorithm classification */
TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
TEST_ASSERT( PSA_ALG_IS_SIGN( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
New algorithm category: key selection A key selection algorithm is similar to a key derivation algorithm in that it takes a secret input and produces a secret output stream. However, unlike key derivation algorithms, there is no expectation that the input cannot be reconstructed from the output. Key selection algorithms are exclusively meant to be used on the output of a key agreement algorithm to select chunks of the shared secret.
2018-09-18 09:52:10 +00:00
TEST_ASSERT( ! PSA_ALG_IS_KEY_SELECTION( alg ) );
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
algorithm_classification( alg, classification_flags );
}
/* END_CASE */
/* BEGIN_CASE */
void asymmetric_encryption_algorithm( int alg_arg, int classification_flags )
{
psa_algorithm_t alg = alg_arg;
/* Algorithm classification */
TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
TEST_ASSERT( PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
New algorithm category: key selection A key selection algorithm is similar to a key derivation algorithm in that it takes a secret input and produces a secret output stream. However, unlike key derivation algorithms, there is no expectation that the input cannot be reconstructed from the output. Key selection algorithms are exclusively meant to be used on the output of a key agreement algorithm to select chunks of the shared secret.
2018-09-18 09:52:10 +00:00
TEST_ASSERT( ! PSA_ALG_IS_KEY_SELECTION( alg ) );
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
algorithm_classification( alg, classification_flags );
}
/* END_CASE */
/* BEGIN_CASE */
New algorithm category: key selection A key selection algorithm is similar to a key derivation algorithm in that it takes a secret input and produces a secret output stream. However, unlike key derivation algorithms, there is no expectation that the input cannot be reconstructed from the output. Key selection algorithms are exclusively meant to be used on the output of a key agreement algorithm to select chunks of the shared secret.
2018-09-18 09:52:10 +00:00
void key_derivation_algorithm( int alg_arg, int classification_flags )
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
{
psa_algorithm_t alg = alg_arg;
/* Algorithm classification */
TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
New algorithm category: key selection A key selection algorithm is similar to a key derivation algorithm in that it takes a secret input and produces a secret output stream. However, unlike key derivation algorithms, there is no expectation that the input cannot be reconstructed from the output. Key selection algorithms are exclusively meant to be used on the output of a key agreement algorithm to select chunks of the shared secret.
2018-09-18 09:52:10 +00:00
TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
TEST_ASSERT( PSA_ALG_IS_KEY_DERIVATION( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_SELECTION( alg ) );
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
algorithm_classification( alg, classification_flags );
Key agreement: macros for finite-field Diffie-Hellman, ECDH Declare macros to represent key agreement algorithms.
2018-09-18 09:54:43 +00:00
/* Check combinations with key agreements */
TEST_ASSERT( PSA_ALG_IS_KEY_AGREEMENT( PSA_ALG_FFDH( alg ) ) );
TEST_ASSERT( PSA_ALG_IS_KEY_AGREEMENT( PSA_ALG_ECDH( alg ) ) );
TEST_ASSERT( PSA_ALG_KEY_AGREEMENT_GET_KDF( PSA_ALG_ECDH( alg ) ) == alg );
TEST_ASSERT( PSA_ALG_KEY_AGREEMENT_GET_KDF( PSA_ALG_FFDH( alg ) ) == alg );
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
}
/* END_CASE */
/* BEGIN_CASE */
New algorithm category: key selection A key selection algorithm is similar to a key derivation algorithm in that it takes a secret input and produces a secret output stream. However, unlike key derivation algorithms, there is no expectation that the input cannot be reconstructed from the output. Key selection algorithms are exclusively meant to be used on the output of a key agreement algorithm to select chunks of the shared secret.
2018-09-18 09:52:10 +00:00
void key_selection_algorithm( int alg_arg, int classification_flags )
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
{
psa_algorithm_t alg = alg_arg;
/* Algorithm classification */
TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
New algorithm category: key selection A key selection algorithm is similar to a key derivation algorithm in that it takes a secret input and produces a secret output stream. However, unlike key derivation algorithms, there is no expectation that the input cannot be reconstructed from the output. Key selection algorithms are exclusively meant to be used on the output of a key agreement algorithm to select chunks of the shared secret.
2018-09-18 09:52:10 +00:00
TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
TEST_ASSERT( PSA_ALG_IS_KEY_SELECTION( alg ) );
algorithm_classification( alg, classification_flags );
Key agreement: macros for finite-field Diffie-Hellman, ECDH Declare macros to represent key agreement algorithms.
2018-09-18 09:54:43 +00:00
/* Check combinations with key agreements */
TEST_ASSERT( PSA_ALG_IS_KEY_AGREEMENT( PSA_ALG_FFDH( alg ) ) );
TEST_ASSERT( PSA_ALG_IS_KEY_AGREEMENT( PSA_ALG_ECDH( alg ) ) );
TEST_ASSERT( PSA_ALG_KEY_AGREEMENT_GET_KDF( PSA_ALG_ECDH( alg ) ) == alg );
TEST_ASSERT( PSA_ALG_KEY_AGREEMENT_GET_KDF( PSA_ALG_FFDH( alg ) ) == alg );
New algorithm category: key selection A key selection algorithm is similar to a key derivation algorithm in that it takes a secret input and produces a secret output stream. However, unlike key derivation algorithms, there is no expectation that the input cannot be reconstructed from the output. Key selection algorithms are exclusively meant to be used on the output of a key agreement algorithm to select chunks of the shared secret.
2018-09-18 09:52:10 +00:00
}
/* END_CASE */
/* BEGIN_CASE */
void key_agreement_algorithm( int alg_arg, int classification_flags,
int post_alg_arg )
{
psa_algorithm_t alg = alg_arg;
psa_algorithm_t actual_post_alg = PSA_ALG_KEY_AGREEMENT_GET_KDF( alg );
psa_algorithm_t expected_post_alg = post_alg_arg;
/* Algorithm classification */
TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
TEST_ASSERT( PSA_ALG_IS_KEY_AGREEMENT( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
TEST_ASSERT( ! PSA_ALG_IS_KEY_SELECTION( alg ) );
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
algorithm_classification( alg, classification_flags );
New algorithm category: key selection A key selection algorithm is similar to a key derivation algorithm in that it takes a secret input and produces a secret output stream. However, unlike key derivation algorithms, there is no expectation that the input cannot be reconstructed from the output. Key selection algorithms are exclusively meant to be used on the output of a key agreement algorithm to select chunks of the shared secret.
2018-09-18 09:52:10 +00:00
/* Shared secret derivation properties */
TEST_ASSERT( PSA_ALG_IS_KEY_DERIVATION( actual_post_alg ) ||
PSA_ALG_IS_KEY_SELECTION( actual_post_alg ) );
TEST_ASSERT( actual_post_alg == expected_post_alg );
Algorithm validation tests For all algorithms, validate feature test macros (PSA_ALG_IS_xxx). For hash algorithms, validate the exact hash size, and validate xxx_GET_HASH macros on dependent algorithms. For MAC algorithms, validate the MAC size. For AEAD algorithms, validate the tag size. There is a separate test case for each HMAC algorithm, which is necessary because each has its own MAC size. For other hash-dependent algorithms, there is no interesting variation to test here, so only one hash gets tested.
2018-08-22 16:36:36 +00:00
}
/* END_CASE */
Key type validation tests For all key types, validate feature test macros (PSA_KEY_TYPE_IS_xxx). For asymmetric keys (public key or key pair), validate the corresponding public/pair type. For ECC keys, validate GET_CURVE.
2018-08-22 16:43:09 +00:00
/* BEGIN_CASE */
void key_type( int type_arg, int classification_flags )
{
psa_key_type_t type = type_arg;
key_type_classification( type, classification_flags );
/* For asymmetric types, check the corresponding pair/public type */
if( classification_flags & KEY_TYPE_IS_PUBLIC_KEY )
{
psa_key_type_t pair_type = PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY( type );
TEST_ASSERT( PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR( pair_type ) == type );
key_type_classification( pair_type,
( classification_flags
& ~KEY_TYPE_IS_PUBLIC_KEY )
| KEY_TYPE_IS_KEYPAIR );
TEST_ASSERT( PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR( type ) == type );
}
if( classification_flags & KEY_TYPE_IS_KEYPAIR )
{
psa_key_type_t public_type = PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR( type );
TEST_ASSERT( PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY( public_type ) == type );
key_type_classification( public_type,
( classification_flags
& ~KEY_TYPE_IS_KEYPAIR )
| KEY_TYPE_IS_PUBLIC_KEY );
TEST_ASSERT( PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY( type ) == type );
}
}
/* END_CASE */
/* BEGIN_CASE */
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
void ecc_key_types( int curve_arg, int curve_bits_arg )
Key type validation tests For all key types, validate feature test macros (PSA_KEY_TYPE_IS_xxx). For asymmetric keys (public key or key pair), validate the corresponding public/pair type. For ECC keys, validate GET_CURVE.
2018-08-22 16:43:09 +00:00
{
psa_ecc_curve_t curve = curve_arg;
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
size_t curve_bits = curve_bits_arg;
Key type validation tests For all key types, validate feature test macros (PSA_KEY_TYPE_IS_xxx). For asymmetric keys (public key or key pair), validate the corresponding public/pair type. For ECC keys, validate GET_CURVE.
2018-08-22 16:43:09 +00:00
psa_key_type_t public_type = PSA_KEY_TYPE_ECC_PUBLIC_KEY( curve );
psa_key_type_t pair_type = PSA_KEY_TYPE_ECC_KEYPAIR( curve );
test_key_type( public_type, KEY_TYPE_IS_ECC | KEY_TYPE_IS_PUBLIC_KEY );
test_key_type( pair_type, KEY_TYPE_IS_ECC | KEY_TYPE_IS_KEYPAIR );
TEST_ASSERT( PSA_KEY_TYPE_GET_CURVE( public_type ) == curve );
TEST_ASSERT( PSA_KEY_TYPE_GET_CURVE( pair_type ) == curve );
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
/* Validate that the bit size is less than the maximum ECC bit size
* in this implementation. There's no parameter that should be equal
* to curve_bits and can be validated without creating a key. */
TEST_ASSERT( curve_bits <= PSA_VENDOR_ECC_MAX_CURVE_BITS );
Key type validation tests For all key types, validate feature test macros (PSA_KEY_TYPE_IS_xxx). For asymmetric keys (public key or key pair), validate the corresponding public/pair type. For ECC keys, validate GET_CURVE.
2018-08-22 16:43:09 +00:00
}
/* END_CASE */
Reference in a new issue Copy permalink