moccms.h

Go to the documentation of this file.

/*
 * moccms.h
 *
 * Declarations and definitions for the Digicert CMS handling
 *
 * Copyright 2019-2024 DigiCert, Inc. All Rights Reserved.
 * Proprietary and Confidential Material.
 *
 */

#ifndef __MOCANA_CMS_HEADER__
#define __MOCANA_CMS_HEADER__

#ifdef __cplusplus
extern "C" {
#endif

typedef enum MOC_CMS_ContentType
{
    E_MOC_CMS_ct_undetermined = 0,
    E_MOC_CMS_ct_data = 1,
    E_MOC_CMS_ct_signedData = 2,
    E_MOC_CMS_ct_envelopedData = 3,
    E_MOC_CMS_ct_signedAndEnvelopedData = 4,
    E_MOC_CMS_ct_digestedData = 5,
    E_MOC_CMS_ct_encryptedData = 6,
    E_MOC_CMS_ct_authData = 102,
    E_MOC_CMS_ct_invalid = 999,
} MOC_CMS_ContentType;

typedef enum MOC_CMS_UpdateType
{
   E_MOC_CMS_ut_invalid = 0,
   E_MOC_CMS_ut_update = 1,
   E_MOC_CMS_ut_final = 2,
   E_MOC_CMS_ut_result = 3,
} MOC_CMS_UpdateType;

typedef enum MOC_CMS_action
{
    E_MOC_CMS_sa_none = 0,
    E_MOC_CMS_sa_addCert = 1,
} MOC_CMS_action;

typedef sbyte4 MOC_CMS_signerID;

/* The value to identify 'all' signers */
#define MOC_CMS_signerID_ALL (-1)

typedef struct MOC_CMS_IssuerSerialNumber
{
   ubyte* pIssuer;
   ubyte4 issuerLen;
   ubyte* pSerialNumber;
   ubyte4 serialNumberLen;
} MOC_CMS_IssuerSerialNumber;

typedef struct MOC_CMS_OriginatorPublicKey
{
    ubyte* pAlgoOID;
    ubyte4 algoOIDLen;
    ubyte* pAlgoParameters;
    ubyte4 algoParametersLen;
    ubyte* pPublicKey;
    ubyte4 publicKeyLen;
} MOC_CMS_OriginatorPublicKey;

typedef struct MOC_CMS_SubjectKeyIdentifier
{
    ubyte* pIdentifier;
    ubyte4 identifierLen;
} MOC_CMS_SubjectKeyIdentifier;

typedef struct MOC_CMS_KeyTransRecipientId
{
    ubyte4 type;
    union
    {
        MOC_CMS_IssuerSerialNumber   issuerAndSerialNumber; /* type = NO_TAG */
        MOC_CMS_SubjectKeyIdentifier subjectKeyIdentifier;  /* type = 0 OCTETSTRING */
    } u;
} MOC_CMS_KeyTransRecipientId;

typedef struct MOC_CMS_KeyAgreeRecipientId
{
    ubyte4 type;
    union
    {
        MOC_CMS_IssuerSerialNumber   issuerAndSerialNumber;  /* type = NO_TAG */
        MOC_CMS_SubjectKeyIdentifier subjectKeyIdentifier;   /* type = 0 OCTETSTRING */
        MOC_CMS_OriginatorPublicKey  originatorKey;          /* type = 1 */
    } u;
} MOC_CMS_KeyAgreeRecipientId;

typedef struct MOC_CMS_RecipientId
{
    ubyte4 type;
    union
    {
        MOC_CMS_KeyTransRecipientId    ktrid;   /* type = NO_TAG */
        MOC_CMS_KeyAgreeRecipientId    karid;   /* type = 1 */
#if 0
        MOC_CMS_KEKRecipientId         kekrid;  /* type = 2 */
        MOC_CMS_PasswordRecipientId    pwrdi;   /* type = 3 */
        MOC_CMS_OtherRecipientId       orid;    /* type = 4 */
#endif
    } ri;
} MOC_CMS_RecipientId;

typedef struct MOC_CMS_MsgSignInfo
{
    ubyte*      pASN1;
    ubyte4      ASN1Len;
    ubyte*      pMsgSigDigest;
    ubyte4      msgSigDigestLen;
    intBoolean  verifies;
    TimeDate*   pSigningTime;
} MOC_CMS_MsgSignInfo;

/* Recipient id tag value used to represent that the CMS id data was not tagged. */
#define NO_TAG (0xFFFFFFFF)

typedef void* MOC_CMS_context;

typedef MSTATUS (*MOC_CMS_GetPrivateKey)(const void* arg,
                                         ubyte* pSerialNumber,
                                         ubyte4 serialNumberLen,
                                         ubyte* pIssuer,
                                         ubyte4 issuerLen,
                                         struct AsymmetricKey* pKey);

typedef MSTATUS (*MOC_CMS_GetPrivateKeyEx)(const void* arg,
                                           const MOC_CMS_RecipientId* pRecipientId,
                                           struct AsymmetricKey* pKey);

typedef MSTATUS (*MOC_CMS_ValidateRootCertificate)(const void* arg,
                                                   ubyte* pCertificate,
                                                   ubyte4 certificateLen,
                                                   MOC_CMS_MsgSignInfo *pSigInfo);

typedef MSTATUS (*MOC_CMS_GetCertificate)(const void* arg,
                                          ubyte* pSerialNumber,
                                          ubyte4 serialNumberLen,
                                          ubyte* pIssuer,
                                          ubyte4 issuerLen,
                                          ubyte** ppCertificate,
                                          ubyte4* pCertificateLen);

typedef MSTATUS (*MOC_CMS_UpdateData)(const void* arg,
                                      MOC_CMS_context pCtx,
                                      MOC_CMS_UpdateType type,
                                      ubyte* pBuf,
                                      ubyte4 bufLen);

typedef struct MOC_CMS_Callbacks
{
    MOC_CMS_GetPrivateKey             getPrivKeyFun;
    MOC_CMS_GetPrivateKeyEx           getPrivKeyFunEx;
    MOC_CMS_ValidateRootCertificate   valCertFun;
    MOC_CMS_GetCertificate            getCertFun;
    MOC_CMS_UpdateData                dataUpdateFun;
} MOC_CMS_Callbacks;

MOC_EXTERN MSTATUS MOC_CMS_newContext (MOC_CMS_context* pNewContext,
                                       const void* callbackArg,
                                       const MOC_CMS_Callbacks* pCallbacks);

MOC_EXTERN MSTATUS MOC_CMS_newContextOut (MOC_CMS_context *pNewContext,
                                          MOC_CMS_ContentType type,
                                          RNGFun rngFun,
                                          void *rngFunArg,
                                          intBoolean isStreaming,
                                          const void *callbackArg,
                                          MOC_CMS_UpdateData dataUpdateFun);

MOC_EXTERN MSTATUS MOC_CMS_updateContext (MOC_CMS_context context,
                                          const ubyte* input,
                                          ubyte4 inputLen,
                                          intBoolean* pFinished);

MOC_EXTERN MSTATUS MOC_CMS_updateContextOut (MOC_CMS_context context,
                                             const ubyte* output,
                                             ubyte4 outputLen,
                                             intBoolean last);

MOC_EXTERN MSTATUS MOC_CMS_finalizeContextOut (MOC_CMS_context context);

MOC_EXTERN MSTATUS MOC_CMS_deleteContext (MOC_CMS_context* pContext);

MOC_EXTERN MSTATUS MOC_CMS_getContentType (MOC_CMS_context context,
                                           MOC_CMS_ContentType* cmsContentType);

MOC_EXTERN MSTATUS MOC_CMS_getCallbacks (MOC_CMS_context context,
                                         MOC_CMS_Callbacks* pCB);

MOC_EXTERN MSTATUS MOC_CMS_getNumRecipients (MOC_CMS_context context,
                                             sbyte4* pNumRecipients);

MOC_EXTERN MSTATUS MOC_CMS_getRecipientId (MOC_CMS_context context,
                                           sbyte4 idxRecipient,
                                           MOC_CMS_RecipientId* pRecipient);

MOC_EXTERN MSTATUS MOC_CMS_deleteRecipientId (MOC_CMS_RecipientId* pRecipient);

MOC_EXTERN MSTATUS MOC_CMS_getNumSigners (MOC_CMS_context context,
                                          sbyte4* pNumSigners);

MOC_EXTERN MSTATUS MOC_CMS_getSignerInfo (MOC_CMS_context context,
                                          sbyte4 idxSigner,
                                          MOC_CMS_MsgSignInfo* pSigner);

MOC_EXTERN MSTATUS MOC_CMS_getNumSignatures (MOC_CMS_context context,
                                             sbyte4* pNumSigs);

MOC_EXTERN MSTATUS MOC_CMS_deleteSignerInfo (MOC_CMS_MsgSignInfo* pSigner);

MOC_EXTERN MSTATUS MOC_CMS_getCertificates (MOC_CMS_context context,
                                            const ubyte **ppCerts,
                                            ubyte4 *pCertLen);

MOC_EXTERN MSTATUS MOC_CMS_getCRLs (MOC_CMS_context context,
                                    const ubyte **ppCRLs,
                                    ubyte4 *pCRLsLen);

MOC_EXTERN MSTATUS MOC_CMS_getNumDigests (MOC_CMS_context context,
                                          ubyte4* pNumDigests);

MOC_EXTERN MSTATUS MOC_CMS_getDigestID (MOC_CMS_context context,
                                        ubyte4 idx,
                                        const ubyte** pDigestAlgoOID);

MOC_EXTERN MSTATUS MOC_CMS_setPayloadLength (MOC_CMS_context context,
                                             ubyte4 len);

MOC_EXTERN MSTATUS MOC_CMS_addSigner (MOC_CMS_context context,
                                      ubyte* pCert,
                                      ubyte4 certLen,
                                      const AsymmetricKey* pKey,
                                      const ubyte* pDigestAlgoOID,
                                      ubyte4 digestAlgoOIDLen,
                                      MOC_CMS_action action,
                                      MOC_CMS_signerID *pSignID);

MOC_EXTERN MSTATUS MOC_CMS_addSignerAttribute (MOC_CMS_context context,
                                               MOC_CMS_signerID signId,
                                               const ubyte* idOID,
                                               ubyte4 oidLen,
                                               ubyte4 typeID,
                                               const ubyte* value,
                                               ubyte4 valueLen,
                                               intBoolean authenticated);

MOC_EXTERN MSTATUS MOC_CMS_addCertificate (MOC_CMS_context context,
                                           ubyte* pCert,
                                           ubyte4 certLen);

MOC_EXTERN MSTATUS MOC_CMS_addCRL (MOC_CMS_context context,
                                   ubyte* pCRL,
                                   ubyte4 CRLLen);

MOC_EXTERN MSTATUS MOC_CMS_addSignatureRaw (MOC_CMS_context context,
                                            const ubyte* pSig,
                                            ubyte4 sigLen);

MOC_EXTERN MSTATUS MOC_CMS_addDigest (MOC_CMS_context context,
                                      const ubyte* digestAlgoOID,
                                      ubyte4 digestAlgoOIDLen);

MOC_EXTERN MSTATUS MOC_CMS_setEncryption (MOC_CMS_context context,
                                          const ubyte* encryptAlgoOID,
                                          ubyte4       encryptAlgoOIDLen,
                                          RNGFun rngFun,
                                          void* rngFunArg);

MOC_EXTERN MSTATUS MOC_CMS_addRecipient (MOC_CMS_context context,
                                         const ubyte* pCert,
                                         ubyte4 certLen);

MOC_EXTERN MSTATUS MOC_CMS_addUnprotectedAttribute (MOC_CMS_context context,
                                                    const ubyte* idOID,
                                                    ubyte4 oidLen,
                                                    ubyte4 typeID,
                                                    const ubyte* value,
                                                    ubyte4 valueLen);

#ifdef __cplusplus
}
#endif

#endif  /* __MOCANA_CMS_HEADER__ */