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

qapi/crypto: Drop unwanted '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.

QCryptoAkCipherKeyType has a 'prefix' that overrides the generated
enumeration constants' prefix to QCRYPTO_AKCIPHER_KEY_TYPE.

Drop it.  The prefix becomes QCRYPTO_AK_CIPHER_KEY_TYPE.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Daniel P. Berrangé <berrange@redhat.com>
Message-ID: <20240904111836.3273842-11-armbru@redhat.com>
This commit is contained in:
Markus Armbruster 2024-09-04 13:18:27 +02:00
parent 32cfefb904
commit 5f4059ef33
9 changed files with 32 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

4
backends/cryptodev-builtin.c
View file

@ -334,11 +334,11 @@ static int cryptodev_builtin_create_akcipher_session(
switch (sess_info->keytype) { switch (sess_info->keytype) {
case VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PUBLIC: case VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PUBLIC:
type = QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC; type = QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC;
break; break;
case VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PRIVATE: case VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PRIVATE:
type = QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE; type = QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE;
break; break;
default: default:

6
backends/cryptodev-lkcf.c
View file

@ -322,7 +322,7 @@ static void cryptodev_lkcf_execute_task(CryptoDevLKCFTask *task)
* 2. generally, public key related compution is fast, just compute it with * 2. generally, public key related compution is fast, just compute it with
* thread-pool. * thread-pool.
*/ */
if (session->keytype == QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE) { if (session->keytype == QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE) {
if (qcrypto_akcipher_export_p8info(&session->akcipher_opts, if (qcrypto_akcipher_export_p8info(&session->akcipher_opts,
session->key, session->keylen, session->key, session->keylen,
&p8info, &p8info_len, &p8info, &p8info_len,
@ -534,11 +534,11 @@ static int cryptodev_lkcf_create_asym_session(
switch (sess_info->keytype) { switch (sess_info->keytype) {
case VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PUBLIC: case VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PUBLIC:
sess->keytype = QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC; sess->keytype = QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC;
break; break;
case VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PRIVATE: case VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PRIVATE:
sess->keytype = QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE; sess->keytype = QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE;
break; break;
default: default:

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

@ -85,7 +85,7 @@ static int qcrypto_gcrypt_parse_rsa_private_key(
const uint8_t *key, size_t keylen, Error **errp) const uint8_t *key, size_t keylen, Error **errp)
{ {
g_autoptr(QCryptoAkCipherRSAKey) rsa_key = qcrypto_akcipher_rsakey_parse( g_autoptr(QCryptoAkCipherRSAKey) rsa_key = qcrypto_akcipher_rsakey_parse(
QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE, key, keylen, errp); QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE, key, keylen, errp);
gcry_mpi_t n = NULL, e = NULL, d = NULL, p = NULL, q = NULL, u = NULL; gcry_mpi_t n = NULL, e = NULL, d = NULL, p = NULL, q = NULL, u = NULL;
bool compute_mul_inv = false; bool compute_mul_inv = false;
int ret = -1; int ret = -1;
@ -178,7 +178,7 @@ static int qcrypto_gcrypt_parse_rsa_public_key(QCryptoGcryptRSA *rsa,
{ {
g_autoptr(QCryptoAkCipherRSAKey) rsa_key = qcrypto_akcipher_rsakey_parse( g_autoptr(QCryptoAkCipherRSAKey) rsa_key = qcrypto_akcipher_rsakey_parse(
QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC, key, keylen, errp); QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC, key, keylen, errp);
gcry_mpi_t n = NULL, e = NULL; gcry_mpi_t n = NULL, e = NULL;
int ret = -1; int ret = -1;
gcry_error_t err; gcry_error_t err;
@ -540,13 +540,13 @@ static QCryptoGcryptRSA *qcrypto_gcrypt_rsa_new(
rsa->akcipher.driver = &gcrypt_rsa; rsa->akcipher.driver = &gcrypt_rsa;
switch (type) { switch (type) {
case QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE: case QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE:
if (qcrypto_gcrypt_parse_rsa_private_key(rsa, key, keylen, errp) != 0) { if (qcrypto_gcrypt_parse_rsa_private_key(rsa, key, keylen, errp) != 0) {
goto error; goto error;
} }
break; break;
case QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC: case QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC:
if (qcrypto_gcrypt_parse_rsa_public_key(rsa, key, keylen, errp) != 0) { if (qcrypto_gcrypt_parse_rsa_public_key(rsa, key, keylen, errp) != 0) {
goto error; goto error;
} }

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

@ -87,7 +87,7 @@ static int qcrypt_nettle_parse_rsa_private_key(QCryptoNettleRSA *rsa,
Error **errp) Error **errp)
{ {
g_autoptr(QCryptoAkCipherRSAKey) rsa_key = qcrypto_akcipher_rsakey_parse( g_autoptr(QCryptoAkCipherRSAKey) rsa_key = qcrypto_akcipher_rsakey_parse(
QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE, key, keylen, errp); QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE, key, keylen, errp);
if (!rsa_key) { if (!rsa_key) {
return -1; return -1;
@ -137,7 +137,7 @@ static int qcrypt_nettle_parse_rsa_public_key(QCryptoNettleRSA *rsa,
Error **errp) Error **errp)
{ {
g_autoptr(QCryptoAkCipherRSAKey) rsa_key = qcrypto_akcipher_rsakey_parse( g_autoptr(QCryptoAkCipherRSAKey) rsa_key = qcrypto_akcipher_rsakey_parse(
QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC, key, keylen, errp); QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC, key, keylen, errp);
if (!rsa_key) { if (!rsa_key) {
return -1; return -1;
@ -397,13 +397,13 @@ static QCryptoAkCipher *qcrypto_nettle_rsa_new(
rsa_private_key_init(&rsa->priv); rsa_private_key_init(&rsa->priv);
switch (type) { switch (type) {
case QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE: case QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE:
if (qcrypt_nettle_parse_rsa_private_key(rsa, key, keylen, errp) != 0) { if (qcrypt_nettle_parse_rsa_private_key(rsa, key, keylen, errp) != 0) {
goto error; goto error;
} }
break; break;
case QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC: case QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC:
if (qcrypt_nettle_parse_rsa_public_key(rsa, key, keylen, errp) != 0) { if (qcrypt_nettle_parse_rsa_public_key(rsa, key, keylen, errp) != 0) {
goto error; goto error;
} }

4
crypto/rsakey-builtin.c.inc
View file

@ -183,10 +183,10 @@ QCryptoAkCipherRSAKey *qcrypto_akcipher_rsakey_parse(
size_t keylen, Error **errp) size_t keylen, Error **errp)
{ {
switch (type) { switch (type) {
case QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE: case QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE:
return qcrypto_builtin_rsa_private_key_parse(key, keylen, errp); return qcrypto_builtin_rsa_private_key_parse(key, keylen, errp);
case QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC: case QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC:
return qcrypto_builtin_rsa_public_key_parse(key, keylen, errp); return qcrypto_builtin_rsa_public_key_parse(key, keylen, errp);
default: default:

4
crypto/rsakey-nettle.c.inc
View file

@ -145,10 +145,10 @@ QCryptoAkCipherRSAKey *qcrypto_akcipher_rsakey_parse(
size_t keylen, Error **errp) size_t keylen, Error **errp)
{ {
switch (type) { switch (type) {
case QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE: case QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE:
return qcrypto_nettle_rsa_private_key_parse(key, keylen, errp); return qcrypto_nettle_rsa_private_key_parse(key, keylen, errp);
case QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC: case QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC:
return qcrypto_nettle_rsa_public_key_parse(key, keylen, errp); return qcrypto_nettle_rsa_public_key_parse(key, keylen, errp);
default: default:

1
qapi/crypto.json
View file

@ -609,7 +609,6 @@
# Since: 7.1 # Since: 7.1
## ##
{ 'enum': 'QCryptoAkCipherKeyType', { 'enum': 'QCryptoAkCipherKeyType',
'prefix': 'QCRYPTO_AKCIPHER_KEY_TYPE',
'data': ['public', 'private']} 'data': ['public', 'private']}
## ##

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

@ -28,7 +28,7 @@ static QCryptoAkCipher *create_rsa_akcipher(const uint8_t *priv_key,
opt.alg = QCRYPTO_AKCIPHER_ALG_RSA; opt.alg = QCRYPTO_AKCIPHER_ALG_RSA;
opt.u.rsa.padding_alg = padding; opt.u.rsa.padding_alg = padding;
opt.u.rsa.hash_alg = hash; opt.u.rsa.hash_alg = hash;
return qcrypto_akcipher_new(&opt, QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE, return qcrypto_akcipher_new(&opt, QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE,
priv_key, keylen, &error_abort); priv_key, keylen, &error_abort);
} }

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

@ -692,7 +692,7 @@ struct QCryptoAkCipherTestData {
static QCryptoRSAKeyTestData rsakey_test_data[] = { static QCryptoRSAKeyTestData rsakey_test_data[] = {
{ {
.path = "/crypto/akcipher/rsakey-1024-public", .path = "/crypto/akcipher/rsakey-1024-public",
.key_type = QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC, .key_type = QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC,
.key = rsa1024_public_key, .key = rsa1024_public_key,
.keylen = sizeof(rsa1024_public_key), .keylen = sizeof(rsa1024_public_key),
.is_valid_key = true, .is_valid_key = true,
@ -700,7 +700,7 @@ static QCryptoRSAKeyTestData rsakey_test_data[] = {
}, },
{ {
.path = "/crypto/akcipher/rsakey-1024-private", .path = "/crypto/akcipher/rsakey-1024-private",
.key_type = QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE, .key_type = QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE,
.key = rsa1024_private_key, .key = rsa1024_private_key,
.keylen = sizeof(rsa1024_private_key), .keylen = sizeof(rsa1024_private_key),
.is_valid_key = true, .is_valid_key = true,
@ -708,7 +708,7 @@ static QCryptoRSAKeyTestData rsakey_test_data[] = {
}, },
{ {
.path = "/crypto/akcipher/rsakey-2048-public", .path = "/crypto/akcipher/rsakey-2048-public",
.key_type = QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC, .key_type = QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC,
.key = rsa2048_public_key, .key = rsa2048_public_key,
.keylen = sizeof(rsa2048_public_key), .keylen = sizeof(rsa2048_public_key),
.is_valid_key = true, .is_valid_key = true,
@ -716,7 +716,7 @@ static QCryptoRSAKeyTestData rsakey_test_data[] = {
}, },
{ {
.path = "/crypto/akcipher/rsakey-2048-private", .path = "/crypto/akcipher/rsakey-2048-private",
.key_type = QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE, .key_type = QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE,
.key = rsa2048_private_key, .key = rsa2048_private_key,
.keylen = sizeof(rsa2048_private_key), .keylen = sizeof(rsa2048_private_key),
.is_valid_key = true, .is_valid_key = true,
@ -724,56 +724,56 @@ static QCryptoRSAKeyTestData rsakey_test_data[] = {
}, },
{ {
.path = "/crypto/akcipher/rsakey-public-lack-elem", .path = "/crypto/akcipher/rsakey-public-lack-elem",
.key_type = QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC, .key_type = QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC,
.key = rsa_public_key_lack_element, .key = rsa_public_key_lack_element,
.keylen = sizeof(rsa_public_key_lack_element), .keylen = sizeof(rsa_public_key_lack_element),
.is_valid_key = false, .is_valid_key = false,
}, },
{ {
.path = "/crypto/akcipher/rsakey-private-lack-elem", .path = "/crypto/akcipher/rsakey-private-lack-elem",
.key_type = QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE, .key_type = QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE,
.key = rsa_private_key_lack_element, .key = rsa_private_key_lack_element,
.keylen = sizeof(rsa_private_key_lack_element), .keylen = sizeof(rsa_private_key_lack_element),
.is_valid_key = false, .is_valid_key = false,
}, },
{ {
.path = "/crypto/akcipher/rsakey-public-empty-elem", .path = "/crypto/akcipher/rsakey-public-empty-elem",
.key_type = QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC, .key_type = QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC,
.key = rsa_public_key_empty_element, .key = rsa_public_key_empty_element,
.keylen = sizeof(rsa_public_key_empty_element), .keylen = sizeof(rsa_public_key_empty_element),
.is_valid_key = false, .is_valid_key = false,
}, },
{ {
.path = "/crypto/akcipher/rsakey-private-empty-elem", .path = "/crypto/akcipher/rsakey-private-empty-elem",
.key_type = QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE, .key_type = QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE,
.key = rsa_private_key_empty_element, .key = rsa_private_key_empty_element,
.keylen = sizeof(rsa_private_key_empty_element), .keylen = sizeof(rsa_private_key_empty_element),
.is_valid_key = false, .is_valid_key = false,
}, },
{ {
.path = "/crypto/akcipher/rsakey-public-empty-key", .path = "/crypto/akcipher/rsakey-public-empty-key",
.key_type = QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC, .key_type = QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC,
.key = NULL, .key = NULL,
.keylen = 0, .keylen = 0,
.is_valid_key = false, .is_valid_key = false,
}, },
{ {
.path = "/crypto/akcipher/rsakey-private-empty-key", .path = "/crypto/akcipher/rsakey-private-empty-key",
.key_type = QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE, .key_type = QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE,
.key = NULL, .key = NULL,
.keylen = 0, .keylen = 0,
.is_valid_key = false, .is_valid_key = false,
}, },
{ {
.path = "/crypto/akcipher/rsakey-public-invalid-length-val", .path = "/crypto/akcipher/rsakey-public-invalid-length-val",
.key_type = QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC, .key_type = QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC,
.key = rsa_public_key_invalid_length_val, .key = rsa_public_key_invalid_length_val,
.keylen = sizeof(rsa_public_key_invalid_length_val), .keylen = sizeof(rsa_public_key_invalid_length_val),
.is_valid_key = false, .is_valid_key = false,
}, },
{ {
.path = "/crypto/akcipher/rsakey-public-extra-elem", .path = "/crypto/akcipher/rsakey-public-extra-elem",
.key_type = QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC, .key_type = QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC,
.key = rsa_public_key_extra_elem, .key = rsa_public_key_extra_elem,
.keylen = sizeof(rsa_public_key_extra_elem), .keylen = sizeof(rsa_public_key_extra_elem),
.is_valid_key = false, .is_valid_key = false,
@ -885,12 +885,12 @@ static void test_akcipher(const void *opaque)
return; return;
} }
pub_key = qcrypto_akcipher_new(&data->opt, pub_key = qcrypto_akcipher_new(&data->opt,
QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC, QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC,
data->pub_key, data->pub_key_len, data->pub_key, data->pub_key_len,
&error_abort); &error_abort);
g_assert(pub_key != NULL); g_assert(pub_key != NULL);
priv_key = qcrypto_akcipher_new(&data->opt, priv_key = qcrypto_akcipher_new(&data->opt,
QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE, QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE,
data->priv_key, data->priv_key_len, data->priv_key, data->priv_key_len,
&error_abort); &error_abort);
g_assert(priv_key != NULL); g_assert(priv_key != NULL);