8dfc8c41b7
The function wasn't converting back data to internal representation when writing it out. Signed-off-by: Janos Follath <janos.follath@arm.com>
252 lines
7.3 KiB
C
252 lines
7.3 KiB
C
/* BEGIN_HEADER */
|
|
#include "mbedtls/bignum.h"
|
|
#include "mbedtls/entropy.h"
|
|
#include "bignum_mod.h"
|
|
#include "constant_time_internal.h"
|
|
#include "test/constant_flow.h"
|
|
/* END_HEADER */
|
|
|
|
/* BEGIN_DEPENDENCIES
|
|
* depends_on:MBEDTLS_BIGNUM_C
|
|
* END_DEPENDENCIES
|
|
*/
|
|
|
|
/* BEGIN_CASE */
|
|
void mpi_mod_setup( int int_rep, int iret )
|
|
{
|
|
#define MLIMBS 8
|
|
mbedtls_mpi_uint mp[MLIMBS];
|
|
mbedtls_mpi_mod_modulus m;
|
|
int ret;
|
|
|
|
memset( mp, 0xFF, sizeof(mp) );
|
|
|
|
mbedtls_mpi_mod_modulus_init( &m );
|
|
ret = mbedtls_mpi_mod_modulus_setup( &m, mp, MLIMBS, int_rep );
|
|
TEST_EQUAL( ret, iret );
|
|
|
|
/* Only test if the constants have been set-up */
|
|
if ( ret == 0 && int_rep == MBEDTLS_MPI_MOD_REP_MONTGOMERY )
|
|
{
|
|
/* Test that the consts have been calculated */
|
|
TEST_ASSERT( m.rep.mont.rr != NULL );
|
|
TEST_ASSERT( m.rep.mont.mm != 0 );
|
|
|
|
}
|
|
|
|
/* Address sanitiser should catch if we try to free mp */
|
|
mbedtls_mpi_mod_modulus_free( &m );
|
|
|
|
/* Make sure that the modulus doesn't have reference to mp anymore */
|
|
TEST_ASSERT( m.p != mp );
|
|
|
|
/* Only test if the constants have been set-up */
|
|
if ( ret == 0 && int_rep == MBEDTLS_MPI_MOD_REP_MONTGOMERY )
|
|
{
|
|
/* Verify the data and pointers allocated have been properly wiped */
|
|
TEST_ASSERT( m.rep.mont.rr == NULL );
|
|
TEST_ASSERT( m.rep.mont.mm == 0 );
|
|
}
|
|
exit:
|
|
/* It should be safe to call an mbedtls free several times */
|
|
mbedtls_mpi_mod_modulus_free( &m );
|
|
|
|
#undef MLIMBS
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN MERGE SLOT 1 */
|
|
|
|
/* END MERGE SLOT 1 */
|
|
|
|
/* BEGIN MERGE SLOT 2 */
|
|
|
|
/* END MERGE SLOT 2 */
|
|
|
|
/* BEGIN MERGE SLOT 3 */
|
|
|
|
/* END MERGE SLOT 3 */
|
|
|
|
/* BEGIN MERGE SLOT 4 */
|
|
|
|
/* END MERGE SLOT 4 */
|
|
|
|
/* BEGIN MERGE SLOT 5 */
|
|
|
|
/* END MERGE SLOT 5 */
|
|
|
|
/* BEGIN MERGE SLOT 6 */
|
|
|
|
/* END MERGE SLOT 6 */
|
|
|
|
/* BEGIN MERGE SLOT 7 */
|
|
/* BEGIN_CASE */
|
|
void mpi_residue_setup( char * input_N, char * input_R, int ret )
|
|
{
|
|
mbedtls_mpi_uint *N = NULL;
|
|
mbedtls_mpi_uint *R = NULL;
|
|
size_t n_limbs, r_limbs;
|
|
mbedtls_mpi_mod_modulus m;
|
|
mbedtls_mpi_mod_residue r;
|
|
|
|
mbedtls_mpi_mod_modulus_init( &m );
|
|
|
|
/* Allocate the memory for intermediate data structures */
|
|
TEST_EQUAL( 0, mbedtls_test_read_mpi_core( &N, &n_limbs, input_N ) );
|
|
TEST_EQUAL( 0, mbedtls_test_read_mpi_core( &R, &r_limbs, input_R ) );
|
|
|
|
TEST_EQUAL( 0, mbedtls_mpi_mod_modulus_setup( &m, N, n_limbs,
|
|
MBEDTLS_MPI_MOD_REP_MONTGOMERY ) );
|
|
|
|
TEST_EQUAL( ret, mbedtls_mpi_mod_residue_setup( &r, &m, R , r_limbs ) );
|
|
|
|
if ( ret == 0 )
|
|
{
|
|
TEST_EQUAL( r.limbs, r_limbs );
|
|
TEST_ASSERT( r.p == R );
|
|
}
|
|
|
|
exit:
|
|
mbedtls_mpi_mod_modulus_free( &m );
|
|
mbedtls_free( N );
|
|
mbedtls_free( R );
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void mpi_mod_io_neg( char * input_N, data_t * buf, int ret )
|
|
{
|
|
mbedtls_mpi_uint *N = NULL;
|
|
mbedtls_mpi_uint *R = NULL;
|
|
|
|
mbedtls_mpi_mod_modulus m;
|
|
mbedtls_mpi_mod_residue r;
|
|
mbedtls_mpi_mod_residue rn = { NULL, 0 };
|
|
mbedtls_mpi_mod_ext_rep endian = MBEDTLS_MPI_MOD_EXT_REP_LE;
|
|
|
|
mbedtls_mpi_mod_modulus_init( &m );
|
|
|
|
size_t n_limbs;
|
|
TEST_EQUAL( 0, mbedtls_test_read_mpi_core( &N, &n_limbs, input_N ) );
|
|
size_t r_limbs = n_limbs;
|
|
ASSERT_ALLOC( R, r_limbs );
|
|
|
|
/* modulo->p == NULL || residue->p == NULL ( m has not been set-up ) */
|
|
TEST_EQUAL( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
|
mbedtls_mpi_mod_read( &r, &m, buf->x, buf->len, endian ) );
|
|
|
|
TEST_EQUAL( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
|
mbedtls_mpi_mod_write( &r, &m, buf->x, buf->len, endian ) );
|
|
|
|
TEST_EQUAL( 0, mbedtls_mpi_mod_modulus_setup( &m, N, n_limbs,
|
|
MBEDTLS_MPI_MOD_REP_MONTGOMERY ) );
|
|
TEST_EQUAL( 0, mbedtls_mpi_mod_residue_setup( &r, &m, R , r_limbs ) );
|
|
|
|
/* modulo->p == NULL || residue->p == NULL ( m has been set-up ) */
|
|
TEST_EQUAL( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
|
mbedtls_mpi_mod_read( &rn, &m, buf->x, buf->len, endian ) );
|
|
TEST_EQUAL( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
|
mbedtls_mpi_mod_write( &rn, &m, buf->x, buf->len, endian ) );
|
|
|
|
/* Fail for r_limbs < m->limbs */
|
|
r.limbs--;
|
|
TEST_ASSERT( r.limbs < m.limbs );
|
|
TEST_EQUAL( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
|
mbedtls_mpi_mod_read( &r, &m, buf->x, buf->len, endian ) );
|
|
TEST_EQUAL( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
|
mbedtls_mpi_mod_write( &r, &m, buf->x, buf->len, endian ) );
|
|
r.limbs++;
|
|
|
|
/* Fail for r_limbs > m->limbs */
|
|
m.limbs--;
|
|
TEST_ASSERT( r.limbs > m.limbs );
|
|
TEST_EQUAL( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
|
mbedtls_mpi_mod_read( &r, &m, buf->x, buf->len, endian ) );
|
|
TEST_EQUAL( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
|
|
mbedtls_mpi_mod_write( &r, &m, buf->x, buf->len, endian ) );
|
|
m.limbs++;
|
|
|
|
/* Test the read */
|
|
TEST_EQUAL( ret, mbedtls_mpi_mod_read( &r, &m, buf->x, buf->len, endian ) );
|
|
|
|
/* Test write overflow only when the representation is large and read is successful */
|
|
if ( r.limbs > 1 && ret == 0 )
|
|
TEST_EQUAL( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL,
|
|
mbedtls_mpi_mod_write( &r, &m, buf->x, 1, endian ) );
|
|
|
|
exit:
|
|
mbedtls_mpi_mod_residue_release( &r );
|
|
mbedtls_mpi_mod_modulus_free( &m );
|
|
mbedtls_free( N );
|
|
mbedtls_free( R );
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void mpi_mod_io( char * input_N, data_t * input_A, int endian )
|
|
{
|
|
mbedtls_mpi_uint *N = NULL;
|
|
mbedtls_mpi_uint *R = NULL;
|
|
mbedtls_mpi_uint *R_COPY = NULL;
|
|
unsigned char *r_buff = NULL;
|
|
mbedtls_mpi_mod_modulus m;
|
|
mbedtls_mpi_mod_residue r;
|
|
mbedtls_mpi_mod_residue r_copy;
|
|
size_t n_limbs, n_bytes, a_bytes;
|
|
|
|
mbedtls_mpi_mod_modulus_init( &m );
|
|
|
|
/* Read inputs */
|
|
TEST_EQUAL( 0, mbedtls_test_read_mpi_core( &N, &n_limbs, input_N ) );
|
|
n_bytes = n_limbs * sizeof( mbedtls_mpi_uint );
|
|
a_bytes = input_A->len;
|
|
|
|
/* Allocate the memory for intermediate data structures */
|
|
ASSERT_ALLOC( R, n_bytes );
|
|
ASSERT_ALLOC( R_COPY, n_bytes );
|
|
ASSERT_ALLOC( r_buff, a_bytes );
|
|
|
|
/* Test that input's size is not greater to modulo's */
|
|
TEST_LE_U( a_bytes, n_bytes );
|
|
|
|
/* Init Structures */
|
|
TEST_EQUAL( 0, mbedtls_mpi_mod_modulus_setup( &m, N, n_limbs,
|
|
MBEDTLS_MPI_MOD_REP_MONTGOMERY ) );
|
|
|
|
/* Enforcing p_limbs >= m->limbs */
|
|
TEST_EQUAL( 0, mbedtls_mpi_mod_residue_setup( &r, &m, R, n_limbs ) );
|
|
|
|
TEST_EQUAL( 0, mbedtls_mpi_mod_read( &r, &m, input_A->x, input_A->len,
|
|
endian ) );
|
|
|
|
TEST_EQUAL( 0, mbedtls_mpi_mod_write( &r, &m, r_buff, a_bytes,
|
|
endian ) );
|
|
|
|
/* Make sure that writing didn't change the value of r */
|
|
TEST_EQUAL( 0, mbedtls_mpi_mod_residue_setup( &r_copy, &m, R_COPY, n_limbs ) );
|
|
TEST_EQUAL( 0, mbedtls_mpi_mod_read( &r_copy, &m, input_A->x, input_A->len,
|
|
endian ) );
|
|
ASSERT_COMPARE( r.p, r.limbs, r_copy.p, r_copy.limbs );
|
|
|
|
ASSERT_COMPARE( r_buff, a_bytes, input_A->x, a_bytes );
|
|
exit:
|
|
mbedtls_mpi_mod_modulus_free( &m );
|
|
mbedtls_free( N );
|
|
mbedtls_free( R );
|
|
mbedtls_free( R_COPY );
|
|
mbedtls_free( r_buff );
|
|
}
|
|
/* END_CASE */
|
|
/* END MERGE SLOT 7 */
|
|
|
|
/* BEGIN MERGE SLOT 8 */
|
|
|
|
/* END MERGE SLOT 8 */
|
|
|
|
/* BEGIN MERGE SLOT 9 */
|
|
|
|
/* END MERGE SLOT 9 */
|
|
|
|
/* BEGIN MERGE SLOT 10 */
|
|
|
|
/* END MERGE SLOT 10 */
|