mirror of
https://github.com/Mbed-TLS/mbedtls.git
synced 2025-07-28 00:21:48 +03:00
Merge pull request #6095 from gabor-mezei-arm/6016_add_new_modulus_and_residue_structures
Add the new modulus and the residue structures with low level I/O operations
This commit is contained in:
@ -18,6 +18,9 @@ set(src_crypto
|
||||
asn1write.c
|
||||
base64.c
|
||||
bignum.c
|
||||
bignum_core.c
|
||||
bignum_mod.c
|
||||
bignum_mod_raw.c
|
||||
camellia.c
|
||||
ccm.c
|
||||
chacha20.c
|
||||
|
@ -83,6 +83,9 @@ OBJS_CRYPTO= \
|
||||
asn1write.o \
|
||||
base64.o \
|
||||
bignum.o \
|
||||
bignum_core.o \
|
||||
bignum_mod.o \
|
||||
bignum_mod_raw.o \
|
||||
camellia.o \
|
||||
ccm.o \
|
||||
chacha20.o \
|
||||
|
235
library/bignum.c
235
library/bignum.c
@ -39,6 +39,7 @@
|
||||
|
||||
#include "mbedtls/bignum.h"
|
||||
#include "bignum_internal.h"
|
||||
#include "bignum_core.h"
|
||||
#include "bn_mul.h"
|
||||
#include "mbedtls/platform_util.h"
|
||||
#include "mbedtls/error.h"
|
||||
@ -62,19 +63,8 @@
|
||||
#define MPI_VALIDATE( cond ) \
|
||||
MBEDTLS_INTERNAL_VALIDATE( cond )
|
||||
|
||||
#define ciL (sizeof(mbedtls_mpi_uint)) /* chars in limb */
|
||||
#define biL (ciL << 3) /* bits in limb */
|
||||
#define biH (ciL << 2) /* half limb size */
|
||||
|
||||
#define MPI_SIZE_T_MAX ( (size_t) -1 ) /* SIZE_T_MAX is not standard */
|
||||
|
||||
/*
|
||||
* Convert between bits/chars and number of limbs
|
||||
* Divide first in order to avoid potential overflows
|
||||
*/
|
||||
#define BITS_TO_LIMBS(i) ( (i) / biL + ( (i) % biL != 0 ) )
|
||||
#define CHARS_TO_LIMBS(i) ( (i) / ciL + ( (i) % ciL != 0 ) )
|
||||
|
||||
/* Implementation that should never be optimized out by the compiler */
|
||||
static void mbedtls_mpi_zeroize( mbedtls_mpi_uint *v, size_t n )
|
||||
{
|
||||
@ -303,10 +293,6 @@ int mbedtls_mpi_get_bit( const mbedtls_mpi *X, size_t pos )
|
||||
return( ( X->p[pos / biL] >> ( pos % biL ) ) & 0x01 );
|
||||
}
|
||||
|
||||
/* Get a specific byte, without range checks. */
|
||||
#define GET_BYTE( X, i ) \
|
||||
( ( ( X )->p[( i ) / ciL] >> ( ( ( i ) % ciL ) * 8 ) ) & 0xff )
|
||||
|
||||
/*
|
||||
* Set a bit to a specific value of 0 or 1
|
||||
*/
|
||||
@ -352,41 +338,12 @@ size_t mbedtls_mpi_lsb( const mbedtls_mpi *X )
|
||||
return( 0 );
|
||||
}
|
||||
|
||||
/*
|
||||
* Count leading zero bits in a given integer
|
||||
*/
|
||||
static size_t mbedtls_clz( const mbedtls_mpi_uint x )
|
||||
{
|
||||
size_t j;
|
||||
mbedtls_mpi_uint mask = (mbedtls_mpi_uint) 1 << (biL - 1);
|
||||
|
||||
for( j = 0; j < biL; j++ )
|
||||
{
|
||||
if( x & mask ) break;
|
||||
|
||||
mask >>= 1;
|
||||
}
|
||||
|
||||
return j;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return the number of bits
|
||||
*/
|
||||
size_t mbedtls_mpi_bitlen( const mbedtls_mpi *X )
|
||||
{
|
||||
size_t i, j;
|
||||
|
||||
if( X->n == 0 )
|
||||
return( 0 );
|
||||
|
||||
for( i = X->n - 1; i > 0; i-- )
|
||||
if( X->p[i] != 0 )
|
||||
break;
|
||||
|
||||
j = biL - mbedtls_clz( X->p[i] );
|
||||
|
||||
return( ( i * biL ) + j );
|
||||
return( mbedtls_mpi_core_bitlen( X->p, X->n ) );
|
||||
}
|
||||
|
||||
/*
|
||||
@ -693,97 +650,6 @@ cleanup:
|
||||
}
|
||||
#endif /* MBEDTLS_FS_IO */
|
||||
|
||||
|
||||
/* Convert a big-endian byte array aligned to the size of mbedtls_mpi_uint
|
||||
* into the storage form used by mbedtls_mpi. */
|
||||
|
||||
static mbedtls_mpi_uint mpi_uint_bigendian_to_host_c( mbedtls_mpi_uint x )
|
||||
{
|
||||
uint8_t i;
|
||||
unsigned char *x_ptr;
|
||||
mbedtls_mpi_uint tmp = 0;
|
||||
|
||||
for( i = 0, x_ptr = (unsigned char*) &x; i < ciL; i++, x_ptr++ )
|
||||
{
|
||||
tmp <<= CHAR_BIT;
|
||||
tmp |= (mbedtls_mpi_uint) *x_ptr;
|
||||
}
|
||||
|
||||
return( tmp );
|
||||
}
|
||||
|
||||
static mbedtls_mpi_uint mpi_uint_bigendian_to_host( mbedtls_mpi_uint x )
|
||||
{
|
||||
#if defined(__BYTE_ORDER__)
|
||||
|
||||
/* Nothing to do on bigendian systems. */
|
||||
#if ( __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ )
|
||||
return( x );
|
||||
#endif /* __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ */
|
||||
|
||||
#if ( __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ )
|
||||
|
||||
/* For GCC and Clang, have builtins for byte swapping. */
|
||||
#if defined(__GNUC__) && defined(__GNUC_PREREQ)
|
||||
#if __GNUC_PREREQ(4,3)
|
||||
#define have_bswap
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(__clang__) && defined(__has_builtin)
|
||||
#if __has_builtin(__builtin_bswap32) && \
|
||||
__has_builtin(__builtin_bswap64)
|
||||
#define have_bswap
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(have_bswap)
|
||||
/* The compiler is hopefully able to statically evaluate this! */
|
||||
switch( sizeof(mbedtls_mpi_uint) )
|
||||
{
|
||||
case 4:
|
||||
return( __builtin_bswap32(x) );
|
||||
case 8:
|
||||
return( __builtin_bswap64(x) );
|
||||
}
|
||||
#endif
|
||||
#endif /* __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ */
|
||||
#endif /* __BYTE_ORDER__ */
|
||||
|
||||
/* Fall back to C-based reordering if we don't know the byte order
|
||||
* or we couldn't use a compiler-specific builtin. */
|
||||
return( mpi_uint_bigendian_to_host_c( x ) );
|
||||
}
|
||||
|
||||
static void mpi_bigendian_to_host( mbedtls_mpi_uint * const p, size_t limbs )
|
||||
{
|
||||
mbedtls_mpi_uint *cur_limb_left;
|
||||
mbedtls_mpi_uint *cur_limb_right;
|
||||
if( limbs == 0 )
|
||||
return;
|
||||
|
||||
/*
|
||||
* Traverse limbs and
|
||||
* - adapt byte-order in each limb
|
||||
* - swap the limbs themselves.
|
||||
* For that, simultaneously traverse the limbs from left to right
|
||||
* and from right to left, as long as the left index is not bigger
|
||||
* than the right index (it's not a problem if limbs is odd and the
|
||||
* indices coincide in the last iteration).
|
||||
*/
|
||||
for( cur_limb_left = p, cur_limb_right = p + ( limbs - 1 );
|
||||
cur_limb_left <= cur_limb_right;
|
||||
cur_limb_left++, cur_limb_right-- )
|
||||
{
|
||||
mbedtls_mpi_uint tmp;
|
||||
/* Note that if cur_limb_left == cur_limb_right,
|
||||
* this code effectively swaps the bytes only once. */
|
||||
tmp = mpi_uint_bigendian_to_host( *cur_limb_left );
|
||||
*cur_limb_left = mpi_uint_bigendian_to_host( *cur_limb_right );
|
||||
*cur_limb_right = tmp;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Import X from unsigned binary data, little endian
|
||||
*
|
||||
@ -794,14 +660,12 @@ int mbedtls_mpi_read_binary_le( mbedtls_mpi *X,
|
||||
const unsigned char *buf, size_t buflen )
|
||||
{
|
||||
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
|
||||
size_t i;
|
||||
size_t const limbs = CHARS_TO_LIMBS( buflen );
|
||||
const size_t limbs = CHARS_TO_LIMBS( buflen );
|
||||
|
||||
/* Ensure that target MPI has exactly the necessary number of limbs */
|
||||
MBEDTLS_MPI_CHK( mbedtls_mpi_resize_clear( X, limbs ) );
|
||||
|
||||
for( i = 0; i < buflen; i++ )
|
||||
X->p[i / ciL] |= ((mbedtls_mpi_uint) buf[i]) << ((i % ciL) << 3);
|
||||
MBEDTLS_MPI_CHK( mbedtls_mpi_core_read_le( X->p, X->n, buf, buflen ) );
|
||||
|
||||
cleanup:
|
||||
|
||||
@ -822,9 +686,7 @@ cleanup:
|
||||
int mbedtls_mpi_read_binary( mbedtls_mpi *X, const unsigned char *buf, size_t buflen )
|
||||
{
|
||||
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
|
||||
size_t const limbs = CHARS_TO_LIMBS( buflen );
|
||||
size_t const overhead = ( limbs * ciL ) - buflen;
|
||||
unsigned char *Xp;
|
||||
const size_t limbs = CHARS_TO_LIMBS( buflen );
|
||||
|
||||
MPI_VALIDATE_RET( X != NULL );
|
||||
MPI_VALIDATE_RET( buflen == 0 || buf != NULL );
|
||||
@ -832,15 +694,7 @@ int mbedtls_mpi_read_binary( mbedtls_mpi *X, const unsigned char *buf, size_t bu
|
||||
/* Ensure that target MPI has exactly the necessary number of limbs */
|
||||
MBEDTLS_MPI_CHK( mbedtls_mpi_resize_clear( X, limbs ) );
|
||||
|
||||
/* Avoid calling `memcpy` with NULL source or destination argument,
|
||||
* even if buflen is 0. */
|
||||
if( buflen != 0 )
|
||||
{
|
||||
Xp = (unsigned char*) X->p;
|
||||
memcpy( Xp + overhead, buf, buflen );
|
||||
|
||||
mpi_bigendian_to_host( X->p, limbs );
|
||||
}
|
||||
MBEDTLS_MPI_CHK( mbedtls_mpi_core_read_be( X->p, X->n, buf, buflen ) );
|
||||
|
||||
cleanup:
|
||||
|
||||
@ -858,37 +712,7 @@ cleanup:
|
||||
int mbedtls_mpi_write_binary_le( const mbedtls_mpi *X,
|
||||
unsigned char *buf, size_t buflen )
|
||||
{
|
||||
size_t stored_bytes = X->n * ciL;
|
||||
size_t bytes_to_copy;
|
||||
size_t i;
|
||||
|
||||
if( stored_bytes < buflen )
|
||||
{
|
||||
bytes_to_copy = stored_bytes;
|
||||
}
|
||||
else
|
||||
{
|
||||
bytes_to_copy = buflen;
|
||||
|
||||
/* The output buffer is smaller than the allocated size of X.
|
||||
* However X may fit if its leading bytes are zero. */
|
||||
for( i = bytes_to_copy; i < stored_bytes; i++ )
|
||||
{
|
||||
if( GET_BYTE( X, i ) != 0 )
|
||||
return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
|
||||
}
|
||||
}
|
||||
|
||||
for( i = 0; i < bytes_to_copy; i++ )
|
||||
buf[i] = GET_BYTE( X, i );
|
||||
|
||||
if( stored_bytes < buflen )
|
||||
{
|
||||
/* Write trailing 0 bytes */
|
||||
memset( buf + stored_bytes, 0, buflen - stored_bytes );
|
||||
}
|
||||
|
||||
return( 0 );
|
||||
return( mbedtls_mpi_core_write_le( X->p, X->n, buf, buflen ) );
|
||||
}
|
||||
|
||||
/*
|
||||
@ -897,44 +721,7 @@ int mbedtls_mpi_write_binary_le( const mbedtls_mpi *X,
|
||||
int mbedtls_mpi_write_binary( const mbedtls_mpi *X,
|
||||
unsigned char *buf, size_t buflen )
|
||||
{
|
||||
size_t stored_bytes;
|
||||
size_t bytes_to_copy;
|
||||
unsigned char *p;
|
||||
size_t i;
|
||||
|
||||
MPI_VALIDATE_RET( X != NULL );
|
||||
MPI_VALIDATE_RET( buflen == 0 || buf != NULL );
|
||||
|
||||
stored_bytes = X->n * ciL;
|
||||
|
||||
if( stored_bytes < buflen )
|
||||
{
|
||||
/* There is enough space in the output buffer. Write initial
|
||||
* null bytes and record the position at which to start
|
||||
* writing the significant bytes. In this case, the execution
|
||||
* trace of this function does not depend on the value of the
|
||||
* number. */
|
||||
bytes_to_copy = stored_bytes;
|
||||
p = buf + buflen - stored_bytes;
|
||||
memset( buf, 0, buflen - stored_bytes );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* The output buffer is smaller than the allocated size of X.
|
||||
* However X may fit if its leading bytes are zero. */
|
||||
bytes_to_copy = buflen;
|
||||
p = buf;
|
||||
for( i = bytes_to_copy; i < stored_bytes; i++ )
|
||||
{
|
||||
if( GET_BYTE( X, i ) != 0 )
|
||||
return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
|
||||
}
|
||||
}
|
||||
|
||||
for( i = 0; i < bytes_to_copy; i++ )
|
||||
p[bytes_to_copy - i - 1] = GET_BYTE( X, i );
|
||||
|
||||
return( 0 );
|
||||
return( mbedtls_mpi_core_write_be( X->p, X->n, buf, buflen ) );
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1545,7 +1332,7 @@ static mbedtls_mpi_uint mbedtls_int_div_int( mbedtls_mpi_uint u1,
|
||||
/*
|
||||
* Normalize the divisor, d, and dividend, u0, u1
|
||||
*/
|
||||
s = mbedtls_clz( d );
|
||||
s = mbedtls_mpi_core_clz( d );
|
||||
d = d << s;
|
||||
|
||||
u1 = u1 << s;
|
||||
@ -2334,7 +2121,7 @@ static int mpi_fill_random_internal(
|
||||
memset( X->p, 0, overhead );
|
||||
memset( (unsigned char *) X->p + limbs * ciL, 0, ( X->n - limbs ) * ciL );
|
||||
MBEDTLS_MPI_CHK( f_rng( p_rng, (unsigned char *) X->p + overhead, n_bytes ) );
|
||||
mpi_bigendian_to_host( X->p, limbs );
|
||||
mbedtls_mpi_core_bigendian_to_host( X->p, limbs );
|
||||
|
||||
cleanup:
|
||||
return( ret );
|
||||
@ -2352,7 +2139,7 @@ int mbedtls_mpi_fill_random( mbedtls_mpi *X, size_t size,
|
||||
void *p_rng )
|
||||
{
|
||||
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
|
||||
size_t const limbs = CHARS_TO_LIMBS( size );
|
||||
const size_t limbs = CHARS_TO_LIMBS( size );
|
||||
|
||||
MPI_VALIDATE_RET( X != NULL );
|
||||
MPI_VALIDATE_RET( f_rng != NULL );
|
||||
|
294
library/bignum_core.c
Normal file
294
library/bignum_core.c
Normal file
@ -0,0 +1,294 @@
|
||||
/*
|
||||
* Core bignum functions
|
||||
*
|
||||
* Copyright The Mbed TLS Contributors
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include "common.h"
|
||||
|
||||
#if defined(MBEDTLS_BIGNUM_C)
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include "mbedtls/error.h"
|
||||
#include "mbedtls/platform_util.h"
|
||||
|
||||
#if defined(MBEDTLS_PLATFORM_C)
|
||||
#include "mbedtls/platform.h"
|
||||
#else
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#define mbedtls_printf printf
|
||||
#define mbedtls_calloc calloc
|
||||
#define mbedtls_free free
|
||||
#endif
|
||||
|
||||
#include "bignum_core.h"
|
||||
|
||||
size_t mbedtls_mpi_core_clz( mbedtls_mpi_uint a )
|
||||
{
|
||||
size_t j;
|
||||
mbedtls_mpi_uint mask = (mbedtls_mpi_uint) 1 << (biL - 1);
|
||||
|
||||
for( j = 0; j < biL; j++ )
|
||||
{
|
||||
if( a & mask ) break;
|
||||
|
||||
mask >>= 1;
|
||||
}
|
||||
|
||||
return( j );
|
||||
}
|
||||
|
||||
size_t mbedtls_mpi_core_bitlen( const mbedtls_mpi_uint *A, size_t A_limbs )
|
||||
{
|
||||
size_t i, j;
|
||||
|
||||
if( A_limbs == 0 )
|
||||
return( 0 );
|
||||
|
||||
for( i = A_limbs - 1; i > 0; i-- )
|
||||
if( A[i] != 0 )
|
||||
break;
|
||||
|
||||
j = biL - mbedtls_mpi_core_clz( A[i] );
|
||||
|
||||
return( ( i * biL ) + j );
|
||||
}
|
||||
|
||||
/* Convert a big-endian byte array aligned to the size of mbedtls_mpi_uint
|
||||
* into the storage form used by mbedtls_mpi. */
|
||||
static mbedtls_mpi_uint mpi_bigendian_to_host_c( mbedtls_mpi_uint a )
|
||||
{
|
||||
uint8_t i;
|
||||
unsigned char *a_ptr;
|
||||
mbedtls_mpi_uint tmp = 0;
|
||||
|
||||
for( i = 0, a_ptr = (unsigned char *) &a; i < ciL; i++, a_ptr++ )
|
||||
{
|
||||
tmp <<= CHAR_BIT;
|
||||
tmp |= (mbedtls_mpi_uint) *a_ptr;
|
||||
}
|
||||
|
||||
return( tmp );
|
||||
}
|
||||
|
||||
static mbedtls_mpi_uint mpi_bigendian_to_host( mbedtls_mpi_uint a )
|
||||
{
|
||||
#if defined(__BYTE_ORDER__)
|
||||
|
||||
/* Nothing to do on bigendian systems. */
|
||||
#if ( __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ )
|
||||
return( a );
|
||||
#endif /* __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ */
|
||||
|
||||
#if ( __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ )
|
||||
|
||||
/* For GCC and Clang, have builtins for byte swapping. */
|
||||
#if defined(__GNUC__) && defined(__GNUC_PREREQ)
|
||||
#if __GNUC_PREREQ(4,3)
|
||||
#define have_bswap
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(__clang__) && defined(__has_builtin)
|
||||
#if __has_builtin(__builtin_bswap32) && \
|
||||
__has_builtin(__builtin_bswap64)
|
||||
#define have_bswap
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(have_bswap)
|
||||
/* The compiler is hopefully able to statically evaluate this! */
|
||||
switch( sizeof(mbedtls_mpi_uint) )
|
||||
{
|
||||
case 4:
|
||||
return( __builtin_bswap32(a) );
|
||||
case 8:
|
||||
return( __builtin_bswap64(a) );
|
||||
}
|
||||
#endif
|
||||
#endif /* __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ */
|
||||
#endif /* __BYTE_ORDER__ */
|
||||
|
||||
/* Fall back to C-based reordering if we don't know the byte order
|
||||
* or we couldn't use a compiler-specific builtin. */
|
||||
return( mpi_bigendian_to_host_c( a ) );
|
||||
}
|
||||
|
||||
void mbedtls_mpi_core_bigendian_to_host( mbedtls_mpi_uint *A,
|
||||
size_t A_limbs )
|
||||
{
|
||||
mbedtls_mpi_uint *cur_limb_left;
|
||||
mbedtls_mpi_uint *cur_limb_right;
|
||||
if( A_limbs == 0 )
|
||||
return;
|
||||
|
||||
/*
|
||||
* Traverse limbs and
|
||||
* - adapt byte-order in each limb
|
||||
* - swap the limbs themselves.
|
||||
* For that, simultaneously traverse the limbs from left to right
|
||||
* and from right to left, as long as the left index is not bigger
|
||||
* than the right index (it's not a problem if limbs is odd and the
|
||||
* indices coincide in the last iteration).
|
||||
*/
|
||||
for( cur_limb_left = A, cur_limb_right = A + ( A_limbs - 1 );
|
||||
cur_limb_left <= cur_limb_right;
|
||||
cur_limb_left++, cur_limb_right-- )
|
||||
{
|
||||
mbedtls_mpi_uint tmp;
|
||||
/* Note that if cur_limb_left == cur_limb_right,
|
||||
* this code effectively swaps the bytes only once. */
|
||||
tmp = mpi_bigendian_to_host( *cur_limb_left );
|
||||
*cur_limb_left = mpi_bigendian_to_host( *cur_limb_right );
|
||||
*cur_limb_right = tmp;
|
||||
}
|
||||
}
|
||||
|
||||
int mbedtls_mpi_core_read_le( mbedtls_mpi_uint *X,
|
||||
size_t X_limbs,
|
||||
const unsigned char *input,
|
||||
size_t input_length )
|
||||
{
|
||||
const size_t limbs = CHARS_TO_LIMBS( input_length );
|
||||
|
||||
if( X_limbs < limbs )
|
||||
return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
|
||||
|
||||
if( X != NULL )
|
||||
{
|
||||
memset( X, 0, X_limbs * ciL );
|
||||
|
||||
for( size_t i = 0; i < input_length; i++ )
|
||||
{
|
||||
size_t offset = ( ( i % ciL ) << 3 );
|
||||
X[i / ciL] |= ( (mbedtls_mpi_uint) input[i] ) << offset;
|
||||
}
|
||||
}
|
||||
|
||||
return( 0 );
|
||||
}
|
||||
|
||||
int mbedtls_mpi_core_read_be( mbedtls_mpi_uint *X,
|
||||
size_t X_limbs,
|
||||
const unsigned char *input,
|
||||
size_t input_length )
|
||||
{
|
||||
const size_t limbs = CHARS_TO_LIMBS( input_length );
|
||||
|
||||
if( X_limbs < limbs )
|
||||
return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
|
||||
|
||||
/* If X_limbs is 0, input_length must also be 0 (from previous test).
|
||||
* Nothing to do. */
|
||||
if( X_limbs == 0 )
|
||||
return( 0 );
|
||||
|
||||
memset( X, 0, X_limbs * ciL );
|
||||
|
||||
/* memcpy() with (NULL, 0) is undefined behaviour */
|
||||
if( input_length != 0 )
|
||||
{
|
||||
size_t overhead = ( X_limbs * ciL ) - input_length;
|
||||
unsigned char *Xp = (unsigned char *) X;
|
||||
memcpy( Xp + overhead, input, input_length );
|
||||
}
|
||||
|
||||
mbedtls_mpi_core_bigendian_to_host( X, X_limbs );
|
||||
|
||||
return( 0 );
|
||||
}
|
||||
|
||||
int mbedtls_mpi_core_write_le( const mbedtls_mpi_uint *A,
|
||||
size_t A_limbs,
|
||||
unsigned char *output,
|
||||
size_t output_length )
|
||||
{
|
||||
size_t stored_bytes = A_limbs * ciL;
|
||||
size_t bytes_to_copy;
|
||||
|
||||
if( stored_bytes < output_length )
|
||||
{
|
||||
bytes_to_copy = stored_bytes;
|
||||
}
|
||||
else
|
||||
{
|
||||
bytes_to_copy = output_length;
|
||||
|
||||
/* The output buffer is smaller than the allocated size of A.
|
||||
* However A may fit if its leading bytes are zero. */
|
||||
for( size_t i = bytes_to_copy; i < stored_bytes; i++ )
|
||||
{
|
||||
if( GET_BYTE( A, i ) != 0 )
|
||||
return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
|
||||
}
|
||||
}
|
||||
|
||||
for( size_t i = 0; i < bytes_to_copy; i++ )
|
||||
output[i] = GET_BYTE( A, i );
|
||||
|
||||
if( stored_bytes < output_length )
|
||||
{
|
||||
/* Write trailing 0 bytes */
|
||||
memset( output + stored_bytes, 0, output_length - stored_bytes );
|
||||
}
|
||||
|
||||
return( 0 );
|
||||
}
|
||||
|
||||
int mbedtls_mpi_core_write_be( const mbedtls_mpi_uint *X,
|
||||
size_t X_limbs,
|
||||
unsigned char *output,
|
||||
size_t output_length )
|
||||
{
|
||||
size_t stored_bytes;
|
||||
size_t bytes_to_copy;
|
||||
unsigned char *p;
|
||||
|
||||
stored_bytes = X_limbs * ciL;
|
||||
|
||||
if( stored_bytes < output_length )
|
||||
{
|
||||
/* There is enough space in the output buffer. Write initial
|
||||
* null bytes and record the position at which to start
|
||||
* writing the significant bytes. In this case, the execution
|
||||
* trace of this function does not depend on the value of the
|
||||
* number. */
|
||||
bytes_to_copy = stored_bytes;
|
||||
p = output + output_length - stored_bytes;
|
||||
memset( output, 0, output_length - stored_bytes );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* The output buffer is smaller than the allocated size of X.
|
||||
* However X may fit if its leading bytes are zero. */
|
||||
bytes_to_copy = output_length;
|
||||
p = output;
|
||||
for( size_t i = bytes_to_copy; i < stored_bytes; i++ )
|
||||
{
|
||||
if( GET_BYTE( X, i ) != 0 )
|
||||
return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
|
||||
}
|
||||
}
|
||||
|
||||
for( size_t i = 0; i < bytes_to_copy; i++ )
|
||||
p[bytes_to_copy - i - 1] = GET_BYTE( X, i );
|
||||
|
||||
return( 0 );
|
||||
}
|
||||
|
||||
#endif /* MBEDTLS_BIGNUM_C */
|
158
library/bignum_core.h
Normal file
158
library/bignum_core.h
Normal file
@ -0,0 +1,158 @@
|
||||
/**
|
||||
* Core bignum functions
|
||||
*
|
||||
* This interface should only be used by the legacy bignum module (bignum.h)
|
||||
* and the modular bignum modules (bignum_mod.c, bignum_mod_raw.c). All other
|
||||
* modules should use the high-level modular bignum interface (bignum_mod.h)
|
||||
* or the legacy bignum interface (bignum.h).
|
||||
*
|
||||
* Copyright The Mbed TLS Contributors
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef MBEDTLS_BIGNUM_CORE_H
|
||||
#define MBEDTLS_BIGNUM_CORE_H
|
||||
|
||||
#include "common.h"
|
||||
|
||||
#if defined(MBEDTLS_BIGNUM_C)
|
||||
#include "mbedtls/bignum.h"
|
||||
#endif
|
||||
|
||||
/** Count leading zero bits in a given integer.
|
||||
*
|
||||
* \param a Integer to count leading zero bits.
|
||||
*
|
||||
* \return The number of leading zero bits in \p a.
|
||||
*/
|
||||
size_t mbedtls_mpi_core_clz( mbedtls_mpi_uint a );
|
||||
|
||||
/** Return the minimum number of bits required to represent the value held
|
||||
* in the MPI.
|
||||
*
|
||||
* \note This function returns 0 if all the limbs of \p A are 0.
|
||||
*
|
||||
* \param[in] A The address of the MPI.
|
||||
* \param A_limbs The number of limbs of \p A.
|
||||
*
|
||||
* \return The number of bits in \p A.
|
||||
*/
|
||||
size_t mbedtls_mpi_core_bitlen( const mbedtls_mpi_uint *A, size_t A_limbs );
|
||||
|
||||
/** Convert a big-endian byte array aligned to the size of mbedtls_mpi_uint
|
||||
* into the storage form used by mbedtls_mpi.
|
||||
*
|
||||
* \param[in,out] A The address of the MPI.
|
||||
* \param A_limbs The number of limbs of \p A.
|
||||
*/
|
||||
void mbedtls_mpi_core_bigendian_to_host( mbedtls_mpi_uint *A,
|
||||
size_t A_limbs );
|
||||
|
||||
/** Import X from unsigned binary data, little-endian.
|
||||
*
|
||||
* The MPI needs to have enough limbs to store the full value (including any
|
||||
* most significant zero bytes in the input).
|
||||
*
|
||||
* \param[out] X The address of the MPI.
|
||||
* \param X_limbs The number of limbs of \p X.
|
||||
* \param[in] input The input buffer to import from.
|
||||
* \param input_length The length bytes of \p input.
|
||||
*
|
||||
* \return \c 0 if successful.
|
||||
* \return #MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL if \p X isn't
|
||||
* large enough to hold the value in \p input.
|
||||
*/
|
||||
int mbedtls_mpi_core_read_le( mbedtls_mpi_uint *X,
|
||||
size_t X_limbs,
|
||||
const unsigned char *input,
|
||||
size_t input_length );
|
||||
|
||||
/** Import X from unsigned binary data, big-endian.
|
||||
*
|
||||
* The MPI needs to have enough limbs to store the full value (including any
|
||||
* most significant zero bytes in the input).
|
||||
*
|
||||
* \param[out] X The address of the MPI.
|
||||
* May only be #NULL if \X_limbs is 0 and \p input_length
|
||||
* is 0.
|
||||
* \param X_limbs The number of limbs of \p X.
|
||||
* \param[in] input The input buffer to import from.
|
||||
* May only be #NULL if \p input_length is 0.
|
||||
* \param input_length The length in bytes of \p input.
|
||||
*
|
||||
* \return \c 0 if successful.
|
||||
* \return #MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL if \p X isn't
|
||||
* large enough to hold the value in \p input.
|
||||
*/
|
||||
int mbedtls_mpi_core_read_be( mbedtls_mpi_uint *X,
|
||||
size_t X_limbs,
|
||||
const unsigned char *input,
|
||||
size_t input_length );
|
||||
|
||||
/** Export A into unsigned binary data, little-endian.
|
||||
*
|
||||
* \note If \p output is shorter than \p A the export is still successful if the
|
||||
* value held in \p A fits in the buffer (that is, if enough of the most
|
||||
* significant bytes of \p A are 0).
|
||||
*
|
||||
* \param[in] A The address of the MPI.
|
||||
* \param A_limbs The number of limbs of \p A.
|
||||
* \param[out] output The output buffer to export to.
|
||||
* \param output_length The length in bytes of \p output.
|
||||
*
|
||||
* \return \c 0 if successful.
|
||||
* \return #MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL if \p output isn't
|
||||
* large enough to hold the value of \p A.
|
||||
*/
|
||||
int mbedtls_mpi_core_write_le( const mbedtls_mpi_uint *A,
|
||||
size_t A_limbs,
|
||||
unsigned char *output,
|
||||
size_t output_length );
|
||||
|
||||
/** Export A into unsigned binary data, big-endian.
|
||||
*
|
||||
* \note If \p output is shorter than \p A the export is still successful if the
|
||||
* value held in \p A fits in the buffer (that is, if enough of the most
|
||||
* significant bytes of \p A are 0).
|
||||
*
|
||||
* \param[in] A The address of the MPI.
|
||||
* \param A_limbs The number of limbs of \p A.
|
||||
* \param[out] output The output buffer to export to.
|
||||
* \param output_length The length in bytes of \p output.
|
||||
*
|
||||
* \return \c 0 if successful.
|
||||
* \return #MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL if \p output isn't
|
||||
* large enough to hold the value of \p A.
|
||||
*/
|
||||
int mbedtls_mpi_core_write_be( const mbedtls_mpi_uint *A,
|
||||
size_t A_limbs,
|
||||
unsigned char *output,
|
||||
size_t output_length );
|
||||
|
||||
#define ciL ( sizeof(mbedtls_mpi_uint) ) /* chars in limb */
|
||||
#define biL ( ciL << 3 ) /* bits in limb */
|
||||
#define biH ( ciL << 2 ) /* half limb size */
|
||||
|
||||
/*
|
||||
* Convert between bits/chars and number of limbs
|
||||
* Divide first in order to avoid potential overflows
|
||||
*/
|
||||
#define BITS_TO_LIMBS(i) ( (i) / biL + ( (i) % biL != 0 ) )
|
||||
#define CHARS_TO_LIMBS(i) ( (i) / ciL + ( (i) % ciL != 0 ) )
|
||||
/* Get a specific byte, without range checks. */
|
||||
#define GET_BYTE( X, i ) \
|
||||
( ( (X)[(i) / ciL] >> ( ( (i) % ciL ) * 8 ) ) & 0xff )
|
||||
|
||||
#endif /* MBEDTLS_BIGNUM_CORE_H */
|
152
library/bignum_mod.c
Normal file
152
library/bignum_mod.c
Normal file
@ -0,0 +1,152 @@
|
||||
/**
|
||||
* Modular bignum functions
|
||||
*
|
||||
* Copyright The Mbed TLS Contributors
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include "common.h"
|
||||
|
||||
#if defined(MBEDTLS_BIGNUM_C)
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include "mbedtls/platform_util.h"
|
||||
#include "mbedtls/error.h"
|
||||
#include "mbedtls/bignum.h"
|
||||
|
||||
#if defined(MBEDTLS_PLATFORM_C)
|
||||
#include "mbedtls/platform.h"
|
||||
#else
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#define mbedtls_printf printf
|
||||
#define mbedtls_calloc calloc
|
||||
#define mbedtls_free free
|
||||
#endif
|
||||
|
||||
#include "bignum_core.h"
|
||||
#include "bignum_mod.h"
|
||||
#include "bignum_mod_raw.h"
|
||||
#include "constant_time_internal.h"
|
||||
|
||||
int mbedtls_mpi_mod_residue_setup( mbedtls_mpi_mod_residue *r,
|
||||
const mbedtls_mpi_mod_modulus *m,
|
||||
mbedtls_mpi_uint *p,
|
||||
size_t p_limbs )
|
||||
{
|
||||
if( p_limbs < m->limbs || !mbedtls_mpi_core_lt_ct( m->p, p, p_limbs ) )
|
||||
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
|
||||
|
||||
r->limbs = m->limbs;
|
||||
r->p = p;
|
||||
|
||||
return( 0 );
|
||||
}
|
||||
|
||||
void mbedtls_mpi_mod_residue_release( mbedtls_mpi_mod_residue *r )
|
||||
{
|
||||
if ( r == NULL )
|
||||
return;
|
||||
|
||||
r->limbs = 0;
|
||||
r->p = NULL;
|
||||
}
|
||||
|
||||
void mbedtls_mpi_mod_modulus_init( mbedtls_mpi_mod_modulus *m )
|
||||
{
|
||||
if ( m == NULL )
|
||||
return;
|
||||
|
||||
m->p = NULL;
|
||||
m->limbs = 0;
|
||||
m->bits = 0;
|
||||
m->ext_rep = MBEDTLS_MPI_MOD_EXT_REP_INVALID;
|
||||
m->int_rep = MBEDTLS_MPI_MOD_REP_INVALID;
|
||||
}
|
||||
|
||||
void mbedtls_mpi_mod_modulus_free( mbedtls_mpi_mod_modulus *m )
|
||||
{
|
||||
if ( m == NULL )
|
||||
return;
|
||||
|
||||
switch( m->int_rep )
|
||||
{
|
||||
case MBEDTLS_MPI_MOD_REP_MONTGOMERY:
|
||||
mbedtls_free( m->rep.mont );
|
||||
break;
|
||||
case MBEDTLS_MPI_MOD_REP_OPT_RED:
|
||||
mbedtls_free( m->rep.ored );
|
||||
break;
|
||||
case MBEDTLS_MPI_MOD_REP_INVALID:
|
||||
break;
|
||||
}
|
||||
|
||||
m->p = NULL;
|
||||
m->limbs = 0;
|
||||
m->bits = 0;
|
||||
m->ext_rep = MBEDTLS_MPI_MOD_EXT_REP_INVALID;
|
||||
m->int_rep = MBEDTLS_MPI_MOD_REP_INVALID;
|
||||
}
|
||||
|
||||
int mbedtls_mpi_mod_modulus_setup( mbedtls_mpi_mod_modulus *m,
|
||||
const mbedtls_mpi_uint *p,
|
||||
size_t p_limbs,
|
||||
mbedtls_mpi_mod_ext_rep ext_rep,
|
||||
mbedtls_mpi_mod_rep_selector int_rep )
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
m->p = p;
|
||||
m->limbs = p_limbs;
|
||||
m->bits = mbedtls_mpi_core_bitlen( p, p_limbs );
|
||||
|
||||
switch( ext_rep )
|
||||
{
|
||||
case MBEDTLS_MPI_MOD_EXT_REP_LE:
|
||||
case MBEDTLS_MPI_MOD_EXT_REP_BE:
|
||||
m->ext_rep = ext_rep;
|
||||
break;
|
||||
default:
|
||||
ret = MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
switch( int_rep )
|
||||
{
|
||||
case MBEDTLS_MPI_MOD_REP_MONTGOMERY:
|
||||
m->int_rep = int_rep;
|
||||
m->rep.mont = NULL;
|
||||
break;
|
||||
case MBEDTLS_MPI_MOD_REP_OPT_RED:
|
||||
m->int_rep = int_rep;
|
||||
m->rep.ored = NULL;
|
||||
break;
|
||||
default:
|
||||
ret = MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
exit:
|
||||
|
||||
if( ret != 0 )
|
||||
{
|
||||
mbedtls_mpi_mod_modulus_free( m );
|
||||
}
|
||||
|
||||
return( ret );
|
||||
}
|
||||
|
||||
#endif /* MBEDTLS_BIGNUM_C */
|
143
library/bignum_mod.h
Normal file
143
library/bignum_mod.h
Normal file
@ -0,0 +1,143 @@
|
||||
/**
|
||||
* Modular bignum functions
|
||||
*
|
||||
* Copyright The Mbed TLS Contributors
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef MBEDTLS_BIGNUM_MOD_H
|
||||
#define MBEDTLS_BIGNUM_MOD_H
|
||||
|
||||
#include "common.h"
|
||||
|
||||
#if defined(MBEDTLS_BIGNUM_C)
|
||||
#include "mbedtls/bignum.h"
|
||||
#endif
|
||||
|
||||
/* Skip 1 as it is slightly easier to accidentally pass to functions. */
|
||||
typedef enum
|
||||
{
|
||||
MBEDTLS_MPI_MOD_REP_INVALID = 0,
|
||||
MBEDTLS_MPI_MOD_REP_MONTGOMERY = 2,
|
||||
MBEDTLS_MPI_MOD_REP_OPT_RED
|
||||
} mbedtls_mpi_mod_rep_selector;
|
||||
|
||||
/* Make mbedtls_mpi_mod_rep_selector and mbedtls_mpi_mod_ext_rep disjoint to
|
||||
* make it easier to catch when they are accidentally swapped. */
|
||||
typedef enum
|
||||
{
|
||||
MBEDTLS_MPI_MOD_EXT_REP_INVALID = 0,
|
||||
MBEDTLS_MPI_MOD_EXT_REP_LE = 8,
|
||||
MBEDTLS_MPI_MOD_EXT_REP_BE
|
||||
} mbedtls_mpi_mod_ext_rep;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
mbedtls_mpi_uint *p;
|
||||
size_t limbs;
|
||||
} mbedtls_mpi_mod_residue;
|
||||
|
||||
typedef void *mbedtls_mpi_mont_struct;
|
||||
typedef void *mbedtls_mpi_opt_red_struct;
|
||||
|
||||
typedef struct {
|
||||
const mbedtls_mpi_uint *p;
|
||||
size_t limbs; // number of limbs
|
||||
size_t bits; // bitlen of p
|
||||
mbedtls_mpi_mod_ext_rep ext_rep; // signals external representation (eg. byte order)
|
||||
mbedtls_mpi_mod_rep_selector int_rep; // selector to signal the active member of the union
|
||||
union rep
|
||||
{
|
||||
mbedtls_mpi_mont_struct mont;
|
||||
mbedtls_mpi_opt_red_struct ored;
|
||||
} rep;
|
||||
} mbedtls_mpi_mod_modulus;
|
||||
|
||||
/** Setup a residue structure.
|
||||
*
|
||||
* \param[out] r The address of residue to setup. The size is determined by
|
||||
* \p m.
|
||||
* (In particular, it must have at least as many limbs as the
|
||||
* modulus \p m.)
|
||||
* \param[in] m The address of the modulus related to \p r.
|
||||
* \param[in] p The address of the limb array storing the value of \p r.
|
||||
* The memory pointed to by \p p will be used by \p r and must
|
||||
* not be modified in any way until after
|
||||
* mbedtls_mpi_mod_residue_release() is called.
|
||||
* \param p_limbs The number of limbs of \p p.
|
||||
*
|
||||
* \return \c 0 if successful.
|
||||
* \return #MBEDTLS_ERR_MPI_BAD_INPUT_DATA if \p p_limbs is less than the
|
||||
* limbs in \p m or if \p p is not less than \p m.
|
||||
*/
|
||||
int mbedtls_mpi_mod_residue_setup( mbedtls_mpi_mod_residue *r,
|
||||
const mbedtls_mpi_mod_modulus *m,
|
||||
mbedtls_mpi_uint *p,
|
||||
size_t p_limbs );
|
||||
|
||||
/** Unbind elements of a residue structure.
|
||||
*
|
||||
* This function removes the reference to the limb array that was passed to
|
||||
* mbedtls_mpi_mod_residue_setup() to make it safe to free or use again.
|
||||
*
|
||||
* This function invalidates \p r and it must not be used until after
|
||||
* mbedtls_mpi_mod_residue_setup() is called on it again.
|
||||
*
|
||||
* \param[out] r The address of residue to release.
|
||||
*/
|
||||
void mbedtls_mpi_mod_residue_release( mbedtls_mpi_mod_residue *r );
|
||||
|
||||
/** Initialize a modulus structure.
|
||||
*
|
||||
* \param[out] m The address of the modulus structure to initialize.
|
||||
*/
|
||||
void mbedtls_mpi_mod_modulus_init( mbedtls_mpi_mod_modulus *m );
|
||||
|
||||
/** Setup a modulus structure.
|
||||
*
|
||||
* \param[out] m The address of the modulus structure to populate.
|
||||
* \param[in] p The address of the limb array storing the value of \p m.
|
||||
* The memory pointed to by \p p will be used by \p m and must
|
||||
* not be modified in any way until after
|
||||
* mbedtls_mpi_mod_modulus_free() is called.
|
||||
* \param p_limbs The number of limbs of \p p.
|
||||
* \param ext_rep The external representation to be used for residues
|
||||
* associated with \p m (see #mbedtls_mpi_mod_ext_rep).
|
||||
* \param int_rep The internal representation to be used for residues
|
||||
* associated with \p m (see #mbedtls_mpi_mod_rep_selector).
|
||||
*
|
||||
* \return \c 0 if successful.
|
||||
* \return #MBEDTLS_ERR_MPI_BAD_INPUT_DATA if \p ext_rep or \p int_rep is
|
||||
* invalid.
|
||||
*/
|
||||
int mbedtls_mpi_mod_modulus_setup( mbedtls_mpi_mod_modulus *m,
|
||||
const mbedtls_mpi_uint *p,
|
||||
size_t p_limbs,
|
||||
mbedtls_mpi_mod_ext_rep ext_rep,
|
||||
mbedtls_mpi_mod_rep_selector int_rep );
|
||||
|
||||
/** Free elements of a modulus structure.
|
||||
*
|
||||
* This function frees any memory allocated by mbedtls_mpi_mod_modulus_setup().
|
||||
*
|
||||
* \warning This function does not free the limb array passed to
|
||||
* mbedtls_mpi_mod_modulus_setup() only removes the reference to it,
|
||||
* making it safe to free or to use it again.
|
||||
*
|
||||
* \param[in,out] m The address of the modulus structure to free.
|
||||
*/
|
||||
void mbedtls_mpi_mod_modulus_free( mbedtls_mpi_mod_modulus *m );
|
||||
|
||||
#endif /* MBEDTLS_BIGNUM_MOD_H */
|
97
library/bignum_mod_raw.c
Normal file
97
library/bignum_mod_raw.c
Normal file
@ -0,0 +1,97 @@
|
||||
/*
|
||||
* Low-level modular bignum functions
|
||||
*
|
||||
* Copyright The Mbed TLS Contributors
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include "common.h"
|
||||
|
||||
#if defined(MBEDTLS_BIGNUM_C)
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include "mbedtls/error.h"
|
||||
#include "mbedtls/platform_util.h"
|
||||
|
||||
#if defined(MBEDTLS_PLATFORM_C)
|
||||
#include "mbedtls/platform.h"
|
||||
#else
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#define mbedtls_printf printf
|
||||
#define mbedtls_calloc calloc
|
||||
#define mbedtls_free free
|
||||
#endif
|
||||
|
||||
#include "bignum_core.h"
|
||||
#include "bignum_mod_raw.h"
|
||||
#include "bignum_mod.h"
|
||||
#include "constant_time_internal.h"
|
||||
|
||||
int mbedtls_mpi_mod_raw_read( mbedtls_mpi_uint *X,
|
||||
const mbedtls_mpi_mod_modulus *m,
|
||||
const unsigned char *input,
|
||||
size_t input_length )
|
||||
{
|
||||
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
|
||||
|
||||
switch( m->ext_rep )
|
||||
{
|
||||
case MBEDTLS_MPI_MOD_EXT_REP_LE:
|
||||
ret = mbedtls_mpi_core_read_le( X, m->limbs,
|
||||
input, input_length );
|
||||
break;
|
||||
case MBEDTLS_MPI_MOD_EXT_REP_BE:
|
||||
ret = mbedtls_mpi_core_read_be( X, m->limbs,
|
||||
input, input_length );
|
||||
break;
|
||||
default:
|
||||
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
|
||||
}
|
||||
|
||||
if( ret != 0 )
|
||||
goto cleanup;
|
||||
|
||||
if( !mbedtls_mpi_core_lt_ct( X, m->p, m->limbs ) )
|
||||
{
|
||||
ret = MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
cleanup:
|
||||
|
||||
return( ret );
|
||||
}
|
||||
|
||||
int mbedtls_mpi_mod_raw_write( const mbedtls_mpi_uint *A,
|
||||
const mbedtls_mpi_mod_modulus *m,
|
||||
unsigned char *output,
|
||||
size_t output_length )
|
||||
{
|
||||
switch( m->ext_rep )
|
||||
{
|
||||
case MBEDTLS_MPI_MOD_EXT_REP_LE:
|
||||
return( mbedtls_mpi_core_write_le( A, m->limbs,
|
||||
output, output_length ) );
|
||||
case MBEDTLS_MPI_MOD_EXT_REP_BE:
|
||||
return( mbedtls_mpi_core_write_be( A, m->limbs,
|
||||
output, output_length ) );
|
||||
default:
|
||||
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* MBEDTLS_BIGNUM_C */
|
79
library/bignum_mod_raw.h
Normal file
79
library/bignum_mod_raw.h
Normal file
@ -0,0 +1,79 @@
|
||||
/**
|
||||
* Low-level modular bignum functions
|
||||
*
|
||||
* This interface should only be used by the higher-level modular bignum
|
||||
* module (bignum_mod.c) and the ECP module (ecp.c, ecp_curves.c). All other
|
||||
* modules should use the high-level modular bignum interface (bignum_mod.h)
|
||||
* or the legacy bignum interface (bignum.h).
|
||||
*
|
||||
* Copyright The Mbed TLS Contributors
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef MBEDTLS_BIGNUM_MOD_RAW_H
|
||||
#define MBEDTLS_BIGNUM_MOD_RAW_H
|
||||
|
||||
#include "common.h"
|
||||
|
||||
#if defined(MBEDTLS_BIGNUM_C)
|
||||
#include "mbedtls/bignum.h"
|
||||
#endif
|
||||
|
||||
#include "bignum_mod.h"
|
||||
|
||||
/** Import X from unsigned binary data.
|
||||
*
|
||||
* The MPI needs to have enough limbs to store the full value (including any
|
||||
* most significant zero bytes in the input).
|
||||
*
|
||||
* \param[out] X The address of the MPI. The size is determined by \p m.
|
||||
* (In particular, it must have at least as many limbs as
|
||||
* the modulus \p m.)
|
||||
* \param[in] m The address of the modulus related to \p X.
|
||||
* \param[in] input The input buffer to import from.
|
||||
* \param input_length The length in bytes of \p input.
|
||||
*
|
||||
* \return \c 0 if successful.
|
||||
* \return #MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL if \p X isn't
|
||||
* large enough to hold the value in \p input.
|
||||
* \return #MBEDTLS_ERR_MPI_BAD_INPUT_DATA if the external representation
|
||||
* of \p m is invalid or \p X is not less than \p m.
|
||||
*/
|
||||
int mbedtls_mpi_mod_raw_read( mbedtls_mpi_uint *X,
|
||||
const mbedtls_mpi_mod_modulus *m,
|
||||
const unsigned char *input,
|
||||
size_t input_length );
|
||||
|
||||
/** Export A into unsigned binary data.
|
||||
*
|
||||
* \param[in] A The address of the MPI. The size is determined by \p m.
|
||||
* (In particular, it must have at least as many limbs as
|
||||
* the modulus \p m.)
|
||||
* \param[in] m The address of the modulus related to \p A.
|
||||
* \param[out] output The output buffer to export to.
|
||||
* \param output_length The length in bytes of \p output.
|
||||
*
|
||||
* \return \c 0 if successful.
|
||||
* \return #MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL if \p output isn't
|
||||
* large enough to hold the value of \p A.
|
||||
* \return #MBEDTLS_ERR_MPI_BAD_INPUT_DATA if the external representation
|
||||
* of \p m is invalid.
|
||||
*/
|
||||
int mbedtls_mpi_mod_raw_write( const mbedtls_mpi_uint *A,
|
||||
const mbedtls_mpi_mod_modulus *m,
|
||||
unsigned char *output,
|
||||
size_t output_length );
|
||||
|
||||
#endif /* MBEDTLS_BIGNUM_MOD_RAW_H */
|
@ -741,6 +741,50 @@ cleanup:
|
||||
return( ret );
|
||||
}
|
||||
|
||||
/*
|
||||
* Compare unsigned values in constant time
|
||||
*/
|
||||
unsigned mbedtls_mpi_core_lt_ct( const mbedtls_mpi_uint *A,
|
||||
const mbedtls_mpi_uint *B,
|
||||
size_t limbs )
|
||||
{
|
||||
unsigned ret, cond, done;
|
||||
|
||||
/* The value of any of these variables is either 0 or 1 for the rest of
|
||||
* their scope. */
|
||||
ret = cond = done = 0;
|
||||
|
||||
for( size_t i = limbs; i > 0; i-- )
|
||||
{
|
||||
/*
|
||||
* If B[i - 1] < A[i - 1] then A < B is false and the result must
|
||||
* remain 0.
|
||||
*
|
||||
* Again even if we can make a decision, we just mark the result and
|
||||
* the fact that we are done and continue looping.
|
||||
*/
|
||||
cond = mbedtls_ct_mpi_uint_lt( B[i - 1], A[i - 1] );
|
||||
done |= cond;
|
||||
|
||||
/*
|
||||
* If A[i - 1] < B[i - 1] then A < B is true.
|
||||
*
|
||||
* Again even if we can make a decision, we just mark the result and
|
||||
* the fact that we are done and continue looping.
|
||||
*/
|
||||
cond = mbedtls_ct_mpi_uint_lt( A[i - 1], B[i - 1] );
|
||||
ret |= cond & ( 1 - done );
|
||||
done |= cond;
|
||||
}
|
||||
|
||||
/*
|
||||
* If all the limbs were equal, then the numbers are equal, A < B is false
|
||||
* and leaving the result 0 is correct.
|
||||
*/
|
||||
|
||||
return( ret );
|
||||
}
|
||||
|
||||
/*
|
||||
* Compare signed values in constant time
|
||||
*/
|
||||
|
@ -129,6 +129,23 @@ unsigned mbedtls_ct_size_bool_eq( size_t x,
|
||||
unsigned mbedtls_ct_mpi_uint_lt( const mbedtls_mpi_uint x,
|
||||
const mbedtls_mpi_uint y );
|
||||
|
||||
/**
|
||||
* \brief Check if one unsigned MPI is less than another in constant
|
||||
* time.
|
||||
*
|
||||
* \param A The left-hand MPI. This must point to an array of limbs
|
||||
* with the same allocated length as \p B.
|
||||
* \param B The right-hand MPI. This must point to an array of limbs
|
||||
* with the same allocated length as \p A.
|
||||
* \param limbs The number of limbs in \p A and \p B.
|
||||
*
|
||||
* \return The result of the comparison:
|
||||
* \c 1 if \p A is less than \p B.
|
||||
* \c 0 if \p A is greater than or equal to \p B.
|
||||
*/
|
||||
unsigned mbedtls_mpi_core_lt_ct( const mbedtls_mpi_uint *A,
|
||||
const mbedtls_mpi_uint *B,
|
||||
size_t limbs);
|
||||
#endif /* MBEDTLS_BIGNUM_C */
|
||||
|
||||
/** Choose between two integer values without branches.
|
||||
|
Reference in New Issue
Block a user