ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

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

QCryptoCipherAlgorithm has a 'prefix' that overrides the generated
enumeration constants' prefix to QCRYPTO_CIPHER_ALG.

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

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

Rename the type to QCryptoCipherAlgo instead.  The prefix becomes
QCRYPTO_CIPHER_ALGO.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Daniel P. Berrangé <berrange@redhat.com>
Message-ID: <20240904111836.3273842-13-armbru@redhat.com>
This commit is contained in:
Markus Armbruster 2024-09-04 13:18:29 +02:00
parent ef834aa2b2
commit a092c513db
26 changed files with 277 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
backends/cryptodev-builtin.c
View File

@ -138,18 +138,18 @@ cryptodev_builtin_get_aes_algo(uint32_t key_len, int mode, Error **errp)
int algo; int algo;
if (key_len == AES_KEYSIZE_128) { if (key_len == AES_KEYSIZE_128) {
algo = QCRYPTO_CIPHER_ALG_AES_128; algo = QCRYPTO_CIPHER_ALGO_AES_128;
} else if (key_len == AES_KEYSIZE_192) { } else if (key_len == AES_KEYSIZE_192) {
algo = QCRYPTO_CIPHER_ALG_AES_192; algo = QCRYPTO_CIPHER_ALGO_AES_192;
} else if (key_len == AES_KEYSIZE_256) { /* equals AES_KEYSIZE_128_XTS */ } else if (key_len == AES_KEYSIZE_256) { /* equals AES_KEYSIZE_128_XTS */
if (mode == QCRYPTO_CIPHER_MODE_XTS) { if (mode == QCRYPTO_CIPHER_MODE_XTS) {
algo = QCRYPTO_CIPHER_ALG_AES_128; algo = QCRYPTO_CIPHER_ALGO_AES_128;
} else { } else {
algo = QCRYPTO_CIPHER_ALG_AES_256; algo = QCRYPTO_CIPHER_ALGO_AES_256;
} }
} else if (key_len == AES_KEYSIZE_256_XTS) { } else if (key_len == AES_KEYSIZE_256_XTS) {
if (mode == QCRYPTO_CIPHER_MODE_XTS) { if (mode == QCRYPTO_CIPHER_MODE_XTS) {
algo = QCRYPTO_CIPHER_ALG_AES_256; algo = QCRYPTO_CIPHER_ALGO_AES_256;
} else { } else {
goto err; goto err;
} }
@ -271,15 +271,15 @@ static int cryptodev_builtin_create_cipher_session(
break; break;
case VIRTIO_CRYPTO_CIPHER_3DES_ECB: case VIRTIO_CRYPTO_CIPHER_3DES_ECB:
mode = QCRYPTO_CIPHER_MODE_ECB; mode = QCRYPTO_CIPHER_MODE_ECB;
algo = QCRYPTO_CIPHER_ALG_3DES; algo = QCRYPTO_CIPHER_ALGO_3DES;
break; break;
case VIRTIO_CRYPTO_CIPHER_3DES_CBC: case VIRTIO_CRYPTO_CIPHER_3DES_CBC:
mode = QCRYPTO_CIPHER_MODE_CBC; mode = QCRYPTO_CIPHER_MODE_CBC;
algo = QCRYPTO_CIPHER_ALG_3DES; algo = QCRYPTO_CIPHER_ALGO_3DES;
break; break;
case VIRTIO_CRYPTO_CIPHER_3DES_CTR: case VIRTIO_CRYPTO_CIPHER_3DES_CTR:
mode = QCRYPTO_CIPHER_MODE_CTR; mode = QCRYPTO_CIPHER_MODE_CTR;
algo = QCRYPTO_CIPHER_ALG_3DES; algo = QCRYPTO_CIPHER_ALGO_3DES;
break; break;
default: default:
error_setg(errp, "Unsupported cipher alg :%u", error_setg(errp, "Unsupported cipher alg :%u",

4
block/rbd.c
View File

@ -367,11 +367,11 @@ static int qemu_rbd_convert_luks_create_options(
if (luks_opts->has_cipher_alg) { if (luks_opts->has_cipher_alg) {
switch (luks_opts->cipher_alg) { switch (luks_opts->cipher_alg) {
case QCRYPTO_CIPHER_ALG_AES_128: { case QCRYPTO_CIPHER_ALGO_AES_128: {
*alg = RBD_ENCRYPTION_ALGORITHM_AES128; *alg = RBD_ENCRYPTION_ALGORITHM_AES128;
break; break;
} }
case QCRYPTO_CIPHER_ALG_AES_256: { case QCRYPTO_CIPHER_ALGO_AES_256: {
*alg = RBD_ENCRYPTION_ALGORITHM_AES256; *alg = RBD_ENCRYPTION_ALGORITHM_AES256;
break; break;
} }

92
crypto/block-luks.c
View File

@ -68,38 +68,38 @@ struct QCryptoBlockLUKSCipherNameMap {
static const QCryptoBlockLUKSCipherSizeMap static const QCryptoBlockLUKSCipherSizeMap
qcrypto_block_luks_cipher_size_map_aes[] = { qcrypto_block_luks_cipher_size_map_aes[] = {
{ 16, QCRYPTO_CIPHER_ALG_AES_128 }, { 16, QCRYPTO_CIPHER_ALGO_AES_128 },
{ 24, QCRYPTO_CIPHER_ALG_AES_192 }, { 24, QCRYPTO_CIPHER_ALGO_AES_192 },
{ 32, QCRYPTO_CIPHER_ALG_AES_256 }, { 32, QCRYPTO_CIPHER_ALGO_AES_256 },
{ 0, 0 }, { 0, 0 },
}; };
static const QCryptoBlockLUKSCipherSizeMap static const QCryptoBlockLUKSCipherSizeMap
qcrypto_block_luks_cipher_size_map_cast5[] = { qcrypto_block_luks_cipher_size_map_cast5[] = {
{ 16, QCRYPTO_CIPHER_ALG_CAST5_128 }, { 16, QCRYPTO_CIPHER_ALGO_CAST5_128 },
{ 0, 0 }, { 0, 0 },
}; };
static const QCryptoBlockLUKSCipherSizeMap static const QCryptoBlockLUKSCipherSizeMap
qcrypto_block_luks_cipher_size_map_serpent[] = { qcrypto_block_luks_cipher_size_map_serpent[] = {
{ 16, QCRYPTO_CIPHER_ALG_SERPENT_128 }, { 16, QCRYPTO_CIPHER_ALGO_SERPENT_128 },
{ 24, QCRYPTO_CIPHER_ALG_SERPENT_192 }, { 24, QCRYPTO_CIPHER_ALGO_SERPENT_192 },
{ 32, QCRYPTO_CIPHER_ALG_SERPENT_256 }, { 32, QCRYPTO_CIPHER_ALGO_SERPENT_256 },
{ 0, 0 }, { 0, 0 },
}; };
static const QCryptoBlockLUKSCipherSizeMap static const QCryptoBlockLUKSCipherSizeMap
qcrypto_block_luks_cipher_size_map_twofish[] = { qcrypto_block_luks_cipher_size_map_twofish[] = {
{ 16, QCRYPTO_CIPHER_ALG_TWOFISH_128 }, { 16, QCRYPTO_CIPHER_ALGO_TWOFISH_128 },
{ 24, QCRYPTO_CIPHER_ALG_TWOFISH_192 }, { 24, QCRYPTO_CIPHER_ALGO_TWOFISH_192 },
{ 32, QCRYPTO_CIPHER_ALG_TWOFISH_256 }, { 32, QCRYPTO_CIPHER_ALGO_TWOFISH_256 },
{ 0, 0 }, { 0, 0 },
}; };
#ifdef CONFIG_CRYPTO_SM4 #ifdef CONFIG_CRYPTO_SM4
static const QCryptoBlockLUKSCipherSizeMap static const QCryptoBlockLUKSCipherSizeMap
qcrypto_block_luks_cipher_size_map_sm4[] = { qcrypto_block_luks_cipher_size_map_sm4[] = {
{ 16, QCRYPTO_CIPHER_ALG_SM4}, { 16, QCRYPTO_CIPHER_ALGO_SM4},
{ 0, 0 }, { 0, 0 },
}; };
#endif #endif
@ -123,7 +123,7 @@ struct QCryptoBlockLUKS {
QCryptoBlockLUKSHeader header; QCryptoBlockLUKSHeader header;
/* Main encryption algorithm used for encryption*/ /* Main encryption algorithm used for encryption*/
QCryptoCipherAlgorithm cipher_alg; QCryptoCipherAlgo cipher_alg;
/* Mode of encryption for the selected encryption algorithm */ /* Mode of encryption for the selected encryption algorithm */
QCryptoCipherMode cipher_mode; QCryptoCipherMode cipher_mode;
@ -138,7 +138,7 @@ struct QCryptoBlockLUKS {
* Encryption algorithm used for IV generation. * Encryption algorithm used for IV generation.
* Usually the same as main encryption algorithm * Usually the same as main encryption algorithm
*/ */
QCryptoCipherAlgorithm ivgen_cipher_alg; QCryptoCipherAlgo ivgen_cipher_alg;
/* Hash algorithm used in pbkdf2 function */ /* Hash algorithm used in pbkdf2 function */
QCryptoHashAlgo hash_alg; QCryptoHashAlgo hash_alg;
@ -179,7 +179,7 @@ static int qcrypto_block_luks_cipher_name_lookup(const char *name,
} }
static const char * static const char *
qcrypto_block_luks_cipher_alg_lookup(QCryptoCipherAlgorithm alg, qcrypto_block_luks_cipher_alg_lookup(QCryptoCipherAlgo alg,
Error **errp) Error **errp)
{ {
const QCryptoBlockLUKSCipherNameMap *map = const QCryptoBlockLUKSCipherNameMap *map =
@ -195,7 +195,7 @@ qcrypto_block_luks_cipher_alg_lookup(QCryptoCipherAlgorithm alg,
} }
error_setg(errp, "Algorithm '%s' not supported", error_setg(errp, "Algorithm '%s' not supported",
QCryptoCipherAlgorithm_str(alg)); QCryptoCipherAlgo_str(alg));
return NULL; return NULL;
} }
@ -262,8 +262,8 @@ qcrypto_block_luks_has_format(const uint8_t *buf,
* the cipher since that gets a key length matching the digest * the cipher since that gets a key length matching the digest
* size, not AES 128 with truncated digest as might be imagined * size, not AES 128 with truncated digest as might be imagined
*/ */
static QCryptoCipherAlgorithm static QCryptoCipherAlgo
qcrypto_block_luks_essiv_cipher(QCryptoCipherAlgorithm cipher, qcrypto_block_luks_essiv_cipher(QCryptoCipherAlgo cipher,
QCryptoHashAlgo hash, QCryptoHashAlgo hash,
Error **errp) Error **errp)
{ {
@ -274,54 +274,54 @@ qcrypto_block_luks_essiv_cipher(QCryptoCipherAlgorithm cipher,
} }
switch (cipher) { switch (cipher) {
case QCRYPTO_CIPHER_ALG_AES_128: case QCRYPTO_CIPHER_ALGO_AES_128:
case QCRYPTO_CIPHER_ALG_AES_192: case QCRYPTO_CIPHER_ALGO_AES_192:
case QCRYPTO_CIPHER_ALG_AES_256: case QCRYPTO_CIPHER_ALGO_AES_256:
if (digestlen == qcrypto_cipher_get_key_len( if (digestlen == qcrypto_cipher_get_key_len(
QCRYPTO_CIPHER_ALG_AES_128)) { QCRYPTO_CIPHER_ALGO_AES_128)) {
return QCRYPTO_CIPHER_ALG_AES_128; return QCRYPTO_CIPHER_ALGO_AES_128;
} else if (digestlen == qcrypto_cipher_get_key_len( } else if (digestlen == qcrypto_cipher_get_key_len(
QCRYPTO_CIPHER_ALG_AES_192)) { QCRYPTO_CIPHER_ALGO_AES_192)) {
return QCRYPTO_CIPHER_ALG_AES_192; return QCRYPTO_CIPHER_ALGO_AES_192;
} else if (digestlen == qcrypto_cipher_get_key_len( } else if (digestlen == qcrypto_cipher_get_key_len(
QCRYPTO_CIPHER_ALG_AES_256)) { QCRYPTO_CIPHER_ALGO_AES_256)) {
return QCRYPTO_CIPHER_ALG_AES_256; return QCRYPTO_CIPHER_ALGO_AES_256;
} else { } else {
error_setg(errp, "No AES cipher with key size %zu available", error_setg(errp, "No AES cipher with key size %zu available",
digestlen); digestlen);
return 0; return 0;
} }
break; break;
case QCRYPTO_CIPHER_ALG_SERPENT_128: case QCRYPTO_CIPHER_ALGO_SERPENT_128:
case QCRYPTO_CIPHER_ALG_SERPENT_192: case QCRYPTO_CIPHER_ALGO_SERPENT_192:
case QCRYPTO_CIPHER_ALG_SERPENT_256: case QCRYPTO_CIPHER_ALGO_SERPENT_256:
if (digestlen == qcrypto_cipher_get_key_len( if (digestlen == qcrypto_cipher_get_key_len(
QCRYPTO_CIPHER_ALG_SERPENT_128)) { QCRYPTO_CIPHER_ALGO_SERPENT_128)) {
return QCRYPTO_CIPHER_ALG_SERPENT_128; return QCRYPTO_CIPHER_ALGO_SERPENT_128;
} else if (digestlen == qcrypto_cipher_get_key_len( } else if (digestlen == qcrypto_cipher_get_key_len(
QCRYPTO_CIPHER_ALG_SERPENT_192)) { QCRYPTO_CIPHER_ALGO_SERPENT_192)) {
return QCRYPTO_CIPHER_ALG_SERPENT_192; return QCRYPTO_CIPHER_ALGO_SERPENT_192;
} else if (digestlen == qcrypto_cipher_get_key_len( } else if (digestlen == qcrypto_cipher_get_key_len(
QCRYPTO_CIPHER_ALG_SERPENT_256)) { QCRYPTO_CIPHER_ALGO_SERPENT_256)) {
return QCRYPTO_CIPHER_ALG_SERPENT_256; return QCRYPTO_CIPHER_ALGO_SERPENT_256;
} else { } else {
error_setg(errp, "No Serpent cipher with key size %zu available", error_setg(errp, "No Serpent cipher with key size %zu available",
digestlen); digestlen);
return 0; return 0;
} }
break; break;
case QCRYPTO_CIPHER_ALG_TWOFISH_128: case QCRYPTO_CIPHER_ALGO_TWOFISH_128:
case QCRYPTO_CIPHER_ALG_TWOFISH_192: case QCRYPTO_CIPHER_ALGO_TWOFISH_192:
case QCRYPTO_CIPHER_ALG_TWOFISH_256: case QCRYPTO_CIPHER_ALGO_TWOFISH_256:
if (digestlen == qcrypto_cipher_get_key_len( if (digestlen == qcrypto_cipher_get_key_len(
QCRYPTO_CIPHER_ALG_TWOFISH_128)) { QCRYPTO_CIPHER_ALGO_TWOFISH_128)) {
return QCRYPTO_CIPHER_ALG_TWOFISH_128; return QCRYPTO_CIPHER_ALGO_TWOFISH_128;
} else if (digestlen == qcrypto_cipher_get_key_len( } else if (digestlen == qcrypto_cipher_get_key_len(
QCRYPTO_CIPHER_ALG_TWOFISH_192)) { QCRYPTO_CIPHER_ALGO_TWOFISH_192)) {
return QCRYPTO_CIPHER_ALG_TWOFISH_192; return QCRYPTO_CIPHER_ALGO_TWOFISH_192;
} else if (digestlen == qcrypto_cipher_get_key_len( } else if (digestlen == qcrypto_cipher_get_key_len(
QCRYPTO_CIPHER_ALG_TWOFISH_256)) { QCRYPTO_CIPHER_ALGO_TWOFISH_256)) {
return QCRYPTO_CIPHER_ALG_TWOFISH_256; return QCRYPTO_CIPHER_ALGO_TWOFISH_256;
} else { } else {
error_setg(errp, "No Twofish cipher with key size %zu available", error_setg(errp, "No Twofish cipher with key size %zu available",
digestlen); digestlen);
@ -330,7 +330,7 @@ qcrypto_block_luks_essiv_cipher(QCryptoCipherAlgorithm cipher,
break; break;
default: default:
error_setg(errp, "Cipher %s not supported with essiv", error_setg(errp, "Cipher %s not supported with essiv",
QCryptoCipherAlgorithm_str(cipher)); QCryptoCipherAlgo_str(cipher));
return 0; return 0;
} }
} }
@ -1322,7 +1322,7 @@ qcrypto_block_luks_create(QCryptoBlock *block,
luks_opts.iter_time = QCRYPTO_BLOCK_LUKS_DEFAULT_ITER_TIME_MS; luks_opts.iter_time = QCRYPTO_BLOCK_LUKS_DEFAULT_ITER_TIME_MS;
} }
if (!luks_opts.has_cipher_alg) { if (!luks_opts.has_cipher_alg) {
luks_opts.cipher_alg = QCRYPTO_CIPHER_ALG_AES_256; luks_opts.cipher_alg = QCRYPTO_CIPHER_ALGO_AES_256;
} }
if (!luks_opts.has_cipher_mode) { if (!luks_opts.has_cipher_mode) {
luks_opts.cipher_mode = QCRYPTO_CIPHER_MODE_XTS; luks_opts.cipher_mode = QCRYPTO_CIPHER_MODE_XTS;

4
crypto/block-qcow.c
View File

@ -62,7 +62,7 @@ qcrypto_block_qcow_init(QCryptoBlock *block,
memcpy(keybuf, password, MIN(len, sizeof(keybuf))); memcpy(keybuf, password, MIN(len, sizeof(keybuf)));
g_free(password); g_free(password);
block->niv = qcrypto_cipher_get_iv_len(QCRYPTO_CIPHER_ALG_AES_128, block->niv = qcrypto_cipher_get_iv_len(QCRYPTO_CIPHER_ALGO_AES_128,
QCRYPTO_CIPHER_MODE_CBC); QCRYPTO_CIPHER_MODE_CBC);
block->ivgen = qcrypto_ivgen_new(QCRYPTO_IVGEN_ALG_PLAIN64, block->ivgen = qcrypto_ivgen_new(QCRYPTO_IVGEN_ALG_PLAIN64,
0, 0, NULL, 0, errp); 0, 0, NULL, 0, errp);
@ -71,7 +71,7 @@ qcrypto_block_qcow_init(QCryptoBlock *block,
goto fail; goto fail;
} }
ret = qcrypto_block_init_cipher(block, QCRYPTO_CIPHER_ALG_AES_128, ret = qcrypto_block_init_cipher(block, QCRYPTO_CIPHER_ALGO_AES_128,
QCRYPTO_CIPHER_MODE_CBC, QCRYPTO_CIPHER_MODE_CBC,
keybuf, G_N_ELEMENTS(keybuf), keybuf, G_N_ELEMENTS(keybuf),
errp); errp);

2
crypto/block.c
View File

@ -267,7 +267,7 @@ static void qcrypto_block_push_cipher(QCryptoBlock *block,
int qcrypto_block_init_cipher(QCryptoBlock *block, int qcrypto_block_init_cipher(QCryptoBlock *block,
QCryptoCipherAlgorithm alg, QCryptoCipherAlgo alg,
QCryptoCipherMode mode, QCryptoCipherMode mode,
const uint8_t *key, size_t nkey, const uint8_t *key, size_t nkey,
Error **errp) Error **errp)

4
crypto/blockpriv.h
View File

@ -33,7 +33,7 @@ struct QCryptoBlock {
void *opaque; void *opaque;
/* Cipher parameters */ /* Cipher parameters */
QCryptoCipherAlgorithm alg; QCryptoCipherAlgo alg;
QCryptoCipherMode mode; QCryptoCipherMode mode;
uint8_t *key; uint8_t *key;
size_t nkey; size_t nkey;
@ -132,7 +132,7 @@ int qcrypto_block_encrypt_helper(QCryptoBlock *block,
Error **errp); Error **errp);
int qcrypto_block_init_cipher(QCryptoBlock *block, int qcrypto_block_init_cipher(QCryptoBlock *block,
QCryptoCipherAlgorithm alg, QCryptoCipherAlgo alg,
QCryptoCipherMode mode, QCryptoCipherMode mode,
const uint8_t *key, size_t nkey, const uint8_t *key, size_t nkey,
Error **errp); Error **errp);

24
crypto/cipher-afalg.c
View File

@ -18,7 +18,7 @@
static char * static char *
qcrypto_afalg_cipher_format_name(QCryptoCipherAlgorithm alg, qcrypto_afalg_cipher_format_name(QCryptoCipherAlgo alg,
QCryptoCipherMode mode, QCryptoCipherMode mode,
Error **errp) Error **errp)
{ {
@ -27,22 +27,22 @@ qcrypto_afalg_cipher_format_name(QCryptoCipherAlgorithm alg,
const char *mode_name; const char *mode_name;
switch (alg) { switch (alg) {
case QCRYPTO_CIPHER_ALG_AES_128: case QCRYPTO_CIPHER_ALGO_AES_128:
case QCRYPTO_CIPHER_ALG_AES_192: case QCRYPTO_CIPHER_ALGO_AES_192:
case QCRYPTO_CIPHER_ALG_AES_256: case QCRYPTO_CIPHER_ALGO_AES_256:
alg_name = "aes"; alg_name = "aes";
break; break;
case QCRYPTO_CIPHER_ALG_CAST5_128: case QCRYPTO_CIPHER_ALGO_CAST5_128:
alg_name = "cast5"; alg_name = "cast5";
break; break;
case QCRYPTO_CIPHER_ALG_SERPENT_128: case QCRYPTO_CIPHER_ALGO_SERPENT_128:
case QCRYPTO_CIPHER_ALG_SERPENT_192: case QCRYPTO_CIPHER_ALGO_SERPENT_192:
case QCRYPTO_CIPHER_ALG_SERPENT_256: case QCRYPTO_CIPHER_ALGO_SERPENT_256:
alg_name = "serpent"; alg_name = "serpent";
break; break;
case QCRYPTO_CIPHER_ALG_TWOFISH_128: case QCRYPTO_CIPHER_ALGO_TWOFISH_128:
case QCRYPTO_CIPHER_ALG_TWOFISH_192: case QCRYPTO_CIPHER_ALGO_TWOFISH_192:
case QCRYPTO_CIPHER_ALG_TWOFISH_256: case QCRYPTO_CIPHER_ALGO_TWOFISH_256:
alg_name = "twofish"; alg_name = "twofish";
break; break;
@ -60,7 +60,7 @@ qcrypto_afalg_cipher_format_name(QCryptoCipherAlgorithm alg,
static const struct QCryptoCipherDriver qcrypto_cipher_afalg_driver; static const struct QCryptoCipherDriver qcrypto_cipher_afalg_driver;
QCryptoCipher * QCryptoCipher *
qcrypto_afalg_cipher_ctx_new(QCryptoCipherAlgorithm alg, qcrypto_afalg_cipher_ctx_new(QCryptoCipherAlgo alg,
QCryptoCipherMode mode, QCryptoCipherMode mode,
const uint8_t *key, const uint8_t *key,
size_t nkey, Error **errp) size_t nkey, Error **errp)

18
crypto/cipher-builtin.c.inc
View File

@ -221,13 +221,13 @@ static const struct QCryptoCipherDriver qcrypto_cipher_aes_driver_cbc = {
.cipher_free = qcrypto_cipher_ctx_free, .cipher_free = qcrypto_cipher_ctx_free,
}; };
bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg, bool qcrypto_cipher_supports(QCryptoCipherAlgo alg,
QCryptoCipherMode mode) QCryptoCipherMode mode)
{ {
switch (alg) { switch (alg) {
case QCRYPTO_CIPHER_ALG_AES_128: case QCRYPTO_CIPHER_ALGO_AES_128:
case QCRYPTO_CIPHER_ALG_AES_192: case QCRYPTO_CIPHER_ALGO_AES_192:
case QCRYPTO_CIPHER_ALG_AES_256: case QCRYPTO_CIPHER_ALGO_AES_256:
switch (mode) { switch (mode) {
case QCRYPTO_CIPHER_MODE_ECB: case QCRYPTO_CIPHER_MODE_ECB:
case QCRYPTO_CIPHER_MODE_CBC: case QCRYPTO_CIPHER_MODE_CBC:
@ -241,7 +241,7 @@ bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg,
} }
} }
static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg, static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgo alg,
QCryptoCipherMode mode, QCryptoCipherMode mode,
const uint8_t *key, const uint8_t *key,
size_t nkey, size_t nkey,
@ -252,9 +252,9 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
} }
switch (alg) { switch (alg) {
case QCRYPTO_CIPHER_ALG_AES_128: case QCRYPTO_CIPHER_ALGO_AES_128:
case QCRYPTO_CIPHER_ALG_AES_192: case QCRYPTO_CIPHER_ALGO_AES_192:
case QCRYPTO_CIPHER_ALG_AES_256: case QCRYPTO_CIPHER_ALGO_AES_256:
{ {
QCryptoCipherBuiltinAES *ctx; QCryptoCipherBuiltinAES *ctx;
const QCryptoCipherDriver *drv; const QCryptoCipherDriver *drv;
@ -292,7 +292,7 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
default: default:
error_setg(errp, error_setg(errp,
"Unsupported cipher algorithm %s", "Unsupported cipher algorithm %s",
QCryptoCipherAlgorithm_str(alg)); QCryptoCipherAlgo_str(alg));
return NULL; return NULL;
} }

56
crypto/cipher-gcrypt.c.inc
View File

@ -20,33 +20,33 @@
#include <gcrypt.h> #include <gcrypt.h>
static int qcrypto_cipher_alg_to_gcry_alg(QCryptoCipherAlgorithm alg) static int qcrypto_cipher_alg_to_gcry_alg(QCryptoCipherAlgo alg)
{ {
switch (alg) { switch (alg) {
case QCRYPTO_CIPHER_ALG_DES: case QCRYPTO_CIPHER_ALGO_DES:
return GCRY_CIPHER_DES; return GCRY_CIPHER_DES;
case QCRYPTO_CIPHER_ALG_3DES: case QCRYPTO_CIPHER_ALGO_3DES:
return GCRY_CIPHER_3DES; return GCRY_CIPHER_3DES;
case QCRYPTO_CIPHER_ALG_AES_128: case QCRYPTO_CIPHER_ALGO_AES_128:
return GCRY_CIPHER_AES128; return GCRY_CIPHER_AES128;
case QCRYPTO_CIPHER_ALG_AES_192: case QCRYPTO_CIPHER_ALGO_AES_192:
return GCRY_CIPHER_AES192; return GCRY_CIPHER_AES192;
case QCRYPTO_CIPHER_ALG_AES_256: case QCRYPTO_CIPHER_ALGO_AES_256:
return GCRY_CIPHER_AES256; return GCRY_CIPHER_AES256;
case QCRYPTO_CIPHER_ALG_CAST5_128: case QCRYPTO_CIPHER_ALGO_CAST5_128:
return GCRY_CIPHER_CAST5; return GCRY_CIPHER_CAST5;
case QCRYPTO_CIPHER_ALG_SERPENT_128: case QCRYPTO_CIPHER_ALGO_SERPENT_128:
return GCRY_CIPHER_SERPENT128; return GCRY_CIPHER_SERPENT128;
case QCRYPTO_CIPHER_ALG_SERPENT_192: case QCRYPTO_CIPHER_ALGO_SERPENT_192:
return GCRY_CIPHER_SERPENT192; return GCRY_CIPHER_SERPENT192;
case QCRYPTO_CIPHER_ALG_SERPENT_256: case QCRYPTO_CIPHER_ALGO_SERPENT_256:
return GCRY_CIPHER_SERPENT256; return GCRY_CIPHER_SERPENT256;
case QCRYPTO_CIPHER_ALG_TWOFISH_128: case QCRYPTO_CIPHER_ALGO_TWOFISH_128:
return GCRY_CIPHER_TWOFISH128; return GCRY_CIPHER_TWOFISH128;
case QCRYPTO_CIPHER_ALG_TWOFISH_256: case QCRYPTO_CIPHER_ALGO_TWOFISH_256:
return GCRY_CIPHER_TWOFISH; return GCRY_CIPHER_TWOFISH;
#ifdef CONFIG_CRYPTO_SM4 #ifdef CONFIG_CRYPTO_SM4
case QCRYPTO_CIPHER_ALG_SM4: case QCRYPTO_CIPHER_ALGO_SM4:
return GCRY_CIPHER_SM4; return GCRY_CIPHER_SM4;
#endif #endif
default: default:
@ -70,23 +70,23 @@ static int qcrypto_cipher_mode_to_gcry_mode(QCryptoCipherMode mode)
} }
} }
bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg, bool qcrypto_cipher_supports(QCryptoCipherAlgo alg,
QCryptoCipherMode mode) QCryptoCipherMode mode)
{ {
switch (alg) { switch (alg) {
case QCRYPTO_CIPHER_ALG_DES: case QCRYPTO_CIPHER_ALGO_DES:
case QCRYPTO_CIPHER_ALG_3DES: case QCRYPTO_CIPHER_ALGO_3DES:
case QCRYPTO_CIPHER_ALG_AES_128: case QCRYPTO_CIPHER_ALGO_AES_128:
case QCRYPTO_CIPHER_ALG_AES_192: case QCRYPTO_CIPHER_ALGO_AES_192:
case QCRYPTO_CIPHER_ALG_AES_256: case QCRYPTO_CIPHER_ALGO_AES_256:
case QCRYPTO_CIPHER_ALG_CAST5_128: case QCRYPTO_CIPHER_ALGO_CAST5_128:
case QCRYPTO_CIPHER_ALG_SERPENT_128: case QCRYPTO_CIPHER_ALGO_SERPENT_128:
case QCRYPTO_CIPHER_ALG_SERPENT_192: case QCRYPTO_CIPHER_ALGO_SERPENT_192:
case QCRYPTO_CIPHER_ALG_SERPENT_256: case QCRYPTO_CIPHER_ALGO_SERPENT_256:
case QCRYPTO_CIPHER_ALG_TWOFISH_128: case QCRYPTO_CIPHER_ALGO_TWOFISH_128:
case QCRYPTO_CIPHER_ALG_TWOFISH_256: case QCRYPTO_CIPHER_ALGO_TWOFISH_256:
#ifdef CONFIG_CRYPTO_SM4 #ifdef CONFIG_CRYPTO_SM4
case QCRYPTO_CIPHER_ALG_SM4: case QCRYPTO_CIPHER_ALGO_SM4:
#endif #endif
break; break;
default: default:
@ -228,7 +228,7 @@ static const struct QCryptoCipherDriver qcrypto_gcrypt_ctr_driver = {
.cipher_free = qcrypto_gcrypt_ctx_free, .cipher_free = qcrypto_gcrypt_ctx_free,
}; };
static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg, static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgo alg,
QCryptoCipherMode mode, QCryptoCipherMode mode,
const uint8_t *key, const uint8_t *key,
size_t nkey, size_t nkey,
@ -246,7 +246,7 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
gcryalg = qcrypto_cipher_alg_to_gcry_alg(alg); gcryalg = qcrypto_cipher_alg_to_gcry_alg(alg);
if (gcryalg == GCRY_CIPHER_NONE) { if (gcryalg == GCRY_CIPHER_NONE) {
error_setg(errp, "Unsupported cipher algorithm %s", error_setg(errp, "Unsupported cipher algorithm %s",
QCryptoCipherAlgorithm_str(alg)); QCryptoCipherAlgo_str(alg));
return NULL; return NULL;
} }

38
crypto/cipher-gnutls.c.inc
View File

@ -27,7 +27,7 @@
#define QEMU_GNUTLS_XTS #define QEMU_GNUTLS_XTS
#endif #endif
bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg, bool qcrypto_cipher_supports(QCryptoCipherAlgo alg,
QCryptoCipherMode mode) QCryptoCipherMode mode)
{ {
@ -35,11 +35,11 @@ bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg,
case QCRYPTO_CIPHER_MODE_ECB: case QCRYPTO_CIPHER_MODE_ECB:
case QCRYPTO_CIPHER_MODE_CBC: case QCRYPTO_CIPHER_MODE_CBC:
switch (alg) { switch (alg) {
case QCRYPTO_CIPHER_ALG_AES_128: case QCRYPTO_CIPHER_ALGO_AES_128:
case QCRYPTO_CIPHER_ALG_AES_192: case QCRYPTO_CIPHER_ALGO_AES_192:
case QCRYPTO_CIPHER_ALG_AES_256: case QCRYPTO_CIPHER_ALGO_AES_256:
case QCRYPTO_CIPHER_ALG_DES: case QCRYPTO_CIPHER_ALGO_DES:
case QCRYPTO_CIPHER_ALG_3DES: case QCRYPTO_CIPHER_ALGO_3DES:
return true; return true;
default: default:
return false; return false;
@ -47,8 +47,8 @@ bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg,
#ifdef QEMU_GNUTLS_XTS #ifdef QEMU_GNUTLS_XTS
case QCRYPTO_CIPHER_MODE_XTS: case QCRYPTO_CIPHER_MODE_XTS:
switch (alg) { switch (alg) {
case QCRYPTO_CIPHER_ALG_AES_128: case QCRYPTO_CIPHER_ALGO_AES_128:
case QCRYPTO_CIPHER_ALG_AES_256: case QCRYPTO_CIPHER_ALGO_AES_256:
return true; return true;
default: default:
return false; return false;
@ -229,7 +229,7 @@ static struct QCryptoCipherDriver gnutls_driver = {
.cipher_free = qcrypto_gnutls_cipher_free, .cipher_free = qcrypto_gnutls_cipher_free,
}; };
static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg, static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgo alg,
QCryptoCipherMode mode, QCryptoCipherMode mode,
const uint8_t *key, const uint8_t *key,
size_t nkey, size_t nkey,
@ -244,10 +244,10 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
#ifdef QEMU_GNUTLS_XTS #ifdef QEMU_GNUTLS_XTS
case QCRYPTO_CIPHER_MODE_XTS: case QCRYPTO_CIPHER_MODE_XTS:
switch (alg) { switch (alg) {
case QCRYPTO_CIPHER_ALG_AES_128: case QCRYPTO_CIPHER_ALGO_AES_128:
galg = GNUTLS_CIPHER_AES_128_XTS; galg = GNUTLS_CIPHER_AES_128_XTS;
break; break;
case QCRYPTO_CIPHER_ALG_AES_256: case QCRYPTO_CIPHER_ALGO_AES_256:
galg = GNUTLS_CIPHER_AES_256_XTS; galg = GNUTLS_CIPHER_AES_256_XTS;
break; break;
default: default:
@ -259,19 +259,19 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
case QCRYPTO_CIPHER_MODE_ECB: case QCRYPTO_CIPHER_MODE_ECB:
case QCRYPTO_CIPHER_MODE_CBC: case QCRYPTO_CIPHER_MODE_CBC:
switch (alg) { switch (alg) {
case QCRYPTO_CIPHER_ALG_AES_128: case QCRYPTO_CIPHER_ALGO_AES_128:
galg = GNUTLS_CIPHER_AES_128_CBC; galg = GNUTLS_CIPHER_AES_128_CBC;
break; break;
case QCRYPTO_CIPHER_ALG_AES_192: case QCRYPTO_CIPHER_ALGO_AES_192:
galg = GNUTLS_CIPHER_AES_192_CBC; galg = GNUTLS_CIPHER_AES_192_CBC;
break; break;
case QCRYPTO_CIPHER_ALG_AES_256: case QCRYPTO_CIPHER_ALGO_AES_256:
galg = GNUTLS_CIPHER_AES_256_CBC; galg = GNUTLS_CIPHER_AES_256_CBC;
break; break;
case QCRYPTO_CIPHER_ALG_DES: case QCRYPTO_CIPHER_ALGO_DES:
galg = GNUTLS_CIPHER_DES_CBC; galg = GNUTLS_CIPHER_DES_CBC;
break; break;
case QCRYPTO_CIPHER_ALG_3DES: case QCRYPTO_CIPHER_ALGO_3DES:
galg = GNUTLS_CIPHER_3DES_CBC; galg = GNUTLS_CIPHER_3DES_CBC;
break; break;
default: default:
@ -284,7 +284,7 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
if (galg == GNUTLS_CIPHER_UNKNOWN) { if (galg == GNUTLS_CIPHER_UNKNOWN) {
error_setg(errp, "Unsupported cipher algorithm %s with %s mode", error_setg(errp, "Unsupported cipher algorithm %s with %s mode",
QCryptoCipherAlgorithm_str(alg), QCryptoCipherAlgo_str(alg),
QCryptoCipherMode_str(mode)); QCryptoCipherMode_str(mode));
return NULL; return NULL;
} }
@ -310,8 +310,8 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
} }
} }
if (alg == QCRYPTO_CIPHER_ALG_DES || if (alg == QCRYPTO_CIPHER_ALGO_DES ||
alg == QCRYPTO_CIPHER_ALG_3DES) alg == QCRYPTO_CIPHER_ALGO_3DES)
ctx->blocksize = 8; ctx->blocksize = 8;
else else
ctx->blocksize = 16; ctx->blocksize = 16;

58
crypto/cipher-nettle.c.inc
View File

@ -454,24 +454,24 @@ DEFINE_ECB(qcrypto_nettle_sm4,
sm4_encrypt_native, sm4_decrypt_native) sm4_encrypt_native, sm4_decrypt_native)
#endif #endif
bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg, bool qcrypto_cipher_supports(QCryptoCipherAlgo alg,
QCryptoCipherMode mode) QCryptoCipherMode mode)
{ {
switch (alg) { switch (alg) {
case QCRYPTO_CIPHER_ALG_DES: case QCRYPTO_CIPHER_ALGO_DES:
case QCRYPTO_CIPHER_ALG_3DES: case QCRYPTO_CIPHER_ALGO_3DES:
case QCRYPTO_CIPHER_ALG_AES_128: case QCRYPTO_CIPHER_ALGO_AES_128:
case QCRYPTO_CIPHER_ALG_AES_192: case QCRYPTO_CIPHER_ALGO_AES_192:
case QCRYPTO_CIPHER_ALG_AES_256: case QCRYPTO_CIPHER_ALGO_AES_256:
case QCRYPTO_CIPHER_ALG_CAST5_128: case QCRYPTO_CIPHER_ALGO_CAST5_128:
case QCRYPTO_CIPHER_ALG_SERPENT_128: case QCRYPTO_CIPHER_ALGO_SERPENT_128:
case QCRYPTO_CIPHER_ALG_SERPENT_192: case QCRYPTO_CIPHER_ALGO_SERPENT_192:
case QCRYPTO_CIPHER_ALG_SERPENT_256: case QCRYPTO_CIPHER_ALGO_SERPENT_256:
case QCRYPTO_CIPHER_ALG_TWOFISH_128: case QCRYPTO_CIPHER_ALGO_TWOFISH_128:
case QCRYPTO_CIPHER_ALG_TWOFISH_192: case QCRYPTO_CIPHER_ALGO_TWOFISH_192:
case QCRYPTO_CIPHER_ALG_TWOFISH_256: case QCRYPTO_CIPHER_ALGO_TWOFISH_256:
#ifdef CONFIG_CRYPTO_SM4 #ifdef CONFIG_CRYPTO_SM4
case QCRYPTO_CIPHER_ALG_SM4: case QCRYPTO_CIPHER_ALGO_SM4:
#endif #endif
break; break;
default: default:
@ -489,7 +489,7 @@ bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg,
} }
} }
static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg, static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgo alg,
QCryptoCipherMode mode, QCryptoCipherMode mode,
const uint8_t *key, const uint8_t *key,
size_t nkey, size_t nkey,
@ -510,7 +510,7 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
} }
switch (alg) { switch (alg) {
case QCRYPTO_CIPHER_ALG_DES: case QCRYPTO_CIPHER_ALGO_DES:
{ {
QCryptoNettleDES *ctx; QCryptoNettleDES *ctx;
const QCryptoCipherDriver *drv; const QCryptoCipherDriver *drv;
@ -538,7 +538,7 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
return &ctx->base; return &ctx->base;
} }
case QCRYPTO_CIPHER_ALG_3DES: case QCRYPTO_CIPHER_ALGO_3DES:
{ {
QCryptoNettleDES3 *ctx; QCryptoNettleDES3 *ctx;
const QCryptoCipherDriver *drv; const QCryptoCipherDriver *drv;
@ -565,7 +565,7 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
return &ctx->base; return &ctx->base;
} }
case QCRYPTO_CIPHER_ALG_AES_128: case QCRYPTO_CIPHER_ALGO_AES_128:
{ {
QCryptoNettleAES128 *ctx = g_new0(QCryptoNettleAES128, 1); QCryptoNettleAES128 *ctx = g_new0(QCryptoNettleAES128, 1);
@ -594,7 +594,7 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
return &ctx->base; return &ctx->base;
} }
case QCRYPTO_CIPHER_ALG_AES_192: case QCRYPTO_CIPHER_ALGO_AES_192:
{ {
QCryptoNettleAES192 *ctx = g_new0(QCryptoNettleAES192, 1); QCryptoNettleAES192 *ctx = g_new0(QCryptoNettleAES192, 1);
@ -623,7 +623,7 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
return &ctx->base; return &ctx->base;
} }
case QCRYPTO_CIPHER_ALG_AES_256: case QCRYPTO_CIPHER_ALGO_AES_256:
{ {
QCryptoNettleAES256 *ctx = g_new0(QCryptoNettleAES256, 1); QCryptoNettleAES256 *ctx = g_new0(QCryptoNettleAES256, 1);
@ -652,7 +652,7 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
return &ctx->base; return &ctx->base;
} }
case QCRYPTO_CIPHER_ALG_CAST5_128: case QCRYPTO_CIPHER_ALGO_CAST5_128:
{ {
QCryptoNettleCAST128 *ctx; QCryptoNettleCAST128 *ctx;
const QCryptoCipherDriver *drv; const QCryptoCipherDriver *drv;
@ -680,9 +680,9 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
return &ctx->base; return &ctx->base;
} }
case QCRYPTO_CIPHER_ALG_SERPENT_128: case QCRYPTO_CIPHER_ALGO_SERPENT_128:
case QCRYPTO_CIPHER_ALG_SERPENT_192: case QCRYPTO_CIPHER_ALGO_SERPENT_192:
case QCRYPTO_CIPHER_ALG_SERPENT_256: case QCRYPTO_CIPHER_ALGO_SERPENT_256:
{ {
QCryptoNettleSerpent *ctx = g_new0(QCryptoNettleSerpent, 1); QCryptoNettleSerpent *ctx = g_new0(QCryptoNettleSerpent, 1);
@ -709,9 +709,9 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
return &ctx->base; return &ctx->base;
} }
case QCRYPTO_CIPHER_ALG_TWOFISH_128: case QCRYPTO_CIPHER_ALGO_TWOFISH_128:
case QCRYPTO_CIPHER_ALG_TWOFISH_192: case QCRYPTO_CIPHER_ALGO_TWOFISH_192:
case QCRYPTO_CIPHER_ALG_TWOFISH_256: case QCRYPTO_CIPHER_ALGO_TWOFISH_256:
{ {
QCryptoNettleTwofish *ctx = g_new0(QCryptoNettleTwofish, 1); QCryptoNettleTwofish *ctx = g_new0(QCryptoNettleTwofish, 1);
@ -738,7 +738,7 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
return &ctx->base; return &ctx->base;
} }
#ifdef CONFIG_CRYPTO_SM4 #ifdef CONFIG_CRYPTO_SM4
case QCRYPTO_CIPHER_ALG_SM4: case QCRYPTO_CIPHER_ALGO_SM4:
{ {
QCryptoNettleSm4 *ctx; QCryptoNettleSm4 *ctx;
const QCryptoCipherDriver *drv; const QCryptoCipherDriver *drv;
@ -766,7 +766,7 @@ static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
default: default:
error_setg(errp, "Unsupported cipher algorithm %s", error_setg(errp, "Unsupported cipher algorithm %s",
QCryptoCipherAlgorithm_str(alg)); QCryptoCipherAlgo_str(alg));
return NULL; return NULL;
} }

72
crypto/cipher.c
View File

@ -25,39 +25,39 @@
#include "cipherpriv.h" #include "cipherpriv.h"
static const size_t alg_key_len[QCRYPTO_CIPHER_ALG__MAX] = { static const size_t alg_key_len[QCRYPTO_CIPHER_ALGO__MAX] = {
[QCRYPTO_CIPHER_ALG_AES_128] = 16, [QCRYPTO_CIPHER_ALGO_AES_128] = 16,
[QCRYPTO_CIPHER_ALG_AES_192] = 24, [QCRYPTO_CIPHER_ALGO_AES_192] = 24,
[QCRYPTO_CIPHER_ALG_AES_256] = 32, [QCRYPTO_CIPHER_ALGO_AES_256] = 32,
[QCRYPTO_CIPHER_ALG_DES] = 8, [QCRYPTO_CIPHER_ALGO_DES] = 8,
[QCRYPTO_CIPHER_ALG_3DES] = 24, [QCRYPTO_CIPHER_ALGO_3DES] = 24,
[QCRYPTO_CIPHER_ALG_CAST5_128] = 16, [QCRYPTO_CIPHER_ALGO_CAST5_128] = 16,
[QCRYPTO_CIPHER_ALG_SERPENT_128] = 16, [QCRYPTO_CIPHER_ALGO_SERPENT_128] = 16,
[QCRYPTO_CIPHER_ALG_SERPENT_192] = 24, [QCRYPTO_CIPHER_ALGO_SERPENT_192] = 24,
[QCRYPTO_CIPHER_ALG_SERPENT_256] = 32, [QCRYPTO_CIPHER_ALGO_SERPENT_256] = 32,
[QCRYPTO_CIPHER_ALG_TWOFISH_128] = 16, [QCRYPTO_CIPHER_ALGO_TWOFISH_128] = 16,
[QCRYPTO_CIPHER_ALG_TWOFISH_192] = 24, [QCRYPTO_CIPHER_ALGO_TWOFISH_192] = 24,
[QCRYPTO_CIPHER_ALG_TWOFISH_256] = 32, [QCRYPTO_CIPHER_ALGO_TWOFISH_256] = 32,
#ifdef CONFIG_CRYPTO_SM4 #ifdef CONFIG_CRYPTO_SM4
[QCRYPTO_CIPHER_ALG_SM4] = 16, [QCRYPTO_CIPHER_ALGO_SM4] = 16,
#endif #endif
}; };
static const size_t alg_block_len[QCRYPTO_CIPHER_ALG__MAX] = { static const size_t alg_block_len[QCRYPTO_CIPHER_ALGO__MAX] = {
[QCRYPTO_CIPHER_ALG_AES_128] = 16, [QCRYPTO_CIPHER_ALGO_AES_128] = 16,
[QCRYPTO_CIPHER_ALG_AES_192] = 16, [QCRYPTO_CIPHER_ALGO_AES_192] = 16,
[QCRYPTO_CIPHER_ALG_AES_256] = 16, [QCRYPTO_CIPHER_ALGO_AES_256] = 16,
[QCRYPTO_CIPHER_ALG_DES] = 8, [QCRYPTO_CIPHER_ALGO_DES] = 8,
[QCRYPTO_CIPHER_ALG_3DES] = 8, [QCRYPTO_CIPHER_ALGO_3DES] = 8,
[QCRYPTO_CIPHER_ALG_CAST5_128] = 8, [QCRYPTO_CIPHER_ALGO_CAST5_128] = 8,
[QCRYPTO_CIPHER_ALG_SERPENT_128] = 16, [QCRYPTO_CIPHER_ALGO_SERPENT_128] = 16,
[QCRYPTO_CIPHER_ALG_SERPENT_192] = 16, [QCRYPTO_CIPHER_ALGO_SERPENT_192] = 16,
[QCRYPTO_CIPHER_ALG_SERPENT_256] = 16, [QCRYPTO_CIPHER_ALGO_SERPENT_256] = 16,
[QCRYPTO_CIPHER_ALG_TWOFISH_128] = 16, [QCRYPTO_CIPHER_ALGO_TWOFISH_128] = 16,
[QCRYPTO_CIPHER_ALG_TWOFISH_192] = 16, [QCRYPTO_CIPHER_ALGO_TWOFISH_192] = 16,
[QCRYPTO_CIPHER_ALG_TWOFISH_256] = 16, [QCRYPTO_CIPHER_ALGO_TWOFISH_256] = 16,
#ifdef CONFIG_CRYPTO_SM4 #ifdef CONFIG_CRYPTO_SM4
[QCRYPTO_CIPHER_ALG_SM4] = 16, [QCRYPTO_CIPHER_ALGO_SM4] = 16,
#endif #endif
}; };
@ -69,21 +69,21 @@ static const bool mode_need_iv[QCRYPTO_CIPHER_MODE__MAX] = {
}; };
size_t qcrypto_cipher_get_block_len(QCryptoCipherAlgorithm alg) size_t qcrypto_cipher_get_block_len(QCryptoCipherAlgo alg)
{ {
assert(alg < G_N_ELEMENTS(alg_key_len)); assert(alg < G_N_ELEMENTS(alg_key_len));
return alg_block_len[alg]; return alg_block_len[alg];
} }
size_t qcrypto_cipher_get_key_len(QCryptoCipherAlgorithm alg) size_t qcrypto_cipher_get_key_len(QCryptoCipherAlgo alg)
{ {
assert(alg < G_N_ELEMENTS(alg_key_len)); assert(alg < G_N_ELEMENTS(alg_key_len));
return alg_key_len[alg]; return alg_key_len[alg];
} }
size_t qcrypto_cipher_get_iv_len(QCryptoCipherAlgorithm alg, size_t qcrypto_cipher_get_iv_len(QCryptoCipherAlgo alg,
QCryptoCipherMode mode) QCryptoCipherMode mode)
{ {
if (alg >= G_N_ELEMENTS(alg_block_len)) { if (alg >= G_N_ELEMENTS(alg_block_len)) {
@ -101,20 +101,20 @@ size_t qcrypto_cipher_get_iv_len(QCryptoCipherAlgorithm alg,
static bool static bool
qcrypto_cipher_validate_key_length(QCryptoCipherAlgorithm alg, qcrypto_cipher_validate_key_length(QCryptoCipherAlgo alg,
QCryptoCipherMode mode, QCryptoCipherMode mode,
size_t nkey, size_t nkey,
Error **errp) Error **errp)
{ {
if ((unsigned)alg >= QCRYPTO_CIPHER_ALG__MAX) { if ((unsigned)alg >= QCRYPTO_CIPHER_ALGO__MAX) {
error_setg(errp, "Cipher algorithm %d out of range", error_setg(errp, "Cipher algorithm %d out of range",
alg); alg);
return false; return false;
} }
if (mode == QCRYPTO_CIPHER_MODE_XTS) { if (mode == QCRYPTO_CIPHER_MODE_XTS) {
if (alg == QCRYPTO_CIPHER_ALG_DES || if (alg == QCRYPTO_CIPHER_ALGO_DES ||
alg == QCRYPTO_CIPHER_ALG_3DES) { alg == QCRYPTO_CIPHER_ALGO_3DES) {
error_setg(errp, "XTS mode not compatible with DES/3DES"); error_setg(errp, "XTS mode not compatible with DES/3DES");
return false; return false;
} }
@ -148,7 +148,7 @@ qcrypto_cipher_validate_key_length(QCryptoCipherAlgorithm alg,
#include "cipher-builtin.c.inc" #include "cipher-builtin.c.inc"
#endif #endif
QCryptoCipher *qcrypto_cipher_new(QCryptoCipherAlgorithm alg, QCryptoCipher *qcrypto_cipher_new(QCryptoCipherAlgo alg,
QCryptoCipherMode mode, QCryptoCipherMode mode,
const uint8_t *key, size_t nkey, const uint8_t *key, size_t nkey,
Error **errp) Error **errp)

2
crypto/cipherpriv.h
View File

@ -42,7 +42,7 @@ struct QCryptoCipherDriver {
#include "afalgpriv.h" #include "afalgpriv.h"
extern QCryptoCipher * extern QCryptoCipher *
qcrypto_afalg_cipher_ctx_new(QCryptoCipherAlgorithm alg, qcrypto_afalg_cipher_ctx_new(QCryptoCipherAlgo alg,
QCryptoCipherMode mode, QCryptoCipherMode mode,
const uint8_t *key, const uint8_t *key,
size_t nkey, Error **errp); size_t nkey, Error **errp);

4
crypto/ivgen.c
View File

@ -28,7 +28,7 @@
QCryptoIVGen *qcrypto_ivgen_new(QCryptoIVGenAlgorithm alg, QCryptoIVGen *qcrypto_ivgen_new(QCryptoIVGenAlgorithm alg,
QCryptoCipherAlgorithm cipheralg, QCryptoCipherAlgo cipheralg,
QCryptoHashAlgo hash, QCryptoHashAlgo hash,
const uint8_t *key, size_t nkey, const uint8_t *key, size_t nkey,
Error **errp) Error **errp)
@ -79,7 +79,7 @@ QCryptoIVGenAlgorithm qcrypto_ivgen_get_algorithm(QCryptoIVGen *ivgen)
} }
QCryptoCipherAlgorithm qcrypto_ivgen_get_cipher(QCryptoIVGen *ivgen) QCryptoCipherAlgo qcrypto_ivgen_get_cipher(QCryptoIVGen *ivgen)
{ {
return ivgen->cipher; return ivgen->cipher;
} }

2
crypto/ivgenpriv.h
View File

@ -41,7 +41,7 @@ struct QCryptoIVGen {
void *private; void *private;
QCryptoIVGenAlgorithm algorithm; QCryptoIVGenAlgorithm algorithm;
QCryptoCipherAlgorithm cipher; QCryptoCipherAlgo cipher;
QCryptoHashAlgo hash; QCryptoHashAlgo hash;
}; };

2
crypto/secret_common.c
View File

@ -71,7 +71,7 @@ static void qcrypto_secret_decrypt(QCryptoSecretCommon *secret,
return; return;
} }
aes = qcrypto_cipher_new(QCRYPTO_CIPHER_ALG_AES_256, aes = qcrypto_cipher_new(QCRYPTO_CIPHER_ALGO_AES_256,
QCRYPTO_CIPHER_MODE_CBC, QCRYPTO_CIPHER_MODE_CBC,
key, keylen, key, keylen,
errp); errp);

18
include/crypto/cipher.h
View File

@ -26,7 +26,7 @@
typedef struct QCryptoCipher QCryptoCipher; typedef struct QCryptoCipher QCryptoCipher;
typedef struct QCryptoCipherDriver QCryptoCipherDriver; typedef struct QCryptoCipherDriver QCryptoCipherDriver;
/* See also "QCryptoCipherAlgorithm" and "QCryptoCipherMode" /* See also "QCryptoCipherAlgo" and "QCryptoCipherMode"
* enums defined in qapi/crypto.json */ * enums defined in qapi/crypto.json */
/** /**
@ -50,12 +50,12 @@ typedef struct QCryptoCipherDriver QCryptoCipherDriver;
* size_t keylen = 16; * size_t keylen = 16;
* uint8_t iv = ....; * uint8_t iv = ....;
* *
* if (!qcrypto_cipher_supports(QCRYPTO_CIPHER_ALG_AES_128)) { * if (!qcrypto_cipher_supports(QCRYPTO_CIPHER_ALGO_AES_128)) {
* error_report(errp, "Feature <blah> requires AES cipher support"); * error_report(errp, "Feature <blah> requires AES cipher support");
* return -1; * return -1;
* } * }
* *
* cipher = qcrypto_cipher_new(QCRYPTO_CIPHER_ALG_AES_128, * cipher = qcrypto_cipher_new(QCRYPTO_CIPHER_ALGO_AES_128,
* QCRYPTO_CIPHER_MODE_CBC, * QCRYPTO_CIPHER_MODE_CBC,
* key, keylen, * key, keylen,
* errp); * errp);
@ -78,7 +78,7 @@ typedef struct QCryptoCipherDriver QCryptoCipherDriver;
*/ */
struct QCryptoCipher { struct QCryptoCipher {
QCryptoCipherAlgorithm alg; QCryptoCipherAlgo alg;
QCryptoCipherMode mode; QCryptoCipherMode mode;
const QCryptoCipherDriver *driver; const QCryptoCipherDriver *driver;
}; };
@ -93,7 +93,7 @@ struct QCryptoCipher {
* *
* Returns: true if the algorithm is supported, false otherwise * Returns: true if the algorithm is supported, false otherwise
*/ */
bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg, bool qcrypto_cipher_supports(QCryptoCipherAlgo alg,
QCryptoCipherMode mode); QCryptoCipherMode mode);
/** /**
@ -106,7 +106,7 @@ bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg,
* *
* Returns: the block size in bytes * Returns: the block size in bytes
*/ */
size_t qcrypto_cipher_get_block_len(QCryptoCipherAlgorithm alg); size_t qcrypto_cipher_get_block_len(QCryptoCipherAlgo alg);
/** /**
@ -117,7 +117,7 @@ size_t qcrypto_cipher_get_block_len(QCryptoCipherAlgorithm alg);
* *
* Returns: the key size in bytes * Returns: the key size in bytes
*/ */
size_t qcrypto_cipher_get_key_len(QCryptoCipherAlgorithm alg); size_t qcrypto_cipher_get_key_len(QCryptoCipherAlgo alg);
/** /**
@ -130,7 +130,7 @@ size_t qcrypto_cipher_get_key_len(QCryptoCipherAlgorithm alg);
* *
* Returns: the IV size in bytes, or 0 if no IV is permitted * Returns: the IV size in bytes, or 0 if no IV is permitted
*/ */
size_t qcrypto_cipher_get_iv_len(QCryptoCipherAlgorithm alg, size_t qcrypto_cipher_get_iv_len(QCryptoCipherAlgo alg,
QCryptoCipherMode mode); QCryptoCipherMode mode);
@ -156,7 +156,7 @@ size_t qcrypto_cipher_get_iv_len(QCryptoCipherAlgorithm alg,
* *
* Returns: a new cipher object, or NULL on error * Returns: a new cipher object, or NULL on error
*/ */
QCryptoCipher *qcrypto_cipher_new(QCryptoCipherAlgorithm alg, QCryptoCipher *qcrypto_cipher_new(QCryptoCipherAlgo alg,
QCryptoCipherMode mode, QCryptoCipherMode mode,
const uint8_t *key, size_t nkey, const uint8_t *key, size_t nkey,
Error **errp); Error **errp);

10
include/crypto/ivgen.h
View File

@ -45,21 +45,21 @@
* g_assert((ndata % 512) == 0); * g_assert((ndata % 512) == 0);
* *
* QCryptoIVGen *ivgen = qcrypto_ivgen_new(QCRYPTO_IVGEN_ALG_ESSIV, * QCryptoIVGen *ivgen = qcrypto_ivgen_new(QCRYPTO_IVGEN_ALG_ESSIV,
* QCRYPTO_CIPHER_ALG_AES_128, * QCRYPTO_CIPHER_ALGO_AES_128,
* QCRYPTO_HASH_ALGO_SHA256, * QCRYPTO_HASH_ALGO_SHA256,
* key, nkey, errp); * key, nkey, errp);
* if (!ivgen) { * if (!ivgen) {
* return -1; * return -1;
* } * }
* *
* QCryptoCipher *cipher = qcrypto_cipher_new(QCRYPTO_CIPHER_ALG_AES_128, * QCryptoCipher *cipher = qcrypto_cipher_new(QCRYPTO_CIPHER_ALGO_AES_128,
* QCRYPTO_CIPHER_MODE_CBC, * QCRYPTO_CIPHER_MODE_CBC,
* key, nkey, errp); * key, nkey, errp);
* if (!cipher) { * if (!cipher) {
* goto error; * goto error;
* } * }
* *
* niv = qcrypto_cipher_get_iv_len(QCRYPTO_CIPHER_ALG_AES_128, * niv = qcrypto_cipher_get_iv_len(QCRYPTO_CIPHER_ALGO_AES_128,
* QCRYPTO_CIPHER_MODE_CBC); * QCRYPTO_CIPHER_MODE_CBC);
* iv = g_new0(uint8_t, niv); * iv = g_new0(uint8_t, niv);
* *
@ -134,7 +134,7 @@ typedef struct QCryptoIVGen QCryptoIVGen;
* Returns: a new IV generator, or NULL on error * Returns: a new IV generator, or NULL on error
*/ */
QCryptoIVGen *qcrypto_ivgen_new(QCryptoIVGenAlgorithm alg, QCryptoIVGen *qcrypto_ivgen_new(QCryptoIVGenAlgorithm alg,
QCryptoCipherAlgorithm cipheralg, QCryptoCipherAlgo cipheralg,
QCryptoHashAlgo hash, QCryptoHashAlgo hash,
const uint8_t *key, size_t nkey, const uint8_t *key, size_t nkey,
Error **errp); Error **errp);
@ -179,7 +179,7 @@ QCryptoIVGenAlgorithm qcrypto_ivgen_get_algorithm(QCryptoIVGen *ivgen);
* *
* Returns: the cipher algorithm * Returns: the cipher algorithm
*/ */
QCryptoCipherAlgorithm qcrypto_ivgen_get_cipher(QCryptoIVGen *ivgen); QCryptoCipherAlgo qcrypto_ivgen_get_cipher(QCryptoIVGen *ivgen);
/** /**

4
include/crypto/pbkdf.h
View File

@ -38,7 +38,7 @@
* .... * ....
* *
* char *password = "a-typical-awful-user-password"; * char *password = "a-typical-awful-user-password";
* size_t nkey = qcrypto_cipher_get_key_len(QCRYPTO_CIPHER_ALG_AES_128); * size_t nkey = qcrypto_cipher_get_key_len(QCRYPTO_CIPHER_ALGO_AES_128);
* uint8_t *salt = g_new0(uint8_t, nkey); * uint8_t *salt = g_new0(uint8_t, nkey);
* uint8_t *key = g_new0(uint8_t, nkey); * uint8_t *key = g_new0(uint8_t, nkey);
* int iterations; * int iterations;
@ -70,7 +70,7 @@
* *
* g_free(salt); * g_free(salt);
* *
* cipher = qcrypto_cipher_new(QCRYPTO_CIPHER_ALG_AES_128, * cipher = qcrypto_cipher_new(QCRYPTO_CIPHER_ALGO_AES_128,
* QCRYPTO_CIPHER_MODE_ECB, * QCRYPTO_CIPHER_MODE_ECB,
* key, nkey, errp); * key, nkey, errp);
* g_free(key); * g_free(key);

2
qapi/block-core.json
View File

@ -4163,7 +4163,7 @@
## ##
{ 'struct': 'RbdEncryptionCreateOptionsLUKSBase', { 'struct': 'RbdEncryptionCreateOptionsLUKSBase',
'base': 'RbdEncryptionOptionsLUKSBase', 'base': 'RbdEncryptionOptionsLUKSBase',
'data': { '*cipher-alg': 'QCryptoCipherAlgorithm' } } 'data': { '*cipher-alg': 'QCryptoCipherAlgo' } }
## ##
# @RbdEncryptionOptionsLUKS: # @RbdEncryptionOptionsLUKS:

9
qapi/crypto.json
View File

@ -62,7 +62,7 @@
'data': ['md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'ripemd160']} 'data': ['md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'ripemd160']}
## ##
# @QCryptoCipherAlgorithm: # @QCryptoCipherAlgo:
# #
# The supported algorithms for content encryption ciphers # The supported algorithms for content encryption ciphers
# #
@ -95,8 +95,7 @@
# #
# Since: 2.6 # Since: 2.6
## ##
{ 'enum': 'QCryptoCipherAlgorithm', { 'enum': 'QCryptoCipherAlgo',
'prefix': 'QCRYPTO_CIPHER_ALG',
'data': ['aes-128', 'aes-192', 'aes-256', 'data': ['aes-128', 'aes-192', 'aes-256',
'des', '3des', 'des', '3des',
'cast5-128', 'cast5-128',
@ -225,7 +224,7 @@
## ##
{ 'struct': 'QCryptoBlockCreateOptionsLUKS', { 'struct': 'QCryptoBlockCreateOptionsLUKS',
'base': 'QCryptoBlockOptionsLUKS', 'base': 'QCryptoBlockOptionsLUKS',
'data': { '*cipher-alg': 'QCryptoCipherAlgorithm', 'data': { '*cipher-alg': 'QCryptoCipherAlgo',
'*cipher-mode': 'QCryptoCipherMode', '*cipher-mode': 'QCryptoCipherMode',
'*ivgen-alg': 'QCryptoIVGenAlgorithm', '*ivgen-alg': 'QCryptoIVGenAlgorithm',
'*ivgen-hash-alg': 'QCryptoHashAlgo', '*ivgen-hash-alg': 'QCryptoHashAlgo',
@ -322,7 +321,7 @@
# Since: 2.7 # Since: 2.7
## ##
{ 'struct': 'QCryptoBlockInfoLUKS', { 'struct': 'QCryptoBlockInfoLUKS',
'data': {'cipher-alg': 'QCryptoCipherAlgorithm', 'data': {'cipher-alg': 'QCryptoCipherAlgo',
'cipher-mode': 'QCryptoCipherMode', 'cipher-mode': 'QCryptoCipherMode',
'ivgen-alg': 'QCryptoIVGenAlgorithm', 'ivgen-alg': 'QCryptoIVGenAlgorithm',
'*ivgen-hash-alg': 'QCryptoHashAlgo', '*ivgen-hash-alg': 'QCryptoHashAlgo',

22
tests/bench/benchmark-crypto-cipher.c
View File

@ -17,7 +17,7 @@
static void test_cipher_speed(size_t chunk_size, static void test_cipher_speed(size_t chunk_size,
QCryptoCipherMode mode, QCryptoCipherMode mode,
QCryptoCipherAlgorithm alg) QCryptoCipherAlgo alg)
{ {
QCryptoCipher *cipher; QCryptoCipher *cipher;
Error *err = NULL; Error *err = NULL;
@ -71,7 +71,7 @@ static void test_cipher_speed(size_t chunk_size,
g_test_timer_elapsed(); g_test_timer_elapsed();
g_test_message("enc(%s-%s) chunk %zu bytes %.2f MB/sec ", g_test_message("enc(%s-%s) chunk %zu bytes %.2f MB/sec ",
QCryptoCipherAlgorithm_str(alg), QCryptoCipherAlgo_str(alg),
QCryptoCipherMode_str(mode), QCryptoCipherMode_str(mode),
chunk_size, (double)total / MiB / g_test_timer_last()); chunk_size, (double)total / MiB / g_test_timer_last());
@ -88,7 +88,7 @@ static void test_cipher_speed(size_t chunk_size,
g_test_timer_elapsed(); g_test_timer_elapsed();
g_test_message("dec(%s-%s) chunk %zu bytes %.2f MB/sec ", g_test_message("dec(%s-%s) chunk %zu bytes %.2f MB/sec ",
QCryptoCipherAlgorithm_str(alg), QCryptoCipherAlgo_str(alg),
QCryptoCipherMode_str(mode), QCryptoCipherMode_str(mode),
chunk_size, (double)total / MiB / g_test_timer_last()); chunk_size, (double)total / MiB / g_test_timer_last());
@ -105,7 +105,7 @@ static void test_cipher_speed_ecb_aes_128(const void *opaque)
size_t chunk_size = (size_t)opaque; size_t chunk_size = (size_t)opaque;
test_cipher_speed(chunk_size, test_cipher_speed(chunk_size,
QCRYPTO_CIPHER_MODE_ECB, QCRYPTO_CIPHER_MODE_ECB,
QCRYPTO_CIPHER_ALG_AES_128); QCRYPTO_CIPHER_ALGO_AES_128);
} }
static void test_cipher_speed_ecb_aes_256(const void *opaque) static void test_cipher_speed_ecb_aes_256(const void *opaque)
@ -113,7 +113,7 @@ static void test_cipher_speed_ecb_aes_256(const void *opaque)
size_t chunk_size = (size_t)opaque; size_t chunk_size = (size_t)opaque;
test_cipher_speed(chunk_size, test_cipher_speed(chunk_size,
QCRYPTO_CIPHER_MODE_ECB, QCRYPTO_CIPHER_MODE_ECB,
QCRYPTO_CIPHER_ALG_AES_256); QCRYPTO_CIPHER_ALGO_AES_256);
} }
static void test_cipher_speed_cbc_aes_128(const void *opaque) static void test_cipher_speed_cbc_aes_128(const void *opaque)
@ -121,7 +121,7 @@ static void test_cipher_speed_cbc_aes_128(const void *opaque)
size_t chunk_size = (size_t)opaque; size_t chunk_size = (size_t)opaque;
test_cipher_speed(chunk_size, test_cipher_speed(chunk_size,
QCRYPTO_CIPHER_MODE_CBC, QCRYPTO_CIPHER_MODE_CBC,
QCRYPTO_CIPHER_ALG_AES_128); QCRYPTO_CIPHER_ALGO_AES_128);
} }
static void test_cipher_speed_cbc_aes_256(const void *opaque) static void test_cipher_speed_cbc_aes_256(const void *opaque)
@ -129,7 +129,7 @@ static void test_cipher_speed_cbc_aes_256(const void *opaque)
size_t chunk_size = (size_t)opaque; size_t chunk_size = (size_t)opaque;
test_cipher_speed(chunk_size, test_cipher_speed(chunk_size,
QCRYPTO_CIPHER_MODE_CBC, QCRYPTO_CIPHER_MODE_CBC,
QCRYPTO_CIPHER_ALG_AES_256); QCRYPTO_CIPHER_ALGO_AES_256);
} }
static void test_cipher_speed_ctr_aes_128(const void *opaque) static void test_cipher_speed_ctr_aes_128(const void *opaque)
@ -137,7 +137,7 @@ static void test_cipher_speed_ctr_aes_128(const void *opaque)
size_t chunk_size = (size_t)opaque; size_t chunk_size = (size_t)opaque;
test_cipher_speed(chunk_size, test_cipher_speed(chunk_size,
QCRYPTO_CIPHER_MODE_CTR, QCRYPTO_CIPHER_MODE_CTR,
QCRYPTO_CIPHER_ALG_AES_128); QCRYPTO_CIPHER_ALGO_AES_128);
} }
static void test_cipher_speed_ctr_aes_256(const void *opaque) static void test_cipher_speed_ctr_aes_256(const void *opaque)
@ -145,7 +145,7 @@ static void test_cipher_speed_ctr_aes_256(const void *opaque)
size_t chunk_size = (size_t)opaque; size_t chunk_size = (size_t)opaque;
test_cipher_speed(chunk_size, test_cipher_speed(chunk_size,
QCRYPTO_CIPHER_MODE_CTR, QCRYPTO_CIPHER_MODE_CTR,
QCRYPTO_CIPHER_ALG_AES_256); QCRYPTO_CIPHER_ALGO_AES_256);
} }
static void test_cipher_speed_xts_aes_128(const void *opaque) static void test_cipher_speed_xts_aes_128(const void *opaque)
@ -153,7 +153,7 @@ static void test_cipher_speed_xts_aes_128(const void *opaque)
size_t chunk_size = (size_t)opaque; size_t chunk_size = (size_t)opaque;
test_cipher_speed(chunk_size, test_cipher_speed(chunk_size,
QCRYPTO_CIPHER_MODE_XTS, QCRYPTO_CIPHER_MODE_XTS,
QCRYPTO_CIPHER_ALG_AES_128); QCRYPTO_CIPHER_ALGO_AES_128);
} }
static void test_cipher_speed_xts_aes_256(const void *opaque) static void test_cipher_speed_xts_aes_256(const void *opaque)
@ -161,7 +161,7 @@ static void test_cipher_speed_xts_aes_256(const void *opaque)
size_t chunk_size = (size_t)opaque; size_t chunk_size = (size_t)opaque;
test_cipher_speed(chunk_size, test_cipher_speed(chunk_size,
QCRYPTO_CIPHER_MODE_XTS, QCRYPTO_CIPHER_MODE_XTS,
QCRYPTO_CIPHER_ALG_AES_256); QCRYPTO_CIPHER_ALGO_AES_256);
} }

14
tests/unit/test-crypto-block.c
View File

@ -77,7 +77,7 @@ static QCryptoBlockCreateOptions luks_create_opts_aes256_cbc_plain64 = {
.u.luks = { .u.luks = {
.key_secret = (char *)"sec0", .key_secret = (char *)"sec0",
.has_cipher_alg = true, .has_cipher_alg = true,
.cipher_alg = QCRYPTO_CIPHER_ALG_AES_256, .cipher_alg = QCRYPTO_CIPHER_ALGO_AES_256,
.has_cipher_mode = true, .has_cipher_mode = true,
.cipher_mode = QCRYPTO_CIPHER_MODE_CBC, .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
.has_ivgen_alg = true, .has_ivgen_alg = true,
@ -91,7 +91,7 @@ static QCryptoBlockCreateOptions luks_create_opts_aes256_cbc_essiv = {
.u.luks = { .u.luks = {
.key_secret = (char *)"sec0", .key_secret = (char *)"sec0",
.has_cipher_alg = true, .has_cipher_alg = true,
.cipher_alg = QCRYPTO_CIPHER_ALG_AES_256, .cipher_alg = QCRYPTO_CIPHER_ALGO_AES_256,
.has_cipher_mode = true, .has_cipher_mode = true,
.cipher_mode = QCRYPTO_CIPHER_MODE_CBC, .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
.has_ivgen_alg = true, .has_ivgen_alg = true,
@ -112,7 +112,7 @@ static struct QCryptoBlockTestData {
bool expect_header; bool expect_header;
QCryptoCipherAlgorithm cipher_alg; QCryptoCipherAlgo cipher_alg;
QCryptoCipherMode cipher_mode; QCryptoCipherMode cipher_mode;
QCryptoHashAlgo hash_alg; QCryptoHashAlgo hash_alg;
@ -128,7 +128,7 @@ static struct QCryptoBlockTestData {
.expect_header = false, .expect_header = false,
.cipher_alg = QCRYPTO_CIPHER_ALG_AES_128, .cipher_alg = QCRYPTO_CIPHER_ALGO_AES_128,
.cipher_mode = QCRYPTO_CIPHER_MODE_CBC, .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
.ivgen_alg = QCRYPTO_IVGEN_ALG_PLAIN64, .ivgen_alg = QCRYPTO_IVGEN_ALG_PLAIN64,
@ -141,7 +141,7 @@ static struct QCryptoBlockTestData {
.expect_header = true, .expect_header = true,
.cipher_alg = QCRYPTO_CIPHER_ALG_AES_256, .cipher_alg = QCRYPTO_CIPHER_ALGO_AES_256,
.cipher_mode = QCRYPTO_CIPHER_MODE_XTS, .cipher_mode = QCRYPTO_CIPHER_MODE_XTS,
.hash_alg = QCRYPTO_HASH_ALGO_SHA256, .hash_alg = QCRYPTO_HASH_ALGO_SHA256,
@ -156,7 +156,7 @@ static struct QCryptoBlockTestData {
.expect_header = true, .expect_header = true,
.cipher_alg = QCRYPTO_CIPHER_ALG_AES_256, .cipher_alg = QCRYPTO_CIPHER_ALGO_AES_256,
.cipher_mode = QCRYPTO_CIPHER_MODE_CBC, .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
.hash_alg = QCRYPTO_HASH_ALGO_SHA256, .hash_alg = QCRYPTO_HASH_ALGO_SHA256,
@ -171,7 +171,7 @@ static struct QCryptoBlockTestData {
.expect_header = true, .expect_header = true,
.cipher_alg = QCRYPTO_CIPHER_ALG_AES_256, .cipher_alg = QCRYPTO_CIPHER_ALGO_AES_256,
.cipher_mode = QCRYPTO_CIPHER_MODE_CBC, .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
.hash_alg = QCRYPTO_HASH_ALGO_SHA1, .hash_alg = QCRYPTO_HASH_ALGO_SHA1,

66
tests/unit/test-crypto-cipher.c
View File

@ -27,7 +27,7 @@
typedef struct QCryptoCipherTestData QCryptoCipherTestData; typedef struct QCryptoCipherTestData QCryptoCipherTestData;
struct QCryptoCipherTestData { struct QCryptoCipherTestData {
const char *path; const char *path;
QCryptoCipherAlgorithm alg; QCryptoCipherAlgo alg;
QCryptoCipherMode mode; QCryptoCipherMode mode;
const char *key; const char *key;
const char *plaintext; const char *plaintext;
@ -43,7 +43,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* NIST F.1.1 ECB-AES128.Encrypt */ /* NIST F.1.1 ECB-AES128.Encrypt */
.path = "/crypto/cipher/aes-ecb-128", .path = "/crypto/cipher/aes-ecb-128",
.alg = QCRYPTO_CIPHER_ALG_AES_128, .alg = QCRYPTO_CIPHER_ALGO_AES_128,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = "2b7e151628aed2a6abf7158809cf4f3c", .key = "2b7e151628aed2a6abf7158809cf4f3c",
.plaintext = .plaintext =
@ -60,7 +60,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* NIST F.1.3 ECB-AES192.Encrypt */ /* NIST F.1.3 ECB-AES192.Encrypt */
.path = "/crypto/cipher/aes-ecb-192", .path = "/crypto/cipher/aes-ecb-192",
.alg = QCRYPTO_CIPHER_ALG_AES_192, .alg = QCRYPTO_CIPHER_ALGO_AES_192,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b", .key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
.plaintext = .plaintext =
@ -77,7 +77,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* NIST F.1.5 ECB-AES256.Encrypt */ /* NIST F.1.5 ECB-AES256.Encrypt */
.path = "/crypto/cipher/aes-ecb-256", .path = "/crypto/cipher/aes-ecb-256",
.alg = QCRYPTO_CIPHER_ALG_AES_256, .alg = QCRYPTO_CIPHER_ALGO_AES_256,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = .key =
"603deb1015ca71be2b73aef0857d7781" "603deb1015ca71be2b73aef0857d7781"
@ -96,7 +96,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* NIST F.2.1 CBC-AES128.Encrypt */ /* NIST F.2.1 CBC-AES128.Encrypt */
.path = "/crypto/cipher/aes-cbc-128", .path = "/crypto/cipher/aes-cbc-128",
.alg = QCRYPTO_CIPHER_ALG_AES_128, .alg = QCRYPTO_CIPHER_ALGO_AES_128,
.mode = QCRYPTO_CIPHER_MODE_CBC, .mode = QCRYPTO_CIPHER_MODE_CBC,
.key = "2b7e151628aed2a6abf7158809cf4f3c", .key = "2b7e151628aed2a6abf7158809cf4f3c",
.iv = "000102030405060708090a0b0c0d0e0f", .iv = "000102030405060708090a0b0c0d0e0f",
@ -114,7 +114,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* NIST F.2.3 CBC-AES128.Encrypt */ /* NIST F.2.3 CBC-AES128.Encrypt */
.path = "/crypto/cipher/aes-cbc-192", .path = "/crypto/cipher/aes-cbc-192",
.alg = QCRYPTO_CIPHER_ALG_AES_192, .alg = QCRYPTO_CIPHER_ALGO_AES_192,
.mode = QCRYPTO_CIPHER_MODE_CBC, .mode = QCRYPTO_CIPHER_MODE_CBC,
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b", .key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
.iv = "000102030405060708090a0b0c0d0e0f", .iv = "000102030405060708090a0b0c0d0e0f",
@ -132,7 +132,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* NIST F.2.5 CBC-AES128.Encrypt */ /* NIST F.2.5 CBC-AES128.Encrypt */
.path = "/crypto/cipher/aes-cbc-256", .path = "/crypto/cipher/aes-cbc-256",
.alg = QCRYPTO_CIPHER_ALG_AES_256, .alg = QCRYPTO_CIPHER_ALGO_AES_256,
.mode = QCRYPTO_CIPHER_MODE_CBC, .mode = QCRYPTO_CIPHER_MODE_CBC,
.key = .key =
"603deb1015ca71be2b73aef0857d7781" "603deb1015ca71be2b73aef0857d7781"
@ -156,7 +156,7 @@ static QCryptoCipherTestData test_data[] = {
* ciphertext in ECB and CBC modes * ciphertext in ECB and CBC modes
*/ */
.path = "/crypto/cipher/des-ecb-56-one-block", .path = "/crypto/cipher/des-ecb-56-one-block",
.alg = QCRYPTO_CIPHER_ALG_DES, .alg = QCRYPTO_CIPHER_ALGO_DES,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = "80c4a2e691d5b3f7", .key = "80c4a2e691d5b3f7",
.plaintext = "70617373776f7264", .plaintext = "70617373776f7264",
@ -165,7 +165,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* See previous comment */ /* See previous comment */
.path = "/crypto/cipher/des-cbc-56-one-block", .path = "/crypto/cipher/des-cbc-56-one-block",
.alg = QCRYPTO_CIPHER_ALG_DES, .alg = QCRYPTO_CIPHER_ALGO_DES,
.mode = QCRYPTO_CIPHER_MODE_CBC, .mode = QCRYPTO_CIPHER_MODE_CBC,
.key = "80c4a2e691d5b3f7", .key = "80c4a2e691d5b3f7",
.iv = "0000000000000000", .iv = "0000000000000000",
@ -174,7 +174,7 @@ static QCryptoCipherTestData test_data[] = {
}, },
{ {
.path = "/crypto/cipher/des-ecb-56", .path = "/crypto/cipher/des-ecb-56",
.alg = QCRYPTO_CIPHER_ALG_DES, .alg = QCRYPTO_CIPHER_ALGO_DES,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = "80c4a2e691d5b3f7", .key = "80c4a2e691d5b3f7",
.plaintext = .plaintext =
@ -191,7 +191,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* Borrowed from linux-kernel crypto/testmgr.h */ /* Borrowed from linux-kernel crypto/testmgr.h */
.path = "/crypto/cipher/3des-cbc", .path = "/crypto/cipher/3des-cbc",
.alg = QCRYPTO_CIPHER_ALG_3DES, .alg = QCRYPTO_CIPHER_ALGO_3DES,
.mode = QCRYPTO_CIPHER_MODE_CBC, .mode = QCRYPTO_CIPHER_MODE_CBC,
.key = .key =
"e9c0ff2e760b6424444d995a12d640c0" "e9c0ff2e760b6424444d995a12d640c0"
@ -220,7 +220,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* Borrowed from linux-kernel crypto/testmgr.h */ /* Borrowed from linux-kernel crypto/testmgr.h */
.path = "/crypto/cipher/3des-ecb", .path = "/crypto/cipher/3des-ecb",
.alg = QCRYPTO_CIPHER_ALG_3DES, .alg = QCRYPTO_CIPHER_ALGO_3DES,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = .key =
"0123456789abcdef5555555555555555" "0123456789abcdef5555555555555555"
@ -233,7 +233,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* Borrowed from linux-kernel crypto/testmgr.h */ /* Borrowed from linux-kernel crypto/testmgr.h */
.path = "/crypto/cipher/3des-ctr", .path = "/crypto/cipher/3des-ctr",
.alg = QCRYPTO_CIPHER_ALG_3DES, .alg = QCRYPTO_CIPHER_ALGO_3DES,
.mode = QCRYPTO_CIPHER_MODE_CTR, .mode = QCRYPTO_CIPHER_MODE_CTR,
.key = .key =
"9cd6f39cb95a67005a67002dceeb2dce" "9cd6f39cb95a67005a67002dceeb2dce"
@ -308,7 +308,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* RFC 2144, Appendix B.1 */ /* RFC 2144, Appendix B.1 */
.path = "/crypto/cipher/cast5-128", .path = "/crypto/cipher/cast5-128",
.alg = QCRYPTO_CIPHER_ALG_CAST5_128, .alg = QCRYPTO_CIPHER_ALGO_CAST5_128,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = "0123456712345678234567893456789A", .key = "0123456712345678234567893456789A",
.plaintext = "0123456789abcdef", .plaintext = "0123456789abcdef",
@ -317,7 +317,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* libgcrypt serpent.c */ /* libgcrypt serpent.c */
.path = "/crypto/cipher/serpent-128", .path = "/crypto/cipher/serpent-128",
.alg = QCRYPTO_CIPHER_ALG_SERPENT_128, .alg = QCRYPTO_CIPHER_ALGO_SERPENT_128,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = "00000000000000000000000000000000", .key = "00000000000000000000000000000000",
.plaintext = "d29d576fcea3a3a7ed9099f29273d78e", .plaintext = "d29d576fcea3a3a7ed9099f29273d78e",
@ -326,7 +326,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* libgcrypt serpent.c */ /* libgcrypt serpent.c */
.path = "/crypto/cipher/serpent-192", .path = "/crypto/cipher/serpent-192",
.alg = QCRYPTO_CIPHER_ALG_SERPENT_192, .alg = QCRYPTO_CIPHER_ALGO_SERPENT_192,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = "00000000000000000000000000000000" .key = "00000000000000000000000000000000"
"0000000000000000", "0000000000000000",
@ -336,7 +336,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* libgcrypt serpent.c */ /* libgcrypt serpent.c */
.path = "/crypto/cipher/serpent-256a", .path = "/crypto/cipher/serpent-256a",
.alg = QCRYPTO_CIPHER_ALG_SERPENT_256, .alg = QCRYPTO_CIPHER_ALGO_SERPENT_256,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = "00000000000000000000000000000000" .key = "00000000000000000000000000000000"
"00000000000000000000000000000000", "00000000000000000000000000000000",
@ -346,7 +346,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* libgcrypt serpent.c */ /* libgcrypt serpent.c */
.path = "/crypto/cipher/serpent-256b", .path = "/crypto/cipher/serpent-256b",
.alg = QCRYPTO_CIPHER_ALG_SERPENT_256, .alg = QCRYPTO_CIPHER_ALGO_SERPENT_256,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = "00000000000000000000000000000000" .key = "00000000000000000000000000000000"
"00000000000000000000000000000000", "00000000000000000000000000000000",
@ -356,7 +356,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* Twofish paper "Known Answer Test" */ /* Twofish paper "Known Answer Test" */
.path = "/crypto/cipher/twofish-128", .path = "/crypto/cipher/twofish-128",
.alg = QCRYPTO_CIPHER_ALG_TWOFISH_128, .alg = QCRYPTO_CIPHER_ALGO_TWOFISH_128,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = "d491db16e7b1c39e86cb086b789f5419", .key = "d491db16e7b1c39e86cb086b789f5419",
.plaintext = "019f9809de1711858faac3a3ba20fbc3", .plaintext = "019f9809de1711858faac3a3ba20fbc3",
@ -365,7 +365,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* Twofish paper "Known Answer Test", I=3 */ /* Twofish paper "Known Answer Test", I=3 */
.path = "/crypto/cipher/twofish-192", .path = "/crypto/cipher/twofish-192",
.alg = QCRYPTO_CIPHER_ALG_TWOFISH_192, .alg = QCRYPTO_CIPHER_ALGO_TWOFISH_192,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = "88b2b2706b105e36b446bb6d731a1e88" .key = "88b2b2706b105e36b446bb6d731a1e88"
"efa71f788965bd44", "efa71f788965bd44",
@ -375,7 +375,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* Twofish paper "Known Answer Test", I=4 */ /* Twofish paper "Known Answer Test", I=4 */
.path = "/crypto/cipher/twofish-256", .path = "/crypto/cipher/twofish-256",
.alg = QCRYPTO_CIPHER_ALG_TWOFISH_256, .alg = QCRYPTO_CIPHER_ALGO_TWOFISH_256,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = "d43bb7556ea32e46f2a282b7d45b4e0d" .key = "d43bb7556ea32e46f2a282b7d45b4e0d"
"57ff739d4dc92c1bd7fc01700cc8216f", "57ff739d4dc92c1bd7fc01700cc8216f",
@ -386,7 +386,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* SM4, GB/T 32907-2016, Appendix A.1 */ /* SM4, GB/T 32907-2016, Appendix A.1 */
.path = "/crypto/cipher/sm4", .path = "/crypto/cipher/sm4",
.alg = QCRYPTO_CIPHER_ALG_SM4, .alg = QCRYPTO_CIPHER_ALGO_SM4,
.mode = QCRYPTO_CIPHER_MODE_ECB, .mode = QCRYPTO_CIPHER_MODE_ECB,
.key = "0123456789abcdeffedcba9876543210", .key = "0123456789abcdeffedcba9876543210",
.plaintext = .plaintext =
@ -398,7 +398,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* #1 32 byte key, 32 byte PTX */ /* #1 32 byte key, 32 byte PTX */
.path = "/crypto/cipher/aes-xts-128-1", .path = "/crypto/cipher/aes-xts-128-1",
.alg = QCRYPTO_CIPHER_ALG_AES_128, .alg = QCRYPTO_CIPHER_ALGO_AES_128,
.mode = QCRYPTO_CIPHER_MODE_XTS, .mode = QCRYPTO_CIPHER_MODE_XTS,
.key = .key =
"00000000000000000000000000000000" "00000000000000000000000000000000"
@ -415,7 +415,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* #2, 32 byte key, 32 byte PTX */ /* #2, 32 byte key, 32 byte PTX */
.path = "/crypto/cipher/aes-xts-128-2", .path = "/crypto/cipher/aes-xts-128-2",
.alg = QCRYPTO_CIPHER_ALG_AES_128, .alg = QCRYPTO_CIPHER_ALGO_AES_128,
.mode = QCRYPTO_CIPHER_MODE_XTS, .mode = QCRYPTO_CIPHER_MODE_XTS,
.key = .key =
"11111111111111111111111111111111" "11111111111111111111111111111111"
@ -432,7 +432,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* #5 from xts.7, 32 byte key, 32 byte PTX */ /* #5 from xts.7, 32 byte key, 32 byte PTX */
.path = "/crypto/cipher/aes-xts-128-3", .path = "/crypto/cipher/aes-xts-128-3",
.alg = QCRYPTO_CIPHER_ALG_AES_128, .alg = QCRYPTO_CIPHER_ALGO_AES_128,
.mode = QCRYPTO_CIPHER_MODE_XTS, .mode = QCRYPTO_CIPHER_MODE_XTS,
.key = .key =
"fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0" "fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0"
@ -449,7 +449,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* #4, 32 byte key, 512 byte PTX */ /* #4, 32 byte key, 512 byte PTX */
.path = "/crypto/cipher/aes-xts-128-4", .path = "/crypto/cipher/aes-xts-128-4",
.alg = QCRYPTO_CIPHER_ALG_AES_128, .alg = QCRYPTO_CIPHER_ALGO_AES_128,
.mode = QCRYPTO_CIPHER_MODE_XTS, .mode = QCRYPTO_CIPHER_MODE_XTS,
.key = .key =
"27182818284590452353602874713526" "27182818284590452353602874713526"
@ -528,7 +528,7 @@ static QCryptoCipherTestData test_data[] = {
* which is incompatible with XTS * which is incompatible with XTS
*/ */
.path = "/crypto/cipher/cast5-xts-128", .path = "/crypto/cipher/cast5-xts-128",
.alg = QCRYPTO_CIPHER_ALG_CAST5_128, .alg = QCRYPTO_CIPHER_ALGO_CAST5_128,
.mode = QCRYPTO_CIPHER_MODE_XTS, .mode = QCRYPTO_CIPHER_MODE_XTS,
.key = .key =
"27182818284590452353602874713526" "27182818284590452353602874713526"
@ -537,7 +537,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* NIST F.5.1 CTR-AES128.Encrypt */ /* NIST F.5.1 CTR-AES128.Encrypt */
.path = "/crypto/cipher/aes-ctr-128", .path = "/crypto/cipher/aes-ctr-128",
.alg = QCRYPTO_CIPHER_ALG_AES_128, .alg = QCRYPTO_CIPHER_ALGO_AES_128,
.mode = QCRYPTO_CIPHER_MODE_CTR, .mode = QCRYPTO_CIPHER_MODE_CTR,
.key = "2b7e151628aed2a6abf7158809cf4f3c", .key = "2b7e151628aed2a6abf7158809cf4f3c",
.iv = "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", .iv = "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
@ -555,7 +555,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* NIST F.5.3 CTR-AES192.Encrypt */ /* NIST F.5.3 CTR-AES192.Encrypt */
.path = "/crypto/cipher/aes-ctr-192", .path = "/crypto/cipher/aes-ctr-192",
.alg = QCRYPTO_CIPHER_ALG_AES_192, .alg = QCRYPTO_CIPHER_ALGO_AES_192,
.mode = QCRYPTO_CIPHER_MODE_CTR, .mode = QCRYPTO_CIPHER_MODE_CTR,
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b", .key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
.iv = "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", .iv = "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
@ -573,7 +573,7 @@ static QCryptoCipherTestData test_data[] = {
{ {
/* NIST F.5.5 CTR-AES256.Encrypt */ /* NIST F.5.5 CTR-AES256.Encrypt */
.path = "/crypto/cipher/aes-ctr-256", .path = "/crypto/cipher/aes-ctr-256",
.alg = QCRYPTO_CIPHER_ALG_AES_256, .alg = QCRYPTO_CIPHER_ALGO_AES_256,
.mode = QCRYPTO_CIPHER_MODE_CTR, .mode = QCRYPTO_CIPHER_MODE_CTR,
.key = "603deb1015ca71be2b73aef0857d7781" .key = "603deb1015ca71be2b73aef0857d7781"
"1f352c073b6108d72d9810a30914dff4", "1f352c073b6108d72d9810a30914dff4",
@ -750,7 +750,7 @@ static void test_cipher_null_iv(void)
uint8_t ciphertext[32] = { 0 }; uint8_t ciphertext[32] = { 0 };
cipher = qcrypto_cipher_new( cipher = qcrypto_cipher_new(
QCRYPTO_CIPHER_ALG_AES_256, QCRYPTO_CIPHER_ALGO_AES_256,
QCRYPTO_CIPHER_MODE_CBC, QCRYPTO_CIPHER_MODE_CBC,
key, sizeof(key), key, sizeof(key),
&error_abort); &error_abort);
@ -779,7 +779,7 @@ static void test_cipher_short_plaintext(void)
int ret; int ret;
cipher = qcrypto_cipher_new( cipher = qcrypto_cipher_new(
QCRYPTO_CIPHER_ALG_AES_256, QCRYPTO_CIPHER_ALGO_AES_256,
QCRYPTO_CIPHER_MODE_CBC, QCRYPTO_CIPHER_MODE_CBC,
key, sizeof(key), key, sizeof(key),
&error_abort); &error_abort);
@ -823,7 +823,7 @@ int main(int argc, char **argv)
g_test_add_data_func(test_data[i].path, &test_data[i], test_cipher); g_test_add_data_func(test_data[i].path, &test_data[i], test_cipher);
} else { } else {
g_printerr("# skip unsupported %s:%s\n", g_printerr("# skip unsupported %s:%s\n",
QCryptoCipherAlgorithm_str(test_data[i].alg), QCryptoCipherAlgo_str(test_data[i].alg),
QCryptoCipherMode_str(test_data[i].mode)); QCryptoCipherMode_str(test_data[i].mode));
} }
} }

8
tests/unit/test-crypto-ivgen.c
View File

@ -28,7 +28,7 @@ struct QCryptoIVGenTestData {
uint64_t sector; uint64_t sector;
QCryptoIVGenAlgorithm ivalg; QCryptoIVGenAlgorithm ivalg;
QCryptoHashAlgo hashalg; QCryptoHashAlgo hashalg;
QCryptoCipherAlgorithm cipheralg; QCryptoCipherAlgo cipheralg;
const uint8_t *key; const uint8_t *key;
size_t nkey; size_t nkey;
const uint8_t *iv; const uint8_t *iv;
@ -93,7 +93,7 @@ struct QCryptoIVGenTestData {
"/crypto/ivgen/essiv/1", "/crypto/ivgen/essiv/1",
.sector = 0x1, .sector = 0x1,
.ivalg = QCRYPTO_IVGEN_ALG_ESSIV, .ivalg = QCRYPTO_IVGEN_ALG_ESSIV,
.cipheralg = QCRYPTO_CIPHER_ALG_AES_128, .cipheralg = QCRYPTO_CIPHER_ALGO_AES_128,
.hashalg = QCRYPTO_HASH_ALGO_SHA256, .hashalg = QCRYPTO_HASH_ALGO_SHA256,
.key = (const uint8_t *)"\x00\x01\x02\x03\x04\x05\x06\x07" .key = (const uint8_t *)"\x00\x01\x02\x03\x04\x05\x06\x07"
"\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
@ -107,7 +107,7 @@ struct QCryptoIVGenTestData {
"/crypto/ivgen/essiv/1f2e3d4c", "/crypto/ivgen/essiv/1f2e3d4c",
.sector = 0x1f2e3d4cULL, .sector = 0x1f2e3d4cULL,
.ivalg = QCRYPTO_IVGEN_ALG_ESSIV, .ivalg = QCRYPTO_IVGEN_ALG_ESSIV,
.cipheralg = QCRYPTO_CIPHER_ALG_AES_128, .cipheralg = QCRYPTO_CIPHER_ALGO_AES_128,
.hashalg = QCRYPTO_HASH_ALGO_SHA256, .hashalg = QCRYPTO_HASH_ALGO_SHA256,
.key = (const uint8_t *)"\x00\x01\x02\x03\x04\x05\x06\x07" .key = (const uint8_t *)"\x00\x01\x02\x03\x04\x05\x06\x07"
"\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
@ -121,7 +121,7 @@ struct QCryptoIVGenTestData {
"/crypto/ivgen/essiv/1f2e3d4c5b6a7988", "/crypto/ivgen/essiv/1f2e3d4c5b6a7988",
.sector = 0x1f2e3d4c5b6a7988ULL, .sector = 0x1f2e3d4c5b6a7988ULL,
.ivalg = QCRYPTO_IVGEN_ALG_ESSIV, .ivalg = QCRYPTO_IVGEN_ALG_ESSIV,
.cipheralg = QCRYPTO_CIPHER_ALG_AES_128, .cipheralg = QCRYPTO_CIPHER_ALGO_AES_128,
.hashalg = QCRYPTO_HASH_ALGO_SHA256, .hashalg = QCRYPTO_HASH_ALGO_SHA256,
.key = (const uint8_t *)"\x00\x01\x02\x03\x04\x05\x06\x07" .key = (const uint8_t *)"\x00\x01\x02\x03\x04\x05\x06\x07"
"\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",

4
ui/vnc.c
View File

@ -2783,7 +2783,7 @@ static int protocol_client_auth_vnc(VncState *vs, uint8_t *data, size_t len)
vnc_munge_des_rfb_key(key, sizeof(key)); vnc_munge_des_rfb_key(key, sizeof(key));
cipher = qcrypto_cipher_new( cipher = qcrypto_cipher_new(
QCRYPTO_CIPHER_ALG_DES, QCRYPTO_CIPHER_ALGO_DES,
QCRYPTO_CIPHER_MODE_ECB, QCRYPTO_CIPHER_MODE_ECB,
key, G_N_ELEMENTS(key), key, G_N_ELEMENTS(key),
&err); &err);
@ -4064,7 +4064,7 @@ void vnc_display_open(const char *id, Error **errp)
} }
if (password) { if (password) {
if (!qcrypto_cipher_supports( if (!qcrypto_cipher_supports(
QCRYPTO_CIPHER_ALG_DES, QCRYPTO_CIPHER_MODE_ECB)) { QCRYPTO_CIPHER_ALGO_DES, QCRYPTO_CIPHER_MODE_ECB)) {
error_setg(errp, error_setg(errp,
"Cipher backend does not support DES algorithm"); "Cipher backend does not support DES algorithm");
goto fail; goto fail;