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>
 
#include "liquid_crypto_asym.h"
 
#define DAO_LC_VERSION "25.08.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_MAX_DIGEST_LEN 64
#define DAO_LC_MAX_AUTH_KEY_LEN 64
 
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;
    union {
        bool encrypt;
        bool auth_gen;
    };
};
/* >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
};
 
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;
 
    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_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;
        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,
};
 
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_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,
};
 
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 {
        uint16_t cipher_auth_payload_len;
        uint16_t iv_len;
        uint16_t aad_len;
        uint16_t digest_len;
    } sym;
    struct {
        uint16_t mod_len;
        uint16_t exp_len;
        uint16_t msg_len;
    } rsa;
    struct {
        uint32_t rand_len;
    } rng;
    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_sym_ctx {
    enum dao_lc_sym_opcode opcode;
    uint16_t iv_len;
    union {
        struct dao_lc_sym_fc_ctx fc;
        struct dao_lc_hmac_hash_ctx hash;
    };
};
 
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;
    };
};
 
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_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,
                     uint8_t *mod, uint8_t *exp, 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, uint8_t *mod,
                     uint8_t *exp, 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, uint8_t *q, uint8_t *dQ, uint8_t *p,
                         uint8_t *dP, uint8_t *qInv, 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,
                         uint8_t *q, uint8_t *dQ, uint8_t *p, uint8_t *dP,
                         uint8_t *qInv, uint8_t *em, uint8_t *msg,
                         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,
                    uint8_t *nonce, uint8_t *pkey, uint8_t *digest_data,
                    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, uint8_t *r_data,
                      uint8_t *s_data, uint8_t *digest, uint8_t *qx_data,
                      uint8_t *qy_data, uint64_t op_cookie);
 
#endif /* __DAO_LIQUID_CRYPTO_H__ */