Apply clang formatting.
Executed with:
`find . -regextype posix-egrep -regex ".*\.([hc]|fmt|function)" | xargs -L1 clang-format-12 -i`
Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
diff --git a/tests/suites/test_suite_pk.function b/tests/suites/test_suite_pk.function
index 454bfac..271d71e 100644
--- a/tests/suites/test_suite_pk.function
+++ b/tests/suites/test_suite_pk.function
@@ -16,7 +16,7 @@
#include "psa/crypto.h"
#define RSA_KEY_SIZE 512
-#define RSA_KEY_LEN 64
+#define RSA_KEY_LEN 64
/** Generate a key of the desired type.
*
@@ -29,59 +29,62 @@
* generation function.
* \return -1 if the key type is not recognized.
*/
-static int pk_genkey( mbedtls_pk_context *pk, int parameter )
+static int pk_genkey(mbedtls_pk_context *pk, int parameter)
{
- ((void) pk);
- (void) parameter;
+ ((void)pk);
+ (void)parameter;
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME)
- if( mbedtls_pk_get_type( pk ) == MBEDTLS_PK_RSA )
- return mbedtls_rsa_gen_key( mbedtls_pk_rsa( *pk ),
- mbedtls_test_rnd_std_rand, NULL,
- parameter, 3 );
+ if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_RSA)
+ return mbedtls_rsa_gen_key(
+ mbedtls_pk_rsa(*pk), mbedtls_test_rnd_std_rand, NULL, parameter, 3);
#endif
#if defined(MBEDTLS_ECP_C)
- if( mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECKEY ||
- mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECKEY_DH ||
- mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECDSA )
- {
+ if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_ECKEY ||
+ mbedtls_pk_get_type(pk) == MBEDTLS_PK_ECKEY_DH ||
+ mbedtls_pk_get_type(pk) == MBEDTLS_PK_ECDSA) {
int ret;
- if( ( ret = mbedtls_ecp_group_load( &mbedtls_pk_ec( *pk )->grp,
- parameter ) ) != 0 )
- return ret ;
+ if ((ret = mbedtls_ecp_group_load(&mbedtls_pk_ec(*pk)->grp,
+ parameter)) != 0)
+ return ret;
- return mbedtls_ecp_gen_keypair( &mbedtls_pk_ec( *pk )->grp,
- &mbedtls_pk_ec( *pk )->d,
- &mbedtls_pk_ec( *pk )->Q,
- mbedtls_test_rnd_std_rand, NULL );
+ return mbedtls_ecp_gen_keypair(&mbedtls_pk_ec(*pk)->grp,
+ &mbedtls_pk_ec(*pk)->d,
+ &mbedtls_pk_ec(*pk)->Q,
+ mbedtls_test_rnd_std_rand, NULL);
}
#endif
- return -1 ;
+ return -1;
}
#if defined(MBEDTLS_RSA_C)
-int mbedtls_rsa_decrypt_func( void *ctx, size_t *olen,
- const unsigned char *input, unsigned char *output,
- size_t output_max_len )
+int mbedtls_rsa_decrypt_func(void *ctx,
+ size_t *olen,
+ const unsigned char *input,
+ unsigned char *output,
+ size_t output_max_len)
{
- return( mbedtls_rsa_pkcs1_decrypt( (mbedtls_rsa_context *) ctx,
- mbedtls_test_rnd_std_rand, NULL,
- olen, input, output, output_max_len ) );
+ return (mbedtls_rsa_pkcs1_decrypt((mbedtls_rsa_context *)ctx,
+ mbedtls_test_rnd_std_rand, NULL, olen,
+ input, output, output_max_len));
}
-int mbedtls_rsa_sign_func( void *ctx,
- int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
- mbedtls_md_type_t md_alg, unsigned int hashlen,
- const unsigned char *hash, unsigned char *sig )
+int mbedtls_rsa_sign_func(void *ctx,
+ int (*f_rng)(void *, unsigned char *, size_t),
+ void *p_rng,
+ mbedtls_md_type_t md_alg,
+ unsigned int hashlen,
+ const unsigned char *hash,
+ unsigned char *sig)
{
- ((void) f_rng);
- ((void) p_rng);
- return( mbedtls_rsa_pkcs1_sign( (mbedtls_rsa_context *) ctx,
- mbedtls_test_rnd_std_rand, NULL,
- md_alg, hashlen, hash, sig ) );
+ ((void)f_rng);
+ ((void)p_rng);
+ return (mbedtls_rsa_pkcs1_sign((mbedtls_rsa_context *)ctx,
+ mbedtls_test_rnd_std_rand, NULL, md_alg,
+ hashlen, hash, sig));
}
-size_t mbedtls_rsa_key_len_func( void *ctx )
+size_t mbedtls_rsa_key_len_func(void *ctx)
{
- return ((const mbedtls_rsa_context *) ctx)->len ;
+ return ((const mbedtls_rsa_context *)ctx)->len;
}
#endif /* MBEDTLS_RSA_C */
@@ -92,22 +95,22 @@
* or 0 if the key generation failed.
* The key uses NIST P-256 and is usable for signing with SHA-256.
*/
-mbedtls_svc_key_id_t pk_psa_genkey( void )
+mbedtls_svc_key_id_t pk_psa_genkey(void)
{
mbedtls_svc_key_id_t key;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
const psa_key_type_t type =
- PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_FAMILY_SECP_R1 );
+ PSA_KEY_TYPE_ECC_KEY_PAIR(PSA_ECC_FAMILY_SECP_R1);
const size_t bits = 256;
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
- psa_set_key_algorithm( &attributes, PSA_ALG_ECDSA(PSA_ALG_SHA_256) );
- psa_set_key_type( &attributes, type );
- psa_set_key_bits( &attributes, bits );
- PSA_ASSERT( psa_generate_key( &attributes, &key ) );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH);
+ psa_set_key_algorithm(&attributes, PSA_ALG_ECDSA(PSA_ALG_SHA_256));
+ psa_set_key_type(&attributes, type);
+ psa_set_key_bits(&attributes, bits);
+ PSA_ASSERT(psa_generate_key(&attributes, &key));
exit:
- return key ;
+ return key;
}
#endif /* MBEDTLS_USE_PSA_CRYPTO */
/* END_HEADER */
@@ -118,13 +121,13 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_ECDSA_C:MBEDTLS_ECP_DP_SECP256R1_ENABLED */
-void pk_psa_utils( )
+void pk_psa_utils()
{
mbedtls_pk_context pk, pk2;
mbedtls_svc_key_id_t key;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- const char * const name = "Opaque";
+ const char *const name = "Opaque";
const size_t bitlen = 256; /* harcoded in genkey() */
mbedtls_md_type_t md_alg = MBEDTLS_MD_NONE;
@@ -132,255 +135,225 @@
size_t len;
mbedtls_pk_debug_item dbg;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- mbedtls_pk_init( &pk );
- mbedtls_pk_init( &pk2 );
+ mbedtls_pk_init(&pk);
+ mbedtls_pk_init(&pk2);
- TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
+ TEST_ASSERT(psa_crypto_init() == PSA_SUCCESS);
- TEST_ASSERT( mbedtls_pk_setup_opaque( &pk, MBEDTLS_SVC_KEY_ID_INIT ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_setup_opaque(&pk, MBEDTLS_SVC_KEY_ID_INIT) ==
+ MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- mbedtls_pk_free( &pk );
- mbedtls_pk_init( &pk );
+ mbedtls_pk_free(&pk);
+ mbedtls_pk_init(&pk);
key = pk_psa_genkey();
- if( mbedtls_svc_key_id_is_null( key ) )
+ if (mbedtls_svc_key_id_is_null(key))
goto exit;
- TEST_ASSERT( mbedtls_pk_setup_opaque( &pk, key ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup_opaque(&pk, key) == 0);
- TEST_ASSERT( mbedtls_pk_get_type( &pk ) == MBEDTLS_PK_OPAQUE );
- TEST_ASSERT( strcmp( mbedtls_pk_get_name( &pk), name ) == 0 );
+ TEST_ASSERT(mbedtls_pk_get_type(&pk) == MBEDTLS_PK_OPAQUE);
+ TEST_ASSERT(strcmp(mbedtls_pk_get_name(&pk), name) == 0);
- TEST_ASSERT( mbedtls_pk_get_bitlen( &pk ) == bitlen );
- TEST_ASSERT( mbedtls_pk_get_len( &pk ) == bitlen / 8 );
+ TEST_ASSERT(mbedtls_pk_get_bitlen(&pk) == bitlen);
+ TEST_ASSERT(mbedtls_pk_get_len(&pk) == bitlen / 8);
- TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECKEY ) == 1 );
- TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) == 1 );
- TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_RSA ) == 0 );
+ TEST_ASSERT(mbedtls_pk_can_do(&pk, MBEDTLS_PK_ECKEY) == 1);
+ TEST_ASSERT(mbedtls_pk_can_do(&pk, MBEDTLS_PK_ECDSA) == 1);
+ TEST_ASSERT(mbedtls_pk_can_do(&pk, MBEDTLS_PK_RSA) == 0);
/* unsupported operations: verify, decrypt, encrypt */
- TEST_ASSERT( mbedtls_pk_verify( &pk, md_alg,
- b1, sizeof( b1), b2, sizeof( b2 ) )
- == MBEDTLS_ERR_PK_TYPE_MISMATCH );
- TEST_ASSERT( mbedtls_pk_decrypt( &pk, b1, sizeof( b1 ),
- b2, &len, sizeof( b2 ),
- NULL, NULL )
- == MBEDTLS_ERR_PK_TYPE_MISMATCH );
- TEST_ASSERT( mbedtls_pk_encrypt( &pk, b1, sizeof( b1 ),
- b2, &len, sizeof( b2 ),
- NULL, NULL )
- == MBEDTLS_ERR_PK_TYPE_MISMATCH );
+ TEST_ASSERT(mbedtls_pk_verify(&pk, md_alg, b1, sizeof(b1), b2,
+ sizeof(b2)) == MBEDTLS_ERR_PK_TYPE_MISMATCH);
+ TEST_ASSERT(mbedtls_pk_decrypt(&pk, b1, sizeof(b1), b2, &len, sizeof(b2),
+ NULL, NULL) == MBEDTLS_ERR_PK_TYPE_MISMATCH);
+ TEST_ASSERT(mbedtls_pk_encrypt(&pk, b1, sizeof(b1), b2, &len, sizeof(b2),
+ NULL, NULL) == MBEDTLS_ERR_PK_TYPE_MISMATCH);
/* unsupported functions: check_pair, debug */
- TEST_ASSERT( mbedtls_pk_setup( &pk2,
- mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == 0 );
- TEST_ASSERT( mbedtls_pk_check_pair( &pk, &pk2,
- mbedtls_test_rnd_std_rand, NULL )
- == MBEDTLS_ERR_PK_TYPE_MISMATCH );
- TEST_ASSERT( mbedtls_pk_debug( &pk, &dbg )
- == MBEDTLS_ERR_PK_TYPE_MISMATCH );
+ TEST_ASSERT(mbedtls_pk_setup(
+ &pk2, mbedtls_pk_info_from_type(MBEDTLS_PK_ECKEY)) == 0);
+ TEST_ASSERT(mbedtls_pk_check_pair(&pk, &pk2, mbedtls_test_rnd_std_rand,
+ NULL) == MBEDTLS_ERR_PK_TYPE_MISMATCH);
+ TEST_ASSERT(mbedtls_pk_debug(&pk, &dbg) == MBEDTLS_ERR_PK_TYPE_MISMATCH);
/* test that freeing the context does not destroy the key */
- mbedtls_pk_free( &pk );
- TEST_ASSERT( PSA_SUCCESS == psa_get_key_attributes( key, &attributes ) );
- TEST_ASSERT( PSA_SUCCESS == psa_destroy_key( key ) );
+ mbedtls_pk_free(&pk);
+ TEST_ASSERT(PSA_SUCCESS == psa_get_key_attributes(key, &attributes));
+ TEST_ASSERT(PSA_SUCCESS == psa_destroy_key(key));
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- mbedtls_pk_free( &pk ); /* redundant except upon error */
- mbedtls_pk_free( &pk2 );
- USE_PSA_DONE( );
+ mbedtls_pk_free(&pk); /* redundant except upon error */
+ mbedtls_pk_free(&pk2);
+ USE_PSA_DONE();
}
/* END_CASE */
-
/* BEGIN_CASE */
-void valid_parameters( )
+void valid_parameters()
{
mbedtls_pk_context pk;
unsigned char buf[1];
size_t len;
void *options = NULL;
- mbedtls_pk_init( &pk );
+ mbedtls_pk_init(&pk);
- TEST_ASSERT( mbedtls_pk_setup( &pk, NULL ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_setup(&pk, NULL) == MBEDTLS_ERR_PK_BAD_INPUT_DATA);
/* In informational functions, we accept NULL where a context pointer
* is expected because that's what the library has done forever.
* We do not document that NULL is accepted, so we may wish to change
* the behavior in a future version. */
- TEST_ASSERT( mbedtls_pk_get_bitlen( NULL ) == 0 );
- TEST_ASSERT( mbedtls_pk_get_len( NULL ) == 0 );
- TEST_ASSERT( mbedtls_pk_can_do( NULL, MBEDTLS_PK_NONE ) == 0 );
+ TEST_ASSERT(mbedtls_pk_get_bitlen(NULL) == 0);
+ TEST_ASSERT(mbedtls_pk_get_len(NULL) == 0);
+ TEST_ASSERT(mbedtls_pk_can_do(NULL, MBEDTLS_PK_NONE) == 0);
- TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
- MBEDTLS_MD_NONE,
- NULL, 0,
- buf, sizeof( buf ), &len,
- mbedtls_test_rnd_std_rand, NULL,
- NULL ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_sign_restartable(
+ &pk, MBEDTLS_MD_NONE, NULL, 0, buf, sizeof(buf), &len,
+ mbedtls_test_rnd_std_rand, NULL,
+ NULL) == MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
- MBEDTLS_MD_NONE,
- NULL, 0,
- buf, sizeof( buf ), &len,
- mbedtls_test_rnd_std_rand, NULL,
- NULL ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_sign_restartable(
+ &pk, MBEDTLS_MD_NONE, NULL, 0, buf, sizeof(buf), &len,
+ mbedtls_test_rnd_std_rand, NULL,
+ NULL) == MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_pk_sign( &pk,
- MBEDTLS_MD_NONE,
- NULL, 0,
- buf, sizeof( buf ), &len,
- mbedtls_test_rnd_std_rand, NULL ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_sign(&pk, MBEDTLS_MD_NONE, NULL, 0, buf, sizeof(buf),
+ &len, mbedtls_test_rnd_std_rand,
+ NULL) == MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_pk_verify_restartable( &pk,
- MBEDTLS_MD_NONE,
- NULL, 0,
- buf, sizeof( buf ),
- NULL ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_verify_restartable(&pk, MBEDTLS_MD_NONE, NULL, 0,
+ buf, sizeof(buf), NULL) ==
+ MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_pk_verify( &pk,
- MBEDTLS_MD_NONE,
- NULL, 0,
- buf, sizeof( buf ) ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(
+ mbedtls_pk_verify(&pk, MBEDTLS_MD_NONE, NULL, 0, buf, sizeof(buf)) ==
+ MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
- &pk,
- MBEDTLS_MD_NONE,
- NULL, 0,
- buf, sizeof( buf ) ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_verify_ext(
+ MBEDTLS_PK_NONE, options, &pk, MBEDTLS_MD_NONE, NULL, 0,
+ buf, sizeof(buf)) == MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_pk_encrypt( &pk,
- NULL, 0,
- NULL, &len, 0,
- mbedtls_test_rnd_std_rand, NULL ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_encrypt(&pk, NULL, 0, NULL, &len, 0,
+ mbedtls_test_rnd_std_rand,
+ NULL) == MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_pk_decrypt( &pk,
- NULL, 0,
- NULL, &len, 0,
- mbedtls_test_rnd_std_rand, NULL ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_decrypt(&pk, NULL, 0, NULL, &len, 0,
+ mbedtls_test_rnd_std_rand,
+ NULL) == MBEDTLS_ERR_PK_BAD_INPUT_DATA);
#if defined(MBEDTLS_PK_PARSE_C)
- TEST_ASSERT( mbedtls_pk_parse_key( &pk, NULL, 0, NULL, 1,
- mbedtls_test_rnd_std_rand, NULL ) ==
- MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
+ TEST_ASSERT(mbedtls_pk_parse_key(&pk, NULL, 0, NULL, 1,
+ mbedtls_test_rnd_std_rand, NULL) ==
+ MBEDTLS_ERR_PK_KEY_INVALID_FORMAT);
- TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, NULL, 0 ) ==
- MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
+ TEST_ASSERT(mbedtls_pk_parse_public_key(&pk, NULL, 0) ==
+ MBEDTLS_ERR_PK_KEY_INVALID_FORMAT);
#endif /* MBEDTLS_PK_PARSE_C */
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PK_WRITE_C */
-void valid_parameters_pkwrite( data_t *key_data )
+void valid_parameters_pkwrite(data_t *key_data)
{
mbedtls_pk_context pk;
/* For the write tests to be effective, we need a valid key pair. */
- mbedtls_pk_init( &pk );
- TEST_ASSERT( mbedtls_pk_parse_key( &pk,
- key_data->x, key_data->len, NULL, 0,
- mbedtls_test_rnd_std_rand, NULL ) == 0 );
+ mbedtls_pk_init(&pk);
+ TEST_ASSERT(mbedtls_pk_parse_key(&pk, key_data->x, key_data->len, NULL, 0,
+ mbedtls_test_rnd_std_rand, NULL) == 0);
- TEST_ASSERT( mbedtls_pk_write_key_der( &pk, NULL, 0 ) ==
- MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
+ TEST_ASSERT(mbedtls_pk_write_key_der(&pk, NULL, 0) ==
+ MBEDTLS_ERR_ASN1_BUF_TOO_SMALL);
- TEST_ASSERT( mbedtls_pk_write_pubkey_der( &pk, NULL, 0 ) ==
- MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
+ TEST_ASSERT(mbedtls_pk_write_pubkey_der(&pk, NULL, 0) ==
+ MBEDTLS_ERR_ASN1_BUF_TOO_SMALL);
#if defined(MBEDTLS_PEM_WRITE_C)
- TEST_ASSERT( mbedtls_pk_write_key_pem( &pk, NULL, 0 ) ==
- MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
+ TEST_ASSERT(mbedtls_pk_write_key_pem(&pk, NULL, 0) ==
+ MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL);
- TEST_ASSERT( mbedtls_pk_write_pubkey_pem( &pk, NULL, 0 ) ==
- MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
+ TEST_ASSERT(mbedtls_pk_write_pubkey_pem(&pk, NULL, 0) ==
+ MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL);
#endif /* MBEDTLS_PEM_WRITE_C */
exit:
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE */
-void pk_utils( int type, int parameter, int bitlen, int len, char * name )
+void pk_utils(int type, int parameter, int bitlen, int len, char *name)
{
mbedtls_pk_context pk;
- mbedtls_pk_init( &pk );
+ mbedtls_pk_init(&pk);
- TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
- TEST_ASSERT( pk_genkey( &pk, parameter ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(type)) == 0);
+ TEST_ASSERT(pk_genkey(&pk, parameter) == 0);
- TEST_ASSERT( (int) mbedtls_pk_get_type( &pk ) == type );
- TEST_ASSERT( mbedtls_pk_can_do( &pk, type ) );
- TEST_ASSERT( mbedtls_pk_get_bitlen( &pk ) == (unsigned) bitlen );
- TEST_ASSERT( mbedtls_pk_get_len( &pk ) == (unsigned) len );
- TEST_ASSERT( strcmp( mbedtls_pk_get_name( &pk), name ) == 0 );
+ TEST_ASSERT((int)mbedtls_pk_get_type(&pk) == type);
+ TEST_ASSERT(mbedtls_pk_can_do(&pk, type));
+ TEST_ASSERT(mbedtls_pk_get_bitlen(&pk) == (unsigned)bitlen);
+ TEST_ASSERT(mbedtls_pk_get_len(&pk) == (unsigned)len);
+ TEST_ASSERT(strcmp(mbedtls_pk_get_name(&pk), name) == 0);
exit:
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PK_PARSE_C:MBEDTLS_FS_IO */
-void mbedtls_pk_check_pair( char * pub_file, char * prv_file, int ret )
+void mbedtls_pk_check_pair(char *pub_file, char *prv_file, int ret)
{
mbedtls_pk_context pub, prv, alt;
- mbedtls_pk_init( &pub );
- mbedtls_pk_init( &prv );
- mbedtls_pk_init( &alt );
+ mbedtls_pk_init(&pub);
+ mbedtls_pk_init(&prv);
+ mbedtls_pk_init(&alt);
- TEST_ASSERT( mbedtls_pk_parse_public_keyfile( &pub, pub_file ) == 0 );
- TEST_ASSERT( mbedtls_pk_parse_keyfile( &prv, prv_file, NULL,
- mbedtls_test_rnd_std_rand, NULL )
- == 0 );
+ TEST_ASSERT(mbedtls_pk_parse_public_keyfile(&pub, pub_file) == 0);
+ TEST_ASSERT(mbedtls_pk_parse_keyfile(&prv, prv_file, NULL,
+ mbedtls_test_rnd_std_rand, NULL) == 0);
- TEST_ASSERT( mbedtls_pk_check_pair( &pub, &prv,
- mbedtls_test_rnd_std_rand, NULL )
- == ret );
+ TEST_ASSERT(mbedtls_pk_check_pair(&pub, &prv, mbedtls_test_rnd_std_rand,
+ NULL) == ret);
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
- if( mbedtls_pk_get_type( &prv ) == MBEDTLS_PK_RSA )
- {
- TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, mbedtls_pk_rsa( prv ),
- mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func,
- mbedtls_rsa_key_len_func ) == 0 );
- TEST_ASSERT( mbedtls_pk_check_pair( &pub, &alt,
- mbedtls_test_rnd_std_rand, NULL )
- == ret );
+ if (mbedtls_pk_get_type(&prv) == MBEDTLS_PK_RSA) {
+ TEST_ASSERT(mbedtls_pk_setup_rsa_alt(
+ &alt, mbedtls_pk_rsa(prv), mbedtls_rsa_decrypt_func,
+ mbedtls_rsa_sign_func, mbedtls_rsa_key_len_func) == 0);
+ TEST_ASSERT(mbedtls_pk_check_pair(&pub, &alt, mbedtls_test_rnd_std_rand,
+ NULL) == ret);
}
#endif
- mbedtls_pk_free( &pub );
- mbedtls_pk_free( &prv );
- mbedtls_pk_free( &alt );
+ mbedtls_pk_free(&pub);
+ mbedtls_pk_free(&prv);
+ mbedtls_pk_free(&alt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
-void pk_rsa_verify_test_vec( data_t * message_str, int digest, int mod,
- int radix_N, char * input_N, int radix_E,
- char * input_E, data_t * result_str,
- int result )
+void pk_rsa_verify_test_vec(data_t *message_str,
+ int digest,
+ int mod,
+ int radix_N,
+ char *input_N,
+ int radix_E,
+ char *input_E,
+ data_t *result_str,
+ int result)
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
mbedtls_rsa_context *rsa;
@@ -390,46 +363,56 @@
mbedtls_pk_restart_ctx ctx;
rs_ctx = &ctx;
- mbedtls_pk_restart_init( rs_ctx );
+ mbedtls_pk_restart_init(rs_ctx);
// this setting would ensure restart would happen if ECC was used
- mbedtls_ecp_set_max_ops( 1 );
+ mbedtls_ecp_set_max_ops(1);
#endif
- mbedtls_pk_init( &pk );
+ mbedtls_pk_init(&pk);
- memset( hash_result, 0x00, MBEDTLS_MD_MAX_SIZE );
+ memset(hash_result, 0x00, MBEDTLS_MD_MAX_SIZE);
- TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
- rsa = mbedtls_pk_rsa( pk );
+ TEST_ASSERT(
+ mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
+ rsa = mbedtls_pk_rsa(pk);
rsa->len = mod / 8;
- TEST_ASSERT( mbedtls_test_read_mpi( &rsa->N, radix_N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &rsa->E, radix_E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&rsa->N, radix_N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&rsa->E, radix_E, input_E) == 0);
+ if (mbedtls_md_info_from_type(digest) != NULL)
+ TEST_ASSERT(mbedtls_md(mbedtls_md_info_from_type(digest),
+ message_str->x, message_str->len,
+ hash_result) == 0);
- if( mbedtls_md_info_from_type( digest ) != NULL )
- TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
+ TEST_ASSERT(mbedtls_pk_verify(&pk, digest, hash_result, 0, result_str->x,
+ mbedtls_pk_get_len(&pk)) == result);
- TEST_ASSERT( mbedtls_pk_verify( &pk, digest, hash_result, 0,
- result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
-
- TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, digest, hash_result, 0,
- result_str->x, mbedtls_pk_get_len( &pk ), rs_ctx ) == result );
+ TEST_ASSERT(mbedtls_pk_verify_restartable(
+ &pk, digest, hash_result, 0, result_str->x,
+ mbedtls_pk_get_len(&pk), rs_ctx) == result);
exit:
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
- mbedtls_pk_restart_free( rs_ctx );
+ mbedtls_pk_restart_free(rs_ctx);
#endif
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
-void pk_rsa_verify_ext_test_vec( data_t * message_str, int digest,
- int mod, int radix_N, char * input_N,
- int radix_E, char * input_E,
- data_t * result_str, int pk_type,
- int mgf1_hash_id, int salt_len, int result )
+void pk_rsa_verify_ext_test_vec(data_t *message_str,
+ int digest,
+ int mod,
+ int radix_N,
+ char *input_N,
+ int radix_E,
+ char *input_E,
+ data_t *result_str,
+ int pk_type,
+ int mgf1_hash_id,
+ int salt_len,
+ int result)
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
mbedtls_rsa_context *rsa;
@@ -438,86 +421,91 @@
void *options;
size_t hash_len;
- mbedtls_pk_init( &pk );
+ mbedtls_pk_init(&pk);
- memset( hash_result, 0x00, sizeof( hash_result ) );
+ memset(hash_result, 0x00, sizeof(hash_result));
- TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
- rsa = mbedtls_pk_rsa( pk );
+ TEST_ASSERT(
+ mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
+ rsa = mbedtls_pk_rsa(pk);
rsa->len = mod / 8;
- TEST_ASSERT( mbedtls_test_read_mpi( &rsa->N, radix_N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &rsa->E, radix_E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&rsa->N, radix_N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&rsa->E, radix_E, input_E) == 0);
-
- if( digest != MBEDTLS_MD_NONE )
- {
- const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type( digest );
- TEST_ASSERT( mbedtls_md( md_info, message_str->x, message_str->len,
- hash_result ) == 0 );
- hash_len = mbedtls_md_get_size( md_info );
- }
- else
- {
- memcpy( hash_result, message_str->x, message_str->len );
+ if (digest != MBEDTLS_MD_NONE) {
+ const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type(digest);
+ TEST_ASSERT(mbedtls_md(md_info, message_str->x, message_str->len,
+ hash_result) == 0);
+ hash_len = mbedtls_md_get_size(md_info);
+ } else {
+ memcpy(hash_result, message_str->x, message_str->len);
hash_len = message_str->len;
}
- if( mgf1_hash_id < 0 )
- {
+ if (mgf1_hash_id < 0) {
options = NULL;
- }
- else
- {
+ } else {
options = &pss_opts;
pss_opts.mgf1_hash_id = mgf1_hash_id;
pss_opts.expected_salt_len = salt_len;
}
- TEST_ASSERT( mbedtls_pk_verify_ext( pk_type, options, &pk,
- digest, hash_result, hash_len,
- result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
+ TEST_ASSERT(mbedtls_pk_verify_ext(pk_type, options, &pk, digest,
+ hash_result, hash_len, result_str->x,
+ mbedtls_pk_get_len(&pk)) == result);
exit:
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECDSA_C */
-void pk_ec_test_vec( int type, int id, data_t * key, data_t * hash,
- data_t * sig, int ret )
+void pk_ec_test_vec(int type,
+ int id,
+ data_t *key,
+ data_t *hash,
+ data_t *sig,
+ int ret)
{
mbedtls_pk_context pk;
mbedtls_ecp_keypair *eckey;
- mbedtls_pk_init( &pk );
- USE_PSA_INIT( );
+ mbedtls_pk_init(&pk);
+ USE_PSA_INIT();
- TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(type)) == 0);
- TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) );
- eckey = mbedtls_pk_ec( pk );
+ TEST_ASSERT(mbedtls_pk_can_do(&pk, MBEDTLS_PK_ECDSA));
+ eckey = mbedtls_pk_ec(pk);
- TEST_ASSERT( mbedtls_ecp_group_load( &eckey->grp, id ) == 0 );
- TEST_ASSERT( mbedtls_ecp_point_read_binary( &eckey->grp, &eckey->Q,
- key->x, key->len ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&eckey->grp, id) == 0);
+ TEST_ASSERT(mbedtls_ecp_point_read_binary(&eckey->grp, &eckey->Q, key->x,
+ key->len) == 0);
// MBEDTLS_MD_NONE is used since it will be ignored.
- TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE,
- hash->x, hash->len, sig->x, sig->len ) == ret );
+ TEST_ASSERT(mbedtls_pk_verify(&pk, MBEDTLS_MD_NONE, hash->x, hash->len,
+ sig->x, sig->len) == ret);
exit:
- mbedtls_pk_free( &pk );
- USE_PSA_DONE( );
+ mbedtls_pk_free(&pk);
+ USE_PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECP_RESTARTABLE:MBEDTLS_ECDSA_C:MBEDTLS_ECDSA_DETERMINISTIC */
-void pk_sign_verify_restart( int pk_type, int grp_id, char *d_str,
- char *QX_str, char *QY_str,
- int md_alg, char *msg, data_t *sig_check,
- int max_ops, int min_restart, int max_restart )
+void pk_sign_verify_restart(int pk_type,
+ int grp_id,
+ char *d_str,
+ char *QX_str,
+ char *QY_str,
+ int md_alg,
+ char *msg,
+ data_t *sig_check,
+ int max_ops,
+ int min_restart,
+ int max_restart)
{
int ret, cnt_restart;
mbedtls_pk_restart_ctx rs_ctx;
@@ -527,189 +515,194 @@
size_t hlen, slen;
const mbedtls_md_info_t *md_info;
- mbedtls_pk_restart_init( &rs_ctx );
- mbedtls_pk_init( &prv );
- mbedtls_pk_init( &pub );
- memset( hash, 0, sizeof( hash ) );
- memset( sig, 0, sizeof( sig ) );
+ mbedtls_pk_restart_init(&rs_ctx);
+ mbedtls_pk_init(&prv);
+ mbedtls_pk_init(&pub);
+ memset(hash, 0, sizeof(hash));
+ memset(sig, 0, sizeof(sig));
- TEST_ASSERT( mbedtls_pk_setup( &prv, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
- TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( prv )->grp, grp_id ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &mbedtls_pk_ec( prv )->d, 16, d_str ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup(&prv, mbedtls_pk_info_from_type(pk_type)) ==
+ 0);
+ TEST_ASSERT(mbedtls_ecp_group_load(&mbedtls_pk_ec(prv)->grp, grp_id) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&mbedtls_pk_ec(prv)->d, 16, d_str) == 0);
- TEST_ASSERT( mbedtls_pk_setup( &pub, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
- TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( pub )->grp, grp_id ) == 0 );
- TEST_ASSERT( mbedtls_ecp_point_read_string( &mbedtls_pk_ec( pub )->Q, 16, QX_str, QY_str ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup(&pub, mbedtls_pk_info_from_type(pk_type)) ==
+ 0);
+ TEST_ASSERT(mbedtls_ecp_group_load(&mbedtls_pk_ec(pub)->grp, grp_id) == 0);
+ TEST_ASSERT(mbedtls_ecp_point_read_string(&mbedtls_pk_ec(pub)->Q, 16,
+ QX_str, QY_str) == 0);
- md_info = mbedtls_md_info_from_type( md_alg );
- TEST_ASSERT( md_info != NULL );
+ md_info = mbedtls_md_info_from_type(md_alg);
+ TEST_ASSERT(md_info != NULL);
- hlen = mbedtls_md_get_size( md_info );
- TEST_ASSERT( mbedtls_md( md_info,
- (const unsigned char *) msg, strlen( msg ),
- hash ) == 0 );
+ hlen = mbedtls_md_get_size(md_info);
+ TEST_ASSERT(mbedtls_md(md_info, (const unsigned char *)msg, strlen(msg),
+ hash) == 0);
- mbedtls_ecp_set_max_ops( max_ops );
+ mbedtls_ecp_set_max_ops(max_ops);
- slen = sizeof( sig );
+ slen = sizeof(sig);
cnt_restart = 0;
do {
- ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
- sig, sizeof( sig ), &slen,
- mbedtls_test_rnd_std_rand, NULL,
- &rs_ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
+ ret = mbedtls_pk_sign_restartable(&prv, md_alg, hash, hlen, sig,
+ sizeof(sig), &slen,
+ mbedtls_test_rnd_std_rand, NULL,
+ &rs_ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart);
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( slen == sig_check->len );
- TEST_ASSERT( memcmp( sig, sig_check->x, slen ) == 0 );
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(slen == sig_check->len);
+ TEST_ASSERT(memcmp(sig, sig_check->x, slen) == 0);
- TEST_ASSERT( cnt_restart >= min_restart );
- TEST_ASSERT( cnt_restart <= max_restart );
+ TEST_ASSERT(cnt_restart >= min_restart);
+ TEST_ASSERT(cnt_restart <= max_restart);
cnt_restart = 0;
do {
- ret = mbedtls_pk_verify_restartable( &pub, md_alg,
- hash, hlen, sig, slen, &rs_ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
+ ret = mbedtls_pk_verify_restartable(&pub, md_alg, hash, hlen, sig, slen,
+ &rs_ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart);
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( cnt_restart >= min_restart );
- TEST_ASSERT( cnt_restart <= max_restart );
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(cnt_restart >= min_restart);
+ TEST_ASSERT(cnt_restart <= max_restart);
hash[0]++;
do {
- ret = mbedtls_pk_verify_restartable( &pub, md_alg,
- hash, hlen, sig, slen, &rs_ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
- TEST_ASSERT( ret != 0 );
+ ret = mbedtls_pk_verify_restartable(&pub, md_alg, hash, hlen, sig, slen,
+ &rs_ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
+ TEST_ASSERT(ret != 0);
hash[0]--;
sig[0]++;
do {
- ret = mbedtls_pk_verify_restartable( &pub, md_alg,
- hash, hlen, sig, slen, &rs_ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
- TEST_ASSERT( ret != 0 );
+ ret = mbedtls_pk_verify_restartable(&pub, md_alg, hash, hlen, sig, slen,
+ &rs_ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
+ TEST_ASSERT(ret != 0);
sig[0]--;
/* Do we leak memory when aborting? try verify then sign
* This test only makes sense when we actually restart */
- if( min_restart > 0 )
- {
- ret = mbedtls_pk_verify_restartable( &pub, md_alg,
- hash, hlen, sig, slen, &rs_ctx );
- TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
- mbedtls_pk_restart_free( &rs_ctx );
+ if (min_restart > 0) {
+ ret = mbedtls_pk_verify_restartable(&pub, md_alg, hash, hlen, sig, slen,
+ &rs_ctx);
+ TEST_ASSERT(ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
+ mbedtls_pk_restart_free(&rs_ctx);
- slen = sizeof( sig );
- ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
- sig, sizeof(sig), &slen,
- mbedtls_test_rnd_std_rand, NULL,
- &rs_ctx );
- TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
+ slen = sizeof(sig);
+ ret = mbedtls_pk_sign_restartable(&prv, md_alg, hash, hlen, sig,
+ sizeof(sig), &slen,
+ mbedtls_test_rnd_std_rand, NULL,
+ &rs_ctx);
+ TEST_ASSERT(ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
}
exit:
- mbedtls_pk_restart_free( &rs_ctx );
- mbedtls_pk_free( &prv );
- mbedtls_pk_free( &pub );
+ mbedtls_pk_restart_free(&rs_ctx);
+ mbedtls_pk_free(&prv);
+ mbedtls_pk_free(&pub);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
-void pk_sign_verify( int type, int parameter, int sign_ret, int verify_ret )
+void pk_sign_verify(int type, int parameter, int sign_ret, int verify_ret)
{
mbedtls_pk_context pk;
size_t sig_len;
unsigned char hash[32]; // Hard-coded for SHA256
- size_t hash_len = sizeof( hash );
+ size_t hash_len = sizeof(hash);
unsigned char sig[MBEDTLS_PK_SIGNATURE_MAX_SIZE];
void *rs_ctx = NULL;
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
mbedtls_pk_restart_ctx ctx;
rs_ctx = &ctx;
- mbedtls_pk_restart_init( rs_ctx );
+ mbedtls_pk_restart_init(rs_ctx);
/* This value is large enough that the operation will complete in one run.
* See comments at the top of ecp_test_vect_restart in
* test_suite_ecp.function for estimates of operation counts. */
- mbedtls_ecp_set_max_ops( 42000 );
+ mbedtls_ecp_set_max_ops(42000);
#endif
- mbedtls_pk_init( &pk );
- USE_PSA_INIT( );
+ mbedtls_pk_init(&pk);
+ USE_PSA_INIT();
- memset( hash, 0x2a, sizeof(hash) );
- memset( sig, 0, sizeof(sig) );
+ memset(hash, 0x2a, sizeof(hash));
+ memset(sig, 0, sizeof(sig));
- TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
- TEST_ASSERT( pk_genkey( &pk, parameter ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(type)) == 0);
+ TEST_ASSERT(pk_genkey(&pk, parameter) == 0);
- TEST_ASSERT( mbedtls_pk_sign_restartable( &pk, MBEDTLS_MD_SHA256,
- hash, hash_len,
- sig, sizeof(sig), &sig_len,
- mbedtls_test_rnd_std_rand, NULL,
- rs_ctx ) == sign_ret );
- if( sign_ret == 0 )
- TEST_ASSERT( sig_len <= MBEDTLS_PK_SIGNATURE_MAX_SIZE );
+ TEST_ASSERT(mbedtls_pk_sign_restartable(&pk, MBEDTLS_MD_SHA256, hash,
+ hash_len, sig, sizeof(sig),
+ &sig_len, mbedtls_test_rnd_std_rand,
+ NULL, rs_ctx) == sign_ret);
+ if (sign_ret == 0)
+ TEST_ASSERT(sig_len <= MBEDTLS_PK_SIGNATURE_MAX_SIZE);
else
sig_len = MBEDTLS_PK_SIGNATURE_MAX_SIZE;
- TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
- hash, hash_len, sig, sig_len ) == verify_ret );
+ TEST_ASSERT(mbedtls_pk_verify(&pk, MBEDTLS_MD_SHA256, hash, hash_len, sig,
+ sig_len) == verify_ret);
- if( verify_ret == 0 )
- {
+ if (verify_ret == 0) {
hash[0]++;
- TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
- hash, hash_len, sig, sig_len ) != 0 );
+ TEST_ASSERT(mbedtls_pk_verify(&pk, MBEDTLS_MD_SHA256, hash, hash_len,
+ sig, sig_len) != 0);
hash[0]--;
sig[0]++;
- TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
- hash, hash_len, sig, sig_len ) != 0 );
+ TEST_ASSERT(mbedtls_pk_verify(&pk, MBEDTLS_MD_SHA256, hash, hash_len,
+ sig, sig_len) != 0);
sig[0]--;
}
- TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_SHA256, hash, hash_len,
- sig, sizeof(sig), &sig_len,
- mbedtls_test_rnd_std_rand,
- NULL ) == sign_ret );
- if( sign_ret == 0 )
- TEST_ASSERT( sig_len <= MBEDTLS_PK_SIGNATURE_MAX_SIZE );
+ TEST_ASSERT(mbedtls_pk_sign(&pk, MBEDTLS_MD_SHA256, hash, hash_len, sig,
+ sizeof(sig), &sig_len,
+ mbedtls_test_rnd_std_rand, NULL) == sign_ret);
+ if (sign_ret == 0)
+ TEST_ASSERT(sig_len <= MBEDTLS_PK_SIGNATURE_MAX_SIZE);
else
sig_len = MBEDTLS_PK_SIGNATURE_MAX_SIZE;
- TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
- hash, hash_len, sig, sig_len, rs_ctx ) == verify_ret );
+ TEST_ASSERT(mbedtls_pk_verify_restartable(&pk, MBEDTLS_MD_SHA256, hash,
+ hash_len, sig, sig_len,
+ rs_ctx) == verify_ret);
- if( verify_ret == 0 )
- {
+ if (verify_ret == 0) {
hash[0]++;
- TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
- hash, sizeof(hash), sig, sig_len, rs_ctx ) != 0 );
+ TEST_ASSERT(mbedtls_pk_verify_restartable(&pk, MBEDTLS_MD_SHA256, hash,
+ sizeof(hash), sig, sig_len,
+ rs_ctx) != 0);
hash[0]--;
sig[0]++;
- TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
- hash, sizeof(hash), sig, sig_len, rs_ctx ) != 0 );
+ TEST_ASSERT(mbedtls_pk_verify_restartable(&pk, MBEDTLS_MD_SHA256, hash,
+ sizeof(hash), sig, sig_len,
+ rs_ctx) != 0);
sig[0]--;
}
exit:
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
- mbedtls_pk_restart_free( rs_ctx );
+ mbedtls_pk_restart_free(rs_ctx);
#endif
- mbedtls_pk_free( &pk );
- USE_PSA_DONE( );
+ mbedtls_pk_free(&pk);
+ USE_PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
-void pk_rsa_encrypt_test_vec( data_t * message, int mod, int radix_N,
- char * input_N, int radix_E, char * input_E,
- data_t * result, int ret )
+void pk_rsa_encrypt_test_vec(data_t *message,
+ int mod,
+ int radix_N,
+ char *input_N,
+ int radix_E,
+ char *input_E,
+ data_t *result,
+ int ret)
{
unsigned char output[300];
mbedtls_test_rnd_pseudo_info rnd_info;
@@ -717,34 +710,42 @@
mbedtls_pk_context pk;
size_t olen;
- memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
- memset( output, 0, sizeof( output ) );
+ memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
+ memset(output, 0, sizeof(output));
-
- mbedtls_pk_init( &pk );
- TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
- rsa = mbedtls_pk_rsa( pk );
+ mbedtls_pk_init(&pk);
+ TEST_ASSERT(
+ mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
+ rsa = mbedtls_pk_rsa(pk);
rsa->len = mod / 8;
- TEST_ASSERT( mbedtls_test_read_mpi( &rsa->N, radix_N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &rsa->E, radix_E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&rsa->N, radix_N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&rsa->E, radix_E, input_E) == 0);
- TEST_ASSERT( mbedtls_pk_encrypt( &pk, message->x, message->len,
- output, &olen, sizeof( output ),
- mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
- TEST_ASSERT( olen == result->len );
- TEST_ASSERT( memcmp( output, result->x, olen ) == 0 );
+ TEST_ASSERT(mbedtls_pk_encrypt(&pk, message->x, message->len, output, &olen,
+ sizeof(output), mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == ret);
+ TEST_ASSERT(olen == result->len);
+ TEST_ASSERT(memcmp(output, result->x, olen) == 0);
exit:
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
-void pk_rsa_decrypt_test_vec( data_t * cipher, int mod, int radix_P,
- char * input_P, int radix_Q, char * input_Q,
- int radix_N, char * input_N, int radix_E,
- char * input_E, data_t * clear, int ret )
+void pk_rsa_decrypt_test_vec(data_t *cipher,
+ int mod,
+ int radix_P,
+ char *input_P,
+ int radix_Q,
+ char *input_Q,
+ int radix_N,
+ char *input_N,
+ int radix_E,
+ char *input_E,
+ data_t *clear,
+ int ret)
{
unsigned char output[256];
mbedtls_test_rnd_pseudo_info rnd_info;
@@ -753,49 +754,52 @@
mbedtls_pk_context pk;
size_t olen;
- mbedtls_pk_init( &pk );
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
- mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
+ mbedtls_pk_init(&pk);
+ mbedtls_mpi_init(&N);
+ mbedtls_mpi_init(&P);
+ mbedtls_mpi_init(&Q);
+ mbedtls_mpi_init(&E);
- memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
-
+ memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
/* init pk-rsa context */
- TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
- rsa = mbedtls_pk_rsa( pk );
+ TEST_ASSERT(
+ mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
+ rsa = mbedtls_pk_rsa(pk);
/* load public key */
- TEST_ASSERT( mbedtls_test_read_mpi( &N, radix_N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, radix_E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, radix_N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, radix_E, input_E) == 0);
/* load private key */
- TEST_ASSERT( mbedtls_test_read_mpi( &P, radix_P, input_P ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Q, radix_Q, input_Q ) == 0 );
- TEST_ASSERT( mbedtls_rsa_import( rsa, &N, &P, &Q, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( rsa ) == (size_t) ( mod / 8 ) );
- TEST_ASSERT( mbedtls_rsa_complete( rsa ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&P, radix_P, input_P) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Q, radix_Q, input_Q) == 0);
+ TEST_ASSERT(mbedtls_rsa_import(rsa, &N, &P, &Q, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(rsa) == (size_t)(mod / 8));
+ TEST_ASSERT(mbedtls_rsa_complete(rsa) == 0);
/* decryption test */
- memset( output, 0, sizeof( output ) );
+ memset(output, 0, sizeof(output));
olen = 0;
- TEST_ASSERT( mbedtls_pk_decrypt( &pk, cipher->x, cipher->len,
- output, &olen, sizeof( output ),
- mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
- if( ret == 0 )
- {
- TEST_ASSERT( olen == clear->len );
- TEST_ASSERT( memcmp( output, clear->x, olen ) == 0 );
+ TEST_ASSERT(mbedtls_pk_decrypt(&pk, cipher->x, cipher->len, output, &olen,
+ sizeof(output), mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == ret);
+ if (ret == 0) {
+ TEST_ASSERT(olen == clear->len);
+ TEST_ASSERT(memcmp(output, clear->x, olen) == 0);
}
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
- mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
- mbedtls_pk_free( &pk );
+ mbedtls_mpi_free(&N);
+ mbedtls_mpi_free(&P);
+ mbedtls_mpi_free(&Q);
+ mbedtls_mpi_free(&E);
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE */
-void pk_ec_nocrypt( int type )
+void pk_ec_nocrypt(int type)
{
mbedtls_pk_context pk;
unsigned char output[100];
@@ -804,66 +808,66 @@
size_t olen = 0;
int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
- mbedtls_pk_init( &pk );
+ mbedtls_pk_init(&pk);
- memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
- memset( output, 0, sizeof( output ) );
- memset( input, 0, sizeof( input ) );
+ memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
+ memset(output, 0, sizeof(output));
+ memset(input, 0, sizeof(input));
- TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(type)) == 0);
- TEST_ASSERT( mbedtls_pk_encrypt( &pk, input, sizeof( input ),
- output, &olen, sizeof( output ),
- mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
+ TEST_ASSERT(mbedtls_pk_encrypt(&pk, input, sizeof(input), output, &olen,
+ sizeof(output), mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == ret);
- TEST_ASSERT( mbedtls_pk_decrypt( &pk, input, sizeof( input ),
- output, &olen, sizeof( output ),
- mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
+ TEST_ASSERT(mbedtls_pk_decrypt(&pk, input, sizeof(input), output, &olen,
+ sizeof(output), mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == ret);
exit:
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
-void pk_rsa_overflow( )
+void pk_rsa_overflow()
{
mbedtls_pk_context pk;
size_t hash_len = SIZE_MAX, sig_len = SIZE_MAX;
unsigned char hash[50], sig[100];
- if( SIZE_MAX <= UINT_MAX )
+ if (SIZE_MAX <= UINT_MAX)
return;
- memset( hash, 0x2a, sizeof(hash) );
- memset( sig, 0, sizeof(sig) );
+ memset(hash, 0x2a, sizeof(hash));
+ memset(sig, 0, sizeof(sig));
- mbedtls_pk_init( &pk );
+ mbedtls_pk_init(&pk);
- TEST_ASSERT( mbedtls_pk_setup( &pk,
- mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
+ TEST_ASSERT(
+ mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
#if defined(MBEDTLS_PKCS1_V21)
- TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_RSASSA_PSS, NULL, &pk,
- MBEDTLS_MD_NONE, hash, hash_len, sig, sig_len ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_verify_ext(
+ MBEDTLS_PK_RSASSA_PSS, NULL, &pk, MBEDTLS_MD_NONE, hash,
+ hash_len, sig, sig_len) == MBEDTLS_ERR_PK_BAD_INPUT_DATA);
#endif /* MBEDTLS_PKCS1_V21 */
- TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE, hash, hash_len,
- sig, sig_len ) == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_verify(&pk, MBEDTLS_MD_NONE, hash, hash_len, sig,
+ sig_len) == MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_NONE, hash, hash_len,
- sig, sizeof(sig), &sig_len,
- mbedtls_test_rnd_std_rand, NULL )
- == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_sign(&pk, MBEDTLS_MD_NONE, hash, hash_len, sig,
+ sizeof(sig), &sig_len,
+ mbedtls_test_rnd_std_rand,
+ NULL) == MBEDTLS_ERR_PK_BAD_INPUT_DATA);
exit:
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RSA_C:MBEDTLS_PK_RSA_ALT_SUPPORT */
-void pk_rsa_alt( )
+void pk_rsa_alt()
{
/*
* An rsa_alt context can only do private operations (decrypt, sign).
@@ -878,76 +882,77 @@
size_t sig_len, ciph_len, test_len;
int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
- mbedtls_rsa_init( &raw );
- mbedtls_pk_init( &rsa ); mbedtls_pk_init( &alt );
+ mbedtls_rsa_init(&raw);
+ mbedtls_pk_init(&rsa);
+ mbedtls_pk_init(&alt);
- memset( hash, 0x2a, sizeof(hash) );
- memset( sig, 0, sizeof(sig) );
- memset( msg, 0x2a, sizeof(msg) );
- memset( ciph, 0, sizeof(ciph) );
- memset( test, 0, sizeof(test) );
+ memset(hash, 0x2a, sizeof(hash));
+ memset(sig, 0, sizeof(sig));
+ memset(msg, 0x2a, sizeof(msg));
+ memset(ciph, 0, sizeof(ciph));
+ memset(test, 0, sizeof(test));
/* Initiliaze PK RSA context with random key */
- TEST_ASSERT( mbedtls_pk_setup( &rsa,
- mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
- TEST_ASSERT( pk_genkey( &rsa, RSA_KEY_SIZE ) == 0 );
+ TEST_ASSERT(
+ mbedtls_pk_setup(&rsa, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
+ TEST_ASSERT(pk_genkey(&rsa, RSA_KEY_SIZE) == 0);
/* Extract key to the raw rsa context */
- TEST_ASSERT( mbedtls_rsa_copy( &raw, mbedtls_pk_rsa( rsa ) ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_copy(&raw, mbedtls_pk_rsa(rsa)) == 0);
/* Initialize PK RSA_ALT context */
- TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, (void *) &raw,
- mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func, mbedtls_rsa_key_len_func ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup_rsa_alt(
+ &alt, (void *)&raw, mbedtls_rsa_decrypt_func,
+ mbedtls_rsa_sign_func, mbedtls_rsa_key_len_func) == 0);
/* Test administrative functions */
- TEST_ASSERT( mbedtls_pk_can_do( &alt, MBEDTLS_PK_RSA ) );
- TEST_ASSERT( mbedtls_pk_get_bitlen( &alt ) == RSA_KEY_SIZE );
- TEST_ASSERT( mbedtls_pk_get_len( &alt ) == RSA_KEY_LEN );
- TEST_ASSERT( mbedtls_pk_get_type( &alt ) == MBEDTLS_PK_RSA_ALT );
- TEST_ASSERT( strcmp( mbedtls_pk_get_name( &alt ), "RSA-alt" ) == 0 );
+ TEST_ASSERT(mbedtls_pk_can_do(&alt, MBEDTLS_PK_RSA));
+ TEST_ASSERT(mbedtls_pk_get_bitlen(&alt) == RSA_KEY_SIZE);
+ TEST_ASSERT(mbedtls_pk_get_len(&alt) == RSA_KEY_LEN);
+ TEST_ASSERT(mbedtls_pk_get_type(&alt) == MBEDTLS_PK_RSA_ALT);
+ TEST_ASSERT(strcmp(mbedtls_pk_get_name(&alt), "RSA-alt") == 0);
/* Test signature */
#if SIZE_MAX > UINT_MAX
- TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, SIZE_MAX,
- sig, sizeof(sig), &sig_len,
- mbedtls_test_rnd_std_rand, NULL )
- == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_sign(&alt, MBEDTLS_MD_NONE, hash, SIZE_MAX, sig,
+ sizeof(sig), &sig_len,
+ mbedtls_test_rnd_std_rand,
+ NULL) == MBEDTLS_ERR_PK_BAD_INPUT_DATA);
#endif /* SIZE_MAX > UINT_MAX */
- TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, sizeof(hash),
- sig, sizeof(sig), &sig_len,
- mbedtls_test_rnd_std_rand, NULL )
- == 0 );
- TEST_ASSERT( sig_len == RSA_KEY_LEN );
- TEST_ASSERT( mbedtls_pk_verify( &rsa, MBEDTLS_MD_NONE,
- hash, sizeof(hash), sig, sig_len ) == 0 );
+ TEST_ASSERT(mbedtls_pk_sign(&alt, MBEDTLS_MD_NONE, hash, sizeof(hash), sig,
+ sizeof(sig), &sig_len,
+ mbedtls_test_rnd_std_rand, NULL) == 0);
+ TEST_ASSERT(sig_len == RSA_KEY_LEN);
+ TEST_ASSERT(mbedtls_pk_verify(&rsa, MBEDTLS_MD_NONE, hash, sizeof(hash),
+ sig, sig_len) == 0);
/* Test decrypt */
- TEST_ASSERT( mbedtls_pk_encrypt( &rsa, msg, sizeof(msg),
- ciph, &ciph_len, sizeof(ciph),
- mbedtls_test_rnd_std_rand, NULL ) == 0 );
- TEST_ASSERT( mbedtls_pk_decrypt( &alt, ciph, ciph_len,
- test, &test_len, sizeof(test),
- mbedtls_test_rnd_std_rand, NULL ) == 0 );
- TEST_ASSERT( test_len == sizeof(msg) );
- TEST_ASSERT( memcmp( test, msg, test_len ) == 0 );
+ TEST_ASSERT(mbedtls_pk_encrypt(&rsa, msg, sizeof(msg), ciph, &ciph_len,
+ sizeof(ciph), mbedtls_test_rnd_std_rand,
+ NULL) == 0);
+ TEST_ASSERT(mbedtls_pk_decrypt(&alt, ciph, ciph_len, test, &test_len,
+ sizeof(test), mbedtls_test_rnd_std_rand,
+ NULL) == 0);
+ TEST_ASSERT(test_len == sizeof(msg));
+ TEST_ASSERT(memcmp(test, msg, test_len) == 0);
/* Test forbidden operations */
- TEST_ASSERT( mbedtls_pk_encrypt( &alt, msg, sizeof(msg),
- ciph, &ciph_len, sizeof(ciph),
- mbedtls_test_rnd_std_rand, NULL ) == ret );
- TEST_ASSERT( mbedtls_pk_verify( &alt, MBEDTLS_MD_NONE,
- hash, sizeof(hash), sig, sig_len ) == ret );
- TEST_ASSERT( mbedtls_pk_debug( &alt, dbg_items ) == ret );
+ TEST_ASSERT(mbedtls_pk_encrypt(&alt, msg, sizeof(msg), ciph, &ciph_len,
+ sizeof(ciph), mbedtls_test_rnd_std_rand,
+ NULL) == ret);
+ TEST_ASSERT(mbedtls_pk_verify(&alt, MBEDTLS_MD_NONE, hash, sizeof(hash),
+ sig, sig_len) == ret);
+ TEST_ASSERT(mbedtls_pk_debug(&alt, dbg_items) == ret);
exit:
- mbedtls_rsa_free( &raw );
- mbedtls_pk_free( &rsa ); mbedtls_pk_free( &alt );
+ mbedtls_rsa_free(&raw);
+ mbedtls_pk_free(&rsa);
+ mbedtls_pk_free(&alt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C:MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_ECDSA_C */
-void pk_psa_sign( int grpid_arg,
- int psa_curve_arg, int expected_bits_arg )
+void pk_psa_sign(int grpid_arg, int psa_curve_arg, int expected_bits_arg)
{
mbedtls_ecp_group_id grpid = grpid_arg;
mbedtls_pk_context pk;
@@ -960,7 +965,7 @@
int ret;
mbedtls_svc_key_id_t key_id;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- psa_key_type_t expected_type = PSA_KEY_TYPE_ECC_KEY_PAIR( psa_curve_arg );
+ psa_key_type_t expected_type = PSA_KEY_TYPE_ECC_KEY_PAIR(psa_curve_arg);
size_t expected_bits = expected_bits_arg;
/*
@@ -971,69 +976,63 @@
* - parse it to a PK context and verify the signature this way
*/
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* Create legacy EC public/private key in PK context. */
- mbedtls_pk_init( &pk );
- TEST_ASSERT( mbedtls_pk_setup( &pk,
- mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == 0 );
- TEST_ASSERT( mbedtls_ecp_gen_key( grpid,
- (mbedtls_ecp_keypair*) pk.pk_ctx,
- mbedtls_test_rnd_std_rand, NULL ) == 0 );
+ mbedtls_pk_init(&pk);
+ TEST_ASSERT(mbedtls_pk_setup(
+ &pk, mbedtls_pk_info_from_type(MBEDTLS_PK_ECKEY)) == 0);
+ TEST_ASSERT(mbedtls_ecp_gen_key(grpid, (mbedtls_ecp_keypair *)pk.pk_ctx,
+ mbedtls_test_rnd_std_rand, NULL) == 0);
/* Export underlying public key for re-importing in a legacy context. */
- ret = mbedtls_pk_write_pubkey_der( &pk, pkey_legacy,
- sizeof( pkey_legacy ) );
- TEST_ASSERT( ret >= 0 );
- klen_legacy = (size_t) ret;
+ ret = mbedtls_pk_write_pubkey_der(&pk, pkey_legacy, sizeof(pkey_legacy));
+ TEST_ASSERT(ret >= 0);
+ klen_legacy = (size_t)ret;
/* mbedtls_pk_write_pubkey_der() writes backwards in the data buffer. */
- pkey_legacy_start = pkey_legacy + sizeof( pkey_legacy ) - klen_legacy;
+ pkey_legacy_start = pkey_legacy + sizeof(pkey_legacy) - klen_legacy;
/* Turn PK context into an opaque one. */
- TEST_ASSERT( mbedtls_pk_wrap_as_opaque( &pk, &key_id,
- PSA_ALG_SHA_256 ) == 0 );
+ TEST_ASSERT(mbedtls_pk_wrap_as_opaque(&pk, &key_id, PSA_ALG_SHA_256) == 0);
- PSA_ASSERT( psa_get_key_attributes( key_id, &attributes ) );
- TEST_EQUAL( psa_get_key_type( &attributes ), expected_type );
- TEST_EQUAL( psa_get_key_bits( &attributes ), expected_bits );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ),
- PSA_KEY_LIFETIME_VOLATILE );
+ PSA_ASSERT(psa_get_key_attributes(key_id, &attributes));
+ TEST_EQUAL(psa_get_key_type(&attributes), expected_type);
+ TEST_EQUAL(psa_get_key_bits(&attributes), expected_bits);
+ TEST_EQUAL(psa_get_key_lifetime(&attributes), PSA_KEY_LIFETIME_VOLATILE);
- memset( hash, 0x2a, sizeof(hash) );
- memset( sig, 0, sizeof(sig) );
+ memset(hash, 0x2a, sizeof(hash));
+ memset(sig, 0, sizeof(sig));
- TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_SHA256,
- hash, sizeof(hash), sig, sizeof(sig), &sig_len,
- NULL, NULL ) == 0 );
+ TEST_ASSERT(mbedtls_pk_sign(&pk, MBEDTLS_MD_SHA256, hash, sizeof(hash), sig,
+ sizeof(sig), &sig_len, NULL, NULL) == 0);
/* Export underlying public key for re-importing in a psa context. */
- ret = mbedtls_pk_write_pubkey_der( &pk, pkey_psa,
- sizeof( pkey_psa ) );
- TEST_ASSERT( ret >= 0 );
- klen_psa = (size_t) ret;
+ ret = mbedtls_pk_write_pubkey_der(&pk, pkey_psa, sizeof(pkey_psa));
+ TEST_ASSERT(ret >= 0);
+ klen_psa = (size_t)ret;
/* mbedtls_pk_write_pubkey_der() writes backwards in the data buffer. */
- pkey_psa_start = pkey_psa + sizeof( pkey_psa ) - klen_psa;
+ pkey_psa_start = pkey_psa + sizeof(pkey_psa) - klen_psa;
- TEST_ASSERT( klen_psa == klen_legacy );
- TEST_ASSERT( memcmp( pkey_psa_start, pkey_legacy_start, klen_psa ) == 0 );
+ TEST_ASSERT(klen_psa == klen_legacy);
+ TEST_ASSERT(memcmp(pkey_psa_start, pkey_legacy_start, klen_psa) == 0);
- mbedtls_pk_free( &pk );
- TEST_ASSERT( PSA_SUCCESS == psa_destroy_key( key_id ) );
+ mbedtls_pk_free(&pk);
+ TEST_ASSERT(PSA_SUCCESS == psa_destroy_key(key_id));
- mbedtls_pk_init( &pk );
- TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, pkey_legacy_start,
- klen_legacy ) == 0 );
- TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
- hash, sizeof(hash), sig, sig_len ) == 0 );
+ mbedtls_pk_init(&pk);
+ TEST_ASSERT(
+ mbedtls_pk_parse_public_key(&pk, pkey_legacy_start, klen_legacy) == 0);
+ TEST_ASSERT(mbedtls_pk_verify(&pk, MBEDTLS_MD_SHA256, hash, sizeof(hash),
+ sig, sig_len) == 0);
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- mbedtls_pk_free( &pk );
- USE_PSA_DONE( );
+ mbedtls_pk_free(&pk);
+ USE_PSA_DONE();
}
/* END_CASE */