yuzu/mbedtls
1
0
Fork 0
mirror of https://github.com/yuzu-emu/mbedtls.git synced 2024-12-25 15:25:27 +00:00
Code Issues Packages Projects Releases Wiki Activity
mbedtls/tests/suites/test_suite_mpi.function
Hanno Becker 175668a8fd Address issues found by coverity 
1) The MPI test for prime generation missed a return value
   check for a call to `mpi_shift_r`. This is neither
   critical nor new but should be fixed.

2) The RSA keygeneration example program contained code
   initializing an RSA context after a potentially failing
   call to CTR DRBG initialization, leaving the corresponding
   RSA context free call in the cleanup section orphaned.
   The commit fixes this by moving the initializtion of the
   RSA context prior to the first potentially failing call.
2018-01-10 11:24:43 +00:00

877 lines
23 KiB
Plaintext
Raw Blame History

/* BEGIN_HEADER */
#include "polarssl/bignum.h"
/* END_HEADER */
/* BEGIN_DEPENDENCIES
* depends_on:POLARSSL_BIGNUM_C
* END_DEPENDENCIES
*/
/* BEGIN_CASE */
void mpi_null( )
{
mpi X, Y, Z;
mpi_init( &X );
mpi_init( &Y );
mpi_init( &Z );
TEST_ASSERT( mpi_get_bit( &X, 42 ) == 0 );
TEST_ASSERT( mpi_lsb( &X ) == 0 );
TEST_ASSERT( mpi_msb( &X ) == 0 );
TEST_ASSERT( mpi_size( &X ) == 0 );
exit:
mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_read_write_string( int radix_X, char *input_X, int radix_A,
char *input_A, int output_size, int result_read,
int result_write )
{
mpi X;
char str[1000];
size_t len = output_size;
mpi_init( &X );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == result_read );
if( result_read == 0 )
{
TEST_ASSERT( mpi_write_string( &X, radix_A, str, &len ) == result_write );
if( result_write == 0 )
{
TEST_ASSERT( strcasecmp( str, input_A ) == 0 );
}
}
exit:
mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_read_binary( char *input_X, int radix_A, char *input_A )
{
mpi X;
unsigned char str[1000];
unsigned char buf[1000];
size_t len = 1000;
size_t input_len;
mpi_init( &X );
input_len = unhexify( buf, input_X );
TEST_ASSERT( mpi_read_binary( &X, buf, input_len ) == 0 );
TEST_ASSERT( mpi_write_string( &X, radix_A, (char *) str, &len ) == 0 );
TEST_ASSERT( strcmp( (char *) str, input_A ) == 0 );
exit:
mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_write_binary( int radix_X, char *input_X, char *input_A,
int output_size, int result )
{
mpi X;
unsigned char str[1000];
unsigned char buf[1000];
size_t buflen;
memset( buf, 0x00, 1000 );
memset( str, 0x00, 1000 );
mpi_init( &X );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
buflen = mpi_size( &X );
if( buflen > (size_t) output_size )
buflen = (size_t) output_size;
TEST_ASSERT( mpi_write_binary( &X, buf, buflen ) == result );
if( result == 0)
{
hexify( str, buf, buflen );
TEST_ASSERT( strcasecmp( (char *) str, input_A ) == 0 );
}
exit:
mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE depends_on:POLARSSL_FS_IO */
void mpi_read_file( int radix_X, char *input_file, char *input_A,
int result )
{
mpi X;
unsigned char str[1000];
unsigned char buf[1000];
size_t buflen;
FILE *file;
int ret;
memset( buf, 0x00, 1000 );
memset( str, 0x00, 1000 );
mpi_init( &X );
file = fopen( input_file, "r" );
TEST_ASSERT( file != NULL );
ret = mpi_read_file( &X, radix_X, file );
fclose(file);
TEST_ASSERT( ret == result );
if( result == 0 )
{
buflen = mpi_size( &X );
TEST_ASSERT( mpi_write_binary( &X, buf, buflen ) == 0 );
hexify( str, buf, buflen );
TEST_ASSERT( strcasecmp( (char *) str, input_A ) == 0 );
}
exit:
mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE depends_on:POLARSSL_FS_IO */
void mpi_write_file( int radix_X, char *input_X, int output_radix,
char *output_file )
{
mpi X, Y;
FILE *file_out, *file_in;
mpi_init( &X ); mpi_init( &Y );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
file_out = fopen( output_file, "w" );
TEST_ASSERT( file_out != NULL );
TEST_ASSERT( mpi_write_file( NULL, &X, output_radix, file_out ) == 0 );
fclose(file_out);
file_in = fopen( output_file, "r" );
TEST_ASSERT( file_in != NULL );
TEST_ASSERT( mpi_read_file( &Y, output_radix, file_in ) == 0 );
fclose(file_in);
TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
exit:
mpi_free( &X ); mpi_free( &Y );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_get_bit( int radix_X, char *input_X, int pos, int val )
{
mpi X;
mpi_init( &X );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_get_bit( &X, pos ) == val );
exit:
mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_set_bit( int radix_X, char *input_X, int pos, int val, int radix_Y,
char *output_Y )
{
mpi X, Y;
mpi_init( &X ); mpi_init( &Y );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &Y, radix_Y, output_Y ) == 0 );
TEST_ASSERT( mpi_set_bit( &X, pos, val ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
exit:
mpi_free( &X ); mpi_free( &Y );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_lsb( int radix_X, char *input_X, int nr_bits )
{
mpi X;
mpi_init( &X );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_lsb( &X ) == (size_t) nr_bits );
exit:
mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_msb( int radix_X, char *input_X, int nr_bits )
{
mpi X;
mpi_init( &X );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_msb( &X ) == (size_t) nr_bits );
exit:
mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_gcd( int radix_X, char *input_X, int radix_Y, char *input_Y,
int radix_A, char *input_A )
{
mpi A, X, Y, Z;
mpi_init( &A ); mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_gcd( &Z, &X, &Y ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
mpi_free( &A ); mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_cmp_int( int input_X, int input_A, int result_CMP )
{
mpi X;
mpi_init( &X );
TEST_ASSERT( mpi_lset( &X, input_X ) == 0);
TEST_ASSERT( mpi_cmp_int( &X, input_A ) == result_CMP);
exit:
mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_cmp_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
int input_A )
{
mpi X, Y;
mpi_init( &X ); mpi_init( &Y );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == input_A );
exit:
mpi_free( &X ); mpi_free( &Y );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_cmp_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
int input_A )
{
mpi X, Y;
mpi_init( &X ); mpi_init( &Y );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
TEST_ASSERT( mpi_cmp_abs( &X, &Y ) == input_A );
exit:
mpi_free( &X ); mpi_free( &Y );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_copy( int input_X, int input_A )
{
mpi X, Y, A;
mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
TEST_ASSERT( mpi_lset( &Y, input_A ) == 0 );
TEST_ASSERT( mpi_lset( &A, input_A ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
TEST_ASSERT( mpi_copy( &Y, &X ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) != 0 );
exit:
mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_copy_self( int input_X )
{
mpi X;
mpi_init( &X );
TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
TEST_ASSERT( mpi_copy( &X, &X ) == 0 );
TEST_ASSERT( mpi_cmp_int( &X, input_X ) == 0 );
exit:
mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_shrink( int before, int used, int min, int after )
{
mpi X;
mpi_init( &X );
TEST_ASSERT( mpi_grow( &X, before ) == 0 );
TEST_ASSERT( used <= before );
memset( X.p, 0x2a, used * sizeof( t_uint ) );
TEST_ASSERT( mpi_shrink( &X, min ) == 0 );
TEST_ASSERT( X.n == (size_t) after );
exit:
mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_safe_cond_assign( int x_sign, char *x_str,
int y_sign, char *y_str )
{
mpi X, Y, XX;
mpi_init( &X ); mpi_init( &Y ); mpi_init( &XX );
TEST_ASSERT( mpi_read_string( &X, 16, x_str ) == 0 );
X.s = x_sign;
TEST_ASSERT( mpi_read_string( &Y, 16, y_str ) == 0 );
Y.s = y_sign;
TEST_ASSERT( mpi_copy( &XX, &X ) == 0 );
TEST_ASSERT( mpi_safe_cond_assign( &X, &Y, 0 ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &XX ) == 0 );
TEST_ASSERT( mpi_safe_cond_assign( &X, &Y, 1 ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
exit:
mpi_free( &X ); mpi_free( &Y ); mpi_free( &XX );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_safe_cond_swap( int x_sign, char *x_str,
int y_sign, char *y_str )
{
mpi X, Y, XX, YY;
mpi_init( &X ); mpi_init( &Y );
mpi_init( &XX ); mpi_init( &YY );
TEST_ASSERT( mpi_read_string( &X, 16, x_str ) == 0 );
X.s = x_sign;
TEST_ASSERT( mpi_read_string( &Y, 16, y_str ) == 0 );
Y.s = y_sign;
TEST_ASSERT( mpi_copy( &XX, &X ) == 0 );
TEST_ASSERT( mpi_copy( &YY, &Y ) == 0 );
TEST_ASSERT( mpi_safe_cond_swap( &X, &Y, 0 ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &XX ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &Y, &YY ) == 0 );
TEST_ASSERT( mpi_safe_cond_swap( &X, &Y, 1 ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &Y, &XX ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &YY ) == 0 );
exit:
mpi_free( &X ); mpi_free( &Y );
mpi_free( &XX ); mpi_free( &YY );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_swap( int input_X, int input_Y )
{
mpi X, Y, A;
mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
TEST_ASSERT( mpi_lset( &Y, input_Y ) == 0 );
TEST_ASSERT( mpi_lset( &A, input_X ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
mpi_swap( &X, &Y );
TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
exit:
mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_add_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
int radix_A, char *input_A )
{
mpi X, Y, Z, A;
mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_add_mpi( &Z, &X, &Y ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_add_mpi_inplace( int radix_X, char *input_X, int radix_A, char *input_A )
{
mpi X, A;
mpi_init( &X ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_sub_abs( &X, &X, &X ) == 0 );
TEST_ASSERT( mpi_cmp_int( &X, 0 ) == 0 );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_add_abs( &X, &X, &X ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_add_mpi( &X, &X, &X ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
exit:
mpi_free( &X ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_add_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
int radix_A, char *input_A )
{
mpi X, Y, Z, A;
mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_add_abs( &Z, &X, &Y ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_add_abs_add_first( int radix_X, char *input_X, int radix_Y,
char *input_Y, int radix_A, char *input_A )
{
mpi X, Y, A;
mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_add_abs( &X, &X, &Y ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
exit:
mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_add_abs_add_second( int radix_X, char *input_X, int radix_Y,
char *input_Y, int radix_A, char *input_A )
{
mpi X, Y, A;
mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_add_abs( &Y, &X, &Y ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
exit:
mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_add_int( int radix_X, char *input_X, int input_Y, int radix_A,
char *input_A )
{
mpi X, Z, A;
mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_add_int( &Z, &X, input_Y ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_sub_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
int radix_A, char *input_A )
{
mpi X, Y, Z, A;
mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_sub_mpi( &Z, &X, &Y ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_sub_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
int radix_A, char *input_A, int sub_result )
{
mpi X, Y, Z, A;
int res;
mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
res = mpi_sub_abs( &Z, &X, &Y );
TEST_ASSERT( res == sub_result );
if( res == 0 )
TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_sub_int( int radix_X, char *input_X, int input_Y, int radix_A,
char *input_A )
{
mpi X, Z, A;
mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_sub_int( &Z, &X, input_Y ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_mul_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
int radix_A, char *input_A )
{
mpi X, Y, Z, A;
mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_mul_mpi( &Z, &X, &Y ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_mul_int( int radix_X, char *input_X, int input_Y, int radix_A,
char *input_A, char *result_comparison )
{
mpi X, Z, A;
mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_mul_int( &Z, &X, input_Y ) == 0 );
if( strcmp( result_comparison, "==" ) == 0 )
TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
else if( strcmp( result_comparison, "!=" ) == 0 )
TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) != 0 );
else
TEST_ASSERT( "unknown operator" == 0 );
exit:
mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_div_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
int radix_A, char *input_A, int radix_B, char *input_B,
int div_result )
{
mpi X, Y, Q, R, A, B;
int res;
mpi_init( &X ); mpi_init( &Y ); mpi_init( &Q ); mpi_init( &R );
mpi_init( &A ); mpi_init( &B );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_read_string( &B, radix_B, input_B ) == 0 );
res = mpi_div_mpi( &Q, &R, &X, &Y );
TEST_ASSERT( res == div_result );
if( res == 0 )
{
TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
}
exit:
mpi_free( &X ); mpi_free( &Y ); mpi_free( &Q ); mpi_free( &R );
mpi_free( &A ); mpi_free( &B );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_div_int( int radix_X, char *input_X, int input_Y, int radix_A,
char *input_A, int radix_B, char *input_B, int div_result )
{
mpi X, Q, R, A, B;
int res;
mpi_init( &X ); mpi_init( &Q ); mpi_init( &R ); mpi_init( &A );
mpi_init( &B );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_read_string( &B, radix_B, input_B ) == 0 );
res = mpi_div_int( &Q, &R, &X, input_Y );
TEST_ASSERT( res == div_result );
if( res == 0 )
{
TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
}
exit:
mpi_free( &X ); mpi_free( &Q ); mpi_free( &R ); mpi_free( &A );
mpi_free( &B );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_mod_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
int radix_A, char *input_A, int div_result )
{
mpi X, Y, A;
int res;
mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
res = mpi_mod_mpi( &X, &X, &Y );
TEST_ASSERT( res == div_result );
if( res == 0 )
{
TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
}
exit:
mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_mod_int( int radix_X, char *input_X, int input_Y, int input_A,
int div_result )
{
mpi X;
int res;
t_uint r;
mpi_init( &X );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
res = mpi_mod_int( &r, &X, input_Y );
TEST_ASSERT( res == div_result );
if( res == 0 )
{
TEST_ASSERT( r == (t_uint) input_A );
}
exit:
mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_exp_mod( int radix_A, char *input_A, int radix_E, char *input_E,
int radix_N, char *input_N, int radix_RR, char *input_RR,
int radix_X, char *input_X, int div_result )
{
mpi A, E, N, RR, Z, X;
int res;
mpi_init( &A ); mpi_init( &E ); mpi_init( &N );
mpi_init( &RR ); mpi_init( &Z ); mpi_init( &X );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_read_string( &E, radix_E, input_E ) == 0 );
TEST_ASSERT( mpi_read_string( &N, radix_N, input_N ) == 0 );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
if( strlen( input_RR ) )
TEST_ASSERT( mpi_read_string( &RR, radix_RR, input_RR ) == 0 );
res = mpi_exp_mod( &Z, &A, &E, &N, &RR );
TEST_ASSERT( res == div_result );
if( res == 0 )
{
TEST_ASSERT( mpi_cmp_mpi( &Z, &X ) == 0 );
}
exit:
mpi_free( &A ); mpi_free( &E ); mpi_free( &N );
mpi_free( &RR ); mpi_free( &Z ); mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_inv_mod( int radix_X, char *input_X, int radix_Y, char *input_Y,
int radix_A, char *input_A, int div_result )
{
mpi X, Y, Z, A;
int res;
mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
res = mpi_inv_mod( &Z, &X, &Y );
TEST_ASSERT( res == div_result );
if( res == 0 )
{
TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
}
exit:
mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE depends_on:POLARSSL_GENPRIME */
void mpi_is_prime( int radix_X, char *input_X, int div_result )
{
mpi X;
int res;
mpi_init( &X );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
res = mpi_is_prime( &X, rnd_std_rand, NULL );
TEST_ASSERT( res == div_result );
exit:
mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE depends_on:POLARSSL_GENPRIME */
void mpi_gen_prime( int bits, int safe, int ref_ret )
{
mpi X;
int my_ret;
mpi_init( &X );
my_ret = mpi_gen_prime( &X, bits, safe, rnd_std_rand, NULL );
TEST_ASSERT( my_ret == ref_ret );
if( ref_ret == 0 )
{
size_t actual_bits = mpi_msb( &X );
TEST_ASSERT( actual_bits >= (size_t) bits );
TEST_ASSERT( actual_bits <= (size_t) bits + 1 );
TEST_ASSERT( mpi_is_prime( &X, rnd_std_rand, NULL ) == 0 );
if( safe )
{
/* X = ( X - 1 ) / 2 */
TEST_ASSERT( mpi_shift_r( &X, 1 ) == 0 );
TEST_ASSERT( mpi_is_prime( &X, rnd_std_rand, NULL ) == 0 );
}
}
exit:
mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_shift_l( int radix_X, char *input_X, int shift_X, int radix_A,
char *input_A)
{
mpi X, A;
mpi_init( &X ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_shift_l( &X, shift_X ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
exit:
mpi_free( &X ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_shift_r( int radix_X, char *input_X, int shift_X, int radix_A,
char *input_A )
{
mpi X, A;
mpi_init( &X ); mpi_init( &A );
TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
TEST_ASSERT( mpi_shift_r( &X, shift_X ) == 0 );
TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
exit:
mpi_free( &X ); mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE depends_on:POLARSSL_SELF_TEST */
void mpi_selftest()
{
TEST_ASSERT( mpi_self_test( 0 ) == 0 );
}
/* END_CASE */
Reference in a new issue View git blame Copy permalink