primeec.h

Go to the documentation of this file.

/*
 * primeec.h
 *
 * Finite Field Elliptic Curve Header
 *
 * Copyright 2019-2024 DigiCert, Inc. All Rights Reserved.
 * Proprietary and Confidential Material.
 *
 */

/*------------------------------------------------------------------*/

#ifndef __PRIMEEC_HEADER__
#define __PRIMEEC_HEADER__

#include "../cap/capdecl.h"
#include "../crypto/cryptodecl.h"

#ifdef __cplusplus
extern "C" {
#endif

/* Support for Finite Field Elliptic Curve Operations */

/* Default flag passed into ECDH generate shared secret. This will return the X
 * value back to the caller.
 */
#define ECDH_X_CORD_ONLY 1

/* Pass this into ECDH generate shared secret to get the X and Y back.
 */
#define ECDH_XY_CORD 0

typedef struct ECCKey
{
    intBoolean          privateKey;
    PFEPtr              Qx;         /* public */
    PFEPtr              Qy;         /* public */
    PFEPtr              k;          /* private*/
    PEllipticCurvePtr   pCurve;     /* curve */
    MocAsymKey pPrivateKey;
    MocAsymKey pPublicKey;
    ubyte4 curveIndex;
    ubyte4 enabled;
    ubyte4 curveId;
    void *pEdECCKey;

} ECCKey;

/* Forward declaration */
typedef struct MEccKeyTemplate *MEccKeyTemplatePtr;

#if (defined(__ENABLE_MOCANA_ECC__))

#ifdef MOC_EXTERN_PRIMEEC_H
#undef MOC_EXTERN_PRIMEEC_H
#endif /* MOC_EXTERN_PRIMEEC_H */

/* For non OpenSSL builds macro the old API into the new API for backwards
 * compatability. OpenSSL builds cannot define this macro as there are namespace
 * issues with the old APIs. */
#ifndef OPENSSL_ENGINE
#ifndef ECDSA_sign
#define ECDSA_sign ECDSA_signDigestAux
#endif /* ECDSA_sign */
#endif /* OPENSSL_ENGINE */

#ifdef __RTOS_WIN32__

#ifdef WIN_EXPORT_PRIMEEC_H
#define MOC_EXTERN_PRIMEEC_H __declspec(dllexport)
#else
#define MOC_EXTERN_PRIMEEC_H __declspec(dllimport) extern 
#endif /* WIN_EXPORT_PRIMEEC_H */

#ifdef WIN_STATIC
#undef MOC_EXTERN_PRIMEEC_H
#define MOC_EXTERN_PRIMEEC_H extern
#endif /* WIN_STATIC */

#else

#define MOC_EXTERN_PRIMEEC_H MOC_EXTERN

#endif /* RTOS_WIN32 */

#ifdef MOC_EXTERN_P
#undef MOC_EXTERN_P
#endif /* MOC_EXTERN_P */

#define MOC_EXTERN_P MOC_EXTERN_PRIMEEC_H

/* NIST curves */
#ifndef __ENABLE_MOCANA_ECC_P192__
#define NUM_EC_P192 (0)
#else
#define NUM_EC_P192 (1)
MOC_EXTERN_PRIMEEC_H const PEllipticCurvePtr EC_P192;
#endif

#ifdef __DISABLE_MOCANA_ECC_P224__
#define NUM_EC_P224 (0)
#else
#define NUM_EC_P224 (1)
MOC_EXTERN_PRIMEEC_H const PEllipticCurvePtr EC_P224;
#endif

#ifdef __DISABLE_MOCANA_ECC_P256__
#define NUM_EC_P256 (0)
#else
#define NUM_EC_P256 (1)
MOC_EXTERN_PRIMEEC_H const PEllipticCurvePtr EC_P256;
#endif

#ifdef __DISABLE_MOCANA_ECC_P384__
#define NUM_EC_P384 (0)
#else
#define NUM_EC_P384 (1)
MOC_EXTERN_PRIMEEC_H const PEllipticCurvePtr EC_P384;
#endif

#ifdef __DISABLE_MOCANA_ECC_P521__
#define NUM_EC_P521 (0)
#else
#define NUM_EC_P521 (1)
MOC_EXTERN_PRIMEEC_H const PEllipticCurvePtr EC_P521;
#endif

#define NUM_ECC_PCURVES    ((NUM_EC_P192) + (NUM_EC_P224) + (NUM_EC_P256) + \
                                        (NUM_EC_P384) + (NUM_EC_P521))


MOC_EXTERN PrimeFieldPtr EC_getUnderlyingField(PEllipticCurvePtr pEC);

MOC_EXTERN MSTATUS EC_multiplyPoint(PrimeFieldPtr pPF, PFEPtr pResX, PFEPtr pResY,
                                    ConstPFEPtr k, ConstPFEPtr pX, ConstPFEPtr pY);

MOC_EXTERN MSTATUS EC_addMultiplyPoint(PrimeFieldPtr pPF, PFEPtr pResX, PFEPtr pResY,
                                        ConstPFEPtr pAddedX, ConstPFEPtr pAddedY,
                                        ConstPFEPtr k, ConstPFEPtr pX, ConstPFEPtr pY);

MOC_EXTERN MSTATUS EC_computeYFromX( PEllipticCurvePtr pEC, ConstPFEPtr x, PFEPtr y);

MOC_EXTERN MSTATUS EC_newKey(PEllipticCurvePtr pEC, ECCKey** ppNewKey);

MOC_EXTERN MSTATUS EC_deleteKey(ECCKey** ppKey);

MOC_EXTERN MSTATUS EC_cloneKey(ECCKey** ppNew, const ECCKey* pSrc);

MOC_EXTERN MSTATUS EC_equalKey(const ECCKey* pKey1, const ECCKey* pKey2, byteBoolean* res);

MOC_EXTERN MSTATUS EC_setKeyParameters(ECCKey* pKey, const ubyte* point, ubyte4 pointLen,
                                       const ubyte* scalar, ubyte4 scalarLen);

MOC_EXTERN MSTATUS EC_setPrivateKey( ECCKey *pKey, ubyte *pScalar, ubyte4 scalarLen);

MOC_EXTERN intBoolean EC_compareEllipticCurves(PEllipticCurvePtr pEC1,
                                               PEllipticCurvePtr pEC2);

MOC_EXTERN MSTATUS EC_verifyKeyPair(PEllipticCurvePtr pEC, ConstPFEPtr k,
                                    ConstPFEPtr pQx, ConstPFEPtr pQy);

MOC_EXTERN MSTATUS EC_generateKeyPair(PEllipticCurvePtr pEC, RNGFun rngFun, void* rngArg,
                                      PFEPtr k, PFEPtr pQx, PFEPtr pQy);

MOC_EXTERN MSTATUS EC_verifyPublicKey(PEllipticCurvePtr pEC, ConstPFEPtr pQx, ConstPFEPtr pQy);

MOC_EXTERN MSTATUS EC_verifyPoint(PEllipticCurvePtr pEC, ConstPFEPtr pQx, ConstPFEPtr pQy);

MOC_EXTERN MSTATUS EC_pointToByteString(PEllipticCurvePtr pEC,
                                        ConstPFEPtr pX, ConstPFEPtr pY,
                                        ubyte** s, sbyte4* pLen);

MOC_EXTERN MSTATUS EC_setPointToByteString(PEllipticCurvePtr pEC,
                                           const ubyte* s, sbyte4 len,
                                           PFEPtr pX, PFEPtr pY);

MOC_EXTERN MSTATUS EC_getPointByteStringLen(PEllipticCurvePtr pEC, sbyte4 *pLen);

MOC_EXTERN MSTATUS EC_writePointToBuffer(PEllipticCurvePtr pEC,
                                         ConstPFEPtr pX, ConstPFEPtr pY,
                                         ubyte* s, sbyte4 len);

MOC_EXTERN MSTATUS EC_byteStringToPoint(PEllipticCurvePtr pEC,
                                        const ubyte* s, sbyte4 len,
                                        PFEPtr* ppX, PFEPtr* ppY);

MOC_EXTERN MSTATUS ECDSA_signDigestAux(PEllipticCurvePtr pEC, ConstPFEPtr d,
                              RNGFun rngFun, void* rngArg,
                              const ubyte* hash, ubyte4 hashLen,
                              PFEPtr r, PFEPtr s);

MOC_EXTERN MSTATUS ECDSA_verifySignature(PEllipticCurvePtr pEC,
                                         ConstPFEPtr pPublicKeyX, ConstPFEPtr pPublicKeyY,
                                         const ubyte* hash, ubyte4 hashLen,
                                         ConstPFEPtr r, ConstPFEPtr s);

MOC_EXTERN MSTATUS ECDH_generateSharedSecretAux(PEllipticCurvePtr pEC,
                                                ConstPFEPtr pX, ConstPFEPtr pY,
                                                ConstPFEPtr scalarMultiplier,
                                                ubyte** sharedSecret,
                                                sbyte4* sharedSecretLen,
                                                sbyte4 flag);

MOC_EXTERN MSTATUS ECDH_generateSharedSecret(PEllipticCurvePtr pEC,
                                             const ubyte* pointByteString,
                                             sbyte4 pointByteStringLen,
                                             ConstPFEPtr scalarMultiplier,
                                             ubyte** sharedSecret,
                                             sbyte4* sharedSecretLen);


/* mode macros for DH Key Agreement Schemes */
#define FULL_UNIFIED       0
#define FULL_MQV           1
#define EPHEMERAL_UNIFIED  2
#define ONE_PASS_UNIFIED_U 3
#define ONE_PASS_UNIFIED_V 4
#define ONE_PASS_MQV_U     5
#define ONE_PASS_MQV_V     6
#define ONE_PASS_DH_U      7
#define ONE_PASS_DH_V      8
#define STATIC_UNIFIED     9

MOC_EXTERN MSTATUS ECDH_keyAgreementSchemePrimeCurve(
    ubyte4 mode, 
    ECCKey *pStatic, 
    ECCKey *pEphemeral, 
    ubyte *pOtherPartysStatic, 
    ubyte4 otherStaticLen,
    ubyte *pOtherPartysEphemeral,
    ubyte4 otherEphemeralLen,
    ubyte **ppSharedSecret,
    ubyte4 *pSharedSecretLen);

#if defined(__ENABLE_MOCANA_ECC_COMB__) || !defined( __ENABLE_MOCANA_SMALL_CODE_FOOTPRINT__)

MOC_EXTERN MSTATUS EC_combSize( PrimeFieldPtr pPF, sbyte4 windowSize, sbyte4* size);

MOC_EXTERN MSTATUS EC_precomputeComb(PrimeFieldPtr pPF, ConstPFEPtr pQx,
                                     ConstPFEPtr pQy, sbyte4 windowSize,
                                     PFEPtr* pPrecomputed);

MOC_EXTERN MSTATUS EC_precomputeCombOfCurve(PEllipticCurvePtr pEC, sbyte4 windowSize,
                                            PFEPtr* pCurvePrecomputed);

MOC_EXTERN MSTATUS EC_deleteComb(PrimeFieldPtr pPF, sbyte4 windowSize, PFEPtr *pComb);

#endif /* __ENABLE_MOCANA_ECC_COMB__ !__ENABLE_MOCANA_SMALL_CODE_FOOTPRINT__ */

#if !defined(__DISABLE_MOCANA_SIGNED_ODD_COMB__) && defined(__ENABLE_MOCANA_SIGNED_ODD_COMB_PERSIST__)

MOC_EXTERN MSTATUS EC_deletePrimeCurveCombsAndMutexes(void);

MOC_EXTERN MSTATUS EC_createPrimeCurveMutexes(void);
#endif

MOC_EXTERN MSTATUS ECDSA_verifySignatureEx(PEllipticCurvePtr pEC,
                                           ConstPFEPtr pPublicKeyX, ConstPFEPtr pPublicKeyY,
                                           const ubyte* hash, ubyte4 hashLen,
                                           sbyte4 curveWinSize, ConstPFEPtr pCurvePrecomp,
                                           sbyte4 pubKeyWinSize, ConstPFEPtr pPubKeyPrecomp,
                                           ConstPFEPtr r, ConstPFEPtr s);

#endif /* __ENABLE_MOCANA_ECC__  */

#ifdef __cplusplus
}
#endif

#endif /* __PRIMEEC_HEADER__ */