dao_liquid_crypto.h

Go to the documentation of this file.

/* SPDX-License-Identifier: Marvell-MIT
 * Copyright (c) 2025 Marvell.
 */
 
#ifndef __DAO_LIQUID_CRYPTO_H__
#define __DAO_LIQUID_CRYPTO_H__
 
#include <stdbool.h>
#include <stdint.h>
 
#include <dao_eth_trs.h>
 
#define DAO_LC_VERSION "26.01.0"
#define DAO_CRYPTO_VERSION_LEN 32
#define DAO_CRYPTO_MAX_NB_DEV 1
#define DAO_CMD_QP_IDX_INVALID 0xFFFF
#define DAO_LC_SESS_ID_INVALID 0
#define DAO_LC_SESS_ID_HASH 1
#define DAO_LC_SESS_ID_AES_KEY_WRAP 2
#define DAO_LC_MAX_DIGEST_LEN 255
#define DAO_LC_MAX_AUTH_KEY_LEN 1024
#define DAO_LC_AES_KEY_WRAP_MAX_KEY_DATA_LEN 3072
#define DAO_LC_AES_MAX_KEY_ENC_KEY_LEN 32
#define DAO_LC_AES_KEY_WRAP_IV_LEN 8
#define DAO_LC_RSA_OAEP_MAX_LABEL_LEN 1024
#define DAO_LC_RSA_OAEP_MAX_MOD_LEN 988
#define DAO_LC_SHA3_MAX_CUSTOM_STRING_LEN 511
#define DAO_LC_SHA3_MAX_FUNCTION_NAME_LEN 511
#define DAO_LC_KMAC_MAX_AUTH_KEY_LEN 511
 
struct dao_lc_sym_op_kmac_params {
    uint8_t *custom_string;
    uint16_t custom_string_len;
    uint16_t output_len;
};
 
struct dao_lc_sym_op_cshake_params {
    uint8_t *custom_string;
    uint8_t *function_name;
    uint16_t custom_string_len;
    uint16_t function_name_len;
    uint16_t output_len;
};
 
struct dao_lc_buf {
    void *data;
    uint32_t total_len;
    uint32_t frag_len;
    struct dao_lc_buf *next;
};
 
/* Structure dao_lc_sym_op 8< */
struct dao_lc_sym_op {
    uint64_t op_cookie;
    uint64_t sess_id;
    struct dao_lc_buf *in_buffer;
    struct dao_lc_buf *out_buffer;
    uint32_t cipher_offset;
    uint32_t cipher_len;
    uint32_t auth_offset;
    uint32_t auth_len;
    uint8_t *cipher_iv;
    uint8_t *auth_iv;
    uint8_t *aad;
    uint16_t aad_len;
    uint8_t *digest;
    uint32_t wrap_unwrap_key_len;
    bool is_wrap_pad;
    union {
        bool encrypt;
        bool auth_gen;
        bool is_wrap;
    };
    union {
        struct dao_lc_sym_op_kmac_params kmac_params;
        struct dao_lc_sym_op_cshake_params cshake_params;
    };
};
/* >8 End of structure dao_lc_sym_op. */
 
enum dao_cpt_comp_code {
    DAO_CPT_COMP_NOT_DONE = 0,
    DAO_CPT_COMP_GOOD,
    DAO_CPT_COMP_FAULT,
    DAO_CPT_COMP_SWERR,
    DAO_CPT_COMP_HWERR,
    DAO_CPT_COMP_INSTERR,
    DAO_CPT_COMP_WARN
};
 
enum dao_uc_comp_code {
    DAO_UC_SUCCESS = 0x00,
    DAO_UC_RSA_SG_NOT_SUPPORTED = 0x04,
    DAO_UC_RSA_MOD_LEN_INVALID = 0x06,
    DAO_UC_RSA_MOD_LEN_NOT_EVEN = 0x09,
    DAO_UC_RSA_PKCS_DEC_INCORRECT = 0x0A,
 
    DAO_UC_ECC_DATA_LEN_INVALID = 0x08,
    DAO_UC_ECC_PAI = 0x0b,
    DAO_UC_ECC_CURVE_INVALID = 0x0c,
    DAO_UC_ECC_SIGN_R_INVALID = 0x0d,
    DAO_UC_ECC_SIGN_S_INVALID = 0x0e,
    DAO_UC_ECC_VERIFY_MISMATCH = 0x0f,
    DAO_UC_ECC_PUB_KEY_INVALID = 0x11,
 
    DAO_UC_ERR_GC_DATA_LEN_INVALID = 0x43,
    DAO_UC_ERR_GC_CTX_LEN_INVALID = 0x45,
    DAO_UC_ERR_GC_CIPHER_UNSUPPORTED = 0x46,
    DAO_UC_ERR_GC_AUTH_UNSUPPORTED = 0x47,
    DAO_UC_ERR_GC_OFFSET_INVALID = 0x48,
    DAO_UC_ERR_GC_ICV_MISCOMPARE = 0x4c,
    DAO_UC_ERR_GC_DATA_UNALIGNED = 0x4d,
    DAO_UC_ERR_GC_KEY_LEN_INVALID = 0x4e,
    DAO_UC_ERR_GC_KEY_DATA_LEN_INVALID = 0x41,
    DAO_UC_RSA_OAEP_DECODING_ERROR = 0x9c,
};
 
enum dao_pqc_comp_code {
    DAO_PQC_COMP_NOT_DONE = 0,
    DAO_PQC_COMP_GOOD,
    DAO_PQC_COMP_LIB_ERROR_LIBOQS
};
 
union dao_cpt_res_s {
    struct cpt_cn10k_res_s {
        uint64_t compcode : 7;
        uint64_t doneint : 1;
        uint64_t uc_compcode : 8;
        uint64_t rlen : 16;
        uint64_t spi : 32;
 
        uint64_t esn;
    } cn10k;
 
    struct cpt_cn9k_res_s {
        uint64_t compcode : 8;
        uint64_t uc_compcode : 8;
        uint64_t doneint : 1;
        uint64_t reserved_17_63 : 47;
 
        uint64_t reserved_64_127;
    } cn9k;
 
    struct {
        uint8_t compcode;
        uint8_t op_type;
        uint8_t alg;
        uint16_t data_out_len;
    } pqc;
 
    uint64_t u64[2];
};
 
struct dao_lc_info {
    char version[DAO_CRYPTO_VERSION_LEN];
    uint8_t nb_dev;
    uint16_t nb_qp[DAO_CRYPTO_MAX_NB_DEV];
};
 
struct dao_lc_dev_conf {
    uint8_t dev_id;
    uint16_t nb_qp;
    uint16_t cmd_qp_idx;
};
 
struct dao_lc_dev_caps {
    union {
        struct {
            uint64_t pqc_en : 1;
        };
        uint64_t feature_mask0;
    };
};
 
struct dao_lc_qp_conf {
    bool out_of_order_delivery_en;
    uint16_t nb_desc;
    uint16_t max_seg_size;
};
 
struct dao_lc_res {
    union dao_cpt_res_s res;
    union {
        struct {
            uint16_t data_out_len;
        } rsa;
        struct {
            uint16_t ecc_rs_out_len;
        } ecdsa;
        struct {
            uint16_t wrap_unwrap_key_len;
        } key_wrap;
        struct {
            uint8_t op_type;
            uint8_t alg;
            uint8_t ret_code;
        } pqc;
        uint64_t u64;
    };
    uint64_t op_cookie;
};
 
enum dao_liquid_crypto_rsa_key_type {
    DAO_LC_RSA_KEY_TYPE_PUBLIC,
    DAO_LC_RSA_KEY_TYPE_PRIVATE,
};
 
enum dao_lc_cmd_event_type {
    DAO_LC_CMD_EVENT_SESS_CREATE = 0,
    DAO_LC_CMD_EVENT_SESS_DESTROY = 1,
};
 
struct dao_lc_cmd_sess_event {
    uint64_t sess_id;
    uint64_t sess_cookie;
};
 
struct dao_lc_cmd_event {
    uint8_t event_type;
    union {
        struct dao_lc_cmd_sess_event sess_event;
    };
};
 
enum dao_lc_sym_opcode {
    DAO_LC_SYM_OPCODE_FC = 0x33,
    DAO_LC_SYM_OPCODE_HASH = 0x34,
    DAO_LC_SYM_OPCODE_HMAC = 0x35,
    DAO_LC_SYM_OPCODE_AES_KEY_WRAP = 0x1D,
};
 
enum dao_lc_fc_iv_src {
    DAO_LC_FC_IV_SRC_CTX = 0,
    DAO_LC_FC_IV_SRC_OP = 1
};
 
enum dao_lc_fc_aes_key_len {
    DAO_LC_FC_AES_KEY_LEN_128 = 1,
    DAO_LC_FC_AES_KEY_LEN_192 = 2,
    DAO_LC_FC_AES_KEY_LEN_256 = 3
};
 
enum dao_lc_fc_enc_cipher {
    DAO_LC_FC_ENC_CIPHER_NULL = 0,
    DAO_LC_FC_ENC_CIPHER_3DES_CBC = 1,
    DAO_LC_FC_ENC_CIPHER_3DES_ECB = 2,
    DAO_LC_FC_ENC_CIPHER_AES_CBC = 3,
    DAO_LC_FC_ENC_CIPHER_AES_ECB = 4,
    DAO_LC_FC_ENC_CIPHER_AES_CFB = 5,
    DAO_LC_FC_ENC_CIPHER_AES_CTR = 6,
    DAO_LC_FC_ENC_CIPHER_AES_GCM = 7,
    DAO_LC_FC_ENC_CIPHER_AES_XTS = 8,
    DAO_LC_FC_ENC_CIPHER_CHACHA = 9,
    DAO_LC_FC_ENC_CIPHER_AES_CCM = 10,
};
 
enum dao_lc_fc_chain_order {
    /* Encrypt first, then authenticate */
    DAO_LC_FC_CIPHER_THEN_AUTH = 0,
    /* Authenticate first, then encrypt */
    DAO_LC_FC_AUTH_THEN_CIPHER = 1
};
 
enum dao_lc_fc_auth_input_type {
    DAO_LC_FC_AUTH_INPUT_OPAD_IPAD = 0,
    DAO_LC_FC_AUTH_INPUT_KEY = 1
};
 
enum dao_lc_fc_auth_key_src {
    DAO_LC_FC_AUTH_KEY_SRC_CTX = 0,
    DAO_LC_FC_AUTH_KEY_SRC_OP = 1,
};
 
enum dao_lc_hash_type {
    DAO_LC_HASH_TYPE_NULL = 0,
    DAO_LC_HASH_TYPE_MD5 = 1,
    DAO_LC_HASH_TYPE_SHA1 = 2,
    DAO_LC_HASH_TYPE_SHA2_SHA224 = 3,
    DAO_LC_HASH_TYPE_SHA2_SHA256 = 4,
    DAO_LC_HASH_TYPE_SHA2_SHA384 = 5,
    DAO_LC_HASH_TYPE_SHA2_SHA512 = 6,
    DAO_LC_HASH_TYPE_GMAC = 7,
    DAO_LC_HASH_TYPE_POLY1305 = 8,
    DAO_LC_HASH_TYPE_SM3 = 9,
    DAO_LC_HASH_TYPE_SHA3_SHA224 = 10,
    DAO_LC_HASH_TYPE_SHA3_SHA256 = 11,
    DAO_LC_HASH_TYPE_SHA3_SHA384 = 12,
    DAO_LC_HASH_TYPE_SHA3_SHA512 = 13,
    DAO_LC_HASH_TYPE_SHA3_SHAKE128 = 14,
    DAO_LC_HASH_TYPE_SHA3_SHAKE256 = 15,
    DAO_LC_HASH_TYPE_CMAC = 16,
    DAO_LC_HASH_TYPE_SHA3_KMAC128 = 17,
    DAO_LC_HASH_TYPE_SHA3_KMAC256 = 18,
    DAO_LC_HASH_TYPE_SHA3_CSHAKE128 = 19,
    DAO_LC_HASH_TYPE_SHA3_CSHAKE256 = 20,
};
 
enum dao_lc_hash_digest_size {
    DAO_LC_HASH_DIGEST_SIZE_SHA1 = 20,
    DAO_LC_HASH_DIGEST_SIZE_SHA2_SHA224 = 28,
    DAO_LC_HASH_DIGEST_SIZE_SHA2_SHA256 = 32,
    DAO_LC_HASH_DIGEST_SIZE_SHA2_SHA384 = 48,
    DAO_LC_HASH_DIGEST_SIZE_SHA2_SHA512 = 64,
};
 
enum dao_liquid_crypto_ec_curve_type {
    /* Elliptic curve identifier for P-192 (secp192r1) */
    DAO_LC_AE_EC_ID_P192 = 0,
    /* Elliptic curve identifier for P-224 (secpr224r1) */
    DAO_LC_AE_EC_ID_P224 = 1,
    /* Elliptic curve identifier for P-256 (secpr256r1) */
    DAO_LC_AE_EC_ID_P256 = 2,
    /* Elliptic curve identifier for P-384 (secpr384r1) */
    DAO_LC_AE_EC_ID_P384 = 3,
    /* Elliptic curve identifier for P-521 (secpr521r1) */
    DAO_LC_AE_EC_ID_P521 = 4,
    DAO_LC_AE_EC_ID_PMAX
};
 
struct dao_lc_sym_fc_ctx {
    uint64_t iv_source : 1;
    uint64_t aes_key_len : 2;
    uint64_t rsvd_59 : 1;
    uint64_t enc_cipher : 4;
    uint64_t auth_input_type : 1;
    uint64_t auth_key_src : 1;
    uint64_t rsvd_50_51 : 2;
    uint64_t hash_type : 4;
    uint64_t mac_len : 8;
    uint64_t rsvd_16_39 : 24;
    uint64_t hmac_key_sz : 16;
    uint8_t encr_key[32];
    uint8_t encr_iv[16];
    uint8_t ipad[64];
    uint8_t opad[64];
};
 
struct dao_lc_feature_params {
    struct {
        bool is_sym_enabled;
        uint16_t cipher_auth_payload_len;
        uint16_t iv_len;
        uint16_t aad_len;
        uint16_t digest_len;
        uint16_t hmac_auth_key_len;
        uint16_t key_wrap_len;
        enum dao_lc_fc_aes_key_len aes_kek_type;
    } sym;
    struct {
        uint16_t mod_len;
        uint16_t exp_len;
    } rsa;
    struct {
        uint32_t rand_len;
    } rng;
 
    struct {
        bool is_ecc_enabled;
        enum dao_liquid_crypto_ec_curve_type curve_id;
        uint16_t digest_len;
    } ecc;
 
    struct {
        uint8_t is_rsa_oaep_enabled;
        uint16_t mod_len;
        uint16_t exp_len;
        uint16_t label_len;
        enum dao_lc_hash_type hash_type;
    } rsa_oaep;
 
    /* Specifies whether PQC is enabled or not */
    struct {
        bool is_pqc_enabled;
    } pqc;
 
    bool cmd_qp;
};
 
struct dao_lc_hmac_hash_ctx {
    enum dao_lc_hash_type hmac_hash_type;
    uint8_t digest_len;
    uint16_t hmac_key_len;
    uint8_t hmac_auth_key[DAO_LC_MAX_AUTH_KEY_LEN];
};
 
struct dao_lc_aes_key_wrap_ctx {
    enum dao_lc_fc_aes_key_len aes_kek_type;
    uint8_t kek[DAO_LC_AES_MAX_KEY_ENC_KEY_LEN];
};
 
struct dao_lc_sym_ctx {
    enum dao_lc_sym_opcode opcode;
    uint16_t iv_len;
    bool is_chained_cipher;
    enum dao_lc_fc_chain_order chain_order;
    union {
        struct dao_lc_sym_fc_ctx fc;
        struct dao_lc_hmac_hash_ctx hash;
        struct dao_lc_aes_key_wrap_ctx aes_key_wrap;
    };
};
 
enum dao_lc_random_type {
    DAO_LC_RANDOM_TYPE_HW = 0,
    DAO_LC_RANDOM_TYPE_X9_17 = 1
};
 
struct dao_lc_random_op_x9_17 {
    uint8_t *key;
    uint8_t *datetime;
    uint8_t *seed;
    uint8_t *out_seed;
};
 
struct dao_lc_random_op {
    enum dao_lc_random_type type;
    struct dao_lc_buf *out_buf;
    uint32_t rand_len;
    uint64_t op_cookie;
 
    union {
        struct dao_lc_random_op_x9_17 x9_17;
    };
};
 
enum dao_lc_aes_key_len_bytes {
    DAO_LC_AES_KEY_LEN_16_BYTES = 16,
    DAO_LC_AES_KEY_LEN_24_BYTES = 24,
    DAO_LC_AES_KEY_LEN_32_BYTES = 32
};
 
int dao_liquid_crypto_init(void);
 
int dao_liquid_crypto_fini(void);
 
int dao_liquid_crypto_info_get(struct dao_lc_info *info);
 
int dao_liquid_crypto_dev_create(struct dao_lc_dev_conf *conf);
 
int dao_liquid_crypto_dev_destroy(uint8_t dev_id);
 
int dao_liquid_crypto_qp_configure(uint8_t dev_id, uint16_t qp_id, struct dao_lc_qp_conf *conf);
 
int dao_liquid_crypto_qp_inflight_req_count(uint8_t dev_id, uint16_t qp_id);
 
int dao_liquid_crypto_dev_caps_get(struct dao_lc_dev_caps *lc_caps);
 
int dao_liquid_crypto_dev_start(uint8_t dev_id);
 
int dao_liquid_crypto_dev_stop(uint8_t dev_id);
 
uint16_t dao_liquid_crypto_seg_size_calc(struct dao_lc_feature_params *params);
 
int dao_liquid_crypto_enqueue_op_passthrough(uint8_t dev_id, uint16_t qp_id, uint64_t op_cookie);
 
int dao_liquid_crypto_enq_op_pkcs1v15enc(uint8_t dev_id, uint16_t qp_id,
                     enum dao_liquid_crypto_rsa_key_type key_type,
                     uint16_t mod_len, uint16_t exp_len, uint16_t msg_len,
                     const uint8_t *mod, const uint8_t *exp, const uint8_t *msg,
                     uint8_t *em, uint64_t op_cookie);
 
int dao_liquid_crypto_enq_op_pkcs1v15dec(uint8_t dev_id, uint16_t qp_id,
                     enum dao_liquid_crypto_rsa_key_type key_type,
                     uint16_t mod_len, uint16_t exp_len, const uint8_t *mod,
                     const uint8_t *exp, const uint8_t *em, uint8_t *msg,
                     uint64_t op_cookie);
 
int dao_liquid_crypto_enq_op_pkcs1v15enc_crt(uint8_t dev_id, uint16_t qp_id, uint16_t mod_len,
                         uint16_t msg_len, const uint8_t *q, const uint8_t *dQ,
                         const uint8_t *p, const uint8_t *dP,
                         const uint8_t *qInv, const uint8_t *msg, uint8_t *em,
                         uint64_t op_cookie);
 
int dao_liquid_crypto_enq_op_pkcs1v15dec_crt(uint8_t dev_id, uint16_t qp_id, uint16_t mod_len,
                         const uint8_t *q, const uint8_t *dQ, const uint8_t *p,
                         const uint8_t *dP, const uint8_t *qInv,
                         const uint8_t *em, uint8_t *msg, uint64_t op_cookie);
 
enum dao_lc_pqc_alg {
    DAO_LC_ML_KEM_512 = 1,
    DAO_LC_ML_KEM_768 = 2,
    DAO_LC_ML_KEM_1024 = 3,
    DAO_LC_ML_DSA_44 = 4,
    DAO_LC_ML_DSA_65 = 5,
    DAO_LC_ML_DSA_87 = 6,
    DAO_LC_ML_PQC_ALG_END = 7,
};
 
enum dao_lc_pqc_op_type {
    DAO_LC_ML_KEM_OP_KEYGEN = 1,
    DAO_LC_ML_KEM_OP_ENCAP = 2,
    DAO_LC_ML_KEM_OP_DECAP = 3,
    DAO_LC_ML_DSA_OP_KEYGEN = 4,
    DAO_LC_ML_DSA_OP_SIGN = 5,
    DAO_LC_ML_DSA_OP_VERIFY = 6,
};
 
#define DAO_LC_ML_KEYPAIR_SEED_LEN      (64)
#define DAO_LC_ML_KEM_SHARED_SECRET_LEN (32)
 
/* FIPS 204 recommends at most 255. */
#define DAO_LC_ML_DSA_CTX_LEN_MAX (255)
 
#define DAO_LC_ML_KEM_512_PUB_KEY_LEN    (800)
#define DAO_LC_ML_KEM_512_PRIV_KEY_LEN   (1632)
#define DAO_LC_ML_KEM_512_CIPHERTEXT_LEN (768)
 
#define DAO_LC_ML_KEM_768_PUB_KEY_LEN    (1184)
#define DAO_LC_ML_KEM_768_PRIV_KEY_LEN   (2400)
#define DAO_LC_ML_KEM_768_CIPHERTEXT_LEN (1088)
 
#define DAO_LC_ML_KEM_1024_PUB_KEY_LEN    (1568)
#define DAO_LC_ML_KEM_1024_PRIV_KEY_LEN   (3168)
#define DAO_LC_ML_KEM_1024_CIPHERTEXT_LEN (1568)
 
#define DAO_LC_ML_DSA_44_PUB_KEY_LEN   (1312)
#define DAO_LC_ML_DSA_44_PRIV_KEY_LEN  (2560)
#define DAO_LC_ML_DSA_44_SIGNATURE_LEN (2420)
 
#define DAO_LC_ML_DSA_65_PUB_KEY_LEN   (1952)
#define DAO_LC_ML_DSA_65_PRIV_KEY_LEN  (4032)
#define DAO_LC_ML_DSA_65_SIGNATURE_LEN (3309)
 
#define DAO_LC_ML_DSA_87_PUB_KEY_LEN   (2592)
#define DAO_LC_ML_DSA_87_PRIV_KEY_LEN  (4896)
#define DAO_LC_ML_DSA_87_SIGNATURE_LEN (4627)
 
static uint16_t pqc_ml_pub_key_len[] = {[DAO_LC_ML_KEM_512] = DAO_LC_ML_KEM_512_PUB_KEY_LEN,
                    [DAO_LC_ML_KEM_768] = DAO_LC_ML_KEM_768_PUB_KEY_LEN,
                    [DAO_LC_ML_KEM_1024] = DAO_LC_ML_KEM_1024_PUB_KEY_LEN,
                    [DAO_LC_ML_DSA_44] = DAO_LC_ML_DSA_44_PUB_KEY_LEN,
                    [DAO_LC_ML_DSA_65] = DAO_LC_ML_DSA_65_PUB_KEY_LEN,
                    [DAO_LC_ML_DSA_87] = DAO_LC_ML_DSA_87_PUB_KEY_LEN};
 
static uint16_t pqc_ml_priv_key_len[] = {[DAO_LC_ML_KEM_512] = DAO_LC_ML_KEM_512_PRIV_KEY_LEN,
                     [DAO_LC_ML_KEM_768] = DAO_LC_ML_KEM_768_PRIV_KEY_LEN,
                     [DAO_LC_ML_KEM_1024] = DAO_LC_ML_KEM_1024_PRIV_KEY_LEN,
                     [DAO_LC_ML_DSA_44] = DAO_LC_ML_DSA_44_PRIV_KEY_LEN,
                     [DAO_LC_ML_DSA_65] = DAO_LC_ML_DSA_65_PRIV_KEY_LEN,
                     [DAO_LC_ML_DSA_87] = DAO_LC_ML_DSA_87_PRIV_KEY_LEN};
 
static uint16_t pqc_ml_signature_len[] = {
    [DAO_LC_ML_KEM_512] = 0,
    [DAO_LC_ML_KEM_768] = 0,
    [DAO_LC_ML_KEM_1024] = 0,
 
    [DAO_LC_ML_DSA_44] = DAO_LC_ML_DSA_44_SIGNATURE_LEN,
    [DAO_LC_ML_DSA_65] = DAO_LC_ML_DSA_65_SIGNATURE_LEN,
    [DAO_LC_ML_DSA_87] = DAO_LC_ML_DSA_87_SIGNATURE_LEN};
 
static uint16_t pqc_ml_ciphertext_len[] = {
    [DAO_LC_ML_KEM_512] = DAO_LC_ML_KEM_512_CIPHERTEXT_LEN,
    [DAO_LC_ML_KEM_768] = DAO_LC_ML_KEM_768_CIPHERTEXT_LEN,
    [DAO_LC_ML_KEM_1024] = DAO_LC_ML_KEM_1024_CIPHERTEXT_LEN,
    [DAO_LC_ML_DSA_44] = 0, /* DSA does not have ciphertext */
    [DAO_LC_ML_DSA_65] = 0, /* DSA does not have ciphertext */
    [DAO_LC_ML_DSA_87] = 0  /* DSA does not have ciphertext */
};
 
static inline uint16_t
dao_lc_pqc_pub_key_len(enum dao_lc_pqc_alg alg)
{
    return pqc_ml_pub_key_len[alg];
}
 
static inline uint16_t
dao_lc_pqc_priv_key_len(enum dao_lc_pqc_alg alg)
{
    return pqc_ml_priv_key_len[alg];
}
 
static inline uint16_t
dao_lc_pqc_signature_len(enum dao_lc_pqc_alg alg)
{
    return pqc_ml_signature_len[alg];
}
 
static inline uint16_t
dao_lc_pqc_ciphertext_len(enum dao_lc_pqc_alg alg)
{
    return pqc_ml_ciphertext_len[alg];
}
 
struct dao_lc_pqc_op {
    enum dao_lc_pqc_alg alg;
    enum dao_lc_pqc_op_type op_type;
    union {
        struct {
            uint8_t *pub_key;
            uint8_t *priv_key;
            uint8_t *seed;
        } keygen;
        struct {
            const uint8_t *enc_key;
            uint8_t *shared_secret;
            uint8_t *ciphertext;
        } encap;
        struct {
            const uint8_t *dec_key;
            const uint8_t *ciphertext;
            uint8_t *shared_secret;
        } decap;
        struct {
            const uint8_t *msg;
            uint16_t msg_len;
            const uint8_t *ctx;
            uint16_t ctx_len;
            const uint8_t *priv_key;
            uint8_t *signature;
        } sign;
        struct {
            const uint8_t *msg;
            uint16_t msg_len;
            const uint8_t *ctx;
            uint16_t ctx_len;
            const uint8_t *signature;
            const uint8_t *pub_key;
        } verify;
    };
};
 
int dao_liquid_crypto_pqc_enqueue(uint8_t dev_id, uint16_t qp_id, struct dao_lc_pqc_op *op,
                  uint64_t op_cookie);
 
int dao_liquid_crypto_enq_op_random(uint8_t dev_id, uint16_t qp_id, struct dao_lc_random_op *op);
 
uint16_t dao_liquid_crypto_sym_enqueue_burst(uint8_t dev_id, uint16_t qp_id,
                         struct dao_lc_sym_op *op, uint16_t nb_ops);
 
uint16_t dao_liquid_crypto_dequeue_burst(uint8_t dev_id, uint16_t qp_id, struct dao_lc_res *res,
                     uint16_t nb_ops);
 
int dao_liquid_crypto_sym_sess_create(uint8_t dev_id, const struct dao_lc_sym_ctx *ctx,
                      uint64_t sess_cookie);
 
int dao_liquid_crypto_sym_sess_destroy(uint8_t dev_id, uint64_t sess_id, uint64_t sess_cookie);
 
uint16_t dao_liquid_crypto_cmd_event_dequeue(uint8_t dev_id, struct dao_lc_cmd_event *events,
                         uint16_t nb_events);
 
int dao_liquid_crypto_enq_op_ecdsa_sign(uint8_t dev_id, uint16_t qp_id,
                    enum dao_liquid_crypto_ec_curve_type curve_id,
                    uint16_t nonce_len, uint16_t pkey_len, uint16_t digest_len,
                    const uint8_t *nonce, const uint8_t *pkey,
                    const uint8_t *digest, uint8_t *rs_outdata,
                    uint64_t op_cookie);
 
int dao_liquid_crypto_enq_op_ecdsa_verify(uint8_t dev_id, uint16_t qp_id,
                      enum dao_liquid_crypto_ec_curve_type curve_id,
                      uint16_t r_len, uint16_t s_len, uint16_t digest_len,
                      uint16_t qx_len, uint16_t qy_len, const uint8_t *r_data,
                      const uint8_t *s_data, const uint8_t *digest,
                      const uint8_t *qx_data, const uint8_t *qy_data,
                      uint64_t op_cookie);
 
int dao_liquid_crypto_enq_op_rsa_oaep_enc(uint8_t dev_id, uint16_t qp_id, uint8_t *label,
                      uint16_t label_len, enum dao_lc_hash_type hash_type,
                      uint16_t mod_len, uint16_t exp_len, uint16_t msg_len,
                      const uint8_t *mod, const uint8_t *exp,
                      const uint8_t *msg, uint8_t *em, uint64_t op_cookie);
 
int dao_liquid_crypto_enq_op_rsa_oaep_pvt_exp_dec(uint8_t dev_id, uint16_t qp_id,
                          uint16_t label_len, uint8_t *label,
                          enum dao_lc_hash_type hash_type, uint16_t mod_len,
                          const uint8_t *mod, uint16_t exp_len,
                          const uint8_t *exp, const uint8_t *em,
                          uint8_t *msg, uint64_t op_cookie);
 
int dao_liquid_crypto_enq_op_rsa_oaep_pvt_crt_dec(uint8_t dev_id, uint16_t qp_id, uint8_t *label,
                          uint16_t label_len,
                          enum dao_lc_hash_type hash_type, uint16_t mod_len,
                          uint8_t *p, uint8_t *dP, uint8_t *q, uint8_t *dQ,
                          uint8_t *qInv, uint8_t *em, uint8_t *msg,
                          uint64_t op_cookie);
 
#endif /* __DAO_LIQUID_CRYPTO_H__ */