pubcrypto.h

Go to the documentation of this file.

/*
 * pubcrypto.h
 *
 * General Public Crypto Definitions & Types Header
 *
 * Copyright 2019-2024 DigiCert, Inc. All Rights Reserved.
 * Proprietary and Confidential Material.
 *
 */

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

#ifndef __PUBCRYPTO_HEADER__
#define __PUBCRYPTO_HEADER__

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

#ifdef __ENABLE_MOCANA_QS__
#include "../crypto_interface/crypto_interface_qs.h"
#endif

#ifdef __cplusplus
extern "C" {
#endif

#if (defined(__ENABLE_MOCANA_ECC__))
struct ECCKey;
struct PrimeEllipticCurve;
#endif

struct RSAKey;

#if (defined(__ENABLE_MOCANA_DSA__))
struct DSAKey;
#endif
struct AsymmetricKey;
struct vlong;
struct MAlgoId;

typedef struct AsymmetricKey
{
    ubyte4 type;
    union
    {
        struct RSAKey* pRSA;
#if (defined(__ENABLE_MOCANA_ECC__))
        struct ECCKey* pECC;
#endif
#if (defined(__ENABLE_MOCANA_DSA__))
        struct DSAKey* pDSA;
#endif
        struct MocAsymmetricKey *pMocAsymKey;
    } key;
    
    struct MAlgoId *pAlgoId;
    
#ifdef __ENABLE_MOCANA_QS__
    QS_CTX *pQsCtx;
#endif
    
} AsymmetricKey;

/* General structure that can be used to load two keys at once */
typedef struct HybridKey
{
    void *pKey1;
    void *pKey2;
    
} HybridKey;

MOC_EXTERN MSTATUS  CRYPTO_initAsymmetricKey(AsymmetricKey* pKey);

MOC_EXTERN MSTATUS  CRYPTO_uninitAsymmetricKey(AsymmetricKey* pKey, struct vlong** ppVlongQueue);

MOC_EXTERN MSTATUS  CRYPTO_copyAsymmetricKey(AsymmetricKey* pNew, const AsymmetricKey* pSrc);

MOC_EXTERN MSTATUS  CRYPTO_matchPublicKey(const AsymmetricKey* pKey1, const AsymmetricKey* pKey2);

#if (defined(__ENABLE_MOCANA_ECC__))

MOC_EXTERN ubyte4   CRYPTO_getECCurveId( const AsymmetricKey* pKey);
#endif

MOC_EXTERN MSTATUS  CRYPTO_createRSAKey( AsymmetricKey* pKey, struct vlong** ppVlongQueue);

MOC_EXTERN MSTATUS  CRYPTO_setRSAParameters(MOC_RSA(hwAccelDescr hwAccelCtx)
                                        AsymmetricKey* pKey,
                                        ubyte4 exponent,
                                        const ubyte* modulus,
                                        ubyte4 modulusLen,
                                        const ubyte* p,
                                        ubyte4 pLen,
                                        const ubyte* q,
                                        ubyte4 qLen,
                                        struct vlong **ppVlongQueue);
/* ECC key */
#if (defined(__ENABLE_MOCANA_ECC__))

MOC_EXTERN MSTATUS CRYPTO_createECCKey(
    AsymmetricKey* pKey,
    PEllipticCurvePtr pEC
    );

#ifdef __ENABLE_MOCANA_CRYPTO_INTERFACE__

MOC_EXTERN MSTATUS CRYPTO_createECCKeyEx(
    AsymmetricKey *pKey,
    ubyte4 eccCurveId
    );
#endif

MOC_EXTERN MSTATUS  CRYPTO_setECCParameters(MOC_ECC(hwAccelDescr hwAccelCtx) AsymmetricKey* pKey,
                                        ubyte4 curveId,
                                        const ubyte* point,
                                        ubyte4 pointLen,
                                        const ubyte* scalar,
                                        ubyte4 scalarLen);
    
    
#ifdef __ENABLE_MOCANA_QS__
    
    
MOC_EXTERN MSTATUS CRYPTO_setHybridParameters(
    AsymmetricKey *pKey,
    ubyte4 curveId,
    ubyte4 qsAlgId,
    ubyte *pPubKey,
    ubyte4 pubKeyLen
    );
#endif
    
#endif /* __ENABLE_MOCANA_ECC__ */

#if (defined(__ENABLE_MOCANA_DSA__))

MOC_EXTERN MSTATUS  CRYPTO_createDSAKey( AsymmetricKey* pKey, struct vlong** ppVlongQueue);

MOC_EXTERN MSTATUS  CRYPTO_setDSAParameters( MOC_DSA(hwAccelDescr hwAccelCtx) AsymmetricKey* pKey,
                                        const ubyte* p,
                                        ubyte4 pLen,
                                        const ubyte* q,
                                        ubyte4 qLen,
                                        const ubyte* g,
                                        ubyte4 gLen,
                                        const ubyte* y,
                                        ubyte4 yLen,
                                        const ubyte* x,
                                        ubyte4 xLen,
                                        struct vlong **ppVlongQueue);
#endif

/* To convert a key object to a single byte array (serialize), call
 * CRYPTO_serializeKey.
 * To convert the byte array version of the key to a key object (deserialize),
 * call CRYPTO_deserializeKey.
 * The serialize function takes an AsymmetricKey as a the key object to
 * serialize. However, you might not have the key in that form. It might be an
 * RSAKey, DSAKey, ECCKey, or MocAsymKey. To "convert" an "algorithm key" to an
 * AsymmetricKey, call CRYPTO_loadAsymmetricKey
 */

MOC_EXTERN MSTATUS CRYPTO_loadAsymmetricKey (
  AsymmetricKey *pAsymKey,
  ubyte4 keyType,
  void **ppAlgKey
  );

MOC_EXTERN MSTATUS CRYPTO_loadAlgoId (
  AsymmetricKey *pAsymKey,
  void **ppAlgoId
  );

typedef MSTATUS (*MKeySerialize) ( MOC_ASYM(hwAccelDescr hwAccelCtx)
  AsymmetricKey *, serializedKeyFormat, ubyte **, ubyte4 *);

MOC_EXTERN MSTATUS KeySerializeRsa ( MOC_ASYM(hwAccelDescr )
  AsymmetricKey *, serializedKeyFormat, ubyte **, ubyte4 *);

MOC_EXTERN MSTATUS KeySerializeDsa ( MOC_ASYM(hwAccelDescr )
  AsymmetricKey *, serializedKeyFormat, ubyte **, ubyte4 *);

MOC_EXTERN MSTATUS KeySerializeEcc ( MOC_ASYM(hwAccelDescr )
  AsymmetricKey *, serializedKeyFormat, ubyte **, ubyte4 *);

MOC_EXTERN MSTATUS KeySerializeQs (AsymmetricKey *, serializedKeyFormat, ubyte **, ubyte4 *);

MOC_EXTERN MSTATUS KeySerializeHybrid (AsymmetricKey *, serializedKeyFormat, ubyte **, ubyte4 *);

MOC_EXTERN MSTATUS KeySerializeTpmRsa (
  AsymmetricKey *, serializedKeyFormat, ubyte **, ubyte4 *);

MOC_EXTERN MSTATUS CRYPTO_serializeKey (
  MOC_ASYM(hwAccelDescr hwAccelCtx)
  AsymmetricKey  *pKeyToSerialize,
  MKeySerialize *pSupportedAlgorithms,
  ubyte4 supportedAlgorithmCount,
  serializedKeyFormat format,
  ubyte **ppSerializedKey,
  ubyte4 *pSerializedKeyLen
  );

MOC_EXTERN MSTATUS CRYPTO_deserializeKey (
  MOC_ASYM(hwAccelDescr hwAccelCtx)
  ubyte *pSerializedKey,
  ubyte4 serializedKeyLen,
  MKeySerialize *pSupportedAlgorithms,
  ubyte4 supportedAlgorithmCount,
  AsymmetricKey *pDeserializedKey
  );

MOC_EXTERN MSTATUS CRYPTO_serializeAsymKey (
  MOC_ASYM(hwAccelDescr hwAccelCtx)
  AsymmetricKey *pKeyToSerialize,
  serializedKeyFormat format,
  ubyte **ppSerializedKey,
  ubyte4 *pSerializedKeyLen
  );

MOC_EXTERN MSTATUS CRYPTO_getKeyTapInfo(
  ubyte *pKey,
  ubyte4 keyLen,
  MocCtx pMocCtx,
  byteBoolean *pIsTap,
  ubyte4 *pProvider,
  ubyte4 *pModuleId
);

MOC_EXTERN MSTATUS CRYPTO_serializeAsymKeyToStorage(
  MOC_ASYM(hwAccelDescr hwAccelCtx)
  AsymmetricKey *pKeyToSerialize,
  serializedKeyFormat format,
  ubyte *pId,
  ubyte4 idLen,
  ubyte4 tokenId,
  ubyte **ppSerializedKey,
  ubyte4 *pSerializedKeyLen
);

MOC_EXTERN MSTATUS CRYPTO_deserializeAsymKey (
  MOC_ASYM(hwAccelDescr hwAccelCtx)
  ubyte *pSerializedKey,
  ubyte4 serializedKeyLen,
  MocCtx pMocCtx,
  AsymmetricKey *pDeserializedKey
  );

MOC_EXTERN MSTATUS CRYPTO_deserializeAsymKeyWithCreds (
  MOC_ASYM(hwAccelDescr hwAccelCtx)
  ubyte *pSerializedKey,
  ubyte4 serializedKeyLen,
  MocCtx pMocCtx,
  ubyte *pPassword,
  ubyte4 passwordLen,
  void *pLoadCtx,
  AsymmetricKey *pDeserializedKey
  );

MOC_EXTERN MSTATUS CRYPTO_makeKeyInfo (
  intBoolean isPrivateKey,
  ubyte *pAlgId,
  ubyte4 algIdLen,
  ubyte *pKeyData,
  ubyte4 keyDataLen,
  ubyte **ppKeyInfo,
  ubyte4 *pKeyInfoLen
  );

MOC_EXTERN MSTATUS CRYPTO_findKeyInfoComponents (
  ubyte *pKeyInfo,
  ubyte4 keyInfoLen,
  ubyte **ppAlgId,
  ubyte4 *pAlgIdLen,
  ubyte **ppKeyData,
  ubyte4 *pKeyDataLen,
  intBoolean *isPrivate
  );

/* This is the definiton (function signature) of a callback used when loading
* keys into an AsymmetricKey object.
* <p>A user will be calling a function (e.g. an OpenSSL engine written by
* Mocana) with key data to load. The loading function will know how to perform
* some of the operations needed to load the key, but it is possible the key data
* represents a hardware key or some other non-standard situation. In that case,
* the caller will supply a callback to perform initialization operations (such
* creating or copying a hardware handle).
* <p>This is the interface for the Callback.
* <p>The caller passes in a data struct containing the Callback function along
* with any information the function will need to perform its operations. That
* pLocalData can be NULL, or it might be a hardware handle, or it could be a
* struct itself, containing hardware info or maybe key usage data or whatever
* the key needs.
* <p>The called function will make a call to the Callback, passing the
* pLocalData it was given back to the callback.
* <p>For example, the caller might do something like this.
* <pre>
* <code>
*   MKeyContextCallbackInfo callbackInfo;
*
*   callbackInfo.KeyContextCallback = TPMCallback;
*   callbackInfo.pLocalInfo = (void *)secModHandle;
*
*   status = SomeLoadFunction (
*     data, dataLen, pAsymKey, (void *)&callbackInfo);
* </code>
* </pre>
* <p>The Load function will do something like this.
* <pre>
* <code>
*
*    --load key data operations--
*
*   if (NULL != pCallbackInfo)
*   {
*     if (NULL != pCallbackInfo->KeyContextCallback)
*     {
*       status = pCallbackInfo->KeyContextCallback (
*         pAsymKey, pCallbackInfo->pLocalInfo, state);
*       if (OK != state)
*         goto exit;
*     }
*   }
*
*    --more load key data operations--
*
* </code>
* </pre>
* <p>The state is ???
*/
typedef MSTATUS (*MKeyContextCallback) (
  AsymmetricKey *pAsymKey,
  void *pLocalInfo,
  ubyte4 state
  );

/* This is a struct containing the Callback information to pass to a Load
 * function.
 * <p>See the comments for the definition of the function pointer
 * KeyContextCallback.
 */
typedef struct
{
  MKeyContextCallback   KeyContextCallback;
  void                 *pLocalData;
} MKeyContextCallbackInfo;


#ifdef __cplusplus
}
#endif
/* For backwards compatibility.
 * In previous versions of NanoCrypto, the definitions in mocasym.h were in
 * pubcrypto.h. So if someone includes pubcrypto.h expecting to get the MocAsymKey
 * definitions, they'll get them here.
 */
#include "../crypto/mocasym.h"

#endif /* __PUBCRYPTO_HEADER__ */