falso
/
qemu-irix
mirror of https://github.com/n64decomp/qemu-irix.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

crypto: fix cipher function signature mismatch with nettle & xts 

For versions of nettle < 3.0.0, the cipher functions took a
'void *ctx' and 'unsigned len' instad of 'const void *ctx'
and 'size_t len'. The xts functions though are builtin to
QEMU and always expect the latter signatures. Define a
second set of wrappers to use with the correct signatures
needed by XTS mode.

Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
This commit is contained in:
Daniel P. Berrange 2016-03-18 12:39:12 +00:00
parent 621e6ae657
commit f7ac78cfe1
1 changed files with 109 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
crypto/cipher-nettle.c
View File

@ -29,85 +29,147 @@
#include <nettle/serpent.h> #include <nettle/serpent.h>
#include <nettle/twofish.h> #include <nettle/twofish.h>
#if CONFIG_NETTLE_VERSION_MAJOR < 3 typedef void (*QCryptoCipherNettleFuncWrapper)(const void *ctx,
typedef nettle_crypt_func nettle_cipher_func; size_t length,
uint8_t *dst,
const uint8_t *src);
#if CONFIG_NETTLE_VERSION_MAJOR < 3
typedef nettle_crypt_func * QCryptoCipherNettleFuncNative;
typedef void * cipher_ctx_t; typedef void * cipher_ctx_t;
typedef unsigned cipher_length_t; typedef unsigned cipher_length_t;
#define cast5_set_key cast128_set_key #define cast5_set_key cast128_set_key
#else #else
typedef nettle_cipher_func * QCryptoCipherNettleFuncNative;
typedef const void * cipher_ctx_t; typedef const void * cipher_ctx_t;
typedef size_t cipher_length_t; typedef size_t cipher_length_t;
#endif #endif
static nettle_cipher_func aes_encrypt_wrapper;
static nettle_cipher_func aes_decrypt_wrapper;
static nettle_cipher_func des_encrypt_wrapper;
static nettle_cipher_func des_decrypt_wrapper;
typedef struct QCryptoNettleAES { typedef struct QCryptoNettleAES {
struct aes_ctx enc; struct aes_ctx enc;
struct aes_ctx dec; struct aes_ctx dec;
} QCryptoNettleAES; } QCryptoNettleAES;
static void aes_encrypt_wrapper(cipher_ctx_t ctx, cipher_length_t length, static void aes_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);
}
static void aes_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);
}
static void des_encrypt_native(cipher_ctx_t ctx, cipher_length_t length,
uint8_t *dst, const uint8_t *src)
{
des_encrypt(ctx, length, dst, src);
}
static void des_decrypt_native(cipher_ctx_t ctx, cipher_length_t length,
uint8_t *dst, const uint8_t *src)
{
des_decrypt(ctx, length, dst, src);
}
static void cast128_encrypt_native(cipher_ctx_t ctx, cipher_length_t length,
uint8_t *dst, const uint8_t *src)
{
cast128_encrypt(ctx, length, dst, src);
}
static void cast128_decrypt_native(cipher_ctx_t ctx, cipher_length_t length,
uint8_t *dst, const uint8_t *src)
{
cast128_decrypt(ctx, length, dst, src);
}
static void serpent_encrypt_native(cipher_ctx_t ctx, cipher_length_t length,
uint8_t *dst, const uint8_t *src)
{
serpent_encrypt(ctx, length, dst, src);
}
static void serpent_decrypt_native(cipher_ctx_t ctx, cipher_length_t length,
uint8_t *dst, const uint8_t *src)
{
serpent_decrypt(ctx, length, dst, src);
}
static void twofish_encrypt_native(cipher_ctx_t ctx, cipher_length_t length,
uint8_t *dst, const uint8_t *src)
{
twofish_encrypt(ctx, length, dst, src);
}
static void twofish_decrypt_native(cipher_ctx_t ctx, cipher_length_t length,
uint8_t *dst, const uint8_t *src)
{
twofish_decrypt(ctx, length, dst, src);
}
static void aes_encrypt_wrapper(const void *ctx, size_t length,
uint8_t *dst, const uint8_t *src) uint8_t *dst, const uint8_t *src)
{ {
const QCryptoNettleAES *aesctx = ctx; const QCryptoNettleAES *aesctx = ctx;
aes_encrypt(&aesctx->enc, length, dst, src); aes_encrypt(&aesctx->enc, length, dst, src);
} }
static void aes_decrypt_wrapper(cipher_ctx_t ctx, cipher_length_t length, static void aes_decrypt_wrapper(const void *ctx, size_t length,
uint8_t *dst, const uint8_t *src) uint8_t *dst, const uint8_t *src)
{ {
const QCryptoNettleAES *aesctx = ctx; const QCryptoNettleAES *aesctx = ctx;
aes_decrypt(&aesctx->dec, length, dst, src); aes_decrypt(&aesctx->dec, length, dst, src);
} }
static void des_encrypt_wrapper(cipher_ctx_t ctx, cipher_length_t length, static void des_encrypt_wrapper(const void *ctx, size_t length,
uint8_t *dst, const uint8_t *src) uint8_t *dst, const uint8_t *src)
{ {
des_encrypt(ctx, length, dst, src); des_encrypt(ctx, length, dst, src);
} }
static void des_decrypt_wrapper(cipher_ctx_t ctx, cipher_length_t length, static void des_decrypt_wrapper(const void *ctx, size_t length,
uint8_t *dst, const uint8_t *src) uint8_t *dst, const uint8_t *src)
{ {
des_decrypt(ctx, length, dst, src); des_decrypt(ctx, length, dst, src);
} }
static void cast128_encrypt_wrapper(cipher_ctx_t ctx, cipher_length_t length, static void cast128_encrypt_wrapper(const void *ctx, size_t length,
uint8_t *dst, const uint8_t *src) uint8_t *dst, const uint8_t *src)
{ {
cast128_encrypt(ctx, length, dst, src); cast128_encrypt(ctx, length, dst, src);
} }
static void cast128_decrypt_wrapper(cipher_ctx_t ctx, cipher_length_t length, static void cast128_decrypt_wrapper(const void *ctx, size_t length,
uint8_t *dst, const uint8_t *src) uint8_t *dst, const uint8_t *src)
{ {
cast128_decrypt(ctx, length, dst, src); cast128_decrypt(ctx, length, dst, src);
} }
static void serpent_encrypt_wrapper(cipher_ctx_t ctx, cipher_length_t length, static void serpent_encrypt_wrapper(const void *ctx, size_t length,
uint8_t *dst, const uint8_t *src) uint8_t *dst, const uint8_t *src)
{ {
serpent_encrypt(ctx, length, dst, src); serpent_encrypt(ctx, length, dst, src);
} }
static void serpent_decrypt_wrapper(cipher_ctx_t ctx, cipher_length_t length, static void serpent_decrypt_wrapper(const void *ctx, size_t length,
uint8_t *dst, const uint8_t *src) uint8_t *dst, const uint8_t *src)
{ {
serpent_decrypt(ctx, length, dst, src); serpent_decrypt(ctx, length, dst, src);
} }
static void twofish_encrypt_wrapper(cipher_ctx_t ctx, cipher_length_t length, static void twofish_encrypt_wrapper(const void *ctx, size_t length,
uint8_t *dst, const uint8_t *src) uint8_t *dst, const uint8_t *src)
{ {
twofish_encrypt(ctx, length, dst, src); twofish_encrypt(ctx, length, dst, src);
} }
static void twofish_decrypt_wrapper(cipher_ctx_t ctx, cipher_length_t length, static void twofish_decrypt_wrapper(const void *ctx, size_t length,
uint8_t *dst, const uint8_t *src) uint8_t *dst, const uint8_t *src)
{ {
twofish_decrypt(ctx, length, dst, src); twofish_decrypt(ctx, length, dst, src);
@ -120,8 +182,10 @@ struct QCryptoCipherNettle {
/* Second cipher context for XTS mode only */ /* Second cipher context for XTS mode only */
void *ctx_tweak; void *ctx_tweak;
/* Cipher callbacks for both contexts */ /* Cipher callbacks for both contexts */
nettle_cipher_func *alg_encrypt; QCryptoCipherNettleFuncNative alg_encrypt_native;
nettle_cipher_func *alg_decrypt; QCryptoCipherNettleFuncNative alg_decrypt_native;
QCryptoCipherNettleFuncWrapper alg_encrypt_wrapper;
QCryptoCipherNettleFuncWrapper alg_decrypt_wrapper;
uint8_t *iv; uint8_t *iv;
size_t blocksize; size_t blocksize;
@ -184,8 +248,10 @@ QCryptoCipher *qcrypto_cipher_new(QCryptoCipherAlgorithm alg,
des_set_key(ctx->ctx, rfbkey); des_set_key(ctx->ctx, rfbkey);
g_free(rfbkey); g_free(rfbkey);
ctx->alg_encrypt = des_encrypt_wrapper; ctx->alg_encrypt_native = des_encrypt_native;
ctx->alg_decrypt = des_decrypt_wrapper; ctx->alg_decrypt_native = des_decrypt_native;
ctx->alg_encrypt_wrapper = des_encrypt_wrapper;
ctx->alg_decrypt_wrapper = des_decrypt_wrapper;
ctx->blocksize = DES_BLOCK_SIZE; ctx->blocksize = DES_BLOCK_SIZE;
break; break;
@ -215,8 +281,10 @@ QCryptoCipher *qcrypto_cipher_new(QCryptoCipherAlgorithm alg,
nkey, key); nkey, key);
} }
ctx->alg_encrypt = aes_encrypt_wrapper; ctx->alg_encrypt_native = aes_encrypt_native;
ctx->alg_decrypt = aes_decrypt_wrapper; ctx->alg_decrypt_native = aes_decrypt_native;
ctx->alg_encrypt_wrapper = aes_encrypt_wrapper;
ctx->alg_decrypt_wrapper = aes_decrypt_wrapper;
ctx->blocksize = AES_BLOCK_SIZE; ctx->blocksize = AES_BLOCK_SIZE;
break; break;
@ -234,8 +302,10 @@ QCryptoCipher *qcrypto_cipher_new(QCryptoCipherAlgorithm alg,
cast5_set_key(ctx->ctx, nkey, key); cast5_set_key(ctx->ctx, nkey, key);
} }
ctx->alg_encrypt = cast128_encrypt_wrapper; ctx->alg_encrypt_native = cast128_encrypt_native;
ctx->alg_decrypt = cast128_decrypt_wrapper; ctx->alg_decrypt_native = cast128_decrypt_native;
ctx->alg_encrypt_wrapper = cast128_encrypt_wrapper;
ctx->alg_decrypt_wrapper = cast128_decrypt_wrapper;
ctx->blocksize = CAST128_BLOCK_SIZE; ctx->blocksize = CAST128_BLOCK_SIZE;
break; break;
@ -255,8 +325,10 @@ QCryptoCipher *qcrypto_cipher_new(QCryptoCipherAlgorithm alg,
serpent_set_key(ctx->ctx, nkey, key); serpent_set_key(ctx->ctx, nkey, key);
} }
ctx->alg_encrypt = serpent_encrypt_wrapper; ctx->alg_encrypt_native = serpent_encrypt_native;
ctx->alg_decrypt = serpent_decrypt_wrapper; ctx->alg_decrypt_native = serpent_decrypt_native;
ctx->alg_encrypt_wrapper = serpent_encrypt_wrapper;
ctx->alg_decrypt_wrapper = serpent_decrypt_wrapper;
ctx->blocksize = SERPENT_BLOCK_SIZE; ctx->blocksize = SERPENT_BLOCK_SIZE;
break; break;
@ -276,8 +348,10 @@ QCryptoCipher *qcrypto_cipher_new(QCryptoCipherAlgorithm alg,
twofish_set_key(ctx->ctx, nkey, key); twofish_set_key(ctx->ctx, nkey, key);
} }
ctx->alg_encrypt = twofish_encrypt_wrapper; ctx->alg_encrypt_native = twofish_encrypt_native;
ctx->alg_decrypt = twofish_decrypt_wrapper; ctx->alg_decrypt_native = twofish_decrypt_native;
ctx->alg_encrypt_wrapper = twofish_encrypt_wrapper;
ctx->alg_decrypt_wrapper = twofish_decrypt_wrapper;
ctx->blocksize = TWOFISH_BLOCK_SIZE; ctx->blocksize = TWOFISH_BLOCK_SIZE;
break; break;
@ -332,18 +406,18 @@ int qcrypto_cipher_encrypt(QCryptoCipher *cipher,
switch (cipher->mode) { switch (cipher->mode) {
case QCRYPTO_CIPHER_MODE_ECB: case QCRYPTO_CIPHER_MODE_ECB:
ctx->alg_encrypt(ctx->ctx, len, out, in); ctx->alg_encrypt_wrapper(ctx->ctx, len, out, in);
break; break;
case QCRYPTO_CIPHER_MODE_CBC: case QCRYPTO_CIPHER_MODE_CBC:
cbc_encrypt(ctx->ctx, ctx->alg_encrypt, cbc_encrypt(ctx->ctx, ctx->alg_encrypt_native,
ctx->blocksize, ctx->iv, ctx->blocksize, ctx->iv,
len, out, in); len, out, in);
break; break;
case QCRYPTO_CIPHER_MODE_XTS: case QCRYPTO_CIPHER_MODE_XTS:
xts_encrypt(ctx->ctx, ctx->ctx_tweak, xts_encrypt(ctx->ctx, ctx->ctx_tweak,
ctx->alg_encrypt, ctx->alg_encrypt, ctx->alg_encrypt_wrapper, ctx->alg_encrypt_wrapper,
ctx->iv, len, out, in); ctx->iv, len, out, in);
break; break;
@ -372,11 +446,11 @@ int qcrypto_cipher_decrypt(QCryptoCipher *cipher,
switch (cipher->mode) { switch (cipher->mode) {
case QCRYPTO_CIPHER_MODE_ECB: case QCRYPTO_CIPHER_MODE_ECB:
ctx->alg_decrypt(ctx->ctx, len, out, in); ctx->alg_decrypt_wrapper(ctx->ctx, len, out, in);
break; break;
case QCRYPTO_CIPHER_MODE_CBC: case QCRYPTO_CIPHER_MODE_CBC:
cbc_decrypt(ctx->ctx, ctx->alg_decrypt, cbc_decrypt(ctx->ctx, ctx->alg_decrypt_native,
ctx->blocksize, ctx->iv, ctx->blocksize, ctx->iv,
len, out, in); len, out, in);
break; break;
@ -388,7 +462,7 @@ int qcrypto_cipher_decrypt(QCryptoCipher *cipher,
return -1; return -1;
} }
xts_decrypt(ctx->ctx, ctx->ctx_tweak, xts_decrypt(ctx->ctx, ctx->ctx_tweak,
ctx->alg_encrypt, ctx->alg_decrypt, ctx->alg_encrypt_wrapper, ctx->alg_decrypt_wrapper,
ctx->iv, len, out, in); ctx->iv, len, out, in);
break; break;