crypt_types.h

/*
 * This file is part of the openHiTLS project.
 *
 * openHiTLS is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
 * You may obtain a copy of Mulan PSL v2 at:
 *
 *     http://license.coscl.org.cn/MulanPSL2
 *
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 * See the Mulan PSL v2 for more details.
 */

 
#ifndef CRYPT_TYPES_H
#define CRYPT_TYPES_H
 
#include <stdint.h>
#include <stddef.h>
#include "crypt_algid.h"
 
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus

typedef struct {
    uint8_t *data; 
    uint32_t len; 
} CRYPT_Data;

typedef struct {
    const uint8_t *data;
    uint32_t len;
} CRYPT_ConstData;

typedef struct {
    uint32_t min; 
    uint32_t max; 
} CRYPT_Range;

typedef struct {
    CRYPT_MD_AlgId mdId; 
} CRYPT_RSA_PkcsV15Para;

typedef enum {
    // When the padding type is PSS, the salt data is obtained by the DRBG and the length is hashlen.
    CRYPT_RSA_SALTLEN_TYPE_HASHLEN = -1,
    // When the padding type is PSS, the salt data is obtained by the DRBG.
    // and the length is padLen - mdMethod->GetDigestSize - 2
    CRYPT_RSA_SALTLEN_TYPE_MAXLEN = -2,
    // get salt length from signature, only used verify.
    CRYPT_RSA_SALTLEN_TYPE_AUTOLEN = -3
} CRYPT_RSA_SaltLenType;

typedef struct {
    int32_t saltLen; 
    CRYPT_MD_AlgId mdId; 
    CRYPT_MD_AlgId mgfId; 
} CRYPT_RSA_PssPara;
 
typedef struct {
    CRYPT_MD_AlgId mdId;  
    CRYPT_MD_AlgId mgfId; 
} CRYPT_RSA_OaepPara;
 
typedef enum {
    CRYPT_RSA_BLINDING = 0x00000001, 
    CRYPT_RSA_BSSA = 0x00000002, 
    CRYPT_RSA_MAXFLAG
} CRYPT_RSA_Flag;
 
typedef enum {
    CRYPT_DH_NO_PADZERO = 0x00000001, 
    CRYPT_DH_MAXFLAG
} CRYPT_DH_Flag;

typedef enum {
    CRYPT_ECC_CACHE_PUBKEY = 0x00000001,
    CRYPT_ECC_PRIKEY_NO_PUBKEY = 0x00000002, 
    CRYPT_ECC_MAXFLAG
} CRYPT_ECC_Flag;

typedef struct {
    uint8_t *d; 
    uint8_t *n; 
    uint8_t *p; 
    uint8_t *q; 
    uint8_t *dP; 
    uint8_t *dQ; 
    uint8_t *qInv; 
    uint8_t *e; 
    uint32_t dLen; 
    uint32_t nLen; 
    uint32_t pLen; 
    uint32_t qLen; 
    uint32_t dPLen; 
    uint32_t dQLen; 
    uint32_t qInvLen; 
    uint32_t eLen; 
} CRYPT_RsaPrv;

typedef struct {
    uint8_t *p;
    uint8_t *a;
    uint8_t *b;
    uint8_t *n;
    uint8_t *h;
    uint8_t *x;
    uint8_t *y;
    uint32_t pLen;
    uint32_t aLen;
    uint32_t bLen;
    uint32_t nLen;
    uint32_t hLen;
    uint32_t xLen;
    uint32_t yLen;
} CRYPT_EccPara;

typedef struct {
    uint8_t *n;      
    uint8_t *lambda; 
    uint8_t *mu;     
    uint8_t *n2;     
    uint32_t nLen;   
    uint32_t lambdaLen; 
    uint32_t muLen; 
    uint32_t n2Len; 
} CRYPT_PaillierPrv;
 
typedef struct {
    /* Initialization parameters of the noise source */
    void *para;
    /* Noise Source Initialization Interface */
    void *(*init)(void *para);
    /* Noise source read interface,can't be NULL */
    int32_t (*read)(void *ctx, uint32_t timeout, uint8_t *buf, uint32_t bufLen);
    /* Noise Source Deinitialization Interface */
    void (*deinit)(void *ctx);
} CRYPT_EAL_NsMethod;
 
typedef struct {
    /* Repetition Count Test: the cutoff value C */
    uint32_t rctCutoff;
    /* Adaptive Proportion Test: the cutoff value C */
    uint32_t aptCutoff;
    /* Adaptive Proportion Test: the window size W
     * see nist.sp.800-90b section 4.4.2
     * The window size W is selected based on the alphabet size, and shall be assigned to 1024
     * if the noise source is binary (that is, the noise source produces only two distinct values) and 512 if
     * the noise source is not binary (that is, the noise source produces more than two distinct values).
     */
    uint32_t aptWinSize;
} CRYPT_EAL_NsTestPara;
 
typedef struct {
    /* Noise source name, which must be unique. */
    const char *name;
    /* Whether the noise source automatically performs the health test */
    bool autoTest;
    /* Minimum entropy, that is, the number of bits of entropy for a byte */
    uint32_t minEntropy;
    CRYPT_EAL_NsMethod nsMeth;
    CRYPT_EAL_NsTestPara nsPara;
} CRYPT_EAL_NsPara;

typedef uint32_t (*CRYPT_EAL_EntropyGet)(void *ctx, uint8_t *buf, uint32_t bufLen);
 
typedef struct {
    /* Whether Physical Entropy Source. */
    bool isPhysical;
    /* minimum entropy, (0, 8]. */
    uint32_t minEntropy;
    /* entropy source handle */
    void *entropyCtx;
    CRYPT_EAL_EntropyGet entropyGet;
} CRYPT_EAL_EsPara;
 

typedef struct {
    uint8_t *p; 
    uint8_t *g; 
    uint8_t *x; 
 
    uint32_t pLen; 
    uint32_t gLen; 
    uint32_t xLen; 
 
} CRYPT_ElGamalPrv;

typedef CRYPT_Data CRYPT_DsaPrv;

typedef CRYPT_Data CRYPT_EccPrv;

typedef CRYPT_Data CRYPT_EcdsaPrv;

typedef CRYPT_Data CRYPT_Sm2Prv;

typedef CRYPT_Data CRYPT_DhPrv;

typedef CRYPT_Data CRYPT_EcdhPrv;

typedef CRYPT_Data CRYPT_Curve25519Prv;

typedef CRYPT_Data CRYPT_KemDecapsKey;

typedef CRYPT_Data CRYPT_MlDsaPrv;

typedef struct {
    uint8_t *e; 
    uint8_t *n; 
    uint32_t eLen; 
    uint32_t nLen; 
} CRYPT_RsaPub;

typedef struct {
    uint8_t *n; 
    uint8_t *g; 
    uint8_t *n2; 
    uint32_t nLen; 
    uint32_t gLen; 
    uint32_t n2Len; 
} CRYPT_PaillierPub;
 

typedef struct {
    uint8_t *seed; // Seed for generating keys
    uint8_t *root; // Root node of the top XMSS tree
    uint32_t len; // key length
} CRYPT_SlhDsaPub;

typedef struct {
    uint8_t *seed; // Seed for generating keys
    uint8_t *prf; // To generate randomization value
    CRYPT_SlhDsaPub pub; // pubkey
} CRYPT_SlhDsaPrv;

typedef CRYPT_SlhDsaPub CRYPT_XmssPub;

typedef struct {
    uint8_t *seed; // Seed for generating keys
    uint8_t *prf; // To generate randomization value
    uint64_t index; // ots key index
    CRYPT_XmssPub pub; // pubkey
} CRYPT_XmssPrv;

typedef struct {
    uint8_t *p; 
    uint8_t *g; 
    uint8_t *y; 
    uint8_t *q; 
    uint32_t pLen; 
    uint32_t gLen; 
    uint32_t yLen; 
    uint32_t qLen; 
} CRYPT_ElGamalPub;

typedef CRYPT_Data CRYPT_DsaPub;

typedef CRYPT_Data CRYPT_EccPub;

typedef CRYPT_Data CRYPT_EcdsaPub;

typedef CRYPT_Data CRYPT_Sm2Pub;

typedef CRYPT_Data CRYPT_DhPub;

typedef CRYPT_Data CRYPT_EcdhPub;

typedef CRYPT_Data CRYPT_Curve25519Pub;

typedef CRYPT_Data CRYPT_KemEncapsKey;

typedef CRYPT_Data CRYPT_MlDsaPub;

typedef struct {   
    uint8_t *e;    
    uint32_t eLen; 
    uint32_t bits; 
} CRYPT_RsaPara;

typedef struct {
    uint8_t *p;  
    uint8_t *q;  
    uint8_t *g;  
    uint32_t pLen; 
    uint32_t qLen; 
    uint32_t gLen; 
} CRYPT_DsaPara;

typedef struct {
    uint8_t *p;  
    uint8_t *q;  
    uint8_t *g;  
    uint32_t pLen; 
    uint32_t qLen; 
    uint32_t gLen; 
} CRYPT_DhPara;

typedef struct {
    uint8_t *p; 
    uint8_t *q; 
    uint32_t pLen; 
    uint32_t qLen; 
    uint32_t bits; 
} CRYPT_PaillierPara;

typedef struct {
    uint8_t *q; 
    uint32_t qLen; 
    uint32_t bits; 
    uint32_t k_bits; 
} CRYPT_ElGamalPara;

typedef int32_t (*CRYPT_EAL_GetEntropyCb)(void *ctx, CRYPT_Data *entropy, uint32_t strength, CRYPT_Range *lenRange);

typedef void (*CRYPT_EAL_CleanEntropyCb)(void *ctx, CRYPT_Data *entropy);

typedef int32_t (*CRYPT_EAL_GetNonceCb)(void *ctx, CRYPT_Data *nonce, uint32_t strength, CRYPT_Range *lenRange);

typedef void (*CRYPT_EAL_CleanNonceCb)(void *ctx, CRYPT_Data *nonce);

typedef struct {
    CRYPT_EAL_GetEntropyCb getEntropy;
    CRYPT_EAL_CleanEntropyCb cleanEntropy;
    CRYPT_EAL_GetNonceCb getNonce;
    CRYPT_EAL_CleanNonceCb cleanNonce;
} CRYPT_RandSeedMethod;

typedef enum {
    CRYPT_CTRL_SET_IV = 0,        
    CRYPT_CTRL_GET_IV,            
    CRYPT_CTRL_GET_BLOCKSIZE,     
    CRYPT_CTRL_SET_COUNT,         
    CRYPT_CTRL_SET_AAD,           
    CRYPT_CTRL_GET_TAG,           
    CRYPT_CTRL_SET_TAGLEN,        
    CRYPT_CTRL_SET_MSGLEN,        
    CRYPT_CTRL_SET_FEEDBACKSIZE,  
    CRYPT_CTRL_GET_FEEDBACKSIZE,  
    CRYPT_CTRL_DES_NOKEYCHECK,    
    CRYPT_CTRL_SET_PADDING,       
    CRYPT_CTRL_GET_PADDING,       
    CRYPT_CTRL_REINIT_STATUS,     
    CRYPT_CTRL_MAX
} CRYPT_CipherCtrl;

typedef enum {
    // common
    CRYPT_CTRL_UP_REFERENCES = 0,        
    CRYPT_CTRL_SET_PARA_BY_ID,           /* Asymmetric cipher set para by id. */
    CRYPT_CTRL_SET_NO_PADDING,           
 
    CRYPT_CTRL_GET_PARAID,               /* Asymmetric cipher get id of para. */
    CRYPT_CTRL_GET_BITS,                 /* Asymmetric cipher get bits . */
    CRYPT_CTRL_GET_SIGNLEN,              /* Asymmetric cipher get signlen . */
    CRYPT_CTRL_GET_SECBITS,              /* Asymmetric cipher get secure bits . */
    CRYPT_CTRL_GET_SHARED_KEY_LEN,       
    CRYPT_CTRL_GET_PUBKEY_LEN,           
    CRYPT_CTRL_GET_PRVKEY_LEN,           
    CRYPT_CTRL_GET_CIPHERTEXT_LEN,       
    CRYPT_CTRL_SET_DETERMINISTIC_FLAG,   
    CRYPT_CTRL_SET_CTX_INFO,             
    CRYPT_CTRL_SET_PREHASH_FLAG,         
    CRYPT_CTRL_GEN_PARA,                 
    CRYPT_CTRL_SET_GEN_FLAG,             
    CRYPT_CTRL_GET_PUB_KEY_BITS,         
    CRYPT_CTRL_SET_SIGN_MD,
    CRYPT_CTRL_GET_ECC_POINT_FORMAT,     
    CRYPT_CTRL_CLEAN_PUB_KEY,            
    // dh
    CRYPT_CTRL_SET_DH_FLAG = 150,          
 
    // rsa
    CRYPT_CTRL_SET_RSA_EMSA_PKCSV15 = 200, 
    CRYPT_CTRL_GET_RSA_SALT,            
    CRYPT_CTRL_SET_RSA_EMSA_PSS,         
    CRYPT_CTRL_SET_RSA_SALT,             
    CRYPT_CTRL_SET_RSA_PADDING,         
    CRYPT_CTRL_SET_RSA_RSAES_OAEP,      
    CRYPT_CTRL_SET_RSA_OAEP_LABEL,      
    CRYPT_CTRL_SET_RSA_FLAG,            
    CRYPT_CTRL_SET_RSA_RSAES_PKCSV15,   
    CRYPT_CTRL_SET_RSA_RSAES_PKCSV15_TLS, 
    CRYPT_CTRL_GET_RSA_SALTLEN,         
    CRYPT_CTRL_GET_RSA_PADDING,         
    CRYPT_CTRL_GET_RSA_MD,              
    CRYPT_CTRL_GET_RSA_MGF,             
    CRYPT_CTRL_CLR_RSA_FLAG,            
    CRYPT_CTRL_SET_RSA_BSSA_FACTOR_R,   
    CRYPT_CTRL_SET_RSA_EMSA_ISO9796_2,    
 
    // ecc
    CRYPT_CTRL_SET_SM2_USER_ID = 300,
    CRYPT_CTRL_SET_SM2_SERVER,          /* SM2 set the user status. */
    CRYPT_CTRL_SET_SM2_R,               /* SM2 set the R value. */
    CRYPT_CTRL_SET_SM2_RANDOM,          /* SM2 set the r value. */
    CRYPT_CTRL_SET_SM2_PKG,             /* SM2 uses the PKG process. */
    CRYPT_CTRL_SET_SM2_K,               /* SM2 set the K value. */
 
    CRYPT_CTRL_SET_ECC_POINT_FORMAT,      
    CRYPT_CTRL_SET_ECC_USE_COFACTOR_MODE, 
 
    CRYPT_CTRL_SM2_GET_SEND_CHECK,      /* SM2 obtain the check value sent from the local end to the peer end. */
    CRYPT_CTRL_GENE_SM2_R,              /* SM2 obtain the R value. */
 
    CRYPT_CTRL_SM2_DO_CHECK,            /* SM2 check the shared key. */
    CRYPT_CTRL_GEN_ECC_PUBLICKEY,       
    CRYPT_CTRL_GET_ECC_PUB_X_BIN,       
    CRYPT_CTRL_GET_ECC_PUB_Y_BIN,       
    CRYPT_CTRL_GET_ECC_ORDER_BITS,      
    CRYPT_CTRL_GET_ECC_NAME,            
    CRYPT_CTRL_GEN_X25519_PUBLICKEY,    
    CRYPT_CTRL_GET_SM2_RANDOM,          
    CRYPT_CTRL_GET_FLAG,                
    CRYPT_CTRL_SET_FLAG,                
    CRYPT_CTRL_CLR_FLAG,                
 
    // slh-dsa
    CRYPT_CTRL_GET_SLH_DSA_KEY_LEN = 600,     
    CRYPT_CTRL_SET_SLH_DSA_ADDRAND, 
    // mldsa
    CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG = 700,  
    CRYPT_CTRL_SET_MLDSA_MUMSG_FLAG,         
    CRYPT_CTRL_GET_MLDSA_SEED,               
    CRYPT_CTRL_SET_MLDSA_PRVKEY_FORMAT,      
    CRYPT_CTRL_GET_MLDSA_PRVKEY_FORMAT,      
 
    // mlkem
    CRYPT_CTRL_GET_MLKEM_SEED = 750,         
    CRYPT_CTRL_SET_MLKEM_DK_FORMAT,          
    CRYPT_CTRL_GET_MLKEM_DK_FORMAT,          
 
    // xmss
    CRYPT_CTRL_GET_XMSS_XDR_ALG_TYPE = 800,     
    CRYPT_CTRL_SET_XMSS_XDR_ALG_TYPE = 801,     
} CRYPT_PkeyCtrl;
 
 
typedef enum {
    CRYPT_CTRL_SET_GM_LEVEL,    
    CRYPT_CTRL_SET_RESEED_INTERVAL,
    CRYPT_CTRL_SET_RESEED_TIME,
    CRYPT_CTRL_GET_RESEED_INTERVAL,
    CRYPT_CTRL_GET_RESEED_TIME,
    CRYPT_CTRL_SET_PREDICTION_RESISTANCE,
    CRYPT_CTRL_GET_WORKING_STATUS,
    CRYPT_CTRL_RAND_MAX = 0xff,
} CRYPT_RandCtrl;

typedef enum {
    CRYPT_CTRL_SET_CBC_MAC_PADDING = 0, 
    CRYPT_CTRL_GET_MACLEN,              /* Mac get maxlen . */
    CRYPT_CTRL_MAC_MAX
} CRYPT_MacCtrl;

typedef enum {
    CRYPT_ENTROPY_SET_POOL_SIZE = 0,      
    CRYPT_ENTROPY_SET_CF,                 
    CRYPT_ENTROPY_ADD_NS,                 
    CRYPT_ENTROPY_REMOVE_NS,              
    CRYPT_ENTROPY_ENABLE_TEST,            
    CRYPT_ENTROPY_GET_STATE,              
    CRYPT_ENTROPY_GET_POOL_SIZE,          
    CRYPT_ENTROPY_POOL_GET_CURRSIZE,      
    CRYPT_ENTROPY_GET_CF_SIZE,            
    CRYPT_ENTROPY_GATHER_ENTROPY,         
    CRYPT_ENTROPY_SET_LOG_CALLBACK,       
    CRYPT_ENTROPY_MAX
} CRYPT_ENTROPY_TYPE;

typedef enum {
    CRYPT_PADDING_NONE = 0,         
    CRYPT_PADDING_ZEROS,            
    CRYPT_PADDING_ISO7816,          
    CRYPT_PADDING_X923,             
    CRYPT_PADDING_PKCS5,            
    CRYPT_PADDING_PKCS7,            
    CRYPT_PADDING_MAX_COUNT
} CRYPT_PaddingType;
 
typedef enum {
    CRYPT_EMSA_PKCSV15 = 1, 
    CRYPT_EMSA_PSS,         
    CRYPT_RSAES_OAEP,       
    CRYPT_RSAES_PKCSV15,    
    CRYPT_RSA_NO_PAD,
    CRYPT_RSAES_PKCSV15_TLS, /* Specific RSA pkcs1.5 padding verification process to
                                prevent possible Bleichenbacher attacks */
    CRYPT_EMSA_ISO9796_2,   
    CRYPT_RSA_PADDINGMAX,
} CRYPT_RsaPadType;

typedef enum {
    CRYPT_EVENT_ENC,          
    CRYPT_EVENT_DEC,          
    CRYPT_EVENT_GEN,          
    CRYPT_EVENT_SIGN,         
    CRYPT_EVENT_VERIFY,       
    CRYPT_EVENT_MD,           
    CRYPT_EVENT_MAC,          
    CRYPT_EVENT_KDF,          
    CRYPT_EVENT_KEYAGGREMENT, 
    CRYPT_EVENT_RANDGEN,      
    CRYPT_EVENT_ZERO,         
    CRYPT_EVENT_ERR,          
    CRYPT_EVENT_SETSSP,       
    CRYPT_EVENT_GETSSP,       
    CRYPT_EVENT_ENCAPS,       
    CRYPT_EVENT_DECAPS,       
    CRYPT_EVENT_BLIND,        
    CRYPT_EVENT_UNBLIND,      
    CRYPT_EVENT_PARAM_CHECK,  
    CRYPT_EVENT_PCT_TEST,     
    CRYPT_EVENT_KAT_TEST,     
    CRYPT_EVENT_ES_HEALTH_TEST, 
    CRYPT_EVENT_INTEGRITY_TEST, 
    CRYPT_EVENT_GET_VERSION,    
    CRYPT_EVENT_MAX
} CRYPT_EVENT_TYPE;

typedef enum {
    CRYPT_ALGO_CIPHER = 0,
    CRYPT_ALGO_PKEY,
    CRYPT_ALGO_MD,
    CRYPT_ALGO_MAC,
    CRYPT_ALGO_KDF,
    CRYPT_ALGO_RAND
} CRYPT_ALGO_TYPE;
 
typedef enum {
    CRYPT_ALGO_MLDSA_PRIV_FORMAT_NOT_SET = 0,
    CRYPT_ALGO_MLDSA_PRIV_FORMAT_BOTH,
    CRYPT_ALGO_MLDSA_PRIV_FORMAT_PRIV_ONLY,
    CRYPT_ALGO_MLDSA_PRIV_FORMAT_SEED_ONLY,
    CRYPT_ALGO_MLDSA_PRIV_FORMAT_END,
} CRYPT_ALGO_MLDSA_PRIV_KEY_FORMAT_TYPE;
 
typedef enum {
    CRYPT_ALGO_MLKEM_DK_FORMAT_NOT_SET = 0,
    CRYPT_ALGO_MLKEM_DK_FORMAT_BOTH,
    CRYPT_ALGO_MLKEM_DK_FORMAT_DK_ONLY,
    CRYPT_ALGO_MLKEM_DK_FORMAT_SEED_ONLY,
    CRYPT_ALGO_MLKEM_DK_FORMAT_END,
} CRYPT_ALGO_MLKEM_DK_FORMAT_TYPE;

typedef void (*EventReport)(CRYPT_EVENT_TYPE oper, CRYPT_ALGO_TYPE type, int32_t id, int32_t err);

void CRYPT_EAL_RegEventReport(EventReport func);

typedef enum {
    CRYPT_INFO_IS_AEAD = 0,          
    CRYPT_INFO_IS_STREAM,            
    CRYPT_INFO_IV_LEN,               
    CRYPT_INFO_KEY_LEN,              
    CRYPT_INFO_BLOCK_LEN,            
    CRYPT_INFO_MAX
} CRYPT_INFO_TYPE;
 
typedef enum {
    CRYPT_KDF_HKDF_MODE_FULL = 0,
    CRYPT_KDF_HKDF_MODE_EXTRACT,
    CRYPT_KDF_HKDF_MODE_EXPAND,
} CRYPT_HKDF_MODE;
 
typedef enum {
    CRYPT_ENCDEC_UNKNOW,
    CRYPT_PRIKEY_PKCS8_UNENCRYPT,
    CRYPT_PRIKEY_PKCS8_ENCRYPT,
    CRYPT_PRIKEY_RSA,
    CRYPT_PRIKEY_ECC,
    CRYPT_PUBKEY_SUBKEY,
    CRYPT_PUBKEY_RSA,
    CRYPT_PUBKEY_SUBKEY_WITHOUT_SEQ,
} CRYPT_ENCDEC_TYPE;
 
typedef enum {
    CRYPT_DERIVE_PBKDF2,
} CRYPT_DERIVE_MODE;
 
typedef struct {
    uint32_t deriveMode;
    void *param;
} CRYPT_EncodeParam;
 
typedef struct {
    uint32_t pbesId;
    uint32_t pbkdfId;
    uint32_t hmacId;
    uint32_t symId;
    uint32_t saltLen;
    uint8_t *pwd;
    uint32_t pwdLen;
    uint32_t itCnt;
} CRYPT_Pbkdf2Param;
 
typedef struct EAL_LibCtx CRYPT_EAL_LibCtx;
 
/* The hitls framework generates context for each provider */
typedef struct EAL_ProviderMgrCtx CRYPT_EAL_ProvMgrCtx;
 
typedef struct {
    int32_t id;
    void *func;
} CRYPT_EAL_Func;
 
typedef enum {
    CRYPT_CMVP_PROVIDER_SELFTEST = 0x01, 
} CRYPT_CMVP_SELFTEST_AlgId;
 
#ifdef __cplusplus
}
#endif // __cplusplus
 
#endif // CRYPT_TYPES_H