mirror of
https://github.com/yuzu-emu/mbedtls.git
synced 2024-10-19 01:31:17 +00:00
c70b982056
A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
495 lines
15 KiB
Plaintext
495 lines
15 KiB
Plaintext
BEGIN_HEADER
|
|
#include <polarssl/rsa.h>
|
|
#include <polarssl/md2.h>
|
|
#include <polarssl/md4.h>
|
|
#include <polarssl/md5.h>
|
|
#include <polarssl/sha1.h>
|
|
#include <polarssl/sha2.h>
|
|
#include <polarssl/sha4.h>
|
|
#include <polarssl/entropy.h>
|
|
#include <polarssl/ctr_drbg.h>
|
|
END_HEADER
|
|
|
|
BEGIN_DEPENDENCIES
|
|
depends_on:POLARSSL_RSA_C:POLARSSL_BIGNUM_C:POLARSSL_GENPRIME
|
|
END_DEPENDENCIES
|
|
|
|
BEGIN_CASE
|
|
rsa_pkcs1_sign:message_hex_string:padding_mode:digest:mod:radix_P:input_P:radix_Q:input_Q:radix_N:input_N:radix_E:input_E:result_hex_str:result
|
|
{
|
|
unsigned char message_str[1000];
|
|
unsigned char hash_result[1000];
|
|
unsigned char output[1000];
|
|
unsigned char output_str[1000];
|
|
rsa_context ctx;
|
|
mpi P1, Q1, H, G;
|
|
int msg_len;
|
|
|
|
mpi_init( &P1 ); mpi_init( &Q1 ); mpi_init( &H ); mpi_init( &G );
|
|
rsa_init( &ctx, {padding_mode}, 0 );
|
|
|
|
memset( message_str, 0x00, 1000 );
|
|
memset( hash_result, 0x00, 1000 );
|
|
memset( output, 0x00, 1000 );
|
|
memset( output_str, 0x00, 1000 );
|
|
|
|
ctx.len = {mod} / 8;
|
|
TEST_ASSERT( mpi_read_string( &ctx.P, {radix_P}, {input_P} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.Q, {radix_Q}, {input_Q} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
|
|
|
|
TEST_ASSERT( mpi_sub_int( &P1, &ctx.P, 1 ) == 0 );
|
|
TEST_ASSERT( mpi_sub_int( &Q1, &ctx.Q, 1 ) == 0 );
|
|
TEST_ASSERT( mpi_mul_mpi( &H, &P1, &Q1 ) == 0 );
|
|
TEST_ASSERT( mpi_gcd( &G, &ctx.E, &H ) == 0 );
|
|
TEST_ASSERT( mpi_inv_mod( &ctx.D , &ctx.E, &H ) == 0 );
|
|
TEST_ASSERT( mpi_mod_mpi( &ctx.DP, &ctx.D, &P1 ) == 0 );
|
|
TEST_ASSERT( mpi_mod_mpi( &ctx.DQ, &ctx.D, &Q1 ) == 0 );
|
|
TEST_ASSERT( mpi_inv_mod( &ctx.QP, &ctx.Q, &ctx.P ) == 0 );
|
|
|
|
TEST_ASSERT( rsa_check_privkey( &ctx ) == 0 );
|
|
|
|
msg_len = unhexify( message_str, {message_hex_string} );
|
|
|
|
if( md_info_from_type( {digest} ) != NULL )
|
|
TEST_ASSERT( md( md_info_from_type( {digest} ), message_str, msg_len, hash_result ) == 0 );
|
|
|
|
TEST_ASSERT( rsa_pkcs1_sign( &ctx, NULL, NULL, RSA_PRIVATE, {digest}, 0, hash_result, output ) == {result} );
|
|
if( {result} == 0 )
|
|
{
|
|
hexify( output_str, output, ctx.len );
|
|
|
|
TEST_ASSERT( strcasecmp( (char *) output_str, {result_hex_str} ) == 0 );
|
|
}
|
|
|
|
mpi_free( &P1 ); mpi_free( &Q1 ); mpi_free( &H ); mpi_free( &G );
|
|
rsa_free( &ctx );
|
|
}
|
|
END_CASE
|
|
|
|
BEGIN_CASE
|
|
rsa_pkcs1_verify:message_hex_string:padding_mode:digest:mod:radix_N:input_N:radix_E:input_E:result_hex_str:result
|
|
{
|
|
unsigned char message_str[1000];
|
|
unsigned char hash_result[1000];
|
|
unsigned char result_str[1000];
|
|
rsa_context ctx;
|
|
int msg_len;
|
|
|
|
rsa_init( &ctx, {padding_mode}, 0 );
|
|
memset( message_str, 0x00, 1000 );
|
|
memset( hash_result, 0x00, 1000 );
|
|
memset( result_str, 0x00, 1000 );
|
|
|
|
ctx.len = {mod} / 8;
|
|
TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
|
|
|
|
TEST_ASSERT( rsa_check_pubkey( &ctx ) == 0 );
|
|
|
|
msg_len = unhexify( message_str, {message_hex_string} );
|
|
unhexify( result_str, {result_hex_str} );
|
|
|
|
if( md_info_from_type( {digest} ) != NULL )
|
|
TEST_ASSERT( md( md_info_from_type( {digest} ), message_str, msg_len, hash_result ) == 0 );
|
|
|
|
TEST_ASSERT( rsa_pkcs1_verify( &ctx, RSA_PUBLIC, {digest}, 0, hash_result, result_str ) == {result} );
|
|
|
|
rsa_free( &ctx );
|
|
}
|
|
END_CASE
|
|
|
|
|
|
BEGIN_CASE
|
|
rsa_pkcs1_sign_raw:message_hex_string:hash_result_string:padding_mode:mod:radix_P:input_P:radix_Q:input_Q:radix_N:input_N:radix_E:input_E:result_hex_str
|
|
{
|
|
unsigned char message_str[1000];
|
|
unsigned char hash_result[1000];
|
|
unsigned char output[1000];
|
|
unsigned char output_str[1000];
|
|
rsa_context ctx;
|
|
mpi P1, Q1, H, G;
|
|
int hash_len;
|
|
|
|
mpi_init( &P1 ); mpi_init( &Q1 ); mpi_init( &H ); mpi_init( &G );
|
|
rsa_init( &ctx, {padding_mode}, 0 );
|
|
|
|
memset( message_str, 0x00, 1000 );
|
|
memset( hash_result, 0x00, 1000 );
|
|
memset( output, 0x00, 1000 );
|
|
memset( output_str, 0x00, 1000 );
|
|
|
|
ctx.len = {mod} / 8;
|
|
TEST_ASSERT( mpi_read_string( &ctx.P, {radix_P}, {input_P} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.Q, {radix_Q}, {input_Q} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
|
|
|
|
TEST_ASSERT( mpi_sub_int( &P1, &ctx.P, 1 ) == 0 );
|
|
TEST_ASSERT( mpi_sub_int( &Q1, &ctx.Q, 1 ) == 0 );
|
|
TEST_ASSERT( mpi_mul_mpi( &H, &P1, &Q1 ) == 0 );
|
|
TEST_ASSERT( mpi_gcd( &G, &ctx.E, &H ) == 0 );
|
|
TEST_ASSERT( mpi_inv_mod( &ctx.D , &ctx.E, &H ) == 0 );
|
|
TEST_ASSERT( mpi_mod_mpi( &ctx.DP, &ctx.D, &P1 ) == 0 );
|
|
TEST_ASSERT( mpi_mod_mpi( &ctx.DQ, &ctx.D, &Q1 ) == 0 );
|
|
TEST_ASSERT( mpi_inv_mod( &ctx.QP, &ctx.Q, &ctx.P ) == 0 );
|
|
|
|
TEST_ASSERT( rsa_check_privkey( &ctx ) == 0 );
|
|
|
|
unhexify( message_str, {message_hex_string} );
|
|
hash_len = unhexify( hash_result, {hash_result_string} );
|
|
|
|
TEST_ASSERT( rsa_pkcs1_sign( &ctx, NULL, NULL, RSA_PRIVATE, POLARSSL_MD_NONE, hash_len, hash_result, output ) == 0 );
|
|
|
|
hexify( output_str, output, ctx.len );
|
|
|
|
TEST_ASSERT( strcasecmp( (char *) output_str, {result_hex_str} ) == 0 );
|
|
|
|
mpi_free( &P1 ); mpi_free( &Q1 ); mpi_free( &H ); mpi_free( &G );
|
|
rsa_free( &ctx );
|
|
}
|
|
END_CASE
|
|
|
|
BEGIN_CASE
|
|
rsa_pkcs1_verify_raw:message_hex_string:hash_result_string:padding_mode:mod:radix_N:input_N:radix_E:input_E:result_hex_str:correct
|
|
{
|
|
unsigned char message_str[1000];
|
|
unsigned char hash_result[1000];
|
|
unsigned char result_str[1000];
|
|
rsa_context ctx;
|
|
size_t hash_len;
|
|
|
|
rsa_init( &ctx, {padding_mode}, 0 );
|
|
memset( message_str, 0x00, 1000 );
|
|
memset( hash_result, 0x00, 1000 );
|
|
memset( result_str, 0x00, 1000 );
|
|
|
|
ctx.len = {mod} / 8;
|
|
TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
|
|
|
|
TEST_ASSERT( rsa_check_pubkey( &ctx ) == 0 );
|
|
|
|
unhexify( message_str, {message_hex_string} );
|
|
hash_len = unhexify( hash_result, {hash_result_string} );
|
|
unhexify( result_str, {result_hex_str} );
|
|
|
|
TEST_ASSERT( rsa_pkcs1_verify( &ctx, RSA_PUBLIC, POLARSSL_MD_NONE, hash_len, hash_result, result_str ) == {correct} );
|
|
|
|
rsa_free( &ctx );
|
|
}
|
|
END_CASE
|
|
|
|
BEGIN_CASE
|
|
rsa_pkcs1_encrypt:message_hex_string:padding_mode:mod:radix_N:input_N:radix_E:input_E:result_hex_str:result
|
|
{
|
|
unsigned char message_str[1000];
|
|
unsigned char output[1000];
|
|
unsigned char output_str[1000];
|
|
rsa_context ctx;
|
|
size_t msg_len;
|
|
rnd_pseudo_info rnd_info;
|
|
|
|
memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
|
|
|
|
rsa_init( &ctx, {padding_mode}, 0 );
|
|
memset( message_str, 0x00, 1000 );
|
|
memset( output, 0x00, 1000 );
|
|
memset( output_str, 0x00, 1000 );
|
|
|
|
ctx.len = {mod} / 8;
|
|
TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
|
|
|
|
TEST_ASSERT( rsa_check_pubkey( &ctx ) == 0 );
|
|
|
|
msg_len = unhexify( message_str, {message_hex_string} );
|
|
|
|
TEST_ASSERT( rsa_pkcs1_encrypt( &ctx, &rnd_pseudo_rand, &rnd_info, RSA_PUBLIC, msg_len, message_str, output ) == {result} );
|
|
if( {result} == 0 )
|
|
{
|
|
hexify( output_str, output, ctx.len );
|
|
|
|
TEST_ASSERT( strcasecmp( (char *) output_str, {result_hex_str} ) == 0 );
|
|
}
|
|
|
|
rsa_free( &ctx );
|
|
}
|
|
END_CASE
|
|
|
|
BEGIN_CASE
|
|
rsa_pkcs1_encrypt_bad_rng:message_hex_string:padding_mode:mod:radix_N:input_N:radix_E:input_E:result_hex_str:result
|
|
{
|
|
unsigned char message_str[1000];
|
|
unsigned char output[1000];
|
|
unsigned char output_str[1000];
|
|
rsa_context ctx;
|
|
size_t msg_len;
|
|
|
|
rsa_init( &ctx, {padding_mode}, 0 );
|
|
memset( message_str, 0x00, 1000 );
|
|
memset( output, 0x00, 1000 );
|
|
memset( output_str, 0x00, 1000 );
|
|
|
|
ctx.len = {mod} / 8;
|
|
TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
|
|
|
|
TEST_ASSERT( rsa_check_pubkey( &ctx ) == 0 );
|
|
|
|
msg_len = unhexify( message_str, {message_hex_string} );
|
|
|
|
TEST_ASSERT( rsa_pkcs1_encrypt( &ctx, &rnd_zero_rand, NULL, RSA_PUBLIC, msg_len, message_str, output ) == {result} );
|
|
if( {result} == 0 )
|
|
{
|
|
hexify( output_str, output, ctx.len );
|
|
|
|
TEST_ASSERT( strcasecmp( (char *) output_str, {result_hex_str} ) == 0 );
|
|
}
|
|
|
|
rsa_free( &ctx );
|
|
}
|
|
END_CASE
|
|
|
|
BEGIN_CASE
|
|
rsa_pkcs1_decrypt:message_hex_string:padding_mode:mod:radix_P:input_P:radix_Q:input_Q:radix_N:input_N:radix_E:input_E:max_output:result_hex_str:result
|
|
{
|
|
unsigned char message_str[1000];
|
|
unsigned char output[1000];
|
|
unsigned char output_str[1000];
|
|
rsa_context ctx;
|
|
mpi P1, Q1, H, G;
|
|
size_t output_len;
|
|
|
|
mpi_init( &P1 ); mpi_init( &Q1 ); mpi_init( &H ); mpi_init( &G );
|
|
rsa_init( &ctx, {padding_mode}, 0 );
|
|
|
|
memset( message_str, 0x00, 1000 );
|
|
memset( output, 0x00, 1000 );
|
|
memset( output_str, 0x00, 1000 );
|
|
|
|
ctx.len = {mod} / 8;
|
|
TEST_ASSERT( mpi_read_string( &ctx.P, {radix_P}, {input_P} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.Q, {radix_Q}, {input_Q} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
|
|
|
|
TEST_ASSERT( mpi_sub_int( &P1, &ctx.P, 1 ) == 0 );
|
|
TEST_ASSERT( mpi_sub_int( &Q1, &ctx.Q, 1 ) == 0 );
|
|
TEST_ASSERT( mpi_mul_mpi( &H, &P1, &Q1 ) == 0 );
|
|
TEST_ASSERT( mpi_gcd( &G, &ctx.E, &H ) == 0 );
|
|
TEST_ASSERT( mpi_inv_mod( &ctx.D , &ctx.E, &H ) == 0 );
|
|
TEST_ASSERT( mpi_mod_mpi( &ctx.DP, &ctx.D, &P1 ) == 0 );
|
|
TEST_ASSERT( mpi_mod_mpi( &ctx.DQ, &ctx.D, &Q1 ) == 0 );
|
|
TEST_ASSERT( mpi_inv_mod( &ctx.QP, &ctx.Q, &ctx.P ) == 0 );
|
|
|
|
TEST_ASSERT( rsa_check_privkey( &ctx ) == 0 );
|
|
|
|
unhexify( message_str, {message_hex_string} );
|
|
output_len = 0;
|
|
|
|
TEST_ASSERT( rsa_pkcs1_decrypt( &ctx, RSA_PRIVATE, &output_len, message_str, output, {max_output} ) == {result} );
|
|
if( {result} == 0 )
|
|
{
|
|
hexify( output_str, output, ctx.len );
|
|
|
|
TEST_ASSERT( strncasecmp( (char *) output_str, {result_hex_str}, strlen( {result_hex_str} ) ) == 0 );
|
|
}
|
|
|
|
mpi_free( &P1 ); mpi_free( &Q1 ); mpi_free( &H ); mpi_free( &G );
|
|
rsa_free( &ctx );
|
|
}
|
|
END_CASE
|
|
|
|
BEGIN_CASE
|
|
rsa_public:message_hex_string:mod:radix_N:input_N:radix_E:input_E:result_hex_str:result
|
|
{
|
|
unsigned char message_str[1000];
|
|
unsigned char output[1000];
|
|
unsigned char output_str[1000];
|
|
rsa_context ctx;
|
|
|
|
rsa_init( &ctx, RSA_PKCS_V15, 0 );
|
|
memset( message_str, 0x00, 1000 );
|
|
memset( output, 0x00, 1000 );
|
|
memset( output_str, 0x00, 1000 );
|
|
|
|
ctx.len = {mod} / 8;
|
|
TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
|
|
|
|
TEST_ASSERT( rsa_check_pubkey( &ctx ) == 0 );
|
|
|
|
unhexify( message_str, {message_hex_string} );
|
|
|
|
TEST_ASSERT( rsa_public( &ctx, message_str, output ) == {result} );
|
|
if( {result} == 0 )
|
|
{
|
|
hexify( output_str, output, ctx.len );
|
|
|
|
TEST_ASSERT( strcasecmp( (char *) output_str, {result_hex_str} ) == 0 );
|
|
}
|
|
|
|
rsa_free( &ctx );
|
|
}
|
|
END_CASE
|
|
|
|
BEGIN_CASE
|
|
rsa_private:message_hex_string:mod:radix_P:input_P:radix_Q:input_Q:radix_N:input_N:radix_E:input_E:result_hex_str:result
|
|
{
|
|
unsigned char message_str[1000];
|
|
unsigned char output[1000];
|
|
unsigned char output_str[1000];
|
|
rsa_context ctx;
|
|
mpi P1, Q1, H, G;
|
|
|
|
mpi_init( &P1 ); mpi_init( &Q1 ); mpi_init( &H ); mpi_init( &G );
|
|
rsa_init( &ctx, RSA_PKCS_V15, 0 );
|
|
|
|
memset( message_str, 0x00, 1000 );
|
|
memset( output, 0x00, 1000 );
|
|
memset( output_str, 0x00, 1000 );
|
|
|
|
ctx.len = {mod} / 8;
|
|
TEST_ASSERT( mpi_read_string( &ctx.P, {radix_P}, {input_P} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.Q, {radix_Q}, {input_Q} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
|
|
TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
|
|
|
|
TEST_ASSERT( mpi_sub_int( &P1, &ctx.P, 1 ) == 0 );
|
|
TEST_ASSERT( mpi_sub_int( &Q1, &ctx.Q, 1 ) == 0 );
|
|
TEST_ASSERT( mpi_mul_mpi( &H, &P1, &Q1 ) == 0 );
|
|
TEST_ASSERT( mpi_gcd( &G, &ctx.E, &H ) == 0 );
|
|
TEST_ASSERT( mpi_inv_mod( &ctx.D , &ctx.E, &H ) == 0 );
|
|
TEST_ASSERT( mpi_mod_mpi( &ctx.DP, &ctx.D, &P1 ) == 0 );
|
|
TEST_ASSERT( mpi_mod_mpi( &ctx.DQ, &ctx.D, &Q1 ) == 0 );
|
|
TEST_ASSERT( mpi_inv_mod( &ctx.QP, &ctx.Q, &ctx.P ) == 0 );
|
|
|
|
TEST_ASSERT( rsa_check_privkey( &ctx ) == 0 );
|
|
|
|
unhexify( message_str, {message_hex_string} );
|
|
|
|
TEST_ASSERT( rsa_private( &ctx, message_str, output ) == {result} );
|
|
if( {result} == 0 )
|
|
{
|
|
hexify( output_str, output, ctx.len );
|
|
|
|
TEST_ASSERT( strcasecmp( (char *) output_str, {result_hex_str} ) == 0 );
|
|
}
|
|
|
|
mpi_free( &P1 ); mpi_free( &Q1 ); mpi_free( &H ); mpi_free( &G );
|
|
rsa_free( &ctx );
|
|
}
|
|
END_CASE
|
|
|
|
BEGIN_CASE
|
|
rsa_check_privkey_null:
|
|
{
|
|
rsa_context ctx;
|
|
memset( &ctx, 0x00, sizeof( rsa_context ) );
|
|
|
|
TEST_ASSERT( rsa_check_privkey( &ctx ) == POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
|
|
}
|
|
END_CASE
|
|
|
|
BEGIN_CASE
|
|
rsa_check_pubkey:radix_N:input_N:radix_E:input_E:result
|
|
{
|
|
rsa_context ctx;
|
|
|
|
rsa_init( &ctx, RSA_PKCS_V15, 0 );
|
|
|
|
if( strlen( {input_N} ) )
|
|
{
|
|
TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
|
|
}
|
|
if( strlen( {input_E} ) )
|
|
{
|
|
TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
|
|
}
|
|
|
|
TEST_ASSERT( rsa_check_pubkey( &ctx ) == {result} );
|
|
|
|
rsa_free( &ctx );
|
|
}
|
|
END_CASE
|
|
|
|
BEGIN_CASE
|
|
rsa_check_privkey:mod:radix_P:input_P:radix_Q:input_Q:radix_N:input_N:radix_E:input_E:radix_D:input_D:radix_DP:input_DP:radix_DQ:input_DQ:radix_QP:input_QP:result
|
|
{
|
|
rsa_context ctx;
|
|
|
|
rsa_init( &ctx, RSA_PKCS_V15, 0 );
|
|
|
|
ctx.len = {mod} / 8;
|
|
if( strlen( {input_P} ) )
|
|
{
|
|
TEST_ASSERT( mpi_read_string( &ctx.P, {radix_P}, {input_P} ) == 0 );
|
|
}
|
|
if( strlen( {input_Q} ) )
|
|
{
|
|
TEST_ASSERT( mpi_read_string( &ctx.Q, {radix_Q}, {input_Q} ) == 0 );
|
|
}
|
|
if( strlen( {input_N} ) )
|
|
{
|
|
TEST_ASSERT( mpi_read_string( &ctx.N, {radix_N}, {input_N} ) == 0 );
|
|
}
|
|
if( strlen( {input_E} ) )
|
|
{
|
|
TEST_ASSERT( mpi_read_string( &ctx.E, {radix_E}, {input_E} ) == 0 );
|
|
}
|
|
if( strlen( {input_D} ) )
|
|
{
|
|
TEST_ASSERT( mpi_read_string( &ctx.D, {radix_D}, {input_D} ) == 0 );
|
|
}
|
|
if( strlen( {input_DP} ) )
|
|
{
|
|
TEST_ASSERT( mpi_read_string( &ctx.DP, {radix_DP}, {input_DP} ) == 0 );
|
|
}
|
|
if( strlen( {input_DQ} ) )
|
|
{
|
|
TEST_ASSERT( mpi_read_string( &ctx.DQ, {radix_DQ}, {input_DQ} ) == 0 );
|
|
}
|
|
if( strlen( {input_QP} ) )
|
|
{
|
|
TEST_ASSERT( mpi_read_string( &ctx.QP, {radix_QP}, {input_QP} ) == 0 );
|
|
}
|
|
|
|
TEST_ASSERT( rsa_check_privkey( &ctx ) == {result} );
|
|
|
|
rsa_free( &ctx );
|
|
}
|
|
END_CASE
|
|
|
|
BEGIN_CASE
|
|
rsa_gen_key:nrbits:exponent:result
|
|
{
|
|
rsa_context ctx;
|
|
entropy_context entropy;
|
|
ctr_drbg_context ctr_drbg;
|
|
char *pers = "test_suite_rsa";
|
|
|
|
entropy_init( &entropy );
|
|
TEST_ASSERT( ctr_drbg_init( &ctr_drbg, entropy_func, &entropy,
|
|
(unsigned char *) pers, strlen( pers ) ) == 0 );
|
|
|
|
rsa_init( &ctx, 0, 0 );
|
|
|
|
TEST_ASSERT( rsa_gen_key( &ctx, ctr_drbg_random, &ctr_drbg, {nrbits}, {exponent} ) == {result} );
|
|
if( {result} == 0 )
|
|
{
|
|
TEST_ASSERT( rsa_check_privkey( &ctx ) == 0 );
|
|
}
|
|
|
|
rsa_free( &ctx );
|
|
}
|
|
END_CASE
|
|
|
|
BEGIN_CASE
|
|
rsa_selftest:
|
|
{
|
|
TEST_ASSERT( rsa_self_test( 0 ) == 0 );
|
|
}
|
|
END_CASE
|