- Acc - mailweb.openeuler.org

[PATCH] digest: fix for digest soft init
by Qi Tao 05 Feb '25

05 Feb '25

From: Wenkai Lin <linwenkai6(a)hisilicon.com> Ensure that soft_ctx is initialized before invoking software calculation and reduces repeated judgments for digest soft init. Signed-off-by: Wenkai Lin <linwenkai6(a)hisilicon.com> --- src/uadk_digest.c | 83 ++++++++++++++++++++--------------------------- 1 file changed, 36 insertions(+), 47 deletions(-) diff --git a/src/uadk_digest.c b/src/uadk_digest.c index ed68ee2..f7882e4 100644 --- a/src/uadk_digest.c +++ b/src/uadk_digest.c @@ -189,70 +189,56 @@ static EVP_MD *uadk_sha512; static int uadk_e_digests_soft_md(struct digest_priv_ctx *priv) { - int app_datasize = 0; + int app_datasize; - if (priv->soft_md) + if (priv->soft_md && priv->soft_ctx) return 1; switch (priv->e_nid) { - case NID_sm3: - priv->soft_md = EVP_sm3(); - break; case NID_md5: priv->soft_md = EVP_md5(); + /* OpenSSL 3.0 has no app_datasize, need set manually + * check crypto/evp/legacy_md5.c: md5_md as example + */ + app_datasize = EVP_MD_meth_get_app_datasize(priv->soft_md); + if (!app_datasize) + app_datasize = sizeof(EVP_MD *) + sizeof(MD5_CTX); + break; + case NID_sm3: + priv->soft_md = EVP_sm3(); + app_datasize = EVP_MD_meth_get_app_datasize(priv->soft_md); + if (!app_datasize) + app_datasize = sizeof(EVP_MD *) + sizeof(SM3_CTX); break; case NID_sha1: priv->soft_md = EVP_sha1(); + app_datasize = EVP_MD_meth_get_app_datasize(priv->soft_md); + if (!app_datasize) + app_datasize = sizeof(EVP_MD *) + sizeof(SHA_CTX); break; case NID_sha224: - priv->soft_md = EVP_sha224(); - break; case NID_sha256: - priv->soft_md = EVP_sha256(); + if (priv->e_nid == NID_sha224) + priv->soft_md = EVP_sha224(); + else + priv->soft_md = EVP_sha256(); + app_datasize = EVP_MD_meth_get_app_datasize(priv->soft_md); + if (!app_datasize) + app_datasize = sizeof(EVP_MD *) + sizeof(SHA256_CTX); break; case NID_sha384: - priv->soft_md = EVP_sha384(); - break; case NID_sha512: - priv->soft_md = EVP_sha512(); + if (priv->e_nid == NID_sha384) + priv->soft_md = EVP_sha384(); + else + priv->soft_md = EVP_sha512(); + app_datasize = EVP_MD_meth_get_app_datasize(priv->soft_md); + if (!app_datasize) + app_datasize = sizeof(EVP_MD *) + sizeof(SHA512_CTX); break; default: - break; - } - - if (unlikely(priv->soft_md == NULL)) + fprintf(stderr, "digest nid %d is invalid.\n", priv->e_nid); return 0; - - app_datasize = EVP_MD_meth_get_app_datasize(priv->soft_md); - if (app_datasize == 0) { - /* OpenSSL 3.0 has no app_datasize, need set manually - * check crypto/evp/legacy_md5.c: md5_md as example - */ - switch (priv->e_nid) { - case NID_sm3: - app_datasize = sizeof(EVP_MD *) + sizeof(SM3_CTX); - break; - case NID_md5: - app_datasize = sizeof(EVP_MD *) + sizeof(MD5_CTX); - break; - case NID_sha1: - app_datasize = sizeof(EVP_MD *) + sizeof(SHA_CTX); - break; - case NID_sha224: - app_datasize = sizeof(EVP_MD *) + sizeof(SHA256_CTX); - break; - case NID_sha256: - app_datasize = sizeof(EVP_MD *) + sizeof(SHA256_CTX); - break; - case NID_sha384: - app_datasize = sizeof(EVP_MD *) + sizeof(SHA512_CTX); - break; - case NID_sha512: - app_datasize = sizeof(EVP_MD *) + sizeof(SHA512_CTX); - break; - default: - break; - } } if (priv->soft_ctx == NULL) { @@ -262,8 +248,10 @@ static int uadk_e_digests_soft_md(struct digest_priv_ctx *priv) return 0; ctx->md_data = OPENSSL_malloc(app_datasize); - if (ctx->md_data == NULL) + if (ctx->md_data == NULL) { + EVP_MD_CTX_free(ctx); return 0; + } priv->soft_ctx = ctx; priv->app_datasize = app_datasize; @@ -1015,6 +1003,7 @@ static int uadk_e_digest_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from) } if (t->soft_ctx) { + t->soft_md = NULL; t->soft_ctx = NULL; ret = digest_soft_init(t); if (!ret) -- 2.33.0

1 0

1.22 会议 follow up
by Zhangfei Gao 23 Jan '25

23 Jan '25

1. longfang 问的ctx的问题 adapter 方案 ctx 是在worker 内部的，每个worker有pool, ctx 等资源，完全解耦/不相关的比如sve 是支持异步的， hw+sve 异步是完全没问题的，代码 wd_cipher_init2_ for (i = 0; i < adapter->workers_nb; i++) { // 依次初始化各worker wd_alg_attrs_init(worker, &wd_cipher_init_attrs); switch (driver_type) { case UADK_ALG_SVE_INSTR: 分配sve的ctxs // sve, ce 其实可以合并 case UADK_ALG_HW: 分配hw的ctx wd_cipher_common_init -> wd_init_async_request_pool(&worker->pool, // 分配worker自己的pool } 另外，adapter方案的调度是选择worker, 是以worker为调度单元比如小包 sw，大包 hw，我们之前的调度，是期望每次过来能选择不同的ctx，实际中多线程需要加锁，性能跟不上，所以被废弃掉了。直接改成了alloc_sess的时候就绑定ctx，即每个线程就指定一个ctx 我理解这个其实就是ctx_allocator adapter 方案是把ctx 封装到worker内部了，即只管怎么选worker, 如果是硬件，还是按现在这样，绑定ctx的目前get_worker 选择worker 是放在算法层 2. To longfang 之前想到的问题, 在群里也提过前提是如果用户初始化的时候init(mix) 指定了选择异构调度， a, 这个代码不好改，比如已经上传了dpdk/ceph社区 b. 即使能改，init 很费时间，uadk_engine 基本是初始化的时候就init 了，即 init 一旦选择了异构调度方案就不会随便动了。 1）流模式下，不能运行一半发生切换，如何避免即调度器如何知道现在是不是流模式，算法层的信息如何传递给调度层。 ps. adapter 方案是在算法层做的，所以直接就能判断是否是流模式 2. 如何实现threshold, 很多场景就只是小包，无论怎么优化，就是指令集快调度器如何知道包的大小，需要传给调度层 ps. adapter 方案是在算法层，直接获取包的大小，这个数据结构各算法还不一样比如req->src_len vs req->in_bytes 3. 硬件出错怎么处理，fb 异步能否实现，fb方案其实我们没验证过。代码 cipher.c wd_do_cipher_async msg_id = wd_get_msg_from_pool(&wd_cipher_setting.pool, idx, (void **)&msg); //ctx_id a drv: temp_msg = wd_cipher_get_msg(qp->q_info.idx, tag); // ctx_id_a 如果fb-> drv_b temp_msg = wd_cipher_get_msg(ctx_id_b, tag); // 这里我理解拿不到msg, 可能有坑 ps：adapter方案的做法是设标记，上层retry进来选worker[1] 4. 多个加速器，如何选, hw/ce/sve 龙芳群里的回答：指定业务运行方式，配置设备驱动不懂目前的做法删掉ce的库，然后指定sve ps：adapter方案可以在uadk.conf 配置，通过命令行也可以即生成个配置文件 /tmp/pid.conf， setenv 5. 不同平台加速器不一样，920 hw, 920b hw/ce/sve, 920c? 一套模式/算法在一个平台上调好，其他平台是否适用龙芳群里的回答：自动适配，不区分硬件平台不同算法可能有区别比如rsa 就是硬件好 cipher/digest 就是小包指令集更好。 6. 未来如果有办法读取带宽，能否/怎么支持。这个龙芳群里回答过带宽查询功能具备以后，通过驱动的get_usage()直接读取，然后再新建一个调度器根据设备利用率实施调度 ps：adapter方案可能做法是get_worker里面加if/else 【腾讯文档】adapter方案 https://docs.qq.com/doc/DRUxFaVJDdHJFUWdM

2 3

2025/1/22 AccLIb SIG 双周例会 11:00 - 12:00
by openEuler conference 21 Jan '25

21 Jan '25

您好！ sig-AccLib 邀请您参加 2025-01-22 11:00 召开的Zoom会议会议主题：2025/1/22 AccLIb SIG 双周例会 11:00 - 12:00 会议内容：会议链接：linaro-org.zoom.us/j/91879279131 会议纪要：etherpad.openeuler.org/p/sig-AccLib-meet 会议链接：https://us06web.zoom.us/j/89685603297?pwd=oTjA3Nd99NBqEQbPVD7aYubeMganRz.1 会议纪要：https://etherpad.openeuler.org/p/sig-AccLib-meetings 更多资讯尽在：https://www.openeuler.org/zh/ Hello! sig-AccLib invites you to attend the Zoom conference will be held at 2025-01-22 11:00, The subject of the conference is 2025/1/22 AccLIb SIG 双周例会 11:00 - 12:00, Summary: 会议链接：linaro-org.zoom.us/j/91879279131 会议纪要：etherpad.openeuler.org/p/sig-AccLib-meet You can join the meeting at https://us06web.zoom.us/j/89685603297?pwd=oTjA3Nd99NBqEQbPVD7aYubeMganRz.1. Add topics at https://etherpad.openeuler.org/p/sig-AccLib-meetings. More information: https://www.openeuler.org/en/

1 0

[PATCH 00/11] uadk_prov: support new algs
by Qi Tao 20 Jan '25

20 Jan '25

*** BLURB HERE *** Chenghai Huang (4): uadk_provider/aead: cleanup functions in aead uadk_provider: fix the fork function of the digest uadk_provider: fix the ctx copy function of the digest uadk_provider: code cleanup for digest and aead Weili Qian (3): uadk_provider/ecdsa: support ecdsa signature and verify uadk_async: check type and ctx in task uadk_provider: use default provider to get random data Zhiqi Song (4): uadk_engine/rsa: fix memory leak of pkey meth uadk_engine: fix memory leak in fork scene uadk_provider: support X25519 uadk_engine/rsa: add rsa finish method src/Makefile.am | 2 +- src/uadk_async.c | 5 +- src/uadk_engine_init.c | 2 +- src/uadk_prov.h | 5 + src/uadk_prov_aead.c | 92 ++- src/uadk_prov_cipher.c | 3 + src/uadk_prov_der_writer.c | 112 +++- src/uadk_prov_der_writer.h | 2 + src/uadk_prov_digest.c | 235 ++++++-- src/uadk_prov_ecdsa.c | 1151 ++++++++++++++++++++++++++++++++++++ src/uadk_prov_ecx.c | 517 ++++++++++++++-- src/uadk_prov_init.c | 17 +- src/uadk_prov_pkey.c | 28 +- src/uadk_prov_pkey.h | 3 + src/uadk_rsa.c | 11 + 15 files changed, 2003 insertions(+), 182 deletions(-) create mode 100644 src/uadk_prov_ecdsa.c -- 2.33.0

1 0

[PATCH 01/11] uadk_provider/ecdsa: support ecdsa signature and verify
by Qi Tao 20 Jan '25

20 Jan '25

From: Weili Qian <qianweili(a)huawei.com> Support ecdsa signature and verify. openssl speed -provider uadk_provider -seconds 10 ecdsap521 Signed-off-by: Weili Qian <qianweili(a)huawei.com> --- src/Makefile.am | 2 +- src/uadk_prov.h | 2 + src/uadk_prov_der_writer.c | 112 +++- src/uadk_prov_der_writer.h | 2 + src/uadk_prov_ecdsa.c | 1151 ++++++++++++++++++++++++++++++++++++ src/uadk_prov_init.c | 2 + src/uadk_prov_pkey.c | 2 +- src/uadk_prov_pkey.h | 1 + 8 files changed, 1269 insertions(+), 5 deletions(-) create mode 100644 src/uadk_prov_ecdsa.c diff --git a/src/Makefile.am b/src/Makefile.am index c143edd..66650d2 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -75,7 +75,7 @@ uadk_provider_la_SOURCES=uadk_prov_init.c uadk_async.c uadk_utils.c \ uadk_prov_pkey.c uadk_prov_sm2.c \ uadk_prov_ffc.c uadk_prov_aead.c \ uadk_prov_ec_kmgmt.c uadk_prov_ecdh_exch.c \ - uadk_prov_ecx.c + uadk_prov_ecx.c uadk_prov_ecdsa.c uadk_provider_la_LDFLAGS=-module -version-number $(VERSION) uadk_provider_la_LIBADD=$(WD_LIBS) -lpthread diff --git a/src/uadk_prov.h b/src/uadk_prov.h index 84a3f01..2786e79 100644 --- a/src/uadk_prov.h +++ b/src/uadk_prov.h @@ -185,6 +185,8 @@ extern const OSSL_DISPATCH uadk_ecdh_keyexch_functions[FUNC_MAX_NUM]; extern const OSSL_DISPATCH uadk_x448_keymgmt_functions[FUNC_MAX_NUM]; extern const OSSL_DISPATCH uadk_x448_keyexch_functions[FUNC_MAX_NUM]; +extern const OSSL_DISPATCH uadk_ecdsa_signature_functions[FUNC_MAX_NUM]; + void uadk_prov_destroy_digest(void); void uadk_prov_destroy_cipher(void); void uadk_prov_destroy_aead(void); diff --git a/src/uadk_prov_der_writer.c b/src/uadk_prov_der_writer.c index e7e7e49..7e5ee31 100644 --- a/src/uadk_prov_der_writer.c +++ b/src/uadk_prov_der_writer.c @@ -12,10 +12,66 @@ #include <string.h> #include "uadk_prov_der_writer.h" -#define DER_OID_SZ_sm2_with_SM3 10 -#define PACKET_LEN_TAG 30 +#define PACKET_LEN_TAG 30 +#define DER_P_OBJECT 6 +#define DER_OID_SZ_sm2_with_SM3 10 +#define DER_OID_SZ_ecdsa_with_SHA1 9 +#define DER_OID_SZ_ecdsa_with_SHA224 10 +#define DER_OID_SZ_ecdsa_with_SHA256 10 +#define DER_OID_SZ_ecdsa_with_SHA384 10 +#define DER_OID_SZ_ecdsa_with_SHA512 10 +#define DER_OID_SZ_id_ecdsa_with_sha3_224 11 +#define DER_OID_SZ_id_ecdsa_with_sha3_256 11 +#define DER_OID_SZ_id_ecdsa_with_sha3_384 11 +#define DER_OID_SZ_id_ecdsa_with_sha3_512 11 + +static const unsigned char +ossl_der_oid_id_ecdsa_with_sha1[DER_OID_SZ_ecdsa_with_SHA1] = { + DER_P_OBJECT, 7, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x01 +}; + +static const unsigned char +ossl_der_oid_id_ecdsa_with_sha224[DER_OID_SZ_ecdsa_with_SHA224] = { + DER_P_OBJECT, 8, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x01 +}; + +static const unsigned char +ossl_der_oid_id_ecdsa_with_sha256[DER_OID_SZ_ecdsa_with_SHA256] = { + DER_P_OBJECT, 8, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02 +}; -unsigned char ossl_der_oid_sm2_with_SM3[DER_OID_SZ_sm2_with_SM3] = { +static const unsigned char +ossl_der_oid_id_ecdsa_with_sha384[DER_OID_SZ_ecdsa_with_SHA384] = { + DER_P_OBJECT, 8, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x03 +}; + +static const unsigned char +ossl_der_oid_id_ecdsa_with_sha512[DER_OID_SZ_ecdsa_with_SHA384] = { + DER_P_OBJECT, 8, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x04 +}; + +static const unsigned char +ossl_der_oid_id_ecdsa_with_sha3_224[DER_OID_SZ_id_ecdsa_with_sha3_224] = { + DER_P_OBJECT, 9, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x03, 0x09 +}; + +static const unsigned char +ossl_der_oid_id_ecdsa_with_sha3_256[DER_OID_SZ_id_ecdsa_with_sha3_256] = { + DER_P_OBJECT, 9, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x03, 0x0A +}; + +static const unsigned char +ossl_der_oid_id_ecdsa_with_sha3_384[DER_OID_SZ_id_ecdsa_with_sha3_384] = { + DER_P_OBJECT, 9, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x03, 0x0B +}; + +static const unsigned char +ossl_der_oid_id_ecdsa_with_sha3_512[DER_OID_SZ_id_ecdsa_with_sha3_512] = { + DER_P_OBJECT, 9, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x03, 0x0C +}; + +static const unsigned char +ossl_der_oid_sm2_with_SM3[DER_OID_SZ_sm2_with_SM3] = { 6, 8, 0x2A, 0x81, 0x1C, 0xCF, 0x55, 0x01, 0x83, 0x75 }; @@ -234,3 +290,53 @@ int ossl_DER_w_algorithmIdentifier_SM2_with_MD(WPACKET *pkt, int cont, && ossl_DER_w_precompiled(pkt, -1, precompiled, precompiled_sz) && ossl_DER_w_end_sequence(pkt, cont); } + +int ossl_DER_w_algorithmIdentifier_ECDSA_with_MD(WPACKET *pkt, int cont, + EC_KEY *ec, int mdnid) +{ + const unsigned char *precompiled = NULL; + size_t precompiled_sz = 0; + +#define MD_CASE(name) \ +do { \ + precompiled = ossl_der_oid_id_ecdsa_with_##name; \ + precompiled_sz = sizeof(ossl_der_oid_id_ecdsa_with_##name); \ +} while (0) + + switch (mdnid) { + case NID_sha1: + MD_CASE(sha1); + break; + case NID_sha224: + MD_CASE(sha224); + break; + case NID_sha256: + MD_CASE(sha256); + break; + case NID_sha384: + MD_CASE(sha384); + break; + case NID_sha512: + MD_CASE(sha512); + break; + case NID_sha3_224: + MD_CASE(sha3_224); + break; + case NID_sha3_256: + MD_CASE(sha3_256); + break; + case NID_sha3_384: + MD_CASE(sha3_384); + break; + case NID_sha3_512: + MD_CASE(sha3_512); + break; + default: + return 0; + } + + return ossl_DER_w_begin_sequence(pkt, cont) && + /* No parameters (yet?) */ + ossl_DER_w_precompiled(pkt, -1, precompiled, precompiled_sz) && + ossl_DER_w_end_sequence(pkt, cont); +} diff --git a/src/uadk_prov_der_writer.h b/src/uadk_prov_der_writer.h index 39308e0..4f0bab5 100644 --- a/src/uadk_prov_der_writer.h +++ b/src/uadk_prov_der_writer.h @@ -126,4 +126,6 @@ int ossl_DER_w_end_sequence(WPACKET *pkt, int tag); int ossl_DER_w_algorithmIdentifier_SM2_with_MD(WPACKET *pkt, int cont, EC_KEY *ec, int mdnid); +int ossl_DER_w_algorithmIdentifier_ECDSA_with_MD(WPACKET *pkt, int cont, + EC_KEY *ec, int mdnid); #endif diff --git a/src/uadk_prov_ecdsa.c b/src/uadk_prov_ecdsa.c new file mode 100644 index 0000000..774e8ee --- /dev/null +++ b/src/uadk_prov_ecdsa.c @@ -0,0 +1,1151 @@ +// SPDX-License-Identifier: Apache-2.0 +/* + * Copyright 2024 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 <openssl/err.h> +#include <openssl/evp.h> +#include <openssl/err.h> +#include <openssl/kdf.h> +#include "uadk_async.h" +#include "uadk_prov.h" +#include "uadk_prov_der_writer.h" +#include "uadk_prov_pkey.h" + +#define DIGEST_MAX_NAME_SIZE 50 +#define MAX_ALGORITHM_ID_SIZE 256 +#define MAX_PROPQUERY_SIZE 256 +#define UADK_SIGN_SIG_NULL 2 +#define DGST_SHIFT_NUM(n) (8 - ((n) & 0x7)) +#define UADK_PROV_ECDSA "ecdsa" + +/* + * What's passed as an actual key is defined by the KEYMGMT interface. + * We happen to know that our KEYMGMT simply passes DSA structures, so + * we use that here too. + */ +struct ecdsa_ctx { + OSSL_LIB_CTX *libctx; + char *propq; + EC_KEY *ec; + char mdname[DIGEST_MAX_NAME_SIZE]; + + /* + * Flag to determine if the hash function can be changed (true) or not (false) + * Because it's dangerous to change during a DigestSign or DigestVerify + * operation, this flag is cleared by their Init function, and set again + * by their Final function. + */ + bool flag_allow_md; + + /* The Algorithm Identifier of the combined signature algorithm */ + unsigned char aid_buf[MAX_ALGORITHM_ID_SIZE]; + unsigned char *aid; + size_t aid_len; + size_t mdsize; + int operation; + + EVP_MD *md; + EVP_MD_CTX *mdctx; + /* + * Internally used to cache the results of calling the EC group + * sign_setup() methods which are then passed to the sign operation. + * This is used by CAVS failure tests to terminate a loop if the signature + * is not valid. + * This could of also been done with a simple flag. + */ + BIGNUM *kinv; + BIGNUM *r; +}; + +struct ecdsa_opdata { + const unsigned char *tbs; + size_t tbslen; + ECDSA_SIG *sig; + EC_KEY *ec; +}; + +UADK_PKEY_SIGNATURE_DESCR(ecdsa, ECDSA); + +static void *uadk_signature_ecdsa_newctx(void *provctx, const char *propq) +{ + struct ecdsa_ctx *ctx; + + ctx = OPENSSL_zalloc(sizeof(*ctx)); + if (!ctx) + return NULL; + + ctx->flag_allow_md = true; + ctx->libctx = prov_libctx_of(provctx); + + if (propq) { + ctx->propq = OPENSSL_strdup(propq); + if (!ctx->propq) { + fprintf(stderr, "failed to strdup propq!\n"); + OPENSSL_free(ctx); + ctx = NULL; + } + } + + return ctx; +} + +static void uadk_signature_ecdsa_freectx(void *vctx) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + + if (!ctx) + return; + + OPENSSL_free(ctx->propq); + EVP_MD_CTX_free(ctx->mdctx); + EVP_MD_free(ctx->md); + EC_KEY_free(ctx->ec); + BN_clear_free(ctx->kinv); + BN_clear_free(ctx->r); + OPENSSL_clear_free(ctx, sizeof(*ctx)); +} + +static void *uadk_signature_ecdsa_dupctx(void *vctx) +{ + struct ecdsa_ctx *src_ctx = (struct ecdsa_ctx *)vctx; + struct ecdsa_ctx *dst_ctx; + + if (!src_ctx) { + fprintf(stderr, "invalid: src ctx is NULL to dupctx!\n"); + return NULL; + } + + /* Test KATS should not need to be supported */ + if (src_ctx->kinv || src_ctx->r) { + fprintf(stderr, "invalid: src ctx kinv or r is not NULL!\n"); + return NULL; + } + + dst_ctx = OPENSSL_zalloc(sizeof(*dst_ctx)); + if (!dst_ctx) + return NULL; + + *dst_ctx = *src_ctx; + dst_ctx->ec = NULL; + dst_ctx->md = NULL; + dst_ctx->mdctx = NULL; + dst_ctx->propq = NULL; + + if (src_ctx->ec && !EC_KEY_up_ref(src_ctx->ec)) + goto err; + dst_ctx->ec = src_ctx->ec; + + if (src_ctx->md && !EVP_MD_up_ref(src_ctx->md)) + goto err; + dst_ctx->md = src_ctx->md; + + if (src_ctx->mdctx) { + dst_ctx->mdctx = EVP_MD_CTX_new(); + if (!dst_ctx->mdctx || !EVP_MD_CTX_copy_ex(dst_ctx->mdctx, src_ctx->mdctx)) + goto err; + } + + if (src_ctx->propq) { + dst_ctx->propq = OPENSSL_strdup(src_ctx->propq); + if (!dst_ctx->propq) + goto err; + } + + return dst_ctx; + +err: + uadk_signature_ecdsa_freectx(dst_ctx); + return NULL; +} + +static void ecdsa_set_aid(struct ecdsa_ctx *ctx, int md_nid) +{ + WPACKET pkt; + + ctx->aid_len = 0; + if (WPACKET_init_der(&pkt, ctx->aid_buf, sizeof(ctx->aid_buf)) && + ossl_DER_w_algorithmIdentifier_ECDSA_with_MD(&pkt, -1, ctx->ec, md_nid) && + WPACKET_finish(&pkt)) { + WPACKET_get_total_written(&pkt, &ctx->aid_len); + ctx->aid = WPACKET_get_curr(&pkt); + } + WPACKET_cleanup(&pkt); +} + +/* + * Internal library code deals with NIDs, so we need to translate from a name. + * We do so using EVP_MD_is_a(), and therefore need a name to NID map. + */ +static int ecdsa_digest_md_to_nid(const EVP_MD *md, const OSSL_ITEM *it, size_t it_len) +{ + size_t i; + + if (!md) + return NID_undef; + + for (i = 0; i < it_len; i++) + if (EVP_MD_is_a(md, it[i].ptr)) + return (int)it[i].id; + + return NID_undef; +} + +/* + * Retrieve one of the FIPS approved hash algorithms by nid. + * See FIPS 180-4 "Secure Hash Standard" and FIPS 202 - SHA-3. + */ +static int ecdsa_digest_get_nid(const EVP_MD *md) +{ + static const OSSL_ITEM name_to_nid[] = { + {NID_sha1, OSSL_DIGEST_NAME_SHA1}, + {NID_sha224, OSSL_DIGEST_NAME_SHA2_224}, + {NID_sha256, OSSL_DIGEST_NAME_SHA2_256}, + {NID_sha384, OSSL_DIGEST_NAME_SHA2_384}, + {NID_sha512, OSSL_DIGEST_NAME_SHA2_512}, + {NID_sha512_224, OSSL_DIGEST_NAME_SHA2_512_224}, + {NID_sha512_256, OSSL_DIGEST_NAME_SHA2_512_256}, + {NID_sha3_224, OSSL_DIGEST_NAME_SHA3_224}, + {NID_sha3_256, OSSL_DIGEST_NAME_SHA3_256}, + {NID_sha3_384, OSSL_DIGEST_NAME_SHA3_384}, + {NID_sha3_512, OSSL_DIGEST_NAME_SHA3_512}, + }; + + return ecdsa_digest_md_to_nid(md, name_to_nid, OSSL_NELEM(name_to_nid)); +} + +static int ecdsa_digest_get_approved_nid(struct ecdsa_ctx *ctx, const EVP_MD *md) +{ + int mdnid = ecdsa_digest_get_nid(md); + +#ifndef OPENSSL_NO_FIPS_SECURITYCHECKS + int sha1_allowed = (ctx->operation != EVP_PKEY_OP_SIGN); + + if (uadk_prov_securitycheck_enabled(ctx->libctx)) { + if (mdnid == NID_undef || (mdnid == NID_sha1 && !sha1_allowed)) + mdnid = -1; /* disallowed by security checks */ + } +# endif /* OPENSSL_NO_FIPS_SECURITYCHECKS */ + + return mdnid; +} + +static int ecdsa_setup_md(struct ecdsa_ctx *ctx, const char *mdname, const char *mdprops) +{ + size_t mdname_len; + EVP_MD *md = NULL; + int md_nid; + + if (!mdname) + return UADK_P_SUCCESS; + + mdname_len = strlen(mdname); + if (mdname_len >= DIGEST_MAX_NAME_SIZE) { + fprintf(stderr, "invalid: %s size %zu exceeds name buffer length %d!\n", + mdname, mdname_len, DIGEST_MAX_NAME_SIZE); + return UADK_P_FAIL; + } + + if (!mdprops) + mdprops = ctx->propq; + + md = EVP_MD_fetch(ctx->libctx, mdname, mdprops); + if (!md) { + fprintf(stderr, "failed to fetch %s!\n", mdname); + return UADK_P_FAIL; + } + + md_nid = ecdsa_digest_get_approved_nid(ctx, md); + if (md_nid < 0) { + fprintf(stderr, "digest %s not allowed!\n", mdname); + goto err; + } + + if (!ctx->flag_allow_md) { + if (ctx->mdname[0] != '\0' && !EVP_MD_is_a(md, ctx->mdname)) { + fprintf(stderr, "digest %s is not same ctx digest %s!\n", + mdname, ctx->mdname); + goto err; + } + EVP_MD_free(md); + return UADK_P_SUCCESS; + } + + EVP_MD_CTX_free(ctx->mdctx); + ctx->mdctx = NULL; + + EVP_MD_free(ctx->md); + ctx->md = md; + ctx->mdsize = EVP_MD_get_size(ctx->md); + OPENSSL_strlcpy(ctx->mdname, mdname, DIGEST_MAX_NAME_SIZE); + + ecdsa_set_aid(ctx, md_nid); + + return UADK_P_SUCCESS; + +err: + EVP_MD_free(md); + return UADK_P_FAIL; +} + +static int ecdsa_signverify_init(void *vctx, void *ec, + const OSSL_PARAM params[], + int operation) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + const EC_KEY *eckey = (const EC_KEY *)ec; + int ret; + + if (!ctx || (!ec && !ctx->ec)) { + fprintf(stderr, "invalid: ctx or ec is NULL to digest init!\n"); + return UADK_P_FAIL; + } + + ret = uadk_signature_ecdsa_set_ctx_params(ctx, params); + if (!ret) + return ret; + + if (eckey) { + if (!uadk_prov_ecc_check_key(ctx->libctx, eckey, + operation == EVP_PKEY_OP_SIGN)) + return UADK_P_FAIL; + + if (!EC_KEY_up_ref(ec)) + return UADK_P_FAIL; + EC_KEY_free(ctx->ec); + ctx->ec = ec; + } + + ctx->operation = operation; + + return UADK_P_SUCCESS; +} + +static int uadk_signature_ecdsa_sign_init(void *vctx, void *ec, const OSSL_PARAM params[]) +{ + return ecdsa_signverify_init(vctx, ec, params, EVP_PKEY_OP_SIGN); +} + +static int uadk_signature_ecdsa_verify_init(void *vctx, void *ec, const OSSL_PARAM params[]) +{ + return ecdsa_signverify_init(vctx, ec, params, EVP_PKEY_OP_VERIFY); +} + +static int ecdsa_common_params_check(struct ecdsa_ctx *ctx, + struct ecdsa_opdata *opdata) +{ + const EC_GROUP *group; + int type; + + if (unlikely(!opdata->tbs || !opdata->tbslen)) { + fprintf(stderr, "invalid: tbs is NULL or tbslen %zu error!\n", opdata->tbslen); + return UADK_P_FAIL; + } + + if (ctx->mdsize && opdata->tbslen != ctx->mdsize) { + fprintf(stderr, "invalid: ctx->mdsize %zu not equal tbslen %zu!\n", + ctx->mdsize, opdata->tbslen); + return UADK_P_FAIL; + } + + group = EC_KEY_get0_group(ctx->ec); + if (unlikely(!group)) { + fprintf(stderr, "invalid: group is NULL!\n"); + return UADK_P_FAIL; + } + + /* Field GF(2m) is not supported by uadk */ + type = EC_METHOD_get_field_type(EC_GROUP_method_of(group)); + if (type != NID_X9_62_prime_field) { + fprintf(stderr, "invalid: uadk unsupport Field GF(2m)!\n"); + return UADK_P_FAIL; + } + + opdata->ec = ctx->ec; + + return uadk_prov_ecc_bit_check(group); +} + +static handle_t ecdsa_alloc_sess(EC_KEY *ec) +{ + int ret; + + ret = uadk_prov_signature_get_support_state(SIGNATURE_ECDSA); + if (!ret) { + fprintf(stderr, "failed to get hardware ecdsa support!\n"); + return ret; + } + + ret = uadk_prov_ecc_init(UADK_PROV_ECDSA); + if (!ret) { + fprintf(stderr, "failed to init ecdsa!\n"); + return ret; + } + + return uadk_prov_ecc_alloc_sess(ec, UADK_PROV_ECDSA); +} + +static void ecdsa_free_sess(handle_t sess) +{ + wd_ecc_free_sess(sess); +} + +static bool ecdsa_data_is_all_zero(struct wd_dtb *e) +{ + __u32 i; + + for (i = 0; i < e->dsize; i++) { + if (e->data[i]) + return false; + } + + return true; +} + +static int ecdsa_set_digest(struct ecdsa_opdata *opdata, struct wd_dtb *e) +{ + const EC_GROUP *group = EC_KEY_get0_group(opdata->ec); + size_t order_bits = EC_GROUP_order_bits(group); + size_t data_len = opdata->tbslen; + BIGNUM *m; + + if (BYTES_TO_BITS(data_len) > order_bits) { + m = BN_new(); + if (!m) { + fprintf(stderr, "failed to BN_new m!\n"); + return UADK_P_FAIL; + } + + /* + * Need to truncate digest if it is too long: first truncate + * whole bytes + */ + data_len = BITS_TO_BYTES(order_bits); + if (!BN_bin2bn(opdata->tbs, data_len, m)) { + fprintf(stderr, "failed to BN_bin2bn tbs!\n"); + BN_free(m); + return UADK_P_FAIL; + } + + /* + * If the length of digest is still longer than the length + * of the base point order, truncate remaining bits with a + * shift to that length. + */ + if (BYTES_TO_BITS(data_len) > order_bits && + !BN_rshift(m, m, DGST_SHIFT_NUM(order_bits))) { + fprintf(stderr, "failed to truncate input tbs!\n"); + BN_free(m); + return UADK_P_FAIL; + } + e->dsize = BN_bn2bin(m, (void *)e->data); + e->bsize = UADK_ECC_MAX_KEY_BYTES; + BN_free(m); + } else { + e->data = (char *)opdata->tbs; + e->dsize = data_len; + e->bsize = data_len; + } + + if (ecdsa_data_is_all_zero(e)) + return UADK_P_FAIL; + + return UADK_P_SUCCESS; +} + +static int ecdsa_sign_init_iot(handle_t sess, struct wd_ecc_req *req, + struct ecdsa_opdata *opdata) +{ + char buff[UADK_ECC_MAX_KEY_BYTES] = {0}; + struct wd_ecc_out *ecc_out; + struct wd_ecc_in *ecc_in; + struct wd_dtb e = {0}; + int ret; + + e.data = buff; + ret = ecdsa_set_digest(opdata, &e); + if (!ret) + return ret; + + ecc_in = wd_ecdsa_new_sign_in(sess, &e, NULL); + if (unlikely(!ecc_in)) { + fprintf(stderr, "failed to new ecdsa sign in!\n"); + return UADK_P_FAIL; + } + + ecc_out = wd_ecdsa_new_sign_out(sess); + if (unlikely(!ecc_out)) { + fprintf(stderr, "failed to new ecdsa sign out!\n"); + wd_ecc_del_in(sess, ecc_in); + return UADK_P_FAIL; + } + + uadk_prov_ecc_fill_req(req, WD_ECDSA_SIGN, ecc_in, ecc_out); + + return UADK_P_SUCCESS; +} + +static void ecdsa_uninit_req_iot(handle_t sess, struct wd_ecc_req *req) +{ + if (req->src) + wd_ecc_del_in(sess, req->src); + if (req->dst) + wd_ecc_del_out(sess, req->dst); +} + +static ECDSA_SIG *ecdsa_get_sign_data(struct wd_ecc_req *req) +{ + struct wd_dtb *r = NULL; + struct wd_dtb *s = NULL; + BIGNUM *br, *bs; + ECDSA_SIG *sig; + int ret; + + br = BN_new(); + bs = BN_new(); + if (unlikely(!br || !bs)) { + fprintf(stderr, "failed to new br or bs!\n"); + goto free_bn; + } + + wd_ecdsa_get_sign_out_params(req->dst, &r, &s); + if (unlikely(!r || !s)) { + fprintf(stderr, "failed to get r or s\n"); + goto free_bn; + } + + if (!BN_bin2bn((void *)r->data, r->dsize, br) || + !BN_bin2bn((void *)s->data, s->dsize, bs)) { + fprintf(stderr, "failed to BN_bin2bn r or s\n"); + goto free_bn; + } + + sig = ECDSA_SIG_new(); + if (unlikely(!sig)) { + fprintf(stderr, "failed to new sig!\n"); + goto free_bn; + } + + ret = ECDSA_SIG_set0(sig, br, bs); + if (unlikely(!ret)) { + fprintf(stderr, "failed to set br or bs to sig!\n"); + goto free_sig; + } + + return sig; +free_sig: + ECDSA_SIG_free(sig); +free_bn: + BN_clear_free(br); + BN_clear_free(bs); + return NULL; +} + +static int ecdsa_hw_sign(struct ecdsa_opdata *opdata) +{ + struct wd_ecc_req req = {0}; + handle_t sess; + int ret; + + sess = ecdsa_alloc_sess(opdata->ec); + if (unlikely(!sess)) { + fprintf(stderr, "failed to alloc ecdsa sess!\n"); + return UADK_P_FAIL; + } + + ret = ecdsa_sign_init_iot(sess, &req, opdata); + if (unlikely(!ret)) { + fprintf(stderr, "failed to ecdsa_sign_init_iot!\n"); + goto free_sess; + } + + ret = uadk_prov_ecc_set_private_key(sess, opdata->ec); + if (unlikely(!ret)) { + fprintf(stderr, "failed to set private key!\n"); + goto free_iot; + } + + ret = uadk_prov_ecc_crypto(sess, &req, (void *)sess); + if (unlikely(!ret)) { + fprintf(stderr, "failed to sign!\n"); + goto free_iot; + } + + opdata->sig = ecdsa_get_sign_data(&req); + if (!opdata->sig) + ret = UADK_P_FAIL; + +free_iot: + ecdsa_uninit_req_iot(sess, &req); +free_sess: + ecdsa_free_sess(sess); + return ret; +} + +static int ecdsa_sign_params_check(struct ecdsa_ctx *ctx, + struct ecdsa_opdata *opdata, + unsigned char *sig, size_t *siglen, + size_t sigsize) +{ + size_t ecsize; + + if (unlikely(!siglen)) { + fprintf(stderr, "invalid: siglen is NULL to sign!\n"); + return UADK_P_FAIL; + } + + if (unlikely(!ctx || !ctx->ec)) { + fprintf(stderr, "invalid: ctx or ec is NULL to sign!\n"); + return UADK_P_FAIL; + } + + ecsize = ECDSA_size(ctx->ec); + if (unlikely(!sig)) { + *siglen = ecsize; + return UADK_SIGN_SIG_NULL; + } + + if (unlikely(sigsize < ecsize)) { + fprintf(stderr, "invalid: sigsize %zu is less than ecsize %zu!\n", + sigsize, ecsize); + return UADK_P_FAIL; + } + + return ecdsa_common_params_check(ctx, opdata); +} + +static int uadk_signature_ecdsa_sign(void *vctx, unsigned char *sig, size_t *siglen, + size_t sigsize, const unsigned char *tbs, size_t tbslen) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + struct ecdsa_opdata opdata = {0}; + int ret; + + opdata.tbs = tbs; + opdata.tbslen = tbslen; + ret = ecdsa_sign_params_check(ctx, &opdata, sig, siglen, sigsize); + if (ret == UADK_SIGN_SIG_NULL) { + return UADK_P_SUCCESS; + } else if (unlikely(!ret)) { + fprintf(stderr, "failed to check params to sign!\n"); + goto err; + } + + ret = ecdsa_hw_sign(&opdata); + if (unlikely(!ret)) + goto err; + ret = i2d_ECDSA_SIG(opdata.sig, &sig); + /* ECDSA_SIG_free will free br and bs applied for in ecdsa_get_sign_data() */ + ECDSA_SIG_free(opdata.sig); + if (ret < 0) + goto err; + + *siglen = (size_t)ret; + + return UADK_P_SUCCESS; +err: + if (siglen) + *siglen = 0; + return UADK_P_FAIL; +} + +static int ecdsa_verify_init_iot(handle_t sess, struct wd_ecc_req *req, + struct ecdsa_opdata *opdata) +{ + char buf_r[UADK_ECC_MAX_KEY_BYTES] = {0}; + char buf_s[UADK_ECC_MAX_KEY_BYTES] = {0}; + char buf_e[UADK_ECC_MAX_KEY_BYTES] = {0}; + const BIGNUM *sig_r = NULL; + const BIGNUM *sig_s = NULL; + struct wd_ecc_in *ecc_in; + struct wd_dtb e = {0}; + struct wd_dtb r = {0}; + struct wd_dtb s = {0}; + int ret; + + e.data = buf_e; + ret = ecdsa_set_digest(opdata, &e); + if (!ret) + return ret; + + r.data = buf_r; + s.data = buf_s; + r.bsize = UADK_ECC_MAX_KEY_BYTES; + s.bsize = UADK_ECC_MAX_KEY_BYTES; + ECDSA_SIG_get0(opdata->sig, &sig_r, &sig_s); + r.dsize = BN_bn2bin(sig_r, (void *)r.data); + s.dsize = BN_bn2bin(sig_s, (void *)s.data); + ecc_in = wd_ecdsa_new_verf_in(sess, &e, &r, &s); + if (unlikely(!ecc_in)) { + fprintf(stderr, "failed to new ecdsa verf in\n"); + return UADK_P_FAIL; + } + + uadk_prov_ecc_fill_req(req, WD_ECDSA_VERIFY, ecc_in, NULL); + + return UADK_P_SUCCESS; +} + +static int ecdsa_hw_verify(struct ecdsa_opdata *opdata) +{ + struct wd_ecc_req req = {0}; + handle_t sess; + int ret; + + sess = ecdsa_alloc_sess(opdata->ec); + if (!sess) { + fprintf(stderr, "failed to alloc ecdsa sess!\n"); + return UADK_P_FAIL; + } + + ret = ecdsa_verify_init_iot(sess, &req, opdata); + if (!ret) + goto free_sess; + + ret = uadk_prov_ecc_set_public_key(sess, opdata->ec); + if (!ret) + goto free_iot; + + ret = uadk_prov_ecc_crypto(sess, &req, (void *)sess); + +free_iot: + ecdsa_uninit_req_iot(sess, &req); +free_sess: + ecdsa_free_sess(sess); + return ret; +} + +static int ecdsa_verify_params_check(struct ecdsa_ctx *ctx, struct ecdsa_opdata *opdata, + const unsigned char *sig, size_t siglen) +{ + if (!ctx || !ctx->ec) { + fprintf(stderr, "invalid: ctx or ec is NULL to verify!\n"); + return UADK_P_FAIL; + } + + if (!sig || !siglen) { + fprintf(stderr, "invalid: sig is NULL or siglen %zu error!\n", siglen); + return UADK_P_FAIL; + } + + return ecdsa_common_params_check(ctx, opdata); +} + +static ECDSA_SIG *ecdsa_create_sig(const unsigned char *sig, size_t siglen) +{ + const unsigned char *p = sig; + unsigned char *der = NULL; + ECDSA_SIG *s; + int derlen; + + s = ECDSA_SIG_new(); + if (!s) { + fprintf(stderr, "failed to new s to verify!\n"); + return NULL; + } + + if (!d2i_ECDSA_SIG(&s, &p, siglen)) { + fprintf(stderr, "failed to d2i_ECDSA_SIG: siglen = %zu!\n", + siglen); + goto err; + } + + /* Ensure signature uses DER and doesn't have trailing garbage */ + derlen = i2d_ECDSA_SIG(s, &der); + if (derlen != siglen || memcmp(sig, der, derlen) != 0) { + fprintf(stderr, "sig have trailing garbage, derlen %d!\n", derlen); + OPENSSL_free(der); + goto err; + } + + OPENSSL_free(der); + + return s; + +err: + ECDSA_SIG_free(s); + return NULL; +} + +static int uadk_signature_ecdsa_verify(void *vctx, const unsigned char *sig, + size_t siglen, const unsigned char *tbs, + size_t tbslen) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + struct ecdsa_opdata opdata = {0}; + int ret; + + opdata.tbs = tbs; + opdata.tbslen = tbslen; + ret = ecdsa_verify_params_check(ctx, &opdata, sig, siglen); + if (!ret) { + fprintf(stderr, "failed to check params to sign!\n"); + return UADK_P_FAIL; + } + + opdata.sig = ecdsa_create_sig(sig, siglen); + if (!opdata.sig) { + fprintf(stderr, "failed to create s to verify!\n"); + return UADK_P_FAIL; + } + + ret = ecdsa_hw_verify(&opdata); + + ECDSA_SIG_free(opdata.sig); + return ret; +} + +static int ecdsa_digest_singverify_init(void *vctx, const char *mdname, void *ec, + const OSSL_PARAM params[], int operation) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + int ret; + + ret = ecdsa_signverify_init(vctx, ec, params, operation); + if (!ret) + return ret; + + ret = ecdsa_setup_md(ctx, mdname, NULL); + if (!ret) + return ret; + + ctx->flag_allow_md = false; + if (!ctx->mdctx) { + ctx->mdctx = EVP_MD_CTX_new(); + if (!ctx->mdctx) + goto err; + } + + ret = EVP_DigestInit_ex2(ctx->mdctx, ctx->md, params); + if (!ret) + goto err; + + return UADK_P_SUCCESS; + +err: + EVP_MD_CTX_free(ctx->mdctx); + ctx->mdctx = NULL; + return UADK_P_FAIL; +} + +static int uadk_signature_ecdsa_digest_sign_init(void *vctx, const char *mdname, + void *ec, const OSSL_PARAM params[]) +{ + return ecdsa_digest_singverify_init(vctx, mdname, ec, params, EVP_PKEY_OP_SIGN); +} + +static int ecdsa_digest_signverify_update(void *vctx, const unsigned char *data, + size_t datalen) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + + if (!ctx || !ctx->mdctx) { + fprintf(stderr, "invalid: ctx or mdctx is NULL to digest update!\n"); + return UADK_P_FAIL; + } + + return EVP_DigestUpdate(ctx->mdctx, data, datalen); +} + +static int uadk_signature_ecdsa_digest_sign_update(void *vctx, const unsigned char *data, + size_t datalen) +{ + return ecdsa_digest_signverify_update(vctx, data, datalen); +} + +static int uadk_signature_ecdsa_digest_sign_final(void *vctx, unsigned char *sig, + size_t *siglen, size_t sigsize) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + unsigned char digest[EVP_MAX_MD_SIZE]; + unsigned int dlen = 0; + + if (!ctx || !ctx->mdctx) { + fprintf(stderr, "invalid: ctx or mdctx is NULL to sign digest final!\n"); + return UADK_P_FAIL; + } + + /* + * If sig is NULL then we're just finding out the sig size. Other fields + * are ignored. Defer to uadk_signature_ecdsa_sign. + */ + if (sig && !EVP_DigestFinal_ex(ctx->mdctx, digest, &dlen)) + return UADK_P_FAIL; + + ctx->flag_allow_md = true; + + return uadk_signature_ecdsa_sign(vctx, sig, siglen, sigsize, digest, (size_t)dlen); +} + +static int uadk_signature_ecdsa_digest_verify_init(void *vctx, const char *mdname, + void *ec, const OSSL_PARAM params[]) +{ + return ecdsa_digest_singverify_init(vctx, mdname, ec, params, EVP_PKEY_OP_VERIFY); +} + +static int uadk_signature_ecdsa_digest_verify_update(void *vctx, const unsigned char *data, + size_t datalen) +{ + return ecdsa_digest_signverify_update(vctx, data, datalen); +} + +static int uadk_signature_ecdsa_digest_verify_final(void *vctx, const unsigned char *sig, + size_t siglen) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + unsigned char digest[EVP_MAX_MD_SIZE]; + unsigned int dlen = 0; + + if (!ctx || !ctx->mdctx) { + fprintf(stderr, "invalid: ctx or mdctx is NULL to verify digest final!\n"); + return UADK_P_FAIL; + } + + if (!EVP_DigestFinal_ex(ctx->mdctx, digest, &dlen)) + return UADK_P_FAIL; + + ctx->flag_allow_md = true; + + return uadk_signature_ecdsa_verify(vctx, sig, siglen, digest, (size_t)dlen); +} + +static int ecdsa_get_ctx_aid(struct ecdsa_ctx *ctx, OSSL_PARAM *params) +{ + OSSL_PARAM *p; + + p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_ALGORITHM_ID); + if (!p) + return UADK_P_SUCCESS; + + return OSSL_PARAM_set_octet_string(p, ctx->aid, ctx->aid_len); +} + +static int ecdsa_get_ctx_digest_size(struct ecdsa_ctx *ctx, OSSL_PARAM *params) +{ + OSSL_PARAM *p; + + p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_DIGEST_SIZE); + if (!p) + return UADK_P_SUCCESS; + + return OSSL_PARAM_set_size_t(p, ctx->mdsize); +} + +static int ecdsa_get_ctx_digest(struct ecdsa_ctx *ctx, OSSL_PARAM *params) +{ + const char *mdname; + OSSL_PARAM *p; + + p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_DIGEST); + if (!p) + return UADK_P_SUCCESS; + + mdname = ctx->md ? EVP_MD_get0_name(ctx->md) : ctx->mdname; + + return OSSL_PARAM_set_utf8_string(p, mdname); +} + +static int uadk_signature_ecdsa_get_ctx_params(void *vctx, OSSL_PARAM *params) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + int ret; + + if (!ctx) { + fprintf(stderr, "invalid: ctx is NULL to get_ctx_params!\n"); + return UADK_P_FAIL; + } + + if (!params) + return UADK_P_SUCCESS; + + ret = ecdsa_get_ctx_digest(ctx, params); + if (!ret) + return ret; + + ret = ecdsa_get_ctx_digest_size(ctx, params); + if (!ret) + return ret; + + return ecdsa_get_ctx_aid(ctx, params); +} + +static const OSSL_PARAM known_gettable_ctx_params[] = { + OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0), + OSSL_PARAM_size_t(OSSL_SIGNATURE_PARAM_DIGEST_SIZE, NULL), + OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0), + OSSL_PARAM_END +}; + +static const OSSL_PARAM * +uadk_signature_ecdsa_gettable_ctx_params(ossl_unused void *vctx, + ossl_unused void *provctx) +{ + return known_gettable_ctx_params; +} + +static int ecdsa_set_ctx_digest(struct ecdsa_ctx *ctx, const OSSL_PARAM params[]) +{ + char mdname[DIGEST_MAX_NAME_SIZE] = {0}; + char mdprops[MAX_PROPQUERY_SIZE] = {0}; + const OSSL_PARAM *p_digest, *propsp; + char *pmdprops = mdprops; + char *pmdname = mdname; + int ret; + + p_digest = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST); + if (!p_digest) + return UADK_P_SUCCESS; + + ret = OSSL_PARAM_get_utf8_string(p_digest, &pmdname, DIGEST_MAX_NAME_SIZE); + if (!ret) + return UADK_P_FAIL; + + propsp = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_PROPERTIES); + if (propsp) { + ret = OSSL_PARAM_get_utf8_string(propsp, &pmdprops, MAX_PROPQUERY_SIZE); + if (!ret) + return UADK_P_FAIL; + } + + return ecdsa_setup_md(ctx, mdname, mdprops); +} + +static int ecdsa_set_ctx_digest_size(struct ecdsa_ctx *ctx, const OSSL_PARAM params[]) +{ + const OSSL_PARAM *p; + size_t mdsize = 0; + int ret; + + p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST_SIZE); + if (!p) + return UADK_P_SUCCESS; + + ret = OSSL_PARAM_get_size_t(p, &mdsize); + if (!ret) + return UADK_P_FAIL; + + if (!ctx->flag_allow_md && mdsize != ctx->mdsize) + return UADK_P_FAIL; + + ctx->mdsize = mdsize; + + return UADK_P_SUCCESS; +} + +static int uadk_signature_ecdsa_set_ctx_params(void *vctx, const OSSL_PARAM params[]) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + int ret; + + if (!ctx) { + fprintf(stderr, "invalid: ctx is NULL to set_ctx_params!\n"); + return UADK_P_FAIL; + } + + if (!params) + return UADK_P_SUCCESS; + + ret = ecdsa_set_ctx_digest(ctx, params); + if (!ret) + return ret; + + return ecdsa_set_ctx_digest_size(ctx, params); +} + +static const OSSL_PARAM settable_ctx_params[] = { + OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0), + OSSL_PARAM_size_t(OSSL_SIGNATURE_PARAM_DIGEST_SIZE, NULL), + OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PROPERTIES, NULL, 0), + OSSL_PARAM_uint(OSSL_SIGNATURE_PARAM_KAT, NULL), + OSSL_PARAM_END +}; + +static const OSSL_PARAM settable_ctx_params_no_digest[] = { + OSSL_PARAM_uint(OSSL_SIGNATURE_PARAM_KAT, NULL), + OSSL_PARAM_END +}; + +static const OSSL_PARAM * +uadk_signature_ecdsa_settable_ctx_params(void *vctx, ossl_unused void *provctx) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + + if (ctx && !ctx->flag_allow_md) + return settable_ctx_params_no_digest; + + return settable_ctx_params; +} + +static int uadk_signature_ecdsa_get_ctx_md_params(void *vctx, OSSL_PARAM *params) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + + if (!ctx || !ctx->mdctx) { + fprintf(stderr, "invalid: ctx or md ctx is NULL to get_ctx_md_params!\n"); + return UADK_P_FAIL; + } + + return EVP_MD_CTX_get_params(ctx->mdctx, params); +} + +static const OSSL_PARAM *uadk_signature_ecdsa_gettable_ctx_md_params(void *vctx) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + + if (!ctx || !ctx->md) { + fprintf(stderr, "invalid: ctx or md is NULL to gettable_ctx_md_params!\n"); + return NULL; + } + + return EVP_MD_gettable_ctx_params(ctx->md); +} + +static int uadk_signature_ecdsa_set_ctx_md_params(void *vctx, const OSSL_PARAM params[]) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + + if (!ctx || !ctx->mdctx) { + fprintf(stderr, "invalid: ctx or md ctx is NULL to set_ctx_md_params!\n"); + return UADK_P_FAIL; + } + + return EVP_MD_CTX_set_params(ctx->mdctx, params); +} + +static const OSSL_PARAM *uadk_signature_ecdsa_settable_ctx_md_params(void *vctx) +{ + struct ecdsa_ctx *ctx = (struct ecdsa_ctx *)vctx; + + if (!ctx || !ctx->md) { + fprintf(stderr, "invalid: ctx or md is NULL to settable_ctx_md_params!\n"); + return NULL; + } + + return EVP_MD_settable_ctx_params(ctx->md); +} + +static int uadk_signature_ecdsa_verify_recover_init(void *vctx, void *vecdsa, + const OSSL_PARAM params[]) +{ + return UADK_P_SUCCESS; +} + +static int uadk_signature_ecdsa_verify_recover(void *vctx, unsigned char *rout, + size_t *routlen, size_t routsize, + const unsigned char *sig, size_t siglen) +{ + return UADK_P_SUCCESS; +} diff --git a/src/uadk_prov_init.c b/src/uadk_prov_init.c index 9a2baeb..52d0b90 100644 --- a/src/uadk_prov_init.c +++ b/src/uadk_prov_init.c @@ -165,6 +165,8 @@ static const OSSL_ALGORITHM uadk_prov_signature[] = { uadk_rsa_signature_functions, "uadk_provider rsa_signature" }, { "SM2", UADK_DEFAULT_PROPERTIES, uadk_sm2_signature_functions, "uadk_provider sm2_signature" }, + { "ECDSA", UADK_DEFAULT_PROPERTIES, + uadk_ecdsa_signature_functions, "uadk_provider ecdsa_signature" }, { NULL, NULL, NULL } }; diff --git a/src/uadk_prov_pkey.c b/src/uadk_prov_pkey.c index f654dd6..ebf90e4 100644 --- a/src/uadk_prov_pkey.c +++ b/src/uadk_prov_pkey.c @@ -680,7 +680,7 @@ void uadk_prov_keymgmt_alg(void) void uadk_prov_signature_alg(void) { - static const char * const signature_alg[] = {"sm2"}; + static const char * const signature_alg[] = {"sm2", "ecdsa"}; __u32 i, size; bool sp; diff --git a/src/uadk_prov_pkey.h b/src/uadk_prov_pkey.h index f40313d..38a67ac 100644 --- a/src/uadk_prov_pkey.h +++ b/src/uadk_prov_pkey.h @@ -75,6 +75,7 @@ enum { enum { SIGNATURE_SM2 = 0x0, + SIGNATURE_ECDSA = 0x1, SIGNATURE_MAX = 0x3 }; -- 2.33.0

1 10

[PATCH 01/46] vfio: Introduce base object for VFIOContainer and targeted interface
by Zhou Wang 11 Jan '25

11 Jan '25

From: Zhenzhong Duan <zhenzhong.duan(a)intel.com> Introduce a dumb VFIOContainerBase object and its targeted interface. This is willingly not a QOM object because we don't want it to be visible from the user interface. The VFIOContainerBase will be smoothly populated in subsequent patches as well as interfaces. No functional change intended. Signed-off-by: Eric Auger <eric.auger(a)redhat.com> Signed-off-by: Yi Liu <yi.l.liu(a)intel.com> Signed-off-by: Yi Sun <yi.y.sun(a)linux.intel.com> Signed-off-by: Zhenzhong Duan <zhenzhong.duan(a)intel.com> Reviewed-by: Cédric Le Goater <clg(a)redhat.com> Signed-off-by: Cédric Le Goater <clg(a)redhat.com> Signed-off-by: Zhou Wang <wangzhou1(a)hisilicon.com> --- include/hw/vfio/vfio-common.h | 8 ++--- include/hw/vfio/vfio-container-base.h | 50 +++++++++++++++++++++++++++ 2 files changed, 52 insertions(+), 6 deletions(-) create mode 100644 include/hw/vfio/vfio-container-base.h diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h index fd9828d50b..c89b5886f2 100644 --- a/include/hw/vfio/vfio-common.h +++ b/include/hw/vfio/vfio-common.h @@ -30,6 +30,7 @@ #include <linux/vfio.h> #endif #include "sysemu/sysemu.h" +#include "hw/vfio/vfio-container-base.h" #define VFIO_MSG_PREFIX "vfio %s: " @@ -89,6 +90,7 @@ typedef struct VFIODMARange { } VFIODMARange; typedef struct VFIOContainer { + VFIOContainerBase bcontainer; VFIOAddressSpace *space; int fd; /* /dev/vfio/vfio, empowered by the attached groups */ MemoryListener listener; @@ -211,12 +213,6 @@ typedef struct VFIODisplay { } dmabuf; } VFIODisplay; -typedef struct { - unsigned long *bitmap; - hwaddr size; - hwaddr pages; -} VFIOBitmap; - VFIOAddressSpace *vfio_get_address_space(AddressSpace *as); void vfio_put_address_space(VFIOAddressSpace *space); bool vfio_devices_all_running_and_saving(VFIOContainer *container); diff --git a/include/hw/vfio/vfio-container-base.h b/include/hw/vfio/vfio-container-base.h new file mode 100644 index 0000000000..1d6daaea5d --- /dev/null +++ b/include/hw/vfio/vfio-container-base.h @@ -0,0 +1,50 @@ +/* + * VFIO BASE CONTAINER + * + * Copyright (C) 2023 Intel Corporation. + * Copyright Red Hat, Inc. 2023 + * + * Authors: Yi Liu <yi.l.liu(a)intel.com> + * Eric Auger <eric.auger(a)redhat.com> + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ + +#ifndef HW_VFIO_VFIO_CONTAINER_BASE_H +#define HW_VFIO_VFIO_CONTAINER_BASE_H + +#include "exec/memory.h" + +typedef struct VFIODevice VFIODevice; +typedef struct VFIOIOMMUOps VFIOIOMMUOps; + +typedef struct { + unsigned long *bitmap; + hwaddr size; + hwaddr pages; +} VFIOBitmap; + +/* + * This is the base object for vfio container backends + */ +typedef struct VFIOContainerBase { + const VFIOIOMMUOps *ops; +} VFIOContainerBase; + +struct VFIOIOMMUOps { + /* basic feature */ + int (*dma_map)(VFIOContainerBase *bcontainer, + hwaddr iova, ram_addr_t size, + void *vaddr, bool readonly); + int (*dma_unmap)(VFIOContainerBase *bcontainer, + hwaddr iova, ram_addr_t size, + IOMMUTLBEntry *iotlb); + int (*attach_device)(const char *name, VFIODevice *vbasedev, + AddressSpace *as, Error **errp); + void (*detach_device)(VFIODevice *vbasedev); + /* migration feature */ + int (*set_dirty_page_tracking)(VFIOContainerBase *bcontainer, bool start); + int (*query_dirty_bitmap)(VFIOContainerBase *bcontainer, VFIOBitmap *vbmap, + hwaddr iova, hwaddr size); +}; +#endif /* HW_VFIO_VFIO_CONTAINER_BASE_H */ -- 2.33.0

1 45

[PATCH 0/9] uadk: bigfix
by Qi Tao 09 Jan '25

09 Jan '25

*** BLURB HERE *** Junchong Pan (1): uadk_tool: print help when empty parameters Qi Tao (1): uadk: support appending tag for digest stream model Wenkai Lin (7): uadk: fix for aead authsize check uadk: fix for aead auth key length uadk: fix for digest auth key length uadk: fix for ce key_len check uadk: fix for key address check uadk: fix for v1 aead authsize check uadk: fix for aead cbc mode authsize drv/hisi_sec.c | 40 +++++++++++++------------- drv/isa_ce_sm3.c | 5 ---- uadk_tool/benchmark/uadk_benchmark.c | 6 ++-- uadk_tool/benchmark/uadk_benchmark.h | 1 + uadk_tool/uadk_tool.c | 10 ++++++- v1/drv/hisi_sec_udrv.c | 18 ++---------- v1/wd_aead.c | 41 ++++++++++++++++++++------- v1/wd_cipher.c | 2 +- v1/wd_digest.c | 42 ++++++++++++++++++++++------ v1/wd_digest.h | 19 +++++++++++-- wd_aead.c | 11 +++----- wd_digest.c | 12 ++++---- 12 files changed, 127 insertions(+), 80 deletions(-) -- 2.33.0

1 2

[PATCH] uadk: support appending tag for digest stream model
by Qi Tao 09 Jan '25

09 Jan '25

In common digest stream mode, io_bytes and iv_bytes need to be set to 0 when the final bd is calculated. Therefore, in the appending tag scenario, need to restore the values of io_bytes and iv_bytes to the values before they are set to 0. Therefore, the hardware can compute the overall hash value of the appending packet and the previously calculated packet, and reduce the repeated calculation. Signed-off-by: Qi Tao <taoqi10(a)huawei.com> --- v1/wd_digest.c | 29 +++++++++++++++++++++++++++-- v1/wd_digest.h | 19 +++++++++++++++++-- 2 files changed, 44 insertions(+), 4 deletions(-) diff --git a/v1/wd_digest.c b/v1/wd_digest.c index c02b3b30..1b665a34 100644 --- a/v1/wd_digest.c +++ b/v1/wd_digest.c @@ -445,7 +445,7 @@ static int param_check(struct wcrypto_digest_ctx *d_ctx, return -WD_EINVAL; } - if (d_opdata[i]->has_next) + if (d_opdata[i]->has_next == WCRYPTO_DIGEST_DOING) ret = stream_mode_param_check(d_ctx, d_opdata[i], num); else ret = block_mode_param_check(d_ctx, d_opdata[i]); @@ -466,6 +466,24 @@ static int param_check(struct wcrypto_digest_ctx *d_ctx, return WD_SUCCESS; } +static int append_tag_restore_status(struct wcrypto_digest_ctx *ctxt, + struct wcrypto_digest_op_data **opdata, + struct wcrypto_digest_msg **req, __u32 ind) +{ + if (opdata[ind]->has_next == WCRYPTO_DIGEST_STREAM_END) + opdata[ind]->has_next = WCRYPTO_DIGEST_END; + else if (opdata[ind]->has_next == WCRYPTO_DIGEST_STREAM_DOING) + opdata[ind]->has_next = WCRYPTO_DIGEST_DOING; + else + return -WD_EINVAL; + + ctxt->io_bytes = *(__u64 *)opdata[ind]->priv; + req[ind]->iv_bytes = opdata[ind]->out_bytes; + opdata[ind]->priv = NULL; + + return WD_SUCCESS; +} + int wcrypto_burst_digest(void *d_ctx, struct wcrypto_digest_op_data **opdata, void **tag, __u32 num) { @@ -483,8 +501,15 @@ int wcrypto_burst_digest(void *d_ctx, struct wcrypto_digest_op_data **opdata, return ret; for (i = 0; i < num; i++) { - cookies[i]->tag.priv = opdata[i]->priv; req[i] = &cookies[i]->msg; + + if (opdata[i]->has_next > WCRYPTO_DIGEST_DOING) { + ret = append_tag_restore_status(ctxt, opdata, req, i); + if (unlikely(ret)) + goto fail_with_cookies; + } + + cookies[i]->tag.priv = opdata[i]->priv; if (tag) cookies[i]->tag.wcrypto_tag.tag = tag[i]; } diff --git a/v1/wd_digest.h b/v1/wd_digest.h index f0bdf4da..07901e3f 100644 --- a/v1/wd_digest.h +++ b/v1/wd_digest.h @@ -76,6 +76,21 @@ enum wcrypto_digest_mode { WCRYPTO_DIGEST_HMAC, }; +/** + * wcrypto_digest_msg_state - Message state of digest + * @WCRYPTO_DIGEST_END: Final message or single block message + * @WCRYPTO_DIGEST_DOING: First message or middle message + * @WCRYPTO_DIGEST_STREAM_END: Final message for appending tag mode + * @WCRYPTO_DIGEST_STREAM_DOING: Middle message for appending tag mode + */ +enum wcrypto_digest_msg_state { + WCRYPTO_DIGEST_END = 0x0, + WCRYPTO_DIGEST_DOING, + WCRYPTO_DIGEST_STREAM_END, + WCRYPTO_DIGEST_STREAM_DOING, + WCRYPTO_DIGEST_MSG_STATE_MAX, +}; + /** * different contexts for different users/threads * @cb: call back functions of user @@ -100,7 +115,7 @@ struct wcrypto_digest_ctx_setup { * @out_bytes:output data size * @priv:reserved data field segment * @status:I/O operation return status - * @has_next: is there next data block + * @has_next: message state, all types are defined in enum wcrypto_digest_msg_state * @iv: initialization verctor data address * @iv_bytes:initialization verctor data size */ @@ -111,7 +126,7 @@ struct wcrypto_digest_op_data { __u32 out_bytes; void *priv; int status; - bool has_next; + int has_next; void *iv; __u32 iv_bytes; }; -- 2.33.0

1 0

2025/1/8 AccLIb SIG 双周例会 11:00 - 12:00
by openEuler conference 07 Jan '25

07 Jan '25

您好！ sig-AccLib 邀请您参加 2025-01-08 11:00 召开的Zoom会议会议主题：2025/1/8 AccLIb SIG 双周例会 11:00 - 12:00 会议内容：会议链接：linaro-org.zoom.us/j/91879279131 会议纪要：etherpad.openeuler.org/p/sig-AccLib-meet 会议链接：https://us06web.zoom.us/j/83172200317?pwd=nrqT1amyXEaZrWuXb30bWbaJMV2XNv.1 会议纪要：https://etherpad.openeuler.org/p/sig-AccLib-meetings 更多资讯尽在：https://www.openeuler.org/zh/ Hello! sig-AccLib invites you to attend the Zoom conference will be held at 2025-01-08 11:00, The subject of the conference is 2025/1/8 AccLIb SIG 双周例会 11:00 - 12:00, Summary: 会议链接：linaro-org.zoom.us/j/91879279131 会议纪要：etherpad.openeuler.org/p/sig-AccLib-meet You can join the meeting at https://us06web.zoom.us/j/83172200317?pwd=nrqT1amyXEaZrWuXb30bWbaJMV2XNv.1. Add topics at https://etherpad.openeuler.org/p/sig-AccLib-meetings. More information: https://www.openeuler.org/en/

1 0

[PATCH] uadk/v1 - add fair lock to replace CAS
by Qi Tao 27 Dec '24

27 Dec '24

From: Yang Shen <shenyang39(a)huawei.com> In Warpdrive sync mode, the driver writes a tag in the SQE to mark the owner and checks this tag when a request is completed. To ensure it functions properly, we added a lock to protect the receiving process. However, pthread_spin_lock is a CAS lock, which results in a situation where a thread can repeatedly acquire the lock while the completed request does not belong to it until timeout. Therefore, we introduce a fair lock to replace pthread_spin_lock. This way, every thread can acquire the lock in a round-robin manner. Signed-off-by: Yang Shen <shenyang39(a)huawei.com> --- v1/drv/hisi_qm_udrv.c | 39 ++++++++++++--------------------------- v1/drv/hisi_qm_udrv.h | 4 ++-- v1/wd_util.c | 31 +++++++++++++++++++++++++++++++ v1/wd_util.h | 8 ++++++++ 4 files changed, 53 insertions(+), 29 deletions(-) diff --git a/v1/drv/hisi_qm_udrv.c b/v1/drv/hisi_qm_udrv.c index c711a497..7b0183bc 100644 --- a/v1/drv/hisi_qm_udrv.c +++ b/v1/drv/hisi_qm_udrv.c @@ -535,24 +535,11 @@ static int qm_set_queue_info(struct wd_queue *q) goto err_with_regions; } - ret = pthread_spin_init(&info->sd_lock, PTHREAD_PROCESS_PRIVATE); - if (ret) { - WD_ERR("failed to init qinfo sd_lock!\n"); - goto free_cache; - } - - ret = pthread_spin_init(&info->rc_lock, PTHREAD_PROCESS_PRIVATE); - if (ret) { - WD_ERR("failed to init qinfo rc_lock!\n"); - goto uninit_lock; - } + wd_fair_init(&info->sd_lock); + wd_fair_init(&info->rc_lock); return 0; -uninit_lock: - pthread_spin_destroy(&info->sd_lock); -free_cache: - free(info->req_cache); err_with_regions: qm_unset_queue_regions(q); return ret; @@ -593,8 +580,6 @@ void qm_uninit_queue(struct wd_queue *q) struct q_info *qinfo = q->qinfo; struct qm_queue_info *info = qinfo->priv; - pthread_spin_destroy(&info->rc_lock); - pthread_spin_destroy(&info->sd_lock); free(info->req_cache); qm_unset_queue_regions(q); free(qinfo->priv); @@ -624,10 +609,10 @@ int qm_send(struct wd_queue *q, void **req, __u32 num) int ret; __u32 i; - pthread_spin_lock(&info->sd_lock); + wd_fair_lock(&info->sd_lock); if (unlikely((__u32)__atomic_load_n(&info->used, __ATOMIC_RELAXED) > info->sq_depth - num - 1)) { - pthread_spin_unlock(&info->sd_lock); + wd_fair_unlock(&info->sd_lock); WD_ERR("queue is full!\n"); return -WD_EBUSY; } @@ -636,7 +621,7 @@ int qm_send(struct wd_queue *q, void **req, __u32 num) ret = info->sqe_fill[qinfo->atype](req[i], qinfo->priv, info->sq_tail_index); if (unlikely(ret != WD_SUCCESS)) { - pthread_spin_unlock(&info->sd_lock); + wd_fair_unlock(&info->sd_lock); WD_ERR("sqe fill error, ret %d!\n", ret); return -WD_EINVAL; } @@ -648,7 +633,7 @@ int qm_send(struct wd_queue *q, void **req, __u32 num) } ret = qm_tx_update(info, num); - pthread_spin_unlock(&info->sd_lock); + wd_fair_unlock(&info->sd_lock); return ret; } @@ -681,9 +666,9 @@ static int check_ds_rx_base(struct qm_queue_info *info, return 0; if (before) { - pthread_spin_lock(&info->rc_lock); + wd_fair_lock(&info->rc_lock); qm_rx_from_cache(info, resp, num); - pthread_spin_unlock(&info->rc_lock); + wd_fair_unlock(&info->rc_lock); WD_ERR("wd queue hw error happened before qm receive!\n"); } else { WD_ERR("wd queue hw error happened after qm receive!\n"); @@ -724,7 +709,7 @@ int qm_recv(struct wd_queue *q, void **resp, __u32 num) if (unlikely(ret)) return ret; - pthread_spin_lock(&info->rc_lock); + wd_fair_lock(&info->rc_lock); for (i = 0; i < num; i++) { cqe = info->cq_base + info->cq_head_index * sizeof(struct cqe); if (info->cqc_phase != CQE_PHASE(cqe)) @@ -733,7 +718,7 @@ int qm_recv(struct wd_queue *q, void **resp, __u32 num) mb(); /* make sure the data is all in memory before read */ sq_head = CQE_SQ_HEAD_INDEX(cqe); if (unlikely(sq_head >= info->sq_depth)) { - pthread_spin_unlock(&info->rc_lock); + wd_fair_unlock(&info->rc_lock); WD_ERR("CQE_SQ_HEAD_INDEX(%u) error\n", sq_head); return -WD_EIO; } @@ -745,7 +730,7 @@ int qm_recv(struct wd_queue *q, void **resp, __u32 num) if (!ret) { break; } else if (ret < 0) { - pthread_spin_unlock(&info->rc_lock); + wd_fair_unlock(&info->rc_lock); WD_ERR("recv sqe error %u\n", sq_head); return ret; } @@ -766,7 +751,7 @@ int qm_recv(struct wd_queue *q, void **resp, __u32 num) ret = i; } - pthread_spin_unlock(&info->rc_lock); + wd_fair_unlock(&info->rc_lock); return ret; } diff --git a/v1/drv/hisi_qm_udrv.h b/v1/drv/hisi_qm_udrv.h index 06ac66a0..d71f9de8 100644 --- a/v1/drv/hisi_qm_udrv.h +++ b/v1/drv/hisi_qm_udrv.h @@ -166,8 +166,8 @@ struct qm_queue_info { qm_sqe_parse sqe_parse[WCRYPTO_MAX_ALG]; hisi_qm_sqe_fill_priv sqe_fill_priv; hisi_qm_sqe_parse_priv sqe_parse_priv; - pthread_spinlock_t sd_lock; - pthread_spinlock_t rc_lock; + struct wd_fair_lock sd_lock; + struct wd_fair_lock rc_lock; struct wd_queue *q; int (*sgl_info)(struct hw_sgl_info *info); int (*sgl_init)(void *pool, struct wd_sgl *sgl); diff --git a/v1/wd_util.c b/v1/wd_util.c index 29f65792..3dac2d74 100644 --- a/v1/wd_util.c +++ b/v1/wd_util.c @@ -14,6 +14,7 @@ * limitations under the License. */ +#include <stdatomic.h> #include <stdio.h> #include <string.h> #include <dirent.h> @@ -21,6 +22,7 @@ #include "v1/wd_util.h" #define BYTE_TO_BIT 8 +#define LOCK_TRY_CNT (0x800000000U) void wd_spinlock(struct wd_lock *lock) { @@ -43,6 +45,35 @@ void wd_unspinlock(struct wd_lock *lock) __atomic_store_n(&lock->lock, 0, __ATOMIC_RELEASE); } +void wd_fair_init(struct wd_fair_lock *lock) +{ + atomic_exchange_explicit(&lock->ticket, 0, memory_order_acq_rel); + atomic_exchange_explicit(&lock->serving, 0, memory_order_acq_rel); +} + +void wd_fair_lock(struct wd_fair_lock *lock) +{ + __u32 my_ticket = atomic_fetch_add_explicit(&lock->ticket, 1, + memory_order_acq_rel); + __u32 val = atomic_load_explicit(&lock->serving, memory_order_acquire); + __u64 cnt = 0; + + if (val == my_ticket) + return; + + do { + if (++cnt == LOCK_TRY_CNT) + WD_ERR("failed to get lock with %lu times\n", LOCK_TRY_CNT); + + val = atomic_load_explicit(&lock->serving, memory_order_acquire); + } while (val != my_ticket); +} + +void wd_fair_unlock(struct wd_fair_lock *lock) +{ + atomic_fetch_add_explicit(&lock->serving, 1, memory_order_acq_rel); +} + void *drv_iova_map(struct wd_queue *q, void *va, size_t sz) { struct q_info *qinfo = q->qinfo; diff --git a/v1/wd_util.h b/v1/wd_util.h index 21137d2d..70f9ed92 100644 --- a/v1/wd_util.h +++ b/v1/wd_util.h @@ -111,6 +111,11 @@ struct wd_lock { __u8 lock; }; +struct wd_fair_lock { + volatile __u32 ticket; + volatile __u32 serving; +}; + struct wd_ss_region { void *va; unsigned long long pa; @@ -392,6 +397,9 @@ static inline uint32_t wd_reg_read(void *reg_addr) void wd_spinlock(struct wd_lock *lock); void wd_unspinlock(struct wd_lock *lock); +void wd_fair_init(struct wd_fair_lock *lock); +void wd_fair_lock(struct wd_fair_lock *lock); +void wd_fair_unlock(struct wd_fair_lock *lock); void *wd_drv_mmap_qfr(struct wd_queue *q, enum uacce_qfrt qfrt, size_t size); void wd_drv_unmmap_qfr(struct wd_queue *q, void *addr, enum uacce_qfrt qfrt, size_t size); -- 2.33.0

1 0

2025

2024

2023

2022