- Acc - mailweb.openeuler.org

AccLib sig 例会
by openEuler conference 12 Dec '23

12 Dec '23

您好！ sig-AccLib SIG 邀请您参加 2023-12-13 11:00 召开的Zoom会议会议主题：AccLib sig 例会会议内容：【2023/12/13 AccLIb SIG 双周例会 11:00 - 12:00】会议链接：https://linaro-org.zoom.us/j/91879279131 会议纪要：会议链接：https://us06web.zoom.us/j/88567434959?pwd=Cg2BUTho7Bnwet10dhUBPMkxscRzjR.1 会议纪要：https://etherpad.openeuler.org/p/sig-AccLib-meetings 温馨提醒：建议接入会议后修改参会人的姓名，也可以使用您在gitee.com的ID 更多资讯尽在：https://openeuler.org/zh/ Hello! openEuler sig-AccLib SIG invites you to attend the Zoom conference will be held at 2023-12-13 11:00, The subject of the conference is AccLib sig 例会, Summary: 【2023/12/13 AccLIb SIG 双周例会 11:00 - 12:00】会议链接：https://linaro-org.zoom.us/j/91879279131 会议纪要： You can join the meeting at https://us06web.zoom.us/j/88567434959?pwd=Cg2BUTho7Bnwet10dhUBPMkxscRzjR.1. Add topics at https://etherpad.openeuler.org/p/sig-AccLib-meetings. Note: You are advised to change the participant name after joining the conference or use your ID at gitee.com. More information: https://openeuler.org/en/

1 0

[PATCH] uadk/v1: fix static compilation error
by Qi Tao 11 Dec '23

11 Dec '23

Modify the function name to avoid multiple definition of "wd_check_src_dst()" in uadk/v1. Signed-off-by: Qi Tao <taoqi10(a)huawei.com> --- v1/wd_aead.c | 2 +- v1/wd_cipher.c | 2 +- v1/wd_digest.c | 2 +- v1/wd_rsa.c | 2 +- v1/wd_util.c | 2 +- v1/wd_util.h | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/v1/wd_aead.c b/v1/wd_aead.c index 380daf0..311b01c 100644 --- a/v1/wd_aead.c +++ b/v1/wd_aead.c @@ -540,7 +540,7 @@ static int param_check(struct wcrypto_aead_ctx *a_ctx, return -WD_EINVAL; } - ret = wd_check_src_dst(a_opdata[i]->in, a_opdata[i]->in_bytes, a_opdata[i]->out, a_opdata[i]->out_bytes); + ret = wd_check_src_dst_v1(a_opdata[i]->in, a_opdata[i]->in_bytes, a_opdata[i]->out, a_opdata[i]->out_bytes); if (unlikely(ret)) { WD_ERR("invalid: src/dst addr is NULL when src/dst size is non-zero!\n"); return -WD_EINVAL; diff --git a/v1/wd_cipher.c b/v1/wd_cipher.c index 0877993..1d8cb94 100644 --- a/v1/wd_cipher.c +++ b/v1/wd_cipher.c @@ -432,7 +432,7 @@ static int param_check(struct wcrypto_cipher_ctx *c_ctx, return -WD_EINVAL; } - ret = wd_check_src_dst(c_opdata[i]->in, c_opdata[i]->in_bytes, c_opdata[i]->out, c_opdata[i]->out_bytes); + ret = wd_check_src_dst_v1(c_opdata[i]->in, c_opdata[i]->in_bytes, c_opdata[i]->out, c_opdata[i]->out_bytes); if (unlikely(ret)) { WD_ERR("invalid: src/dst addr is NULL when src/dst size is non-zero!\n"); return -WD_EINVAL; diff --git a/v1/wd_digest.c b/v1/wd_digest.c index cb9b6e0..e9d2dc1 100644 --- a/v1/wd_digest.c +++ b/v1/wd_digest.c @@ -437,7 +437,7 @@ static int param_check(struct wcrypto_digest_ctx *d_ctx, return -WD_EINVAL; } - ret = wd_check_src_dst(d_opdata[i]->in, d_opdata[i]->in_bytes, + ret = wd_check_src_dst_v1(d_opdata[i]->in, d_opdata[i]->in_bytes, d_opdata[i]->out, d_opdata[i]->out_bytes); if (unlikely(ret)) { WD_ERR("invalid: src/dst addr is NULL when src/dst size is non-zero!\n"); diff --git a/v1/wd_rsa.c b/v1/wd_rsa.c index 9e467d0..5d429b4 100644 --- a/v1/wd_rsa.c +++ b/v1/wd_rsa.c @@ -961,7 +961,7 @@ static int do_rsa_prepare(struct wcrypto_rsa_ctx *ctxt, return -WD_EINVAL; } - ret = wd_check_src_dst(opdata->in, opdata->in_bytes, opdata->out, opdata->out_bytes); + ret = wd_check_src_dst_v1(opdata->in, opdata->in_bytes, opdata->out, opdata->out_bytes); if (unlikely(ret)) { WD_ERR("invalid: src/dst addr is NULL when src/dst size is non-zero!\n"); return -WD_EINVAL; diff --git a/v1/wd_util.c b/v1/wd_util.c index f31d138..d577d6e 100644 --- a/v1/wd_util.c +++ b/v1/wd_util.c @@ -183,7 +183,7 @@ int wd_burst_recv(struct wd_queue *q, void **resp, __u32 num) return drv_recv(q, resp, num); } -int wd_check_src_dst(void *src, __u32 in_bytes, void *dst, __u32 out_bytes) +int wd_check_src_dst_v1(void *src, __u32 in_bytes, void *dst, __u32 out_bytes) { if (unlikely((in_bytes && !src) || (out_bytes && !dst))) return -WD_EINVAL; diff --git a/v1/wd_util.h b/v1/wd_util.h index 9e5fa90..6242f94 100644 --- a/v1/wd_util.h +++ b/v1/wd_util.h @@ -421,6 +421,6 @@ void drv_set_sgl_pri(struct wd_sgl *sgl, void *priv); void *drv_get_sgl_pri(struct wd_sgl *sgl); struct wd_mm_br *drv_get_br(void *pool); void wd_sgl_memset(struct wd_sgl *sgl, int ch); -int wd_check_src_dst(void *src, __u32 in_bytes, void *dst, __u32 out_bytes); +int wd_check_src_dst_v1(void *src, __u32 in_bytes, void *dst, __u32 out_bytes); #endif -- 2.33.0

1 0

[PATCH] uadk: fix sec send and recv check failed
by Yang Shen 09 Dec '23

09 Dec '23

From: Wenkai Lin <linwenkai6(a)hisilicon.com> The send and recv pointers should be assigned at the beginning, not during wd initialization. Signed-off-by: Wenkai Lin <linwenkai6(a)hisilicon.com> --- drv/hisi_sec.c | 260 ++++++++++++++++++++++++++++--------------------- 1 file changed, 149 insertions(+), 111 deletions(-) diff --git a/drv/hisi_sec.c b/drv/hisi_sec.c index d7369fe..2948fe1 100644 --- a/drv/hisi_sec.c +++ b/drv/hisi_sec.c @@ -539,12 +539,93 @@ static __u32 g_sec_hmac_full_len[WD_DIGEST_TYPE_MAX] = { static int hisi_sec_init(void *conf, void *priv); static void hisi_sec_exit(void *priv); +static int hisi_sec_cipher_send(handle_t ctx, void *wd_msg); +static int hisi_sec_cipher_recv(handle_t ctx, void *wd_msg); +static int hisi_sec_cipher_send_v3(handle_t ctx, void *wd_msg); +static int hisi_sec_cipher_recv_v3(handle_t ctx, void *wd_msg); + +static int hisi_sec_digest_send(handle_t ctx, void *wd_msg); +static int hisi_sec_digest_recv(handle_t ctx, void *wd_msg); +static int hisi_sec_digest_send_v3(handle_t ctx, void *wd_msg); +static int hisi_sec_digest_recv_v3(handle_t ctx, void *wd_msg); + +static int hisi_sec_aead_send(handle_t ctx, void *wd_msg); +static int hisi_sec_aead_recv(handle_t ctx, void *wd_msg); +static int hisi_sec_aead_send_v3(handle_t ctx, void *wd_msg); +static int hisi_sec_aead_recv_v3(handle_t ctx, void *wd_msg); + +static int cipher_send(handle_t ctx, void *msg) +{ + handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); + struct hisi_qp *qp = (struct hisi_qp *)h_qp; + struct hisi_qm_queue_info q_info = qp->q_info; + + if (q_info.hw_type == HISI_QM_API_VER2_BASE) + return hisi_sec_cipher_send(ctx, msg); + return hisi_sec_cipher_send_v3(ctx, msg); +} + +static int cipher_recv(handle_t ctx, void *msg) +{ + handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); + struct hisi_qp *qp = (struct hisi_qp *)h_qp; + struct hisi_qm_queue_info q_info = qp->q_info; + + if (q_info.hw_type == HISI_QM_API_VER2_BASE) + return hisi_sec_cipher_recv(ctx, msg); + return hisi_sec_cipher_recv_v3(ctx, msg); +} + +static int digest_send(handle_t ctx, void *msg) +{ + handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); + struct hisi_qp *qp = (struct hisi_qp *)h_qp; + struct hisi_qm_queue_info q_info = qp->q_info; + + if (q_info.hw_type == HISI_QM_API_VER2_BASE) + return hisi_sec_digest_send(ctx, msg); + return hisi_sec_digest_send_v3(ctx, msg); +} + +static int digest_recv(handle_t ctx, void *msg) +{ + handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); + struct hisi_qp *qp = (struct hisi_qp *)h_qp; + struct hisi_qm_queue_info q_info = qp->q_info; + + if (q_info.hw_type == HISI_QM_API_VER2_BASE) + return hisi_sec_digest_recv(ctx, msg); + return hisi_sec_digest_recv_v3(ctx, msg); +} + +static int aead_send(handle_t ctx, void *msg) +{ + handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); + struct hisi_qp *qp = (struct hisi_qp *)h_qp; + struct hisi_qm_queue_info q_info = qp->q_info; + + if (q_info.hw_type == HISI_QM_API_VER2_BASE) + return hisi_sec_aead_send(ctx, msg); + return hisi_sec_aead_send_v3(ctx, msg); +} + +static int aead_recv(handle_t ctx, void *msg) +{ + handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); + struct hisi_qp *qp = (struct hisi_qp *)h_qp; + struct hisi_qm_queue_info q_info = qp->q_info; + + if (q_info.hw_type == HISI_QM_API_VER2_BASE) + return hisi_sec_aead_recv(ctx, msg); + return hisi_sec_aead_recv_v3(ctx, msg); +} + static int hisi_sec_get_usage(void *param) { return 0; } -#define GEN_SEC_ALG_DRIVER(sec_alg_name) \ +#define GEN_SEC_ALG_DRIVER(sec_alg_name, alg_type) \ {\ .drv_name = "hisi_sec2",\ .alg_name = (sec_alg_name),\ @@ -556,57 +637,59 @@ static int hisi_sec_get_usage(void *param) .fallback = 0,\ .init = hisi_sec_init,\ .exit = hisi_sec_exit,\ + .send = alg_type##_send,\ + .recv = alg_type##_recv,\ .get_usage = hisi_sec_get_usage,\ } static struct wd_alg_driver cipher_alg_driver[] = { - GEN_SEC_ALG_DRIVER("ecb(aes)"), - GEN_SEC_ALG_DRIVER("cbc(aes)"), - GEN_SEC_ALG_DRIVER("xts(aes)"), - GEN_SEC_ALG_DRIVER("ecb(sm4)"), - GEN_SEC_ALG_DRIVER("cbc(sm4)"), - GEN_SEC_ALG_DRIVER("ctr(sm4)"), - GEN_SEC_ALG_DRIVER("xts(sm4)"), - GEN_SEC_ALG_DRIVER("ecb(des)"), - GEN_SEC_ALG_DRIVER("cbc(des)"), - GEN_SEC_ALG_DRIVER("ecb(des3_ede)"), - GEN_SEC_ALG_DRIVER("cbc(des3_ede)"), - - GEN_SEC_ALG_DRIVER("ctr(aes)"), - GEN_SEC_ALG_DRIVER("ofb(aes)"), - GEN_SEC_ALG_DRIVER("cfb(aes)"), - GEN_SEC_ALG_DRIVER("cbc-cs1(aes)"), - GEN_SEC_ALG_DRIVER("cbc-cs2(aes)"), - GEN_SEC_ALG_DRIVER("cbc-cs3(aes)"), - GEN_SEC_ALG_DRIVER("ofb(sm4)"), - GEN_SEC_ALG_DRIVER("cfb(sm4)"), - GEN_SEC_ALG_DRIVER("cbc-cs1(sm4)"), - GEN_SEC_ALG_DRIVER("cbc-cs2(sm4)"), - GEN_SEC_ALG_DRIVER("cbc-cs3(sm4)"), + GEN_SEC_ALG_DRIVER("ecb(aes)", cipher), + GEN_SEC_ALG_DRIVER("cbc(aes)", cipher), + GEN_SEC_ALG_DRIVER("xts(aes)", cipher), + GEN_SEC_ALG_DRIVER("ecb(sm4)", cipher), + GEN_SEC_ALG_DRIVER("cbc(sm4)", cipher), + GEN_SEC_ALG_DRIVER("ctr(sm4)", cipher), + GEN_SEC_ALG_DRIVER("xts(sm4)", cipher), + GEN_SEC_ALG_DRIVER("ecb(des)", cipher), + GEN_SEC_ALG_DRIVER("cbc(des)", cipher), + GEN_SEC_ALG_DRIVER("ecb(des3_ede)", cipher), + GEN_SEC_ALG_DRIVER("cbc(des3_ede)", cipher), + + GEN_SEC_ALG_DRIVER("ctr(aes)", cipher), + GEN_SEC_ALG_DRIVER("ofb(aes)", cipher), + GEN_SEC_ALG_DRIVER("cfb(aes)", cipher), + GEN_SEC_ALG_DRIVER("cbc-cs1(aes)", cipher), + GEN_SEC_ALG_DRIVER("cbc-cs2(aes)", cipher), + GEN_SEC_ALG_DRIVER("cbc-cs3(aes)", cipher), + GEN_SEC_ALG_DRIVER("ofb(sm4)", cipher), + GEN_SEC_ALG_DRIVER("cfb(sm4)", cipher), + GEN_SEC_ALG_DRIVER("cbc-cs1(sm4)", cipher), + GEN_SEC_ALG_DRIVER("cbc-cs2(sm4)", cipher), + GEN_SEC_ALG_DRIVER("cbc-cs3(sm4)", cipher), }; static struct wd_alg_driver digest_alg_driver[] = { - GEN_SEC_ALG_DRIVER("sm3"), - GEN_SEC_ALG_DRIVER("md5"), - GEN_SEC_ALG_DRIVER("sha1"), - GEN_SEC_ALG_DRIVER("sha224"), - GEN_SEC_ALG_DRIVER("sha256"), - GEN_SEC_ALG_DRIVER("sha384"), - GEN_SEC_ALG_DRIVER("sha512"), - GEN_SEC_ALG_DRIVER("sha512-224"), - GEN_SEC_ALG_DRIVER("sha512-256"), - GEN_SEC_ALG_DRIVER("xcbc-mac-96(aes)"), - GEN_SEC_ALG_DRIVER("xcbc-prf-128(aes)"), - GEN_SEC_ALG_DRIVER("cmac(aes)"), - GEN_SEC_ALG_DRIVER("gmac(aes)"), + GEN_SEC_ALG_DRIVER("sm3", digest), + GEN_SEC_ALG_DRIVER("md5", digest), + GEN_SEC_ALG_DRIVER("sha1", digest), + GEN_SEC_ALG_DRIVER("sha224", digest), + GEN_SEC_ALG_DRIVER("sha256", digest), + GEN_SEC_ALG_DRIVER("sha384", digest), + GEN_SEC_ALG_DRIVER("sha512", digest), + GEN_SEC_ALG_DRIVER("sha512-224", digest), + GEN_SEC_ALG_DRIVER("sha512-256", digest), + GEN_SEC_ALG_DRIVER("xcbc-mac-96(aes)", digest), + GEN_SEC_ALG_DRIVER("xcbc-prf-128(aes)", digest), + GEN_SEC_ALG_DRIVER("cmac(aes)", digest), + GEN_SEC_ALG_DRIVER("gmac(aes)", digest), }; static struct wd_alg_driver aead_alg_driver[] = { - GEN_SEC_ALG_DRIVER("ccm(aes)"), - GEN_SEC_ALG_DRIVER("gcm(aes)"), - GEN_SEC_ALG_DRIVER("authenc(hmac(sha256),cbc(aes))"), - GEN_SEC_ALG_DRIVER("ccm(sm4)"), - GEN_SEC_ALG_DRIVER("gcm(sm4)"), + GEN_SEC_ALG_DRIVER("ccm(aes)", aead), + GEN_SEC_ALG_DRIVER("gcm(aes)", aead), + GEN_SEC_ALG_DRIVER("authenc(hmac(sha256),cbc(aes))", aead), + GEN_SEC_ALG_DRIVER("ccm(sm4)", aead), + GEN_SEC_ALG_DRIVER("gcm(sm4)", aead), }; static void dump_sec_msg(void *msg, const char *alg) @@ -1093,10 +1176,10 @@ static int fill_cipher_bd2(struct wd_cipher_msg *msg, struct hisi_sec_sqe *sqe) return 0; } -int hisi_sec_cipher_send(handle_t ctx, void *cipher_msg) +static int hisi_sec_cipher_send(handle_t ctx, void *wd_msg) { handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); - struct wd_cipher_msg *msg = cipher_msg; + struct wd_cipher_msg *msg = wd_msg; struct hisi_sec_sqe sqe; __u16 count = 0; int ret; @@ -1139,10 +1222,10 @@ int hisi_sec_cipher_send(handle_t ctx, void *cipher_msg) return 0; } -int hisi_sec_cipher_recv(handle_t ctx, void *cipher_msg) +int hisi_sec_cipher_recv(handle_t ctx, void *wd_msg) { handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); - struct wd_cipher_msg *recv_msg = cipher_msg; + struct wd_cipher_msg *recv_msg = wd_msg; struct hisi_sec_sqe sqe; __u16 count = 0; int ret; @@ -1298,10 +1381,10 @@ static int fill_cipher_bd3(struct wd_cipher_msg *msg, struct hisi_sec_sqe3 *sqe) return 0; } -int hisi_sec_cipher_send_v3(handle_t ctx, void *cipher_msg) +static int hisi_sec_cipher_send_v3(handle_t ctx, void *wd_msg) { handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); - struct wd_cipher_msg *msg = cipher_msg; + struct wd_cipher_msg *msg = wd_msg; struct hisi_sec_sqe3 sqe; __u16 count = 0; int ret; @@ -1389,10 +1472,10 @@ static void parse_cipher_bd3(struct hisi_qp *qp, struct hisi_sec_sqe3 *sqe, dump_sec_msg(temp_msg, "cipher"); } -int hisi_sec_cipher_recv_v3(handle_t ctx, void *cipher_msg) +int hisi_sec_cipher_recv_v3(handle_t ctx, void *wd_msg) { handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); - struct wd_cipher_msg *recv_msg = cipher_msg; + struct wd_cipher_msg *recv_msg = wd_msg; struct hisi_sec_sqe3 sqe; __u16 count = 0; int ret; @@ -1662,10 +1745,10 @@ static int digest_len_check(struct wd_digest_msg *msg, enum sec_bd_type type) return 0; } -int hisi_sec_digest_send(handle_t ctx, void *digest_msg) +static int hisi_sec_digest_send(handle_t ctx, void *wd_msg) { handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); - struct wd_digest_msg *msg = digest_msg; + struct wd_digest_msg *msg = wd_msg; struct hisi_sec_sqe sqe; __u16 count = 0; __u8 scene; @@ -1729,10 +1812,10 @@ put_sgl: return ret; } -int hisi_sec_digest_recv(handle_t ctx, void *digest_msg) +int hisi_sec_digest_recv(handle_t ctx, void *wd_msg) { handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); - struct wd_digest_msg *recv_msg = digest_msg; + struct wd_digest_msg *recv_msg = wd_msg; struct hisi_sec_sqe sqe; __u16 count = 0; int ret; @@ -1906,10 +1989,10 @@ static void fill_digest_v3_scene(struct hisi_sec_sqe3 *sqe, sqe->bd_param |= (__u16)(de | scene); } -int hisi_sec_digest_send_v3(handle_t ctx, void *digest_msg) +static int hisi_sec_digest_send_v3(handle_t ctx, void *wd_msg) { handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); - struct wd_digest_msg *msg = digest_msg; + struct wd_digest_msg *msg = wd_msg; struct hisi_sec_sqe3 sqe; __u16 count = 0; int ret; @@ -2006,10 +2089,10 @@ static void parse_digest_bd3(struct hisi_qp *qp, struct hisi_sec_sqe3 *sqe, dump_sec_msg(temp_msg, "digest"); } -int hisi_sec_digest_recv_v3(handle_t ctx, void *digest_msg) +int hisi_sec_digest_recv_v3(handle_t ctx, void *wd_msg) { handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); - struct wd_digest_msg *recv_msg = digest_msg; + struct wd_digest_msg *recv_msg = wd_msg; struct hisi_sec_sqe3 sqe; __u16 count = 0; int ret; @@ -2478,10 +2561,10 @@ int aead_msg_state_check(struct wd_aead_msg *msg) return 0; } -int hisi_sec_aead_send(handle_t ctx, void *aead_msg) +static int hisi_sec_aead_send(handle_t ctx, void *wd_msg) { handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); - struct wd_aead_msg *msg = aead_msg; + struct wd_aead_msg *msg = wd_msg; struct hisi_sec_sqe sqe; __u16 count = 0; int ret; @@ -2600,10 +2683,10 @@ static bool soft_compute_check(struct hisi_qp *qp, struct wd_aead_msg *msg) qp->q_info.qp_mode == CTX_MODE_SYNC; } -int hisi_sec_aead_recv(handle_t ctx, void *aead_msg) +int hisi_sec_aead_recv(handle_t ctx, void *wd_msg) { handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); - struct wd_aead_msg *recv_msg = aead_msg; + struct wd_aead_msg *recv_msg = wd_msg; struct hisi_sec_sqe sqe; __u16 count = 0; int ret; @@ -2864,10 +2947,10 @@ static int fill_aead_bd3(struct wd_aead_msg *msg, struct hisi_sec_sqe3 *sqe) return 0; } -int hisi_sec_aead_send_v3(handle_t ctx, void *aead_msg) +static int hisi_sec_aead_send_v3(handle_t ctx, void *wd_msg) { handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); - struct wd_aead_msg *msg = aead_msg; + struct wd_aead_msg *msg = wd_msg; struct hisi_sec_sqe3 sqe; __u16 count = 0; int ret; @@ -2965,10 +3048,10 @@ static void parse_aead_bd3(struct hisi_qp *qp, struct hisi_sec_sqe3 *sqe, dump_sec_msg(temp_msg, "aead"); } -int hisi_sec_aead_recv_v3(handle_t ctx, void *aead_msg) +int hisi_sec_aead_recv_v3(handle_t ctx, void *wd_msg) { handle_t h_qp = (handle_t)wd_ctx_get_priv(ctx); - struct wd_aead_msg *recv_msg = aead_msg; + struct wd_aead_msg *recv_msg = wd_msg; struct hisi_sec_sqe3 sqe; __u16 count = 0; int ret; @@ -2993,50 +3076,6 @@ int hisi_sec_aead_recv_v3(handle_t ctx, void *aead_msg) return 0; } -static void hisi_sec_driver_adapter(struct hisi_qp *qp) -{ - struct hisi_qm_queue_info q_info = qp->q_info; - int alg_num, i; - - if (q_info.hw_type == HISI_QM_API_VER2_BASE) { - WD_INFO("hisi sec init HIP08!\n"); - alg_num = ARRAY_SIZE(cipher_alg_driver); - for (i = 0; i < alg_num; i++) { - cipher_alg_driver[i].send = hisi_sec_cipher_send; - cipher_alg_driver[i].recv = hisi_sec_cipher_recv; - } - - alg_num = ARRAY_SIZE(digest_alg_driver); - for (i = 0; i < alg_num; i++) { - digest_alg_driver[i].send = hisi_sec_digest_send; - digest_alg_driver[i].recv = hisi_sec_digest_recv; - } - alg_num = ARRAY_SIZE(aead_alg_driver); - for (i = 0; i < alg_num; i++) { - aead_alg_driver[i].send = hisi_sec_aead_send; - aead_alg_driver[i].recv = hisi_sec_aead_recv; - } - } else { - WD_INFO("hisi sec init HIP09!\n"); - alg_num = ARRAY_SIZE(cipher_alg_driver); - for (i = 0; i < alg_num; i++) { - cipher_alg_driver[i].send = hisi_sec_cipher_send_v3; - cipher_alg_driver[i].recv = hisi_sec_cipher_recv_v3; - } - - alg_num = ARRAY_SIZE(digest_alg_driver); - for (i = 0; i < alg_num; i++) { - digest_alg_driver[i].send = hisi_sec_digest_send_v3; - digest_alg_driver[i].recv = hisi_sec_digest_recv_v3; - } - alg_num = ARRAY_SIZE(aead_alg_driver); - for (i = 0; i < alg_num; i++) { - aead_alg_driver[i].send = hisi_sec_aead_send_v3; - aead_alg_driver[i].recv = hisi_sec_aead_recv_v3; - } - } -} - static int hisi_sec_init(void *conf, void *priv) { struct wd_ctx_config_internal *config = conf; @@ -3068,7 +3107,6 @@ static int hisi_sec_init(void *conf, void *priv) config->ctxs[i].sqn = qm_priv.sqn; } memcpy(&sec_ctx->config, config, sizeof(struct wd_ctx_config_internal)); - hisi_sec_driver_adapter((struct hisi_qp *)h_qp); return 0; -- 2.33.0

1 0

[PATCH 0/6] some cleanup and bugfix of hpre
by Zhiqi Song 07 Dec '23

07 Dec '23

Some bugfix and cleanup. Zhiqi Song (6): uadk/v1: fix security view issues of hpre uadk: cleanup issues of hpre uadk/v1/hpre: add parameter check of setup uadk/ecc: fix the use of random k in sm2 sign uadk/v1: cleanup common part code style uadk/sec: add return value judgement drv/hisi_hpre.c | 103 +++++++++++++++++++++++----------------- drv/hisi_sec.c | 4 ++ v1/drv/hisi_hpre_udrv.c | 31 ++++++------ v1/drv/hisi_qm_udrv.c | 16 +++---- v1/wd_adapter.c | 18 +++---- v1/wd_bmm.c | 13 +++-- v1/wd_dh.c | 3 +- v1/wd_ecc.c | 17 +++++-- v1/wd_rsa.c | 6 ++- v1/wd_sgl.c | 27 +++++++++-- wd_dh.c | 16 +++---- wd_ecc.c | 34 ++++++++----- wd_rsa.c | 14 +++--- 13 files changed, 181 insertions(+), 121 deletions(-) -- 2.33.0

1 6

[PATCH] uadk: add null pointer check
by Qi Tao 05 Dec '23

05 Dec '23

From: taoqi 30043660 <taoqi10(a)huawei.com> Whether the pointer is NULL is not checked after the memory is applied for. Signed-off-by: taoqi 30043660 <taoqi10(a)huawei.com> --- v1/wd_dh.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/v1/wd_dh.c b/v1/wd_dh.c index 3be6250..d574c1d 100644 --- a/v1/wd_dh.c +++ b/v1/wd_dh.c @@ -185,6 +185,10 @@ void *wcrypto_create_dh_ctx(struct wd_queue *q, struct wcrypto_dh_ctx_setup *set goto free_ctx; } ctx->g.data = ctx->setup.br.alloc(ctx->setup.br.usr, ctx->key_size); + if (!ctx->g.data) { + WD_ERR("failed to alloc ctx->g.data memory!\n"); + goto free_ctx; + } ctx->g.bsize = ctx->key_size; ret = wcrypto_init_dh_cookie(ctx); -- 2.33.0

1 0

[PATCH 00/11] bugfix and codecleanup for uadk v1 and v2
by Qi Tao 04 Dec '23

04 Dec '23

From: Chenghai Huang <huangchenghai2(a)huawei.com> Fixed some bugs of uadk v1 and v2, optimized code function processing, and added file association in compiled files. Chenghai Huang (11): uadk: Add file association uadk: fix the failure process bug uadk: fix the failure process bug uadk: fix the failure process bug uadk: bugfix uadk v1: adapter code cleanup uadk v1: fix wd_rng resource release bug uadk v1: code cleanup for error codes and header files uadk: concentrate the same definitions uadk v1: optimize the function length uadk v1: concentrate the same definitions Makefile.am | 4 +- drv/hisi_sec.c | 11 +----- include/wd_alg_common.h | 13 +++++++ include/wd_cipher.h | 1 - include/wd_digest.h | 2 - v1/drv/hisi_sec_udrv.c | 11 +----- v1/wd.c | 63 ++++++++++++++++--------------- v1/wd_adapter.c | 6 +-- v1/wd_aead.c | 15 -------- v1/wd_cipher.c | 9 +---- v1/wd_digest.c | 84 ++++++++++++++++++++++++++--------------- v1/wd_rng.c | 8 ++-- v1/wd_util.h | 17 +++++++++ wd.c | 2 +- wd_aead.c | 9 ----- wd_cipher.c | 7 ---- wd_digest.c | 9 ----- wd_mempool.c | 3 +- wd_sched.c | 2 +- wd_util.c | 1 + 20 files changed, 133 insertions(+), 144 deletions(-) -- 2.30.0

1 0

[PATCH] uadk_engine: fix env poll timeout in abnormal scenarios
by Zhiqi Song 30 Nov '23

30 Nov '23

In abnormal scenarios, if the alg cores of hardware device are closed, the hw async task may return busy and can not finish the task. There is be a max loop count to avoid infinite loop. But there is already a 'MAX_POLL_TIMES' (1000) in uadk default poll policy. If engine use 'ENGINE_RECV_MAX_CNT' to control the poll loop count, the actual count will be: MAX_POLL_TIMES * ENGINE_RECV_MAX_CNT which is too large. This will cause the process use a very long time to exit. So modify the env poll loop time count. Signed-off-by: Zhiqi Song <songzhiqi1(a)huawei.com> --- README | 2 +- src/uadk.h | 1 + src/uadk_aead.c | 2 +- src/uadk_cipher.c | 2 +- src/uadk_dh.c | 2 +- src/uadk_digest.c | 2 +- src/uadk_pkey.c | 2 +- src/uadk_rsa.c | 2 +- 8 files changed, 8 insertions(+), 7 deletions(-) diff --git a/README b/README index cd27ccb..9586e60 100644 --- a/README +++ b/README @@ -180,7 +180,7 @@ Usage 1. Firstly, modify the openssl.cnf file, add the following settings at the beginning of this file: ``` -openssl_cnf=openssl_def +openssl_conf=openssl_def [openssl_def] engines=engine_section [engine_section] diff --git a/src/uadk.h b/src/uadk.h index ed7dbf1..d212033 100644 --- a/src/uadk.h +++ b/src/uadk.h @@ -22,6 +22,7 @@ #define ENV_STRING_LEN 256 #define ENGINE_SEND_MAX_CNT 90000000 #define ENGINE_RECV_MAX_CNT 60000000 +#define ENGINE_ENV_RECV_MAX_CNT 60000 #define UADK_UNINIT 0 #define UADK_INIT_SUCCESS 1 #define UADK_INIT_FAIL 2 diff --git a/src/uadk_aead.c b/src/uadk_aead.c index e127af8..619b50c 100644 --- a/src/uadk_aead.c +++ b/src/uadk_aead.c @@ -81,7 +81,7 @@ static int uadk_e_aead_env_poll(void *ctx) if (ret < 0 || recv == expt) return ret; rx_cnt++; - } while (rx_cnt < ENGINE_RECV_MAX_CNT); + } while (rx_cnt < ENGINE_ENV_RECV_MAX_CNT); fprintf(stderr, "failed to poll msg: timeout!\n"); diff --git a/src/uadk_cipher.c b/src/uadk_cipher.c index 736a8af..deed97d 100644 --- a/src/uadk_cipher.c +++ b/src/uadk_cipher.c @@ -364,7 +364,7 @@ static int uadk_e_cipher_env_poll(void *ctx) if (ret < 0 || recv == expt) return ret; rx_cnt++; - } while (rx_cnt < ENGINE_RECV_MAX_CNT); + } while (rx_cnt < ENGINE_ENV_RECV_MAX_CNT); fprintf(stderr, "failed to poll msg: timeout!\n"); diff --git a/src/uadk_dh.c b/src/uadk_dh.c index b451a5f..32874d1 100644 --- a/src/uadk_dh.c +++ b/src/uadk_dh.c @@ -297,7 +297,7 @@ static int uadk_e_dh_env_poll(void *ctx) return ret; } rx_cnt++; - } while (rx_cnt < ENGINE_RECV_MAX_CNT); + } while (rx_cnt < ENGINE_ENV_RECV_MAX_CNT); fprintf(stderr, "failed to poll msg: timeout!\n"); diff --git a/src/uadk_digest.c b/src/uadk_digest.c index fc979bc..c5065a4 100644 --- a/src/uadk_digest.c +++ b/src/uadk_digest.c @@ -390,7 +390,7 @@ static int uadk_e_digest_env_poll(void *ctx) if (ret < 0 || recv == expt) return ret; rx_cnt++; - } while (rx_cnt < ENGINE_RECV_MAX_CNT); + } while (rx_cnt < ENGINE_ENV_RECV_MAX_CNT); fprintf(stderr, "failed to poll msg: timeout!\n"); diff --git a/src/uadk_pkey.c b/src/uadk_pkey.c index 2cec16e..7c115fe 100644 --- a/src/uadk_pkey.c +++ b/src/uadk_pkey.c @@ -182,7 +182,7 @@ static int uadk_e_ecc_env_poll(void *ctx) return ret; } rx_cnt++; - } while (rx_cnt < ENGINE_RECV_MAX_CNT); + } while (rx_cnt < ENGINE_ENV_RECV_MAX_CNT); fprintf(stderr, "failed to poll msg: timeout!\n"); diff --git a/src/uadk_rsa.c b/src/uadk_rsa.c index 09d34b4..1594b74 100644 --- a/src/uadk_rsa.c +++ b/src/uadk_rsa.c @@ -719,7 +719,7 @@ static int uadk_e_rsa_env_poll(void *ctx) return ret; } rx_cnt++; - } while (rx_cnt < ENGINE_RECV_MAX_CNT); + } while (rx_cnt < ENGINE_ENV_RECV_MAX_CNT); fprintf(stderr, "failed to poll msg: timeout!\n"); -- 2.30.0

1 0

[PATCH 0/8] some bugfix and cleanup for uadk
by Qi Tao 30 Nov '23

30 Nov '23

*** BLURB HERE *** Chenghai Huang (2): uadk: code cleanup uadk: code cleanup for error codes and variable type Longfang Liu (1): uadk: fixed some input parameter checking issues Qi Tao (2): uadk: fix header file is not self contained sec/uadk: resolve white-box security review comments Wenkai Lin (2): uadk/v1: remove print actions after wd_get_cookies uadk: fix sec send and recv check failed Zhiqi Song (1): uadk/sec: add return value judgement drv/hisi_sec.c | 276 +++++++++++++++++++++++----------------- include/wd.h | 1 + include/wd_alg_common.h | 1 + include/wd_cipher.h | 1 + include/wd_sched.h | 1 + include/wd_util.h | 14 ++ v1/wd_aead.c | 4 +- v1/wd_cipher.c | 4 +- v1/wd_digest.c | 4 +- wd.c | 6 +- wd_aead.c | 13 +- wd_cipher.c | 13 +- wd_comp.c | 4 +- wd_dh.c | 4 +- wd_digest.c | 12 +- wd_ecc.c | 4 +- wd_rsa.c | 4 +- wd_sched.c | 14 +- wd_util.c | 10 +- 19 files changed, 244 insertions(+), 146 deletions(-) -- 2.33.0

1 8

[PATCH 1/7] v1/hpre: fix key transfer error issue
by Weili Qian 30 Nov '23

30 Nov '23

Currently, the RSA algorithm calls qm_crypto_bin_to_hpre_bin() to transfer the key when sending request. However, the key needs to be transferred only once, repeated transfer may cause data inconsistency with original user's data, resulting in incorrect calculation results. Therefore, after the key is transferred, the 'dsize' is changed to the 'bsize', When 'disze' and 'bsize' are equal, no transfer is performed. Signed-off-by: Weili Qian <qianweili(a)huawei.com> --- v1/drv/hisi_hpre_udrv.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/v1/drv/hisi_hpre_udrv.c b/v1/drv/hisi_hpre_udrv.c index 193ba56..0d0c3b4 100644 --- a/v1/drv/hisi_hpre_udrv.c +++ b/v1/drv/hisi_hpre_udrv.c @@ -136,27 +136,32 @@ static int qm_fill_rsa_crt_prikey2(struct wcrypto_rsa_prikey *prikey, wd_dq->bsize, wd_dq->dsize, "rsa crt dq"); if (unlikely(ret)) return ret; + wd_dq->dsize = wd_dq->bsize; ret = qm_crypto_bin_to_hpre_bin(wd_dp->data, (const char *)wd_dp->data, wd_dp->bsize, wd_dp->dsize, "rsa crt dp"); if (unlikely(ret)) return ret; + wd_dp->dsize = wd_dp->bsize; ret = qm_crypto_bin_to_hpre_bin(wd_q->data, (const char *)wd_q->data, wd_q->bsize, wd_q->dsize, "rsa crt q"); if (unlikely(ret)) return ret; + wd_q->dsize = wd_q->bsize; ret = qm_crypto_bin_to_hpre_bin(wd_p->data, (const char *)wd_p->data, wd_p->bsize, wd_p->dsize, "rsa crt p"); if (unlikely(ret)) return ret; + wd_p->dsize = wd_p->bsize; ret = qm_crypto_bin_to_hpre_bin(wd_qinv->data, (const char *)wd_qinv->data, wd_qinv->bsize, wd_qinv->dsize, "rsa crt qinv"); if (unlikely(ret)) return ret; + wd_qinv->dsize = wd_qinv->bsize; *data = wd_dq->data; return (int)(wd_dq->bsize + wd_qinv->bsize + wd_p->bsize + @@ -179,11 +184,13 @@ static int qm_fill_rsa_prikey1(struct wcrypto_rsa_prikey *prikey, void **data) wd_d->bsize, wd_d->dsize, "rsa prikey1 d"); if (unlikely(ret)) return ret; + wd_d->dsize = wd_d->bsize; ret = qm_crypto_bin_to_hpre_bin(wd_n->data, (const char *)wd_n->data, wd_n->bsize, wd_n->dsize, "rsa prikey1 n"); if (unlikely(ret)) return ret; + wd_n->dsize = wd_n->bsize; *data = wd_d->data; return (int)(wd_n->bsize + wd_d->bsize); @@ -200,11 +207,13 @@ static int qm_fill_rsa_pubkey(struct wcrypto_rsa_pubkey *pubkey, void **data) wd_e->bsize, wd_e->dsize, "rsa pubkey e"); if (unlikely(ret)) return ret; + wd_e->dsize = wd_e->dsize; ret = qm_crypto_bin_to_hpre_bin(wd_n->data, (const char *)wd_n->data, wd_n->bsize, wd_n->dsize, "rsa pubkey n"); if (unlikely(ret)) return ret; + wd_n->dsize = wd_n->dsize; *data = wd_e->data; return (int)(wd_n->bsize + wd_e->bsize); -- 2.33.0

1 6

[PATCH] uadk_cipher: fixup sm4 cfb flags
by Zhiqi Song 29 Nov '23

29 Nov '23

The flags of sm4 cfb should be EVP_CIPH_CFB_MODE, so fix it. Signed-off-by: Zhiqi Song <songzhiqi1(a)huawei.com> --- src/uadk_cipher.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/uadk_cipher.c b/src/uadk_cipher.c index 9392e04..736a8af 100644 --- a/src/uadk_cipher.c +++ b/src/uadk_cipher.c @@ -931,7 +931,7 @@ EVP_CIPHER *uadk_create_cipher_meth(int nid) cipher = uadk_sm4_ofb128; break; case NID_sm4_cfb128: - UADK_CIPHER_DESCR(sm4_cfb128, 1, 16, 16, EVP_CIPH_OFB_MODE); + UADK_CIPHER_DESCR(sm4_cfb128, 1, 16, 16, EVP_CIPH_CFB_MODE); cipher = uadk_sm4_cfb128; break; case NID_sm4_ctr: -- 2.30.0

1 0

Acc SIG例会
by openEuler conference 28 Nov '23

28 Nov '23

您好！ sig-AccLib SIG 邀请您参加 2023-11-29 11:00 召开的Zoom会议会议主题：Acc SIG例会会议内容：【2023/11/29 AccLIb SIG 双周例会 11:00 - 12:00】会议链接：https://linaro-org.zoom.us/j/91879279131 会议纪要：http 会议链接：https://us06web.zoom.us/j/84176755455?pwd=aTc3hw7op6TNGGvc0toqzOj0DeZcme.1 会议纪要：https://etherpad.openeuler.org/p/sig-AccLib-meetings 温馨提醒：建议接入会议后修改参会人的姓名，也可以使用您在gitee.com的ID 更多资讯尽在：https://openeuler.org/zh/ Hello! openEuler sig-AccLib SIG invites you to attend the Zoom conference will be held at 2023-11-29 11:00, The subject of the conference is Acc SIG例会, Summary: 【2023/11/29 AccLIb SIG 双周例会 11:00 - 12:00】会议链接：https://linaro-org.zoom.us/j/91879279131 会议纪要：http You can join the meeting at https://us06web.zoom.us/j/84176755455?pwd=aTc3hw7op6TNGGvc0toqzOj0DeZcme.1. Add topics at https://etherpad.openeuler.org/p/sig-AccLib-meetings. Note: You are advised to change the participant name after joining the conference or use your ID at gitee.com. More information: https://openeuler.org/en/

1 0

[PATCH 00/17] uadk_engine: some bugfix and cleanup
by Zhiqi Song 25 Nov '23

25 Nov '23

This patchset contains some bugfix and cleanup. Hao Fang (6): uadk_engine: cipher/digest: fixes for priv address check uadk_engine: ec: add BN_new memory check uadk_engine: rsa: fix mem leak for from_buf uadk_engine: uadk_rsa: fix to free from_buffer uadk_engine: uask_async: fix thread_attr res leak uadk_engine: async: fix add async send timeout Qi Tao (3): cipher: uadk_e_bind_ciphers function is optimized cipher: UADK_CIPHER_DESCR is optimized uadk_engine/v1: fix g_sec_ciphers_info[] error Weili Qian (2): uadk_engine: add device initialization status sm2: fixup switching soft sm2 decrypt problem Zhiqi Song (6): ecc: optimize sm2 sign check function digest: fix the address of async op uadk_engine: fixup resource management issues ecc: add check of siglen v1/pkey: add check of qlist v1/pkey: fix uninitialized variable src/uadk.h | 5 + src/uadk_aead.c | 39 ++++-- src/uadk_async.c | 14 +- src/uadk_async.h | 1 + src/uadk_cipher.c | 170 ++++++++---------------- src/uadk_cipher_adapter.c | 38 +++--- src/uadk_dh.c | 150 +++++++++++++-------- src/uadk_digest.c | 59 +++++++-- src/uadk_ec.c | 69 ++++++---- src/uadk_ecx.c | 8 +- src/uadk_pkey.c | 113 ++++++++++------ src/uadk_rsa.c | 218 +++++++++++++++++++------------ src/uadk_sm2.c | 42 +++--- src/v1/alg/ciphers/sec_ciphers.c | 2 +- src/v1/alg/pkey/hpre_rsa.c | 13 +- src/v1/alg/pkey/hpre_wd.c | 9 +- 16 files changed, 553 insertions(+), 397 deletions(-) -- 2.33.0

2 18

[PATCH 0/3] Synchronizing the uadk to the linaro repository
by Qi Tao 24 Nov '23

24 Nov '23

*** BLURB HERE *** Qi Tao (2): check whether the data address pointer is not null. uadk/aead: fix dlopen() exception check error Yang Shen (1): uadk/v1/comp - add comp ctx parameters check v1/wd_aead.c | 22 ++++++++++---- v1/wd_cipher.c | 22 ++++++++++---- v1/wd_comp.c | 81 +++++++++++++++++++++++++++++++++++++------------- v1/wd_dh.c | 6 ++-- v1/wd_digest.c | 19 ++++++++---- v1/wd_ecc.c | 8 ++--- v1/wd_rng.c | 13 +++++--- v1/wd_rsa.c | 12 ++++++-- v1/wd_util.c | 7 +++++ v1/wd_util.h | 1 + wd_aead.c | 2 +- 11 files changed, 142 insertions(+), 51 deletions(-) -- 2.33.0

1 0

[PATCH 01/10] uadk/v1/drv: hisi_zip_udrv - fix unmap buffer for lz77_zstd stream mode
by Yang Shen 20 Nov '23

20 Nov '23

In uadk v1, the library will alloc a ctx_buffer used for storing stream information. On hisilicon platform, the hardware will output some data to this buffer. So the ctx_buffer should be map to PA/IOVA. But here the lz77_zstd forgot to unmap this buffer on error branch. What's more, if the user use the wd_bmm ops, the unmap is a void function. Signed-off-by: Yang Shen <shenyang39(a)huawei.com> --- v1/drv/hisi_zip_udrv.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/v1/drv/hisi_zip_udrv.c b/v1/drv/hisi_zip_udrv.c index f820b7f..470acb9 100644 --- a/v1/drv/hisi_zip_udrv.c +++ b/v1/drv/hisi_zip_udrv.c @@ -512,6 +512,9 @@ static int fill_zip_addr_lz77_zstd(void *ssqe, unmap_phy_seq: drv_iova_unmap(q, zstd_out->literal, (void *)phy_lit, zstd_out->lit_sz); unmap_phy_lit: + if (msg->stream_mode == WCRYPTO_COMP_STATEFUL) + drv_iova_unmap(q, msg->ctx_buf, (void *)addr.ctxbuf_addr - CTX_BUFFER_OFFSET, + MAX_CTX_RSV_SIZE); drv_iova_unmap(q, msg->src, (void *)addr.source_addr, msg->in_size); return -WD_ENOMEM; } -- 2.33.0

1 9

AccLib SIG双周例会
by openEuler conference 14 Nov '23

14 Nov '23

您好！ sig-AccLib SIG 邀请您参加 2023-11-15 11:00 召开的Zoom会议会议主题：AccLib SIG双周例会会议内容：固定会议链接：https://linaro-org.zoom.us/j/91879279131 会议链接：https://us06web.zoom.us/j/85651976213?pwd=ZANR0TJXwbb2Vpj4mhh1pDm1mrkYsM.1 会议纪要：https://etherpad.openeuler.org/p/sig-AccLib-meetings 温馨提醒：建议接入会议后修改参会人的姓名，也可以使用您在gitee.com的ID 更多资讯尽在：https://openeuler.org/zh/ Hello! openEuler sig-AccLib SIG invites you to attend the Zoom conference will be held at 2023-11-15 11:00, The subject of the conference is AccLib SIG双周例会, Summary: 固定会议链接：https://linaro-org.zoom.us/j/91879279131 You can join the meeting at https://us06web.zoom.us/j/85651976213?pwd=ZANR0TJXwbb2Vpj4mhh1pDm1mrkYsM.1. Add topics at https://etherpad.openeuler.org/p/sig-AccLib-meetings. Note: You are advised to change the participant name after joining the conference or use your ID at gitee.com. More information: https://openeuler.org/en/

1 0

[PATCH 0/8] uadk_engine: support aead aes-gcm and sm4-ecb algorithm
by Wenkai Lin 09 Nov '23

09 Nov '23

From: JiangShui Yang <yangjiangshui(a)h-partners.com> Wenkai Lin (7): uadk_engine: support aead aes-gcm algorithm cipher: fix uadk_e_destroy_cipher memory leak aead: fix for engine lock is not initialized uadk: fix cipher switchover to software calculation fails aead: fix tag length check aead: fix for aes gcm update process cipher: add sm4 ecb mode Zhiqi Song (1): uadk_engine: remove redundant param of async src/Makefile.am | 3 +- src/uadk.h | 3 +- src/uadk_aead.c | 778 ++++++++++++++++++++++++++++++++++++++ src/uadk_async.c | 8 +- src/uadk_async.h | 3 +- src/uadk_cipher.c | 536 +++++++++----------------- src/uadk_cipher_adapter.c | 209 ++++++++++ src/uadk_cipher_adapter.h | 36 ++ src/uadk_dh.c | 4 +- src/uadk_digest.c | 2 +- src/uadk_engine_init.c | 28 +- src/uadk_pkey.c | 2 +- src/uadk_rsa.c | 2 +- 13 files changed, 1246 insertions(+), 368 deletions(-) create mode 100644 src/uadk_aead.c create mode 100644 src/uadk_cipher_adapter.c create mode 100644 src/uadk_cipher_adapter.h -- 2.33.0

1 8

[PATCH 0/4] uadk: add new mode for cipher and digest
by Weili Qian 26 Oct '23

26 Oct '23

Add new mode for cipher and digest Weili Qian (4): uadk/cipher: support sm4-xts GB standard. uadk/v1/cipher: support sm4-xts GB standard uadk/v1/digest: support new AES mode algs uadk/v1: fix long hash state issue drv/hisi_sec.c | 8 ++- include/wd_cipher.h | 3 + v1/drv/hisi_sec_udrv.c | 146 ++++++++++++++++++++++++++++++----------- v1/wd_cipher.c | 3 +- v1/wd_cipher.h | 5 ++ v1/wd_digest.c | 69 +++++++++++++++++-- v1/wd_digest.h | 24 +++++-- v1/wd_util.c | 2 +- wd_alg.c | 3 + wd_cipher.c | 9 +-- 10 files changed, 216 insertions(+), 56 deletions(-) -- 2.33.0

1 4

AccLib-SIG例会
by openEuler conference 17 Oct '23

17 Oct '23

您好！ sig-AccLib SIG 邀请您参加 2023-10-18 11:00 召开的Zoom会议会议主题：AccLib-SIG例会会议链接：https://us06web.zoom.us/j/83885335452?pwd=qa1ToTUPz125bAiKZoOGenGlMzBfAU.1 会议纪要：https://etherpad.openeuler.org/p/sig-AccLib-meetings 温馨提醒：建议接入会议后修改参会人的姓名，也可以使用您在gitee.com的ID 更多资讯尽在：https://openeuler.org/zh/ Hello! openEuler sig-AccLib SIG invites you to attend the Zoom conference will be held at 2023-10-18 11:00, The subject of the conference is AccLib-SIG例会, You can join the meeting at https://us06web.zoom.us/j/83885335452?pwd=qa1ToTUPz125bAiKZoOGenGlMzBfAU.1. Add topics at https://etherpad.openeuler.org/p/sig-AccLib-meetings. Note: You are advised to change the participant name after joining the conference or use your ID at gitee.com. More information: https://openeuler.org/en/

1 0

[PATCH 0/3] digest: alloc session and data when copy evp context
by Qi Tao 13 Oct '23

13 Oct '23

*** BLURB HERE *** Wenkai Lin (3): digest: fix free sess when it is still used digest: fix copy segment fault digest: alloc session and data when copy evp context src/uadk_digest.c | 144 ++++++++++++++++++++++++++++++++-------------- 1 file changed, 102 insertions(+), 42 deletions(-) -- 2.33.0

1 3

[PATCH 01/11 v2] uadk_engine: cleanup code style of async functions
by Zhiqi Song 08 Oct '23

08 Oct '23

Cleanup the return value and judgment code style of async mode functions. Signed-off-by: Zhiqi Song <songzhiqi1(a)huawei.com> --- src/uadk_async.c | 132 +++++++++++++++++++++++------------------------ src/uadk_async.h | 3 ++ 2 files changed, 68 insertions(+), 67 deletions(-) diff --git a/src/uadk_async.c b/src/uadk_async.c index 9251238..3462d67 100644 --- a/src/uadk_async.c +++ b/src/uadk_async.c @@ -48,67 +48,65 @@ static void async_fd_cleanup(ASYNC_WAIT_CTX *ctx, const void *key, int async_setup_async_event_notification(struct async_op *op) { ASYNC_WAIT_CTX *waitctx; + void *custom = NULL; OSSL_ASYNC_FD efd; - void *custom; memset(op, 0, sizeof(struct async_op)); + op->job = ASYNC_get_current_job(); - if (op->job == NULL) - return 1; + if (!op->job) + return DO_SYNC; waitctx = ASYNC_get_wait_ctx(op->job); - if (waitctx == NULL) - return 0; + if (!waitctx) + return UADK_E_FAIL; - if (ASYNC_WAIT_CTX_get_fd(waitctx, engine_uadk_id, - &efd, &custom) == 0) { + if (!ASYNC_WAIT_CTX_get_fd(waitctx, engine_uadk_id, &efd, &custom)) { efd = eventfd(0, EFD_NONBLOCK); if (efd == -1) - return 0; + return UADK_E_FAIL; - if (ASYNC_WAIT_CTX_set_wait_fd(waitctx, engine_uadk_id, efd, - custom, async_fd_cleanup) == 0) { + if (!ASYNC_WAIT_CTX_set_wait_fd(waitctx, engine_uadk_id, efd, + custom, async_fd_cleanup)) { async_fd_cleanup(waitctx, engine_uadk_id, efd, NULL); - return 0; + return UADK_E_FAIL; } } - return 1; + return UADK_E_SUCCESS; } int async_clear_async_event_notification(void) { - ASYNC_JOB *job; ASYNC_WAIT_CTX *waitctx; + void *custom = NULL; OSSL_ASYNC_FD efd; size_t num_add_fds; size_t num_del_fds; - void *custom = NULL; + ASYNC_JOB *job; job = ASYNC_get_current_job(); - if (job == NULL) - return 0; + if (!job) + return UADK_E_FAIL; waitctx = ASYNC_get_wait_ctx(job); - if (waitctx == NULL) - return 0; + if (!waitctx) + return UADK_E_FAIL; - if (ASYNC_WAIT_CTX_get_changed_fds(waitctx, NULL, &num_add_fds, - NULL, &num_del_fds) == 0) - return 0; + if (!ASYNC_WAIT_CTX_get_changed_fds(waitctx, NULL, &num_add_fds, NULL, &num_del_fds)) + return UADK_E_FAIL; if (num_add_fds > 0) { - if (ASYNC_WAIT_CTX_get_fd(waitctx, engine_uadk_id, - &efd, &custom) == 0) - return 0; + if (!ASYNC_WAIT_CTX_get_fd(waitctx, engine_uadk_id, &efd, &custom)) + return UADK_E_FAIL; async_fd_cleanup(waitctx, engine_uadk_id, efd, NULL); - if (ASYNC_WAIT_CTX_clear_fd(waitctx, engine_uadk_id) == 0) - return 0; + if (!ASYNC_WAIT_CTX_clear_fd(waitctx, engine_uadk_id)) + return UADK_E_FAIL; } - return 1; + return UADK_E_SUCCESS; } static void async_poll_task_free(void) @@ -120,11 +118,11 @@ static void async_poll_task_free(void) uadk_e_set_async_poll_state(DISABLE_ASYNC_POLLING); error = pthread_mutex_lock(&poll_queue.async_task_mutex); - if (error != 0) + if (error) return; task = poll_queue.head; - if (task != NULL) + if (task) OPENSSL_free(task); poll_queue.head = NULL; @@ -143,13 +141,13 @@ static int async_get_poll_task(int *id) while (!poll_queue.status[idx]) { idx = (idx + 1) % ASYNC_QUEUE_TASK_NUM; if (cnt++ == ASYNC_QUEUE_TASK_NUM) - return 0; + return UADK_E_FAIL; } *id = idx; poll_queue.rid = (idx + 1) % ASYNC_QUEUE_TASK_NUM; - return 1; + return UADK_E_SUCCESS; } static struct async_poll_task *async_get_queue_task(void) @@ -158,11 +156,11 @@ static struct async_poll_task *async_get_queue_task(void) struct async_poll_task *task_queue; int idx, ret; - if (pthread_mutex_lock(&poll_queue.async_task_mutex) != 0) + if (pthread_mutex_lock(&poll_queue.async_task_mutex)) return NULL; ret = async_get_poll_task(&idx); - if (!ret) + if (ret == UADK_E_FAIL) goto err; task_queue = poll_queue.head; @@ -170,10 +168,10 @@ static struct async_poll_task *async_get_queue_task(void) poll_queue.is_recv = 0; err: - if (pthread_mutex_unlock(&poll_queue.async_task_mutex) != 0) + if (pthread_mutex_unlock(&poll_queue.async_task_mutex)) return NULL; - if (cur_task && cur_task->op == NULL) + if (cur_task && !cur_task->op) return NULL; return cur_task; @@ -181,7 +179,7 @@ err: void async_free_poll_task(int id, bool is_cb) { - if (pthread_mutex_lock(&poll_queue.async_task_mutex) != 0) + if (pthread_mutex_lock(&poll_queue.async_task_mutex)) return; poll_queue.status[id] = 0; @@ -189,7 +187,7 @@ void async_free_poll_task(int id, bool is_cb) if (is_cb) poll_queue.is_recv = 1; - if (pthread_mutex_unlock(&poll_queue.async_task_mutex) != 0) + if (pthread_mutex_unlock(&poll_queue.async_task_mutex)) return; (void)sem_post(&poll_queue.empty_sem); @@ -202,17 +200,17 @@ int async_get_free_task(int *id) int idx, ret; int cnt = 0; - if (sem_wait(&poll_queue.empty_sem) != 0) - return 0; + if (sem_wait(&poll_queue.empty_sem)) + return UADK_E_FAIL; - if (pthread_mutex_lock(&poll_queue.async_task_mutex) != 0) - return 0; + if (pthread_mutex_lock(&poll_queue.async_task_mutex)) + return UADK_E_FAIL; idx = poll_queue.sid; while (poll_queue.status[idx]) { idx = (idx + 1) % ASYNC_QUEUE_TASK_NUM; if (cnt++ == ASYNC_QUEUE_TASK_NUM) { - ret = 0; + ret = UADK_E_FAIL; goto out; } } @@ -223,16 +221,16 @@ int async_get_free_task(int *id) task_queue = poll_queue.head; task = &task_queue[idx]; if (!task) { - ret = 0; + ret = UADK_E_FAIL; goto out; } task->op = NULL; - ret = 1; + ret = UADK_E_SUCCESS; out: - if (pthread_mutex_unlock(&poll_queue.async_task_mutex) != 0) - return 0; + if (pthread_mutex_unlock(&poll_queue.async_task_mutex)) + return UADK_E_FAIL; return ret; } @@ -246,7 +244,7 @@ static int async_add_poll_task(void *ctx, struct async_op *op, enum task_type ty task_queue = poll_queue.head; task = &task_queue[id]; if (!task) - return 0; + return UADK_E_FAIL; task->ctx = ctx; task->type = type; @@ -254,9 +252,9 @@ static int async_add_poll_task(void *ctx, struct async_op *op, enum task_type ty ret = sem_post(&poll_queue.full_sem); if (ret) - return 0; + return UADK_E_FAIL; - return 1; + return UADK_E_SUCCESS; } int async_pause_job(void *ctx, struct async_op *op, enum task_type type, int id) @@ -268,19 +266,19 @@ int async_pause_job(void *ctx, struct async_op *op, enum task_type type, int id) int ret; ret = async_add_poll_task(ctx, op, type, id); - if (ret == 0) + if (ret == UADK_E_FAIL) return ret; waitctx = ASYNC_get_wait_ctx((ASYNC_JOB *)op->job); - if (waitctx == NULL) - return 0; + if (!waitctx) + return UADK_E_FAIL; do { - if (ASYNC_pause_job() == 0) - return 0; + if (!ASYNC_pause_job()) + return UADK_E_FAIL; ret = ASYNC_WAIT_CTX_get_fd(waitctx, engine_uadk_id, &efd, &custom); - if (ret <= 0) + if (ret == UADK_E_FAIL) continue; if (read(efd, &buf, sizeof(uint64_t)) == -1) { @@ -298,13 +296,13 @@ int async_wake_job(ASYNC_JOB *job) { ASYNC_WAIT_CTX *waitctx; OSSL_ASYNC_FD efd; - void *custom; uint64_t buf = 1; + void *custom; int ret; waitctx = ASYNC_get_wait_ctx(job); - if (waitctx == NULL) - return 0; + if (!waitctx) + return UADK_E_FAIL; ret = ASYNC_WAIT_CTX_get_fd(waitctx, engine_uadk_id, &efd, &custom); if (ret > 0) { @@ -332,7 +330,7 @@ static void *async_poll_process_func(void *args) int ret, idx; while (uadk_e_get_async_poll_state()) { - if (sem_wait(&poll_queue.full_sem) != 0) { + if (sem_wait(&poll_queue.full_sem)) { if (errno == EINTR) { /* sem_wait is interrupted by interrupt, continue */ continue; @@ -340,7 +338,7 @@ static void *async_poll_process_func(void *args) } task = async_get_queue_task(); - if (task == NULL) { + if (!task) { (void)sem_post(&poll_queue.full_sem); usleep(1); continue; @@ -368,19 +366,19 @@ int async_module_init(void) memset(&poll_queue, 0, sizeof(struct async_poll_queue)); if (pthread_mutex_init(&(poll_queue.async_task_mutex), NULL) < 0) - return 0; + return UADK_E_FAIL; poll_queue.head = malloc(sizeof(struct async_poll_task) * ASYNC_QUEUE_TASK_NUM); - if (poll_queue.head == NULL) - return 0; + if (!poll_queue.head) + return UADK_E_FAIL; memset(poll_queue.head, 0, sizeof(struct async_poll_task) * ASYNC_QUEUE_TASK_NUM); - if (sem_init(&poll_queue.empty_sem, 0, ASYNC_QUEUE_TASK_NUM) != 0) + if (sem_init(&poll_queue.empty_sem, 0, ASYNC_QUEUE_TASK_NUM)) goto err; - if (sem_init(&poll_queue.full_sem, 0, 0) != 0) + if (sem_init(&poll_queue.full_sem, 0, 0)) goto err; uadk_e_set_async_poll_state(ENABLE_ASYNC_POLLING); @@ -393,9 +391,9 @@ int async_module_init(void) poll_queue.thread_id = thread_id; OPENSSL_atexit(async_poll_task_free); - return 1; + return UADK_E_SUCCESS; err: async_poll_task_free(); - return 0; + return UADK_E_FAIL; } diff --git a/src/uadk_async.h b/src/uadk_async.h index 7e75951..8c26777 100644 --- a/src/uadk_async.h +++ b/src/uadk_async.h @@ -22,6 +22,9 @@ #include <openssl/async.h> #define ASYNC_QUEUE_TASK_NUM 1024 +#define UADK_E_SUCCESS 1 +#define UADK_E_FAIL 0 +#define DO_SYNC 1 struct async_op { ASYNC_JOB *job; -- 2.30.0

1 0

[PATCH] uadk_engine: support aead aes-gcm
by Wenkai Lin 28 Sep '23

28 Sep '23

The uadk_engine supports the AES GCM algorithm. The cipher and aead algorithms use the same set of EVP interfaces. Signed-off-by: Wenkai Lin <linwenkai6(a)hisilicon.com> --- src/Makefile.am | 3 +- src/sec_cipher_adapter.c | 195 ++++++++++++ src/sec_cipher_adapter.h | 36 +++ src/uadk.h | 2 - src/uadk_aead.c | 592 ++++++++++++++++++++++++++++++++++++ src/uadk_cipher.c | 625 +++++++++++++-------------------------- src/uadk_engine_init.c | 26 +- 7 files changed, 1052 insertions(+), 427 deletions(-) create mode 100755 src/sec_cipher_adapter.c create mode 100755 src/sec_cipher_adapter.h create mode 100755 src/uadk_aead.c diff --git a/src/Makefile.am b/src/Makefile.am index af16d85..b84d87f 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -11,7 +11,8 @@ endif #HAVE_CRYPTO3 uadk_engine_la_SOURCES=uadk_utils.c uadk_engine_init.c uadk_cipher.c \ uadk_digest.c uadk_async.c uadk_rsa.c uadk_sm2.c \ - uadk_pkey.c uadk_dh.c uadk_ec.c uadk_ecx.c + uadk_pkey.c uadk_dh.c uadk_ec.c uadk_ecx.c \ + uadk_aead.c sec_cipher_adapter.c uadk_engine_la_LIBADD=-ldl $(WD_LIBS) -lpthread uadk_engine_la_LDFLAGS=-module -version-number $(VERSION) diff --git a/src/sec_cipher_adapter.c b/src/sec_cipher_adapter.c new file mode 100755 index 0000000..694fa55 --- /dev/null +++ b/src/sec_cipher_adapter.c @@ -0,0 +1,195 @@ +/* + * Copyright 2020-2021 Huawei Technologies Co.,Ltd. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +#include "sec_cipher_adapter.h" + +#define HW_SEC_V2 0 +#define HW_SEC_V3 1 +#define OTHERS_HW 2 + +int cipher_hw_v2_nids[] = { + NID_aes_128_cbc, + NID_aes_192_cbc, + NID_aes_256_cbc, + NID_aes_128_ecb, + NID_aes_192_ecb, + NID_aes_256_ecb, + NID_aes_128_xts, + NID_aes_256_xts, + NID_sm4_cbc, + NID_des_ede3_cbc, + NID_des_ede3_ecb, + NID_aes_128_gcm, + NID_aes_192_gcm, + NID_aes_256_gcm +}; + +int cipher_hw_v3_nids[] = { + NID_aes_128_cbc, + NID_aes_192_cbc, + NID_aes_256_cbc, + NID_aes_128_ctr, + NID_aes_192_ctr, + NID_aes_256_ctr, + NID_aes_128_ecb, + NID_aes_192_ecb, + NID_aes_256_ecb, + NID_aes_128_xts, + NID_aes_256_xts, + NID_sm4_cbc, + NID_sm4_ecb, + NID_des_ede3_cbc, + NID_des_ede3_ecb, + NID_aes_128_cfb128, + NID_aes_192_cfb128, + NID_aes_256_cfb128, + NID_aes_128_ofb128, + NID_aes_192_ofb128, + NID_aes_256_ofb128, + NID_sm4_cfb128, + NID_sm4_ofb128, + NID_sm4_ctr, + NID_aes_128_gcm, + NID_aes_192_gcm, + NID_aes_256_gcm +}; + +struct engine_cipher_info c_info[] = { + {NID_aes_128_cbc, NULL}, + {NID_aes_192_cbc, NULL}, + {NID_aes_256_cbc, NULL}, + {NID_aes_128_ctr, NULL}, + {NID_aes_192_ctr, NULL}, + {NID_aes_256_ctr, NULL}, + {NID_aes_128_ecb, NULL}, + {NID_aes_192_ecb, NULL}, + {NID_aes_256_ecb, NULL}, + {NID_aes_128_xts, NULL}, + {NID_aes_256_xts, NULL}, + {NID_sm4_cbc, NULL}, + {NID_sm4_ecb, NULL}, + {NID_des_ede3_cbc, NULL}, + {NID_des_ede3_ecb, NULL}, + {NID_aes_128_cfb128, NULL}, + {NID_aes_192_cfb128, NULL}, + {NID_aes_256_cfb128, NULL}, + {NID_aes_128_ofb128, NULL}, + {NID_aes_192_ofb128, NULL}, + {NID_aes_256_ofb128, NULL}, + {NID_sm4_cfb128, NULL}, + {NID_sm4_ofb128, NULL}, + {NID_sm4_ctr, NULL}, + {NID_aes_128_gcm, NULL}, + {NID_aes_192_gcm, NULL}, + {NID_aes_256_gcm, NULL} +}; + +static const unsigned int num_cc = ARRAY_SIZE(c_info); + +static void uadk_e_create_ciphers(int index) +{ + switch (c_info[index].nid) { + case NID_aes_128_gcm: + case NID_aes_192_gcm: + case NID_aes_256_gcm: + c_info[index].cipher = uadk_create_gcm_cipher_meth(c_info[index].nid); + break; + case NID_aes_128_cbc: + case NID_aes_192_cbc: + case NID_aes_256_cbc: + case NID_aes_128_ctr: + case NID_aes_192_ctr: + case NID_aes_256_ctr: + case NID_aes_128_ecb: + case NID_aes_192_ecb: + case NID_aes_256_ecb: + case NID_aes_128_xts: + case NID_aes_256_xts: + case NID_sm4_cbc: + case NID_sm4_ecb: + case NID_des_ede3_cbc: + case NID_des_ede3_ecb: + case NID_aes_128_cfb128: + case NID_aes_192_cfb128: + case NID_aes_256_cfb128: + case NID_aes_128_ofb128: + case NID_aes_192_ofb128: + case NID_aes_256_ofb128: + case NID_sm4_cfb128: + case NID_sm4_ofb128: + case NID_sm4_ctr: + c_info[index].cipher = uadk_create_cipher_meth(c_info[index].nid); + break; + default: + break; + } +} + +int uadk_e_ciphers(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid) +{ + int platform = OTHERS_HW; + struct uacce_dev *dev; + + (void)e; + + if ((nids == NULL) && ((cipher == NULL) || (nid < 0))) { + if (cipher != NULL) + *cipher = NULL; + return 0; + } + + dev = wd_get_accel_dev("cipher"); + + if (!strcmp(dev->api, "hisi_qm_v2")) + platform = HW_SEC_V2; + else if (!strcmp(dev->api, "hisi_qm_v3")) + platform = HW_SEC_V3; + + if (cipher == NULL) { + if (platform == HW_SEC_V2) { + *nids = cipher_hw_v2_nids; + return ARRAY_SIZE(cipher_hw_v2_nids); + } else if (platform == HW_SEC_V3) { + *nids = cipher_hw_v3_nids; + return ARRAY_SIZE(cipher_hw_v3_nids); + } + } + + for (int i = 0; i < num_cc; i++) { + if (nid == c_info[i].nid) { + if (c_info[i].cipher == NULL) + uadk_e_create_ciphers(i); + + *cipher = c_info[i].cipher; + return 1; + } + } + + *cipher = NULL; + return 0; +} + +int uadk_e_bind_crypto(ENGINE *e) +{ + return ENGINE_set_ciphers(e, uadk_e_ciphers); +} + +void uadk_e_destroy_crypto(void) +{ + uadk_e_destroy_cipher(c_info, num_cc); + uadk_e_destroy_aead(c_info, num_cc); +} + diff --git a/src/sec_cipher_adapter.h b/src/sec_cipher_adapter.h new file mode 100755 index 0000000..3f010f2 --- /dev/null +++ b/src/sec_cipher_adapter.h @@ -0,0 +1,36 @@ +/* + * Copyright 2020-2021 Huawei Technologies Co.,Ltd. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +#ifndef UADK_ADAPT_H +#define UADK_ADAPT_H +#include <openssl/engine.h> +#include <uadk/wd.h> + +struct engine_cipher_info { + int nid; + EVP_CIPHER *cipher; +}; + +#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) + +EVP_CIPHER *uadk_create_gcm_cipher_meth(int nid); +EVP_CIPHER *uadk_create_cipher_meth(int nid); +void uadk_e_destroy_aead(struct engine_cipher_info *info, int num); +void uadk_e_destroy_cipher(struct engine_cipher_info *info, int num); + +int uadk_e_bind_crypto(ENGINE *e); +void uadk_e_destroy_crypto(void); +#endif diff --git a/src/uadk.h b/src/uadk.h index 30c099f..78c8682 100644 --- a/src/uadk.h +++ b/src/uadk.h @@ -29,8 +29,6 @@ enum { }; extern const char *engine_uadk_id; -int uadk_e_bind_cipher(ENGINE *e); -void uadk_e_destroy_cipher(void); int uadk_e_bind_digest(ENGINE *e); void uadk_e_destroy_digest(void); int uadk_e_bind_rsa(ENGINE *e); diff --git a/src/uadk_aead.c b/src/uadk_aead.c new file mode 100755 index 0000000..30e95e1 --- /dev/null +++ b/src/uadk_aead.c @@ -0,0 +1,592 @@ +/* + * Copyright 2020-2021 Huawei Technologies Co.,Ltd. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +#include <stdio.h> +#include <stdbool.h> +#include <string.h> +#include <dlfcn.h> +#include <openssl/aes.h> +#include <openssl/engine.h> +#include <uadk/wd_aead.h> +#include <uadk/wd_sched.h> +#include "sec_cipher_adapter.h" +#include "uadk.h" + +#define CTX_SYNC_ENC 0 +#define CTX_SYNC_DEC 1 +#define CTX_ASYNC_ENC 2 +#define CTX_ASYNC_DEC 3 +#define CTX_NUM 4 +#define AES_GCM_CTR_LEN 4 +#define AES_GCM_BLOCK_SIZE 16 +#define AES_GCM_IV_LEN 12 +#define AES_GCM_TAG_LEN 16 +#define GCM_FLAG (EVP_CIPH_FLAG_DEFAULT_ASN1 | EVP_CIPH_GCM_MODE \ + | EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_AEAD_CIPHER \ + | EVP_CIPH_FLAG_CUSTOM_CIPHER | EVP_CIPH_ALWAYS_CALL_INIT) +#define KEY_BYTES_OFFSET 0x3 +#define AEAD_DOING 1 +#define AEAD_END 0 +#define AEAD_BLOCK_SIZE 0xFFFE00 + +struct aead_priv_ctx { + handle_t sess; + struct wd_aead_sess_setup setup; + struct wd_aead_req req; + unsigned char *data; + unsigned char iv[AES_GCM_BLOCK_SIZE]; + unsigned char mac[AES_GCM_TAG_LEN]; + const unsigned char *ckey; + unsigned int mac_len; +}; + +struct aead_engine { + struct wd_ctx_config ctx_cfg; + struct wd_sched sched; + int numa_id; + int pid; + pthread_spinlock_t lock; +}; + +static struct aead_engine engine; + +static EVP_CIPHER *uadk_aes_128_gcm; +static EVP_CIPHER *uadk_aes_192_gcm; +static EVP_CIPHER *uadk_aes_256_gcm; + +static handle_t sched_single_aead_init(handle_t h_sched_ctx, void *sched_param) +{ + struct sched_params *param = (struct sched_params *)sched_param; + struct sched_params *skey; + + skey = malloc(sizeof(struct sched_params)); + if (!skey) { + fprintf(stderr, "fail to alloc aead sched key!\n"); + return (handle_t)0; + } + + skey->numa_id = param->numa_id; + skey->type = param->type; + + return (handle_t)skey; +} + +static __u32 sched_single_pick_next_ctx(handle_t sched_ctx, void *sched_key, const int sched_mode) +{ + struct sched_params *key = (struct sched_params *)sched_key; + + if (sched_mode) { + if (key->type == WD_CIPHER_ENCRYPTION_DIGEST) + return CTX_ASYNC_ENC; + else + return CTX_ASYNC_DEC; + } else { + if (key->type == WD_CIPHER_ENCRYPTION_DIGEST) + return CTX_SYNC_ENC; + else + return CTX_SYNC_DEC; + } +} + +static int sched_single_poll_policy(handle_t h_sched_ctx, __u32 expect, __u32 *count) +{ + return 0; +} + +static int uadk_e_wd_aead_cipher_env_init(struct uacce_dev *dev) +{ + int ret; + + ret = uadk_e_set_env("WD_AEAD_CIPHER_CTX_NUM", dev->numa_id); + if (ret) + return ret; + + ret = wd_aead_env_init(NULL); + + return ret; +} + +static int uadk_e_wd_aead_cipher_init(struct uacce_dev *dev) +{ + int ret, i, j; + + engine.numa_id = dev->numa_id; + + ret = uadk_e_is_env_enabled("aead"); + if (ret) + return uadk_e_wd_aead_cipher_env_init(dev); + + memset(&engine.ctx_cfg, 0, sizeof(struct wd_ctx_config)); + engine.ctx_cfg.ctx_num = CTX_NUM; + engine.ctx_cfg.ctxs = calloc(CTX_NUM, sizeof(struct wd_ctx)); + if (!engine.ctx_cfg.ctxs) + return -ENOMEM; + + for (i = 0; i < CTX_NUM; i++) { + engine.ctx_cfg.ctxs[i].ctx = wd_request_ctx(dev); + if (!engine.ctx_cfg.ctxs[i].ctx) { + ret = -ENOMEM; + goto err_freectx; + } + } + + engine.ctx_cfg.ctxs[CTX_SYNC_ENC].op_type = CTX_TYPE_ENCRYPT; + engine.ctx_cfg.ctxs[CTX_SYNC_DEC].op_type = CTX_TYPE_DECRYPT; + engine.ctx_cfg.ctxs[CTX_SYNC_ENC].ctx_mode = CTX_MODE_SYNC; + engine.ctx_cfg.ctxs[CTX_SYNC_DEC].ctx_mode = CTX_MODE_SYNC; + + engine.ctx_cfg.ctxs[CTX_ASYNC_ENC].op_type = CTX_TYPE_ENCRYPT; + engine.ctx_cfg.ctxs[CTX_ASYNC_DEC].op_type = CTX_TYPE_DECRYPT; + engine.ctx_cfg.ctxs[CTX_ASYNC_ENC].ctx_mode = CTX_MODE_ASYNC; + engine.ctx_cfg.ctxs[CTX_ASYNC_DEC].ctx_mode = CTX_MODE_ASYNC; + + engine.sched.name = "sched_single"; + engine.sched.pick_next_ctx = sched_single_pick_next_ctx; + engine.sched.poll_policy = sched_single_poll_policy; + engine.sched.sched_init = sched_single_aead_init; + + ret = wd_aead_init(&engine.ctx_cfg, &engine.sched); + if (ret) + goto err_freectx; + + return ret; + +err_freectx: + for (j = 0; j < i; j++) + wd_release_ctx(engine.ctx_cfg.ctxs[j].ctx); + + free(engine.ctx_cfg.ctxs); + + return ret; +} + +static int uadk_e_init_aead_cipher(void) +{ + struct uacce_dev *dev; + int ret; + + if (engine.pid != getpid()) { + pthread_spin_lock(&engine.lock); + if (engine.pid == getpid()) { + pthread_spin_unlock(&engine.lock); + return 1; + } + + dev = wd_get_accel_dev("aead"); + if (!dev) { + pthread_spin_unlock(&engine.lock); + fprintf(stderr, "failed to get device for aead.\n"); + return 0; + } + + ret = uadk_e_wd_aead_cipher_init(dev); + if (ret < 0) { + pthread_spin_unlock(&engine.lock); + fprintf(stderr, "failed to initiate aead cipher.\n"); + return 0; + } + + engine.pid = getpid(); + pthread_spin_unlock(&engine.lock); + free(dev); + } + + return 1; +} + +static int uadk_e_ctx_init(EVP_CIPHER_CTX *ctx, struct aead_priv_ctx *priv) +{ + struct sched_params params = {0}; + int ret; + + ret = uadk_e_init_aead_cipher(); + if (unlikely(!ret)) { + fprintf(stderr, "uadk failed to init aead HW!\n"); + return 0; + } + + params.type = priv->req.op_type; + ret = uadk_e_is_env_enabled("aead"); + if (ret) + params.type = 0; + + params.numa_id = engine.numa_id; + priv->setup.sched_param = &params; + if (!priv->sess) { + priv->sess = wd_aead_alloc_sess(&priv->setup); + if (!priv->sess) { + fprintf(stderr, "uadk engine failed to alloc aead session!\n"); + return 0; + } + priv->data = malloc(AEAD_BLOCK_SIZE); + if (unlikely(!priv->data)) { + wd_aead_free_sess(priv->sess); + priv->sess = 0; + return 0; + } + } + + ret = wd_aead_set_ckey(priv->sess, priv->ckey, EVP_CIPHER_CTX_key_length(ctx)); + if (ret) { + wd_aead_free_sess(priv->sess); + free(priv->data); + priv->sess = 0; + priv->data = NULL; + fprintf(stderr, "uadk engine failed to set ckey!\n"); + return 0; + } + + return 1; +} + +static int uadk_e_aead_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *ckey, + const unsigned char *iv, int enc) +{ + struct aead_priv_ctx *priv = + (struct aead_priv_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); + int ret; + + if (unlikely(!ckey)) + return 1; + + priv->req.op_type = enc ? WD_CIPHER_ENCRYPTION_DIGEST : WD_CIPHER_DECRYPTION_DIGEST; + + if (iv) + memcpy(priv->iv, iv, AES_GCM_IV_LEN); + + priv->setup.calg = WD_CIPHER_AES; + priv->setup.cmode = WD_CIPHER_GCM; + priv->setup.dalg = 0; + priv->setup.dmode = 0; + + priv->req.assoc_bytes = 0; + priv->req.data_fmt = WD_FLAT_BUF; + priv->req.iv_bytes = AES_GCM_IV_LEN; + memset(priv->iv + AES_GCM_IV_LEN, 0, AES_GCM_CTR_LEN); + priv->req.iv = priv->iv; + priv->req.mac_bytes = AES_GCM_TAG_LEN; + + if (enc) { + priv->req.mac = priv->mac; + } else { + priv->req.mac = calloc(AES_GCM_TAG_LEN, sizeof(char)); + } + + priv->ckey = ckey; + + ret = uadk_e_ctx_init(ctx, priv); + if (!ret) + return 0; + //return -1; + + return 1; +} + +static int uadk_e_aead_cipher_cleanup(EVP_CIPHER_CTX *ctx) +{ + struct aead_priv_ctx *priv = + (struct aead_priv_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); + + if (priv->req.op_type == WD_CIPHER_DECRYPTION_DIGEST) + free(priv->req.mac); + + if (priv->sess) { + wd_aead_free_sess(priv->sess); + priv->sess = 0; + } + + if (priv->data) { + free(priv->data); + priv->data = NULL; + } + + return 1; +} + +static int uadk_e_aead_cipher_set_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) +{ + struct aead_priv_ctx *priv = + (struct aead_priv_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); + int enc = EVP_CIPHER_CTX_encrypting(ctx); + + switch (type) { + case EVP_CTRL_INIT: + priv->req.iv_bytes = 0; + return 1; + case EVP_CTRL_GET_IVLEN: + *(int *)ptr = priv->req.iv_bytes; + return 1; + case EVP_CTRL_GCM_SET_IVLEN: + if (arg != AES_GCM_IV_LEN) { + fprintf(stderr, "gcm only support 12 bytes.\n"); + return 0; + } + return 1; + case EVP_CTRL_GCM_GET_TAG: + if (arg <= 0 || arg > AES_GCM_TAG_LEN) { + fprintf(stderr, "TAG length invalid.\n"); + return 0; + } + + priv->mac_len = arg; + + if (EVP_CIPHER_CTX_buf_noconst(ctx) == NULL || ptr == NULL) { + fprintf(stderr, "ctx memory pointer is invalid.\n"); + return 0; + } + + memcpy(ptr, EVP_CIPHER_CTX_buf_noconst(ctx), arg); + return 1; + case EVP_CTRL_GCM_SET_TAG: + if (arg != AES_GCM_TAG_LEN || enc) { + fprintf(stderr, "cannot set tag when encrypt or arg is invalid.\n"); + return 0; + } + + if (EVP_CIPHER_CTX_buf_noconst(ctx) == NULL || ptr == NULL) { + fprintf(stderr, "ctx memory pointer is invalid.\n"); + return 0; + } + + memcpy(EVP_CIPHER_CTX_buf_noconst(ctx), ptr, AES_GCM_TAG_LEN); + return 1; + default: + fprintf(stderr, "unsupported ctrl type: %d\n", type); + return 0; + } +} + +//static void openssl_aes_cb_t(unsigned char *key, unsigned int key_len, +// unsigned char *src, unsigned char *dst) +//{ +// unsigned int local_key_len = key_len << KEY_BYTES_OFFSET; +// AES_KEY local_key; +// +// AES_set_encrypt_key(key, local_key_len, &local_key); +// AES_ecb_encrypt(src, dst, &local_key, AES_ENCRYPT); +//} + +void hexdump(char *s, char *buf, int num) +{ + int i; + + printf("%s\n", s); + for (i = 0; i < num; i++) { + printf("\\%02X", buf[i]); + if ((i + 1) % 8 == 0) + printf("\n"); + } + printf("\n"); + + return; +} + +static int uadk_e_do_first(EVP_CIPHER_CTX *ctx, unsigned char *out, + const unsigned char *in, size_t inlen) +{ + unsigned char *ctx_buf = EVP_CIPHER_CTX_buf_noconst(ctx); + struct aead_priv_ctx *priv = + (struct aead_priv_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); + int ret; + + ret = wd_aead_set_authsize(priv->sess, AES_GCM_TAG_LEN); + if (ret < 0) { + fprintf(stderr, "uadk engine failed to set authsize!\n"); + return -1; + } + + /* Only inputs aad data as do first */ + priv->req.src = (unsigned char *)in; + priv->req.in_bytes = inlen; + priv->req.assoc_bytes = inlen; + priv->req.dst = out; + priv->req.out_bytes = inlen; + priv->req.msg_state = AEAD_MSG_FIRST; + memcpy(priv->req.mac, ctx_buf, AES_GCM_TAG_LEN); + + ret = wd_do_aead_sync(priv->sess, &priv->req); + if (ret < 0) { + fprintf(stderr, "do sec aead first operation failed, ret:%d!\n", ret); + return -1; + } + + return 1; +} + +static int uadk_e_do_update(EVP_CIPHER_CTX *ctx, unsigned char *out, + const unsigned char *in, size_t inlen) +{ + struct aead_priv_ctx *priv = + (struct aead_priv_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); + int ret; + + priv->req.src = (unsigned char *)in; + priv->req.dst = out; + + priv->req.in_bytes = inlen; + priv->req.out_bytes = inlen; + priv->req.msg_state = AEAD_MSG_MIDDLE; + + ret = wd_do_aead_sync(priv->sess, &priv->req); + if (ret < 0) { + fprintf(stderr, "do sec aead update operation failed, ret:%d!\n", ret); + return -1; + } + + return inlen; +} + +static int uadk_e_do_final(EVP_CIPHER_CTX *ctx, unsigned char *out, + const unsigned char *in, size_t inlen) +{ + struct aead_priv_ctx *priv = + (struct aead_priv_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); + unsigned char *ctx_buf = EVP_CIPHER_CTX_buf_noconst(ctx); + int ret, enc; + + enc = EVP_CIPHER_CTX_encrypting(ctx); + priv->req.in_bytes = 0; + priv->req.dst = out; + priv->req.msg_state = AEAD_MSG_END; + + if (!enc) + memcpy(priv->mac, ctx_buf, AES_GCM_TAG_LEN); + + ret = wd_do_aead_sync(priv->sess, &priv->req); + if (ret < 0) { + fprintf(stderr, "do sec aead final operation failed, ret:%d!\n", ret); + return -1; + } + + if (enc) { + memcpy(ctx_buf, priv->req.mac, AES_GCM_TAG_LEN); + } else { + if (priv->req.state != WD_SUCCESS) + return -1; + else + return 1; + } + + return inlen; +} + +static int uadk_e_do_aead_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, + const unsigned char *in, size_t inlen) +{ + if (in) { + if (out == NULL) + return uadk_e_do_first(ctx, out, in, inlen); + else + return uadk_e_do_update(ctx, out, in, inlen); + } else { + /* first ->update ->final */ + return uadk_e_do_final(ctx, out, NULL, 0); + } +} + +#define UADK_AEAD_DESCR(name, block_size, key_size, iv_len, flags, ctx_size,\ + init, cipher, cleanup, set_params, get_params, ctrl)\ +do {\ + uadk_##name = EVP_CIPHER_meth_new(NID_##name, block_size, key_size);\ + if (uadk_##name == 0 ||\ + !EVP_CIPHER_meth_set_iv_length(uadk_##name, iv_len) ||\ + !EVP_CIPHER_meth_set_flags(uadk_##name, flags) ||\ + !EVP_CIPHER_meth_set_impl_ctx_size(uadk_##name, ctx_size) ||\ + !EVP_CIPHER_meth_set_init(uadk_##name, init) ||\ + !EVP_CIPHER_meth_set_do_cipher(uadk_##name, cipher) ||\ + !EVP_CIPHER_meth_set_cleanup(uadk_##name, cleanup) ||\ + !EVP_CIPHER_meth_set_set_asn1_params(uadk_##name, set_params) ||\ + !EVP_CIPHER_meth_set_get_asn1_params(uadk_##name, get_params) ||\ + !EVP_CIPHER_meth_set_ctrl(uadk_##name, ctrl))\ + return 0;\ +} while (0) + +EVP_CIPHER *uadk_create_gcm_cipher_meth(int nid) +{ + EVP_CIPHER *aead = NULL; + + switch (nid) { + case NID_aes_128_gcm: + UADK_AEAD_DESCR(aes_128_gcm, AES_GCM_BLOCK_SIZE, 16, AES_GCM_IV_LEN, + GCM_FLAG, sizeof(struct aead_priv_ctx), + uadk_e_aead_cipher_init, uadk_e_do_aead_cipher, + uadk_e_aead_cipher_cleanup, + (EVP_CIPH_FLAG_DEFAULT_ASN1 ? NULL : EVP_CIPHER_set_asn1_iv), + (EVP_CIPH_FLAG_DEFAULT_ASN1 ? NULL : EVP_CIPHER_get_asn1_iv), + uadk_e_aead_cipher_set_ctrl); + aead = uadk_aes_128_gcm; + break; + case NID_aes_192_gcm: + UADK_AEAD_DESCR(aes_192_gcm, AES_GCM_BLOCK_SIZE, 24, AES_GCM_IV_LEN, + GCM_FLAG, sizeof(struct aead_priv_ctx), + uadk_e_aead_cipher_init, uadk_e_do_aead_cipher, + uadk_e_aead_cipher_cleanup, + (EVP_CIPH_FLAG_DEFAULT_ASN1 ? NULL : EVP_CIPHER_set_asn1_iv), + (EVP_CIPH_FLAG_DEFAULT_ASN1 ? NULL : EVP_CIPHER_get_asn1_iv), + uadk_e_aead_cipher_set_ctrl); + aead = uadk_aes_192_gcm; + break; + case NID_aes_256_gcm: + UADK_AEAD_DESCR(aes_256_gcm, AES_GCM_BLOCK_SIZE, 32, AES_GCM_IV_LEN, + GCM_FLAG, sizeof(struct aead_priv_ctx), + uadk_e_aead_cipher_init, uadk_e_do_aead_cipher, + uadk_e_aead_cipher_cleanup, + (EVP_CIPH_FLAG_DEFAULT_ASN1 ? NULL : EVP_CIPHER_set_asn1_iv), + (EVP_CIPH_FLAG_DEFAULT_ASN1 ? NULL : EVP_CIPHER_get_asn1_iv), + uadk_e_aead_cipher_set_ctrl); + aead = uadk_aes_256_gcm; + break; + default: + aead = NULL; + break; + } + + return aead; +} + +static void destroy_aead(struct engine_cipher_info *info, int num) +{ + int i; + + for (i = 0; i < num; i++) { + if (info[i].cipher != NULL) { + EVP_CIPHER_meth_free(info[i].cipher); + info[i].cipher = NULL; + } + } +} + +void uadk_e_destroy_aead(struct engine_cipher_info *info, int num) +{ + int i, ret; + + if (engine.pid == getpid()) { + ret = uadk_e_is_env_enabled("aead"); + if (ret) { + wd_aead_env_uninit(); + } else { + wd_aead_uninit(); + for (i = 0; i < engine.ctx_cfg.ctx_num; i++) + wd_release_ctx(engine.ctx_cfg.ctxs[i].ctx); + + free(engine.ctx_cfg.ctxs); + } + engine.pid = 0; + } + + pthread_spin_destroy(&engine.lock); + destroy_aead(info, num); +} diff --git a/src/uadk_cipher.c b/src/uadk_cipher.c index c87c7ee..2782ad5 100644 --- a/src/uadk_cipher.c +++ b/src/uadk_cipher.c @@ -25,6 +25,7 @@ #include <uadk/wd_sched.h> #include "uadk.h" #include "uadk_async.h" +#include "sec_cipher_adapter.h" #define UADK_DO_SOFT (-0xE0) #define CTX_SYNC_ENC 0 @@ -74,54 +75,8 @@ struct cipher_info { __u32 out_bytes; }; -static int platform; - #define SMALL_PACKET_OFFLOAD_THRESHOLD_DEFAULT 192 -static int cipher_hw_v2_nids[] = { - NID_aes_128_cbc, - NID_aes_192_cbc, - NID_aes_256_cbc, - NID_aes_128_ecb, - NID_aes_192_ecb, - NID_aes_256_ecb, - NID_aes_128_xts, - NID_aes_256_xts, - NID_sm4_cbc, - NID_des_ede3_cbc, - NID_des_ede3_ecb, - NID_sm4_ecb, - 0, -}; - -static int cipher_hw_v3_nids[] = { - NID_aes_128_cbc, - NID_aes_192_cbc, - NID_aes_256_cbc, - NID_aes_128_ctr, - NID_aes_192_ctr, - NID_aes_256_ctr, - NID_aes_128_ecb, - NID_aes_192_ecb, - NID_aes_256_ecb, - NID_aes_128_xts, - NID_aes_256_xts, - NID_sm4_cbc, - NID_sm4_ecb, - NID_des_ede3_cbc, - NID_des_ede3_ecb, - NID_aes_128_cfb128, - NID_aes_192_cfb128, - NID_aes_256_cfb128, - NID_aes_128_ofb128, - NID_aes_192_ofb128, - NID_aes_256_ofb128, - NID_sm4_cfb128, - NID_sm4_ofb128, - NID_sm4_ctr, - 0, -}; - static EVP_CIPHER *uadk_aes_128_cbc; static EVP_CIPHER *uadk_aes_192_cbc; static EVP_CIPHER *uadk_aes_256_cbc; @@ -134,7 +89,7 @@ static EVP_CIPHER *uadk_aes_256_ecb; static EVP_CIPHER *uadk_aes_128_xts; static EVP_CIPHER *uadk_aes_256_xts; static EVP_CIPHER *uadk_sm4_cbc; -static EVP_CIPHER *uadk_sm4_ecb; +// static EVP_CIPHER *uadk_sm4_ecb; static EVP_CIPHER *uadk_des_ede3_cbc; static EVP_CIPHER *uadk_des_ede3_ecb; static EVP_CIPHER *uadk_aes_128_cfb128; @@ -317,6 +272,12 @@ static int uadk_e_cipher_soft_work(EVP_CIPHER_CTX *ctx, unsigned char *out, return 1; } +static int sec_ciphers_is_check_valid(struct cipher_priv_ctx *priv) +{ + return priv->req.in_bytes <= priv->switch_threshold ? + 0 : 1; +} + static void uadk_e_cipher_sw_cleanup(EVP_CIPHER_CTX *ctx) { struct cipher_priv_ctx *priv = @@ -328,130 +289,6 @@ static void uadk_e_cipher_sw_cleanup(EVP_CIPHER_CTX *ctx) } } -static int uadk_get_accel_platform(char *alg_name) -{ - struct uacce_dev *dev; - - dev = wd_get_accel_dev(alg_name); - if (dev == NULL) - return 0; - - if (!strcmp(dev->api, "hisi_qm_v2")) - platform = HW_V2; - else - platform = HW_V3; - free(dev); - - return 1; -} - -static int uadk_e_engine_ciphers(ENGINE *e, const EVP_CIPHER **cipher, - const int **nids, int nid) -{ - int *cipher_nids; - __u32 size, i; - int ret = 1; - - if (platform == HW_V2) { - size = (sizeof(cipher_hw_v2_nids) - 1) / sizeof(int); - cipher_nids = cipher_hw_v2_nids; - } else { - size = (sizeof(cipher_hw_v3_nids) - 1) / sizeof(int); - cipher_nids = cipher_hw_v3_nids; - } - - if (!cipher) { - *nids = cipher_nids; - return size; - } - - for (i = 0; i < size; i++) { - if (nid == cipher_nids[i]) - break; - } - - switch (nid) { - case NID_aes_128_cbc: - *cipher = uadk_aes_128_cbc; - break; - case NID_aes_192_cbc: - *cipher = uadk_aes_192_cbc; - break; - case NID_aes_256_cbc: - *cipher = uadk_aes_256_cbc; - break; - case NID_aes_128_ctr: - *cipher = uadk_aes_128_ctr; - break; - case NID_aes_192_ctr: - *cipher = uadk_aes_192_ctr; - break; - case NID_aes_256_ctr: - *cipher = uadk_aes_256_ctr; - break; - case NID_aes_128_ecb: - *cipher = uadk_aes_128_ecb; - break; - case NID_aes_192_ecb: - *cipher = uadk_aes_192_ecb; - break; - case NID_aes_256_ecb: - *cipher = uadk_aes_256_ecb; - break; - case NID_aes_128_xts: - *cipher = uadk_aes_128_xts; - break; - case NID_aes_256_xts: - *cipher = uadk_aes_256_xts; - break; - case NID_sm4_cbc: - *cipher = uadk_sm4_cbc; - break; - case NID_sm4_ecb: - *cipher = uadk_sm4_ecb; - break; - case NID_des_ede3_cbc: - *cipher = uadk_des_ede3_cbc; - break; - case NID_des_ede3_ecb: - *cipher = uadk_des_ede3_ecb; - break; - case NID_aes_128_ofb128: - *cipher = uadk_aes_128_ofb128; - break; - case NID_aes_192_ofb128: - *cipher = uadk_aes_192_ofb128; - break; - case NID_aes_256_ofb128: - *cipher = uadk_aes_256_ofb128; - break; - case NID_aes_128_cfb128: - *cipher = uadk_aes_128_cfb128; - break; - case NID_aes_192_cfb128: - *cipher = uadk_aes_192_cfb128; - break; - case NID_aes_256_cfb128: - *cipher = uadk_aes_256_cfb128; - break; - case NID_sm4_ofb128: - *cipher = uadk_sm4_ofb128; - break; - case NID_sm4_cfb128: - *cipher = uadk_sm4_cfb128; - break; - case NID_sm4_ctr: - *cipher = uadk_sm4_ctr; - break; - default: - ret = 0; - *cipher = NULL; - break; - } - - return ret; -} - static handle_t sched_single_init(handle_t h_sched_ctx, void *sched_param) { struct sched_params *param = (struct sched_params *)sched_param; @@ -717,17 +554,17 @@ static int uadk_e_cipher_cleanup(EVP_CIPHER_CTX *ctx) return 1; } -static void *uadk_e_cipher_cb(struct wd_cipher_req *req, void *data) +static void async_cb(struct wd_cipher_req *req, void *data) { struct uadk_e_cb_info *cb_param; struct async_op *op; if (!req) - return NULL; + return; cb_param = req->cb_param; if (!cb_param) - return NULL; + return; op = cb_param->op; if (op && op->job && !op->done) { @@ -735,8 +572,6 @@ static void *uadk_e_cipher_cb(struct wd_cipher_req *req, void *data) async_free_poll_task(op->idx, 1); async_wake_job(op->job); } - - return NULL; } /* Increment counter (128-bit int) by c */ @@ -764,15 +599,16 @@ static void uadk_cipher_update_priv_ctx(struct cipher_priv_ctx *priv) __u16 iv_bytes = priv->req.iv_bytes; int offset = priv->req.in_bytes - iv_bytes; unsigned char K[IV_LEN] = {0}; - __u32 i; + int i; switch (priv->setup.mode) { - case WD_CIPHER_CFB: case WD_CIPHER_CBC: if (priv->req.op_type == WD_CIPHER_ENCRYPTION) - memcpy(priv->iv, priv->req.dst + offset, iv_bytes); + memcpy(priv->iv, priv->req.dst + priv->req.in_bytes - iv_bytes, + iv_bytes); else - memcpy(priv->iv, priv->req.src + offset, iv_bytes); + memcpy(priv->iv, priv->req.src + priv->req.in_bytes - iv_bytes, + iv_bytes); break; case WD_CIPHER_OFB: @@ -781,6 +617,15 @@ static void uadk_cipher_update_priv_ctx(struct cipher_priv_ctx *priv) *((unsigned char *)priv->req.dst + offset + i); } memcpy(priv->iv, K, iv_bytes); + break; + case WD_CIPHER_CFB: + if (priv->req.op_type == WD_CIPHER_ENCRYPTION) + memcpy(priv->iv, priv->req.dst + priv->req.in_bytes - iv_bytes, + iv_bytes); + else + memcpy(priv->iv, priv->req.src + priv->req.in_bytes - iv_bytes, + iv_bytes); + break; case WD_CIPHER_CTR: ctr_iv_inc(priv->iv, priv->req.in_bytes >> CTR_MODE_LEN_SHIFT); @@ -794,16 +639,11 @@ static int do_cipher_sync(struct cipher_priv_ctx *priv) { int ret; - if (unlikely(priv->switch_flag == UADK_DO_SOFT)) { - fprintf(stderr, "switch to soft cipher.\n"); + if (unlikely(priv->switch_flag == UADK_DO_SOFT)) return 0; - } - /* - * If the length of the input data does not reach to hardware computing threshold, - * directly switch to soft cipher. - */ - if (priv->req.in_bytes <= priv->switch_threshold) + ret = sec_ciphers_is_check_valid(priv); + if (!ret) return 0; ret = wd_do_cipher_sync(priv->sess, &priv->req); @@ -818,15 +658,14 @@ static int do_cipher_async(struct cipher_priv_ctx *priv, struct async_op *op) int idx, ret; if (unlikely(priv->switch_flag == UADK_DO_SOFT)) { - fprintf(stderr, "switch to soft cipher.\n"); + fprintf(stderr, "async cipher init failed.\n"); return 0; } cb_param.op = op; cb_param.priv = priv; - priv->req.cb = uadk_e_cipher_cb; + priv->req.cb = (void *)async_cb; priv->req.cb_param = &cb_param; - ret = async_get_free_task(&idx); if (!ret) return 0; @@ -849,10 +688,8 @@ static int do_cipher_async(struct cipher_priv_ctx *priv, struct async_op *op) static void uadk_e_ctx_init(EVP_CIPHER_CTX *ctx, struct cipher_priv_ctx *priv) { - __u32 cipher_counts = ARRAY_SIZE(cipher_info_table); struct sched_params params = {0}; - int nid, ret; - __u32 i; + int ret; priv->req.iv_bytes = EVP_CIPHER_CTX_iv_length(ctx); priv->req.iv = priv->iv; @@ -880,34 +717,15 @@ static void uadk_e_ctx_init(EVP_CIPHER_CTX *ctx, struct cipher_priv_ctx *priv) /* Use the default numa parameters */ params.numa_id = -1; priv->setup.sched_param = &params; - if (!priv->sess) { - nid = EVP_CIPHER_CTX_nid(ctx); - - for (i = 0; i < cipher_counts; i++) { - if (nid == cipher_info_table[i].nid) { - cipher_priv_ctx_setup(priv, cipher_info_table[i].alg, - cipher_info_table[i].mode, cipher_info_table[i].out_bytes); - break; - } - } - - if (i == cipher_counts) { - fprintf(stderr, "failed to setup the private ctx.\n"); - return; - } - priv->sess = wd_cipher_alloc_sess(&priv->setup); - if (!priv->sess) { + if (!priv->sess) fprintf(stderr, "uadk failed to alloc session!\n"); - return; - } } ret = wd_cipher_set_key(priv->sess, priv->key, EVP_CIPHER_CTX_key_length(ctx)); if (ret) { wd_cipher_free_sess(priv->sess); - priv->sess = 0; fprintf(stderr, "uadk failed to set key!\n"); } } @@ -938,14 +756,6 @@ static int uadk_e_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, if (!ret) goto sync_err; } else { - /* - * If the length of the input data - * does not reach to hardware computing threshold, - * directly switch to soft cipher. - */ - if (priv->req.in_bytes <= priv->switch_threshold) - goto sync_err; - ret = do_cipher_async(priv, &op); if (!ret) goto out_notify; @@ -978,210 +788,193 @@ do { \ return 0; \ } while (0) -static int bind_v2_cipher(void) -{ - UADK_CIPHER_DESCR(aes_128_cbc, 16, 16, 16, EVP_CIPH_CBC_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_192_cbc, 16, 24, 16, EVP_CIPH_CBC_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_256_cbc, 16, 32, 16, EVP_CIPH_CBC_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_128_ecb, 16, 16, 0, EVP_CIPH_ECB_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_192_ecb, 16, 24, 0, EVP_CIPH_ECB_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_256_ecb, 16, 32, 0, EVP_CIPH_ECB_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_128_xts, 1, 32, 16, EVP_CIPH_XTS_MODE | EVP_CIPH_CUSTOM_IV, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_256_xts, 1, 64, 16, EVP_CIPH_XTS_MODE | EVP_CIPH_CUSTOM_IV, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(sm4_cbc, 16, 16, 16, EVP_CIPH_CBC_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(des_ede3_cbc, 8, 24, 8, EVP_CIPH_CBC_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(des_ede3_ecb, 8, 24, 0, EVP_CIPH_ECB_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(sm4_ecb, 16, 16, 16, EVP_CIPH_ECB_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - - return 0; -} - -static int bind_v3_cipher(void) -{ - UADK_CIPHER_DESCR(aes_128_ctr, 1, 16, 16, EVP_CIPH_CTR_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_192_ctr, 1, 24, 16, EVP_CIPH_CTR_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_256_ctr, 1, 32, 16, EVP_CIPH_CTR_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_128_ofb128, 1, 16, 16, EVP_CIPH_OFB_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_192_ofb128, 1, 24, 16, EVP_CIPH_OFB_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_256_ofb128, 1, 32, 16, EVP_CIPH_OFB_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_128_cfb128, 1, 16, 16, EVP_CIPH_CFB_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_192_cfb128, 1, 24, 16, EVP_CIPH_CFB_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(aes_256_cfb128, 1, 32, 16, EVP_CIPH_CFB_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(sm4_ofb128, 1, 16, 16, EVP_CIPH_OFB_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(sm4_cfb128, 1, 16, 16, EVP_CIPH_OFB_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - UADK_CIPHER_DESCR(sm4_ctr, 1, 16, 16, EVP_CIPH_CTR_MODE, - sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, - uadk_e_do_cipher, uadk_e_cipher_cleanup, - EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); - - return 0; -} - -int uadk_e_bind_cipher(ENGINE *e) +EVP_CIPHER *uadk_create_cipher_meth(int nid) { - int ret; + EVP_CIPHER *cipher; - ret = uadk_get_accel_platform("cipher"); - if (!ret) { - fprintf(stderr, "failed to get accel hardware version.\n"); - return 0; + switch (nid) { + case NID_aes_128_cbc: + UADK_CIPHER_DESCR(aes_128_cbc, 16, 16, 16, EVP_CIPH_CBC_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_128_cbc; + break; + case NID_aes_192_cbc: + UADK_CIPHER_DESCR(aes_192_cbc, 16, 24, 16, EVP_CIPH_CBC_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_192_cbc; + break; + case NID_aes_256_cbc: + UADK_CIPHER_DESCR(aes_256_cbc, 16, 32, 16, EVP_CIPH_CBC_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_256_cbc; + break; + case NID_aes_128_ecb: + UADK_CIPHER_DESCR(aes_128_ecb, 16, 16, 0, EVP_CIPH_ECB_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_128_ecb; + break; + case NID_aes_192_ecb: + UADK_CIPHER_DESCR(aes_192_ecb, 16, 24, 0, EVP_CIPH_ECB_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_192_ecb; + break; + case NID_aes_256_ecb: + UADK_CIPHER_DESCR(aes_256_ecb, 16, 32, 0, EVP_CIPH_ECB_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_256_ecb; + break; + case NID_aes_128_xts: + UADK_CIPHER_DESCR(aes_128_xts, 1, 32, 16, EVP_CIPH_XTS_MODE | EVP_CIPH_CUSTOM_IV, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_128_xts; + break; + case NID_aes_256_xts: + UADK_CIPHER_DESCR(aes_256_xts, 1, 64, 16, EVP_CIPH_XTS_MODE | EVP_CIPH_CUSTOM_IV, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_256_xts; + break; + case NID_sm4_cbc: + UADK_CIPHER_DESCR(sm4_cbc, 16, 16, 16, EVP_CIPH_CBC_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_sm4_cbc; + break; + case NID_des_ede3_cbc: + UADK_CIPHER_DESCR(des_ede3_cbc, 8, 24, 8, EVP_CIPH_CBC_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_des_ede3_cbc; + break; + case NID_des_ede3_ecb: + UADK_CIPHER_DESCR(des_ede3_ecb, 8, 24, 0, EVP_CIPH_ECB_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_des_ede3_ecb; + break; + case NID_aes_128_ctr: + UADK_CIPHER_DESCR(aes_128_ctr, 1, 16, 16, EVP_CIPH_CTR_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_128_ctr; + break; + case NID_aes_192_ctr: + UADK_CIPHER_DESCR(aes_192_ctr, 1, 24, 16, EVP_CIPH_CTR_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_192_ctr; + break; + case NID_aes_256_ctr: + UADK_CIPHER_DESCR(aes_256_ctr, 1, 32, 16, EVP_CIPH_CTR_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_256_ctr; + break; + case NID_aes_128_ofb128: + UADK_CIPHER_DESCR(aes_128_ofb128, 1, 16, 16, EVP_CIPH_OFB_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_128_ofb128; + break; + case NID_aes_192_ofb128: + UADK_CIPHER_DESCR(aes_192_ofb128, 1, 24, 16, EVP_CIPH_OFB_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_192_ofb128; + break; + case NID_aes_256_ofb128: + UADK_CIPHER_DESCR(aes_256_ofb128, 1, 32, 16, EVP_CIPH_OFB_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_256_ofb128; + break; + case NID_aes_128_cfb128: + UADK_CIPHER_DESCR(aes_128_cfb128, 1, 16, 16, EVP_CIPH_CFB_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_128_cfb128; + break; + case NID_aes_192_cfb128: + UADK_CIPHER_DESCR(aes_192_cfb128, 1, 24, 16, EVP_CIPH_CFB_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_192_cfb128; + break; + case NID_aes_256_cfb128: + UADK_CIPHER_DESCR(aes_256_cfb128, 1, 32, 16, EVP_CIPH_CFB_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_aes_256_cfb128; + break; + case NID_sm4_ofb128: + UADK_CIPHER_DESCR(sm4_ofb128, 1, 16, 16, EVP_CIPH_OFB_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_sm4_ofb128; + break; + case NID_sm4_cfb128: + UADK_CIPHER_DESCR(sm4_cfb128, 1, 16, 16, EVP_CIPH_OFB_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_sm4_cfb128; + break; + case NID_sm4_ctr: + UADK_CIPHER_DESCR(sm4_ctr, 1, 16, 16, EVP_CIPH_CTR_MODE, + sizeof(struct cipher_priv_ctx), uadk_e_cipher_init, + uadk_e_do_cipher, uadk_e_cipher_cleanup, + EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv); + cipher = uadk_sm4_ctr; + break; + default: + cipher = NULL; + break; } - bind_v2_cipher(); - if (platform > HW_V2) - bind_v3_cipher(); - - return ENGINE_set_ciphers(e, uadk_e_engine_ciphers); + return cipher; } -static void destroy_v2_cipher(void) +static void destroy_cipher(struct engine_cipher_info *info, int num) { - EVP_CIPHER_meth_free(uadk_aes_128_cbc); - uadk_aes_128_cbc = 0; - EVP_CIPHER_meth_free(uadk_aes_192_cbc); - uadk_aes_192_cbc = 0; - EVP_CIPHER_meth_free(uadk_aes_256_cbc); - uadk_aes_256_cbc = 0; - EVP_CIPHER_meth_free(uadk_aes_128_ecb); - uadk_aes_128_ecb = 0; - EVP_CIPHER_meth_free(uadk_aes_192_ecb); - uadk_aes_192_ecb = 0; - EVP_CIPHER_meth_free(uadk_aes_256_ecb); - uadk_aes_256_ecb = 0; - EVP_CIPHER_meth_free(uadk_aes_128_xts); - uadk_aes_128_xts = 0; - EVP_CIPHER_meth_free(uadk_aes_256_xts); - uadk_aes_256_xts = 0; - EVP_CIPHER_meth_free(uadk_sm4_cbc); - uadk_sm4_cbc = 0; - EVP_CIPHER_meth_free(uadk_des_ede3_cbc); - uadk_des_ede3_cbc = 0; - EVP_CIPHER_meth_free(uadk_des_ede3_ecb); - uadk_des_ede3_ecb = 0; - EVP_CIPHER_meth_free(uadk_sm4_ecb); - uadk_sm4_ecb = 0; -} - -static void destroy_v3_cipher(void) -{ - EVP_CIPHER_meth_free(uadk_aes_128_ctr); - uadk_aes_128_ctr = 0; - EVP_CIPHER_meth_free(uadk_aes_192_ctr); - uadk_aes_192_ctr = 0; - EVP_CIPHER_meth_free(uadk_aes_256_ctr); - uadk_aes_256_ctr = 0; - EVP_CIPHER_meth_free(uadk_aes_128_ofb128); - uadk_aes_128_ofb128 = 0; - EVP_CIPHER_meth_free(uadk_aes_192_ofb128); - uadk_aes_192_ofb128 = 0; - EVP_CIPHER_meth_free(uadk_aes_256_ofb128); - uadk_aes_256_ofb128 = 0; - EVP_CIPHER_meth_free(uadk_aes_128_cfb128); - uadk_aes_128_cfb128 = 0; - EVP_CIPHER_meth_free(uadk_aes_192_cfb128); - uadk_aes_192_cfb128 = 0; - EVP_CIPHER_meth_free(uadk_aes_256_cfb128); - uadk_aes_256_cfb128 = 0; - EVP_CIPHER_meth_free(uadk_sm4_cfb128); - uadk_sm4_cfb128 = 0; - EVP_CIPHER_meth_free(uadk_sm4_ofb128); - uadk_sm4_ofb128 = 0; - EVP_CIPHER_meth_free(uadk_sm4_ctr); - uadk_sm4_ctr = 0; -} - -void uadk_e_destroy_cipher(void) -{ - __u32 i; - int ret; - - if (g_cipher_engine.pid == getpid()) { - ret = uadk_e_is_env_enabled("cipher"); - if (ret == ENV_ENABLED) { - wd_cipher_env_uninit(); - } else { - wd_cipher_uninit(); - for (i = 0; i < g_cipher_engine.ctx_cfg.ctx_num; i++) - wd_release_ctx(g_cipher_engine.ctx_cfg.ctxs[i].ctx); - free(g_cipher_engine.ctx_cfg.ctxs); + for (int i = 0; i != num; ++i) { + if (info[i].cipher != NULL) { + EVP_CIPHER_meth_free(info[i].cipher); + info[i].cipher = NULL; } - g_cipher_engine.pid = 0; } +} - pthread_spin_destroy(&g_cipher_engine.lock); - - destroy_v2_cipher(); - if (platform > HW_V2) - destroy_v3_cipher(); +void uadk_e_destroy_cipher(struct engine_cipher_info *info, int num) +{ + destroy_cipher(info, num); } void uadk_e_cipher_lock_init(void) diff --git a/src/uadk_engine_init.c b/src/uadk_engine_init.c index 0a9e3e6..d6503f8 100644 --- a/src/uadk_engine_init.c +++ b/src/uadk_engine_init.c @@ -24,15 +24,17 @@ #include <uadk/wd.h> #include "uadk.h" #include "uadk_async.h" +#include "sec_cipher_adapter.h" #ifdef KAE #include "v1/uadk_v1.h" #endif #define UADK_CMD_ENABLE_CIPHER_ENV ENGINE_CMD_BASE -#define UADK_CMD_ENABLE_DIGEST_ENV (ENGINE_CMD_BASE + 1) -#define UADK_CMD_ENABLE_RSA_ENV (ENGINE_CMD_BASE + 2) -#define UADK_CMD_ENABLE_DH_ENV (ENGINE_CMD_BASE + 3) -#define UADK_CMD_ENABLE_ECC_ENV (ENGINE_CMD_BASE + 4) +#define UADK_CMD_ENABLE_AEAD_ENV (ENGINE_CMD_BASE + 1) +#define UADK_CMD_ENABLE_DIGEST_ENV (ENGINE_CMD_BASE + 2) +#define UADK_CMD_ENABLE_RSA_ENV (ENGINE_CMD_BASE + 3) +#define UADK_CMD_ENABLE_DH_ENV (ENGINE_CMD_BASE + 4) +#define UADK_CMD_ENABLE_ECC_ENV (ENGINE_CMD_BASE + 5) /* Constants used when creating the ENGINE */ const char *engine_uadk_id = "uadk_engine"; @@ -60,6 +62,12 @@ static const ENGINE_CMD_DEFN g_uadk_cmd_defns[] = { "Enable or Disable cipher engine environment variable.", ENGINE_CMD_FLAG_NUMERIC }, + { + UADK_CMD_ENABLE_AEAD_ENV, + "UADK_CMD_ENABLE_AEAD_ENV", + "Enable or Disable aead engine environment variable.", + ENGINE_CMD_FLAG_NUMERIC + }, { UADK_CMD_ENABLE_DIGEST_ENV, "UADK_CMD_ENABLE_DIGEST_ENV", @@ -104,6 +112,7 @@ struct uadk_alg_env_enabled { static struct uadk_alg_env_enabled uadk_env_enabled[] = { { "cipher", 0 }, + { "aead", 0 }, { "digest", 0 }, { "rsa", 0 }, { "dh", 0 }, @@ -210,7 +219,7 @@ static int uadk_destroy(ENGINE *e) #endif if (uadk_cipher) - uadk_e_destroy_cipher(); + uadk_e_destroy_crypto(); if (uadk_digest) uadk_e_destroy_digest(); if (uadk_rsa) @@ -322,11 +331,12 @@ static void bind_fn_kae_alg(ENGINE *e) static void bind_fn_uadk_alg(ENGINE *e) { - struct uacce_dev *dev; + struct uacce_dev *dev, *dev_aead; + dev_aead = wd_get_accel_dev("aead"); dev = wd_get_accel_dev("cipher"); - if (dev) { - if (!uadk_e_bind_cipher(e)) + if (dev && dev_aead) { + if (!uadk_e_bind_crypto(e)) fprintf(stderr, "uadk bind cipher failed\n"); else uadk_cipher = 1; -- 2.30.0

1 0

[PATCH 1/1] uadk/sec: optimize the function name and implement for digest
by Qi Tao 27 Sep '23

27 Sep '23

digest_bd2_zero_packet_check() and digest_bd3_zero_packet_check() do not check whether the packet length is 0. Therefor, the function name does not match the function semantics. Signed-off-by: Qi Tao <taoqi10(a)huawei.com> --- drv/hisi_sec.c | 25 ++++++++++--------------- 1 file changed, 10 insertions(+), 15 deletions(-) diff --git a/drv/hisi_sec.c b/drv/hisi_sec.c index df6f56c..ebd9aaf 100644 --- a/drv/hisi_sec.c +++ b/drv/hisi_sec.c @@ -1578,7 +1578,7 @@ static int digest_long_bd_align_check(struct wd_digest_msg *msg) return 0; } -static int digest_bd2_zero_packet_check(struct wd_digest_msg *msg) +static int digest_bd2_type_check(struct wd_digest_msg *msg) { enum hash_bd_type type = get_hash_bd_type(msg); @@ -1597,7 +1597,7 @@ static int digest_bd2_zero_packet_check(struct wd_digest_msg *msg) return 0; } -static int digest_bd3_zero_packet_check(struct wd_digest_msg *msg) +static int digest_bd3_type_check(struct wd_digest_msg *msg) { enum hash_bd_type type = get_hash_bd_type(msg); /* Long hash first and middle bd */ @@ -1618,28 +1618,23 @@ static int digest_bd3_zero_packet_check(struct wd_digest_msg *msg) static int digest_len_check(struct wd_digest_msg *msg, enum sec_bd_type type) { - int ret; + int ret = 0; /* * Hardware needs to check the zero byte packet in the block * and long hash mode. First and middle bd not support 0 size, * final bd not need to check it. */ - if (type == BD_TYPE2 && !msg->in_bytes) { - ret = digest_bd2_zero_packet_check(msg); - if (ret) - return ret; - } + if (unlikely(!msg->in_bytes)) { + if (type == BD_TYPE2) + ret = digest_bd2_type_check(msg); + else if (type == BD_TYPE3) + ret = digest_bd3_type_check(msg); - if (type == BD_TYPE3 && !msg->in_bytes) { - ret = digest_bd3_zero_packet_check(msg); if (ret) return ret; - } - - if (unlikely(msg->in_bytes > MAX_INPUT_DATA_LEN)) { - WD_ERR("digest input length is too long, size = %u\n", - msg->in_bytes); + } else if (unlikely(msg->in_bytes > MAX_INPUT_DATA_LEN)) { + WD_ERR("digest input length is too long, size = %u\n", msg->in_bytes); return -WD_EINVAL; } -- 2.33.0

1 0

[PATCH 0/6] support digest message carrying long data information
by Qi Tao 22 Sep '23

22 Sep '23

From: JiangShui Yang <yangjiangshui(a)h-partners.com> Wenkai Lin (6): uadk: fix for wd_memset_zero occupies high cpu usage uadk: optimize session update for long hash mode uadk: support digest message carrying long data information uadk: add out_bytes check for long hash scene uadk: bugfix for aead set decrypt mac for stream mode uadk: fix for digest mac full length check drv/hisi_sec.c | 4 +- include/drv/wd_aead_drv.h | 2 +- include/wd_digest.h | 22 +++++++++- v1/drv/hisi_sec_udrv.c | 4 ++ v1/wd_digest.c | 34 +++++++++++---- v1/wd_digest.h | 12 ++++++ wd_aead.c | 18 +++++--- wd_cipher.c | 2 +- wd_digest.c | 89 ++++++++++++++++++++++++--------------- 9 files changed, 131 insertions(+), 56 deletions(-) -- 2.30.0

1 6

[PATCH 1/2] uadk/v1: modify the alignment size of sha384.
by Qi Tao 20 Sep '23

20 Sep '23

sha384 alignment size is 128Byte instead of 64Byte. Signed-off-by: Qi Tao <taoqi10(a)huawei.com> --- v1/wd_digest.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/v1/wd_digest.c b/v1/wd_digest.c index 84b84dd..0a80cba 100644 --- a/v1/wd_digest.c +++ b/v1/wd_digest.c @@ -199,7 +199,7 @@ void *wcrypto_create_digest_ctx(struct wd_queue *q, } } - if (setup->alg >= WCRYPTO_SHA512) + if (setup->alg >= WCRYPTO_SHA384) ctx->align_sz = SEC_SHA512_ALIGN_SZ; else ctx->align_sz = SEC_SHA1_ALIGN_SZ; -- 2.33.0

1 1

[PATCH] uadk/cipher: cleaup judgement sequence
by Zhiqi Song 19 Sep '23

19 Sep '23

Modify the jugement sequence in aes_sm4_len_check(), prioritize the conditions that must be met. Signed-off-by: Zhiqi Song <songzhiqi1(a)huawei.com> --- drv/hisi_sec.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/drv/hisi_sec.c b/drv/hisi_sec.c index 5eaa1a1..f8e5cfa 100644 --- a/drv/hisi_sec.c +++ b/drv/hisi_sec.c @@ -892,18 +892,18 @@ static void parse_cipher_bd2(struct hisi_qp *qp, struct hisi_sec_sqe *sqe, static int aes_sm4_len_check(struct wd_cipher_msg *msg) { - if ((msg->mode == WD_CIPHER_CBC_CS1 || + if (msg->alg == WD_CIPHER_AES && + msg->in_bytes <= AES_BLOCK_SIZE && + (msg->mode == WD_CIPHER_CBC_CS1 || msg->mode == WD_CIPHER_CBC_CS2 || - msg->mode == WD_CIPHER_CBC_CS3) && - msg->alg == WD_CIPHER_AES && - msg->in_bytes <= AES_BLOCK_SIZE) { + msg->mode == WD_CIPHER_CBC_CS3)) { WD_ERR("failed to check input bytes of AES_CBC_CS_X, size = %u\n", msg->in_bytes); return -WD_EINVAL; } - if ((msg->mode == WD_CIPHER_CBC || msg->mode == WD_CIPHER_ECB) && - msg->in_bytes & (AES_BLOCK_SIZE - 1)) { + if ((msg->in_bytes & (AES_BLOCK_SIZE - 1)) && + (msg->mode == WD_CIPHER_CBC || msg->mode == WD_CIPHER_ECB)) { WD_ERR("failed to check input bytes of AES or SM4, size = %u\n", msg->in_bytes); return -WD_EINVAL; -- 2.30.0

1 0