Remove references to libdecaf (aeeef83c) · Commits · CYBER - Cyber Security / TS 103 523 MSP / TLMSP / TLMSP OpenSSL

crypto/ec/curve448/arch_32/f_impl.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -13,7 +13,7 @@
		#include "f_field.h"

		#if (defined(__OPTIMIZE__) && !defined(__OPTIMIZE_SIZE__) && !I_HATE_UNROLLED_LOOPS) \
		\|\| defined(DECAF_FORCE_UNROLL)
		\|\| defined(C448_FORCE_UNROLL)
		# define REPEAT8(_x) _x _x _x _x _x _x _x _x
		# define FOR_LIMB(_i,_start,_end,_x) do { _i=_start; REPEAT8( if (_i<_end) { _x; } _i++;) } while (0)
		#else

crypto/ec/curve448/curve448.c

+37 −37

Original line number	Diff line number	Diff line
		@@ -23,8 +23,8 @@
		#define COMBS_N 5
		#define COMBS_T 5
		#define COMBS_S 18
		#define DECAF_WNAF_FIXED_TABLE_BITS 5
		#define DECAF_WNAF_VAR_TABLE_BITS 3
		#define C448_WNAF_FIXED_TABLE_BITS 5
		#define C448_WNAF_VAR_TABLE_BITS 3

		static const int EDWARDS_D = -39081;
		static const curve448_scalar_t precomputed_scalarmul_adjustment = {
		@@ -38,7 +38,7 @@ static const curve448_scalar_t precomputed_scalarmul_adjustment = {

		#define TWISTED_D ((EDWARDS_D)-1)

		#define WBITS DECAF_WORD_BITS /* NB this may be different from ARCH_WORD_BITS */
		#define WBITS C448_WORD_BITS /* NB this may be different from ARCH_WORD_BITS */

		/* Projective Niels coordinates */
		typedef struct {
		@@ -203,7 +203,7 @@ static void sub_pniels_from_pt(curve448_point_t p, const pniels_t pn,
		sub_niels_from_pt(p, pn->n, before_double);
		}

		decaf_bool_t curve448_point_eq(const curve448_point_t p,
		c448_bool_t curve448_point_eq(const curve448_point_t p,
		const curve448_point_t q)
		{
		mask_t succ;
		@@ -217,7 +217,7 @@ decaf_bool_t curve448_point_eq(const curve448_point_t p,
		return mask_to_bool(succ);
		}

		decaf_bool_t curve448_point_valid(const curve448_point_t p)
		c448_bool_t curve448_point_valid(const curve448_point_t p)
		{
		mask_t out;

		@@ -267,7 +267,7 @@ void curve448_precomputed_scalarmul(curve448_point_t out,

		for (k = 0; k < t; k++) {
		unsigned int bit = i + s * (k + j * t);
		if (bit < DECAF_448_SCALAR_BITS) {
		if (bit < C448_448_SCALAR_BITS) {
		tab \|=
		(scalar1x->limb[bit / WBITS] >> (bit % WBITS) & 1) << k;
		}
		@@ -294,7 +294,7 @@ void curve448_precomputed_scalarmul(curve448_point_t out,
		}

		void curve448_point_mul_by_ratio_and_encode_like_eddsa(
		uint8_t enc[DECAF_EDDSA_448_PUBLIC_BYTES],
		uint8_t enc[C448_EDDSA_448_PUBLIC_BYTES],
		const curve448_point_t p)
		{

		@@ -329,9 +329,9 @@ void curve448_point_mul_by_ratio_and_encode_like_eddsa(
		gf_mul(x, y, z);

		/* Encode */
		enc[DECAF_EDDSA_448_PRIVATE_BYTES - 1] = 0;
		enc[C448_EDDSA_448_PRIVATE_BYTES - 1] = 0;
		gf_serialize(enc, x, 1);
		enc[DECAF_EDDSA_448_PRIVATE_BYTES - 1] \|= 0x80 & gf_lobit(t);
		enc[C448_EDDSA_448_PRIVATE_BYTES - 1] \|= 0x80 & gf_lobit(t);

		OPENSSL_cleanse(x, sizeof(x));
		OPENSSL_cleanse(y, sizeof(y));
		@@ -340,22 +340,22 @@ void curve448_point_mul_by_ratio_and_encode_like_eddsa(
		curve448_point_destroy(q);
		}

		decaf_error_t curve448_point_decode_like_eddsa_and_mul_by_ratio(
		c448_error_t curve448_point_decode_like_eddsa_and_mul_by_ratio(
		curve448_point_t p,
		const uint8_t enc[DECAF_EDDSA_448_PUBLIC_BYTES])
		const uint8_t enc[C448_EDDSA_448_PUBLIC_BYTES])
		{
		uint8_t enc2[DECAF_EDDSA_448_PUBLIC_BYTES];
		uint8_t enc2[C448_EDDSA_448_PUBLIC_BYTES];
		mask_t low;
		mask_t succ;

		memcpy(enc2, enc, sizeof(enc2));

		low = ~word_is_zero(enc2[DECAF_EDDSA_448_PRIVATE_BYTES - 1] & 0x80);
		enc2[DECAF_EDDSA_448_PRIVATE_BYTES - 1] &= ~0x80;
		low = ~word_is_zero(enc2[C448_EDDSA_448_PRIVATE_BYTES - 1] & 0x80);
		enc2[C448_EDDSA_448_PRIVATE_BYTES - 1] &= ~0x80;

		succ = gf_deserialize(p->y, enc2, 1, 0);
		#if 0 == 0
		succ &= word_is_zero(enc2[DECAF_EDDSA_448_PRIVATE_BYTES - 1]);
		succ &= word_is_zero(enc2[C448_EDDSA_448_PRIVATE_BYTES - 1]);
		#endif

		gf_sqr(p->x, p->y);
		@@ -396,10 +396,10 @@ decaf_error_t curve448_point_decode_like_eddsa_and_mul_by_ratio(
		OPENSSL_cleanse(enc2, sizeof(enc2));
		assert(curve448_point_valid(p) \|\| ~succ);

		return decaf_succeed_if(mask_to_bool(succ));
		return c448_succeed_if(mask_to_bool(succ));
		}

		decaf_error_t decaf_x448(uint8_t out[X_PUBLIC_BYTES],
		c448_error_t c448_x448(uint8_t out[X_PUBLIC_BYTES],
		const uint8_t base[X_PUBLIC_BYTES],
		const uint8_t scalar[X_PRIVATE_BYTES])
		{
		@@ -470,7 +470,7 @@ decaf_error_t decaf_x448(uint8_t out[X_PUBLIC_BYTES],
		OPENSSL_cleanse(t1, sizeof(t1));
		OPENSSL_cleanse(t2, sizeof(t2));

		return decaf_succeed_if(mask_to_bool(nz));
		return c448_succeed_if(mask_to_bool(nz));
		}

		void curve448_point_mul_by_ratio_and_encode_like_x448(uint8_t
		@@ -486,7 +486,7 @@ void curve448_point_mul_by_ratio_and_encode_like_x448(uint8_t
		curve448_point_destroy(q);
		}

		void decaf_x448_derive_public_key(uint8_t out[X_PUBLIC_BYTES],
		void c448_x448_derive_public_key(uint8_t out[X_PUBLIC_BYTES],
		const uint8_t scalar[X_PRIVATE_BYTES])
		{
		/* Scalar conditioning */
		@@ -504,7 +504,7 @@ void decaf_x448_derive_public_key(uint8_t out[X_PUBLIC_BYTES],
		curve448_scalar_decode_long(the_scalar, scalar2, sizeof(scalar2));

		/* Compensate for the encoding ratio */
		for (i = 1; i < DECAF_X448_ENCODE_RATIO; i <<= 1) {
		for (i = 1; i < C448_X448_ENCODE_RATIO; i <<= 1) {
		curve448_scalar_halve(the_scalar, the_scalar);
		}
		curve448_precomputed_scalarmul(p, curve448_precomputed_base, the_scalar);
		@@ -522,7 +522,7 @@ static int recode_wnaf(struct smvt_control *control,
		const curve448_scalar_t scalar,
		unsigned int table_bits)
		{
		unsigned int table_size = DECAF_448_SCALAR_BITS / (table_bits + 1) + 3;
		unsigned int table_size = C448_448_SCALAR_BITS / (table_bits + 1) + 3;
		int position = table_size - 1; /* at the end */
		uint64_t current = scalar->limb[0] & 0xFFFF;
		uint32_t mask = (1 << (table_bits + 1)) - 1;
		@@ -541,8 +541,8 @@ static int recode_wnaf(struct smvt_control *control,
		* 1/5 op. Probably not worth it.
		*/

		for (w = 1; w < (DECAF_448_SCALAR_BITS - 1) / 16 + 3; w++) {
		if (w < (DECAF_448_SCALAR_BITS - 1) / 16 + 1) {
		for (w = 1; w < (C448_448_SCALAR_BITS - 1) / 16 + 3; w++) {
		if (w < (C448_448_SCALAR_BITS - 1) / 16 + 1) {
		/* Refill the 16 high bits of current */
		current += (uint32_t)((scalar->limb[w / B_OVER_16]
		>> (16 * (w % B_OVER_16))) << 16);
		@@ -610,15 +610,15 @@ void curve448_base_double_scalarmul_non_secret(curve448_point_t combo,
		const curve448_point_t base2,
		const curve448_scalar_t scalar2)
		{
		const int table_bits_var = DECAF_WNAF_VAR_TABLE_BITS,
		table_bits_pre = DECAF_WNAF_FIXED_TABLE_BITS;
		struct smvt_control control_var[DECAF_448_SCALAR_BITS /
		(DECAF_WNAF_VAR_TABLE_BITS + 1) + 3];
		struct smvt_control control_pre[DECAF_448_SCALAR_BITS /
		(DECAF_WNAF_FIXED_TABLE_BITS + 1) + 3];
		const int table_bits_var = C448_WNAF_VAR_TABLE_BITS,
		table_bits_pre = C448_WNAF_FIXED_TABLE_BITS;
		struct smvt_control control_var[C448_448_SCALAR_BITS /
		(C448_WNAF_VAR_TABLE_BITS + 1) + 3];
		struct smvt_control control_pre[C448_448_SCALAR_BITS /
		(C448_WNAF_FIXED_TABLE_BITS + 1) + 3];
		int ncb_pre = recode_wnaf(control_pre, scalar1, table_bits_pre);
		int ncb_var = recode_wnaf(control_var, scalar2, table_bits_var);
		pniels_t precmp_var[1 << DECAF_WNAF_VAR_TABLE_BITS];
		pniels_t precmp_var[1 << C448_WNAF_VAR_TABLE_BITS];
		int contp = 0, contv = 0, i;

		prepare_wnaf_table(precmp_var, base2, table_bits_var);
		@@ -697,12 +697,12 @@ void curve448_point_destroy(curve448_point_t point)
		int X448(uint8_t out_shared_key[56], const uint8_t private_key[56],
		const uint8_t peer_public_value[56])
		{
		return decaf_x448(out_shared_key, peer_public_value, private_key)
		== DECAF_SUCCESS;
		return c448_x448(out_shared_key, peer_public_value, private_key)
		== C448_SUCCESS;
		}

		void X448_public_from_private(uint8_t out_public_value[56],
		const uint8_t private_key[56])
		{
		decaf_x448_derive_public_key(out_public_value, private_key);
		c448_x448_derive_public_key(out_public_value, private_key);
		}

crypto/ec/curve448/curve448utils.h

+28 −28

Original line number	Diff line number	Diff line
		@@ -10,8 +10,8 @@
		* Originally written by Mike Hamburg
		*/

		#ifndef __DECAF_COMMON_H__
		# define __DECAF_COMMON_H__ 1
		#ifndef __C448_COMMON_H__
		# define __C448_COMMON_H__ 1

		# include <openssl/e_os2.h>

		@@ -26,61 +26,61 @@ extern "C" {
		* header was built with eg arch_neon, you might end up linking a library built
		* with arch_arm32.
		*/
		# ifndef DECAF_WORD_BITS
		# ifndef C448_WORD_BITS
		# if (defined(__ILP64__) \|\| defined(__amd64__) \|\| defined(__x86_64__) \
		\|\| (((__UINT_FAST32_MAX__)>>30)>>30))
		# define DECAF_WORD_BITS 64 /* The number of bits in a word */
		# define C448_WORD_BITS 64 /* The number of bits in a word */
		# else
		# define DECAF_WORD_BITS 32 /* The number of bits in a word */
		# define C448_WORD_BITS 32 /* The number of bits in a word */
		# endif
		# endif

		# if DECAF_WORD_BITS == 64
		# if C448_WORD_BITS == 64
		/* Word size for internal computations */
		typedef uint64_t decaf_word_t;
		typedef uint64_t c448_word_t;
		/* Signed word size for internal computations */
		typedef int64_t decaf_sword_t;
		typedef int64_t c448_sword_t;
		/* "Boolean" type, will be set to all-zero or all-one (i.e. -1u) */
		typedef uint64_t decaf_bool_t;
		typedef uint64_t c448_bool_t;
		/* Double-word size for internal computations */
		typedef __uint128_t decaf_dword_t;
		typedef __uint128_t c448_dword_t;
		/* Signed double-word size for internal computations */
		typedef __int128_t decaf_dsword_t;
		# elif DECAF_WORD_BITS == 32
		typedef __int128_t c448_dsword_t;
		# elif C448_WORD_BITS == 32
		/* Word size for internal computations */
		typedef uint32_t decaf_word_t;
		typedef uint32_t c448_word_t;
		/* Signed word size for internal computations */
		typedef int32_t decaf_sword_t;
		typedef int32_t c448_sword_t;
		/* "Boolean" type, will be set to all-zero or all-one (i.e. -1u) */
		typedef uint32_t decaf_bool_t;
		typedef uint32_t c448_bool_t;
		/* Double-word size for internal computations */
		typedef uint64_t decaf_dword_t;
		typedef uint64_t c448_dword_t;
		/* Signed double-word size for internal computations */
		typedef int64_t decaf_dsword_t;
		typedef int64_t c448_dsword_t;
		# else
		# error "Only supporting DECAF_WORD_BITS = 32 or 64 for now"
		# error "Only supporting C448_WORD_BITS = 32 or 64 for now"
		# endif

		/* DECAF_TRUE = -1 so that DECAF_TRUE & x = x */
		static const decaf_bool_t DECAF_TRUE = -(decaf_bool_t) 1;
		/* C448_TRUE = -1 so that C448_TRUE & x = x */
		static const c448_bool_t C448_TRUE = -(c448_bool_t) 1;

		/* DECAF_FALSE = 0 so that DECAF_FALSE & x = 0 */
		static const decaf_bool_t DECAF_FALSE = 0;
		/* C448_FALSE = 0 so that C448_FALSE & x = 0 */
		static const c448_bool_t C448_FALSE = 0;

		/* Another boolean type used to indicate success or failure. */
		typedef enum {
		DECAF_SUCCESS = -1, /*< The operation succeeded. /
		DECAF_FAILURE = 0 /*< The operation failed. /
		} decaf_error_t;
		C448_SUCCESS = -1, /*< The operation succeeded. /
		C448_FAILURE = 0 /*< The operation failed. /
		} c448_error_t;

		/* Return success if x is true */
		static ossl_inline decaf_error_t decaf_succeed_if(decaf_bool_t x)
		static ossl_inline c448_error_t c448_succeed_if(c448_bool_t x)
		{
		return (decaf_error_t) x;
		return (c448_error_t) x;
		}

		#ifdef __cplusplus
		} /* extern "C" */
		#endif

		#endif /* __DECAF_COMMON_H__ */
		#endif /* __C448_COMMON_H__ */

crypto/ec/curve448/ed448.h

+40 −41

Original line number	Diff line number	Diff line
		@@ -10,8 +10,8 @@
		* Originally written by Mike Hamburg
		*/

		#ifndef __DECAF_ED448_H__
		# define __DECAF_ED448_H__ 1
		#ifndef __C448_ED448_H__
		# define __C448_ED448_H__ 1

		# include "point_448.h"

		@@ -20,20 +20,20 @@ extern "C" {
		#endif

		/* Number of bytes in an EdDSA public key. */
		# define DECAF_EDDSA_448_PUBLIC_BYTES 57
		# define C448_EDDSA_448_PUBLIC_BYTES 57

		/* Number of bytes in an EdDSA private key. */
		# define DECAF_EDDSA_448_PRIVATE_BYTES DECAF_EDDSA_448_PUBLIC_BYTES
		# define C448_EDDSA_448_PRIVATE_BYTES C448_EDDSA_448_PUBLIC_BYTES

		/* Number of bytes in an EdDSA private key. */
		# define DECAF_EDDSA_448_SIGNATURE_BYTES (DECAF_EDDSA_448_PUBLIC_BYTES + \
		DECAF_EDDSA_448_PRIVATE_BYTES)
		# define C448_EDDSA_448_SIGNATURE_BYTES (C448_EDDSA_448_PUBLIC_BYTES + \
		C448_EDDSA_448_PRIVATE_BYTES)

		/* EdDSA encoding ratio. */
		# define DECAF_448_EDDSA_ENCODE_RATIO 4
		# define C448_448_EDDSA_ENCODE_RATIO 4

		/* EdDSA decoding ratio. */
		# define DECAF_448_EDDSA_DECODE_RATIO (4 / 4)
		# define C448_448_EDDSA_DECODE_RATIO (4 / 4)

		/*
		* EdDSA key generation. This function uses a different (non-Decaf) encoding.
		@@ -41,9 +41,9 @@ extern "C" {
		* pubkey (out): The public key.
		* privkey (in): The private key.
		*/
		decaf_error_t decaf_ed448_derive_public_key(
		uint8_t pubkey [DECAF_EDDSA_448_PUBLIC_BYTES],
		const uint8_t privkey [DECAF_EDDSA_448_PRIVATE_BYTES]);
		c448_error_t c448_ed448_derive_public_key(
		uint8_t pubkey [C448_EDDSA_448_PUBLIC_BYTES],
		const uint8_t privkey [C448_EDDSA_448_PRIVATE_BYTES]);

		/*
		* EdDSA signing.
		@@ -63,10 +63,10 @@ decaf_error_t decaf_ed448_derive_public_key(
		* disambiguation. For Ed448 it is safe. The C++ wrapper is designed to make
		* it harder to screw this up, but this C code gives you no seat belt.
		*/
		decaf_error_t decaf_ed448_sign(
		uint8_t signature[DECAF_EDDSA_448_SIGNATURE_BYTES],
		const uint8_t privkey[DECAF_EDDSA_448_PRIVATE_BYTES],
		const uint8_t pubkey[DECAF_EDDSA_448_PUBLIC_BYTES],
		c448_error_t c448_ed448_sign(
		uint8_t signature[C448_EDDSA_448_SIGNATURE_BYTES],
		const uint8_t privkey[C448_EDDSA_448_PRIVATE_BYTES],
		const uint8_t pubkey[C448_EDDSA_448_PUBLIC_BYTES],
		const uint8_t *message, size_t message_len,
		uint8_t prehashed, const uint8_t *context,
		size_t context_len)
		@@ -89,10 +89,10 @@ decaf_error_t decaf_ed448_sign(
		* disambiguation. For Ed448 it is safe. The C++ wrapper is designed to make
		* it harder to screw this up, but this C code gives you no seat belt.
		*/
		decaf_error_t decaf_ed448_sign_prehash(
		uint8_t signature[DECAF_EDDSA_448_SIGNATURE_BYTES],
		const uint8_t privkey[DECAF_EDDSA_448_PRIVATE_BYTES],
		const uint8_t pubkey[DECAF_EDDSA_448_PUBLIC_BYTES],
		c448_error_t c448_ed448_sign_prehash(
		uint8_t signature[C448_EDDSA_448_SIGNATURE_BYTES],
		const uint8_t privkey[C448_EDDSA_448_PRIVATE_BYTES],
		const uint8_t pubkey[C448_EDDSA_448_PUBLIC_BYTES],
		const uint8_t hash[64],
		const uint8_t *context,
		size_t context_len)
		@@ -117,10 +117,10 @@ decaf_error_t decaf_ed448_sign_prehash(
		* disambiguation. For Ed448 it is safe. The C++ wrapper is designed to make
		* it harder to screw this up, but this C code gives you no seat belt.
		*/
		decaf_error_t decaf_ed448_verify(const uint8_t
		signature[DECAF_EDDSA_448_SIGNATURE_BYTES],
		c448_error_t c448_ed448_verify(const uint8_t
		signature[C448_EDDSA_448_SIGNATURE_BYTES],
		const uint8_t
		pubkey[DECAF_EDDSA_448_PUBLIC_BYTES],
		pubkey[C448_EDDSA_448_PUBLIC_BYTES],
		const uint8_t *message, size_t message_len,
		uint8_t prehashed, const uint8_t *context,
		uint8_t context_len)
		@@ -144,9 +144,9 @@ decaf_error_t decaf_ed448_verify(const uint8_t
		* disambiguation. For Ed448 it is safe. The C++ wrapper is designed to make
		* it harder to screw this up, but this C code gives you no seat belt.
		*/
		decaf_error_t decaf_ed448_verify_prehash(
		const uint8_t signature[DECAF_EDDSA_448_SIGNATURE_BYTES],
		const uint8_t pubkey[DECAF_EDDSA_448_PUBLIC_BYTES],
		c448_error_t c448_ed448_verify_prehash(
		const uint8_t signature[C448_EDDSA_448_SIGNATURE_BYTES],
		const uint8_t pubkey[C448_EDDSA_448_PUBLIC_BYTES],
		const uint8_t hash[64],
		const uint8_t *context,
		uint8_t context_len)
		@@ -154,7 +154,7 @@ decaf_error_t decaf_ed448_verify_prehash(

		/*
		* EdDSA point encoding. Used internally, exposed externally.
		* Multiplies by DECAF_448_EDDSA_ENCODE_RATIO first.
		* Multiplies by C448_448_EDDSA_ENCODE_RATIO first.
		*
		* The multiplication is required because the EdDSA encoding represents
		* the cofactor information, but the Decaf encoding ignores it (which
		@@ -162,26 +162,25 @@ decaf_error_t decaf_ed448_verify_prehash(
		* EdDSA, the cofactor info must get cleared, because the intermediate
		* representation doesn't track it.
		*
		* The way libdecaf handles this is to multiply by
		* DECAF_448_EDDSA_DECODE_RATIO when decoding, and by
		* DECAF_448_EDDSA_ENCODE_RATIO when encoding. The product of these
		* ratios is always exactly the cofactor 4, so the cofactor
		* ends up cleared one way or another. But exactly how that shakes
		* out depends on the base points specified in RFC 8032.
		* The way we handle this is to multiply by C448_448_EDDSA_DECODE_RATIO when
		* decoding, and by C448_448_EDDSA_ENCODE_RATIO when encoding. The product of
		* these ratios is always exactly the cofactor 4, so the cofactor ends up
		* cleared one way or another. But exactly how that shakes out depends on the
		* base points specified in RFC 8032.
		*
		* The upshot is that if you pass the Decaf/Ristretto base point to
		* this function, you will get DECAF_448_EDDSA_ENCODE_RATIO times the
		* this function, you will get C448_448_EDDSA_ENCODE_RATIO times the
		* EdDSA base point.
		*
		* enc (out): The encoded point.
		* p (in): The point.
		*/
		void curve448_point_mul_by_ratio_and_encode_like_eddsa(
		uint8_t enc [DECAF_EDDSA_448_PUBLIC_BYTES],
		uint8_t enc [C448_EDDSA_448_PUBLIC_BYTES],
		const curve448_point_t p);

		/*
		* EdDSA point decoding. Multiplies by DECAF_448_EDDSA_DECODE_RATIO, and
		* EdDSA point decoding. Multiplies by C448_448_EDDSA_DECODE_RATIO, and
		* ignores cofactor information.
		*
		* See notes on curve448_point_mul_by_ratio_and_encode_like_eddsa
		@@ -189,9 +188,9 @@ void curve448_point_mul_by_ratio_and_encode_like_eddsa(
		* enc (out): The encoded point.
		* p (in): The point.
		*/
		decaf_error_t curve448_point_decode_like_eddsa_and_mul_by_ratio(
		c448_error_t curve448_point_decode_like_eddsa_and_mul_by_ratio(
		curve448_point_t p,
		const uint8_t enc[DECAF_EDDSA_448_PUBLIC_BYTES]);
		const uint8_t enc[C448_EDDSA_448_PUBLIC_BYTES]);

		/*
		* EdDSA to ECDH private key conversion
		@@ -201,12 +200,12 @@ decaf_error_t curve448_point_decode_like_eddsa_and_mul_by_ratio(
		* x (out): The ECDH private key as in RFC7748
		* ed (in): The EdDSA private key
		*/
		decaf_error_t decaf_ed448_convert_private_key_to_x448(
		uint8_t x[DECAF_X448_PRIVATE_BYTES],
		const uint8_t ed[DECAF_EDDSA_448_PRIVATE_BYTES]);
		c448_error_t c448_ed448_convert_private_key_to_x448(
		uint8_t x[C448_X448_PRIVATE_BYTES],
		const uint8_t ed[C448_EDDSA_448_PRIVATE_BYTES]);

		#ifdef __cplusplus
		} /* extern "C" */
		#endif

		#endif /* __DECAF_ED448_H__ */
		#endif /* __C448_ED448_H__ */

crypto/ec/curve448/eddsa.c

+90 −97

File changed.

Preview size limit exceeded, changes collapsed.