The Great Renaming
A simple execution of tmp/invoke-rename.pl
diff --git a/tests/suites/test_suite_mpi.function b/tests/suites/test_suite_mpi.function
index 75c8d30..bf4f0b3 100644
--- a/tests/suites/test_suite_mpi.function
+++ b/tests/suites/test_suite_mpi.function
@@ -3,7 +3,7 @@
/* END_HEADER */
/* BEGIN_DEPENDENCIES
- * depends_on:POLARSSL_BIGNUM_C
+ * depends_on:MBEDTLS_BIGNUM_C
* END_DEPENDENCIES
*/
@@ -12,16 +12,16 @@
char *input_A, int output_size, int result_read,
int result_write )
{
- mpi X;
+ mbedtls_mpi X;
char str[1000];
size_t len = output_size;
- mpi_init( &X );
+ mbedtls_mpi_init( &X );
- TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == result_read );
+ TEST_ASSERT( mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_write_string( &X, radix_A, str, &len ) == result_write );
if( result_write == 0 )
{
TEST_ASSERT( strcasecmp( str, input_A ) == 0 );
@@ -29,37 +29,37 @@
}
exit:
- mpi_free( &X );
+ mbedtls_mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_read_binary( char *input_X, int radix_A, char *input_A )
+void mbedtls_mpi_read_binary( char *input_X, int radix_A, char *input_A )
{
- mpi X;
+ mbedtls_mpi X;
unsigned char str[1000];
unsigned char buf[1000];
size_t len = 1000;
size_t input_len;
- mpi_init( &X );
+ mbedtls_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( mbedtls_mpi_read_binary( &X, buf, input_len ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_write_string( &X, radix_A, (char *) str, &len ) == 0 );
TEST_ASSERT( strcmp( (char *) str, input_A ) == 0 );
exit:
- mpi_free( &X );
+ mbedtls_mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_write_binary( int radix_X, char *input_X, char *input_A,
+void mbedtls_mpi_write_binary( int radix_X, char *input_X, char *input_A,
int output_size, int result )
{
- mpi X;
+ mbedtls_mpi X;
unsigned char str[1000];
unsigned char buf[1000];
size_t buflen;
@@ -67,15 +67,15 @@
memset( buf, 0x00, 1000 );
memset( str, 0x00, 1000 );
- mpi_init( &X );
+ mbedtls_mpi_init( &X );
- TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
- buflen = mpi_size( &X );
+ buflen = mbedtls_mpi_size( &X );
if( buflen > (size_t) output_size )
buflen = (size_t) output_size;
- TEST_ASSERT( mpi_write_binary( &X, buf, buflen ) == result );
+ TEST_ASSERT( mbedtls_mpi_write_binary( &X, buf, buflen ) == result );
if( result == 0)
{
hexify( str, buf, buflen );
@@ -84,15 +84,15 @@
}
exit:
- mpi_free( &X );
+ mbedtls_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,
+/* BEGIN_CASE depends_on:MBEDTLS_FS_IO */
+void mbedtls_mpi_read_file( int radix_X, char *input_file, char *input_A,
int result )
{
- mpi X;
+ mbedtls_mpi X;
unsigned char str[1000];
unsigned char buf[1000];
size_t buflen;
@@ -102,18 +102,18 @@
memset( buf, 0x00, 1000 );
memset( str, 0x00, 1000 );
- mpi_init( &X );
+ mbedtls_mpi_init( &X );
file = fopen( input_file, "r" );
TEST_ASSERT( file != NULL );
- ret = mpi_read_file( &X, radix_X, file );
+ ret = mbedtls_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 );
+ buflen = mbedtls_mpi_size( &X );
+ TEST_ASSERT( mbedtls_mpi_write_binary( &X, buf, buflen ) == 0 );
hexify( str, buf, buflen );
@@ -121,320 +121,320 @@
}
exit:
- mpi_free( &X );
+ mbedtls_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,
+/* BEGIN_CASE depends_on:MBEDTLS_FS_IO */
+void mbedtls_mpi_write_file( int radix_X, char *input_X, int output_radix,
char *output_file )
{
- mpi X, Y;
+ mbedtls_mpi X, Y;
FILE *file_out, *file_in;
- mpi_init( &X ); mpi_init( &Y );
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
- TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_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 );
+ TEST_ASSERT( mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_file( &Y, output_radix, file_in ) == 0 );
fclose(file_in);
- TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &Y );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_get_bit( int radix_X, char *input_X, int pos, int val )
+void mbedtls_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 );
+ mbedtls_mpi X;
+ mbedtls_mpi_init( &X );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_get_bit( &X, pos ) == val );
exit:
- mpi_free( &X );
+ mbedtls_mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_set_bit( int radix_X, char *input_X, int pos, int val, int radix_Y,
+void mbedtls_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 );
+ mbedtls_mpi X, Y;
+ mbedtls_mpi_init( &X ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, output_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_set_bit( &X, pos, val ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &Y );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_lsb( int radix_X, char *input_X, int nr_bits )
+void mbedtls_mpi_lsb( int radix_X, char *input_X, int nr_bits )
{
- mpi X;
- mpi_init( &X );
+ mbedtls_mpi X;
+ mbedtls_mpi_init( &X );
- TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
- TEST_ASSERT( mpi_lsb( &X ) == (size_t) nr_bits );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_lsb( &X ) == (size_t) nr_bits );
exit:
- mpi_free( &X );
+ mbedtls_mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_msb( int radix_X, char *input_X, int nr_bits )
+void mbedtls_mpi_msb( int radix_X, char *input_X, int nr_bits )
{
- mpi X;
- mpi_init( &X );
+ mbedtls_mpi X;
+ mbedtls_mpi_init( &X );
- TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
- TEST_ASSERT( mpi_msb( &X ) == (size_t) nr_bits );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_msb( &X ) == (size_t) nr_bits );
exit:
- mpi_free( &X );
+ mbedtls_mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_gcd( int radix_X, char *input_X, int radix_Y, char *input_Y,
+void mbedtls_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 );
+ mbedtls_mpi A, X, Y, Z;
+ mbedtls_mpi_init( &A ); mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_gcd( &Z, &X, &Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
- mpi_free( &A ); mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z );
+ mbedtls_mpi_free( &A ); mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_cmp_int( int input_X, int input_A, int result_CMP )
+void mbedtls_mpi_cmp_int( int input_X, int input_A, int result_CMP )
{
- mpi X;
- mpi_init( &X );
+ mbedtls_mpi X;
+ mbedtls_mpi_init( &X );
- TEST_ASSERT( mpi_lset( &X, input_X ) == 0);
- TEST_ASSERT( mpi_cmp_int( &X, input_A ) == result_CMP);
+ TEST_ASSERT( mbedtls_mpi_lset( &X, input_X ) == 0);
+ TEST_ASSERT( mbedtls_mpi_cmp_int( &X, input_A ) == result_CMP);
exit:
- mpi_free( &X );
+ mbedtls_mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_cmp_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
+void mbedtls_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 );
+ mbedtls_mpi X, Y;
+ mbedtls_mpi_init( &X ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == input_A );
exit:
- mpi_free( &X ); mpi_free( &Y );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_cmp_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
+void mbedtls_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 );
+ mbedtls_mpi X, Y;
+ mbedtls_mpi_init( &X ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_abs( &X, &Y ) == input_A );
exit:
- mpi_free( &X ); mpi_free( &Y );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_copy( int input_X, int input_A )
+void mbedtls_mpi_copy( int input_X, int input_A )
{
- mpi X, Y, A;
- mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
+ mbedtls_mpi X, Y, A;
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_lset( &X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_lset( &Y, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_lset( &A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) != 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_copy( &Y, &X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) != 0 );
exit:
- mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
void mpi_copy_self( int input_X )
{
- mpi X;
- mpi_init( &X );
+ mbedtls_mpi X;
+ mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_lset( &X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_copy( &X, &X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_int( &X, input_X ) == 0 );
exit:
- mpi_free( &X );
+ mbedtls_mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_shrink( int before, int used, int min, int after )
+void mbedtls_mpi_shrink( int before, int used, int min, int after )
{
- mpi X;
- mpi_init( &X );
+ mbedtls_mpi X;
+ mbedtls_mpi_init( &X );
- TEST_ASSERT( mpi_grow( &X, before ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_grow( &X, before ) == 0 );
TEST_ASSERT( used <= before );
- memset( X.p, 0x2a, used * sizeof( t_uint ) );
- TEST_ASSERT( mpi_shrink( &X, min ) == 0 );
+ memset( X.p, 0x2a, used * sizeof( mbedtls_mpi_uint ) );
+ TEST_ASSERT( mbedtls_mpi_shrink( &X, min ) == 0 );
TEST_ASSERT( X.n == (size_t) after );
exit:
- mpi_free( &X );
+ mbedtls_mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_safe_cond_assign( int x_sign, char *x_str,
+void mbedtls_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 );
+ mbedtls_mpi X, Y, XX;
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &XX );
- TEST_ASSERT( mpi_read_string( &X, 16, x_str ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, 16, x_str ) == 0 );
X.s = x_sign;
- TEST_ASSERT( mpi_read_string( &Y, 16, y_str ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, 16, y_str ) == 0 );
Y.s = y_sign;
- TEST_ASSERT( mpi_copy( &XX, &X ) == 0 );
+ TEST_ASSERT( mbedtls_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( mbedtls_mpi_safe_cond_assign( &X, &Y, 0 ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &XX ) == 0 );
- TEST_ASSERT( mpi_safe_cond_assign( &X, &Y, 1 ) == 0 );
- TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_safe_cond_assign( &X, &Y, 1 ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &Y ); mpi_free( &XX );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &XX );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_safe_cond_swap( int x_sign, char *x_str,
+void mbedtls_mpi_safe_cond_swap( int x_sign, char *x_str,
int y_sign, char *y_str )
{
- mpi X, Y, XX, YY;
+ mbedtls_mpi X, Y, XX, YY;
- mpi_init( &X ); mpi_init( &Y );
- mpi_init( &XX ); mpi_init( &YY );
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
+ mbedtls_mpi_init( &XX ); mbedtls_mpi_init( &YY );
- TEST_ASSERT( mpi_read_string( &X, 16, x_str ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, 16, x_str ) == 0 );
X.s = x_sign;
- TEST_ASSERT( mpi_read_string( &Y, 16, y_str ) == 0 );
+ TEST_ASSERT( mbedtls_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( mbedtls_mpi_copy( &XX, &X ) == 0 );
+ TEST_ASSERT( mbedtls_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( mbedtls_mpi_safe_cond_swap( &X, &Y, 0 ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &XX ) == 0 );
+ TEST_ASSERT( mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_safe_cond_swap( &X, &Y, 1 ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &XX ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &YY ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &Y );
- mpi_free( &XX ); mpi_free( &YY );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
+ mbedtls_mpi_free( &XX ); mbedtls_mpi_free( &YY );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_swap( int input_X, int input_Y )
+void mbedtls_mpi_swap( int input_X, int input_Y )
{
- mpi X, Y, A;
- mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
+ mbedtls_mpi X, Y, A;
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_lset( &X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_lset( &Y, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_lset( &A, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) != 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
+ mbedtls_mpi_swap( &X, &Y );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) != 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_add_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
+void mbedtls_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 );
+ mbedtls_mpi X, Y, Z, A;
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_add_mpi( &Z, &X, &Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_add_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
+void mbedtls_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 );
+ mbedtls_mpi X, Y, Z, A;
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_add_abs( &Z, &X, &Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
}
/* END_CASE */
@@ -442,17 +442,17 @@
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 );
+ mbedtls_mpi X, Y, A;
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_add_abs( &X, &X, &Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
}
/* END_CASE */
@@ -460,371 +460,371 @@
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 );
+ mbedtls_mpi X, Y, A;
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_add_abs( &Y, &X, &Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_add_int( int radix_X, char *input_X, int input_Y, int radix_A,
+void mbedtls_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 );
+ mbedtls_mpi X, Z, A;
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Z ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_add_int( &Z, &X, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_sub_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
+void mbedtls_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 );
+ mbedtls_mpi X, Y, Z, A;
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_sub_mpi( &Z, &X, &Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_sub_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
+void mbedtls_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;
+ mbedtls_mpi X, Y, Z, A;
int res;
- mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_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( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
- res = mpi_sub_abs( &Z, &X, &Y );
+ res = mbedtls_mpi_sub_abs( &Z, &X, &Y );
TEST_ASSERT( res == sub_result );
if( res == 0 )
- TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_sub_int( int radix_X, char *input_X, int input_Y, int radix_A,
+void mbedtls_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 );
+ mbedtls_mpi X, Z, A;
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Z ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_sub_int( &Z, &X, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_mul_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
+void mbedtls_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 );
+ mbedtls_mpi X, Y, Z, A;
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_mul_mpi( &Z, &X, &Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_mul_int( int radix_X, char *input_X, int input_Y, int radix_A,
+void mbedtls_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 );
+ mbedtls_mpi X, Z, A;
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Z ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_mul_int( &Z, &X, input_Y ) == 0 );
if( strcmp( result_comparison, "==" ) == 0 )
- TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
else if( strcmp( result_comparison, "!=" ) == 0 )
- TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) != 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) != 0 );
else
TEST_ASSERT( "unknown operator" == 0 );
exit:
- mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_div_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
+void mbedtls_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;
+ mbedtls_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 );
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &R );
+ mbedtls_mpi_init( &A ); mbedtls_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( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &B, radix_B, input_B ) == 0 );
+ res = mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Q, &A ) == 0 );
+ TEST_ASSERT( mbedtls_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 );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &R );
+ mbedtls_mpi_free( &A ); mbedtls_mpi_free( &B );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_div_int( int radix_X, char *input_X, int input_Y, int radix_A,
+void mbedtls_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;
+ mbedtls_mpi X, Q, R, A, B;
int res;
- mpi_init( &X ); mpi_init( &Q ); mpi_init( &R ); mpi_init( &A );
- mpi_init( &B );
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &R ); mbedtls_mpi_init( &A );
+ mbedtls_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( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &B, radix_B, input_B ) == 0 );
+ res = mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Q, &A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R, &B ) == 0 );
}
exit:
- mpi_free( &X ); mpi_free( &Q ); mpi_free( &R ); mpi_free( &A );
- mpi_free( &B );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &R ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free( &B );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_mod_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
+void mbedtls_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;
+ mbedtls_mpi X, Y, A;
int res;
- mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_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( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ res = mbedtls_mpi_mod_mpi( &X, &X, &Y );
TEST_ASSERT( res == div_result );
if( res == 0 )
{
- TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
}
exit:
- mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_mod_int( int radix_X, char *input_X, int input_Y, int input_A,
+void mbedtls_mpi_mod_int( int radix_X, char *input_X, int input_Y, int input_A,
int div_result )
{
- mpi X;
+ mbedtls_mpi X;
int res;
- t_uint r;
- mpi_init( &X );
+ mbedtls_mpi_uint r;
+ mbedtls_mpi_init( &X );
- TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
- res = mpi_mod_int( &r, &X, input_Y );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ res = mbedtls_mpi_mod_int( &r, &X, input_Y );
TEST_ASSERT( res == div_result );
if( res == 0 )
{
- TEST_ASSERT( r == (t_uint) input_A );
+ TEST_ASSERT( r == (mbedtls_mpi_uint) input_A );
}
exit:
- mpi_free( &X );
+ mbedtls_mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_exp_mod( int radix_A, char *input_A, int radix_E, char *input_E,
+void mbedtls_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;
+ mbedtls_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 );
+ mbedtls_mpi_init( &A ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &N );
+ mbedtls_mpi_init( &RR ); mbedtls_mpi_init( &Z ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
if( strlen( input_RR ) )
- TEST_ASSERT( mpi_read_string( &RR, radix_RR, input_RR ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &RR, radix_RR, input_RR ) == 0 );
- res = mpi_exp_mod( &Z, &A, &E, &N, &RR );
+ res = mbedtls_mpi_exp_mod( &Z, &A, &E, &N, &RR );
TEST_ASSERT( res == div_result );
if( res == 0 )
{
- TEST_ASSERT( mpi_cmp_mpi( &Z, &X ) == 0 );
+ TEST_ASSERT( mbedtls_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 );
+ mbedtls_mpi_free( &A ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &N );
+ mbedtls_mpi_free( &RR ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_inv_mod( int radix_X, char *input_X, int radix_Y, char *input_Y,
+void mbedtls_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;
+ mbedtls_mpi X, Y, Z, A;
int res;
- mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
+ mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_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( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ res = mbedtls_mpi_inv_mod( &Z, &X, &Y );
TEST_ASSERT( res == div_result );
if( res == 0 )
{
- TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
}
exit:
- mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
}
/* END_CASE */
-/* BEGIN_CASE depends_on:POLARSSL_GENPRIME */
-void mpi_is_prime( int radix_X, char *input_X, int div_result )
+/* BEGIN_CASE depends_on:MBEDTLS_GENPRIME */
+void mbedtls_mpi_is_prime( int radix_X, char *input_X, int div_result )
{
- mpi X;
+ mbedtls_mpi X;
int res;
- mpi_init( &X );
+ mbedtls_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( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ res = mbedtls_mpi_is_prime( &X, rnd_std_rand, NULL );
TEST_ASSERT( res == div_result );
exit:
- mpi_free( &X );
+ mbedtls_mpi_free( &X );
}
/* END_CASE */
-/* BEGIN_CASE depends_on:POLARSSL_GENPRIME */
-void mpi_gen_prime( int bits, int safe, int ref_ret )
+/* BEGIN_CASE depends_on:MBEDTLS_GENPRIME */
+void mbedtls_mpi_gen_prime( int bits, int safe, int ref_ret )
{
- mpi X;
+ mbedtls_mpi X;
int my_ret;
- mpi_init( &X );
+ mbedtls_mpi_init( &X );
- my_ret = mpi_gen_prime( &X, bits, safe, rnd_std_rand, NULL );
+ my_ret = mbedtls_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 );
+ size_t actual_bits = mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_is_prime( &X, rnd_std_rand, NULL ) == 0 );
if( safe )
{
- mpi_shift_r( &X, 1 ); /* X = ( X - 1 ) / 2 */
- TEST_ASSERT( mpi_is_prime( &X, rnd_std_rand, NULL ) == 0 );
+ mbedtls_mpi_shift_r( &X, 1 ); /* X = ( X - 1 ) / 2 */
+ TEST_ASSERT( mbedtls_mpi_is_prime( &X, rnd_std_rand, NULL ) == 0 );
}
}
exit:
- mpi_free( &X );
+ mbedtls_mpi_free( &X );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_shift_l( int radix_X, char *input_X, int shift_X, int radix_A,
+void mbedtls_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 );
+ mbedtls_mpi X, A;
+ mbedtls_mpi_init( &X ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_shift_l( &X, shift_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &A );
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_shift_r( int radix_X, char *input_X, int shift_X, int radix_A,
+void mbedtls_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 );
+ mbedtls_mpi X, A;
+ mbedtls_mpi_init( &X ); mbedtls_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 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_shift_r( &X, shift_X ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
exit:
- mpi_free( &X ); mpi_free( &A );
+ mbedtls_mpi_free( &X ); mbedtls_mpi_free( &A );
}
/* END_CASE */
-/* BEGIN_CASE depends_on:POLARSSL_SELF_TEST */
+/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
void mpi_selftest()
{
- TEST_ASSERT( mpi_self_test( 0 ) == 0 );
+ TEST_ASSERT( mbedtls_mpi_self_test( 0 ) == 0 );
}
/* END_CASE */