edhoc 1.4.0 → 2.0.0

package/external/libedhoc/externals/mbedtls/library/ecp_internal_alt.h

@@ -1,287 +0,0 @@
-/**
- * \file ecp_internal_alt.h
- *
- * \brief Function declarations for alternative implementation of elliptic curve
- * point arithmetic.
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
- */
-
-/*
- * References:
- *
- * [1] BERNSTEIN, Daniel J. Curve25519: new Diffie-Hellman speed records.
- *     <http://cr.yp.to/ecdh/curve25519-20060209.pdf>
- *
- * [2] CORON, Jean-S'ebastien. Resistance against differential power analysis
- *     for elliptic curve cryptosystems. In : Cryptographic Hardware and
- *     Embedded Systems. Springer Berlin Heidelberg, 1999. p. 292-302.
- *     <http://link.springer.com/chapter/10.1007/3-540-48059-5_25>
- *
- * [3] HEDABOU, Mustapha, PINEL, Pierre, et B'EN'ETEAU, Lucien. A comb method to
- *     render ECC resistant against Side Channel Attacks. IACR Cryptology
- *     ePrint Archive, 2004, vol. 2004, p. 342.
- *     <http://eprint.iacr.org/2004/342.pdf>
- *
- * [4] Certicom Research. SEC 2: Recommended Elliptic Curve Domain Parameters.
- *     <http://www.secg.org/sec2-v2.pdf>
- *
- * [5] HANKERSON, Darrel, MENEZES, Alfred J., VANSTONE, Scott. Guide to Elliptic
- *     Curve Cryptography.
- *
- * [6] Digital Signature Standard (DSS), FIPS 186-4.
- *     <http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf>
- *
- * [7] Elliptic Curve Cryptography (ECC) Cipher Suites for Transport Layer
- *     Security (TLS), RFC 4492.
- *     <https://tools.ietf.org/search/rfc4492>
- *
- * [8] <http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian.html>
- *
- * [9] COHEN, Henri. A Course in Computational Algebraic Number Theory.
- *     Springer Science & Business Media, 1 Aug 2000
- */
-
-#ifndef MBEDTLS_ECP_INTERNAL_H
-#define MBEDTLS_ECP_INTERNAL_H
-
-#include "mbedtls/build_info.h"
-
-#if defined(MBEDTLS_ECP_INTERNAL_ALT)
-
-/**
- * \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.
- */
-unsigned char mbedtls_internal_ecp_grp_capable(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.
- */
-int mbedtls_internal_ecp_init(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.
- */
-void mbedtls_internal_ecp_free(const mbedtls_ecp_group *grp);
-
-#if defined(MBEDTLS_ECP_SHORT_WEIERSTRASS_ENABLED)
-
-#if defined(MBEDTLS_ECP_RANDOMIZE_JAC_ALT)
-/**
- * \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.
- */
-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);
-#endif
-
-#if defined(MBEDTLS_ECP_ADD_MIXED_ALT)
-/**
- * \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.
- */
-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);
-#endif
-
-/**
- * \brief           Point doubling R = 2 P, Jacobian coordinates.
- *
- *                  Cost:   1D := 3M + 4S    (A ==  0)
- *                          4M + 4S          (A == -3)
- *                          3M + 6S + 1a     otherwise
- *                  when the implementation is based on the "dbl-1998-cmo-2"
- *                  doubling formulas in [8] and standard optimizations are
- *                  applied when curve parameter A is one of { 0, -3 }.
- *
- * \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 point that has to be doubled, given with
- *                  Jacobian coordinates.
- *
- * \return          0 if successful.
- */
-#if defined(MBEDTLS_ECP_DOUBLE_JAC_ALT)
-int mbedtls_internal_ecp_double_jac(const mbedtls_ecp_group *grp,
-                                    mbedtls_ecp_point *R, const mbedtls_ecp_point *P);
-#endif
-
-/**
- * \brief           Normalize jacobian coordinates of an array of (pointers to)
- *                  points.
- *
- *                  Using Montgomery's trick to perform only one inversion mod P
- *                  the cost is:
- *                      1N(t) := 1I + (6t - 3)M + 1S
- *                  (See for example Algorithm 10.3.4. in [9])
- *
- *                  This function is used only as a subrutine of
- *                  ecp_mul_comb().
- *
- *                  Warning: fails (returning an error) if one of the points is
- *                  zero!
- *                  This should never happen, see choice of w in ecp_mul_comb().
- *
- * \param grp       Pointer to the group representing the curve.
- *
- * \param T         Array of pointers to the points to normalise.
- *
- * \param t_len     Number of elements in the array.
- *
- * \return          0 if successful,
- *                      an error if one of the points is zero.
- */
-#if defined(MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT)
-int mbedtls_internal_ecp_normalize_jac_many(const mbedtls_ecp_group *grp,
-                                            mbedtls_ecp_point *T[], size_t t_len);
-#endif
-
-/**
- * \brief           Normalize jacobian coordinates so that Z == 0 || Z == 1.
- *
- *                  Cost in field operations if done by [5] 3.2.1:
- *                      1N := 1I + 3M + 1S
- *
- * \param grp       Pointer to the group representing the curve.
- *
- * \param pt        pointer to the point to be normalised. This is an
- *                  input/output parameter.
- *
- * \return          0 if successful.
- */
-#if defined(MBEDTLS_ECP_NORMALIZE_JAC_ALT)
-int mbedtls_internal_ecp_normalize_jac(const mbedtls_ecp_group *grp,
-                                       mbedtls_ecp_point *pt);
-#endif
-
-#endif /* MBEDTLS_ECP_SHORT_WEIERSTRASS_ENABLED */
-
-#if defined(MBEDTLS_ECP_MONTGOMERY_ENABLED)
-
-#if defined(MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT)
-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);
-#endif
-
-/**
- * \brief           Randomize projective x/z coordinates:
- *                      (X, Z) -> (l X, l Z) for random l
- *
- * \param grp       pointer to the group representing the curve
- *
- * \param P         the point on the curve to be randomised given with
- *                  projective coordinates. This is an input/output parameter.
- *
- * \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
- */
-#if defined(MBEDTLS_ECP_RANDOMIZE_MXZ_ALT)
-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);
-#endif
-
-/**
- * \brief           Normalize Montgomery x/z coordinates: X = X/Z, Z = 1.
- *
- * \param grp       pointer to the group representing the curve
- *
- * \param P         pointer to the point to be normalised. This is an
- *                  input/output parameter.
- *
- * \return          0 if successful
- */
-#if defined(MBEDTLS_ECP_NORMALIZE_MXZ_ALT)
-int mbedtls_internal_ecp_normalize_mxz(const mbedtls_ecp_group *grp,
-                                       mbedtls_ecp_point *P);
-#endif
-
-#endif /* MBEDTLS_ECP_MONTGOMERY_ENABLED */
-
-#endif /* MBEDTLS_ECP_INTERNAL_ALT */
-
-#endif /* ecp_internal_alt.h */

package/external/libedhoc/externals/mbedtls/library/ecp_invasive.h

@@ -1,325 +0,0 @@
-/**
- * \file ecp_invasive.h
- *
- * \brief ECP module: interfaces for invasive testing only.
- *
- * The interfaces in this file are intended for testing purposes only.
- * They SHOULD NOT be made available in library integrations except when
- * building the library for testing.
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
- */
-#ifndef MBEDTLS_ECP_INVASIVE_H
-#define MBEDTLS_ECP_INVASIVE_H
-
-#include "common.h"
-#include "mbedtls/bignum.h"
-#include "bignum_mod.h"
-#include "mbedtls/ecp.h"
-
-/*
- * Curve modulus types
- */
-typedef enum {
-    MBEDTLS_ECP_MOD_NONE = 0,
-    MBEDTLS_ECP_MOD_COORDINATE,
-    MBEDTLS_ECP_MOD_SCALAR
-} mbedtls_ecp_modulus_type;
-
-typedef enum {
-    MBEDTLS_ECP_VARIANT_NONE = 0,
-    MBEDTLS_ECP_VARIANT_WITH_MPI_STRUCT,
-    MBEDTLS_ECP_VARIANT_WITH_MPI_UINT
-} mbedtls_ecp_variant;
-
-#if defined(MBEDTLS_TEST_HOOKS) && defined(MBEDTLS_ECP_LIGHT)
-
-/** Queries the ecp variant.
- *
- * \return  The id of the ecp variant.
- */
-MBEDTLS_STATIC_TESTABLE
-mbedtls_ecp_variant mbedtls_ecp_get_variant(void);
-
-#if defined(MBEDTLS_ECP_MONTGOMERY_ENABLED)
-/** Generate a private key on a Montgomery curve (Curve25519 or Curve448).
- *
- * This function implements key generation for the set of secret keys
- * specified in [Curve25519] p. 5 and in [Curve448]. The resulting value
- * has the lower bits masked but is not necessarily canonical.
- *
- * \note            - [Curve25519] http://cr.yp.to/ecdh/curve25519-20060209.pdf
- *                  - [RFC7748] https://tools.ietf.org/html/rfc7748
- *
- * \p high_bit      The position of the high-order bit of the key to generate.
- *                  This is the bit-size of the key minus 1:
- *                  254 for Curve25519 or 447 for Curve448.
- * \param d         The randomly generated key. This is a number of size
- *                  exactly \p high_bit + 1 bits, with the least significant bits
- *                  masked as specified in [Curve25519] and in [RFC7748] §5.
- * \param f_rng     The RNG function.
- * \param p_rng     The RNG context to be passed to \p f_rng.
- *
- * \return          \c 0 on success.
- * \return          \c MBEDTLS_ERR_ECP_xxx or MBEDTLS_ERR_MPI_xxx on failure.
- */
-int mbedtls_ecp_gen_privkey_mx(size_t high_bit,
-                               mbedtls_mpi *d,
-                               int (*f_rng)(void *, unsigned char *, size_t),
-                               void *p_rng);
-
-#endif /* MBEDTLS_ECP_MONTGOMERY_ENABLED */
-
-#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
-
-/** Fast quasi-reduction modulo p192 (FIPS 186-3 D.2.1)
- *
- * This operation expects a 384 bit MPI and the result of the reduction
- * is a 192 bit MPI.
- *
- * \param[in,out]   Np  The address of the MPI to be converted.
- *                      Must have twice as many limbs as the modulus.
- *                      Upon return this holds the reduced value. The bitlength
- *                      of the reduced value is the same as that of the modulus
- *                      (192 bits).
- * \param[in]       Nn  The length of \p Np in limbs.
- */
-MBEDTLS_STATIC_TESTABLE
-int mbedtls_ecp_mod_p192_raw(mbedtls_mpi_uint *Np, size_t Nn);
-
-#endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */
-
-#if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
-
-/** Fast quasi-reduction modulo p224 (FIPS 186-3 D.2.2)
- *
- * \param[in,out]   X       The address of the MPI to be converted.
- *                          Must have exact limb size that stores a 448-bit MPI
- *                          (double the bitlength of the modulus).
- *                          Upon return holds the reduced value which is
- *                          in range `0 <= X < 2 * N` (where N is the modulus).
- *                          The bitlength of the reduced value is the same as
- *                          that of the modulus (224 bits).
- * \param[in]       X_limbs The length of \p X in limbs.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_ECP_BAD_INPUT_DATA if \p X_limbs is not the
- *                  limb size that sores a 448-bit MPI.
- */
-MBEDTLS_STATIC_TESTABLE
-int mbedtls_ecp_mod_p224_raw(mbedtls_mpi_uint *X, size_t X_limbs);
-
-#endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */
-
-#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
-
-/** Fast quasi-reduction modulo p256 (FIPS 186-3 D.2.3)
- *
- * \param[in,out]   X       The address of the MPI to be converted.
- *                          Must have exact limb size that stores a 512-bit MPI
- *                          (double the bitlength of the modulus).
- *                          Upon return holds the reduced value which is
- *                          in range `0 <= X < 2 * N` (where N is the modulus).
- *                          The bitlength of the reduced value is the same as
- *                          that of the modulus (256 bits).
- * \param[in]       X_limbs The length of \p X in limbs.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_ECP_BAD_INPUT_DATA if \p X_limbs is not the
- *                  limb size that sores a 512-bit MPI.
- */
-MBEDTLS_STATIC_TESTABLE
-int mbedtls_ecp_mod_p256_raw(mbedtls_mpi_uint *X, size_t X_limbs);
-
-#endif
-
-#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
-
-/** Fast quasi-reduction modulo p521 = 2^521 - 1 (FIPS 186-3 D.2.5)
- *
- * \param[in,out]   X       The address of the MPI to be converted.
- *                          Must have twice as many limbs as the modulus
- *                          (the modulus is 521 bits long). Upon return this
- *                          holds the reduced value. The reduced value is
- *                          in range `0 <= X < 2 * N` (where N is the modulus).
- *                          and its the bitlength is one plus the bitlength
- *                          of the modulus.
- * \param[in]       X_limbs The length of \p X in limbs.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_ECP_BAD_INPUT_DATA if \p X_limbs does not have
- *                  twice as many limbs as the modulus.
- */
-MBEDTLS_STATIC_TESTABLE
-int mbedtls_ecp_mod_p521_raw(mbedtls_mpi_uint *X, size_t X_limbs);
-
-#endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */
-
-#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
-
-/** Fast quasi-reduction modulo p384 (FIPS 186-3 D.2.4)
- *
- * \param[in,out]   X       The address of the MPI to be converted.
- *                          Must have exact limb size that stores a 768-bit MPI
- *                          (double the bitlength of the modulus).
- *                          Upon return holds the reduced value which is
- *                          in range `0 <= X < 2 * N` (where N is the modulus).
- *                          The bitlength of the reduced value is the same as
- *                          that of the modulus (384 bits).
- * \param[in]       X_limbs The length of \p N in limbs.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_ECP_BAD_INPUT_DATA if \p N_n does not have
- *                  twice as many limbs as the modulus.
- */
-MBEDTLS_STATIC_TESTABLE
-int  mbedtls_ecp_mod_p384_raw(mbedtls_mpi_uint *X, size_t X_limbs);
-
-#endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
-
-#if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
-
-/** Fast quasi-reduction modulo p192k1 = 2^192 - R,
- * with R = 2^32 + 2^12 + 2^8 + 2^7 + 2^6 + 2^3 + 1 = 0x01000011C9
- *
- * \param[in,out]   X       The address of the MPI to be converted.
- *                          Must have exact limb size that stores a 384-bit MPI
- *                          (double the bitlength of the modulus).
- *                          Upon return holds the reduced value which is
- *                          in range `0 <= X < 2 * N` (where N is the modulus).
- *                          The bitlength of the reduced value is the same as
- *                          that of the modulus (192 bits).
- * \param[in]       X_limbs The length of \p X in limbs.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_ECP_BAD_INPUT_DATA if \p X does not have
- *                  twice as many limbs as the modulus.
- * \return          #MBEDTLS_ERR_ECP_ALLOC_FAILED if memory allocation failed.
- */
-MBEDTLS_STATIC_TESTABLE
-int mbedtls_ecp_mod_p192k1_raw(mbedtls_mpi_uint *X, size_t X_limbs);
-
-#endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */
-
-#if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
-
-/** Fast quasi-reduction modulo p224k1 = 2^224 - R,
- * with R = 2^32 + 2^12 + 2^11 + 2^9 + 2^7 + 2^4 + 2 + 1 = 0x0100001A93
- *
- * \param[in,out]   X       The address of the MPI to be converted.
- *                          Must have exact limb size that stores a 448-bit MPI
- *                          (double the bitlength of the modulus).
- *                          Upon return holds the reduced value which is
- *                          in range `0 <= X < 2 * N` (where N is the modulus).
- *                          The bitlength of the reduced value is the same as
- *                          that of the modulus (224 bits).
- * \param[in]       X_limbs The length of \p X in limbs.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_ECP_BAD_INPUT_DATA if \p X does not have
- *                  twice as many limbs as the modulus.
- * \return          #MBEDTLS_ERR_ECP_ALLOC_FAILED if memory allocation failed.
- */
-MBEDTLS_STATIC_TESTABLE
-int mbedtls_ecp_mod_p224k1_raw(mbedtls_mpi_uint *X, size_t X_limbs);
-
-#endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */
-
-#if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
-
-/** Fast quasi-reduction modulo p256k1 = 2^256 - R,
- * with R = 2^32 + 2^9 + 2^8 + 2^7 + 2^6 + 2^4 + 1 = 0x01000003D1
- *
- * \param[in,out]   X       The address of the MPI to be converted.
- *                          Must have exact limb size that stores a 512-bit MPI
- *                          (double the bitlength of the modulus).
- *                          Upon return holds the reduced value which is
- *                          in range `0 <= X < 2 * N` (where N is the modulus).
- *                          The bitlength of the reduced value is the same as
- *                          that of the modulus (256 bits).
- * \param[in]       X_limbs The length of \p X in limbs.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_ECP_BAD_INPUT_DATA if \p X does not have
- *                  twice as many limbs as the modulus.
- * \return          #MBEDTLS_ERR_ECP_ALLOC_FAILED if memory allocation failed.
- */
-MBEDTLS_STATIC_TESTABLE
-int mbedtls_ecp_mod_p256k1_raw(mbedtls_mpi_uint *X, size_t X_limbs);
-
-#endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */
-
-#if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
-
-/** Fast quasi-reduction modulo p255 = 2^255 - 19
- *
- * \param[in,out]   X       The address of the MPI to be converted.
- *                          Must have exact limb size that stores a 510-bit MPI
- *                          (double the bitlength of the modulus).
- *                          Upon return holds the reduced value which is
- *                          in range `0 <= X < 2 * N` (where N is the modulus).
- * \param[in]       X_limbs The length of \p X in limbs.
- *
- * \return          \c 0 on success.
- * \return          #MBEDTLS_ERR_ECP_BAD_INPUT_DATA if \p X does not have
- *                  twice as many limbs as the modulus.
- * \return          #MBEDTLS_ERR_ECP_ALLOC_FAILED if memory allocation failed.
- */
-MBEDTLS_STATIC_TESTABLE
-int mbedtls_ecp_mod_p255_raw(mbedtls_mpi_uint *X, size_t X_limbs);
-
-#endif /* MBEDTLS_ECP_DP_CURVE25519_ENABLED */
-
-#if defined(MBEDTLS_ECP_DP_CURVE448_ENABLED)
-
-/** Fast quasi-reduction modulo p448 = 2^448 - 2^224 - 1
- * Write X as A0 + 2^448 A1 and A1 as B0 + 2^224 B1, and return A0 + A1 + B1 +
- * (B0 + B1) * 2^224.
- *
- * \param[in,out]   X       The address of the MPI to be converted.
- *                          Must have exact limb size that stores a 896-bit MPI
- *                          (double the bitlength of the modulus). Upon return
- *                          holds the reduced value which is in range `0 <= X <
- *                          N` (where N is the modulus). The bitlength of the
- *                          reduced value is the same as that of the modulus
- *                          (448 bits).
- * \param[in]       X_limbs The length of \p X in limbs.
- *
- * \return          \c 0 on Success.
- * \return          #MBEDTLS_ERR_ECP_BAD_INPUT_DATA if \p X does not have
- *                  twice as many limbs as the modulus.
- * \return          #MBEDTLS_ERR_ECP_ALLOC_FAILED if memory allocation
- *                  failed.
- */
-MBEDTLS_STATIC_TESTABLE
-int mbedtls_ecp_mod_p448_raw(mbedtls_mpi_uint *X, size_t X_limbs);
-
-#endif /* MBEDTLS_ECP_DP_CURVE448_ENABLED */
-
-/** Initialise a modulus with hard-coded const curve data.
- *
- * \note            The caller is responsible for the \p N modulus' memory.
- *                  mbedtls_mpi_mod_modulus_free(&N) should be invoked at the
- *                  end of its lifecycle.
- *
- * \param[in,out] N The address of the modulus structure to populate.
- *                  Must be initialized.
- * \param[in] id    The mbedtls_ecp_group_id for which to initialise the modulus.
- * \param[in] ctype The mbedtls_ecp_modulus_type identifier for a coordinate modulus (P)
- *                  or a scalar modulus (N).
- *
- * \return          \c 0 if successful.
- * \return          #MBEDTLS_ERR_ECP_BAD_INPUT_DATA if the given MPIs do not
- *                  have the correct number of limbs.
- *
- */
-MBEDTLS_STATIC_TESTABLE
-int mbedtls_ecp_modulus_setup(mbedtls_mpi_mod_modulus *N,
-                              const mbedtls_ecp_group_id id,
-                              const mbedtls_ecp_modulus_type ctype);
-
-#endif /* MBEDTLS_TEST_HOOKS && MBEDTLS_ECP_C */
-
-#endif /* MBEDTLS_ECP_INVASIVE_H */