- Acc - mailweb.openeuler.org

[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

2024/12/25 AccLIb SIG 双周例会 11:00 - 12:00
by openEuler conference 24 Dec '24

24 Dec '24

您好！ sig-AccLib 邀请您参加 2024-12-25 11:00 召开的Zoom会议会议主题：2024/12/25 AccLIb SIG 双周例会 11:00 - 12:00 会议内容：会议链接：linaro-org.zoom.us/j/91879279131 会议纪要：etherpad.openeuler.org/p/sig-AccLib-meet 会议链接：https://us06web.zoom.us/j/87231569205?pwd=h4OaT6BML3ZmPXDiWL8aCUJSx2opeH.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 2024-12-25 11:00, The subject of the conference is 2024/12/25 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/87231569205?pwd=h4OaT6BML3ZmPXDiWL8aCUJSx2opeH.1. Add topics at https://etherpad.openeuler.org/p/sig-AccLib-meetings. More information: https://www.openeuler.org/en/

1 0

[PATCH 00/13] uadk: sync some bugfix and cleancode
by Qi Tao 24 Dec '24

24 Dec '24

*** BLURB HERE *** Chenghai Huang (1): uadk - fix the log frequency limit function Qi Tao (2): uadk: add compilation options uadk_tool: fix error in saving the aead dst data Wenkai Lin (7): uadk: fix for set hashagg session state uadk/v1: support the hmac(sm3)-cbc(sm4) algorithm uadk: fix for the algorithm name of the aead cbc mode uadk/v1: Add stream mode for AES-GCM and SM4-GCM uadk/v1: add assoc bytes check uadk/v1: set aead msg state for the hardware v2 uadk/v1: fix input length check for aead stream mode. Zhiqi Song (3): uadk/hpre: modify privkey transform method of ecc v1/hpre: modify privkey transform method of ecc uadk/v1: cleanup key format transform function Makefile.am | 17 +- drv/hash_mb/hash_mb.c | 4 + drv/hisi_comp.c | 6 +- drv/hisi_dae.c | 34 ++- drv/hisi_hpre.c | 18 +- drv/hisi_sec.c | 8 +- include/crypto/sm4.h | 18 ++ include/wd_rsa.h | 2 - include/wd_util.h | 10 +- lib/crypto/sm4.c | 176 ++++++++++++++ uadk_tool/benchmark/sec_uadk_benchmark.c | 6 + uadk_tool/benchmark/uadk_benchmark.c | 6 +- uadk_tool/test/test_sec.c | 4 +- v1/drv/hisi_hpre_udrv.c | 28 +-- v1/drv/hisi_qm_udrv.c | 12 +- v1/drv/hisi_sec_udrv.c | 296 ++++++++++++++++++++++- v1/drv/hisi_sec_udrv.h | 9 +- v1/drv/hisi_zip_udrv.c | 26 +- v1/test/hisi_sec_test/test_hisi_sec.c | 4 +- v1/wd_adapter.c | 4 +- v1/wd_adapter.h | 2 +- v1/wd_aead.c | 67 ++++- v1/wd_aead.h | 12 + v1/wd_cipher.c | 2 +- v1/wd_digest.c | 6 +- v1/wd_ecc.c | 10 +- wd.c | 2 +- wd_aead.c | 10 +- wd_agg.c | 43 ++-- wd_alg.c | 2 + wd_cipher.c | 6 +- wd_comp.c | 16 +- wd_digest.c | 14 +- wd_ecc.c | 13 - wd_mempool.c | 2 +- wd_rsa.c | 6 +- wd_util.c | 16 +- 37 files changed, 739 insertions(+), 178 deletions(-) create mode 100644 include/crypto/sm4.h create mode 100644 lib/crypto/sm4.c -- 2.33.0

1 13

[PATCH v3 00/10] uadk_prov: add new algs
by Qi Tao 19 Dec '24

19 Dec '24

*** BLURB HERE *** Chenghai Huang (1): uadk_provider: add aead alg for uadk_provider in openssl3.0 Qi Tao (1): uadk_provider/rsa: cleanup variable definition and return value Weili Qian (6): uadk_provider: move functions to uadk_prov_pkey.c uadk_provider: add query_operation_name callback for keymgmt uadk_provider: support ec keymgmt hardware acceleration uadk_provider: support ecdh keyexch hardware acceleration uadk_provider: use default provider to get random data uadk_provider: alloc memory when copying ctx Zhiqi Song (1): uadk_provider: support x448 alg lizhi (1): uadk_engine: clear some compilation warnings, specific cleanup is as follows. src/Makefile.am | 20 +- src/uadk_aead.c | 2 +- src/uadk_prov.h | 12 +- src/uadk_prov_aead.c | 1030 +++++++++++++++++++++++++++++++ src/uadk_prov_bio.c | 2 + src/uadk_prov_cipher.c | 6 +- src/uadk_prov_der_writer.c | 2 +- src/uadk_prov_dh.c | 17 +- src/uadk_prov_digest.c | 38 +- src/uadk_prov_ec_kmgmt.c | 746 +++++++++++++++++++++++ src/uadk_prov_ecdh_exch.c | 884 +++++++++++++++++++++++++++ src/uadk_prov_ecx.c | 1164 ++++++++++++++++++++++++++++++++++++ src/uadk_prov_ffc.c | 24 +- src/uadk_prov_ffc.h | 1 - src/uadk_prov_init.c | 33 +- src/uadk_prov_pkey.c | 191 +++++- src/uadk_prov_pkey.h | 28 +- src/uadk_prov_rsa.c | 326 +++++----- src/uadk_prov_sm2.c | 71 +-- 19 files changed, 4329 insertions(+), 268 deletions(-) create mode 100644 src/uadk_prov_aead.c create mode 100644 src/uadk_prov_ec_kmgmt.c create mode 100644 src/uadk_prov_ecdh_exch.c create mode 100644 src/uadk_prov_ecx.c -- 2.33.0

1 10

[PATCH v2 0/6] fix compination warnings.
by Qi Tao 17 Dec '24

17 Dec '24

*** BLURB HERE *** Chenghai Huang (1): uadk_provider: add aead alg for uadk_provider in openssl3.0 Weili Qian (4): uadk_provider: move functions to uadk_prov_pkey.c uadk_provider: add query_operation_name callback for keymgmt uadk_provider: support ec keymgmt hardware acceleration uadk_provider: support ecdh keyexch hardware acceleration Zhiqi Song (1): uadk_provider: support x448 alg src/Makefile.am | 4 +- src/uadk_prov.h | 12 +- src/uadk_prov_aead.c | 1030 ++++++++++++++++++++++++++++++++ src/uadk_prov_dh.c | 8 + src/uadk_prov_ec_kmgmt.c | 746 +++++++++++++++++++++++ src/uadk_prov_ecdh_exch.c | 884 +++++++++++++++++++++++++++ src/uadk_prov_ecx.c | 1192 +++++++++++++++++++++++++++++++++++++ src/uadk_prov_init.c | 24 +- src/uadk_prov_pkey.c | 183 +++++- src/uadk_prov_pkey.h | 26 +- src/uadk_prov_rsa.c | 8 + src/uadk_prov_sm2.c | 71 +-- 12 files changed, 4121 insertions(+), 67 deletions(-) create mode 100644 src/uadk_prov_aead.c create mode 100644 src/uadk_prov_ec_kmgmt.c create mode 100644 src/uadk_prov_ecdh_exch.c create mode 100644 src/uadk_prov_ecx.c -- 2.33.0

1 6

【2024/12/11 AccLIb SIG 双周例会 11:00 - 12:00】
by openEuler conference 10 Dec '24

10 Dec '24

您好！ sig-AccLib 邀请您参加 2024-12-11 11:00 召开的Zoom会议会议主题：【2024/12/11 AccLIb SIG 双周例会 11:00 - 12:00】会议内容：会议链接：linaro-org.zoom.us/j/91879279131 会议纪要：etherpad.openeuler.org/p/sig-AccLib-meet 会议链接：https://us06web.zoom.us/j/84094811406?pwd=oVaPaIyP4VXx7aFiZFhAWFbla5JJ2j.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 2024-12-11 11:00, The subject of the conference is 【2024/12/11 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/84094811406?pwd=oVaPaIyP4VXx7aFiZFhAWFbla5JJ2j.1. Add topics at https://etherpad.openeuler.org/p/sig-AccLib-meetings. More information: https://www.openeuler.org/en/

1 0

[PATCH OLK-6.6 0/7] uacce: fix some problems
by Yang Shen 06 Dec '24

06 Dec '24

From: JiangShui Yang <yangjiangshui(a)h-partners.com> Chenghai Huang (1): crypto: hisilicon/zip - correct the wrong word in the printed information Longfang Liu (1): migration: modify dfx error type without VM driver Weili Qian (1): uacce: check the qfr address before releasing the qfr Yang Shen (4): uacce: add error number for the unsupported mremap uacce: add stop_queue to replace put_queue in ioctl uacce: add mutex for check qfr crypto: hisilicon/qm - fix the uacce_alloc return value check drivers/crypto/hisilicon/qm.c | 8 ++ drivers/crypto/hisilicon/zip/zip_crypto.c | 2 +- drivers/misc/uacce/uacce.c | 76 ++++++++++++------- .../vfio/pci/hisilicon/hisi_acc_vfio_pci.c | 2 +- 4 files changed, 60 insertions(+), 28 deletions(-) -- 2.43.0

1 7

[PATCH 1/8] uadk_provider: add aead alg for uadk_provider in openssl3.0
by Qi Tao 04 Dec '24

04 Dec '24

From: Chenghai Huang <huangchenghai2(a)huawei.com> The following 3 AES algorithms are added: AES-128-GCM AES-192-GCM AES-256-GCM Signed-off-by: Chenghai Huang <huangchenghai2(a)huawei.com> --- src/Makefile.am | 2 +- src/uadk_prov.h | 4 + src/uadk_prov_aead.c | 1028 ++++++++++++++++++++++++++++++++++++++++++ src/uadk_prov_init.c | 7 + 4 files changed, 1040 insertions(+), 1 deletion(-) create mode 100644 src/uadk_prov_aead.c diff --git a/src/Makefile.am b/src/Makefile.am index 54c00e7..921305b 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -65,7 +65,7 @@ uadk_provider_la_SOURCES=uadk_prov_init.c uadk_async.c uadk_utils.c \ uadk_prov_rsa.c uadk_prov_dh.c \ uadk_prov_bio.c uadk_prov_der_writer.c uadk_prov_packet.c \ uadk_prov_pkey.c uadk_prov_sm2.c \ - uadk_prov_ffc.c + uadk_prov_ffc.c uadk_prov_aead.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 8756fc6..ac82245 100644 --- a/src/uadk_prov.h +++ b/src/uadk_prov.h @@ -162,6 +162,9 @@ extern const OSSL_DISPATCH uadk_sm4_ecb_functions[FUNC_MAX_NUM]; extern const OSSL_DISPATCH uadk_sm4_ofb128_functions[FUNC_MAX_NUM]; extern const OSSL_DISPATCH uadk_sm4_cfb128_functions[FUNC_MAX_NUM]; extern const OSSL_DISPATCH uadk_sm4_ctr_functions[FUNC_MAX_NUM]; +extern const OSSL_DISPATCH uadk_aes_128_gcm_functions[FUNC_MAX_NUM]; +extern const OSSL_DISPATCH uadk_aes_192_gcm_functions[FUNC_MAX_NUM]; +extern const OSSL_DISPATCH uadk_aes_256_gcm_functions[FUNC_MAX_NUM]; extern const OSSL_DISPATCH uadk_des_ede3_cbc_functions[]; extern const OSSL_DISPATCH uadk_des_ede3_ecb_functions[]; @@ -178,6 +181,7 @@ extern const OSSL_DISPATCH uadk_sm2_asym_cipher_functions[FUNC_MAX_NUM]; void uadk_prov_destroy_digest(void); void uadk_prov_destroy_cipher(void); +void uadk_prov_destroy_aead(void); void uadk_prov_destroy_rsa(void); void uadk_prov_destroy_dh(void); void uadk_prov_sm2_uninit(void); diff --git a/src/uadk_prov_aead.c b/src/uadk_prov_aead.c new file mode 100644 index 0000000..c396f39 --- /dev/null +++ b/src/uadk_prov_aead.c @@ -0,0 +1,1028 @@ +// SPDX-License-Identifier: Apache-2.0 +/* + * Copyright 2023-2024 Huawei Technologies Co.,Ltd. All rights reserved. + * Copyright 2023-2024 Linaro ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include <stdio.h> +#include <stdbool.h> +#include <string.h> +#include <dlfcn.h> +#include <numa.h> +#include <openssl/core_names.h> +#include <openssl/proverr.h> +#include <uadk/wd_aead.h> +#include <uadk/wd_sched.h> +#include "uadk.h" +#include "uadk_async.h" +#include "uadk_prov.h" + +#define MAX_IV_LEN 16 +#define MAX_KEY_LEN 64 +#define MAX_AAD_LEN 0xFFFF +#define ALG_NAME_SIZE 128 +#define AES_GCM_TAG_LEN 16 +/* The max data length is 16M-512B */ +#define AEAD_BLOCK_SIZE 0xFFFE00 + +#define UADK_OSSL_FAIL 0 +#define UADK_AEAD_SUCCESS 1 +#define UADK_AEAD_FAIL (-1) + +#define UNINITIALISED_SIZET ((size_t)-1) +#define IV_STATE_UNINITIALISED 0 +#define IV_STATE_SET 1 +#define KEY_STATE_SET 1 + +/* Internal flags that can be queried */ +#define PROV_CIPHER_FLAG_AEAD 0x0001 +#define PROV_CIPHER_FLAG_CUSTOM_IV 0x0002 +#define AEAD_FLAGS (PROV_CIPHER_FLAG_AEAD | PROV_CIPHER_FLAG_CUSTOM_IV) + +#define UADK_AEAD_DEF_CTXS 2 +#define UADK_AEAD_OP_NUM 1 + +struct aead_prov { + int pid; +}; +static struct aead_prov aprov; +static pthread_mutex_t aead_mutex = PTHREAD_MUTEX_INITIALIZER; + +enum uadk_aead_mode { + UNINIT_MODE, + ASYNC_MODE, + SYNC_MODE +}; + +enum aead_tag_status { + INIT_TAG, + READ_TAG, /* The MAC has been read. */ + SET_TAG /* The MAC has been set to req. */ +}; + +struct aead_priv_ctx { + int nid; + char alg_name[ALG_NAME_SIZE]; + size_t keylen; + size_t ivlen; + size_t taglen; + + unsigned int enc : 1; + unsigned int key_set : 1; /* Whether key is copied to priv key buffers */ + unsigned int iv_set : 1; /* Whether iv is copied to priv iv buffers */ + enum aead_tag_status tag_set; /* Whether mac is copied to priv mac buffers */ + + unsigned char iv[MAX_IV_LEN]; + unsigned char key[MAX_KEY_LEN]; + unsigned char buf[AES_GCM_TAG_LEN]; /* mac buffers */ + unsigned char *data; /* store input and output when block mode */ + + struct wd_aead_sess_setup setup; + struct wd_aead_req req; + enum uadk_aead_mode mode; + handle_t sess; +}; + +struct aead_info { + int nid; + enum wd_cipher_alg alg; + enum wd_cipher_mode mode; +}; + +static struct aead_info aead_info_table[] = { + { NID_aes_128_gcm, WD_CIPHER_AES, WD_CIPHER_GCM }, + { NID_aes_192_gcm, WD_CIPHER_AES, WD_CIPHER_GCM }, + { NID_aes_256_gcm, WD_CIPHER_AES, WD_CIPHER_GCM } +}; + +static int uadk_aead_poll(void *ctx) +{ + __u64 rx_cnt = 0; + __u32 recv = 0; + /* Poll one packet currently */ + int expt = 1; + int ret; + + do { + ret = wd_aead_poll(expt, &recv); + if (ret < 0 || recv >= expt) + return ret; + rx_cnt++; + } while (rx_cnt < ENGINE_RECV_MAX_CNT); + + fprintf(stderr, "failed to poll msg: timeout!\n"); + + return -ETIMEDOUT; +} + +static void uadk_aead_mutex_infork(void) +{ + /* Release the replication lock of the child process */ + pthread_mutex_unlock(&aead_mutex); +} + +static int uadk_prov_aead_dev_init(struct aead_priv_ctx *priv) +{ + struct wd_ctx_nums ctx_set_num; + struct wd_ctx_params cparams = {0}; + int ret = UADK_AEAD_SUCCESS; + + pthread_atfork(NULL, NULL, uadk_aead_mutex_infork); + pthread_mutex_lock(&aead_mutex); + if (aprov.pid == getpid()) + goto mutex_unlock; + + cparams.op_type_num = UADK_AEAD_OP_NUM; + cparams.ctx_set_num = &ctx_set_num; + cparams.bmp = numa_allocate_nodemask(); + if (!cparams.bmp) { + ret = UADK_AEAD_FAIL; + fprintf(stderr, "failed to create nodemask!\n"); + goto mutex_unlock; + } + + numa_bitmask_setall(cparams.bmp); + + ctx_set_num.sync_ctx_num = UADK_AEAD_DEF_CTXS; + ctx_set_num.async_ctx_num = UADK_AEAD_DEF_CTXS; + + ret = wd_aead_init2_(priv->alg_name, TASK_MIX, SCHED_POLICY_RR, &cparams); + if (unlikely(ret)) { + ret = UADK_AEAD_FAIL; + fprintf(stderr, "failed to init aead!\n"); + goto free_nodemask; + } + + aprov.pid = getpid(); + async_register_poll_fn(ASYNC_TASK_AEAD, uadk_aead_poll); + +free_nodemask: + numa_free_nodemask(cparams.bmp); +mutex_unlock: + pthread_mutex_unlock(&aead_mutex); + return ret; +} + +static int uadk_prov_aead_ctx_init(struct aead_priv_ctx *priv) +{ + struct sched_params params = {0}; + int ret; + + if (!priv->key_set || !priv->iv_set) { + fprintf(stderr, "key or iv is not set yet!\n"); + return UADK_AEAD_FAIL; + } + + priv->req.iv_bytes = priv->ivlen; + priv->req.iv = priv->iv; + priv->req.out_bytes = 0; + priv->req.mac = priv->buf; + priv->req.mac_bytes = priv->taglen; + + ret = uadk_prov_aead_dev_init(priv); + if (unlikely(ret < 0)) + return UADK_AEAD_FAIL; + + /* dec and enc use the same op */ + params.type = 0; + /* Use the default numa parameters */ + params.numa_id = -1; + priv->setup.sched_param = &params; + + if (!priv->sess) { + priv->sess = wd_aead_alloc_sess(&priv->setup); + if (!priv->sess) { + fprintf(stderr, "uadk failed to alloc session!\n"); + return UADK_AEAD_FAIL; + } + + ret = wd_aead_set_authsize(priv->sess, priv->taglen); + if (ret) { + fprintf(stderr, "uadk failed to set authsize!\n"); + goto free_sess; + } + + ret = wd_aead_set_ckey(priv->sess, priv->key, priv->keylen); + if (ret) { + fprintf(stderr, "uadk failed to set key!\n"); + goto free_sess; + } + } + + return UADK_AEAD_SUCCESS; + +free_sess: + wd_aead_free_sess(priv->sess); + priv->sess = 0; + return UADK_AEAD_FAIL; +} + +static void *uadk_prov_aead_cb(struct wd_aead_req *req, void *data) +{ + struct uadk_e_cb_info *cb_param; + struct wd_aead_req *req_origin; + struct async_op *op; + + if (!req) + return NULL; + + cb_param = req->cb_param; + if (!cb_param) + return NULL; + + req_origin = cb_param->priv; + req_origin->state = req->state; + + op = cb_param->op; + if (op && op->job && !op->done) { + op->done = 1; + async_free_poll_task(op->idx, 1); + async_wake_job(op->job); + } + + return NULL; +} + +static int do_aes_gcm_prepare(struct aead_priv_ctx *priv) +{ + if (priv->mode == UNINIT_MODE) { + if (ASYNC_get_current_job()) + priv->mode = ASYNC_MODE; + else + priv->mode = SYNC_MODE; + } + + if (!priv->enc && priv->tag_set == READ_TAG) { + if (likely(priv->taglen == AES_GCM_TAG_LEN)) { + memcpy(priv->req.mac, priv->buf, AES_GCM_TAG_LEN); + priv->tag_set = SET_TAG; + } else { + fprintf(stderr, "invalid: aead gcm mac length only support 16B.\n"); + return UADK_AEAD_FAIL; + } + } + + return UADK_AEAD_SUCCESS; +} + +static void uadk_do_aead_async_prepare(struct aead_priv_ctx *priv, unsigned char *out, + const unsigned char *in, size_t inlen) +{ + priv->req.in_bytes = inlen; + /* AAD data is input or output together with plaintext or ciphertext. */ + if (priv->req.assoc_bytes) { + memcpy(priv->data + priv->req.assoc_bytes, in, inlen); + priv->req.src = priv->data; + priv->req.dst = priv->data + AEAD_BLOCK_SIZE; + } else { + priv->req.src = (unsigned char *)in; + priv->req.dst = out; + } +} + +static int uadk_do_aead_sync_inner(struct aead_priv_ctx *priv, unsigned char *out, + const unsigned char *in, size_t inlen, enum wd_aead_msg_state state) +{ + int ret; + + if ((state == AEAD_MSG_BLOCK || state == AEAD_MSG_END) + && !priv->enc && priv->tag_set != SET_TAG) { + fprintf(stderr, "The tag for synchronous decryption is not set.\n"); + return UADK_AEAD_FAIL; + } + + priv->req.msg_state = state; + priv->req.src = in; + priv->req.dst = out; + priv->req.in_bytes = inlen; + priv->req.state = 0; + ret = wd_do_aead_sync(priv->sess, &priv->req); + if (unlikely(ret < 0 || priv->req.state)) { + fprintf(stderr, "do aead task failed, msg state: %u, ret: %d, state: %u!\n", + state, ret, priv->req.state); + return UADK_AEAD_FAIL; + } + + return inlen; +} + +static int uadk_do_aead_sync(struct aead_priv_ctx *priv, unsigned char *out, + const unsigned char *in, size_t inlen) +{ + size_t nbytes, tail, processing_len, max_mid_len; + const unsigned char *in_block = in; + unsigned char *out_block = out; + int ret; + + /* Due to a hardware limitation, zero-length aad using block mode. */ + if (!priv->req.assoc_bytes) + return uadk_do_aead_sync_inner(priv, out, in, inlen, AEAD_MSG_BLOCK); + + tail = inlen % AES_BLOCK_SIZE; + nbytes = inlen - tail; + max_mid_len = AEAD_BLOCK_SIZE - priv->req.assoc_bytes; + + /* If the data length is not 16-byte aligned, it is split according to the protocol. */ + while (nbytes > 0) { + processing_len = nbytes > max_mid_len ? max_mid_len : nbytes; + processing_len -= (processing_len % AES_BLOCK_SIZE); + + ret = uadk_do_aead_sync_inner(priv, out_block, in_block, + processing_len, AEAD_MSG_MIDDLE); + if (ret < 0) + return UADK_AEAD_FAIL; + nbytes -= processing_len; + in_block = in_block + processing_len; + out_block = out_block + processing_len; + } + + if (tail) { + ret = uadk_do_aead_sync_inner(priv, out_block, in_block, tail, AEAD_MSG_END); + if (ret < 0) + return UADK_AEAD_FAIL; + } + + return inlen; +} + +static int uadk_do_aead_async(struct aead_priv_ctx *priv, struct async_op *op, + unsigned char *out, const unsigned char *in, size_t inlen) +{ + struct uadk_e_cb_info *cb_param; + int cnt = 0; + int ret; + + if (!priv->enc && priv->tag_set != SET_TAG) { + fprintf(stderr, "The tag for asynchronous decryption is not set.\n"); + return UADK_AEAD_FAIL; + } + + if (unlikely(priv->req.assoc_bytes + inlen > AEAD_BLOCK_SIZE)) { + fprintf(stderr, "aead input data length is too long!\n"); + return UADK_AEAD_FAIL; + } + + uadk_do_aead_async_prepare(priv, out, in, inlen); + + cb_param = malloc(sizeof(struct uadk_e_cb_info)); + if (unlikely(!cb_param)) { + fprintf(stderr, "failed to alloc cb_param.\n"); + return UADK_AEAD_FAIL; + } + + cb_param->op = op; + cb_param->priv = &priv->req; + priv->req.cb = uadk_prov_aead_cb; + priv->req.cb_param = cb_param; + priv->req.msg_state = AEAD_MSG_BLOCK; + priv->req.state = UADK_AEAD_FAIL; + + ret = async_get_free_task(&op->idx); + if (unlikely(!ret)) + goto free_cb_param; + + do { + ret = wd_do_aead_async(priv->sess, &priv->req); + if (unlikely(ret < 0)) { + if (unlikely(ret != -EBUSY)) + fprintf(stderr, "do aead async operation failed ret = %d.\n", ret); + else if (unlikely(cnt++ > ENGINE_SEND_MAX_CNT)) + fprintf(stderr, "do aead async operation timeout.\n"); + else + continue; + + async_free_poll_task(op->idx, 0); + ret = UADK_AEAD_FAIL; + goto free_cb_param; + } + } while (ret == -EBUSY); + + ret = async_pause_job(priv, op, ASYNC_TASK_AEAD); + if (unlikely(!ret || priv->req.state)) { + fprintf(stderr, "do aead async job failed, ret: %d, state: %u!\n", + ret, priv->req.state); + ret = UADK_AEAD_FAIL; + goto free_cb_param; + } + + if (priv->req.assoc_bytes) + memcpy(out, priv->req.dst + priv->req.assoc_bytes, inlen); + +free_cb_param: + free(cb_param); + return ret; +} + +static int uadk_prov_do_aes_gcm_first(struct aead_priv_ctx *priv, unsigned char *out, + const unsigned char *in, size_t inlen) +{ + int ret; + + if (inlen > MAX_AAD_LEN) { + fprintf(stderr, "the aad len is out of range, aad len = %lu.\n", inlen); + return UADK_AEAD_FAIL; + } + + priv->req.assoc_bytes = inlen; + + /* Asynchronous jobs use the block mode. */ + if (priv->mode == ASYNC_MODE || !priv->req.assoc_bytes) { + memcpy(priv->data, in, inlen); + return UADK_AEAD_SUCCESS; + } + + ret = uadk_do_aead_sync_inner(priv, out, in, inlen, AEAD_MSG_FIRST); + if (unlikely(ret < 0)) + return UADK_AEAD_FAIL; + + return UADK_AEAD_SUCCESS; +} + +static int uadk_prov_do_aes_gcm_update(struct aead_priv_ctx *priv, unsigned char *out, + const unsigned char *in, size_t inlen) +{ + struct async_op *op; + int ret; + + if (priv->mode == ASYNC_MODE) { + op = malloc(sizeof(struct async_op)); + if (unlikely(!op)) + return UADK_AEAD_FAIL; + + ret = async_setup_async_event_notification(op); + if (unlikely(!ret)) { + fprintf(stderr, "failed to setup async event notification.\n"); + goto free_op; + } + + ret = uadk_do_aead_async(priv, op, out, in, inlen); + if (unlikely(ret < 0)) { + fprintf(stderr, "uadk_do_aead_async failed ret = %d.\n", ret); + goto free_notification; + } + + free(op); + return inlen; + } + + return uadk_do_aead_sync(priv, out, in, inlen); + +free_notification: + (void)async_clear_async_event_notification(); +free_op: + free(op); + return UADK_AEAD_FAIL; +} + +static int uadk_prov_do_aes_gcm_final(struct aead_priv_ctx *priv, unsigned char *out, + const unsigned char *in, size_t inlen) +{ + int ret; + + if (priv->mode == ASYNC_MODE || !priv->req.assoc_bytes || + priv->req.msg_state == AEAD_MSG_END) + goto out; + + ret = uadk_do_aead_sync_inner(priv, out, in, inlen, AEAD_MSG_END); + if (unlikely(ret < 0)) + return UADK_AEAD_FAIL; + +out: + if (priv->enc) + memcpy(priv->buf, priv->req.mac, priv->taglen); + else + priv->tag_set = INIT_TAG; + + priv->mode = UNINIT_MODE; + return UADK_AEAD_SUCCESS; +} + +static int uadk_prov_do_aes_gcm(struct aead_priv_ctx *priv, unsigned char *out, + size_t *outl, size_t outsize, + const unsigned char *in, size_t inlen) +{ + int ret; + + ret = uadk_prov_aead_ctx_init(priv); + if (ret != UADK_AEAD_SUCCESS) + return UADK_AEAD_FAIL; + + ret = do_aes_gcm_prepare(priv); + if (unlikely(ret < 0)) + return UADK_AEAD_FAIL; + + if (in) { + if (!out) + return uadk_prov_do_aes_gcm_first(priv, out, in, inlen); + + return uadk_prov_do_aes_gcm_update(priv, out, in, inlen); + } + + return uadk_prov_do_aes_gcm_final(priv, out, NULL, 0); +} + +void uadk_prov_destroy_aead(void) +{ + pthread_mutex_lock(&aead_mutex); + if (aprov.pid == getpid()) { + wd_aead_uninit2(); + aprov.pid = 0; + } + pthread_mutex_unlock(&aead_mutex); +} + +static OSSL_FUNC_cipher_encrypt_init_fn uadk_prov_aead_einit; +static OSSL_FUNC_cipher_decrypt_init_fn uadk_prov_aead_dinit; +static OSSL_FUNC_cipher_freectx_fn uadk_prov_aead_freectx; +static OSSL_FUNC_cipher_dupctx_fn uadk_prov_aead_dupctx; +static OSSL_FUNC_cipher_get_ctx_params_fn uadk_prov_aead_get_ctx_params; +static OSSL_FUNC_cipher_gettable_ctx_params_fn uadk_prov_aead_gettable_ctx_params; +static OSSL_FUNC_cipher_set_ctx_params_fn uadk_prov_aead_set_ctx_params; +static OSSL_FUNC_cipher_settable_ctx_params_fn uadk_prov_aead_settable_ctx_params; + +static int uadk_prov_aead_cipher(void *vctx, unsigned char *out, size_t *outl, + size_t outsize, const unsigned char *in, + size_t inl) +{ + struct aead_priv_ctx *priv = (struct aead_priv_ctx *)vctx; + int ret; + + if (!vctx || !out || !outl) + return UADK_OSSL_FAIL; + + if (outsize < inl) { + ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL); + return UADK_OSSL_FAIL; + } + + ret = uadk_prov_do_aes_gcm(priv, out, outl, outsize, in, inl); + if (ret < 0) + return UADK_OSSL_FAIL; + + *outl = inl; + return UADK_AEAD_SUCCESS; +} + +static int uadk_prov_aead_stream_update(void *vctx, unsigned char *out, + size_t *outl, size_t outsize, + const unsigned char *in, size_t inl) +{ + struct aead_priv_ctx *priv = (struct aead_priv_ctx *)vctx; + int ret; + + if (!vctx) + return UADK_OSSL_FAIL; + + if (outsize < inl) { + ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL); + return UADK_OSSL_FAIL; + } + + ret = uadk_prov_do_aes_gcm(priv, out, outl, outsize, in, inl); + if (ret < 0) { + fprintf(stderr, "stream data update failed.\n"); + return UADK_OSSL_FAIL; + } + + *outl = inl; + return UADK_AEAD_SUCCESS; +} + +static int uadk_prov_aead_stream_final(void *vctx, unsigned char *out, + size_t *outl, size_t outsize) +{ + struct aead_priv_ctx *priv = (struct aead_priv_ctx *)vctx; + int ret; + + if (!vctx || !out || !outl) + return UADK_OSSL_FAIL; + + ret = uadk_prov_do_aes_gcm(priv, out, outl, outsize, NULL, 0); + if (ret < 0) { + fprintf(stderr, "stream data final failed, ret = %d\n", ret); + return UADK_OSSL_FAIL; + } + + *outl = 0; + return UADK_AEAD_SUCCESS; +} + +static int uadk_get_aead_info(struct aead_priv_ctx *priv) +{ + int aead_counts = ARRAY_SIZE(aead_info_table); + int i; + + for (i = 0; i < aead_counts; i++) { + if (priv->nid == aead_info_table[i].nid) { + priv->setup.calg = aead_info_table[i].alg; + priv->setup.cmode = aead_info_table[i].mode; + break; + } + } + + if (unlikely(i == aead_counts)) { + fprintf(stderr, "failed to setup the private ctx.\n"); + return UADK_AEAD_FAIL; + } + + return UADK_AEAD_SUCCESS; +} + +static int uadk_prov_aead_init(struct aead_priv_ctx *priv, + const unsigned char *key, size_t keylen, + const unsigned char *iv, size_t ivlen) +{ + int ret; + + if (ivlen > MAX_IV_LEN || keylen > MAX_KEY_LEN) { + fprintf(stderr, "invalid keylen or ivlen.\n"); + return UADK_OSSL_FAIL; + } + + if (iv) { + memcpy(priv->iv, iv, ivlen); + priv->iv_set = IV_STATE_SET; + } + + ret = uadk_get_aead_info(priv); + if (unlikely(ret < 0)) + return UADK_OSSL_FAIL; + + if (key) { + memcpy(priv->key, key, keylen); + priv->key_set = KEY_STATE_SET; + } + + ret = uadk_prov_aead_dev_init(priv); + if (unlikely(ret < 0)) + return UADK_OSSL_FAIL; + + return UADK_AEAD_SUCCESS; +} + +static int uadk_prov_aead_einit(void *vctx, const unsigned char *key, size_t keylen, + const unsigned char *iv, size_t ivlen, + const OSSL_PARAM params[]) +{ + struct aead_priv_ctx *priv = (struct aead_priv_ctx *)vctx; + + if (!vctx) + return UADK_OSSL_FAIL; + + priv->req.op_type = WD_CIPHER_ENCRYPTION_DIGEST; + priv->enc = 1; + + return uadk_prov_aead_init(priv, key, keylen, iv, ivlen); +} + +static int uadk_prov_aead_dinit(void *vctx, const unsigned char *key, size_t keylen, + const unsigned char *iv, size_t ivlen, + const OSSL_PARAM params[]) +{ + struct aead_priv_ctx *priv = (struct aead_priv_ctx *)vctx; + + if (!vctx) + return UADK_OSSL_FAIL; + + priv->req.op_type = WD_CIPHER_DECRYPTION_DIGEST; + priv->enc = 0; + + return uadk_prov_aead_init(priv, key, keylen, iv, ivlen); +} + +static const OSSL_PARAM uadk_prov_settable_ctx_params[] = { + OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL), + OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL), + OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0), + OSSL_PARAM_END +}; + +const OSSL_PARAM *uadk_prov_aead_settable_ctx_params(ossl_unused void *cctx, + ossl_unused void *provctx) +{ + return uadk_prov_settable_ctx_params; +} + +static int uadk_prov_aead_set_ctx_params(void *vctx, const OSSL_PARAM params[]) +{ + struct aead_priv_ctx *priv = (struct aead_priv_ctx *)vctx; + const OSSL_PARAM *p; + size_t sz = 0; + void *vp; + + if (!vctx) + return UADK_OSSL_FAIL; + + p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_TAG); + if (p) { + vp = priv->buf; + if (!OSSL_PARAM_get_octet_string(p, &vp, EVP_GCM_TLS_TAG_LEN, &sz)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); + return UADK_OSSL_FAIL; + } + + if (sz == 0 || priv->enc) { + ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAG); + return UADK_OSSL_FAIL; + } + priv->tag_set = READ_TAG; + priv->taglen = sz; + } + + p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN); + if (p) { + size_t keylen; + + if (!OSSL_PARAM_get_size_t(p, &keylen)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); + return UADK_OSSL_FAIL; + } + if (priv->keylen != keylen) { + ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH); + return UADK_OSSL_FAIL; + } + } + + p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_IVLEN); + if (p) { + if (!OSSL_PARAM_get_size_t(p, &sz)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER); + return UADK_OSSL_FAIL; + } + if (sz == 0 || sz > priv->ivlen) { + ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH); + return UADK_OSSL_FAIL; + } + priv->ivlen = sz; + } + + return UADK_AEAD_SUCCESS; +} + +static const OSSL_PARAM uadk_prov_aead_ctx_params[] = { + OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL), + OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL), + OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL), + OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0), + OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_UPDATED_IV, NULL, 0), + OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0), + OSSL_PARAM_END +}; + +static const OSSL_PARAM *uadk_prov_aead_gettable_ctx_params(ossl_unused void *cctx, + ossl_unused void *provctx) +{ + return uadk_prov_aead_ctx_params; +} + +static int uadk_prov_aead_get_ctx_params(void *vctx, OSSL_PARAM params[]) +{ + struct aead_priv_ctx *priv = (struct aead_priv_ctx *)vctx; + OSSL_PARAM *p; + + if (!vctx || !params) + return UADK_OSSL_FAIL; + + p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN); + if (p && !OSSL_PARAM_set_size_t(p, priv->ivlen)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); + return UADK_OSSL_FAIL; + } + + p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN); + if (p && !OSSL_PARAM_set_size_t(p, priv->keylen)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); + return UADK_OSSL_FAIL; + } + + p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TAGLEN); + if (p) { + size_t taglen = (priv->taglen != UNINITIALISED_SIZET) ? + priv->taglen : AES_GCM_TAG_LEN; + + if (!OSSL_PARAM_set_size_t(p, taglen)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); + return UADK_OSSL_FAIL; + } + } + + p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV); + if (p) { + if (priv->iv_set == IV_STATE_UNINITIALISED) + return UADK_OSSL_FAIL; + if (priv->ivlen > p->data_size) { + ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH); + return UADK_OSSL_FAIL; + } + if (!OSSL_PARAM_set_octet_string(p, priv->iv, priv->ivlen) + && !OSSL_PARAM_set_octet_ptr(p, &priv->iv, priv->ivlen)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); + return UADK_OSSL_FAIL; + } + } + + p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_UPDATED_IV); + if (p) { + if (priv->iv_set == IV_STATE_UNINITIALISED) + return UADK_OSSL_FAIL; + if (priv->ivlen > p->data_size) { + ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH); + return UADK_OSSL_FAIL; + } + if (!OSSL_PARAM_set_octet_string(p, priv->iv, priv->ivlen) + && !OSSL_PARAM_set_octet_ptr(p, &priv->iv, priv->ivlen)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); + return UADK_OSSL_FAIL; + } + } + + p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TAG); + if (p) { + size_t sz = p->data_size; + + if (sz == 0 || sz > EVP_GCM_TLS_TAG_LEN || !priv->enc + || priv->taglen == UNINITIALISED_SIZET) { + ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAG); + return UADK_OSSL_FAIL; + } + + if (!OSSL_PARAM_set_octet_string(p, priv->buf, sz)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); + return UADK_OSSL_FAIL; + } + } + return UADK_AEAD_SUCCESS; +} + +static const OSSL_PARAM aead_known_gettable_params[] = { + OSSL_PARAM_uint(OSSL_CIPHER_PARAM_MODE, NULL), + OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL), + OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL), + OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_BLOCK_SIZE, NULL), + OSSL_PARAM_int(OSSL_CIPHER_PARAM_AEAD, NULL), + OSSL_PARAM_int(OSSL_CIPHER_PARAM_CUSTOM_IV, NULL), + OSSL_PARAM_END +}; + +static const OSSL_PARAM *uadk_prov_aead_gettable_params(ossl_unused void *provctx) +{ + return aead_known_gettable_params; +} + +static int uadk_cipher_aead_get_params(OSSL_PARAM params[], unsigned int md, + uint64_t flags, size_t kbits, + size_t blkbits, size_t ivbits) +{ + OSSL_PARAM *p; + + p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_MODE); + if (p && !OSSL_PARAM_set_uint(p, md)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); + return UADK_OSSL_FAIL; + } + p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD); + if (p && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_AEAD) != 0)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); + return UADK_OSSL_FAIL; + } + p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_CUSTOM_IV); + if (p && !OSSL_PARAM_set_int(p, (flags & PROV_CIPHER_FLAG_CUSTOM_IV) != 0)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); + return UADK_OSSL_FAIL; + } + p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN); + if (p && !OSSL_PARAM_set_size_t(p, kbits)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); + return UADK_OSSL_FAIL; + } + p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_BLOCK_SIZE); + if (p && !OSSL_PARAM_set_size_t(p, blkbits)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); + return UADK_OSSL_FAIL; + } + p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN); + if (p && !OSSL_PARAM_set_size_t(p, ivbits)) { + ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER); + return UADK_OSSL_FAIL; + } + + return UADK_AEAD_SUCCESS; +} + +static void *uadk_prov_aead_dupctx(void *ctx) +{ + struct aead_priv_ctx *priv, *ret; + + priv = (struct aead_priv_ctx *)ctx; + if (!priv) + return NULL; + + ret = OPENSSL_memdup(priv, sizeof(*priv)); + if (!ret) + return NULL; + + ret->sess = 0; + ret->data = OPENSSL_memdup(priv->data, AEAD_BLOCK_SIZE << 1); + if (!ret->data) { + OPENSSL_clear_free(ret, sizeof(*ret)); + return NULL; + } + + return ret; +} + +static void uadk_prov_aead_freectx(void *ctx) +{ + struct aead_priv_ctx *priv = (struct aead_priv_ctx *)ctx; + + if (!ctx) + return; + + if (priv->sess) { + wd_aead_free_sess(priv->sess); + priv->sess = 0; + } + + if (priv->data) { + OPENSSL_clear_free(priv->data, AEAD_BLOCK_SIZE << 1); + priv->data = NULL; + } + OPENSSL_clear_free(priv, sizeof(*priv)); +} + +#define UADK_AEAD_DESCR(nm, tag_len, key_len, iv_len, blk_size, \ + flags, e_nid, algnm, mode) \ +static OSSL_FUNC_cipher_newctx_fn uadk_##nm##_newctx; \ +static void *uadk_##nm##_newctx(void *provctx) \ +{ \ + struct aead_priv_ctx *ctx = OPENSSL_zalloc(sizeof(*ctx)); \ + if (!ctx) \ + return NULL; \ + \ + ctx->data = OPENSSL_zalloc(AEAD_BLOCK_SIZE << 1); \ + if (!ctx->data) { \ + OPENSSL_clear_free(ctx, sizeof(*ctx)); \ + return NULL; \ + } \ + \ + ctx->keylen = key_len; \ + ctx->ivlen = iv_len; \ + ctx->nid = e_nid; \ + ctx->taglen = tag_len; \ + strncpy(ctx->alg_name, #algnm, ALG_NAME_SIZE - 1); \ + \ + return ctx; \ +} \ +static OSSL_FUNC_cipher_get_params_fn uadk_##nm##_get_params; \ +static int uadk_##nm##_get_params(OSSL_PARAM params[]) \ +{ \ + return uadk_cipher_aead_get_params(params, mode, flags, \ + key_len, blk_size, iv_len); \ +} \ +const OSSL_DISPATCH uadk_##nm##_functions[] = { \ + { OSSL_FUNC_CIPHER_NEWCTX, (void (*)(void))uadk_##nm##_newctx }, \ + { OSSL_FUNC_CIPHER_FREECTX, (void (*)(void))uadk_prov_aead_freectx }, \ + { OSSL_FUNC_CIPHER_DUPCTX, (void (*)(void))uadk_prov_aead_dupctx }, \ + { OSSL_FUNC_CIPHER_ENCRYPT_INIT, \ + (void (*)(void))uadk_prov_aead_einit }, \ + { OSSL_FUNC_CIPHER_DECRYPT_INIT, \ + (void (*)(void))uadk_prov_aead_dinit }, \ + { OSSL_FUNC_CIPHER_UPDATE, \ + (void (*)(void))uadk_prov_aead_stream_update }, \ + { OSSL_FUNC_CIPHER_FINAL, \ + (void (*)(void))uadk_prov_aead_stream_final }, \ + { OSSL_FUNC_CIPHER_CIPHER, (void (*)(void))uadk_prov_aead_cipher }, \ + { OSSL_FUNC_CIPHER_GET_PARAMS, \ + (void (*)(void))uadk_##nm##_get_params }, \ + { OSSL_FUNC_CIPHER_GETTABLE_PARAMS, \ + (void (*)(void))uadk_prov_aead_gettable_params }, \ + { OSSL_FUNC_CIPHER_GET_CTX_PARAMS, \ + (void (*)(void))uadk_prov_aead_get_ctx_params }, \ + { OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS, \ + (void (*)(void))uadk_prov_aead_gettable_ctx_params }, \ + { OSSL_FUNC_CIPHER_SET_CTX_PARAMS, \ + (void (*)(void))uadk_prov_aead_set_ctx_params }, \ + { OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS, \ + (void (*)(void))uadk_prov_aead_settable_ctx_params }, \ + { 0, NULL } \ +} + +UADK_AEAD_DESCR(aes_128_gcm, AES_GCM_TAG_LEN, 16, 12, 8, AEAD_FLAGS, NID_aes_128_gcm, gcm(aes), + EVP_CIPH_GCM_MODE); +UADK_AEAD_DESCR(aes_192_gcm, AES_GCM_TAG_LEN, 24, 12, 8, AEAD_FLAGS, NID_aes_192_gcm, gcm(aes), + EVP_CIPH_GCM_MODE); +UADK_AEAD_DESCR(aes_256_gcm, AES_GCM_TAG_LEN, 32, 12, 8, AEAD_FLAGS, NID_aes_256_gcm, gcm(aes), + EVP_CIPH_GCM_MODE); diff --git a/src/uadk_prov_init.c b/src/uadk_prov_init.c index 972f953..772ddbb 100644 --- a/src/uadk_prov_init.c +++ b/src/uadk_prov_init.c @@ -137,6 +137,12 @@ const OSSL_ALGORITHM uadk_prov_ciphers_v3[] = { uadk_aes_192_cfb128_functions, "uadk_provider aes-192-cfb" }, { "AES-256-CFB", UADK_DEFAULT_PROPERTIES, uadk_aes_256_cfb128_functions, "uadk_provider aes-256-cfb" }, + { "AES-128-GCM", UADK_DEFAULT_PROPERTIES, + uadk_aes_128_gcm_functions, "uadk_provider aes-128-gcm" }, + { "AES-192-GCM", UADK_DEFAULT_PROPERTIES, + uadk_aes_192_gcm_functions, "uadk_provider aes-192-gcm" }, + { "AES-256-GCM", UADK_DEFAULT_PROPERTIES, + uadk_aes_256_gcm_functions, "uadk_provider aes-256-gcm" }, { "SM4-CBC", UADK_DEFAULT_PROPERTIES, uadk_sm4_cbc_functions, "uadk_provider sm4-cbc" }, { "SM4-ECB", UADK_DEFAULT_PROPERTIES, @@ -232,6 +238,7 @@ static void uadk_teardown(void *provctx) uadk_prov_destroy_digest(); uadk_prov_destroy_cipher(); + uadk_prov_destroy_aead(); uadk_prov_destroy_rsa(); uadk_prov_sm2_uninit(); uadk_prov_dh_uninit(); -- 2.33.0

1 6

[PATCH] uadk_engine: Add release note for uadk_engine 1.5
by Zhiqi Song 02 Dec '24

02 Dec '24

Add new feature and fixes release note of uadk_engine 1.5. Signed-off-by: Zhiqi Song <songzhiqi1(a)huawei.com> --- docs/ReleaseNotes.md | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/docs/ReleaseNotes.md b/docs/ReleaseNotes.md index 20163a2..94fc7bb 100644 --- a/docs/ReleaseNotes.md +++ b/docs/ReleaseNotes.md @@ -2,11 +2,23 @@ # UADK engine Release v1.5 Dec 2024 ## New Features +- Support SM2 asymmetric algorithm with openssl 3.0 provider mechanism. +- Support processing single diesgt block function with openssl 3.0 provider mechanism. +- Support AES CTS alg with openssl 3.0 provider mechanism. ## Fixes +- Reconstructing uadk_provider DH implementation with unified data structure and FFC \ + extended functions. +- Add different AES algorithm key bit width specifications in the uadk_provider. +- For digest algorithms, for both uadk_engine and uadk_provider, increasing the \ + amount of data delivered to the hardware at a time to reduce the number of interactions. +- Fixup bio fseek() suspending problem in uadk_provider. +- Fixup an async problem: wakup async_poll_process_func before free async_poll_task_free. +- Fixip cipher issue when input len is 0 in decrypto update. +- Fixip the key and IV verification methods for cipher init. +- Remove update iv for cipher, as the iv has been updated by the UADK. ## Working combination - - UADK v2.8 - OpenSSL 1.1.1f & OpenSSL 3.0+ -- 2.33.0

1 0

[PATCH 0/6] uadk_prov: fix compination warning
by Qi Tao 02 Dec '24

02 Dec '24

*** BLURB HERE *** Chenghai Huang (2): uadk_provider: fixed the variable type inconsistency issue uadk_provider/sec: cleanup variable definition and return value Zhiqi Song (4): async: modify the condition for async module uninit uadk_provider/pkey: cleanup unused functions in pkey uadk_provider/pkey: cleanup variable definition and return uadk_provider: fix discards 'const' qulifier from pointer src/uadk_async.c | 85 ++++++------ src/uadk_async.h | 1 + src/uadk_engine_init.c | 3 +- src/uadk_prov_cipher.c | 285 ++++++++++++++++++++--------------------- src/uadk_prov_dh.c | 3 +- src/uadk_prov_digest.c | 66 +++++----- src/uadk_prov_init.c | 2 +- src/uadk_prov_pkey.c | 171 ++++++++++++------------- src/uadk_prov_pkey.h | 59 +-------- src/uadk_prov_rsa.c | 44 ++++++- src/uadk_prov_sm2.c | 252 ++++++++++++++++++------------------ 11 files changed, 477 insertions(+), 494 deletions(-) -- 2.33.0

1 0

[PATCH] uadk_provider: fixed the variable type inconsistency issue
by Qi Tao 29 Nov '24

29 Nov '24

From: Chenghai Huang <huangchenghai2(a)huawei.com> The output parameter outl is of the size_t * type in the interface defined by OpenSSL. The int * type is different in uadk_prov_cipher. Signed-off-by: Chenghai Huang <huangchenghai2(a)huawei.com> --- src/uadk_prov_cipher.c | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/uadk_prov_cipher.c b/src/uadk_prov_cipher.c index 0d01a6a..3e0a5de 100644 --- a/src/uadk_prov_cipher.c +++ b/src/uadk_prov_cipher.c @@ -329,7 +329,7 @@ static int uadk_prov_cipher_soft_work(struct cipher_priv_ctx *priv, unsigned cha } static int uadk_prov_cipher_soft_final(struct cipher_priv_ctx *priv, unsigned char *out, - int *outl) + size_t *outl) { int sw_final_len = 0; @@ -681,7 +681,7 @@ static int ossl_cipher_unpadblock(unsigned char *buf, size_t *buflen, size_t blo } static int uadk_prov_hw_cipher(struct cipher_priv_ctx *priv, unsigned char *out, - int *outl, size_t outsize, + size_t *outl, size_t outsize, const unsigned char *in, size_t inlen) { size_t blksz = priv->blksize; @@ -729,7 +729,7 @@ static int uadk_prov_hw_cipher(struct cipher_priv_ctx *priv, unsigned char *out, } static int uadk_prov_do_cipher(struct cipher_priv_ctx *priv, unsigned char *out, - int *outl, size_t outsize, + size_t *outl, size_t outsize, const unsigned char *in, size_t inlen) { size_t blksz = priv->blksize; @@ -831,7 +831,7 @@ static OSSL_FUNC_cipher_gettable_ctx_params_fn uadk_prov_cipher_gettable_ctx_par static OSSL_FUNC_cipher_set_ctx_params_fn uadk_prov_cipher_set_ctx_params; static OSSL_FUNC_cipher_settable_ctx_params_fn uadk_prov_cipher_settable_ctx_params; -static int uadk_prov_cipher_cipher(void *vctx, unsigned char *out, int *outl, +static int uadk_prov_cipher_cipher(void *vctx, unsigned char *out, size_t *outl, size_t outsize, const unsigned char *in, size_t inl) { @@ -861,9 +861,9 @@ static int uadk_prov_cipher_cipher(void *vctx, unsigned char *out, int *outl, } static int uadk_prov_cipher_block_encrypto(struct cipher_priv_ctx *priv, - unsigned char *out, int *outl, size_t outsize) + unsigned char *out, size_t *outl, size_t outsize) { - int blksz = priv->blksize; + size_t blksz = priv->blksize; int ret; if (priv->pad) { @@ -893,7 +893,7 @@ static int uadk_prov_cipher_block_encrypto(struct cipher_priv_ctx *priv, } static int uadk_prov_cipher_block_decrypto(struct cipher_priv_ctx *priv, - unsigned char *out, int *outl, size_t outsize) + unsigned char *out, size_t *outl, size_t outsize) { size_t blksz = priv->blksize; int ret; @@ -932,7 +932,7 @@ static int uadk_prov_cipher_block_decrypto(struct cipher_priv_ctx *priv, } static int uadk_prov_cipher_block_final(void *vctx, unsigned char *out, - int *outl, size_t outsize) + size_t *outl, size_t outsize) { struct cipher_priv_ctx *priv = (struct cipher_priv_ctx *)vctx; int ret; @@ -952,7 +952,7 @@ static int uadk_prov_cipher_block_final(void *vctx, unsigned char *out, } static int uadk_prov_cipher_block_update(void *vctx, unsigned char *out, - int *outl, size_t outsize, + size_t *outl, size_t outsize, const unsigned char *in, size_t inl) { struct cipher_priv_ctx *priv = (struct cipher_priv_ctx *)vctx; @@ -974,7 +974,7 @@ static int uadk_prov_cipher_block_update(void *vctx, unsigned char *out, } static int uadk_prov_cipher_stream_update(void *vctx, unsigned char *out, - int *outl, size_t outsize, + size_t *outl, size_t outsize, const unsigned char *in, size_t inl) { struct cipher_priv_ctx *priv = (struct cipher_priv_ctx *)vctx; @@ -1024,7 +1024,7 @@ do_soft: } static int uadk_prov_cipher_stream_final(void *vctx, unsigned char *out, - int *outl, size_t outsize) + size_t *outl, size_t outsize) { struct cipher_priv_ctx *priv = (struct cipher_priv_ctx *)vctx; -- 2.33.0

1 0

[PATCH 0/8] add new algs for uadk_prov
by Qi Tao 27 Nov '24

27 Nov '24

*** BLURB HERE *** Chenghai Huang (2): uadk_provider: add aead alg for uadk_provider in openssl3.0 uadk_provider: fixed the variable type inconsistency issue Weili Qian (4): uadk_provider: move functions to uadk_prov_pkey.c uadk_provider: add query_operation_name callback for keymgmt uadk_provider: support ec keymgmt hardware acceleration uadk_provider: support ecdh keyexch hardware acceleration Zhiqi Song (1): uadk_provider: support x448 alg lizhi (1): uadk_engine: Clear some compilation warnings, specific cleanup is as follows. src/Makefile.am | 4 +- src/uadk_prov.h | 12 +- src/uadk_prov_aead.c | 1028 ++++++++++++++++++++++++++++++++ src/uadk_prov_bio.c | 2 + src/uadk_prov_cipher.c | 28 +- src/uadk_prov_der_writer.c | 2 +- src/uadk_prov_dh.c | 17 +- src/uadk_prov_ec_kmgmt.c | 782 ++++++++++++++++++++++++ src/uadk_prov_ecdh_exch.c | 965 ++++++++++++++++++++++++++++++ src/uadk_prov_ecx.c | 1145 ++++++++++++++++++++++++++++++++++++ src/uadk_prov_ffc.c | 24 +- src/uadk_prov_ffc.h | 1 - src/uadk_prov_init.c | 24 +- src/uadk_prov_pkey.c | 109 +++- src/uadk_prov_pkey.h | 28 +- src/uadk_prov_rsa.c | 8 + src/uadk_prov_sm2.c | 71 +-- 17 files changed, 4145 insertions(+), 105 deletions(-) create mode 100644 src/uadk_prov_aead.c create mode 100644 src/uadk_prov_ec_kmgmt.c create mode 100644 src/uadk_prov_ecdh_exch.c create mode 100644 src/uadk_prov_ecx.c -- 2.33.0

1 9

【2024/11/27 AccLIb SIG 双周例会 11:00 - 12:00】
by openEuler conference 26 Nov '24

26 Nov '24

您好！ sig-AccLib 邀请您参加 2024-11-27 11:00 召开的Zoom会议会议主题：【2024/11/27 AccLIb SIG 双周例会 11:00 - 12:00】会议内容：会议链接：linaro-org.zoom.us/j/91879279131 会议纪要：etherpad.openeuler.org/p/sig-AccLib-meetings 会议链接：https://us06web.zoom.us/j/89022246024?pwd=GrFAG6Ko1v0NRvb73If2PnKJ401Tet.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 2024-11-27 11:00, The subject of the conference is 【2024/11/27 AccLIb SIG 双周例会 11:00 - 12:00】, Summary: 会议链接：linaro-org.zoom.us/j/91879279131 会议纪要：etherpad.openeuler.org/p/sig-AccLib-meetings You can join the meeting at https://us06web.zoom.us/j/89022246024?pwd=GrFAG6Ko1v0NRvb73If2PnKJ401Tet.1. Add topics at https://etherpad.openeuler.org/p/sig-AccLib-meetings. More information: https://www.openeuler.org/en/

1 0

[PATCH 00/15] uadk_tool: add comp test
by Qi Tao 21 Nov '24

21 Nov '24

*** BLURB HERE *** Hao Fang (14): uadk_tool: test: change the comp_test directory to uadk_tool uadk_tool: test: unified the log print uadk_tool: test: remove comp test unused cmd uadk_tool: test: comp test remove the --ilist/olist cmd uadk_tool: test: remove unuse functions in comp_lib.h uadk_tool: test: reduce duplicate code in hw_blk_compress uadk_tool: test: comp test remove poll_thread_func uadk_tool: test: comp test remove the number in function name uadk_tool: test: comp test remove the batch mode uadk_tool: test: comp test remove the send_thread_func uadk_tool: comp test: move info.in_buf alloction into create_send_tdata uadk_tool: comp test: simplified the test_hw function uadk_tool: comp test: unified the test cmd format uadk_tool: comp test: some fixes found with checkpatch Qi Tao (1): uadk_tool: fix error in saving the aead dst data uadk_tool/Makefile.am | 11 +- uadk_tool/benchmark/sec_uadk_benchmark.c | 6 + uadk_tool/benchmark/uadk_benchmark.h | 2 +- uadk_tool/test/comp_lib.c | 1410 ++++++++++++++++++++++ uadk_tool/test/comp_lib.h | 300 +++++ uadk_tool/test/comp_main.c | 1393 +++++++++++++++++++++ uadk_tool/test/comp_main.h | 11 + uadk_tool/test/uadk_test.c | 8 +- 8 files changed, 3133 insertions(+), 8 deletions(-) create mode 100644 uadk_tool/test/comp_lib.c create mode 100644 uadk_tool/test/comp_lib.h create mode 100644 uadk_tool/test/comp_main.c create mode 100644 uadk_tool/test/comp_main.h -- 2.33.0

1 15

[PATCH 00/15] add comp test
by Qi Tao 21 Nov '24

21 Nov '24

*** BLURB HERE *** Hao Fang (14): uadk_tool: test: change the comp_test directory to uadk_tool uadk_tool: test: unified the log print uadk_tool: test: remove comp test unused cmd uadk_tool: test: comp test remove the --ilist/olist cmd uadk_tool: test: remove unuse functions in comp_lib.h uadk_tool: test: reduce duplicate code in hw_blk_compress uadk_tool: test: comp test remove poll_thread_func uadk_tool: test: comp test remove the number in function name uadk_tool: test: comp test remove the batch mode uadk_tool: test: comp test remove the send_thread_func uadk_tool: comp test: move info.in_buf alloction into create_send_tdata uadk_tool: comp test: simplified the test_hw function uadk_tool: comp test: unified the test cmd format uadk_tool: comp test: some fixes found with checkpatch Qi Tao (1): uadk_tool: fix error in saving the aead dst data uadk_tool/Makefile.am | 11 +- uadk_tool/benchmark/sec_uadk_benchmark.c | 6 + uadk_tool/benchmark/uadk_benchmark.h | 2 +- uadk_tool/test/comp_lib.c | 1410 ++++++++++++++++++++++ uadk_tool/test/comp_lib.h | 300 +++++ uadk_tool/test/comp_main.c | 1393 +++++++++++++++++++++ uadk_tool/test/comp_main.h | 11 + uadk_tool/test/uadk_test.c | 8 +- 8 files changed, 3133 insertions(+), 8 deletions(-) create mode 100644 uadk_tool/test/comp_lib.c create mode 100644 uadk_tool/test/comp_lib.h create mode 100644 uadk_tool/test/comp_main.c create mode 100644 uadk_tool/test/comp_main.h -- 2.33.0

1 15

2024/11/13 AccLIb SIG 双周例会 11:00 - 12:00
by openEuler conference 12 Nov '24

12 Nov '24

您好！ sig-AccLib 邀请您参加 2024-11-13 11:00 召开的Zoom会议会议主题：2024/11/13 AccLIb SIG 双周例会 11:00 - 12:00 会议内容：【2024/11/13 AccLIb SIG 双周例会 11:00 - 12:00】会议链接：linaro-org.zoom.us/j/91879279131 会议纪要：https 会议链接：https://us06web.zoom.us/j/88376532953?pwd=kka7dbzWQYpWW0eYHW8ia76IfrMOx5.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 2024-11-13 11:00, The subject of the conference is 2024/11/13 AccLIb SIG 双周例会 11:00 - 12:00, Summary: 【2024/11/13 AccLIb SIG 双周例会 11:00 - 12:00】会议链接：linaro-org.zoom.us/j/91879279131 会议纪要：https You can join the meeting at https://us06web.zoom.us/j/88376532953?pwd=kka7dbzWQYpWW0eYHW8ia76IfrMOx5.1. Add topics at https://etherpad.openeuler.org/p/sig-AccLib-meetings. More information: https://www.openeuler.org/en/

1 0

[PATCH 1/2] uadk: fix for hashagg include files
by Qi Tao 01 Nov '24

01 Nov '24

A compilation error occurred because the wd_util.h is not an externally visible header file, so use wd.h and wd_alg_common.h here. Signed-off-by: Qi Tao <taoqi10(a)huawei.com> --- include/drv/wd_agg_drv.h | 1 + include/wd_agg.h | 1 - include/wd_dae.h | 1 + 3 files changed, 2 insertions(+), 1 deletion(-) diff --git a/include/drv/wd_agg_drv.h b/include/drv/wd_agg_drv.h index cf99a704..3d26eeb3 100644 --- a/include/drv/wd_agg_drv.h +++ b/include/drv/wd_agg_drv.h @@ -8,6 +8,7 @@ #include <asm/types.h> #include "wd_agg.h" +#include "wd_util.h" #ifdef __cplusplus extern "C" { diff --git a/include/wd_agg.h b/include/wd_agg.h index e37023b5..aac3d406 100644 --- a/include/wd_agg.h +++ b/include/wd_agg.h @@ -8,7 +8,6 @@ #include <dlfcn.h> #include <asm/types.h> -#include "wd_util.h" #include "wd_dae.h" #ifdef __cplusplus diff --git a/include/wd_dae.h b/include/wd_dae.h index 5f22d90c..aa9f966c 100644 --- a/include/wd_dae.h +++ b/include/wd_dae.h @@ -9,6 +9,7 @@ #include <dlfcn.h> #include <stdbool.h> #include <asm/types.h> +#include "wd_alg_common.h" #include "wd.h" #ifdef __cplusplus -- 2.33.0

1 0

【2024/10/30 AccLIb SIG 双周例会 11:00 - 12:00】
by openEuler conference 29 Oct '24

29 Oct '24

您好！ sig-AccLib 邀请您参加 2024-10-30 11:00 召开的Zoom会议会议主题：【2024/10/30 AccLIb SIG 双周例会 11:00 - 12:00】会议内容：【2024/10/30 AccLIb SIG 双周例会 11:00 - 12:00】会议链接：linaro-org.zoom.us/j/91879279131 会议纪要：https 会议链接：https://us06web.zoom.us/j/87676404752?pwd=F3iZtD19sxQUxpK0AYLQHVMgx5ukg2.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 2024-10-30 11:00, The subject of the conference is 【2024/10/30 AccLIb SIG 双周例会 11:00 - 12:00】, Summary: 【2024/10/30 AccLIb SIG 双周例会 11:00 - 12:00】会议链接：linaro-org.zoom.us/j/91879279131 会议纪要：https You can join the meeting at https://us06web.zoom.us/j/87676404752?pwd=F3iZtD19sxQUxpK0AYLQHVMgx5ukg2.1. Add topics at https://etherpad.openeuler.org/p/sig-AccLib-meetings. More information: https://www.openeuler.org/en/

1 0

[PATCH v2 00/24] fix compile warming
by Qi Tao 21 Oct '24

21 Oct '24

*** BLURB HERE *** Chenghai Huang (15): uadk_provider: add input pointer length check for digest and cipher uadk_provider: code cleanup for provider bio uadk_provider: add length check for input pointer uadk_provider: add a timeout exit condition to the loop uadk_provider: code cleanup for uadk_provider and uadk_engine uadk_provider: add aes alg for uadk_provider in openssl3.0 uadk_engine: optimized engine update process uadk_provider: fix cipher issue when input len is 0 in decrypto update uadk_provider: fix the set ctx param function for ivlen and pad uadk_provider: fix the key and IV verification methods for cipher init uadk_provider: fix the switch condition issue of soft digest in engine uadk_provider: extract hardware initialization functions to separate functions uadk_provider: modify poll loop exit condition uadk_provider: add aes cts alg to uadk_provider in openssl3.0 uadk_provider: bugfix cipher decryption issue Qi Tao (2): uadk_prov: fix some cleancode issues and bugs for rsa uadk_prov: fix data type conversion errors Wenkai Lin (1): uadk_engine: remove update iv for cipher Zhiqi Song (6): uadk_provider: add openssl ffc library function uadk_provider: reconstructing dh implementation uadk_engine/ecx: merge some similar code logic uadk_engine: fixup pubkey size used in reverse operation uadk_provider/rsa: unify function definitions with macro uadk_provider/pkey: fixup functions with the same name src/Makefile.am | 3 +- src/uadk_async.c | 6 +- src/uadk_cipher.c | 114 +- src/uadk_digest.c | 41 +- src/uadk_ecx.c | 303 ++--- src/uadk_prov.h | 56 +- src/uadk_prov_bio.c | 19 +- src/uadk_prov_bio.h | 2 +- src/uadk_prov_cipher.c | 867 +++++++------ src/uadk_prov_dh.c | 2609 +++++++++++++++++++++------------------- src/uadk_prov_digest.c | 61 +- src/uadk_prov_ffc.c | 1888 +++++++++++++++++++++++++++++ src/uadk_prov_ffc.h | 330 +++++ src/uadk_prov_init.c | 46 +- src/uadk_prov_pkey.h | 114 +- src/uadk_prov_rsa.c | 1138 +++++++----------- src/uadk_prov_sm2.c | 94 +- 17 files changed, 5044 insertions(+), 2647 deletions(-) create mode 100644 src/uadk_prov_ffc.c create mode 100644 src/uadk_prov_ffc.h -- 2.33.0

1 24