yuzu/mbedtls
1
0
Fork 0
mirror of https://github.com/yuzu-emu/mbedtls.git synced 2024-12-26 12:15:44 +00:00
Code Issues Packages Projects Releases Wiki Activity
mbedtls/tests/suites/test_suite_psa_crypto_metadata.data

461 lines
14 KiB
Plaintext
Raw Normal View History

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
Hash: MD2
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_MD2_C
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
hash_algorithm:PSA_ALG_MD2:16
Hash: MD4
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_MD4_C
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
hash_algorithm:PSA_ALG_MD4:16
Hash: MD5
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_MD5_C
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
hash_algorithm:PSA_ALG_MD5:16
Hash: RIPEMD160
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_RIPEMD160_C
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
hash_algorithm:PSA_ALG_RIPEMD160:20
Hash: SHA-1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA1_C
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
hash_algorithm:PSA_ALG_SHA_1:20
Hash: SHA-2 SHA-224
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA256_C
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
hash_algorithm:PSA_ALG_SHA_224:28
Hash: SHA-2 SHA-256
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA256_C
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
hash_algorithm:PSA_ALG_SHA_256:32
Hash: SHA-2 SHA-384
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA512_C
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
hash_algorithm:PSA_ALG_SHA_384:48
Hash: SHA-2 SHA-512
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA512_C
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
hash_algorithm:PSA_ALG_SHA_512:64
Hash: SHA-2 SHA-512/224
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA512_C:MBEDTLS_SHA512_256
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
hash_algorithm:PSA_ALG_SHA_512_224:28
Hash: SHA-2 SHA-512/256
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA512_C:MBEDTLS_SHA512_256
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
hash_algorithm:PSA_ALG_SHA_512_256:32
Hash: SHA-3 SHA3-224
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA3_C
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
hash_algorithm:PSA_ALG_SHA3_224:28
Hash: SHA-3 SHA3-256
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA3_C
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
hash_algorithm:PSA_ALG_SHA3_256:32
Hash: SHA-3 SHA3-384
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA3_C
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
hash_algorithm:PSA_ALG_SHA3_384:48
Hash: SHA-3 SHA3-512
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA3_C
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
hash_algorithm:PSA_ALG_SHA3_512:64
MAC: HMAC-MD2
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_MD2_C
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_MD2 ):16:64
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
MAC: HMAC-MD4
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_MD4_C
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_MD4 ):16:64
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
MAC: HMAC-MD5
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_MD5_C
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_MD5 ):16:64
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
MAC: HMAC-RIPEMD160
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_RIPEMD160_C
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_RIPEMD160 ):20:64
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
MAC: HMAC-SHA-1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA1_C
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_SHA_1 ):20:64
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
MAC: HMAC-SHA-224
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA256_C
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_SHA_224 ):28:64
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
MAC: HMAC-SHA-256
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA256_C
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_SHA_256 ):32:64
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
MAC: HMAC-SHA-384
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA512_C
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_SHA_384 ):48:128
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
MAC: HMAC-SHA-512
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA512_C
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_SHA_512 ):64:128
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
MAC: HMAC-SHA-512/224
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA512_C:MBEDTLS_SHA512_256
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_SHA_512_224 ):28:128
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
MAC: HMAC-SHA-512/256
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA512_C:MBEDTLS_SHA512_256
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_SHA_512_256 ):32:128
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
MAC: HMAC-SHA3-224
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA3_C
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_SHA3_224 ):28:144
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
MAC: HMAC-SHA3-256
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA3_C
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_SHA3_256 ):32:136
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
MAC: HMAC-SHA3-384
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA3_C
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_SHA3_384 ):48:104
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
MAC: HMAC-SHA3-512
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA3_C
Add block sizes to HMAC metadata validation tests
2018-09-17 12:13:26 +00:00
hmac_algorithm:PSA_ALG_HMAC( PSA_ALG_SHA3_512 ):64:72
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
MAC: CBC_MAC-AES-128
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_AES_C:MBEDTLS_CIPHER_C
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
mac_algorithm:PSA_ALG_CBC_MAC:ALG_IS_BLOCK_CIPHER_MAC:16:PSA_KEY_TYPE_AES:128
MAC: CBC_MAC-AES-192
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_AES_C:MBEDTLS_CIPHER_C
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
mac_algorithm:PSA_ALG_CBC_MAC:ALG_IS_BLOCK_CIPHER_MAC:16:PSA_KEY_TYPE_AES:192
MAC: CBC_MAC-AES-256
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_AES_C:MBEDTLS_CIPHER_C
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
mac_algorithm:PSA_ALG_CBC_MAC:ALG_IS_BLOCK_CIPHER_MAC:16:PSA_KEY_TYPE_AES:256
MAC: CBC_MAC-3DES
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_DES_C:MBEDTLS_CIPHER_C
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
mac_algorithm:PSA_ALG_CBC_MAC:ALG_IS_BLOCK_CIPHER_MAC:8:PSA_KEY_TYPE_DES:192
MAC: CMAC-AES-128
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_AES_C:MBEDTLS_CMAC_C
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
mac_algorithm:PSA_ALG_CMAC:ALG_IS_BLOCK_CIPHER_MAC:16:PSA_KEY_TYPE_AES:128
MAC: CMAC-AES-192
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_AES_C:MBEDTLS_CMAC_C
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
mac_algorithm:PSA_ALG_CMAC:ALG_IS_BLOCK_CIPHER_MAC:16:PSA_KEY_TYPE_AES:192
MAC: CMAC-AES-256
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_AES_C:MBEDTLS_CMAC_C
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
mac_algorithm:PSA_ALG_CMAC:ALG_IS_BLOCK_CIPHER_MAC:16:PSA_KEY_TYPE_AES:256
MAC: CMAC-3DES
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_DES_C:MBEDTLS_CMAC_C
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
mac_algorithm:PSA_ALG_CMAC:ALG_IS_BLOCK_CIPHER_MAC:8:PSA_KEY_TYPE_DES:192
Cipher: ARC4
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ARC4_C
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
cipher_algorithm:PSA_ALG_ARC4:ALG_IS_STREAM_CIPHER
Declare ChaCha20 cipher and AEAD Declare algorithms for ChaCha20 and ChaCha20-Poly1305, and a corresponding (common) key type. Don't declare Poly1305 as a separate algorithm because it's a one-time authenticator, not a MAC, so the API isn't suitable for it (no way to use a nonce).
2019-05-06 13:20:04 +00:00
Cipher: ChaCha20
depends_on:MBEDTLS_CHACHA_C
cipher_algorithm:PSA_ALG_CHACHA20:ALG_IS_STREAM_CIPHER
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
Cipher: CTR
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_CIPHER_C:MBEDTLS_CIPHER_MODE_CTR
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
cipher_algorithm:PSA_ALG_CTR:ALG_IS_STREAM_CIPHER
Cipher: CFB
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_CIPHER_C:MBEDTLS_CIPHER_MODE_CFB
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
cipher_algorithm:PSA_ALG_CFB:ALG_IS_STREAM_CIPHER
Cipher: OFB
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_CIPHER_C:MBEDTLS_CIPHER_MODE_OFB
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
cipher_algorithm:PSA_ALG_OFB:ALG_IS_STREAM_CIPHER
Cipher: CBC-nopad
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_CIPHER_C:MBEDTLS_CIPHER_MODE_CBC
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
cipher_algorithm:PSA_ALG_CBC_NO_PADDING:0
Cipher: CBC-PKCS#7
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_CIPHER_C:MBEDTLS_CIPHER_MODE_CBC:MBEDTLS_CIPHER_PADDING_PKCS7
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
cipher_algorithm:PSA_ALG_CBC_PKCS7:0
Cipher: XTS
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_CIPHER_C:MBEDTLS_CIPHER_MODE_XTS
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
cipher_algorithm:PSA_ALG_XTS:0
AEAD: CCM
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_CCM_C
Algorithm encoding: add flag bit PSA_ALG_AEAD_FROM_BLOCK_FLAG Make it easy to distinguish generic constructions on top of block ciphers, such as CCM or GCM, from specialized algorithms such as Chacha20-Poly1305.
2019-05-06 13:10:16 +00:00
aead_algorithm:PSA_ALG_CCM:ALG_IS_AEAD_ON_BLOCK_CIPHER:16
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
AEAD: GCM
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_GCM_C
Algorithm encoding: add flag bit PSA_ALG_AEAD_FROM_BLOCK_FLAG Make it easy to distinguish generic constructions on top of block ciphers, such as CCM or GCM, from specialized algorithms such as Chacha20-Poly1305.
2019-05-06 13:10:16 +00:00
aead_algorithm:PSA_ALG_GCM:ALG_IS_AEAD_ON_BLOCK_CIPHER:16
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
Declare ChaCha20 cipher and AEAD Declare algorithms for ChaCha20 and ChaCha20-Poly1305, and a corresponding (common) key type. Don't declare Poly1305 as a separate algorithm because it's a one-time authenticator, not a MAC, so the API isn't suitable for it (no way to use a nonce).
2019-05-06 13:20:04 +00:00
AEAD: ChaCha20_Poly1305
depends_on:MBEDTLS_CHACHAPOLY_C
aead_algorithm:PSA_ALG_CHACHA20_POLY1305:0:16
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
Asymmetric signature: RSA PKCS#1 v1.5 raw
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_RSA_C:MBEDTLS_PKCS1_V15
New macro PSA_ALG_IS_HASH_AND_SIGN Test for a subclass of public-key algorithm: those that perform full-domain hashing, i.e. algorithms that can be broken down as sign(key, hash(message)).
2019-01-14 15:02:15 +00:00
asymmetric_signature_algorithm:PSA_ALG_RSA_PKCS1V15_SIGN_RAW:ALG_IS_RSA_PKCS1V15_SIGN | ALG_IS_HASH_AND_SIGN
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
Asymmetric signature: RSA PKCS#1 v1.5 SHA-256
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_RSA_C:MBEDTLS_PKCS1_V15:MBEDTLS_SHA256_C
New macro PSA_ALG_IS_HASH_AND_SIGN Test for a subclass of public-key algorithm: those that perform full-domain hashing, i.e. algorithms that can be broken down as sign(key, hash(message)).
2019-01-14 15:02:15 +00:00
asymmetric_signature_algorithm:PSA_ALG_RSA_PKCS1V15_SIGN( PSA_ALG_SHA_256 ):ALG_IS_RSA_PKCS1V15_SIGN | ALG_IS_HASH_AND_SIGN
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
Asymmetric signature: RSA PSS SHA-256
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_RSA_C:MBEDTLS_PKCS1_V21:MBEDTLS_SHA256_C
New macro PSA_ALG_IS_HASH_AND_SIGN Test for a subclass of public-key algorithm: those that perform full-domain hashing, i.e. algorithms that can be broken down as sign(key, hash(message)).
2019-01-14 15:02:15 +00:00
asymmetric_signature_algorithm:PSA_ALG_RSA_PSS( PSA_ALG_SHA_256 ):ALG_IS_RSA_PSS | ALG_IS_HASH_AND_SIGN
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
Asymmetric signature: SHA-256 + randomized DSA SHA-256 using SHA-256
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_DSA_C:MBEDTLS_SHA256_C
New macro PSA_ALG_IS_HASH_AND_SIGN Test for a subclass of public-key algorithm: those that perform full-domain hashing, i.e. algorithms that can be broken down as sign(key, hash(message)).
2019-01-14 15:02:15 +00:00
asymmetric_signature_algorithm:PSA_ALG_DSA( PSA_ALG_SHA_256 ):ALG_IS_DSA | ALG_IS_RANDOMIZED_DSA | ALG_IS_HASH_AND_SIGN
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
Uniquify test case descriptions Make check-test-cases.py pass. Prior to this commit, there were many repeated test descriptions, but none with the same test data and dependencies and comments, as checked with the following command: for x in tests/suites/*.data; do perl -00 -ne 'warn "$ARGV: $. = $seen{$_}\n" if $seen{$_}; $seen{$_}=$.' $x; done Wherever a test suite contains multiple test cases with the exact same description, add " [#1]", " [#2]", etc. to make the descriptions unique. We don't currently use this particular arrangement of punctuation, so all occurrences of " [#" were added by this script. I used the following ad hoc code: import sys def fix_test_suite(data_file_name): in_paragraph = False total = {} index = {} lines = None with open(data_file_name) as data_file: lines = list(data_file.readlines()) for line in lines: if line == '\n': in_paragraph = False continue if line.startswith('#'): continue if not in_paragraph: # This is a test case description line. total[line] = total.get(line, 0) + 1 index[line] = 0 in_paragraph = True with open(data_file_name, 'w') as data_file: for line in lines: if line in total and total[line] > 1: index[line] += 1 line = '%s [#%d]\n' % (line[:-1], index[line]) data_file.write(line) for data_file_name in sys.argv[1:]: fix_test_suite(data_file_name)
2019-09-19 19:20:26 +00:00
Asymmetric signature: SHA-256 + deterministic DSA using SHA-256 [#1]
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_DSA_C:MBEDTLS_SHA256_C:MBEDTLS_DSA_DETERMINISTIC
New macro PSA_ALG_IS_HASH_AND_SIGN Test for a subclass of public-key algorithm: those that perform full-domain hashing, i.e. algorithms that can be broken down as sign(key, hash(message)).
2019-01-14 15:02:15 +00:00
asymmetric_signature_algorithm:PSA_ALG_DETERMINISTIC_DSA( PSA_ALG_SHA_256 ):ALG_IS_DSA | ALG_IS_DETERMINISTIC_DSA | ALG_DSA_IS_DETERMINISTIC | ALG_IS_HASH_AND_SIGN
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
Asymmetric signature: randomized ECDSA (no hashing)
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECDSA_C
New macro PSA_ALG_IS_HASH_AND_SIGN Test for a subclass of public-key algorithm: those that perform full-domain hashing, i.e. algorithms that can be broken down as sign(key, hash(message)).
2019-01-14 15:02:15 +00:00
asymmetric_signature_algorithm:PSA_ALG_ECDSA_ANY:ALG_IS_ECDSA | ALG_IS_RANDOMIZED_ECDSA | ALG_IS_HASH_AND_SIGN
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
Asymmetric signature: SHA-256 + randomized ECDSA
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECDSA_C:MBEDTLS_SHA256_C
New macro PSA_ALG_IS_HASH_AND_SIGN Test for a subclass of public-key algorithm: those that perform full-domain hashing, i.e. algorithms that can be broken down as sign(key, hash(message)).
2019-01-14 15:02:15 +00:00
asymmetric_signature_algorithm:PSA_ALG_ECDSA( PSA_ALG_SHA_256 ):ALG_IS_ECDSA | ALG_IS_RANDOMIZED_ECDSA | ALG_IS_HASH_AND_SIGN
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
Uniquify test case descriptions Make check-test-cases.py pass. Prior to this commit, there were many repeated test descriptions, but none with the same test data and dependencies and comments, as checked with the following command: for x in tests/suites/*.data; do perl -00 -ne 'warn "$ARGV: $. = $seen{$_}\n" if $seen{$_}; $seen{$_}=$.' $x; done Wherever a test suite contains multiple test cases with the exact same description, add " [#1]", " [#2]", etc. to make the descriptions unique. We don't currently use this particular arrangement of punctuation, so all occurrences of " [#" were added by this script. I used the following ad hoc code: import sys def fix_test_suite(data_file_name): in_paragraph = False total = {} index = {} lines = None with open(data_file_name) as data_file: lines = list(data_file.readlines()) for line in lines: if line == '\n': in_paragraph = False continue if line.startswith('#'): continue if not in_paragraph: # This is a test case description line. total[line] = total.get(line, 0) + 1 index[line] = 0 in_paragraph = True with open(data_file_name, 'w') as data_file: for line in lines: if line in total and total[line] > 1: index[line] += 1 line = '%s [#%d]\n' % (line[:-1], index[line]) data_file.write(line) for data_file_name in sys.argv[1:]: fix_test_suite(data_file_name)
2019-09-19 19:20:26 +00:00
Asymmetric signature: SHA-256 + deterministic DSA using SHA-256 [#2]
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECDSA_C:MBEDTLS_ECDSA_DETERMINISTIC:MBEDTLS_SHA256_C
New macro PSA_ALG_IS_HASH_AND_SIGN Test for a subclass of public-key algorithm: those that perform full-domain hashing, i.e. algorithms that can be broken down as sign(key, hash(message)).
2019-01-14 15:02:15 +00:00
asymmetric_signature_algorithm:PSA_ALG_DETERMINISTIC_ECDSA( PSA_ALG_SHA_256 ):ALG_IS_ECDSA | ALG_IS_DETERMINISTIC_ECDSA | ALG_ECDSA_IS_DETERMINISTIC | ALG_IS_HASH_AND_SIGN
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 a hash wildcard value for hash-and-sign algorithm You can use PSA_ALG_ANY_HASH to build the algorithm value for a hash-and-sign algorithm in a policy. Then the policy allows usage with this hash-and-sign family with any hash. Test that PSA_ALG_ANY_HASH-based policies allow a specific hash, but not a different hash-and-sign family. Test that PSA_ALG_ANY_HASH is not valid for operations, only in policies.
2019-01-14 15:06:39 +00:00
Asymmetric signature: RSA PKCS#1 v1.5 with wildcard hash
depends_on:MBEDTLS_RSA_C:MBEDTLS_PKCS1_V15
asymmetric_signature_wildcard:PSA_ALG_RSA_PKCS1V15_SIGN( PSA_ALG_ANY_HASH ):ALG_IS_RSA_PKCS1V15_SIGN
Asymmetric signature: RSA PSS with wildcard hash
depends_on:MBEDTLS_RSA_C:MBEDTLS_PKCS1_V21
asymmetric_signature_wildcard:PSA_ALG_RSA_PSS( PSA_ALG_ANY_HASH ):ALG_IS_RSA_PSS
Asymmetric signature: randomized DSA with wildcard hash
depends_on:MBEDTLS_DSA_C
asymmetric_signature_wildcard:PSA_ALG_DSA( PSA_ALG_ANY_HASH ):ALG_IS_DSA | ALG_IS_RANDOMIZED_DSA
Uniquify test case descriptions Make check-test-cases.py pass. Prior to this commit, there were many repeated test descriptions, but none with the same test data and dependencies and comments, as checked with the following command: for x in tests/suites/*.data; do perl -00 -ne 'warn "$ARGV: $. = $seen{$_}\n" if $seen{$_}; $seen{$_}=$.' $x; done Wherever a test suite contains multiple test cases with the exact same description, add " [#1]", " [#2]", etc. to make the descriptions unique. We don't currently use this particular arrangement of punctuation, so all occurrences of " [#" were added by this script. I used the following ad hoc code: import sys def fix_test_suite(data_file_name): in_paragraph = False total = {} index = {} lines = None with open(data_file_name) as data_file: lines = list(data_file.readlines()) for line in lines: if line == '\n': in_paragraph = False continue if line.startswith('#'): continue if not in_paragraph: # This is a test case description line. total[line] = total.get(line, 0) + 1 index[line] = 0 in_paragraph = True with open(data_file_name, 'w') as data_file: for line in lines: if line in total and total[line] > 1: index[line] += 1 line = '%s [#%d]\n' % (line[:-1], index[line]) data_file.write(line) for data_file_name in sys.argv[1:]: fix_test_suite(data_file_name)
2019-09-19 19:20:26 +00:00
Asymmetric signature: deterministic DSA with wildcard hash [#1]
Add a hash wildcard value for hash-and-sign algorithm You can use PSA_ALG_ANY_HASH to build the algorithm value for a hash-and-sign algorithm in a policy. Then the policy allows usage with this hash-and-sign family with any hash. Test that PSA_ALG_ANY_HASH-based policies allow a specific hash, but not a different hash-and-sign family. Test that PSA_ALG_ANY_HASH is not valid for operations, only in policies.
2019-01-14 15:06:39 +00:00
depends_on:MBEDTLS_DSA_C:MBEDTLS_DSA_DETERMINISTIC
asymmetric_signature_wildcard:PSA_ALG_DETERMINISTIC_DSA( PSA_ALG_ANY_HASH ):ALG_IS_DSA | ALG_IS_DETERMINISTIC_DSA | ALG_DSA_IS_DETERMINISTIC
Asymmetric signature: randomized ECDSA with wildcard hash
depends_on:MBEDTLS_ECDSA_C
asymmetric_signature_wildcard:PSA_ALG_ECDSA( PSA_ALG_ANY_HASH ):ALG_IS_ECDSA | ALG_IS_RANDOMIZED_ECDSA
Uniquify test case descriptions Make check-test-cases.py pass. Prior to this commit, there were many repeated test descriptions, but none with the same test data and dependencies and comments, as checked with the following command: for x in tests/suites/*.data; do perl -00 -ne 'warn "$ARGV: $. = $seen{$_}\n" if $seen{$_}; $seen{$_}=$.' $x; done Wherever a test suite contains multiple test cases with the exact same description, add " [#1]", " [#2]", etc. to make the descriptions unique. We don't currently use this particular arrangement of punctuation, so all occurrences of " [#" were added by this script. I used the following ad hoc code: import sys def fix_test_suite(data_file_name): in_paragraph = False total = {} index = {} lines = None with open(data_file_name) as data_file: lines = list(data_file.readlines()) for line in lines: if line == '\n': in_paragraph = False continue if line.startswith('#'): continue if not in_paragraph: # This is a test case description line. total[line] = total.get(line, 0) + 1 index[line] = 0 in_paragraph = True with open(data_file_name, 'w') as data_file: for line in lines: if line in total and total[line] > 1: index[line] += 1 line = '%s [#%d]\n' % (line[:-1], index[line]) data_file.write(line) for data_file_name in sys.argv[1:]: fix_test_suite(data_file_name)
2019-09-19 19:20:26 +00:00
Asymmetric signature: deterministic DSA with wildcard hash [#2]
Add a hash wildcard value for hash-and-sign algorithm You can use PSA_ALG_ANY_HASH to build the algorithm value for a hash-and-sign algorithm in a policy. Then the policy allows usage with this hash-and-sign family with any hash. Test that PSA_ALG_ANY_HASH-based policies allow a specific hash, but not a different hash-and-sign family. Test that PSA_ALG_ANY_HASH is not valid for operations, only in policies.
2019-01-14 15:06:39 +00:00
depends_on:MBEDTLS_ECDSA_C:MBEDTLS_ECDSA_DETERMINISTIC
asymmetric_signature_wildcard:PSA_ALG_DETERMINISTIC_ECDSA( PSA_ALG_ANY_HASH ):ALG_IS_ECDSA | ALG_IS_DETERMINISTIC_ECDSA | ALG_ECDSA_IS_DETERMINISTIC
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
Asymmetric encryption: RSA PKCS#1 v1.5
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_RSA_C:MBEDTLS_PKCS1_V15
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
asymmetric_encryption_algorithm:PSA_ALG_RSA_PKCS1V15_CRYPT:0
Asymmetric encryption: RSA OAEP using SHA-256
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_RSA_C:MBEDTLS_PKCS1_V21:MBEDTLS_SHA256_C
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
asymmetric_encryption_algorithm:PSA_ALG_RSA_OAEP( PSA_ALG_SHA_256 ):ALG_IS_RSA_OAEP
Key derivation: HKDF using SHA-256
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_SHA256_C
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_derivation_algorithm:PSA_ALG_HKDF( PSA_ALG_SHA_256 ):ALG_IS_HKDF
Key agreement: macros for finite-field Diffie-Hellman, ECDH Declare macros to represent key agreement algorithms.
2018-09-18 09:54:43 +00:00
Key agreement: FFDH, raw output
depends_on:MBEDTLS_DHM_C
Simplify the encoding of key agreement algorithms Get rid of "key selection" algorithms (of which there was only one: raw key selection). Encode key agreement by combining a raw key agreement with a KDF, rather than passing the KDF as an argument of a key agreement macro.
2019-01-18 15:44:49 +00:00
key_agreement_algorithm:PSA_ALG_FFDH:ALG_IS_FFDH | ALG_IS_RAW_KEY_AGREEMENT:PSA_ALG_FFDH:PSA_ALG_CATEGORY_KEY_DERIVATION
Key agreement: macros for finite-field Diffie-Hellman, ECDH Declare macros to represent key agreement algorithms.
2018-09-18 09:54:43 +00:00
Key agreement: FFDH, HKDF using SHA-256
depends_on:MBEDTLS_DHM_C
Simplify the encoding of key agreement algorithms Get rid of "key selection" algorithms (of which there was only one: raw key selection). Encode key agreement by combining a raw key agreement with a KDF, rather than passing the KDF as an argument of a key agreement macro.
2019-01-18 15:44:49 +00:00
key_agreement_algorithm:PSA_ALG_KEY_AGREEMENT( PSA_ALG_FFDH, PSA_ALG_HKDF( PSA_ALG_SHA_256 ) ):ALG_IS_FFDH:PSA_ALG_FFDH:PSA_ALG_HKDF( PSA_ALG_SHA_256 )
Key agreement: macros for finite-field Diffie-Hellman, ECDH Declare macros to represent key agreement algorithms.
2018-09-18 09:54:43 +00:00
Key agreement: ECDH, raw output
depends_on:MBEDTLS_ECDH_C
Simplify the encoding of key agreement algorithms Get rid of "key selection" algorithms (of which there was only one: raw key selection). Encode key agreement by combining a raw key agreement with a KDF, rather than passing the KDF as an argument of a key agreement macro.
2019-01-18 15:44:49 +00:00
key_agreement_algorithm:PSA_ALG_ECDH:ALG_IS_ECDH | ALG_IS_RAW_KEY_AGREEMENT:PSA_ALG_ECDH:PSA_ALG_CATEGORY_KEY_DERIVATION
Key agreement: macros for finite-field Diffie-Hellman, ECDH Declare macros to represent key agreement algorithms.
2018-09-18 09:54:43 +00:00
Key agreement: ECDH, HKDF using SHA-256
depends_on:MBEDTLS_ECDH_C
Simplify the encoding of key agreement algorithms Get rid of "key selection" algorithms (of which there was only one: raw key selection). Encode key agreement by combining a raw key agreement with a KDF, rather than passing the KDF as an argument of a key agreement macro.
2019-01-18 15:44:49 +00:00
key_agreement_algorithm:PSA_ALG_KEY_AGREEMENT( PSA_ALG_ECDH, PSA_ALG_HKDF( PSA_ALG_SHA_256 ) ):ALG_IS_ECDH:PSA_ALG_ECDH:PSA_ALG_HKDF( PSA_ALG_SHA_256 )
Key agreement: macros for finite-field Diffie-Hellman, ECDH Declare macros to represent key agreement algorithms.
2018-09-18 09:54:43 +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
Key type: raw data
key_type:PSA_KEY_TYPE_RAW_DATA:KEY_TYPE_IS_UNSTRUCTURED
Key type: HMAC
key_type:PSA_KEY_TYPE_HMAC:KEY_TYPE_IS_UNSTRUCTURED
Key type: secret for key derivation
key_type:PSA_KEY_TYPE_DERIVE:KEY_TYPE_IS_UNSTRUCTURED
Key type: AES
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_AES_C
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
key_type:PSA_KEY_TYPE_AES:KEY_TYPE_IS_UNSTRUCTURED
Key type: DES
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_DES_C
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
key_type:PSA_KEY_TYPE_DES:KEY_TYPE_IS_UNSTRUCTURED
Key type: Camellia
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_CAMELLIA_C
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
key_type:PSA_KEY_TYPE_CAMELLIA:KEY_TYPE_IS_UNSTRUCTURED
Key type: ARC4
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ARC4_C
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
key_type:PSA_KEY_TYPE_ARC4:KEY_TYPE_IS_UNSTRUCTURED
Declare ChaCha20 cipher and AEAD Declare algorithms for ChaCha20 and ChaCha20-Poly1305, and a corresponding (common) key type. Don't declare Poly1305 as a separate algorithm because it's a one-time authenticator, not a MAC, so the API isn't suitable for it (no way to use a nonce).
2019-05-06 13:20:04 +00:00
Key type: ChaCha20
depends_on:MBEDTLS_CHACHA20_C
key_type:PSA_KEY_TYPE_CHACHA20:KEY_TYPE_IS_UNSTRUCTURED
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
Key type: RSA public key
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_RSA_C
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
key_type:PSA_KEY_TYPE_RSA_PUBLIC_KEY:KEY_TYPE_IS_PUBLIC_KEY | KEY_TYPE_IS_RSA
Key type: RSA key pair
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_RSA_C
Rename *KEYPAIR* to *KEY_PAIR* Be consistent with PUBLIC_KEY. perl -i -pe 's/KEYPAIR/KEY_PAIR/g' $(git ls-files)
2019-05-16 17:39:54 +00:00
key_type:PSA_KEY_TYPE_RSA_KEY_PAIR:KEY_TYPE_IS_KEY_PAIR | KEY_TYPE_IS_RSA
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
Key type: DSA public key
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_DSA_C
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
key_type:PSA_KEY_TYPE_DSA_PUBLIC_KEY:KEY_TYPE_IS_PUBLIC_KEY | KEY_TYPE_IS_DSA
Key type: DSA key pair
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_DSA_C
Rename *KEYPAIR* to *KEY_PAIR* Be consistent with PUBLIC_KEY. perl -i -pe 's/KEYPAIR/KEY_PAIR/g' $(git ls-files)
2019-05-16 17:39:54 +00:00
key_type:PSA_KEY_TYPE_DSA_KEY_PAIR:KEY_TYPE_IS_KEY_PAIR | KEY_TYPE_IS_DSA
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
ECC key types: sect163k1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECT163K1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECT163K1:163
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
ECC key types: sect163r1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECT163R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECT163R1:163
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
ECC key types: sect163r2
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECT163R2_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECT163R2:163
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
ECC key types: sect193r1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECT193R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECT193R1:193
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
ECC key types: sect193r2
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECT193R2_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECT193R2:193
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
ECC key types: sect233k1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECT233K1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECT233K1:233
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
ECC key types: sect233r1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECT233R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECT233R1:233
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
ECC key types: sect239k1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECT239K1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECT239K1:239
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
ECC key types: sect283k1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECT283K1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECT283K1:283
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
ECC key types: sect283r1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECT283R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECT283R1:283
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
ECC key types: sect409k1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECT409K1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECT409K1:409
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
ECC key types: sect409r1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECT409R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECT409R1:409
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
ECC key types: sect571k1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECT571K1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECT571K1:571
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
ECC key types: sect571r1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECT571R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECT571R1:571
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
ECC key types: secp160k1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECP160K1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECP160K1:160
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
ECC key types: secp160r1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECP160R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECP160R1:160
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
ECC key types: secp160r2
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECP160R2_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECP160R2:160
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
ECC key types: secp192k1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECP192K1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECP192K1:192
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
ECC key types: secp192r1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECP192R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECP192R1:192
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
ECC key types: secp224k1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECP224K1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECP224K1:224
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
ECC key types: secp224r1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECP224R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECP224R1:224
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
ECC key types: secp256k1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECP256K1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECP256K1:256
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
ECC key types: secp256r1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECP256R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECP256R1:256
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
ECC key types: secp384r1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECP384R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECP384R1:384
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
ECC key types: secp521r1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_SECP521R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_SECP521R1:521
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
ECC key types: Brainpool P256R1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_BP256R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_BRAINPOOL_P256R1:256
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
ECC key types: Brainpool P384R1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_BP384R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_BRAINPOOL_P384R1:384
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
ECC key types: Brainpool P512R1
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_BP512R1_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_BRAINPOOL_P512R1:512
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
ECC key types: Curve25519
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_CURVE25519_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_CURVE25519:255
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
ECC key types: Curve448
Add dependencies to metadata validation tests If some algorithms are excluded in the build, it's ok for the corresponding macros not to give the correct results. Therefore the corresponding test cases should depend on the implementation of the algorithm. For example, it's ok for PSA_HASH_MAX_SIZE to be less than PSA_HASH_SIZE(PSA_ALG_SHA_512) if we build without SHA-512 support, and we indeed do this. It's even ok for an implementation to return 0 for PSA_ALG_IS_HASH(PSA_ALG_SHA_512) if it doesn't support SHA-512; we return 1 anyway but the tests are less implementation-specific if we don't enforce it. This commit adds dependencies on symbols that don't exist in Mbed TLS, for algorithms that Mbed TLS doesn't implement. These are: MBEDTLS_SHA512_256 for SHA-512/256, MBEDTLS_SHA3_C for SHA-3, MBEDTLS_DSA_C and MBEDTLS_DSA_DETERMINISTIC for DSA, and MBEDTLS_ECP_DP_xxx_ENABLED for elliptic curves that have a PSA encoding but are not supported in Mbed TLS.
2018-09-17 11:58:36 +00:00
depends_on:MBEDTLS_ECP_DP_CURVE448_ENABLED
Add curve sizes to ECC curve metadata validation tests
2018-09-17 12:19:57 +00:00
ecc_key_types:PSA_ECC_CURVE_CURVE448:448
Parametrize Diffie-Hellman keys by a group identifier Parametrize finite-field Diffie-Hellman key types with a DH group identifier, in the same way elliptic curve keys are parametrized with an EC curve identifier. Define the DH groups from the TLS registry (these are the groups from RFC 7919). Replicate the macro definitions and the metadata tests from elliptic curve identifiers to DH group identifiers. Define PSA_DH_GROUP_CUSTOM as an implementation-specific extension for which domain parameters are used to specify the group.
2019-05-16 10:55:35 +00:00
DH group types: FFDHE2048
dh_key_types:PSA_DH_GROUP_FFDHE2048:2048
DH group types: FFDHE3072
dh_key_types:PSA_DH_GROUP_FFDHE3072:2048
DH group types: FFDHE4096
dh_key_types:PSA_DH_GROUP_FFDHE4096:2048
DH group types: FFDHE6144
dh_key_types:PSA_DH_GROUP_FFDHE6144:2048
DH group types: FFDHE8192
dh_key_types:PSA_DH_GROUP_FFDHE8192:2048
Reference in a new issue Copy permalink