From f6221f178fe43735fe56d45ae8d030dd949b3a23 Mon Sep 17 00:00:00 2001 From: Wenkai Lin Date: Wed, 12 Jan 2022 10:27:45 +0800 Subject: [PATCH] engine: update uadk engine source commit: e26726: digest: fix codecheck warning Signed-off-by: Wenkai Lin --- 0001-digest-delete-some-duplicate-code.patch | 55 --- ...igest-support-digest-multiple-update.patch | 161 ++++++++ ..._engine-define-the-variable-as-const.patch | 38 ++ 0003-ecc-fix-codecheck-warning.patch | 113 ++++++ 0004-rsa-delete-redundant-copy.patch | 28 ++ 0005-rsa-fix-coverity-warning.patch | 35 ++ ...anup-duplicate-public-key-allocation.patch | 165 ++++++++ ...p-about-reducing-function-parameters.patch | 349 +++++++++++++++++ ...-cleanup-sm2-compute-digest-function.patch | 355 ++++++++++++++++++ ...gfix-about-ecc-init-after-alloc-sess.patch | 232 ++++++++++++ 0010-rsa-cleanup-about-prime-generation.patch | 110 ++++++ ...cleanup-the-form-of-the-return-value.patch | 209 +++++++++++ ...-fix-uadk-engine-compatibility-issue.patch | 140 +++++++ ...t-modify-the-process-of-free-session.patch | 31 ++ ...e-process-of-soft-and-hardware-hando.patch | 153 ++++++++ 0015-ecc-bugfix-about-sm2-decryption.patch | 114 ++++++ 0016-dh-bugfix-about-dh-compute-key.patch | 103 +++++ 0017-ecc-bugfix-about-ecc-general-init.patch | 28 ++ 0018-digest-fix-codecheck-warning.patch | 113 ++++++ uadk_engine-1.0.0.tar.gz | Bin 556173 -> 486414 bytes uadk_engine.spec | 24 +- 21 files changed, 2499 insertions(+), 57 deletions(-) delete mode 100644 0001-digest-delete-some-duplicate-code.patch create mode 100644 0001-digest-support-digest-multiple-update.patch create mode 100644 0002-uadk_engine-define-the-variable-as-const.patch create mode 100644 0003-ecc-fix-codecheck-warning.patch create mode 100644 0004-rsa-delete-redundant-copy.patch create mode 100644 0005-rsa-fix-coverity-warning.patch create mode 100644 0006-ecc-cleanup-duplicate-public-key-allocation.patch create mode 100644 0007-rsa-cleanup-about-reducing-function-parameters.patch create mode 100644 0008-ecc-cleanup-sm2-compute-digest-function.patch create mode 100644 0009-ecc-bugfix-about-ecc-init-after-alloc-sess.patch create mode 100644 0010-rsa-cleanup-about-prime-generation.patch create mode 100644 0011-ecc-cleanup-the-form-of-the-return-value.patch create mode 100644 0012-engine-fix-uadk-engine-compatibility-issue.patch create mode 100644 0013-digest-modify-the-process-of-free-session.patch create mode 100644 0014-digest-modify-the-process-of-soft-and-hardware-hando.patch create mode 100644 0015-ecc-bugfix-about-sm2-decryption.patch create mode 100644 0016-dh-bugfix-about-dh-compute-key.patch create mode 100644 0017-ecc-bugfix-about-ecc-general-init.patch create mode 100644 0018-digest-fix-codecheck-warning.patch diff --git a/0001-digest-delete-some-duplicate-code.patch b/0001-digest-delete-some-duplicate-code.patch deleted file mode 100644 index 1c95acc..0000000 --- a/0001-digest-delete-some-duplicate-code.patch +++ /dev/null @@ -1,55 +0,0 @@ -From eba09f6a2eb20bf431822718fa752a68b6d682c5 Mon Sep 17 00:00:00 2001 -From: Kai Ye -Date: Thu, 9 Dec 2021 11:17:40 +0800 -Subject: [PATCH] digest: delete some duplicate code - -digest task not need to allocate session twice for one stream. -init->update->final as one stream. - -Signed-off-by: Kai Ye ---- - src/uadk_digest.c | 14 +++++--------- - 1 file changed, 5 insertions(+), 9 deletions(-) - -diff --git a/src/uadk_digest.c b/src/uadk_digest.c -index 9fdec91..db33d16 100644 ---- a/src/uadk_digest.c -+++ b/src/uadk_digest.c -@@ -607,10 +607,6 @@ static int uadk_e_digest_final(EVP_MD_CTX *ctx, unsigned char *digest) - int ret = 1; - struct async_op op; - -- priv->sess = wd_digest_alloc_sess(&priv->setup); -- if (unlikely(!priv->sess)) -- return 0; -- - priv->req.in = priv->data; - priv->req.out = digest; - priv->req.in_bytes = priv->tail; -@@ -639,11 +635,6 @@ static int uadk_e_digest_final(EVP_MD_CTX *ctx, unsigned char *digest) - goto clear; - } - -- if (priv->sess) { -- wd_digest_free_sess(priv->sess); -- priv->sess = 0; -- } -- - return 1; - - sync_err: -@@ -665,6 +656,11 @@ static int uadk_e_digest_cleanup(EVP_MD_CTX *ctx) - if (!priv || priv->copy) - return 1; - -+ if (priv->sess) { -+ wd_digest_free_sess(priv->sess); -+ priv->sess = 0; -+ } -+ - if (priv && priv->data) - OPENSSL_free(priv->data); - --- -2.24.4 - diff --git a/0001-digest-support-digest-multiple-update.patch b/0001-digest-support-digest-multiple-update.patch new file mode 100644 index 0000000..92f060c --- /dev/null +++ b/0001-digest-support-digest-multiple-update.patch @@ -0,0 +1,161 @@ +From 8cc0e8724565c12f0fa6f099070ec57504cd21fa Mon Sep 17 00:00:00 2001 +From: Kai Ye +Date: Thu, 9 Dec 2021 15:39:32 +0800 +Subject: [PATCH 01/18] digest: support digest multiple update + +Support digest multiple updating by using the SEC stream mode. + +Signed-off-by: Kai Ye +--- + src/uadk_digest.c | 77 ++++++++++++++++++++++++++++++++++++++--------- + 1 file changed, 62 insertions(+), 15 deletions(-) + +diff --git a/src/uadk_digest.c b/src/uadk_digest.c +index db33d16..41de449 100644 +--- a/src/uadk_digest.c ++++ b/src/uadk_digest.c +@@ -31,6 +31,8 @@ + #define CTX_SYNC 0 + #define CTX_ASYNC 1 + #define CTX_NUM 2 ++#define DIGEST_DOING 1 ++#define DIGEST_END 0 + #define ENV_ENABLED 1 + + /* The max BD data length is 16M-512B */ +@@ -41,6 +43,7 @@ + #define SM3_SMALL_PACKET_OFFLOAD_THRESHOLD_DEFAULT (512) + #define MD5_SMALL_PACKET_OFFLOAD_THRESHOLD_DEFAULT (8 * 1024) + #define SHA_SMALL_PACKET_OFFLOAD_THRESHOLD_DEFAULT (512) ++#define MAX_DIGEST_LENGTH 64 + + struct digest_threshold_table { + int nid; +@@ -69,12 +72,16 @@ struct evp_md_ctx_st { + int (*update)(EVP_MD_CTX *ctx, const void *data, size_t count); + }; + ++#define DIGEST_BLOCK_SIZE 4096 ++ + struct digest_priv_ctx { + handle_t sess; + struct wd_digest_sess_setup setup; + struct wd_digest_req req; + unsigned char *data; +- long tail; ++ unsigned char out[MAX_DIGEST_LENGTH]; ++ size_t tail; ++ size_t last_update_bufflen; + bool copy; + uint32_t e_nid; + EVP_MD_CTX *soft_ctx; +@@ -496,6 +503,13 @@ static int uadk_e_digest_init(EVP_MD_CTX *ctx) + if (unlikely(!priv->sess)) + return 0; + ++ priv->data = malloc(DIGEST_BLOCK_SIZE); ++ if (priv->data == NULL) { ++ wd_digest_free_sess(priv->sess); ++ return 0; ++ } ++ memset(priv->data, 0, DIGEST_BLOCK_SIZE); ++ + priv->switch_threshold = sec_digest_get_sw_threshold(nid); + + return 1; +@@ -504,6 +518,45 @@ soft_init: + return digest_soft_init(priv->soft_ctx, priv->e_nid); + } + ++static int digest_update_inner(EVP_MD_CTX *ctx, const void *data, size_t data_len) ++{ ++ struct digest_priv_ctx *priv = ++ (struct digest_priv_ctx *) EVP_MD_CTX_md_data(ctx); ++ const unsigned char *tmpdata = (const unsigned char *)data; ++ size_t left_len = data_len; ++ int copy_to_bufflen; ++ int ret; ++ ++ priv->req.has_next = DIGEST_DOING; ++ ++ while (priv->last_update_bufflen + left_len > DIGEST_BLOCK_SIZE) { ++ copy_to_bufflen = DIGEST_BLOCK_SIZE - priv->last_update_bufflen; ++ memcpy(priv->data + priv->last_update_bufflen, tmpdata, copy_to_bufflen); ++ ++ priv->last_update_bufflen = DIGEST_BLOCK_SIZE; ++ priv->req.in_bytes = DIGEST_BLOCK_SIZE; ++ priv->req.in = priv->data; ++ priv->req.out = priv->out; ++ left_len -= copy_to_bufflen; ++ tmpdata += copy_to_bufflen; ++ ++ ret = wd_do_digest_sync(priv->sess, &priv->req); ++ if (ret) ++ return 0; ++ ++ priv->last_update_bufflen = 0; ++ memset(priv->data, 0, DIGEST_BLOCK_SIZE); ++ if (left_len <= DIGEST_BLOCK_SIZE) { ++ priv->last_update_bufflen = left_len; ++ memcpy(priv->data, tmpdata, priv->last_update_bufflen); ++ break; ++ } ++ ++ } ++ ++ return 1; ++} ++ + static int uadk_e_digest_update(EVP_MD_CTX *ctx, const void *data, size_t data_len) + { + struct digest_priv_ctx *priv = +@@ -512,20 +565,13 @@ static int uadk_e_digest_update(EVP_MD_CTX *ctx, const void *data, size_t data_l + if (unlikely(priv->switch_flag == UADK_DO_SOFT)) + goto soft_update; + +- if ((data_len <= BUF_LEN - priv->tail) && (data_len > 0)) { +- if (!priv->data) { +- priv->data = OPENSSL_malloc(BUF_LEN); +- if (priv->data == NULL) +- return 0; +- } +- +- memcpy(priv->data + priv->tail, data, data_len); +- priv->tail += data_len; +- ++ if (priv->last_update_bufflen + data_len <= DIGEST_BLOCK_SIZE) { ++ memcpy(priv->data + priv->last_update_bufflen, data, data_len); ++ priv->last_update_bufflen += data_len; + return 1; + } + +- return 0; ++ return digest_update_inner(ctx, data, data_len); + + soft_update: + return digest_soft_update(priv->soft_ctx, priv->e_nid, data, data_len); +@@ -606,10 +652,10 @@ static int uadk_e_digest_final(EVP_MD_CTX *ctx, unsigned char *digest) + (struct digest_priv_ctx *)EVP_MD_CTX_md_data(ctx); + int ret = 1; + struct async_op op; +- ++ priv->req.has_next = DIGEST_END; + priv->req.in = priv->data; +- priv->req.out = digest; +- priv->req.in_bytes = priv->tail; ++ priv->req.out = priv->out; ++ priv->req.in_bytes = priv->last_update_bufflen; + priv->e_nid = EVP_MD_nid(EVP_MD_CTX_md(ctx)); + + ret = async_setup_async_event_notification(&op); +@@ -634,6 +680,7 @@ static int uadk_e_digest_final(EVP_MD_CTX *ctx, unsigned char *digest) + if (!ret) + goto clear; + } ++ memcpy(digest, priv->req.out, priv->req.out_bytes); + + return 1; + +-- +2.24.4 + diff --git a/0002-uadk_engine-define-the-variable-as-const.patch b/0002-uadk_engine-define-the-variable-as-const.patch new file mode 100644 index 0000000..87c6930 --- /dev/null +++ b/0002-uadk_engine-define-the-variable-as-const.patch @@ -0,0 +1,38 @@ +From b7bb19a4e5c239035926f952d24c2e95bf813fd8 Mon Sep 17 00:00:00 2001 +From: Weili Qian +Date: Mon, 20 Dec 2021 02:48:54 +0000 +Subject: [PATCH 02/18] uadk_engine: define the variable as 'const' + +Parameter: 'n' in the function has not been changed, +it should be defined as 'const'. + +Signed-off-by: Weili Qian +--- + src/uadk_rsa.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/src/uadk_rsa.c b/src/uadk_rsa.c +index bab3c24..75ae0d1 100644 +--- a/src/uadk_rsa.c ++++ b/src/uadk_rsa.c +@@ -174,7 +174,7 @@ static int prime_mul_res(int num, BIGNUM *rsa_p, BIGNUM *rsa_q, BIGNUM *r1, + } + + static int check_prime_sufficient(int *num, const int *bitsr, int *bitse, +- int *n, BIGNUM *rsa_p, BIGNUM *rsa_q, ++ const int *n, BIGNUM *rsa_p, BIGNUM *rsa_q, + BIGNUM *r1, BIGNUM *r2, BN_CTX *ctx, + BN_GENCB *cb) + { +@@ -268,7 +268,7 @@ static int check_prime_equal(int num, BIGNUM *rsa_p, BIGNUM *rsa_q, + return UADK_E_SUCCESS; + } + +-static int check_prime_useful(int *n, BIGNUM *prime, BIGNUM *r1, BIGNUM *r2, ++static int check_prime_useful(const int *n, BIGNUM *prime, BIGNUM *r1, BIGNUM *r2, + BIGNUM *e_pub, BN_CTX *ctx, BN_GENCB *cb) + { + unsigned long err; +-- +2.24.4 + diff --git a/0003-ecc-fix-codecheck-warning.patch b/0003-ecc-fix-codecheck-warning.patch new file mode 100644 index 0000000..f6eb7ea --- /dev/null +++ b/0003-ecc-fix-codecheck-warning.patch @@ -0,0 +1,113 @@ +From 1cd8bd255ae0f55742d2dffa7ba09aea28d56c9a Mon Sep 17 00:00:00 2001 +From: Weili Qian +Date: Wed, 22 Dec 2021 03:37:13 +0000 +Subject: [PATCH 03/18] ecc: fix codecheck warning + +fix a more than 50 lines function 'uadk_wd_ecc_init'. + +Signed-off-by: Weili Qian +--- + src/uadk_pkey.c | 61 +++++++++++++++++++++++++------------------------ + 1 file changed, 31 insertions(+), 30 deletions(-) + +diff --git a/src/uadk_pkey.c b/src/uadk_pkey.c +index c20b22b..62362b0 100644 +--- a/src/uadk_pkey.c ++++ b/src/uadk_pkey.c +@@ -178,38 +178,20 @@ static int uadk_e_wd_ecc_env_init(struct uacce_dev *dev) + return async_register_poll_fn(ASYNC_TASK_ECC, uadk_e_ecc_env_poll); + } + +-static int uadk_wd_ecc_init(struct ecc_res_config *config) ++static int uadk_e_wd_ecc_general_init(struct uacce_dev *dev, ++ struct wd_sched *sched) + { +- struct wd_sched *sched = &config->sched.wd_sched; + struct wd_ctx_config *ctx_cfg; +- struct uacce_dev *dev; + int ret, i; + +- /* ctx is no difference for sm2/ecdsa/ecdh/x25519/x448 */ +- dev = wd_get_accel_dev("ecdsa"); +- if (!dev) +- return -ENOMEM; +- +- config->numa_id = dev->numa_id; +- +- ret = uadk_e_is_env_enabled("ecc"); +- if (ret == ENV_ENABLED) { +- ret = uadk_e_wd_ecc_env_init(dev); +- goto free_dev; +- } +- +- if (ecc_res.ctx_res) { +- ret = 0; +- goto free_dev; +- } ++ if (ecc_res.ctx_res) ++ return 0; + + ctx_cfg = calloc(1, sizeof(struct wd_ctx_config)); +- if (!ctx_cfg) { ++ if (!ctx_cfg) + ret = -ENOMEM; +- goto free_dev; +- } +- ecc_res.ctx_res = ctx_cfg; + ++ ecc_res.ctx_res = ctx_cfg; + ctx_cfg->ctx_num = CTX_NUM; + ctx_cfg->ctxs = calloc(CTX_NUM, sizeof(struct wd_ctx)); + if (!ctx_cfg->ctxs) { +@@ -230,23 +212,42 @@ static int uadk_wd_ecc_init(struct ecc_res_config *config) + if (ret) + goto free_ctx; + +- free(dev); +- + return async_register_poll_fn(ASYNC_TASK_ECC, uadk_ecc_poll); + + free_ctx: + for (i = 0; i < CTX_NUM; i++) { +- if (ctx_cfg->ctxs[i].ctx) { ++ if (ctx_cfg->ctxs[i].ctx) + wd_release_ctx(ctx_cfg->ctxs[i].ctx); +- ctx_cfg->ctxs[i].ctx = 0; +- } + } + free(ctx_cfg->ctxs); + free_cfg: + free(ctx_cfg); + ecc_res.ctx_res = NULL; +-free_dev: ++ ++ return ret; ++} ++ ++static int uadk_wd_ecc_init(struct ecc_res_config *config) ++{ ++ struct wd_sched *sched = &config->sched.wd_sched; ++ struct uacce_dev *dev; ++ int ret; ++ ++ /* ctx is no difference for sm2/ecdsa/ecdh/x25519/x448 */ ++ dev = wd_get_accel_dev("ecdsa"); ++ if (!dev) ++ return -ENOMEM; ++ ++ config->numa_id = dev->numa_id; ++ ++ ret = uadk_e_is_env_enabled("ecc"); ++ if (ret) ++ ret = uadk_e_wd_ecc_env_init(dev); ++ else ++ ret = uadk_e_wd_ecc_general_init(dev, sched); ++ + free(dev); ++ + return ret; + } + +-- +2.24.4 + diff --git a/0004-rsa-delete-redundant-copy.patch b/0004-rsa-delete-redundant-copy.patch new file mode 100644 index 0000000..8bf9eae --- /dev/null +++ b/0004-rsa-delete-redundant-copy.patch @@ -0,0 +1,28 @@ +From 6c916851ae54c9272a96c7af73cba83598ab3c43 Mon Sep 17 00:00:00 2001 +From: Weili Qian +Date: Wed, 22 Dec 2021 03:51:48 +0000 +Subject: [PATCH 04/18] rsa: delete redundant copy + +'from_buf' and 'req.src' point to the same address space, +redundant copy is not required. + +Signed-off-by: Weili Qian +--- + src/uadk_rsa.c | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/src/uadk_rsa.c b/src/uadk_rsa.c +index 75ae0d1..1e1e226 100644 +--- a/src/uadk_rsa.c ++++ b/src/uadk_rsa.c +@@ -1595,7 +1595,6 @@ static int uadk_e_rsa_private_sign(int flen, const unsigned char *from, + goto free_buf; + } + +- memcpy(rsa_sess->req.src, from_buf, rsa_sess->req.src_bytes); + ret = rsa_do_crypto(rsa_sess); + if (!ret || rsa_sess->req.status) { + ret = UADK_DO_SOFT; +-- +2.24.4 + diff --git a/0005-rsa-fix-coverity-warning.patch b/0005-rsa-fix-coverity-warning.patch new file mode 100644 index 0000000..f444142 --- /dev/null +++ b/0005-rsa-fix-coverity-warning.patch @@ -0,0 +1,35 @@ +From f5fac71459234b4e44fe8ff386b19627e88ad680 Mon Sep 17 00:00:00 2001 +From: Weili Qian +Date: Wed, 22 Dec 2021 06:39:46 +0000 +Subject: [PATCH 05/18] rsa: fix coverity warning + +Parameter: 'n' in the function 'get_prime_once' has not +been changed, it should be defined as 'const'. + +Signed-off-by: Weili Qian +--- + src/uadk_rsa.c | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +diff --git a/src/uadk_rsa.c b/src/uadk_rsa.c +index 1e1e226..cb98159 100644 +--- a/src/uadk_rsa.c ++++ b/src/uadk_rsa.c +@@ -307,10 +307,10 @@ static int check_prime_useful(const int *n, BIGNUM *prime, BIGNUM *r1, BIGNUM *r + return GET_ERR_FINISH; + } + +-static int get_prime_once(int num, const int *bitsr, int *n, BIGNUM *prime, +- BIGNUM *rsa_p, BIGNUM *rsa_q, BIGNUM *r1, +- BIGNUM *r2, BIGNUM *e_pub, BN_CTX *ctx, +- BN_GENCB *cb) ++static int get_prime_once(int num, const int *bitsr, const int *n, ++ BIGNUM *prime, BIGNUM *rsa_p, BIGNUM *rsa_q, ++ BIGNUM *r1, BIGNUM *r2, BIGNUM *e_pub, ++ BN_CTX *ctx, BN_GENCB *cb) + { + int ret = -1; + +-- +2.24.4 + diff --git a/0006-ecc-cleanup-duplicate-public-key-allocation.patch b/0006-ecc-cleanup-duplicate-public-key-allocation.patch new file mode 100644 index 0000000..95b735b --- /dev/null +++ b/0006-ecc-cleanup-duplicate-public-key-allocation.patch @@ -0,0 +1,165 @@ +From 941c89ea6fefe3e78255437788c3f274b6c81414 Mon Sep 17 00:00:00 2001 +From: Zhiqi Song +Date: Wed, 22 Dec 2021 08:27:45 +0000 +Subject: [PATCH 06/18] ecc: cleanup duplicate public key allocation + +Remove duplicate allocation and copy of public key. + +Signed-off-by: Zhiqi Song +--- + src/uadk_ec.c | 95 +++++++++++++++++++++++++++------------------------ + 1 file changed, 51 insertions(+), 44 deletions(-) + +diff --git a/src/uadk_ec.c b/src/uadk_ec.c +index d97436b..9040d3c 100644 +--- a/src/uadk_ec.c ++++ b/src/uadk_ec.c +@@ -784,59 +784,78 @@ static int sm2_keygen_init_iot(handle_t sess, struct wd_ecc_req *req) + + static int eckey_create_key(EC_KEY *eckey) + { +- const EC_GROUP *group; +- EC_POINT *pub_key; + BIGNUM *priv_key; ++ int ret; + +- group = EC_KEY_get0_group(eckey); +- pub_key = (EC_POINT *)EC_KEY_get0_public_key(eckey); +- if (!pub_key) { +- pub_key = EC_POINT_new(group); +- if (!pub_key) { +- fprintf(stderr, "failed to new pub_key\n"); +- return -1; +- } +- EC_KEY_set_public_key(eckey, pub_key); ++ priv_key = (BIGNUM *)EC_KEY_get0_private_key(eckey); ++ if (priv_key) ++ return 1; ++ ++ priv_key = BN_new(); ++ if (!priv_key) { ++ fprintf(stderr, "failed to BN_new priv_key\n"); ++ return 0; + } + ++ ret = EC_KEY_set_private_key(eckey, priv_key); ++ if (!ret) ++ fprintf(stderr, "failed to set private key\n"); ++ ++ BN_free(priv_key); ++ return ret; ++} ++ ++static int ecdh_set_private_key(EC_KEY *eckey, BIGNUM *order) ++{ ++ BIGNUM *priv_key; ++ int ret; ++ ++ priv_key = (BIGNUM *)EC_KEY_get0_private_key(eckey); ++ if (priv_key) ++ return 1; ++ + priv_key = BN_new(); + if (!priv_key) { + fprintf(stderr, "failed to BN_new priv_key\n"); +- return -1; ++ return 0; + } +- EC_KEY_set_private_key(eckey, priv_key); + +- return 0; ++ do { ++ if (!BN_rand_range(priv_key, order)) { ++ fprintf(stderr, "failed to generate random value\n"); ++ ret = 0; ++ goto free_priv_key; ++ } ++ } while (BN_is_zero(priv_key)); ++ ++ ret = EC_KEY_set_private_key(eckey, priv_key); ++ if (!ret) ++ fprintf(stderr, "failed to set private key\n"); ++ ++free_priv_key: ++ BN_free(priv_key); ++ return ret; + } + + static int ecdh_create_key(EC_KEY *eckey) + { +- BIGNUM *priv_key, *order; + const EC_GROUP *group; +- EC_POINT *pub_key; ++ BIGNUM *order; + BN_CTX *ctx; +- int ret = 0; ++ int ret; + + group = EC_KEY_get0_group(eckey); +- pub_key = (EC_POINT *)EC_KEY_get0_public_key(eckey); +- if (!pub_key) { +- pub_key = EC_POINT_new(group); +- if (!pub_key) { +- fprintf(stderr, "failed to new pub_key\n"); +- return ret; +- } +- ret = EC_KEY_set_public_key(eckey, pub_key); +- } + + ctx = BN_CTX_new(); + if (!ctx) { + fprintf(stderr, "failed to allocate ctx\n"); +- return ret; ++ return 0; + } + +- order = BN_CTX_get(ctx); ++ order = BN_CTX_get(ctx); + if (!order) { + fprintf(stderr, "failed to allocate order\n"); ++ ret = 0; + goto free_ctx; + } + +@@ -846,26 +865,14 @@ static int ecdh_create_key(EC_KEY *eckey) + goto free_order; + } + +- priv_key = (BIGNUM *)EC_KEY_get0_private_key(eckey); +- if (!priv_key) { +- priv_key = BN_new(); +- if (!priv_key) { +- fprintf(stderr, "failed to BN_new priv_key\n"); +- goto free_order; +- } +- do { +- if (!BN_rand_range(priv_key, order)) +- fprintf(stderr, "failed to generate random value\n"); +- } while (BN_is_zero(priv_key)); +- ret = EC_KEY_set_private_key(eckey, priv_key); +- } +- ret = 1; ++ ret = ecdh_set_private_key(eckey, order); ++ if (!ret) ++ fprintf(stderr, "failed to set private key\n"); + + free_order: + BN_clear(order); + free_ctx: + BN_CTX_free(ctx); +- + return ret; + } + +@@ -880,7 +887,7 @@ static int sm2_generate_key(EC_KEY *eckey) + goto do_soft; + + ret = eckey_create_key(eckey); +- if (ret) ++ if (!ret) + return ret; + + ret = UADK_DO_SOFT; +-- +2.24.4 + diff --git a/0007-rsa-cleanup-about-reducing-function-parameters.patch b/0007-rsa-cleanup-about-reducing-function-parameters.patch new file mode 100644 index 0000000..b732175 --- /dev/null +++ b/0007-rsa-cleanup-about-reducing-function-parameters.patch @@ -0,0 +1,349 @@ +From 273cf10d03532e73dfcd9f8a1223bfecb64d0f16 Mon Sep 17 00:00:00 2001 +From: Zhiqi Song +Date: Wed, 22 Dec 2021 10:51:48 +0000 +Subject: [PATCH 07/18] rsa: cleanup about reducing function parameters + +Reduce the number of parameters of functions +related to prime, and make the name of those +functions clearer. + +Signed-off-by: Zhiqi Song +--- + src/uadk_rsa.c | 155 ++++++++++++++++++++++++++++++------------------- + 1 file changed, 95 insertions(+), 60 deletions(-) + +diff --git a/src/uadk_rsa.c b/src/uadk_rsa.c +index cb98159..c1609ca 100644 +--- a/src/uadk_rsa.c ++++ b/src/uadk_rsa.c +@@ -97,6 +97,14 @@ struct rsa_prikey_param { + int is_crt; + }; + ++struct rsa_prime_param { ++ BIGNUM *r1; ++ BIGNUM *r2; ++ BIGNUM *rsa_p; ++ BIGNUM *rsa_q; ++ BIGNUM *prime; ++}; ++ + struct uadk_rsa_sess { + handle_t sess; + struct wd_rsa_sess_setup setup; +@@ -156,15 +164,14 @@ static int rsa_check_bit_useful(const int bits, int flen) + } + } + +-static int prime_mul_res(int num, BIGNUM *rsa_p, BIGNUM *rsa_q, BIGNUM *r1, +- BN_CTX *ctx, BN_GENCB *cb) ++static int rsa_prime_mul_res(int num, BIGNUM *rsa_p, BIGNUM *rsa_q, BIGNUM *r1, ++ BN_CTX *ctx, BN_GENCB *cb) + { +- /* calculate n = p * q */ + if (num == 1) { + if (!BN_mul(r1, rsa_p, rsa_q, ctx)) + return BN_ERR; + } else { +- /* if num == 0, use number 3 to indicate do nothing */ ++ /* If num == 0, use number 3 to indicate do nothing */ + if (!BN_GENCB_call(cb, 3, num)) + return BN_ERR; + return BN_CONTINUE; +@@ -173,20 +180,21 @@ static int prime_mul_res(int num, BIGNUM *rsa_p, BIGNUM *rsa_q, BIGNUM *r1, + return BN_VALID; + } + +-static int check_prime_sufficient(int *num, const int *bitsr, int *bitse, +- const int *n, BIGNUM *rsa_p, BIGNUM *rsa_q, +- BIGNUM *r1, BIGNUM *r2, BN_CTX *ctx, +- BN_GENCB *cb) ++static int check_rsa_prime_sufficient(int *num, const int *bitsr, ++ int *bitse, const int *n, ++ struct rsa_prime_param *param, ++ BN_CTX *ctx, BN_GENCB *cb) + { + static int retries; + BN_ULONG bitst; + int ret; + +- ret = prime_mul_res(*num, rsa_p, rsa_q, r1, ctx, cb); ++ ret = rsa_prime_mul_res(*num, param->rsa_p, param->rsa_q, ++ param->r1, ctx, cb); + if (ret) + return ret; + /* +- * if |r1|, product of factors so far, is not as long as expected ++ * If |r1|, product of factors so far, is not as long as expected + * (by checking the first 4 bits are less than 0x9 or greater than + * 0xF). If so, re-generate the last prime. + * +@@ -199,10 +207,10 @@ static int check_prime_sufficient(int *num, const int *bitsr, int *bitse, + * key by using the modulus in a certificate. This is also covered + * by checking the length should not be less than 0x9. + */ +- if (!BN_rshift(r2, r1, *bitse - 4)) ++ if (!BN_rshift(param->r2, param->r1, *bitse - 4)) + return BN_ERR; + +- bitst = BN_get_word(r2); ++ bitst = BN_get_word(param->r2); + if (bitst < 0x9 || bitst > 0xF) { + /* + * For keys with more than 4 primes, we attempt longer factor to +@@ -216,7 +224,9 @@ static int check_prime_sufficient(int *num, const int *bitsr, int *bitse, + *bitse -= bitsr[*num]; + else + return -1; +- if (!BN_GENCB_call(cb, 2, *n++)) ++ ++ ret = BN_GENCB_call(cb, 2, *n++); ++ if (!ret) + return -1; + if (retries == 4) { + *num = -1; +@@ -227,14 +237,17 @@ static int check_prime_sufficient(int *num, const int *bitsr, int *bitse, + retries++; + return BN_REDO; + } +- if (!BN_GENCB_call(cb, 3, *num)) ++ ++ ret = BN_GENCB_call(cb, 3, *num); ++ if (!ret) + return BN_ERR; + retries = 0; + + return BN_VALID; + } + +-static void set_primes(int num, BIGNUM *rsa_p, BIGNUM *rsa_q, BIGNUM **prime) ++static void rsa_set_primes(int num, BIGNUM *rsa_p, BIGNUM *rsa_q, ++ BIGNUM **prime) + { + if (num == 0) + *prime = rsa_p; +@@ -244,8 +257,8 @@ static void set_primes(int num, BIGNUM *rsa_p, BIGNUM *rsa_q, BIGNUM **prime) + BN_set_flags(*prime, BN_FLG_CONSTTIME); + } + +-static int check_prime_equal(int num, BIGNUM *rsa_p, BIGNUM *rsa_q, +- BIGNUM *prime) ++static int check_rsa_prime_equal(int num, BIGNUM *rsa_p, BIGNUM *rsa_q, ++ BIGNUM *prime) + { + BIGNUM *prev_prime; + int j; +@@ -268,8 +281,8 @@ static int check_prime_equal(int num, BIGNUM *rsa_p, BIGNUM *rsa_q, + return UADK_E_SUCCESS; + } + +-static int check_prime_useful(const int *n, BIGNUM *prime, BIGNUM *r1, BIGNUM *r2, +- BIGNUM *e_pub, BN_CTX *ctx, BN_GENCB *cb) ++static int check_rsa_prime_useful(const int *n, struct rsa_prime_param *param, ++ BIGNUM *e_pub, BN_CTX *ctx, BN_GENCB *cb) + { + unsigned long err; + /* +@@ -278,10 +291,10 @@ static int check_prime_useful(const int *n, BIGNUM *prime, BIGNUM *r1, BIGNUM *r + * BN_value_one() returns a BIGNUM constant of value 1. + * r2 = prime - 1. + */ +- if (!BN_sub(r2, prime, BN_value_one())) ++ if (!BN_sub(param->r2, param->prime, BN_value_one())) + return -1; + ERR_set_mark(); +- BN_set_flags(r2, BN_FLG_CONSTTIME); ++ BN_set_flags(param->r2, BN_FLG_CONSTTIME); + /* + * BN_mod_inverse(r,a,n,ctx) used to compute inverse modulo n. + * Precisely, it computes the inverse of "a" modulo "n", and places +@@ -290,7 +303,7 @@ static int check_prime_useful(const int *n, BIGNUM *prime, BIGNUM *r1, BIGNUM *r + * The expected result: (r2 * r1) % e_pub ==1, + * the inverse of r2 exist, that is r1. + */ +- if (BN_mod_inverse(r1, r2, e_pub, ctx)) ++ if (BN_mod_inverse(param->r1, param->r2, e_pub, ctx)) + return UADK_E_SUCCESS; + + err = ERR_peek_last_error(); +@@ -307,10 +320,9 @@ static int check_prime_useful(const int *n, BIGNUM *prime, BIGNUM *r1, BIGNUM *r + return GET_ERR_FINISH; + } + +-static int get_prime_once(int num, const int *bitsr, const int *n, +- BIGNUM *prime, BIGNUM *rsa_p, BIGNUM *rsa_q, +- BIGNUM *r1, BIGNUM *r2, BIGNUM *e_pub, +- BN_CTX *ctx, BN_GENCB *cb) ++static int get_rsa_prime_once(int num, const int *bitsr, const int *n, ++ BIGNUM *e_pub, struct rsa_prime_param *param, ++ BN_CTX *ctx, BN_GENCB *cb) + { + int ret = -1; + +@@ -318,12 +330,13 @@ static int get_prime_once(int num, const int *bitsr, const int *n, + return ret; + while (1) { + /* Generate prime with bitsr[num] len. */ +- if (!BN_generate_prime_ex(prime, bitsr[num], ++ if (!BN_generate_prime_ex(param->prime, bitsr[num], + 0, NULL, NULL, cb)) + return BN_ERR; +- if (!check_prime_equal(num, rsa_p, rsa_q, prime)) ++ if (!check_rsa_prime_equal(num, param->rsa_p, param->rsa_q, ++ param->prime)) + continue; +- ret = check_prime_useful(n, prime, r1, r2, e_pub, ctx, cb); ++ ret = check_rsa_prime_useful(n, param, e_pub, ctx, cb); + if (ret == BN_ERR) + return BN_ERR; + else if (ret == UADK_E_SUCCESS) +@@ -333,8 +346,7 @@ static int get_prime_once(int num, const int *bitsr, const int *n, + return ret; + } + +-static void switch_p_q(BIGNUM *rsa_p, BIGNUM *rsa_q, +- BIGNUM *p, BIGNUM *q) ++static void rsa_switch_p_q(BIGNUM *rsa_p, BIGNUM *rsa_q, BIGNUM *p, BIGNUM *q) + { + BIGNUM *tmp; + +@@ -373,13 +385,37 @@ static int check_rsa_is_crt(RSA *rsa) + return UN_SET; + } + ++static int get_rsa_prime_param(struct rsa_prime_param *param, BN_CTX *ctx) ++{ ++ param->r1 = BN_CTX_get(ctx); ++ if (!param->r1) ++ goto end; ++ ++ param->r2 = BN_CTX_get(ctx); ++ if (!param->r2) ++ goto end; ++ ++ param->rsa_p = BN_CTX_get(ctx); ++ if (!param->rsa_p) ++ goto end; ++ ++ param->rsa_q = BN_CTX_get(ctx); ++ if (!param->rsa_q) ++ goto end; ++ ++ return UADK_E_SUCCESS; ++ ++end: ++ fprintf(stderr, "failed to malloc params\n"); ++ return UADK_E_FAIL; ++} ++ + static int rsa_primes_gen(int bits, BIGNUM *e_pub, BIGNUM *p, + BIGNUM *q, BN_GENCB *cb) + { +- BIGNUM *r1, *r2, *rsa_p, *rsa_q; ++ struct rsa_prime_param *param = NULL; + int bitsr[RSA_MAX_PRIME_NUM] = {0}; + int flag, quo, rmd, i; +- BIGNUM *prime = NULL; + BN_CTX *ctx; + int bitse = 0; + int ret = 0; +@@ -391,12 +427,15 @@ static int rsa_primes_gen(int bits, BIGNUM *e_pub, BIGNUM *p, + return ret; + + BN_CTX_start(ctx); +- r1 = BN_CTX_get(ctx); +- r2 = BN_CTX_get(ctx); +- rsa_p = BN_CTX_get(ctx); +- rsa_q = BN_CTX_get(ctx); +- if (!r1 || !r2 || !rsa_p || !rsa_q) +- goto err; ++ param = OPENSSL_zalloc(sizeof(struct rsa_prime_param)); ++ if (!param) { ++ fprintf(stderr, "failed to malloc rsa prime param\n"); ++ goto free_ctx; ++ } ++ ++ ret = get_rsa_prime_param(param, ctx); ++ if (!ret) ++ goto free_param; + + /* Divide bits into 'primes' pieces evenly */ + quo = bits / RSA_MAX_PRIME_NUM; +@@ -409,39 +448,37 @@ static int rsa_primes_gen(int bits, BIGNUM *e_pub, BIGNUM *p, + /* flag: whether primes are generated correctely. */ + flag = 1; + /* Set flag for primes rsa_p and rsa_q separately. */ +- set_primes(i, rsa_p, rsa_q, &prime); ++ rsa_set_primes(i, param->rsa_p, param->rsa_q, ¶m->prime); + while (flag == 1) { +- if (get_prime_once(i, bitsr, &n, prime, rsa_p, rsa_q, +- r1, r2, e_pub, ctx, cb) == -1) +- goto err; ++ ret = get_rsa_prime_once(i, bitsr, &n, e_pub, param, ++ ctx, cb); ++ if (ret == -1) ++ goto free_param; + bitse += bitsr[i]; +- ret = check_prime_sufficient(&i, bitsr, &bitse, &n, +- rsa_p, rsa_q, r1, r2, +- ctx, cb); ++ ret = check_rsa_prime_sufficient(&i, bitsr, &bitse, &n, ++ param, ctx, cb); + if (ret == BN_ERR) +- goto err; ++ goto free_param; + else if (ret == BN_REDO) + continue; + else + flag = 0; + } + } +- switch_p_q(rsa_p, rsa_q, p, q); ++ rsa_switch_p_q(param->rsa_p, param->rsa_q, p, q); + + ret = UADK_E_SUCCESS; + +-err: +- if (ctx) { +- BN_CTX_end(ctx); +- BN_CTX_free(ctx); +- } +- ++free_param: ++ OPENSSL_free(param); ++free_ctx: ++ BN_CTX_end(ctx); ++ BN_CTX_free(ctx); + return ret; + } + + static int add_rsa_pubenc_padding(int flen, const unsigned char *from, +- unsigned char *buf, int num, +- int padding) ++ unsigned char *buf, int num, int padding) + { + int ret; + +@@ -852,8 +889,7 @@ static struct uadk_rsa_sess *rsa_get_eng_session(RSA *rsa, unsigned int bits, + + static int rsa_fill_pubkey(struct rsa_pubkey_param *pubkey_param, + struct uadk_rsa_sess *rsa_sess, +- unsigned char *in_buf, +- unsigned char *to) ++ unsigned char *in_buf, unsigned char *to) + { + struct wd_rsa_pubkey *pubkey = NULL; + struct wd_dtb *wd_e = NULL; +@@ -882,8 +918,7 @@ static int rsa_fill_pubkey(struct rsa_pubkey_param *pubkey_param, + + static int rsa_fill_prikey(RSA *rsa, struct uadk_rsa_sess *rsa_sess, + struct rsa_prikey_param *pri, +- unsigned char *in_buf, +- unsigned char *to) ++ unsigned char *in_buf, unsigned char *to) + { + struct wd_rsa_prikey *prikey; + struct wd_dtb *wd_dq; +-- +2.24.4 + diff --git a/0008-ecc-cleanup-sm2-compute-digest-function.patch b/0008-ecc-cleanup-sm2-compute-digest-function.patch new file mode 100644 index 0000000..e4647bb --- /dev/null +++ b/0008-ecc-cleanup-sm2-compute-digest-function.patch @@ -0,0 +1,355 @@ +From b99452edd6ae045e833e3ae01866b8546fd5733a Mon Sep 17 00:00:00 2001 +From: Zhiqi Song +Date: Fri, 24 Dec 2021 07:30:22 +0000 +Subject: [PATCH 08/18] ecc: cleanup sm2 compute digest function + +The operation flow of sm2_compute_z_digest() +is modularized and encapsulated to reduce +the code line of sm2_compute_z_digest() and +make the code easier to understand. + +Signed-off-by: Zhiqi Song +--- + src/uadk_sm2.c | 277 +++++++++++++++++++++++++++++++++++-------------- + 1 file changed, 197 insertions(+), 80 deletions(-) + +diff --git a/src/uadk_sm2.c b/src/uadk_sm2.c +index d74aa3a..6d5dad0 100644 +--- a/src/uadk_sm2.c ++++ b/src/uadk_sm2.c +@@ -62,6 +62,26 @@ typedef struct sm2_ciphertext { + ASN1_OCTET_STRING *C2; + } SM2_Ciphertext; + ++struct sm2_param { ++ /* ++ * p: BIGNUM with the prime number (GFp) or the polynomial ++ * defining the underlying field (GF2m) ++ */ ++ BIGNUM *p; ++ /* a: BIGNUM for parameter a of the equation */ ++ BIGNUM *a; ++ /* b: BIGNUM for parameter b of the equation */ ++ BIGNUM *b; ++ /* xG: BIGNUM for the x-coordinate value of G point */ ++ BIGNUM *xG; ++ /* yG: BIGNUM for the y-coordinate value of G point */ ++ BIGNUM *yG; ++ /* xA: BIGNUM for the x-coordinate value of PA point */ ++ BIGNUM *xA; ++ /* yA: BIGNUM for the y-coordinate value of PA point */ ++ BIGNUM *yA; ++}; ++ + DECLARE_ASN1_FUNCTIONS(SM2_Ciphertext) + + ASN1_SEQUENCE(SM2_Ciphertext) = { +@@ -695,8 +715,7 @@ static int sm2_verify_init(EVP_PKEY_CTX *ctx) + } + + static int sm2_verify_init_iot(handle_t sess, struct wd_ecc_req *req, +- struct wd_dtb *e, +- struct wd_dtb *r, ++ struct wd_dtb *e, struct wd_dtb *r, + struct wd_dtb *s) + { + struct wd_ecc_in *ecc_in; +@@ -1229,119 +1248,217 @@ static int sm2_ctrl_str(EVP_PKEY_CTX *ctx, + return UADK_E_INVALID; + } + +-static int sm2_compute_z_digest(uint8_t *out, +- const EVP_MD *digest, +- const uint8_t *id, +- const size_t id_len, +- const EC_KEY *key) ++static int get_sm2_param(struct sm2_param *sm2_param, BN_CTX *ctx) + { +- const EC_GROUP *group = EC_KEY_get0_group(key); +- EVP_MD_CTX *hash = NULL; +- uint8_t *buf = NULL; +- BN_CTX *ctx = NULL; +- BIGNUM *p = NULL; +- BIGNUM *a = NULL; +- BIGNUM *b = NULL; +- BIGNUM *xG = NULL; +- BIGNUM *yG = NULL; +- BIGNUM *xA = NULL; +- BIGNUM *yA = NULL; +- uint8_t e_byte; +- uint16_t entl; +- int p_bytes; +- int rc = 0; ++ sm2_param->p = BN_CTX_get(ctx); ++ if (!sm2_param->p) ++ goto end; + +- hash = EVP_MD_CTX_new(); +- ctx = BN_CTX_new(); +- if (hash == NULL || ctx == NULL) { +- fprintf(stderr, "failed to EVP_CTX_new\n"); +- goto done; +- } ++ sm2_param->a = BN_CTX_get(ctx); ++ if (!sm2_param->a) ++ goto end; + +- p = BN_CTX_get(ctx); +- a = BN_CTX_get(ctx); +- b = BN_CTX_get(ctx); +- xG = BN_CTX_get(ctx); +- yG = BN_CTX_get(ctx); +- xA = BN_CTX_get(ctx); +- yA = BN_CTX_get(ctx); +- if (yA == NULL) { +- fprintf(stderr, "failed to malloc\n"); +- goto done; +- } ++ sm2_param->b = BN_CTX_get(ctx); ++ if (!sm2_param->b) ++ goto end; ++ ++ sm2_param->xG = BN_CTX_get(ctx); ++ if (!sm2_param->xG) ++ goto end; ++ ++ sm2_param->yG = BN_CTX_get(ctx); ++ if (!sm2_param->yG) ++ goto end; ++ ++ sm2_param->xA = BN_CTX_get(ctx); ++ if (!sm2_param->xA) ++ goto end; ++ ++ sm2_param->yA = BN_CTX_get(ctx); ++ if (!sm2_param->yA) ++ goto end; ++ ++ return 1; ++ ++end: ++ fprintf(stderr, "failed to malloc params\n"); ++ return 0; ++} ++ ++static int check_digest_evp_lib(const EVP_MD *digest, EVP_MD_CTX *hash, ++ const size_t id_len, const uint8_t *id) ++{ ++ uint8_t e_byte; ++ uint16_t entl; + + if (!EVP_DigestInit(hash, digest)) { + fprintf(stderr, "error evp lib\n"); +- goto done; ++ return 0; + } + + /* Z = h(ENTL || ID || a || b || xG || yG || xA || yA) */ + if (id_len >= (UINT16_MAX / 8)) { +- /* too large */ + fprintf(stderr, "id too large\n"); +- goto done; ++ return 0; + } + + entl = (uint16_t)(8 * id_len); + + e_byte = entl >> 8; +- if (!EVP_DigestUpdate(hash, &e_byte, 1)) { +- fprintf(stderr, "error evp lib\n"); +- goto done; +- } ++ if (!EVP_DigestUpdate(hash, &e_byte, 1)) { ++ fprintf(stderr, "error evp lib\n"); ++ return 0; ++ } ++ + e_byte = entl & 0xFF; + if (!EVP_DigestUpdate(hash, &e_byte, 1)) { + fprintf(stderr, "error evp lib\n"); +- goto done; ++ return 0; + } + + if (id_len > 0 && !EVP_DigestUpdate(hash, id, id_len)) { + fprintf(stderr, "error evp lib\n"); +- goto done; ++ return 0; + } + +- if (!EC_GROUP_get_curve(group, p, a, b, ctx)) { +- fprintf(stderr, "error ec lib\n"); +- goto done; ++ return 1; ++} ++ ++static int check_equation_param(struct sm2_param *param, EVP_MD_CTX *hash, ++ uint8_t *buf, int p_bytes) ++{ ++ if (BN_bn2binpad(param->a, buf, p_bytes) < 0 || ++ !EVP_DigestUpdate(hash, buf, p_bytes) || ++ BN_bn2binpad(param->b, buf, p_bytes) < 0 || ++ !EVP_DigestUpdate(hash, buf, p_bytes)) { ++ fprintf(stderr, "failed to check equation param\n"); ++ return 0; + } + +- p_bytes = BN_num_bytes(p); +- buf = OPENSSL_zalloc(p_bytes); +- if (buf == NULL) { +- fprintf(stderr, "failed to malloc\n"); +- goto done; ++ return 1; ++} ++ ++ ++static int check_base_point_group_param(struct sm2_param *param, BN_CTX *ctx, ++ const EC_KEY *key) ++{ ++ const EC_GROUP *group = EC_KEY_get0_group(key); ++ ++ if (!EC_POINT_get_affine_coordinates(group, ++ EC_GROUP_get0_generator(group), ++ param->xG, param->yG, ctx)) { ++ fprintf(stderr, "failed to check base point group param\n"); ++ return 0; + } + +- if (BN_bn2binpad(a, buf, p_bytes) < 0 +- || !EVP_DigestUpdate(hash, buf, p_bytes) +- || BN_bn2binpad(b, buf, p_bytes) < 0 +- || !EVP_DigestUpdate(hash, buf, p_bytes) +- || !EC_POINT_get_affine_coordinates(group, +- EC_GROUP_get0_generator(group), +- xG, yG, ctx) +- || BN_bn2binpad(xG, buf, p_bytes) < 0 +- || !EVP_DigestUpdate(hash, buf, p_bytes) +- || BN_bn2binpad(yG, buf, p_bytes) < 0 +- || !EVP_DigestUpdate(hash, buf, p_bytes) +- || !EC_POINT_get_affine_coordinates(group, +- EC_KEY_get0_public_key(key), +- xA, yA, ctx) +- || BN_bn2binpad(xA, buf, p_bytes) < 0 +- || !EVP_DigestUpdate(hash, buf, p_bytes) +- || BN_bn2binpad(yA, buf, p_bytes) < 0 +- || !EVP_DigestUpdate(hash, buf, p_bytes) +- || !EVP_DigestFinal(hash, out, NULL)) { +- fprintf(stderr, "internal error\n"); +- goto done; ++ return 1; ++} ++ ++static int check_base_point_param(struct sm2_param *param, EVP_MD_CTX *hash, ++ uint8_t *buf, int p_bytes) ++{ ++ if (BN_bn2binpad(param->xG, buf, p_bytes) < 0 || ++ !EVP_DigestUpdate(hash, buf, p_bytes) || ++ BN_bn2binpad(param->yG, buf, p_bytes) < 0 || ++ !EVP_DigestUpdate(hash, buf, p_bytes)) { ++ fprintf(stderr, "failed to check base point param\n"); ++ return 0; + } + +- rc = 1; ++ return 1; ++} + +-done: ++static int check_pkey_point_group_param(struct sm2_param *param, BN_CTX *ctx, ++ const EC_KEY *key) ++{ ++ const EC_GROUP *group = EC_KEY_get0_group(key); ++ ++ if (!EC_POINT_get_affine_coordinates(group, ++ EC_KEY_get0_public_key(key), ++ param->xA, param->yA, ctx)) { ++ fprintf(stderr, "failed to check pkey point group param\n"); ++ return 0; ++ } ++ return 1; ++} ++ ++static int check_pkey_point_param(struct sm2_param *param, EVP_MD_CTX *hash, ++ uint8_t *buf, int p_bytes, uint8_t *out) ++{ ++ if (BN_bn2binpad(param->xA, buf, p_bytes) < 0 || ++ !EVP_DigestUpdate(hash, buf, p_bytes) || ++ BN_bn2binpad(param->yA, buf, p_bytes) < 0 || ++ !EVP_DigestUpdate(hash, buf, p_bytes) || ++ !EVP_DigestFinal(hash, out, NULL)) { ++ fprintf(stderr, "failed to check pkey point param\n"); ++ return 0; ++ } ++ ++ return 1; ++} ++ ++static int sm2_compute_z_digest(uint8_t *out, const EVP_MD *digest, ++ const uint8_t *id, const size_t id_len, ++ const EC_KEY *key) ++{ ++ const EC_GROUP *group = EC_KEY_get0_group(key); ++ struct sm2_param *param = NULL; ++ EVP_MD_CTX *hash = NULL; ++ uint8_t *buf = NULL; ++ BN_CTX *ctx = NULL; ++ int p_bytes; ++ int ret = 0; ++ ++ hash = EVP_MD_CTX_new(); ++ if (!hash) ++ return ret; ++ ++ ctx = BN_CTX_new(); ++ if (!ctx) ++ goto free_hash; ++ ++ param = OPENSSL_zalloc(sizeof(struct sm2_param)); ++ if (!param) { ++ fprintf(stderr, "failed to malloc sm2 param\n"); ++ goto free_ctx; ++ } ++ ++ if (!get_sm2_param(param, ctx)) ++ goto free_param; ++ ++ if (!check_digest_evp_lib(digest, hash, id_len, id)) ++ goto free_param; ++ ++ if (!EC_GROUP_get_curve(group, param->p, param->a, param->b, ctx)) { ++ fprintf(stderr, "failed to get curve\n"); ++ goto free_param; ++ } ++ ++ p_bytes = BN_num_bytes(param->p); ++ buf = OPENSSL_zalloc(p_bytes); ++ if (!buf) { ++ fprintf(stderr, "failed to malloc buf\n"); ++ goto free_param; ++ } ++ ++ if (!check_equation_param(param, hash, buf, p_bytes) || ++ !check_base_point_group_param(param, ctx, key) || ++ !check_base_point_param(param, hash, buf, p_bytes) || ++ !check_pkey_point_group_param(param, ctx, key) || ++ !check_pkey_point_param(param, hash, buf, p_bytes, out)) ++ goto free_buf; ++ ++ ret = 1; ++ ++free_buf: + OPENSSL_free(buf); ++free_param: ++ OPENSSL_free(param); ++free_ctx: + BN_CTX_free(ctx); ++free_hash: + EVP_MD_CTX_free(hash); +- return rc; ++ return ret; + } + + static int sm2_digest_custom(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx) +-- +2.24.4 + diff --git a/0009-ecc-bugfix-about-ecc-init-after-alloc-sess.patch b/0009-ecc-bugfix-about-ecc-init-after-alloc-sess.patch new file mode 100644 index 0000000..af9a35e --- /dev/null +++ b/0009-ecc-bugfix-about-ecc-init-after-alloc-sess.patch @@ -0,0 +1,232 @@ +From 1bb24b3d0769f82e6903ca94fa6b8ad466eb5bbe Mon Sep 17 00:00:00 2001 +From: Zhiqi Song +Date: Fri, 24 Dec 2021 08:44:03 +0000 +Subject: [PATCH 09/18] ecc: bugfix about ecc init after alloc sess + +When executing allocating session operation, it needs +sched_init(), which is supported by init operation +in the engine, so the init operation should be done +before executing allocating session operation. + +Signed-off-by: Zhiqi Song +--- + src/uadk_ec.c | 93 +++++++++++++++++++++++---------------------------- + 1 file changed, 42 insertions(+), 51 deletions(-) + +diff --git a/src/uadk_ec.c b/src/uadk_ec.c +index 9040d3c..0c8a011 100644 +--- a/src/uadk_ec.c ++++ b/src/uadk_ec.c +@@ -426,7 +426,10 @@ static ECDSA_SIG *ecdsa_do_sign(const unsigned char *dgst, int dlen, + if (ret) + goto do_soft; + +- ret = UADK_DO_SOFT; ++ ret = uadk_init_ecc(); ++ if (ret) ++ goto do_soft; ++ + sess = ecc_alloc_sess(eckey, "ecdsa"); + if (!sess) + goto do_soft; +@@ -438,33 +441,28 @@ static ECDSA_SIG *ecdsa_do_sign(const unsigned char *dgst, int dlen, + if (ret) + goto free_sess; + +- ret = uadk_ecc_set_private_key(sess, eckey); ++ ret = uadk_ecc_set_private_key(sess, eckey); + if (ret) + goto uninit_iot; + +- ret = uadk_init_ecc(); +- if (ret) { +- ret = UADK_DO_SOFT; +- goto uninit_iot; +- } +- + ret = uadk_ecc_crypto(sess, &req, (void *)sess); +- if (ret != 1) { +- ret = UADK_DO_SOFT; ++ if (ret != 1) + goto uninit_iot; +- } + + sig = create_ecdsa_sig(&req); + ++ wd_ecc_del_in(sess, req.src); ++ wd_ecc_del_out(sess, req.dst); ++ wd_ecc_free_sess(sess); ++ ++ return sig; ++ + uninit_iot: + wd_ecc_del_in(sess, req.src); + wd_ecc_del_out(sess, req.dst); + free_sess: + wd_ecc_free_sess(sess); + do_soft: +- if (ret != UADK_DO_SOFT) +- return sig; +- + fprintf(stderr, "switch to execute openssl software calculation.\n"); + return openssl_do_sign(dgst, dlen, in_kinv, in_r, eckey); + } +@@ -617,7 +615,10 @@ static int ecdsa_do_verify(const unsigned char *dgst, int dlen, + if (ret) + goto do_soft; + +- ret = UADK_DO_SOFT; ++ ret = uadk_init_ecc(); ++ if (ret) ++ goto do_soft; ++ + sess = ecc_alloc_sess(eckey, "ecdsa"); + if (!sess) + goto do_soft; +@@ -633,24 +634,19 @@ static int ecdsa_do_verify(const unsigned char *dgst, int dlen, + if (ret) + goto uninit_iot; + +- ret = uadk_init_ecc(); +- if (ret) { +- ret = UADK_DO_SOFT; +- goto uninit_iot; +- } +- + ret = uadk_ecc_crypto(sess, &req, (void *)sess); + if (ret != 1) { +- printf("failed to uadk_ecc_crypto, ret = %d\n", ret); +- ret = UADK_DO_SOFT; ++ fprintf(stderr, "failed to uadk_ecc_crypto, ret = %d\n", ret); ++ goto uninit_iot; + } ++ ++ return ret; ++ + uninit_iot: + wd_ecc_del_in(sess, req.src); + free_sess: + wd_ecc_free_sess(sess); + do_soft: +- if (ret != UADK_DO_SOFT) +- return ret; + fprintf(stderr, "switch to execute openssl software calculation.\n"); + return openssl_do_verify(dgst, dlen, sig, eckey); + } +@@ -888,9 +884,12 @@ static int sm2_generate_key(EC_KEY *eckey) + + ret = eckey_create_key(eckey); + if (!ret) +- return ret; ++ goto do_soft; ++ ++ ret = uadk_init_ecc(); ++ if (ret) ++ goto do_soft; + +- ret = UADK_DO_SOFT; + sess = ecc_alloc_sess(eckey, "sm2"); + if (!sess) + goto do_soft; +@@ -900,35 +899,29 @@ static int sm2_generate_key(EC_KEY *eckey) + if (ret) + goto free_sess; + +- ret = uadk_init_ecc(); +- if (ret) { +- ret = UADK_DO_SOFT; +- goto uninit_iot; +- } +- + ret = uadk_ecc_crypto(sess, &req, (void *)sess); +- if (ret != 1) { +- ret = UADK_DO_SOFT; ++ if (ret != 1) + goto uninit_iot; +- } + + ret = set_key_to_ec_key(eckey, &req); + if (ret) + goto uninit_iot; + + ret = 1; ++ wd_ecc_del_out(sess, req.dst); ++ wd_ecc_free_sess(sess); ++ ++ return ret; ++ + uninit_iot: + wd_ecc_del_out(sess, req.dst); + free_sess: + wd_ecc_free_sess(sess); + do_soft: +- if (ret != UADK_DO_SOFT) +- return ret; + fprintf(stderr, "switch to execute openssl software calculation.\n"); + return openssl_do_generate(eckey); + } + +- + static int ecdh_keygen_init_iot(handle_t sess, struct wd_ecc_req *req, + EC_KEY *ecdh) + { +@@ -1108,6 +1101,10 @@ static int ecdh_generate_key(EC_KEY *ecdh) + if (!ret) + goto do_soft; + ++ ret = uadk_init_ecc(); ++ if (ret) ++ goto do_soft; ++ + sess = ecc_alloc_sess(ecdh, "ecdh"); + if (!sess) + goto do_soft; +@@ -1121,10 +1118,6 @@ static int ecdh_generate_key(EC_KEY *ecdh) + if (ret) + goto uninit_iot; + +- ret = uadk_init_ecc(); +- if (ret) +- goto uninit_iot; +- + ret = uadk_ecc_crypto(sess, &req, (void *)sess); + if (ret != 1) + goto uninit_iot; +@@ -1202,10 +1195,8 @@ static int ecc_compkey_check(unsigned char **out, + return 1; + } + +-static int ecdh_compute_key(unsigned char **out, +- size_t *outlen, +- const EC_POINT *pub_key, +- const EC_KEY *ecdh) ++static int ecdh_compute_key(unsigned char **out, size_t *outlen, ++ const EC_POINT *pub_key, const EC_KEY *ecdh) + { + struct wd_ecc_req req; + handle_t sess; +@@ -1215,6 +1206,10 @@ static int ecdh_compute_key(unsigned char **out, + if (!ret) + goto do_soft; + ++ ret = uadk_init_ecc(); ++ if (ret) ++ goto do_soft; ++ + sess = ecc_alloc_sess(ecdh, "ecdh"); + if (!sess) + goto do_soft; +@@ -1232,10 +1227,6 @@ static int ecdh_compute_key(unsigned char **out, + if (ret) + goto uninit_iot; + +- ret = uadk_init_ecc(); +- if (ret) +- goto uninit_iot; +- + ret = uadk_ecc_crypto(sess, &req, (void *)sess); + if (ret != 1) + goto uninit_iot; +-- +2.24.4 + diff --git a/0010-rsa-cleanup-about-prime-generation.patch b/0010-rsa-cleanup-about-prime-generation.patch new file mode 100644 index 0000000..22d3d17 --- /dev/null +++ b/0010-rsa-cleanup-about-prime-generation.patch @@ -0,0 +1,110 @@ +From fc023b87189ff488b4e760567d92afeca2635559 Mon Sep 17 00:00:00 2001 +From: Zhiqi Song +Date: Sat, 25 Dec 2021 01:35:03 +0000 +Subject: [PATCH 10/18] rsa: cleanup about prime generation + +Reduce parameter number of rsa_prime_mul_res(), +and add comments of BN_GENCB_call(). + +Signed-off-by: Zhiqi Song +--- + src/uadk_rsa.c | 28 +++++++++++++++++----------- + 1 file changed, 17 insertions(+), 11 deletions(-) + +diff --git a/src/uadk_rsa.c b/src/uadk_rsa.c +index c1609ca..2526af9 100644 +--- a/src/uadk_rsa.c ++++ b/src/uadk_rsa.c +@@ -164,14 +164,17 @@ static int rsa_check_bit_useful(const int bits, int flen) + } + } + +-static int rsa_prime_mul_res(int num, BIGNUM *rsa_p, BIGNUM *rsa_q, BIGNUM *r1, ++static int rsa_prime_mul_res(int num, struct rsa_prime_param *param, + BN_CTX *ctx, BN_GENCB *cb) + { + if (num == 1) { +- if (!BN_mul(r1, rsa_p, rsa_q, ctx)) ++ if (!BN_mul(param->r1, param->rsa_p, param->rsa_q, ctx)) + return BN_ERR; + } else { +- /* If num == 0, use number 3 to indicate do nothing */ ++ /* ++ * Use the number 3 to indicate whether ++ * the generator has been found. ++ */ + if (!BN_GENCB_call(cb, 3, num)) + return BN_ERR; + return BN_CONTINUE; +@@ -189,8 +192,7 @@ static int check_rsa_prime_sufficient(int *num, const int *bitsr, + BN_ULONG bitst; + int ret; + +- ret = rsa_prime_mul_res(*num, param->rsa_p, param->rsa_q, +- param->r1, ctx, cb); ++ ret = rsa_prime_mul_res(*num, param, ctx, cb); + if (ret) + return ret; + /* +@@ -224,7 +226,10 @@ static int check_rsa_prime_sufficient(int *num, const int *bitsr, + *bitse -= bitsr[*num]; + else + return -1; +- ++ /* ++ * Use the number 2 to indicate whether ++ * a prime has been found. ++ */ + ret = BN_GENCB_call(cb, 2, *n++); + if (!ret) + return -1; +@@ -237,7 +242,7 @@ static int check_rsa_prime_sufficient(int *num, const int *bitsr, + retries++; + return BN_REDO; + } +- ++ /* Use the number 3 to indicate whether the generator has been found. */ + ret = BN_GENCB_call(cb, 3, *num); + if (!ret) + return BN_ERR; +@@ -314,6 +319,7 @@ static int check_rsa_prime_useful(const int *n, struct rsa_prime_param *param, + else + return BN_ERR; + ++ /* Use the number 2 to indicate whether a prime has been found. */ + if (!BN_GENCB_call(cb, 2, *n++)) + return BN_ERR; + +@@ -1094,7 +1100,7 @@ static int uadk_e_soft_rsa_keygen(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb) + int ret; + + if (!default_meth) { +- printf("failed to get soft method.\n"); ++ fprintf(stderr, "failed to get soft method.\n"); + return UADK_E_FAIL; + } + +@@ -1121,7 +1127,7 @@ static int rsa_fill_keygen_data(struct uadk_rsa_sess *rsa_sess, + return UADK_E_FAIL; + + keygen_param->wd_e->dsize = BN_bn2bin(bn_param->e, +- (unsigned char *)keygen_param->wd_e->data); ++ (unsigned char *)keygen_param->wd_e->data); + + wd_rsa_get_prikey(rsa_sess->sess, &key_pair->prikey); + if (!key_pair->prikey) +@@ -1133,9 +1139,9 @@ static int rsa_fill_keygen_data(struct uadk_rsa_sess *rsa_sess, + return UADK_E_FAIL; + + keygen_param->wd_q->dsize = BN_bn2bin(bn_param->q, +- (unsigned char *)keygen_param->wd_q->data); ++ (unsigned char *)keygen_param->wd_q->data); + keygen_param->wd_p->dsize = BN_bn2bin(bn_param->p, +- (unsigned char *)keygen_param->wd_p->data); ++ (unsigned char *)keygen_param->wd_p->data); + + rsa_sess->req.src_bytes = rsa_sess->key_size; + rsa_sess->req.dst_bytes = rsa_sess->key_size; +-- +2.24.4 + diff --git a/0011-ecc-cleanup-the-form-of-the-return-value.patch b/0011-ecc-cleanup-the-form-of-the-return-value.patch new file mode 100644 index 0000000..50f7402 --- /dev/null +++ b/0011-ecc-cleanup-the-form-of-the-return-value.patch @@ -0,0 +1,209 @@ +From dbb4ff29da9ed378d8753a6e5d18e86756c1d254 Mon Sep 17 00:00:00 2001 +From: Zhiqi Song +Date: Mon, 27 Dec 2021 07:04:43 +0000 +Subject: [PATCH 11/18] ecc: cleanup the form of the return value + +This patch includes: +1. Unified the return value form. +2. Remove redundant goto jumps. + +Signed-off-by: Zhiqi Song +--- + src/uadk_ec.c | 20 +++++++++++--------- + src/uadk_ecx.c | 8 ++++---- + src/uadk_pkey.c | 5 ++--- + src/uadk_sm2.c | 8 ++++---- + 4 files changed, 21 insertions(+), 20 deletions(-) + +diff --git a/src/uadk_ec.c b/src/uadk_ec.c +index 0c8a011..db69871 100644 +--- a/src/uadk_ec.c ++++ b/src/uadk_ec.c +@@ -446,7 +446,7 @@ static ECDSA_SIG *ecdsa_do_sign(const unsigned char *dgst, int dlen, + goto uninit_iot; + + ret = uadk_ecc_crypto(sess, &req, (void *)sess); +- if (ret != 1) ++ if (!ret) + goto uninit_iot; + + sig = create_ecdsa_sig(&req); +@@ -635,11 +635,14 @@ static int ecdsa_do_verify(const unsigned char *dgst, int dlen, + goto uninit_iot; + + ret = uadk_ecc_crypto(sess, &req, (void *)sess); +- if (ret != 1) { ++ if (!ret) { + fprintf(stderr, "failed to uadk_ecc_crypto, ret = %d\n", ret); + goto uninit_iot; + } + ++ wd_ecc_del_in(sess, req.src); ++ wd_ecc_free_sess(sess); ++ + return ret; + + uninit_iot: +@@ -701,7 +704,7 @@ static int set_key_to_ec_key(EC_KEY *ec, struct wd_ecc_req *req) + tmp = BN_bin2bn((unsigned char *)privkey->data, privkey->dsize, NULL); + ret = EC_KEY_set_private_key(ec, tmp); + BN_free(tmp); +- if (ret != 1) { ++ if (!ret) { + fprintf(stderr, "failed to EC KEY set private key\n"); + return -EINVAL; + } +@@ -725,7 +728,7 @@ static int set_key_to_ec_key(EC_KEY *ec, struct wd_ecc_req *req) + + ret = EC_KEY_set_public_key(ec, point); + EC_POINT_free(point); +- if (ret != 1) { ++ if (!ret) { + fprintf(stderr, "failed to EC_KEY_set_public_key\n"); + return -EINVAL; + } +@@ -900,18 +903,17 @@ static int sm2_generate_key(EC_KEY *eckey) + goto free_sess; + + ret = uadk_ecc_crypto(sess, &req, (void *)sess); +- if (ret != 1) ++ if (!ret) + goto uninit_iot; + + ret = set_key_to_ec_key(eckey, &req); + if (ret) + goto uninit_iot; + +- ret = 1; + wd_ecc_del_out(sess, req.dst); + wd_ecc_free_sess(sess); + +- return ret; ++ return 1; + + uninit_iot: + wd_ecc_del_out(sess, req.dst); +@@ -1119,7 +1121,7 @@ static int ecdh_generate_key(EC_KEY *ecdh) + goto uninit_iot; + + ret = uadk_ecc_crypto(sess, &req, (void *)sess); +- if (ret != 1) ++ if (!ret) + goto uninit_iot; + + ret = ecdh_set_key_to_ec_key(ecdh, &req); +@@ -1228,7 +1230,7 @@ static int ecdh_compute_key(unsigned char **out, size_t *outlen, + goto uninit_iot; + + ret = uadk_ecc_crypto(sess, &req, (void *)sess); +- if (ret != 1) ++ if (!ret) + goto uninit_iot; + + ret = ecdh_get_shared_key(ecdh, out, outlen, &req); +diff --git a/src/uadk_ecx.c b/src/uadk_ecx.c +index 6a9f78c..67f9350 100644 +--- a/src/uadk_ecx.c ++++ b/src/uadk_ecx.c +@@ -399,7 +399,7 @@ static int x25519_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) + goto uninit_iot; + + ret = uadk_ecc_crypto(keygen_ctx->sess, &req, (void *)keygen_ctx->sess); +- if (ret != 1) ++ if (!ret) + goto uninit_iot; + + ret = ecx_keygen_set_pkey(pkey, keygen_ctx, &req, ecx_key); +@@ -457,7 +457,7 @@ static int x448_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) + goto uninit_iot; + + ret = uadk_ecc_crypto(keygen_ctx->sess, &req, (void *)keygen_ctx->sess); +- if (ret != 1) ++ if (!ret) + goto uninit_iot; + + ret = ecx_keygen_set_pkey(pkey, keygen_ctx, &req, ecx_key); +@@ -659,7 +659,7 @@ static int x25519_derive(EVP_PKEY_CTX *ctx, unsigned char *key, + goto uninit_iot; + + ret = uadk_ecc_crypto(derive_ctx->sess, &req, (void *)derive_ctx); +- if (ret != 1) ++ if (!ret) + goto uninit_iot; + + wd_ecxdh_get_out_params(req.dst, &s_key); +@@ -745,7 +745,7 @@ static int x448_derive(EVP_PKEY_CTX *ctx, unsigned char *key, + goto uninit_iot; + + ret = uadk_ecc_crypto(derive_ctx->sess, &req, (void *)derive_ctx); +- if (ret != 1) ++ if (!ret) + goto uninit_iot; + + wd_ecxdh_get_out_params(req.dst, &s_key); +diff --git a/src/uadk_pkey.c b/src/uadk_pkey.c +index 62362b0..7ca998b 100644 +--- a/src/uadk_pkey.c ++++ b/src/uadk_pkey.c +@@ -273,8 +273,7 @@ static void uadk_wd_ecc_uninit(void) + ecc_res.pid = 0; + } + +-int uadk_ecc_crypto(handle_t sess, +- struct wd_ecc_req *req, void *usr) ++int uadk_ecc_crypto(handle_t sess, struct wd_ecc_req *req, void *usr) + { + struct uadk_e_cb_info cb_param; + struct async_op op; +@@ -314,7 +313,7 @@ int uadk_ecc_crypto(handle_t sess, + } else { + ret = wd_do_ecc_sync(sess, req); + if (ret < 0) +- return ret; ++ return 0; + } + return 1; + err: +diff --git a/src/uadk_sm2.c b/src/uadk_sm2.c +index 6d5dad0..f602e48 100644 +--- a/src/uadk_sm2.c ++++ b/src/uadk_sm2.c +@@ -359,7 +359,7 @@ static int sign_bin_to_ber(EC_KEY *ec, struct wd_dtb *r, struct wd_dtb *s, + } + + ret = ECDSA_SIG_set0(e_sig, br, bs); +- if (ret != 1) { ++ if (!ret) { + fprintf(stderr, "failed to ECDSA_SIG_set0\n"); + ret = -EINVAL; + goto free_s; +@@ -686,7 +686,7 @@ static int sm2_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen, + } + + ret = uadk_ecc_crypto(smctx->sess, &req, smctx); +- if (ret != 1) { ++ if (!ret) { + fprintf(stderr, "failed to uadk_ecc_crypto, ret = %d\n", ret); + ret = UADK_DO_SOFT; + goto uninit_iot; +@@ -907,7 +907,7 @@ static int sm2_encrypt(EVP_PKEY_CTX *ctx, + } + + ret = uadk_ecc_crypto(smctx->sess, &req, smctx); +- if (ret != 1) { ++ if (!ret) { + ret = UADK_DO_SOFT; + fprintf(stderr, "failed to uadk_ecc_crypto, ret = %d\n", ret); + goto uninit_iot; +@@ -1061,7 +1061,7 @@ static int sm2_decrypt(EVP_PKEY_CTX *ctx, + } + + ret = uadk_ecc_crypto(smctx->sess, &req, smctx); +- if (ret != 1) { ++ if (!ret) { + ret = UADK_DO_SOFT; + fprintf(stderr, "failed to uadk_ecc_crypto, ret = %d\n", ret); + goto uninit_iot; +-- +2.24.4 + diff --git a/0012-engine-fix-uadk-engine-compatibility-issue.patch b/0012-engine-fix-uadk-engine-compatibility-issue.patch new file mode 100644 index 0000000..ee913ea --- /dev/null +++ b/0012-engine-fix-uadk-engine-compatibility-issue.patch @@ -0,0 +1,140 @@ +From c212eedcab9135acc0433a125c8fab151674e8c5 Mon Sep 17 00:00:00 2001 +From: Wenkai Lin +Date: Tue, 23 Nov 2021 09:14:31 +0000 +Subject: [PATCH 12/18] engine: fix uadk engine compatibility issue + +When uadk use no sva mode, it should use wd_get_available_dev_num, +otherwise, it will not find old kernel's device path with attrs. + +Signed-off-by: Wenkai Lin +--- + src/e_uadk.c | 70 +++++++++++++++--------------------- + src/v1/uadk_v1.h | 1 + + src/v1/wdmngr/wd_alg_queue.c | 4 +++ + src/v1/wdmngr/wd_alg_queue.h | 2 ++ + 4 files changed, 36 insertions(+), 41 deletions(-) + +diff --git a/src/e_uadk.c b/src/e_uadk.c +index 18c2e4e..4e87c86 100644 +--- a/src/e_uadk.c ++++ b/src/e_uadk.c +@@ -239,54 +239,42 @@ static void engine_init_child_at_fork_handler(void) + #ifdef KAE + static void bind_fn_kae_alg(ENGINE *e) + { +- struct uacce_dev *dev; ++ int dev_num; + +- dev = wd_get_accel_dev("cipher"); +- if (dev) { +- if (!(dev->flags & UACCE_DEV_SVA)) { +- cipher_module_init(); +- if (!ENGINE_set_ciphers(e, sec_engine_ciphers)) +- fprintf(stderr, "uadk bind cipher failed\n"); +- else +- uadk_cipher_nosva = 1; +- } +- free(dev); ++ dev_num = wd_get_nosva_dev_num("cipher"); ++ if (dev_num > 0) { ++ cipher_module_init(); ++ if (!ENGINE_set_ciphers(e, sec_engine_ciphers)) ++ fprintf(stderr, "uadk bind cipher failed\n"); ++ else ++ uadk_cipher_nosva = 1; + } + +- dev = wd_get_accel_dev("digest"); +- if (dev) { +- if (!(dev->flags & UACCE_DEV_SVA)) { +- digest_module_init(); +- if (!ENGINE_set_digests(e, sec_engine_digests)) +- fprintf(stderr, "uadk bind digest failed\n"); +- else +- uadk_digest_nosva = 1; +- } +- free(dev); ++ dev_num = wd_get_nosva_dev_num("digest"); ++ if (dev_num > 0) { ++ digest_module_init(); ++ if (!ENGINE_set_digests(e, sec_engine_digests)) ++ fprintf(stderr, "uadk bind digest failed\n"); ++ else ++ uadk_digest_nosva = 1; + } + +- dev = wd_get_accel_dev("rsa"); +- if (dev) { +- if (!(dev->flags & UACCE_DEV_SVA)) { +- hpre_module_init(); +- if (!ENGINE_set_RSA(e, hpre_get_rsa_methods())) +- fprintf(stderr, "uadk bind rsa failed\n"); +- else +- uadk_rsa_nosva = 1; +- } +- free(dev); ++ dev_num = wd_get_nosva_dev_num("rsa"); ++ if (dev_num > 0) { ++ hpre_module_init(); ++ if (!ENGINE_set_RSA(e, hpre_get_rsa_methods())) ++ fprintf(stderr, "uadk bind rsa failed\n"); ++ else ++ uadk_rsa_nosva = 1; + } + +- dev = wd_get_accel_dev("dh"); +- if (dev) { +- if (!(dev->flags & UACCE_DEV_SVA)) { +- hpre_module_dh_init(); +- if (!ENGINE_set_DH(e, hpre_get_dh_methods())) +- fprintf(stderr, "uadk bind dh failed\n"); +- else +- uadk_dh_nosva = 1; +- } +- free(dev); ++ dev_num = wd_get_nosva_dev_num("dh"); ++ if (dev_num > 0) { ++ hpre_module_dh_init(); ++ if (!ENGINE_set_DH(e, hpre_get_dh_methods())) ++ fprintf(stderr, "uadk bind dh failed\n"); ++ else ++ uadk_dh_nosva = 1; + } + } + #endif +diff --git a/src/v1/uadk_v1.h b/src/v1/uadk_v1.h +index f5081e3..d921706 100644 +--- a/src/v1/uadk_v1.h ++++ b/src/v1/uadk_v1.h +@@ -35,4 +35,5 @@ extern void hpre_dh_destroy(void); + + extern int hpre_pkey_meths(ENGINE *e, EVP_PKEY_METHOD **pmeth, + const int **pnids, int nid); ++extern int wd_get_nosva_dev_num(const char *algorithm); + #endif +diff --git a/src/v1/wdmngr/wd_alg_queue.c b/src/v1/wdmngr/wd_alg_queue.c +index 79c9a6d..5cd33ae 100644 +--- a/src/v1/wdmngr/wd_alg_queue.c ++++ b/src/v1/wdmngr/wd_alg_queue.c +@@ -74,3 +74,7 @@ void wd_free_queue(struct wd_queue *queue) + } + } + ++int wd_get_nosva_dev_num(const char *algorithm) ++{ ++ return wd_get_available_dev_num(algorithm); ++} +diff --git a/src/v1/wdmngr/wd_alg_queue.h b/src/v1/wdmngr/wd_alg_queue.h +index 4fd3a9d..955eed5 100644 +--- a/src/v1/wdmngr/wd_alg_queue.h ++++ b/src/v1/wdmngr/wd_alg_queue.h +@@ -25,4 +25,6 @@ + struct wd_queue *wd_new_queue(int algtype); + + void wd_free_queue(struct wd_queue *queue); ++ ++int wd_get_nosva_dev_num(const char *algorithm); + #endif +-- +2.24.4 + diff --git a/0013-digest-modify-the-process-of-free-session.patch b/0013-digest-modify-the-process-of-free-session.patch new file mode 100644 index 0000000..701bbcd --- /dev/null +++ b/0013-digest-modify-the-process-of-free-session.patch @@ -0,0 +1,31 @@ +From ca59dfa548656d82d6d50a6dad6bfc88b2825473 Mon Sep 17 00:00:00 2001 +From: Kai Ye +Date: Thu, 6 Jan 2022 14:49:27 +0800 +Subject: [PATCH 13/18] digest: modify the process of free session + +Currently, release the session in the cleanup instead of final. so not +should free session in the final. Here is fix it. + +Signed-off-by: Kai Ye +--- + src/uadk_digest.c | 4 ---- + 1 file changed, 4 deletions(-) + +diff --git a/src/uadk_digest.c b/src/uadk_digest.c +index 41de449..cbfb539 100644 +--- a/src/uadk_digest.c ++++ b/src/uadk_digest.c +@@ -688,10 +688,6 @@ sync_err: + ret = uadk_e_digest_soft_work(priv, priv->tail, digest); + clear: + async_clear_async_event_notification(); +- if (priv->sess) { +- wd_digest_free_sess(priv->sess); +- priv->sess = 0; +- } + return ret; + } + +-- +2.24.4 + diff --git a/0014-digest-modify-the-process-of-soft-and-hardware-hando.patch b/0014-digest-modify-the-process-of-soft-and-hardware-hando.patch new file mode 100644 index 0000000..5c90457 --- /dev/null +++ b/0014-digest-modify-the-process-of-soft-and-hardware-hando.patch @@ -0,0 +1,153 @@ +From 7efc5b169d74b84af8108bc736d80eedbe3a8004 Mon Sep 17 00:00:00 2001 +From: Kai Ye +Date: Thu, 6 Jan 2022 14:48:13 +0800 +Subject: [PATCH 14/18] digest: modify the process of soft and hardware handoff + +Due to has added the stream mode for digest. So need to modify the +process of software and hardware handoff. + +Signed-off-by: Kai Ye +--- + src/uadk_digest.c | 60 +++++++++++++++++++++++++++++++++++++---------- + 1 file changed, 48 insertions(+), 12 deletions(-) + +diff --git a/src/uadk_digest.c b/src/uadk_digest.c +index cbfb539..bf738af 100644 +--- a/src/uadk_digest.c ++++ b/src/uadk_digest.c +@@ -44,6 +44,14 @@ + #define MD5_SMALL_PACKET_OFFLOAD_THRESHOLD_DEFAULT (8 * 1024) + #define SHA_SMALL_PACKET_OFFLOAD_THRESHOLD_DEFAULT (512) + #define MAX_DIGEST_LENGTH 64 ++#define DIGEST_BLOCK_SIZE (512 * 1024) ++ ++enum sec_digestz_state { ++ SEC_DIGEST_INIT, ++ SEC_DIGEST_FIRST_UPDATING, ++ SEC_DIGEST_DOING, ++ SEC_DIGEST_FINAL ++}; + + struct digest_threshold_table { + int nid; +@@ -72,21 +80,19 @@ struct evp_md_ctx_st { + int (*update)(EVP_MD_CTX *ctx, const void *data, size_t count); + }; + +-#define DIGEST_BLOCK_SIZE 4096 +- + struct digest_priv_ctx { + handle_t sess; + struct wd_digest_sess_setup setup; + struct wd_digest_req req; + unsigned char *data; + unsigned char out[MAX_DIGEST_LENGTH]; +- size_t tail; ++ EVP_MD_CTX *soft_ctx; + size_t last_update_bufflen; +- bool copy; + uint32_t e_nid; +- EVP_MD_CTX *soft_ctx; +- size_t switch_threshold; ++ uint32_t state; ++ uint32_t switch_threshold; + int switch_flag; ++ bool copy; + }; + + static int digest_nids[] = { +@@ -150,7 +156,7 @@ static const EVP_MD *uadk_e_digests_soft_md(uint32_t e_nid) + return digest_md; + } + +-static int sec_digest_get_sw_threshold(int n_id) ++static uint32_t sec_digest_get_sw_threshold(int n_id) + { + int threshold_table_size = ARRAY_SIZE(digest_pkt_threshold_table); + int i = 0; +@@ -464,6 +470,7 @@ static int uadk_e_digest_init(EVP_MD_CTX *ctx) + priv->soft_ctx = EVP_MD_CTX_new(); + priv->e_nid = nid; + ++ priv->state = SEC_DIGEST_INIT; + ret = uadk_e_init_digest(); + if (!ret) { + priv->switch_flag = UADK_DO_SOFT; +@@ -504,7 +511,7 @@ static int uadk_e_digest_init(EVP_MD_CTX *ctx) + return 0; + + priv->data = malloc(DIGEST_BLOCK_SIZE); +- if (priv->data == NULL) { ++ if (!priv->data) { + wd_digest_free_sess(priv->sess); + return 0; + } +@@ -540,9 +547,16 @@ static int digest_update_inner(EVP_MD_CTX *ctx, const void *data, size_t data_le + left_len -= copy_to_bufflen; + tmpdata += copy_to_bufflen; + ++ if (priv->state == SEC_DIGEST_INIT) ++ priv->state = SEC_DIGEST_FIRST_UPDATING; ++ else if (priv->state == SEC_DIGEST_FIRST_UPDATING) ++ priv->state = SEC_DIGEST_DOING; ++ + ret = wd_do_digest_sync(priv->sess, &priv->req); +- if (ret) +- return 0; ++ if (ret) { ++ fprintf(stderr, "do sec digest sync failed, switch to soft digest.\n"); ++ goto do_soft_digest; ++ } + + priv->last_update_bufflen = 0; + memset(priv->data, 0, DIGEST_BLOCK_SIZE); +@@ -551,10 +565,26 @@ static int digest_update_inner(EVP_MD_CTX *ctx, const void *data, size_t data_le + memcpy(priv->data, tmpdata, priv->last_update_bufflen); + break; + } ++ } ++ ++ return 1; ++do_soft_digest: ++ if (priv->state == SEC_DIGEST_FIRST_UPDATING ++ && priv->data ++ && priv->last_update_bufflen != 0) { ++ priv->switch_flag = UADK_DO_SOFT; ++ digest_soft_init(priv->soft_ctx, priv->e_nid); ++ ret = digest_soft_update(priv->soft_ctx, priv->e_nid, ++ priv->data, priv->last_update_bufflen); ++ if (ret != 1) ++ return ret; + ++ return digest_soft_update(priv->soft_ctx, priv->e_nid, ++ tmpdata, left_len); + } + +- return 1; ++ fprintf(stderr, "do soft digest failed during updating!\n"); ++ return 0; + } + + static int uadk_e_digest_update(EVP_MD_CTX *ctx, const void *data, size_t data_len) +@@ -681,11 +711,17 @@ static int uadk_e_digest_final(EVP_MD_CTX *ctx, unsigned char *digest) + goto clear; + } + memcpy(digest, priv->req.out, priv->req.out_bytes); ++ priv->last_update_bufflen = 0; + + return 1; + + sync_err: +- ret = uadk_e_digest_soft_work(priv, priv->tail, digest); ++ if (priv->state == SEC_DIGEST_INIT) { ++ ret = uadk_e_digest_soft_work(priv, priv->req.in_bytes, digest); ++ } else { ++ ret = 0; ++ fprintf(stderr, "do sec digest stream mode failed.\n"); ++ } + clear: + async_clear_async_event_notification(); + return ret; +-- +2.24.4 + diff --git a/0015-ecc-bugfix-about-sm2-decryption.patch b/0015-ecc-bugfix-about-sm2-decryption.patch new file mode 100644 index 0000000..3c64c7b --- /dev/null +++ b/0015-ecc-bugfix-about-sm2-decryption.patch @@ -0,0 +1,114 @@ +From 32c58bf68e7f33d0170b3cc9040a11395a68df72 Mon Sep 17 00:00:00 2001 +From: Zhiqi Song +Date: Sat, 8 Jan 2022 07:24:22 +0000 +Subject: [PATCH 15/18] ecc: bugfix about sm2 decryption + +When doing sm2_decrypt_check(), if the out param is NULL, +it is supposed to use sm2_plaintext_size() function to +get the output plain text length, rather than use +sm2_ciphertext_size(). + +Signed-off-by: Zhiqi Song +--- + src/uadk_sm2.c | 29 ++++++++++++++++++++++------- + 1 file changed, 22 insertions(+), 7 deletions(-) + +diff --git a/src/uadk_sm2.c b/src/uadk_sm2.c +index f602e48..b39c418 100644 +--- a/src/uadk_sm2.c ++++ b/src/uadk_sm2.c +@@ -524,7 +524,7 @@ static int cipher_ber_to_bin(unsigned char *ber, size_t ber_len, + len = BN_num_bytes(ctext_struct->C1x); + len1 = BN_num_bytes(ctext_struct->C1y); + c1->x.data = malloc(len + len1 + ctext_struct->C2->length + +- ctext_struct->C3->length); ++ ctext_struct->C3->length); + if (!c1->x.data) { + ret = -ENOMEM; + goto free_ctext; +@@ -547,7 +547,6 @@ free_ctext: + + static size_t ec_field_size(const EC_GROUP *group) + { +- /* Is there some simpler way to do this? */ + BIGNUM *p = BN_new(); + BIGNUM *a = BN_new(); + BIGNUM *b = BN_new(); +@@ -559,7 +558,7 @@ static size_t ec_field_size(const EC_GROUP *group) + if (!EC_GROUP_get_curve(group, p, a, b, NULL)) + goto done; + +- /* Pad and convert bits to bytes*/ ++ /* Pad and convert bits to bytes */ + field_size = (BN_num_bits(p) + 7) / 8; + + done: +@@ -570,6 +569,22 @@ done: + return field_size; + } + ++static int sm2_plaintext_size(const unsigned char *ct, size_t ct_size, size_t *pt_size) ++{ ++ struct sm2_ciphertext *sm2_ctext; ++ ++ sm2_ctext = d2i_SM2_Ciphertext(NULL, &ct, ct_size); ++ if (!sm2_ctext) { ++ fprintf(stderr, "invalid sm2 encoding\n"); ++ return 0; ++ } ++ ++ *pt_size = sm2_ctext->C2->length; ++ SM2_Ciphertext_free(sm2_ctext); ++ ++ return 1; ++} ++ + static int sm2_ciphertext_size(const EC_KEY *key, + const EVP_MD *digest, size_t msg_len, + size_t *ct_size) +@@ -589,6 +604,7 @@ static int sm2_ciphertext_size(const EC_KEY *key, + + ASN1_object_size(0, md_size, V_ASN1_OCTET_STRING) + + ASN1_object_size(0, msg_len, V_ASN1_OCTET_STRING); + *ct_size = ASN1_object_size(1, sz, V_ASN1_SEQUENCE); ++ + return 1; + } + +@@ -792,7 +808,7 @@ static int sm2_verify(EVP_PKEY_CTX *ctx, + } + + ret = uadk_ecc_crypto(smctx->sess, &req, smctx); +- if (ret != 1) { ++ if (!ret) { + ret = UADK_DO_SOFT; + fprintf(stderr, "failed to uadk_ecc_crypto, ret = %d\n", ret); + goto uninit_iot; +@@ -941,8 +957,6 @@ static int sm2_decrypt_check(EVP_PKEY_CTX *ctx, + const unsigned char *in, size_t inlen) + { + struct sm2_ctx *smctx = EVP_PKEY_CTX_get_data(ctx); +- EVP_PKEY *p_key = EVP_PKEY_CTX_get0_pkey(ctx); +- EC_KEY *ec = EVP_PKEY_get0(p_key); + const EVP_MD *md; + int hash_size; + +@@ -959,7 +973,7 @@ static int sm2_decrypt_check(EVP_PKEY_CTX *ctx, + } + + if (!out) { +- if (!sm2_ciphertext_size(ec, md, inlen, outlen)) ++ if (!sm2_plaintext_size(in, inlen, outlen)) + return -1; + else + return 1; +@@ -1039,6 +1053,7 @@ static int sm2_decrypt(EVP_PKEY_CTX *ctx, + } + + md = (smctx->ctx.md == NULL) ? EVP_sm3() : smctx->ctx.md; ++ + ret = cipher_ber_to_bin((void *)in, inlen, &c1, &c2, &c3); + if (ret) + goto do_soft; +-- +2.24.4 + diff --git a/0016-dh-bugfix-about-dh-compute-key.patch b/0016-dh-bugfix-about-dh-compute-key.patch new file mode 100644 index 0000000..c9f8f60 --- /dev/null +++ b/0016-dh-bugfix-about-dh-compute-key.patch @@ -0,0 +1,103 @@ +From ff486764bbab601177acad102febb1497262a88c Mon Sep 17 00:00:00 2001 +From: Zhiqi Song +Date: Sat, 8 Jan 2022 08:42:55 +0000 +Subject: [PATCH 16/18] dh: bugfix about dh compute key + +This patch includes: +1. Add an UADK_DO_SOFT tag when dh_do_crypto() failed. +2. Do some tiny cleanup. + +Signed-off-by: Zhiqi Song +--- + src/uadk_dh.c | 14 ++++---------- + 1 file changed, 4 insertions(+), 10 deletions(-) + +diff --git a/src/uadk_dh.c b/src/uadk_dh.c +index 9c2bfbf..989c9ec 100644 +--- a/src/uadk_dh.c ++++ b/src/uadk_dh.c +@@ -741,13 +741,12 @@ static int dh_soft_set_pkey(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key) + return UADK_E_SUCCESS; + } + +-/* Main Phase1: Generate public key */ + static int uadk_e_dh_generate_key(DH *dh) + { + struct uadk_dh_sess *dh_sess = NULL; +- int bits = DH_bits(dh); +- BIGNUM *pub_key = NULL; + BIGNUM *priv_key = NULL; ++ BIGNUM *pub_key = NULL; ++ int bits = DH_bits(dh); + const BIGNUM *p = NULL; + const BIGNUM *g = NULL; + const BIGNUM *q = NULL; +@@ -771,7 +770,6 @@ static int uadk_e_dh_generate_key(DH *dh) + goto exe_soft; + } + +- /* Fill request data */ + ret = dh_fill_genkey_req(g, p, priv_key, dh_sess); + if (!ret) { + fprintf(stderr, "failed to fill req\n"); +@@ -786,7 +784,6 @@ static int uadk_e_dh_generate_key(DH *dh) + goto free_sess; + } + +- /* Get the generated public key from uadk(->hardware) */ + ret = dh_get_pubkey(dh_sess, &pub_key); + if (!ret) { + fprintf(stderr, "failed to get public key\n"); +@@ -794,7 +791,6 @@ static int uadk_e_dh_generate_key(DH *dh) + goto free_sess; + } + +- /* Set the public key and private key */ + ret = dh_soft_set_pkey(dh, pub_key, priv_key); + + free_sess: +@@ -806,16 +802,15 @@ exe_soft: + return uadk_e_dh_soft_generate_key(dh); + } + +-/* Main Phase2: Compute shared key */ + static int uadk_e_dh_compute_key(unsigned char *key, const BIGNUM *pub_key, + DH *dh) + { + struct uadk_dh_sess *dh_sess = NULL; ++ BIGNUM *priv_key = NULL; + int bits = DH_bits(dh); + const BIGNUM *p = NULL; + const BIGNUM *g = NULL; + const BIGNUM *q = NULL; +- BIGNUM *priv_key = NULL; + int ret; + + if (!dh || !key || !pub_key || !DH_get0_priv_key(dh)) +@@ -845,6 +840,7 @@ static int uadk_e_dh_compute_key(unsigned char *key, const BIGNUM *pub_key, + ret = dh_do_crypto(dh_sess); + if (!ret) { + fprintf(stderr, "failed to generate DH shared key\n"); ++ ret = UADK_DO_SOFT; + goto free_sess; + } + +@@ -894,7 +890,6 @@ static void uadk_e_delete_dh_meth(void) + uadk_dh_method = NULL; + } + +- + int uadk_e_bind_dh(ENGINE *e) + { + pthread_spin_init(&g_dh_res.lock, PTHREAD_PROCESS_PRIVATE); +@@ -905,7 +900,6 @@ int uadk_e_bind_dh(ENGINE *e) + void uadk_e_destroy_dh(void) + { + pthread_spin_destroy(&g_dh_res.lock); +- + uadk_e_delete_dh_meth(); + uadk_e_wd_dh_uninit(); + } +-- +2.24.4 + diff --git a/0017-ecc-bugfix-about-ecc-general-init.patch b/0017-ecc-bugfix-about-ecc-general-init.patch new file mode 100644 index 0000000..c008750 --- /dev/null +++ b/0017-ecc-bugfix-about-ecc-general-init.patch @@ -0,0 +1,28 @@ +From 3ff18ada641a8ad6c54a6054b4b8323b0b4389a2 Mon Sep 17 00:00:00 2001 +From: Zhiqi Song +Date: Sat, 8 Jan 2022 09:03:00 +0000 +Subject: [PATCH 17/18] ecc: bugfix about ecc general init + +When calloc failed, it should return with error code directly. + +Signed-off-by: Zhiqi Song +--- + src/uadk_pkey.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/uadk_pkey.c b/src/uadk_pkey.c +index 7ca998b..14e0b8f 100644 +--- a/src/uadk_pkey.c ++++ b/src/uadk_pkey.c +@@ -189,7 +189,7 @@ static int uadk_e_wd_ecc_general_init(struct uacce_dev *dev, + + ctx_cfg = calloc(1, sizeof(struct wd_ctx_config)); + if (!ctx_cfg) +- ret = -ENOMEM; ++ return -ENOMEM; + + ecc_res.ctx_res = ctx_cfg; + ctx_cfg->ctx_num = CTX_NUM; +-- +2.24.4 + diff --git a/0018-digest-fix-codecheck-warning.patch b/0018-digest-fix-codecheck-warning.patch new file mode 100644 index 0000000..20a28e8 --- /dev/null +++ b/0018-digest-fix-codecheck-warning.patch @@ -0,0 +1,113 @@ +From e26726746340428c58ea1ce2460c0fb669bb7545 Mon Sep 17 00:00:00 2001 +From: Kai Ye +Date: Fri, 7 Jan 2022 09:56:54 +0800 +Subject: [PATCH 18/18] digest: fix codecheck warning + +fix a more than 50 lines function uadk_e_digest_init. + +Signed-off-by: Kai Ye +--- + src/uadk_digest.c | 57 ++++++++++++++++++++++++++--------------------- + 1 file changed, 31 insertions(+), 26 deletions(-) + +diff --git a/src/uadk_digest.c b/src/uadk_digest.c +index bf738af..5b843a0 100644 +--- a/src/uadk_digest.c ++++ b/src/uadk_digest.c +@@ -95,6 +95,13 @@ struct digest_priv_ctx { + bool copy; + }; + ++struct digest_info { ++ int nid; ++ enum wd_digest_mode mode; ++ enum wd_digest_type alg; ++ __u32 out_len; ++}; ++ + static int digest_nids[] = { + NID_md5, + NID_sm3, +@@ -116,6 +123,16 @@ static struct digest_threshold_table digest_pkt_threshold_table[] = { + { NID_sha512, SHA_SMALL_PACKET_OFFLOAD_THRESHOLD_DEFAULT }, + }; + ++static struct digest_info digest_info_table[] = { ++ {NID_md5, WD_DIGEST_NORMAL, WD_DIGEST_MD5, 16}, ++ {NID_sm3, WD_DIGEST_NORMAL, WD_DIGEST_SM3, 32}, ++ {NID_sha1, WD_DIGEST_NORMAL, WD_DIGEST_SHA1, 20}, ++ {NID_sha224, WD_DIGEST_NORMAL, WD_DIGEST_SHA224, 28}, ++ {NID_sha256, WD_DIGEST_NORMAL, WD_DIGEST_SHA256, 32}, ++ {NID_sha384, WD_DIGEST_NORMAL, WD_DIGEST_SHA384, 48}, ++ {NID_sha512, WD_DIGEST_NORMAL, WD_DIGEST_SHA512, 64}, ++}; ++ + static EVP_MD *uadk_md5; + static EVP_MD *uadk_sm3; + static EVP_MD *uadk_sha1; +@@ -451,8 +468,8 @@ static void digest_priv_ctx_setup(struct digest_priv_ctx *priv, + enum wd_digest_type alg, enum wd_digest_mode mode, + __u32 out_len) + { +- priv->setup.mode = alg; +- priv->setup.alg = mode; ++ priv->setup.alg = alg; ++ priv->setup.mode = mode; + priv->req.out_buf_bytes = out_len; + priv->req.out_bytes = out_len; + } +@@ -461,9 +478,10 @@ static int uadk_e_digest_init(EVP_MD_CTX *ctx) + { + struct digest_priv_ctx *priv = + (struct digest_priv_ctx *) EVP_MD_CTX_md_data(ctx); ++ int digest_counts = ARRAY_SIZE(digest_info_table); + int nid = EVP_MD_nid(EVP_MD_CTX_md(ctx)); + struct sched_params params = {0}; +- int ret; ++ int ret, i; + + /* Allocate a soft ctx for hardware engine */ + if (priv->soft_ctx == NULL) +@@ -478,29 +496,16 @@ static int uadk_e_digest_init(EVP_MD_CTX *ctx) + goto soft_init; + } + +- switch (nid) { +- case NID_md5: +- digest_priv_ctx_setup(priv, WD_DIGEST_NORMAL, WD_DIGEST_MD5, 16); +- break; +- case NID_sm3: +- digest_priv_ctx_setup(priv, WD_DIGEST_NORMAL, WD_DIGEST_SM3, 32); +- break; +- case NID_sha1: +- digest_priv_ctx_setup(priv, WD_DIGEST_NORMAL, WD_DIGEST_SHA1, 20); +- break; +- case NID_sha224: +- digest_priv_ctx_setup(priv, WD_DIGEST_NORMAL, WD_DIGEST_SHA224, 28); +- break; +- case NID_sha256: +- digest_priv_ctx_setup(priv, WD_DIGEST_NORMAL, WD_DIGEST_SHA256, 32); +- break; +- case NID_sha384: +- digest_priv_ctx_setup(priv, WD_DIGEST_NORMAL, WD_DIGEST_SHA384, 48); +- break; +- case NID_sha512: +- digest_priv_ctx_setup(priv, WD_DIGEST_NORMAL, WD_DIGEST_SHA512, 64); +- break; +- default: ++ for (i = 0; i < digest_counts; i++) { ++ if (nid == digest_info_table[i].nid) { ++ digest_priv_ctx_setup(priv, digest_info_table[i].alg, ++ digest_info_table[i].mode, digest_info_table[i].out_len); ++ break; ++ } ++ } ++ ++ if (i == digest_counts) { ++ fprintf(stderr, "failed to setup the private ctx.\n"); + return 0; + } + +-- +2.24.4 + diff --git a/uadk_engine-1.0.0.tar.gz b/uadk_engine-1.0.0.tar.gz index c1656bfed49c0a297229c80f5d436ac1e8d662de..63b7d49a9e2c0f8f13daed8bf67aa6a61eb80c4c 100644 GIT binary patch delta 402763 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