motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-04 08:13:54 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

qapi/crypto: Rename QCryptoRSAPaddingAlgorithm to *Algo, and drop prefix

Browse source 
QAPI's 'prefix' feature can make the connection between enumeration
type and its constants less than obvious.  It's best used with
restraint.

QCryptoRSAPaddingAlgorithm has a 'prefix' that overrides the generated
enumeration constants' prefix to QCRYPTO_RSA_PADDING_ALG.

We could simply drop 'prefix', but then the prefix becomes
QCRYPTO_RSA_PADDING_ALGORITHM, which is rather long.

We could additionally rename the type to QCryptoRSAPaddingAlg, but I
think the abbreviation "alg" is less than clear.

Rename the type to QCryptoRSAPaddingAlgo instead.  The prefix becomes
QCRYPTO_RSA_PADDING_ALGO.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Daniel P. Berrangé <berrange@redhat.com>
Message-ID: <20240904111836.3273842-16-armbru@redhat.com>
This commit is contained in:
Markus Armbruster 2024-09-04 13:18:32 +02:00
parent cd48d82a50
commit c96050f43e
7 changed files with 41 additions and 42 deletions
Download patch file Download diff file Expand all files Collapse all files

6
backends/cryptodev-builtin.c
View file

@ -65,7 +65,7 @@ static void cryptodev_builtin_init_akcipher(CryptoDevBackend *backend)
QCryptoAkCipherOptions opts; QCryptoAkCipherOptions opts;
opts.alg = QCRYPTO_AK_CIPHER_ALGO_RSA; opts.alg = QCRYPTO_AK_CIPHER_ALGO_RSA;
opts.u.rsa.padding_alg = QCRYPTO_RSA_PADDING_ALG_RAW; opts.u.rsa.padding_alg = QCRYPTO_RSA_PADDING_ALGO_RAW;
if (qcrypto_akcipher_supports(&opts)) { if (qcrypto_akcipher_supports(&opts)) {
backend->conf.crypto_services |= backend->conf.crypto_services |=
(1u << QCRYPTODEV_BACKEND_SERVICE_AKCIPHER); (1u << QCRYPTODEV_BACKEND_SERVICE_AKCIPHER);
@ -200,12 +200,12 @@ static int cryptodev_builtin_set_rsa_options(
return -1; return -1;
} }
opt->hash_alg = hash_alg; opt->hash_alg = hash_alg;
opt->padding_alg = QCRYPTO_RSA_PADDING_ALG_PKCS1; opt->padding_alg = QCRYPTO_RSA_PADDING_ALGO_PKCS1;
return 0; return 0;
} }
if (virtio_padding_algo == VIRTIO_CRYPTO_RSA_RAW_PADDING) { if (virtio_padding_algo == VIRTIO_CRYPTO_RSA_RAW_PADDING) {
opt->padding_alg = QCRYPTO_RSA_PADDING_ALG_RAW; opt->padding_alg = QCRYPTO_RSA_PADDING_ALGO_RAW;
return 0; return 0;
} }

10
backends/cryptodev-lkcf.c
View file

@ -139,14 +139,14 @@ static int cryptodev_lkcf_set_op_desc(QCryptoAkCipherOptions *opts,
} }
rsa_opt = &opts->u.rsa; rsa_opt = &opts->u.rsa;
if (rsa_opt->padding_alg == QCRYPTO_RSA_PADDING_ALG_PKCS1) { if (rsa_opt->padding_alg == QCRYPTO_RSA_PADDING_ALGO_PKCS1) {
snprintf(key_desc, desc_len, "enc=%s hash=%s", snprintf(key_desc, desc_len, "enc=%s hash=%s",
QCryptoRSAPaddingAlgorithm_str(rsa_opt->padding_alg), QCryptoRSAPaddingAlgo_str(rsa_opt->padding_alg),
QCryptoHashAlgo_str(rsa_opt->hash_alg)); QCryptoHashAlgo_str(rsa_opt->hash_alg));
} else { } else {
snprintf(key_desc, desc_len, "enc=%s", snprintf(key_desc, desc_len, "enc=%s",
QCryptoRSAPaddingAlgorithm_str(rsa_opt->padding_alg)); QCryptoRSAPaddingAlgo_str(rsa_opt->padding_alg));
} }
return 0; return 0;
} }
@ -157,7 +157,7 @@ static int cryptodev_lkcf_set_rsa_opt(int virtio_padding_alg,
Error **errp) Error **errp)
{ {
if (virtio_padding_alg == VIRTIO_CRYPTO_RSA_PKCS1_PADDING) { if (virtio_padding_alg == VIRTIO_CRYPTO_RSA_PKCS1_PADDING) {
opt->padding_alg = QCRYPTO_RSA_PADDING_ALG_PKCS1; opt->padding_alg = QCRYPTO_RSA_PADDING_ALGO_PKCS1;
switch (virtio_hash_alg) { switch (virtio_hash_alg) {
case VIRTIO_CRYPTO_RSA_MD5: case VIRTIO_CRYPTO_RSA_MD5:
@ -184,7 +184,7 @@ static int cryptodev_lkcf_set_rsa_opt(int virtio_padding_alg,
} }
if (virtio_padding_alg == VIRTIO_CRYPTO_RSA_RAW_PADDING) { if (virtio_padding_alg == VIRTIO_CRYPTO_RSA_RAW_PADDING) {
opt->padding_alg = QCRYPTO_RSA_PADDING_ALG_RAW; opt->padding_alg = QCRYPTO_RSA_PADDING_ALGO_RAW;
return 0; return 0;
} }

18
crypto/akcipher-gcrypt.c.inc
View file

@ -32,7 +32,7 @@
typedef struct QCryptoGcryptRSA { typedef struct QCryptoGcryptRSA {
QCryptoAkCipher akcipher; QCryptoAkCipher akcipher;
gcry_sexp_t key; gcry_sexp_t key;
QCryptoRSAPaddingAlgorithm padding_alg; QCryptoRSAPaddingAlgo padding_alg;
QCryptoHashAlgo hash_alg; QCryptoHashAlgo hash_alg;
} QCryptoGcryptRSA; } QCryptoGcryptRSA;
@ -241,7 +241,7 @@ static int qcrypto_gcrypt_rsa_encrypt(QCryptoAkCipher *akcipher,
err = gcry_sexp_build(&data_sexp, NULL, err = gcry_sexp_build(&data_sexp, NULL,
"(data (flags %s) (value %b))", "(data (flags %s) (value %b))",
QCryptoRSAPaddingAlgorithm_str(rsa->padding_alg), QCryptoRSAPaddingAlgo_str(rsa->padding_alg),
in_len, in); in_len, in);
if (gcry_err_code(err) != 0) { if (gcry_err_code(err) != 0) {
error_setg(errp, "Failed to build plaintext: %s/%s", error_setg(errp, "Failed to build plaintext: %s/%s",
@ -263,7 +263,7 @@ static int qcrypto_gcrypt_rsa_encrypt(QCryptoAkCipher *akcipher,
goto cleanup; goto cleanup;
} }
if (rsa->padding_alg == QCRYPTO_RSA_PADDING_ALG_RAW) { if (rsa->padding_alg == QCRYPTO_RSA_PADDING_ALGO_RAW) {
cipher_mpi = gcry_sexp_nth_mpi(cipher_sexp_item, 1, GCRYMPI_FMT_USG); cipher_mpi = gcry_sexp_nth_mpi(cipher_sexp_item, 1, GCRYMPI_FMT_USG);
if (!cipher_mpi) { if (!cipher_mpi) {
error_setg(errp, "Invalid ciphertext result"); error_setg(errp, "Invalid ciphertext result");
@ -332,7 +332,7 @@ static int qcrypto_gcrypt_rsa_decrypt(QCryptoAkCipher *akcipher,
err = gcry_sexp_build(&cipher_sexp, NULL, err = gcry_sexp_build(&cipher_sexp, NULL,
"(enc-val (flags %s) (rsa (a %b) ))", "(enc-val (flags %s) (rsa (a %b) ))",
QCryptoRSAPaddingAlgorithm_str(rsa->padding_alg), QCryptoRSAPaddingAlgo_str(rsa->padding_alg),
in_len, in); in_len, in);
if (gcry_err_code(err) != 0) { if (gcry_err_code(err) != 0) {
error_setg(errp, "Failed to build ciphertext: %s/%s", error_setg(errp, "Failed to build ciphertext: %s/%s",
@ -348,7 +348,7 @@ static int qcrypto_gcrypt_rsa_decrypt(QCryptoAkCipher *akcipher,
} }
/* S-expression of plaintext: (value plaintext) */ /* S-expression of plaintext: (value plaintext) */
if (rsa->padding_alg == QCRYPTO_RSA_PADDING_ALG_RAW) { if (rsa->padding_alg == QCRYPTO_RSA_PADDING_ALGO_RAW) {
data_mpi = gcry_sexp_nth_mpi(data_sexp, 1, GCRYMPI_FMT_USG); data_mpi = gcry_sexp_nth_mpi(data_sexp, 1, GCRYMPI_FMT_USG);
if (!data_mpi) { if (!data_mpi) {
error_setg(errp, "Invalid plaintext result"); error_setg(errp, "Invalid plaintext result");
@ -410,7 +410,7 @@ static int qcrypto_gcrypt_rsa_sign(QCryptoAkCipher *akcipher,
return ret; return ret;
} }
if (rsa->padding_alg != QCRYPTO_RSA_PADDING_ALG_PKCS1) { if (rsa->padding_alg != QCRYPTO_RSA_PADDING_ALGO_PKCS1) {
error_setg(errp, "Invalid padding %u", rsa->padding_alg); error_setg(errp, "Invalid padding %u", rsa->padding_alg);
return ret; return ret;
} }
@ -482,7 +482,7 @@ static int qcrypto_gcrypt_rsa_verify(QCryptoAkCipher *akcipher,
return ret; return ret;
} }
if (rsa->padding_alg != QCRYPTO_RSA_PADDING_ALG_PKCS1) { if (rsa->padding_alg != QCRYPTO_RSA_PADDING_ALGO_PKCS1) {
error_setg(errp, "Invalid padding %u", rsa->padding_alg); error_setg(errp, "Invalid padding %u", rsa->padding_alg);
return ret; return ret;
} }
@ -570,10 +570,10 @@ bool qcrypto_akcipher_supports(QCryptoAkCipherOptions *opts)
switch (opts->alg) { switch (opts->alg) {
case QCRYPTO_AK_CIPHER_ALGO_RSA: case QCRYPTO_AK_CIPHER_ALGO_RSA:
switch (opts->u.rsa.padding_alg) { switch (opts->u.rsa.padding_alg) {
case QCRYPTO_RSA_PADDING_ALG_RAW: case QCRYPTO_RSA_PADDING_ALGO_RAW:
return true; return true;
case QCRYPTO_RSA_PADDING_ALG_PKCS1: case QCRYPTO_RSA_PADDING_ALGO_PKCS1:
switch (opts->u.rsa.hash_alg) { switch (opts->u.rsa.hash_alg) {
case QCRYPTO_HASH_ALGO_MD5: case QCRYPTO_HASH_ALGO_MD5:
case QCRYPTO_HASH_ALGO_SHA1: case QCRYPTO_HASH_ALGO_SHA1:

18
crypto/akcipher-nettle.c.inc
View file

@ -33,7 +33,7 @@ typedef struct QCryptoNettleRSA {
QCryptoAkCipher akcipher; QCryptoAkCipher akcipher;
struct rsa_public_key pub; struct rsa_public_key pub;
struct rsa_private_key priv; struct rsa_private_key priv;
QCryptoRSAPaddingAlgorithm padding_alg; QCryptoRSAPaddingAlgo padding_alg;
QCryptoHashAlgo hash_alg; QCryptoHashAlgo hash_alg;
} QCryptoNettleRSA; } QCryptoNettleRSA;
@ -184,11 +184,11 @@ static int qcrypto_nettle_rsa_encrypt(QCryptoAkCipher *akcipher,
/* Nettle do not support RSA encryption without any padding */ /* Nettle do not support RSA encryption without any padding */
switch (rsa->padding_alg) { switch (rsa->padding_alg) {
case QCRYPTO_RSA_PADDING_ALG_RAW: case QCRYPTO_RSA_PADDING_ALGO_RAW:
error_setg(errp, "RSA with raw padding is not supported"); error_setg(errp, "RSA with raw padding is not supported");
break; break;
case QCRYPTO_RSA_PADDING_ALG_PKCS1: case QCRYPTO_RSA_PADDING_ALGO_PKCS1:
mpz_init(c); mpz_init(c);
if (rsa_encrypt(&rsa->pub, NULL, wrap_nettle_random_func, if (rsa_encrypt(&rsa->pub, NULL, wrap_nettle_random_func,
data_len, (uint8_t *)data, c) != 1) { data_len, (uint8_t *)data, c) != 1) {
@ -223,11 +223,11 @@ static int qcrypto_nettle_rsa_decrypt(QCryptoAkCipher *akcipher,
} }
switch (rsa->padding_alg) { switch (rsa->padding_alg) {
case QCRYPTO_RSA_PADDING_ALG_RAW: case QCRYPTO_RSA_PADDING_ALGO_RAW:
error_setg(errp, "RSA with raw padding is not supported"); error_setg(errp, "RSA with raw padding is not supported");
break; break;
case QCRYPTO_RSA_PADDING_ALG_PKCS1: case QCRYPTO_RSA_PADDING_ALGO_PKCS1:
nettle_mpz_init_set_str_256_u(c, enc_len, enc); nettle_mpz_init_set_str_256_u(c, enc_len, enc);
if (!rsa_decrypt(&rsa->priv, &data_len, (uint8_t *)data, c)) { if (!rsa_decrypt(&rsa->priv, &data_len, (uint8_t *)data, c)) {
error_setg(errp, "Failed to decrypt"); error_setg(errp, "Failed to decrypt");
@ -257,7 +257,7 @@ static int qcrypto_nettle_rsa_sign(QCryptoAkCipher *akcipher,
* The RSA algorithm cannot be used for signature/verification * The RSA algorithm cannot be used for signature/verification
* without padding. * without padding.
*/ */
if (rsa->padding_alg == QCRYPTO_RSA_PADDING_ALG_RAW) { if (rsa->padding_alg == QCRYPTO_RSA_PADDING_ALGO_RAW) {
error_setg(errp, "Try to make signature without padding"); error_setg(errp, "Try to make signature without padding");
return ret; return ret;
} }
@ -324,7 +324,7 @@ static int qcrypto_nettle_rsa_verify(QCryptoAkCipher *akcipher,
* The RSA algorithm cannot be used for signature/verification * The RSA algorithm cannot be used for signature/verification
* without padding. * without padding.
*/ */
if (rsa->padding_alg == QCRYPTO_RSA_PADDING_ALG_RAW) { if (rsa->padding_alg == QCRYPTO_RSA_PADDING_ALGO_RAW) {
error_setg(errp, "Try to verify signature without padding"); error_setg(errp, "Try to verify signature without padding");
return ret; return ret;
} }
@ -427,7 +427,7 @@ bool qcrypto_akcipher_supports(QCryptoAkCipherOptions *opts)
switch (opts->alg) { switch (opts->alg) {
case QCRYPTO_AK_CIPHER_ALGO_RSA: case QCRYPTO_AK_CIPHER_ALGO_RSA:
switch (opts->u.rsa.padding_alg) { switch (opts->u.rsa.padding_alg) {
case QCRYPTO_RSA_PADDING_ALG_PKCS1: case QCRYPTO_RSA_PADDING_ALGO_PKCS1:
switch (opts->u.rsa.hash_alg) { switch (opts->u.rsa.hash_alg) {
case QCRYPTO_HASH_ALGO_MD5: case QCRYPTO_HASH_ALGO_MD5:
case QCRYPTO_HASH_ALGO_SHA1: case QCRYPTO_HASH_ALGO_SHA1:
@ -439,7 +439,7 @@ bool qcrypto_akcipher_supports(QCryptoAkCipherOptions *opts)
return false; return false;
} }
case QCRYPTO_RSA_PADDING_ALG_RAW: case QCRYPTO_RSA_PADDING_ALGO_RAW:
default: default:
return false; return false;
} }

9
qapi/crypto.json
View file

@ -608,7 +608,7 @@
'data': ['public', 'private']} 'data': ['public', 'private']}
## ##
# @QCryptoRSAPaddingAlgorithm: # @QCryptoRSAPaddingAlgo:
# #
# The padding algorithm for RSA. # The padding algorithm for RSA.
# #
@ -618,8 +618,7 @@
# #
# Since: 7.1 # Since: 7.1
## ##
{ 'enum': 'QCryptoRSAPaddingAlgorithm', { 'enum': 'QCryptoRSAPaddingAlgo',
'prefix': 'QCRYPTO_RSA_PADDING_ALG',
'data': ['raw', 'pkcs1']} 'data': ['raw', 'pkcs1']}
## ##
@ -629,13 +628,13 @@
# #
# @hash-alg: QCryptoHashAlgo # @hash-alg: QCryptoHashAlgo
# #
# @padding-alg: QCryptoRSAPaddingAlgorithm # @padding-alg: QCryptoRSAPaddingAlgo
# #
# Since: 7.1 # Since: 7.1
## ##
{ 'struct': 'QCryptoAkCipherOptionsRSA', { 'struct': 'QCryptoAkCipherOptionsRSA',
'data': { 'hash-alg':'QCryptoHashAlgo', 'data': { 'hash-alg':'QCryptoHashAlgo',
'padding-alg': 'QCryptoRSAPaddingAlgorithm'}} 'padding-alg': 'QCryptoRSAPaddingAlgo'}}
## ##
# @QCryptoAkCipherOptions: # @QCryptoAkCipherOptions:

12
tests/bench/benchmark-crypto-akcipher.c
View file

@ -20,7 +20,7 @@
static QCryptoAkCipher *create_rsa_akcipher(const uint8_t *priv_key, static QCryptoAkCipher *create_rsa_akcipher(const uint8_t *priv_key,
size_t keylen, size_t keylen,
QCryptoRSAPaddingAlgorithm padding, QCryptoRSAPaddingAlgo padding,
QCryptoHashAlgo hash) QCryptoHashAlgo hash)
{ {
QCryptoAkCipherOptions opt; QCryptoAkCipherOptions opt;
@ -39,7 +39,7 @@ static void test_rsa_speed(const uint8_t *priv_key, size_t keylen,
#define SHA1_DGST_LEN 20 #define SHA1_DGST_LEN 20
#define SIGN_TIMES 10000 #define SIGN_TIMES 10000
#define VERIFY_TIMES 100000 #define VERIFY_TIMES 100000
#define PADDING QCRYPTO_RSA_PADDING_ALG_PKCS1 #define PADDING QCRYPTO_RSA_PADDING_ALGO_PKCS1
#define HASH QCRYPTO_HASH_ALGO_SHA1 #define HASH QCRYPTO_HASH_ALGO_SHA1
g_autoptr(QCryptoAkCipher) rsa = g_autoptr(QCryptoAkCipher) rsa =
@ -53,7 +53,7 @@ static void test_rsa_speed(const uint8_t *priv_key, size_t keylen,
signature = g_new0(uint8_t, key_size / BYTE); signature = g_new0(uint8_t, key_size / BYTE);
g_test_message("benchmark rsa%zu (%s-%s) sign...", key_size, g_test_message("benchmark rsa%zu (%s-%s) sign...", key_size,
QCryptoRSAPaddingAlgorithm_str(PADDING), QCryptoRSAPaddingAlgo_str(PADDING),
QCryptoHashAlgo_str(HASH)); QCryptoHashAlgo_str(HASH));
g_test_timer_start(); g_test_timer_start();
for (count = 0; count < SIGN_TIMES; ++count) { for (count = 0; count < SIGN_TIMES; ++count) {
@ -64,13 +64,13 @@ static void test_rsa_speed(const uint8_t *priv_key, size_t keylen,
g_test_timer_elapsed(); g_test_timer_elapsed();
g_test_message("rsa%zu (%s-%s) sign %zu times in %.2f seconds," g_test_message("rsa%zu (%s-%s) sign %zu times in %.2f seconds,"
" %.2f times/sec ", " %.2f times/sec ",
key_size, QCryptoRSAPaddingAlgorithm_str(PADDING), key_size, QCryptoRSAPaddingAlgo_str(PADDING),
QCryptoHashAlgo_str(HASH), QCryptoHashAlgo_str(HASH),
count, g_test_timer_last(), count, g_test_timer_last(),
(double)count / g_test_timer_last()); (double)count / g_test_timer_last());
g_test_message("benchmark rsa%zu (%s-%s) verification...", key_size, g_test_message("benchmark rsa%zu (%s-%s) verification...", key_size,
QCryptoRSAPaddingAlgorithm_str(PADDING), QCryptoRSAPaddingAlgo_str(PADDING),
QCryptoHashAlgo_str(HASH)); QCryptoHashAlgo_str(HASH));
g_test_timer_start(); g_test_timer_start();
for (count = 0; count < VERIFY_TIMES; ++count) { for (count = 0; count < VERIFY_TIMES; ++count) {
@ -81,7 +81,7 @@ static void test_rsa_speed(const uint8_t *priv_key, size_t keylen,
g_test_timer_elapsed(); g_test_timer_elapsed();
g_test_message("rsa%zu (%s-%s) verify %zu times in %.2f seconds," g_test_message("rsa%zu (%s-%s) verify %zu times in %.2f seconds,"
" %.2f times/sec ", " %.2f times/sec ",
key_size, QCryptoRSAPaddingAlgorithm_str(PADDING), key_size, QCryptoRSAPaddingAlgo_str(PADDING),
QCryptoHashAlgo_str(HASH), QCryptoHashAlgo_str(HASH),
count, g_test_timer_last(), count, g_test_timer_last(),
(double)count / g_test_timer_last()); (double)count / g_test_timer_last());

10
tests/unit/test-crypto-akcipher.c
View file

@ -787,7 +787,7 @@ static QCryptoAkCipherTestData akcipher_test_data[] = {
.opt = { .opt = {
.alg = QCRYPTO_AK_CIPHER_ALGO_RSA, .alg = QCRYPTO_AK_CIPHER_ALGO_RSA,
.u.rsa = { .u.rsa = {
.padding_alg = QCRYPTO_RSA_PADDING_ALG_RAW, .padding_alg = QCRYPTO_RSA_PADDING_ALGO_RAW,
}, },
}, },
.pub_key = rsa1024_public_key, .pub_key = rsa1024_public_key,
@ -807,7 +807,7 @@ static QCryptoAkCipherTestData akcipher_test_data[] = {
.opt = { .opt = {
.alg = QCRYPTO_AK_CIPHER_ALGO_RSA, .alg = QCRYPTO_AK_CIPHER_ALGO_RSA,
.u.rsa = { .u.rsa = {
.padding_alg = QCRYPTO_RSA_PADDING_ALG_PKCS1, .padding_alg = QCRYPTO_RSA_PADDING_ALGO_PKCS1,
.hash_alg = QCRYPTO_HASH_ALGO_SHA1, .hash_alg = QCRYPTO_HASH_ALGO_SHA1,
}, },
}, },
@ -832,7 +832,7 @@ static QCryptoAkCipherTestData akcipher_test_data[] = {
.opt = { .opt = {
.alg = QCRYPTO_AK_CIPHER_ALGO_RSA, .alg = QCRYPTO_AK_CIPHER_ALGO_RSA,
.u.rsa = { .u.rsa = {
.padding_alg = QCRYPTO_RSA_PADDING_ALG_RAW, .padding_alg = QCRYPTO_RSA_PADDING_ALGO_RAW,
}, },
}, },
.pub_key = rsa2048_public_key, .pub_key = rsa2048_public_key,
@ -852,7 +852,7 @@ static QCryptoAkCipherTestData akcipher_test_data[] = {
.opt = { .opt = {
.alg = QCRYPTO_AK_CIPHER_ALGO_RSA, .alg = QCRYPTO_AK_CIPHER_ALGO_RSA,
.u.rsa = { .u.rsa = {
.padding_alg = QCRYPTO_RSA_PADDING_ALG_PKCS1, .padding_alg = QCRYPTO_RSA_PADDING_ALGO_PKCS1,
.hash_alg = QCRYPTO_HASH_ALGO_SHA1, .hash_alg = QCRYPTO_HASH_ALGO_SHA1,
}, },
}, },
@ -946,7 +946,7 @@ static void test_rsakey(const void *opaque)
QCryptoAkCipherOptions opt = { QCryptoAkCipherOptions opt = {
.alg = QCRYPTO_AK_CIPHER_ALGO_RSA, .alg = QCRYPTO_AK_CIPHER_ALGO_RSA,
.u.rsa = { .u.rsa = {
.padding_alg = QCRYPTO_RSA_PADDING_ALG_PKCS1, .padding_alg = QCRYPTO_RSA_PADDING_ALGO_PKCS1,
.hash_alg = QCRYPTO_HASH_ALGO_SHA1, .hash_alg = QCRYPTO_HASH_ALGO_SHA1,
} }
}; };