* [Qemu-devel] [PATCH for-4.1 0/2] Compatibility fixes for nettle 2.7 vs 3.0 vs 3.5
@ 2019-07-12 10:18 Daniel P. Berrangé
2019-07-12 10:18 ` [Qemu-devel] [PATCH for-4.1 1/2] crypto: switch to modern nettle AES APIs Daniel P. Berrangé
` (2 more replies)
0 siblings, 3 replies; 7+ messages in thread
From: Daniel P. Berrangé @ 2019-07-12 10:18 UTC (permalink / raw)
To: qemu-devel; +Cc: Alex Bennée, Amol Surati, Daniel P. Berrangé
This short series fixes a few compatibility issues around different
nettle versions.
Daniel P. Berrangé (2):
crypto: switch to modern nettle AES APIs
crypto: fix function signatures for nettle 2.7 vs 3
crypto/cipher-nettle.c | 218 ++++++++++++++++++++++++++++++++++-------
crypto/hash-nettle.c | 12 ++-
crypto/hmac-nettle.c | 17 +++-
3 files changed, 205 insertions(+), 42 deletions(-)
--
2.21.0
^ permalink raw reply [flat|nested] 7+ messages in thread* [Qemu-devel] [PATCH for-4.1 1/2] crypto: switch to modern nettle AES APIs 2019-07-12 10:18 [Qemu-devel] [PATCH for-4.1 0/2] Compatibility fixes for nettle 2.7 vs 3.0 vs 3.5 Daniel P. Berrangé @ 2019-07-12 10:18 ` Daniel P. Berrangé 2019-07-12 12:09 ` Alex Bennée 2019-07-12 10:18 ` [Qemu-devel] [PATCH for-4.1 2/2] crypto: fix function signatures for nettle 2.7 vs 3 Daniel P. Berrangé 2019-07-13 5:17 ` [Qemu-devel] [PATCH for-4.1 0/2] Compatibility fixes for nettle 2.7 vs 3.0 vs 3.5 Amol Surati 2 siblings, 1 reply; 7+ messages in thread From: Daniel P. Berrangé @ 2019-07-12 10:18 UTC (permalink / raw) To: qemu-devel; +Cc: Alex Bennée, Amol Surati, Daniel P. Berrangé The aes_ctx struct and aes_* functions have been deprecated in nettle 3.5, in favour of keysize specific functions which were introduced first in nettle 3.0. Switch QEMU code to use the new APIs and add some backcompat defines such that it still builds on nettle 2.7 Signed-off-by: Daniel P. Berrangé <berrange@redhat.com> --- crypto/cipher-nettle.c | 218 ++++++++++++++++++++++++++++++++++------- 1 file changed, 183 insertions(+), 35 deletions(-) diff --git a/crypto/cipher-nettle.c b/crypto/cipher-nettle.c index 3848cb3b3a..115d16dd7b 100644 --- a/crypto/cipher-nettle.c +++ b/crypto/cipher-nettle.c @@ -42,29 +42,89 @@ typedef void * cipher_ctx_t; typedef unsigned cipher_length_t; #define cast5_set_key cast128_set_key + +#define aes128_ctx aes_ctx +#define aes192_ctx aes_ctx +#define aes256_ctx aes_ctx +#define aes128_set_encrypt_key(c, k) \ + aes_set_encrypt_key(c, 16, k) +#define aes192_set_encrypt_key(c, k) \ + aes_set_encrypt_key(c, 24, k) +#define aes256_set_encrypt_key(c, k) \ + aes_set_encrypt_key(c, 32, k) +#define aes128_set_decrypt_key(c, k) \ + aes_set_decrypt_key(c, 16, k) +#define aes192_set_decrypt_key(c, k) \ + aes_set_decrypt_key(c, 24, k) +#define aes256_set_decrypt_key(c, k) \ + aes_set_decrypt_key(c, 32, k) +#define aes128_encrypt aes_encrypt +#define aes192_encrypt aes_encrypt +#define aes256_encrypt aes_encrypt +#define aes128_decrypt aes_decrypt +#define aes192_decrypt aes_decrypt +#define aes256_decrypt aes_decrypt #else typedef nettle_cipher_func * QCryptoCipherNettleFuncNative; typedef const void * cipher_ctx_t; typedef size_t cipher_length_t; #endif -typedef struct QCryptoNettleAES { - struct aes_ctx enc; - struct aes_ctx dec; -} QCryptoNettleAES; +typedef struct QCryptoNettleAES128 { + struct aes128_ctx enc; + struct aes128_ctx dec; +} QCryptoNettleAES128; + +typedef struct QCryptoNettleAES192 { + struct aes192_ctx enc; + struct aes192_ctx dec; +} QCryptoNettleAES192; + +typedef struct QCryptoNettleAES256 { + struct aes256_ctx enc; + struct aes256_ctx dec; +} QCryptoNettleAES256; + +static void aes128_encrypt_native(cipher_ctx_t ctx, cipher_length_t length, + uint8_t *dst, const uint8_t *src) +{ + const QCryptoNettleAES128 *aesctx = ctx; + aes128_encrypt(&aesctx->enc, length, dst, src); +} + +static void aes128_decrypt_native(cipher_ctx_t ctx, cipher_length_t length, + uint8_t *dst, const uint8_t *src) +{ + const QCryptoNettleAES128 *aesctx = ctx; + aes128_decrypt(&aesctx->dec, length, dst, src); +} + +static void aes192_encrypt_native(cipher_ctx_t ctx, cipher_length_t length, + uint8_t *dst, const uint8_t *src) +{ + const QCryptoNettleAES192 *aesctx = ctx; + aes192_encrypt(&aesctx->enc, length, dst, src); +} + +static void aes192_decrypt_native(cipher_ctx_t ctx, cipher_length_t length, + uint8_t *dst, const uint8_t *src) +{ + const QCryptoNettleAES192 *aesctx = ctx; + aes192_decrypt(&aesctx->dec, length, dst, src); +} -static void aes_encrypt_native(cipher_ctx_t ctx, cipher_length_t length, +static void aes256_encrypt_native(cipher_ctx_t ctx, cipher_length_t length, uint8_t *dst, const uint8_t *src) { - const QCryptoNettleAES *aesctx = ctx; - aes_encrypt(&aesctx->enc, length, dst, src); + const QCryptoNettleAES256 *aesctx = ctx; + aes256_encrypt(&aesctx->enc, length, dst, src); } -static void aes_decrypt_native(cipher_ctx_t ctx, cipher_length_t length, +static void aes256_decrypt_native(cipher_ctx_t ctx, cipher_length_t length, uint8_t *dst, const uint8_t *src) { - const QCryptoNettleAES *aesctx = ctx; - aes_decrypt(&aesctx->dec, length, dst, src); + const QCryptoNettleAES256 *aesctx = ctx; + aes256_decrypt(&aesctx->dec, length, dst, src); } static void des_encrypt_native(cipher_ctx_t ctx, cipher_length_t length, @@ -127,18 +187,46 @@ static void twofish_decrypt_native(cipher_ctx_t ctx, cipher_length_t length, twofish_decrypt(ctx, length, dst, src); } -static void aes_encrypt_wrapper(const void *ctx, size_t length, +static void aes128_encrypt_wrapper(const void *ctx, size_t length, + uint8_t *dst, const uint8_t *src) +{ + const QCryptoNettleAES128 *aesctx = ctx; + aes128_encrypt(&aesctx->enc, length, dst, src); +} + +static void aes128_decrypt_wrapper(const void *ctx, size_t length, uint8_t *dst, const uint8_t *src) { - const QCryptoNettleAES *aesctx = ctx; - aes_encrypt(&aesctx->enc, length, dst, src); + const QCryptoNettleAES128 *aesctx = ctx; + aes128_decrypt(&aesctx->dec, length, dst, src); } -static void aes_decrypt_wrapper(const void *ctx, size_t length, +static void aes192_encrypt_wrapper(const void *ctx, size_t length, uint8_t *dst, const uint8_t *src) { - const QCryptoNettleAES *aesctx = ctx; - aes_decrypt(&aesctx->dec, length, dst, src); + const QCryptoNettleAES192 *aesctx = ctx; + aes192_encrypt(&aesctx->enc, length, dst, src); +} + +static void aes192_decrypt_wrapper(const void *ctx, size_t length, + uint8_t *dst, const uint8_t *src) +{ + const QCryptoNettleAES192 *aesctx = ctx; + aes192_decrypt(&aesctx->dec, length, dst, src); +} + +static void aes256_encrypt_wrapper(const void *ctx, size_t length, + uint8_t *dst, const uint8_t *src) +{ + const QCryptoNettleAES256 *aesctx = ctx; + aes256_encrypt(&aesctx->enc, length, dst, src); +} + +static void aes256_decrypt_wrapper(const void *ctx, size_t length, + uint8_t *dst, const uint8_t *src) +{ + const QCryptoNettleAES256 *aesctx = ctx; + aes256_decrypt(&aesctx->dec, length, dst, src); } static void des_encrypt_wrapper(const void *ctx, size_t length, @@ -319,34 +407,94 @@ static QCryptoCipherNettle *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg, break; case QCRYPTO_CIPHER_ALG_AES_128: + ctx->ctx = g_new0(QCryptoNettleAES128, 1); + + if (mode == QCRYPTO_CIPHER_MODE_XTS) { + ctx->ctx_tweak = g_new0(QCryptoNettleAES128, 1); + + nkey /= 2; + aes128_set_encrypt_key(&((QCryptoNettleAES128 *)ctx->ctx)->enc, + key); + aes128_set_decrypt_key(&((QCryptoNettleAES128 *)ctx->ctx)->dec, + key); + + aes128_set_encrypt_key(&((QCryptoNettleAES128 *)ctx->ctx_tweak)-> + enc, key + nkey); + aes128_set_decrypt_key(&((QCryptoNettleAES128 *)ctx->ctx_tweak)-> + dec, key + nkey); + } else { + aes128_set_encrypt_key(&((QCryptoNettleAES128 *)ctx->ctx)->enc, + key); + aes128_set_decrypt_key(&((QCryptoNettleAES128 *)ctx->ctx)->dec, + key); + } + + ctx->alg_encrypt_native = aes128_encrypt_native; + ctx->alg_decrypt_native = aes128_decrypt_native; + ctx->alg_encrypt_wrapper = aes128_encrypt_wrapper; + ctx->alg_decrypt_wrapper = aes128_decrypt_wrapper; + + ctx->blocksize = AES_BLOCK_SIZE; + break; + case QCRYPTO_CIPHER_ALG_AES_192: + ctx->ctx = g_new0(QCryptoNettleAES192, 1); + + if (mode == QCRYPTO_CIPHER_MODE_XTS) { + ctx->ctx_tweak = g_new0(QCryptoNettleAES192, 1); + + nkey /= 2; + aes192_set_encrypt_key(&((QCryptoNettleAES192 *)ctx->ctx)->enc, + key); + aes192_set_decrypt_key(&((QCryptoNettleAES192 *)ctx->ctx)->dec, + key); + + aes192_set_encrypt_key(&((QCryptoNettleAES192 *)ctx->ctx_tweak)-> + enc, key + nkey); + aes192_set_decrypt_key(&((QCryptoNettleAES192 *)ctx->ctx_tweak)-> + dec, key + nkey); + } else { + aes192_set_encrypt_key(&((QCryptoNettleAES192 *)ctx->ctx)->enc, + key); + aes192_set_decrypt_key(&((QCryptoNettleAES192 *)ctx->ctx)->dec, + key); + } + + ctx->alg_encrypt_native = aes192_encrypt_native; + ctx->alg_decrypt_native = aes192_decrypt_native; + ctx->alg_encrypt_wrapper = aes192_encrypt_wrapper; + ctx->alg_decrypt_wrapper = aes192_decrypt_wrapper; + + ctx->blocksize = AES_BLOCK_SIZE; + break; + case QCRYPTO_CIPHER_ALG_AES_256: - ctx->ctx = g_new0(QCryptoNettleAES, 1); + ctx->ctx = g_new0(QCryptoNettleAES256, 1); if (mode == QCRYPTO_CIPHER_MODE_XTS) { - ctx->ctx_tweak = g_new0(QCryptoNettleAES, 1); + ctx->ctx_tweak = g_new0(QCryptoNettleAES256, 1); nkey /= 2; - aes_set_encrypt_key(&((QCryptoNettleAES *)ctx->ctx)->enc, - nkey, key); - aes_set_decrypt_key(&((QCryptoNettleAES *)ctx->ctx)->dec, - nkey, key); - - aes_set_encrypt_key(&((QCryptoNettleAES *)ctx->ctx_tweak)->enc, - nkey, key + nkey); - aes_set_decrypt_key(&((QCryptoNettleAES *)ctx->ctx_tweak)->dec, - nkey, key + nkey); + aes256_set_encrypt_key(&((QCryptoNettleAES256 *)ctx->ctx)->enc, + key); + aes256_set_decrypt_key(&((QCryptoNettleAES256 *)ctx->ctx)->dec, + key); + + aes256_set_encrypt_key(&((QCryptoNettleAES256 *)ctx->ctx_tweak)-> + enc, key + nkey); + aes256_set_decrypt_key(&((QCryptoNettleAES256 *)ctx->ctx_tweak)-> + dec, key + nkey); } else { - aes_set_encrypt_key(&((QCryptoNettleAES *)ctx->ctx)->enc, - nkey, key); - aes_set_decrypt_key(&((QCryptoNettleAES *)ctx->ctx)->dec, - nkey, key); + aes256_set_encrypt_key(&((QCryptoNettleAES256 *)ctx->ctx)->enc, + key); + aes256_set_decrypt_key(&((QCryptoNettleAES256 *)ctx->ctx)->dec, + key); } - ctx->alg_encrypt_native = aes_encrypt_native; - ctx->alg_decrypt_native = aes_decrypt_native; - ctx->alg_encrypt_wrapper = aes_encrypt_wrapper; - ctx->alg_decrypt_wrapper = aes_decrypt_wrapper; + ctx->alg_encrypt_native = aes256_encrypt_native; + ctx->alg_decrypt_native = aes256_decrypt_native; + ctx->alg_encrypt_wrapper = aes256_encrypt_wrapper; + ctx->alg_decrypt_wrapper = aes256_decrypt_wrapper; ctx->blocksize = AES_BLOCK_SIZE; break; -- 2.21.0 ^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH for-4.1 1/2] crypto: switch to modern nettle AES APIs 2019-07-12 10:18 ` [Qemu-devel] [PATCH for-4.1 1/2] crypto: switch to modern nettle AES APIs Daniel P. Berrangé @ 2019-07-12 12:09 ` Alex Bennée 0 siblings, 0 replies; 7+ messages in thread From: Alex Bennée @ 2019-07-12 12:09 UTC (permalink / raw) To: Daniel P. Berrangé; +Cc: Amol Surati, qemu-devel Daniel P. Berrangé <berrange@redhat.com> writes: > The aes_ctx struct and aes_* functions have been deprecated in nettle > 3.5, in favour of keysize specific functions which were introduced > first in nettle 3.0. > > Switch QEMU code to use the new APIs and add some backcompat defines > such that it still builds on nettle 2.7 > > Signed-off-by: Daniel P. Berrangé <berrange@redhat.com> Reviewed-by: Alex Bennée <alex.bennee@linaro.org> Tested-by: Alex Bennée <alex.bennee@linaro.org> > --- > crypto/cipher-nettle.c | 218 ++++++++++++++++++++++++++++++++++------- > 1 file changed, 183 insertions(+), 35 deletions(-) > > diff --git a/crypto/cipher-nettle.c b/crypto/cipher-nettle.c > index 3848cb3b3a..115d16dd7b 100644 > --- a/crypto/cipher-nettle.c > +++ b/crypto/cipher-nettle.c > @@ -42,29 +42,89 @@ typedef void * cipher_ctx_t; > typedef unsigned cipher_length_t; > > #define cast5_set_key cast128_set_key > + > +#define aes128_ctx aes_ctx > +#define aes192_ctx aes_ctx > +#define aes256_ctx aes_ctx > +#define aes128_set_encrypt_key(c, k) \ > + aes_set_encrypt_key(c, 16, k) > +#define aes192_set_encrypt_key(c, k) \ > + aes_set_encrypt_key(c, 24, k) > +#define aes256_set_encrypt_key(c, k) \ > + aes_set_encrypt_key(c, 32, k) > +#define aes128_set_decrypt_key(c, k) \ > + aes_set_decrypt_key(c, 16, k) > +#define aes192_set_decrypt_key(c, k) \ > + aes_set_decrypt_key(c, 24, k) > +#define aes256_set_decrypt_key(c, k) \ > + aes_set_decrypt_key(c, 32, k) > +#define aes128_encrypt aes_encrypt > +#define aes192_encrypt aes_encrypt > +#define aes256_encrypt aes_encrypt > +#define aes128_decrypt aes_decrypt > +#define aes192_decrypt aes_decrypt > +#define aes256_decrypt aes_decrypt > #else > typedef nettle_cipher_func * QCryptoCipherNettleFuncNative; > typedef const void * cipher_ctx_t; > typedef size_t cipher_length_t; > #endif > > -typedef struct QCryptoNettleAES { > - struct aes_ctx enc; > - struct aes_ctx dec; > -} QCryptoNettleAES; > +typedef struct QCryptoNettleAES128 { > + struct aes128_ctx enc; > + struct aes128_ctx dec; > +} QCryptoNettleAES128; > + > +typedef struct QCryptoNettleAES192 { > + struct aes192_ctx enc; > + struct aes192_ctx dec; > +} QCryptoNettleAES192; > + > +typedef struct QCryptoNettleAES256 { > + struct aes256_ctx enc; > + struct aes256_ctx dec; > +} QCryptoNettleAES256; > + > +static void aes128_encrypt_native(cipher_ctx_t ctx, cipher_length_t length, > + uint8_t *dst, const uint8_t *src) > +{ > + const QCryptoNettleAES128 *aesctx = ctx; > + aes128_encrypt(&aesctx->enc, length, dst, src); > +} > + > +static void aes128_decrypt_native(cipher_ctx_t ctx, cipher_length_t length, > + uint8_t *dst, const uint8_t *src) > +{ > + const QCryptoNettleAES128 *aesctx = ctx; > + aes128_decrypt(&aesctx->dec, length, dst, src); > +} > + > +static void aes192_encrypt_native(cipher_ctx_t ctx, cipher_length_t length, > + uint8_t *dst, const uint8_t *src) > +{ > + const QCryptoNettleAES192 *aesctx = ctx; > + aes192_encrypt(&aesctx->enc, length, dst, src); > +} > + > +static void aes192_decrypt_native(cipher_ctx_t ctx, cipher_length_t length, > + uint8_t *dst, const uint8_t *src) > +{ > + const QCryptoNettleAES192 *aesctx = ctx; > + aes192_decrypt(&aesctx->dec, length, dst, src); > +} > > -static void aes_encrypt_native(cipher_ctx_t ctx, cipher_length_t length, > +static void aes256_encrypt_native(cipher_ctx_t ctx, cipher_length_t length, > uint8_t *dst, const uint8_t *src) > { > - const QCryptoNettleAES *aesctx = ctx; > - aes_encrypt(&aesctx->enc, length, dst, src); > + const QCryptoNettleAES256 *aesctx = ctx; > + aes256_encrypt(&aesctx->enc, length, dst, src); > } > > -static void aes_decrypt_native(cipher_ctx_t ctx, cipher_length_t length, > +static void aes256_decrypt_native(cipher_ctx_t ctx, cipher_length_t length, > uint8_t *dst, const uint8_t *src) > { > - const QCryptoNettleAES *aesctx = ctx; > - aes_decrypt(&aesctx->dec, length, dst, src); > + const QCryptoNettleAES256 *aesctx = ctx; > + aes256_decrypt(&aesctx->dec, length, dst, src); > } > > static void des_encrypt_native(cipher_ctx_t ctx, cipher_length_t length, > @@ -127,18 +187,46 @@ static void twofish_decrypt_native(cipher_ctx_t ctx, cipher_length_t length, > twofish_decrypt(ctx, length, dst, src); > } > > -static void aes_encrypt_wrapper(const void *ctx, size_t length, > +static void aes128_encrypt_wrapper(const void *ctx, size_t length, > + uint8_t *dst, const uint8_t *src) > +{ > + const QCryptoNettleAES128 *aesctx = ctx; > + aes128_encrypt(&aesctx->enc, length, dst, src); > +} > + > +static void aes128_decrypt_wrapper(const void *ctx, size_t length, > uint8_t *dst, const uint8_t *src) > { > - const QCryptoNettleAES *aesctx = ctx; > - aes_encrypt(&aesctx->enc, length, dst, src); > + const QCryptoNettleAES128 *aesctx = ctx; > + aes128_decrypt(&aesctx->dec, length, dst, src); > } > > -static void aes_decrypt_wrapper(const void *ctx, size_t length, > +static void aes192_encrypt_wrapper(const void *ctx, size_t length, > uint8_t *dst, const uint8_t *src) > { > - const QCryptoNettleAES *aesctx = ctx; > - aes_decrypt(&aesctx->dec, length, dst, src); > + const QCryptoNettleAES192 *aesctx = ctx; > + aes192_encrypt(&aesctx->enc, length, dst, src); > +} > + > +static void aes192_decrypt_wrapper(const void *ctx, size_t length, > + uint8_t *dst, const uint8_t *src) > +{ > + const QCryptoNettleAES192 *aesctx = ctx; > + aes192_decrypt(&aesctx->dec, length, dst, src); > +} > + > +static void aes256_encrypt_wrapper(const void *ctx, size_t length, > + uint8_t *dst, const uint8_t *src) > +{ > + const QCryptoNettleAES256 *aesctx = ctx; > + aes256_encrypt(&aesctx->enc, length, dst, src); > +} > + > +static void aes256_decrypt_wrapper(const void *ctx, size_t length, > + uint8_t *dst, const uint8_t *src) > +{ > + const QCryptoNettleAES256 *aesctx = ctx; > + aes256_decrypt(&aesctx->dec, length, dst, src); > } > > static void des_encrypt_wrapper(const void *ctx, size_t length, > @@ -319,34 +407,94 @@ static QCryptoCipherNettle *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg, > break; > > case QCRYPTO_CIPHER_ALG_AES_128: > + ctx->ctx = g_new0(QCryptoNettleAES128, 1); > + > + if (mode == QCRYPTO_CIPHER_MODE_XTS) { > + ctx->ctx_tweak = g_new0(QCryptoNettleAES128, 1); > + > + nkey /= 2; > + aes128_set_encrypt_key(&((QCryptoNettleAES128 *)ctx->ctx)->enc, > + key); > + aes128_set_decrypt_key(&((QCryptoNettleAES128 *)ctx->ctx)->dec, > + key); > + > + aes128_set_encrypt_key(&((QCryptoNettleAES128 *)ctx->ctx_tweak)-> > + enc, key + nkey); > + aes128_set_decrypt_key(&((QCryptoNettleAES128 *)ctx->ctx_tweak)-> > + dec, key + nkey); > + } else { > + aes128_set_encrypt_key(&((QCryptoNettleAES128 *)ctx->ctx)->enc, > + key); > + aes128_set_decrypt_key(&((QCryptoNettleAES128 *)ctx->ctx)->dec, > + key); > + } > + > + ctx->alg_encrypt_native = aes128_encrypt_native; > + ctx->alg_decrypt_native = aes128_decrypt_native; > + ctx->alg_encrypt_wrapper = aes128_encrypt_wrapper; > + ctx->alg_decrypt_wrapper = aes128_decrypt_wrapper; > + > + ctx->blocksize = AES_BLOCK_SIZE; > + break; > + > case QCRYPTO_CIPHER_ALG_AES_192: > + ctx->ctx = g_new0(QCryptoNettleAES192, 1); > + > + if (mode == QCRYPTO_CIPHER_MODE_XTS) { > + ctx->ctx_tweak = g_new0(QCryptoNettleAES192, 1); > + > + nkey /= 2; > + aes192_set_encrypt_key(&((QCryptoNettleAES192 *)ctx->ctx)->enc, > + key); > + aes192_set_decrypt_key(&((QCryptoNettleAES192 *)ctx->ctx)->dec, > + key); > + > + aes192_set_encrypt_key(&((QCryptoNettleAES192 *)ctx->ctx_tweak)-> > + enc, key + nkey); > + aes192_set_decrypt_key(&((QCryptoNettleAES192 *)ctx->ctx_tweak)-> > + dec, key + nkey); > + } else { > + aes192_set_encrypt_key(&((QCryptoNettleAES192 *)ctx->ctx)->enc, > + key); > + aes192_set_decrypt_key(&((QCryptoNettleAES192 *)ctx->ctx)->dec, > + key); > + } > + > + ctx->alg_encrypt_native = aes192_encrypt_native; > + ctx->alg_decrypt_native = aes192_decrypt_native; > + ctx->alg_encrypt_wrapper = aes192_encrypt_wrapper; > + ctx->alg_decrypt_wrapper = aes192_decrypt_wrapper; > + > + ctx->blocksize = AES_BLOCK_SIZE; > + break; > + > case QCRYPTO_CIPHER_ALG_AES_256: > - ctx->ctx = g_new0(QCryptoNettleAES, 1); > + ctx->ctx = g_new0(QCryptoNettleAES256, 1); > > if (mode == QCRYPTO_CIPHER_MODE_XTS) { > - ctx->ctx_tweak = g_new0(QCryptoNettleAES, 1); > + ctx->ctx_tweak = g_new0(QCryptoNettleAES256, 1); > > nkey /= 2; > - aes_set_encrypt_key(&((QCryptoNettleAES *)ctx->ctx)->enc, > - nkey, key); > - aes_set_decrypt_key(&((QCryptoNettleAES *)ctx->ctx)->dec, > - nkey, key); > - > - aes_set_encrypt_key(&((QCryptoNettleAES *)ctx->ctx_tweak)->enc, > - nkey, key + nkey); > - aes_set_decrypt_key(&((QCryptoNettleAES *)ctx->ctx_tweak)->dec, > - nkey, key + nkey); > + aes256_set_encrypt_key(&((QCryptoNettleAES256 *)ctx->ctx)->enc, > + key); > + aes256_set_decrypt_key(&((QCryptoNettleAES256 *)ctx->ctx)->dec, > + key); > + > + aes256_set_encrypt_key(&((QCryptoNettleAES256 *)ctx->ctx_tweak)-> > + enc, key + nkey); > + aes256_set_decrypt_key(&((QCryptoNettleAES256 *)ctx->ctx_tweak)-> > + dec, key + nkey); > } else { > - aes_set_encrypt_key(&((QCryptoNettleAES *)ctx->ctx)->enc, > - nkey, key); > - aes_set_decrypt_key(&((QCryptoNettleAES *)ctx->ctx)->dec, > - nkey, key); > + aes256_set_encrypt_key(&((QCryptoNettleAES256 *)ctx->ctx)->enc, > + key); > + aes256_set_decrypt_key(&((QCryptoNettleAES256 *)ctx->ctx)->dec, > + key); > } > > - ctx->alg_encrypt_native = aes_encrypt_native; > - ctx->alg_decrypt_native = aes_decrypt_native; > - ctx->alg_encrypt_wrapper = aes_encrypt_wrapper; > - ctx->alg_decrypt_wrapper = aes_decrypt_wrapper; > + ctx->alg_encrypt_native = aes256_encrypt_native; > + ctx->alg_decrypt_native = aes256_decrypt_native; > + ctx->alg_encrypt_wrapper = aes256_encrypt_wrapper; > + ctx->alg_decrypt_wrapper = aes256_decrypt_wrapper; > > ctx->blocksize = AES_BLOCK_SIZE; > break; -- Alex Bennée ^ permalink raw reply [flat|nested] 7+ messages in thread
* [Qemu-devel] [PATCH for-4.1 2/2] crypto: fix function signatures for nettle 2.7 vs 3 2019-07-12 10:18 [Qemu-devel] [PATCH for-4.1 0/2] Compatibility fixes for nettle 2.7 vs 3.0 vs 3.5 Daniel P. Berrangé 2019-07-12 10:18 ` [Qemu-devel] [PATCH for-4.1 1/2] crypto: switch to modern nettle AES APIs Daniel P. Berrangé @ 2019-07-12 10:18 ` Daniel P. Berrangé 2019-07-12 12:10 ` Alex Bennée 2019-07-12 17:15 ` Philippe Mathieu-Daudé 2019-07-13 5:17 ` [Qemu-devel] [PATCH for-4.1 0/2] Compatibility fixes for nettle 2.7 vs 3.0 vs 3.5 Amol Surati 2 siblings, 2 replies; 7+ messages in thread From: Daniel P. Berrangé @ 2019-07-12 10:18 UTC (permalink / raw) To: qemu-devel; +Cc: Alex Bennée, Amol Surati, Daniel P. Berrangé Nettle version 2.7.x used 'unsigned int' instead of 'size_t' for length parameters in functions. Use a local typedef so that we can build with the correct signature depending on nettle version, as we already do in the cipher code. Signed-off-by: Daniel P. Berrangé <berrange@redhat.com> --- crypto/hash-nettle.c | 12 +++++++++--- crypto/hmac-nettle.c | 17 +++++++++++++---- 2 files changed, 22 insertions(+), 7 deletions(-) diff --git a/crypto/hash-nettle.c b/crypto/hash-nettle.c index 96f186f442..6ffb9c3db7 100644 --- a/crypto/hash-nettle.c +++ b/crypto/hash-nettle.c @@ -26,12 +26,18 @@ #include <nettle/sha.h> #include <nettle/ripemd160.h> +#if CONFIG_NETTLE_VERSION_MAJOR < 3 +typedef unsigned int hash_length_t; +#else +typedef size_t hash_length_t; +#endif + typedef void (*qcrypto_nettle_init)(void *ctx); typedef void (*qcrypto_nettle_write)(void *ctx, - unsigned int len, + hash_length_t len, const uint8_t *buf); typedef void (*qcrypto_nettle_result)(void *ctx, - unsigned int len, + hash_length_t len, uint8_t *buf); union qcrypto_hash_ctx { @@ -112,7 +118,7 @@ qcrypto_nettle_hash_bytesv(QCryptoHashAlgorithm alg, size_t *resultlen, Error **errp) { - int i; + size_t i; union qcrypto_hash_ctx ctx; if (!qcrypto_hash_supports(alg)) { diff --git a/crypto/hmac-nettle.c b/crypto/hmac-nettle.c index ec2d61bdde..1152b741fd 100644 --- a/crypto/hmac-nettle.c +++ b/crypto/hmac-nettle.c @@ -18,14 +18,23 @@ #include "hmacpriv.h" #include <nettle/hmac.h> +#if CONFIG_NETTLE_VERSION_MAJOR < 3 +typedef unsigned int hmac_length_t; +#else +typedef size_t hmac_length_t; +#endif + typedef void (*qcrypto_nettle_hmac_setkey)(void *ctx, - size_t key_length, const uint8_t *key); + hmac_length_t key_length, + const uint8_t *key); typedef void (*qcrypto_nettle_hmac_update)(void *ctx, - size_t length, const uint8_t *data); + hmac_length_t length, + const uint8_t *data); typedef void (*qcrypto_nettle_hmac_digest)(void *ctx, - size_t length, uint8_t *digest); + hmac_length_t length, + uint8_t *digest); typedef struct QCryptoHmacNettle QCryptoHmacNettle; struct QCryptoHmacNettle { @@ -135,7 +144,7 @@ qcrypto_nettle_hmac_bytesv(QCryptoHmac *hmac, Error **errp) { QCryptoHmacNettle *ctx; - int i; + size_t i; ctx = (QCryptoHmacNettle *)hmac->opaque; -- 2.21.0 ^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH for-4.1 2/2] crypto: fix function signatures for nettle 2.7 vs 3 2019-07-12 10:18 ` [Qemu-devel] [PATCH for-4.1 2/2] crypto: fix function signatures for nettle 2.7 vs 3 Daniel P. Berrangé @ 2019-07-12 12:10 ` Alex Bennée 2019-07-12 17:15 ` Philippe Mathieu-Daudé 1 sibling, 0 replies; 7+ messages in thread From: Alex Bennée @ 2019-07-12 12:10 UTC (permalink / raw) To: Daniel P. Berrangé; +Cc: Amol Surati, qemu-devel Daniel P. Berrangé <berrange@redhat.com> writes: > Nettle version 2.7.x used 'unsigned int' instead of 'size_t' for length > parameters in functions. Use a local typedef so that we can build with > the correct signature depending on nettle version, as we already do in > the cipher code. > > Signed-off-by: Daniel P. Berrangé <berrange@redhat.com> Reviewed-by: Alex Bennée <alex.bennee@linaro.org> Tested-by: Alex Bennée <alex.bennee@linaro.org> > --- > crypto/hash-nettle.c | 12 +++++++++--- > crypto/hmac-nettle.c | 17 +++++++++++++---- > 2 files changed, 22 insertions(+), 7 deletions(-) > > diff --git a/crypto/hash-nettle.c b/crypto/hash-nettle.c > index 96f186f442..6ffb9c3db7 100644 > --- a/crypto/hash-nettle.c > +++ b/crypto/hash-nettle.c > @@ -26,12 +26,18 @@ > #include <nettle/sha.h> > #include <nettle/ripemd160.h> > > +#if CONFIG_NETTLE_VERSION_MAJOR < 3 > +typedef unsigned int hash_length_t; > +#else > +typedef size_t hash_length_t; > +#endif > + > typedef void (*qcrypto_nettle_init)(void *ctx); > typedef void (*qcrypto_nettle_write)(void *ctx, > - unsigned int len, > + hash_length_t len, > const uint8_t *buf); > typedef void (*qcrypto_nettle_result)(void *ctx, > - unsigned int len, > + hash_length_t len, > uint8_t *buf); > > union qcrypto_hash_ctx { > @@ -112,7 +118,7 @@ qcrypto_nettle_hash_bytesv(QCryptoHashAlgorithm alg, > size_t *resultlen, > Error **errp) > { > - int i; > + size_t i; > union qcrypto_hash_ctx ctx; > > if (!qcrypto_hash_supports(alg)) { > diff --git a/crypto/hmac-nettle.c b/crypto/hmac-nettle.c > index ec2d61bdde..1152b741fd 100644 > --- a/crypto/hmac-nettle.c > +++ b/crypto/hmac-nettle.c > @@ -18,14 +18,23 @@ > #include "hmacpriv.h" > #include <nettle/hmac.h> > > +#if CONFIG_NETTLE_VERSION_MAJOR < 3 > +typedef unsigned int hmac_length_t; > +#else > +typedef size_t hmac_length_t; > +#endif > + > typedef void (*qcrypto_nettle_hmac_setkey)(void *ctx, > - size_t key_length, const uint8_t *key); > + hmac_length_t key_length, > + const uint8_t *key); > > typedef void (*qcrypto_nettle_hmac_update)(void *ctx, > - size_t length, const uint8_t *data); > + hmac_length_t length, > + const uint8_t *data); > > typedef void (*qcrypto_nettle_hmac_digest)(void *ctx, > - size_t length, uint8_t *digest); > + hmac_length_t length, > + uint8_t *digest); > > typedef struct QCryptoHmacNettle QCryptoHmacNettle; > struct QCryptoHmacNettle { > @@ -135,7 +144,7 @@ qcrypto_nettle_hmac_bytesv(QCryptoHmac *hmac, > Error **errp) > { > QCryptoHmacNettle *ctx; > - int i; > + size_t i; > > ctx = (QCryptoHmacNettle *)hmac->opaque; -- Alex Bennée ^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH for-4.1 2/2] crypto: fix function signatures for nettle 2.7 vs 3 2019-07-12 10:18 ` [Qemu-devel] [PATCH for-4.1 2/2] crypto: fix function signatures for nettle 2.7 vs 3 Daniel P. Berrangé 2019-07-12 12:10 ` Alex Bennée @ 2019-07-12 17:15 ` Philippe Mathieu-Daudé 1 sibling, 0 replies; 7+ messages in thread From: Philippe Mathieu-Daudé @ 2019-07-12 17:15 UTC (permalink / raw) To: Daniel P. Berrangé, qemu-devel; +Cc: Amol Surati, Alex Bennée On 7/12/19 12:18 PM, Daniel P. Berrangé wrote: > Nettle version 2.7.x used 'unsigned int' instead of 'size_t' for length > parameters in functions. Use a local typedef so that we can build with > the correct signature depending on nettle version, as we already do in > the cipher code. > Reported-by: Amol Surati <suratiamol@gmail.com> > Signed-off-by: Daniel P. Berrangé <berrange@redhat.com> Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com> > --- > crypto/hash-nettle.c | 12 +++++++++--- > crypto/hmac-nettle.c | 17 +++++++++++++---- > 2 files changed, 22 insertions(+), 7 deletions(-) > > diff --git a/crypto/hash-nettle.c b/crypto/hash-nettle.c > index 96f186f442..6ffb9c3db7 100644 > --- a/crypto/hash-nettle.c > +++ b/crypto/hash-nettle.c > @@ -26,12 +26,18 @@ > #include <nettle/sha.h> > #include <nettle/ripemd160.h> > > +#if CONFIG_NETTLE_VERSION_MAJOR < 3 > +typedef unsigned int hash_length_t; > +#else > +typedef size_t hash_length_t; > +#endif > + > typedef void (*qcrypto_nettle_init)(void *ctx); > typedef void (*qcrypto_nettle_write)(void *ctx, > - unsigned int len, > + hash_length_t len, > const uint8_t *buf); > typedef void (*qcrypto_nettle_result)(void *ctx, > - unsigned int len, > + hash_length_t len, > uint8_t *buf); > > union qcrypto_hash_ctx { > @@ -112,7 +118,7 @@ qcrypto_nettle_hash_bytesv(QCryptoHashAlgorithm alg, > size_t *resultlen, > Error **errp) > { > - int i; > + size_t i; > union qcrypto_hash_ctx ctx; > > if (!qcrypto_hash_supports(alg)) { > diff --git a/crypto/hmac-nettle.c b/crypto/hmac-nettle.c > index ec2d61bdde..1152b741fd 100644 > --- a/crypto/hmac-nettle.c > +++ b/crypto/hmac-nettle.c > @@ -18,14 +18,23 @@ > #include "hmacpriv.h" > #include <nettle/hmac.h> > > +#if CONFIG_NETTLE_VERSION_MAJOR < 3 > +typedef unsigned int hmac_length_t; > +#else > +typedef size_t hmac_length_t; > +#endif > + > typedef void (*qcrypto_nettle_hmac_setkey)(void *ctx, > - size_t key_length, const uint8_t *key); > + hmac_length_t key_length, > + const uint8_t *key); > > typedef void (*qcrypto_nettle_hmac_update)(void *ctx, > - size_t length, const uint8_t *data); > + hmac_length_t length, > + const uint8_t *data); > > typedef void (*qcrypto_nettle_hmac_digest)(void *ctx, > - size_t length, uint8_t *digest); > + hmac_length_t length, > + uint8_t *digest); > > typedef struct QCryptoHmacNettle QCryptoHmacNettle; > struct QCryptoHmacNettle { > @@ -135,7 +144,7 @@ qcrypto_nettle_hmac_bytesv(QCryptoHmac *hmac, > Error **errp) > { > QCryptoHmacNettle *ctx; > - int i; > + size_t i; > > ctx = (QCryptoHmacNettle *)hmac->opaque; > > ^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH for-4.1 0/2] Compatibility fixes for nettle 2.7 vs 3.0 vs 3.5 2019-07-12 10:18 [Qemu-devel] [PATCH for-4.1 0/2] Compatibility fixes for nettle 2.7 vs 3.0 vs 3.5 Daniel P. Berrangé 2019-07-12 10:18 ` [Qemu-devel] [PATCH for-4.1 1/2] crypto: switch to modern nettle AES APIs Daniel P. Berrangé 2019-07-12 10:18 ` [Qemu-devel] [PATCH for-4.1 2/2] crypto: fix function signatures for nettle 2.7 vs 3 Daniel P. Berrangé @ 2019-07-13 5:17 ` Amol Surati 2 siblings, 0 replies; 7+ messages in thread From: Amol Surati @ 2019-07-13 5:17 UTC (permalink / raw) To: Daniel P. Berrangé; +Cc: Alex Bennée, qemu-devel On Fri, Jul 12, 2019 at 11:18:47AM +0100, Daniel P. Berrangé wrote: > This short series fixes a few compatibility issues around different > nettle versions. Thank you for the fix. The compilation with nettle 3.5.1 now succeeds without resorting to --disable-werror or --disable-nettle. -amol ^ permalink raw reply [flat|nested] 7+ messages in thread
end of thread, other threads:[~2019-07-13 5:17 UTC | newest] Thread overview: 7+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2019-07-12 10:18 [Qemu-devel] [PATCH for-4.1 0/2] Compatibility fixes for nettle 2.7 vs 3.0 vs 3.5 Daniel P. Berrangé 2019-07-12 10:18 ` [Qemu-devel] [PATCH for-4.1 1/2] crypto: switch to modern nettle AES APIs Daniel P. Berrangé 2019-07-12 12:09 ` Alex Bennée 2019-07-12 10:18 ` [Qemu-devel] [PATCH for-4.1 2/2] crypto: fix function signatures for nettle 2.7 vs 3 Daniel P. Berrangé 2019-07-12 12:10 ` Alex Bennée 2019-07-12 17:15 ` Philippe Mathieu-Daudé 2019-07-13 5:17 ` [Qemu-devel] [PATCH for-4.1 0/2] Compatibility fixes for nettle 2.7 vs 3.0 vs 3.5 Amol Surati
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.