Documentation

Documentation

Includes

config.h

#include "config.h"
#include "config.h"

MBEDTLS_CONFIG_FILE

#include MBEDTLS_CONFIG_FILE
#include MBEDTLS_CONFIG_FILE

Macros

Marco MBEDTLS_ECP_INTERNAL_H

#define MBEDTLS_ECP_INTERNAL_H

      

Functions

Func mbedtls_internal_ecp_init

int mbedtls_internal_ecp_init( const mbedtls_ecp_group *grp );
/**
 * \brief           Initialise the Elliptic Curve Point module extension.
 *
 *                  If mbedtls_internal_ecp_grp_capable returns true for a
 *                  group, this function has to be able to initialise the
 *                  module for it.
 *
 *                  This module can be a driver to a crypto hardware
 *                  accelerator, for which this could be an initialise function.
 *
 * \param grp       The pointer to the group the module needs to be
 *                  initialised for.
 *
 * \return          0 if successful.
 */

Func mbedtls_internal_ecp_free

void mbedtls_internal_ecp_free( const mbedtls_ecp_group *grp );
/**
 * \brief           Frees and deallocates the Elliptic Curve Point module
 *                  extension.
 *
 * \param grp       The pointer to the group the module was initialised for.
 */

Func mbedtls_internal_ecp_randomize_jac

int mbedtls_internal_ecp_randomize_jac( const mbedtls_ecp_group *grp,
       mbedtls_ecp_point *pt, int (*f_rng)(void *, unsigned char *, size_t),
       void *p_rng );
/**
 * \brief           Randomize jacobian coordinates:
 *                  (X, Y, Z) -> (l^2 X, l^3 Y, l Z) for random l.
 *
 * \param grp       Pointer to the group representing the curve.
 *
 * \param pt        The point on the curve to be randomised, given with Jacobian
 *                  coordinates.
 *
 * \param f_rng     A function pointer to the random number generator.
 *
 * \param p_rng     A pointer to the random number generator state.
 *
 * \return          0 if successful.
 */

Func mbedtls_internal_ecp_add_mixed

int mbedtls_internal_ecp_add_mixed( const mbedtls_ecp_group *grp,
       mbedtls_ecp_point *R, const mbedtls_ecp_point *P,
       const mbedtls_ecp_point *Q );
/**
 * \brief           Addition: R = P + Q, mixed affine-Jacobian coordinates.
 *
 *                  The coordinates of Q must be normalized (= affine),
 *                  but those of P don't need to. R is not normalized.
 *
 *                  This function is used only as a subrutine of
 *                  ecp_mul_comb().
 *
 *                  Special cases: (1) P or Q is zero, (2) R is zero,
 *                      (3) P == Q.
 *                  None of these cases can happen as intermediate step in
 *                  ecp_mul_comb():
 *                      - at each step, P, Q and R are multiples of the base
 *                      point, the factor being less than its order, so none of
 *                      them is zero;
 *                      - Q is an odd multiple of the base point, P an even
 *                      multiple, due to the choice of precomputed points in the
 *                      modified comb method.
 *                  So branches for these cases do not leak secret information.
 *
 *                  We accept Q->Z being unset (saving memory in tables) as
 *                  meaning 1.
 *
 *                  Cost in field operations if done by [5] 3.22:
 *                      1A := 8M + 3S
 *
 * \param grp       Pointer to the group representing the curve.
 *
 * \param R         Pointer to a point structure to hold the result.
 *
 * \param P         Pointer to the first summand, given with Jacobian
 *                  coordinates
 *
 * \param Q         Pointer to the second summand, given with affine
 *                  coordinates.
 *
 * \return          0 if successful.
 */

Func mbedtls_internal_ecp_double_jac

int mbedtls_internal_ecp_double_jac( const mbedtls_ecp_group *grp,
       mbedtls_ecp_point *R, const mbedtls_ecp_point *P );


      

Func mbedtls_internal_ecp_normalize_jac_many

int mbedtls_internal_ecp_normalize_jac_many( const mbedtls_ecp_group *grp,
       mbedtls_ecp_point *T[], size_t t_len );


      

Func mbedtls_internal_ecp_normalize_jac

int mbedtls_internal_ecp_normalize_jac( const mbedtls_ecp_group *grp,
       mbedtls_ecp_point *pt );


      

Func mbedtls_internal_ecp_double_add_mxz

int mbedtls_internal_ecp_double_add_mxz( const mbedtls_ecp_group *grp,
       mbedtls_ecp_point *R, mbedtls_ecp_point *S, const mbedtls_ecp_point *P,
       const mbedtls_ecp_point *Q, const mbedtls_mpi *d );


      

Func mbedtls_internal_ecp_randomize_mxz

int mbedtls_internal_ecp_randomize_mxz( const mbedtls_ecp_group *grp,
       mbedtls_ecp_point *P, int (*f_rng)(void *, unsigned char *, size_t),
       void *p_rng );


      

Func mbedtls_internal_ecp_normalize_mxz

int mbedtls_internal_ecp_normalize_mxz( const mbedtls_ecp_group *grp,
       mbedtls_ecp_point *P );

      

Vars

Variable char

unsigned char mbedtls_internal_ecp_grp_capable( const mbedtls_ecp_group *grp );
/**
 * \brief           Indicate if the Elliptic Curve Point module extension can
 *                  handle the group.
 *
 * \param grp       The pointer to the elliptic curve group that will be the
 *                  basis of the cryptographic computations.
 *
 * \return          Non-zero if successful.
 */

Consts

Types

Typedefs