crypto: introduce generic cipher API & built-in implementation
Introduce a generic cipher API and an implementation of it that supports only the built-in AES and DES-RFB algorithms. The test suite checks the supported algorithms + modes to validate that every backend implementation is actually correctly complying with the specs. Signed-off-by: Daniel P. Berrange <berrange@redhat.com> Message-Id: <1435770638-25715-5-git-send-email-berrange@redhat.com> Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Daniel P. Berrange
Paolo Bonzini
parent
9fd72468df
commit
ca38a4cc9e
@ -2,3 +2,4 @@ util-obj-y += init.o
|
||||
util-obj-y += hash.o
|
||||
util-obj-y += aes.o
|
||||
util-obj-y += desrfb.o
|
||||
util-obj-y += cipher.o
|
||||
|
||||
398
crypto/cipher-builtin.c
Normal file
398
crypto/cipher-builtin.c
Normal file
@ -0,0 +1,398 @@
|
||||
/*
|
||||
* QEMU Crypto cipher built-in algorithms
|
||||
*
|
||||
* Copyright (c) 2015 Red Hat, Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "crypto/aes.h"
|
||||
#include "crypto/desrfb.h"
|
||||
|
||||
typedef struct QCryptoCipherBuiltinAES QCryptoCipherBuiltinAES;
|
||||
struct QCryptoCipherBuiltinAES {
|
||||
AES_KEY encrypt_key;
|
||||
AES_KEY decrypt_key;
|
||||
uint8_t *iv;
|
||||
size_t niv;
|
||||
};
|
||||
typedef struct QCryptoCipherBuiltinDESRFB QCryptoCipherBuiltinDESRFB;
|
||||
struct QCryptoCipherBuiltinDESRFB {
|
||||
uint8_t *key;
|
||||
size_t nkey;
|
||||
};
|
||||
|
||||
typedef struct QCryptoCipherBuiltin QCryptoCipherBuiltin;
|
||||
struct QCryptoCipherBuiltin {
|
||||
union {
|
||||
QCryptoCipherBuiltinAES aes;
|
||||
QCryptoCipherBuiltinDESRFB desrfb;
|
||||
} state;
|
||||
void (*free)(QCryptoCipher *cipher);
|
||||
int (*setiv)(QCryptoCipher *cipher,
|
||||
const uint8_t *iv, size_t niv,
|
||||
Error **errp);
|
||||
int (*encrypt)(QCryptoCipher *cipher,
|
||||
const void *in,
|
||||
void *out,
|
||||
size_t len,
|
||||
Error **errp);
|
||||
int (*decrypt)(QCryptoCipher *cipher,
|
||||
const void *in,
|
||||
void *out,
|
||||
size_t len,
|
||||
Error **errp);
|
||||
};
|
||||
|
||||
|
||||
static void qcrypto_cipher_free_aes(QCryptoCipher *cipher)
|
||||
{
|
||||
QCryptoCipherBuiltin *ctxt = cipher->opaque;
|
||||
|
||||
g_free(ctxt->state.aes.iv);
|
||||
g_free(ctxt);
|
||||
cipher->opaque = NULL;
|
||||
}
|
||||
|
||||
|
||||
static int qcrypto_cipher_encrypt_aes(QCryptoCipher *cipher,
|
||||
const void *in,
|
||||
void *out,
|
||||
size_t len,
|
||||
Error **errp)
|
||||
{
|
||||
QCryptoCipherBuiltin *ctxt = cipher->opaque;
|
||||
|
||||
if (cipher->mode == QCRYPTO_CIPHER_MODE_ECB) {
|
||||
const uint8_t *inptr = in;
|
||||
uint8_t *outptr = out;
|
||||
while (len) {
|
||||
if (len > AES_BLOCK_SIZE) {
|
||||
AES_encrypt(inptr, outptr, &ctxt->state.aes.encrypt_key);
|
||||
inptr += AES_BLOCK_SIZE;
|
||||
outptr += AES_BLOCK_SIZE;
|
||||
len -= AES_BLOCK_SIZE;
|
||||
} else {
|
||||
uint8_t tmp1[AES_BLOCK_SIZE], tmp2[AES_BLOCK_SIZE];
|
||||
memcpy(tmp1, inptr, len);
|
||||
/* Fill with 0 to avoid valgrind uninitialized reads */
|
||||
memset(tmp1 + len, 0, sizeof(tmp1) - len);
|
||||
AES_encrypt(tmp1, tmp2, &ctxt->state.aes.encrypt_key);
|
||||
memcpy(outptr, tmp2, len);
|
||||
len = 0;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
AES_cbc_encrypt(in, out, len,
|
||||
&ctxt->state.aes.encrypt_key,
|
||||
ctxt->state.aes.iv, 1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static int qcrypto_cipher_decrypt_aes(QCryptoCipher *cipher,
|
||||
const void *in,
|
||||
void *out,
|
||||
size_t len,
|
||||
Error **errp)
|
||||
{
|
||||
QCryptoCipherBuiltin *ctxt = cipher->opaque;
|
||||
|
||||
if (cipher->mode == QCRYPTO_CIPHER_MODE_ECB) {
|
||||
const uint8_t *inptr = in;
|
||||
uint8_t *outptr = out;
|
||||
while (len) {
|
||||
if (len > AES_BLOCK_SIZE) {
|
||||
AES_decrypt(inptr, outptr, &ctxt->state.aes.encrypt_key);
|
||||
inptr += AES_BLOCK_SIZE;
|
||||
outptr += AES_BLOCK_SIZE;
|
||||
len -= AES_BLOCK_SIZE;
|
||||
} else {
|
||||
uint8_t tmp1[AES_BLOCK_SIZE], tmp2[AES_BLOCK_SIZE];
|
||||
memcpy(tmp1, inptr, len);
|
||||
/* Fill with 0 to avoid valgrind uninitialized reads */
|
||||
memset(tmp1 + len, 0, sizeof(tmp1) - len);
|
||||
AES_decrypt(tmp1, tmp2, &ctxt->state.aes.encrypt_key);
|
||||
memcpy(outptr, tmp2, len);
|
||||
len = 0;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
AES_cbc_encrypt(in, out, len,
|
||||
&ctxt->state.aes.encrypt_key,
|
||||
ctxt->state.aes.iv, 1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int qcrypto_cipher_setiv_aes(QCryptoCipher *cipher,
|
||||
const uint8_t *iv, size_t niv,
|
||||
Error **errp)
|
||||
{
|
||||
QCryptoCipherBuiltin *ctxt = cipher->opaque;
|
||||
if (niv != 16) {
|
||||
error_setg(errp, "IV must be 16 bytes not %zu", niv);
|
||||
return -1;
|
||||
}
|
||||
|
||||
g_free(ctxt->state.aes.iv);
|
||||
ctxt->state.aes.iv = g_new0(uint8_t, niv);
|
||||
memcpy(ctxt->state.aes.iv, iv, niv);
|
||||
ctxt->state.aes.niv = niv;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
static int qcrypto_cipher_init_aes(QCryptoCipher *cipher,
|
||||
const uint8_t *key, size_t nkey,
|
||||
Error **errp)
|
||||
{
|
||||
QCryptoCipherBuiltin *ctxt;
|
||||
|
||||
if (cipher->mode != QCRYPTO_CIPHER_MODE_CBC &&
|
||||
cipher->mode != QCRYPTO_CIPHER_MODE_ECB) {
|
||||
error_setg(errp, "Unsupported cipher mode %d", cipher->mode);
|
||||
return -1;
|
||||
}
|
||||
|
||||
ctxt = g_new0(QCryptoCipherBuiltin, 1);
|
||||
|
||||
if (AES_set_encrypt_key(key, nkey * 8, &ctxt->state.aes.encrypt_key) != 0) {
|
||||
error_setg(errp, "Failed to set encryption key");
|
||||
goto error;
|
||||
}
|
||||
|
||||
if (AES_set_decrypt_key(key, nkey * 8, &ctxt->state.aes.decrypt_key) != 0) {
|
||||
error_setg(errp, "Failed to set decryption key");
|
||||
goto error;
|
||||
}
|
||||
|
||||
ctxt->free = qcrypto_cipher_free_aes;
|
||||
ctxt->setiv = qcrypto_cipher_setiv_aes;
|
||||
ctxt->encrypt = qcrypto_cipher_encrypt_aes;
|
||||
ctxt->decrypt = qcrypto_cipher_decrypt_aes;
|
||||
|
||||
cipher->opaque = ctxt;
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
g_free(ctxt);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
static void qcrypto_cipher_free_des_rfb(QCryptoCipher *cipher)
|
||||
{
|
||||
QCryptoCipherBuiltin *ctxt = cipher->opaque;
|
||||
|
||||
g_free(ctxt->state.desrfb.key);
|
||||
g_free(ctxt);
|
||||
cipher->opaque = NULL;
|
||||
}
|
||||
|
||||
|
||||
static int qcrypto_cipher_encrypt_des_rfb(QCryptoCipher *cipher,
|
||||
const void *in,
|
||||
void *out,
|
||||
size_t len,
|
||||
Error **errp)
|
||||
{
|
||||
QCryptoCipherBuiltin *ctxt = cipher->opaque;
|
||||
size_t i;
|
||||
|
||||
if (len % 8) {
|
||||
error_setg(errp, "Buffer size must be multiple of 8 not %zu",
|
||||
len);
|
||||
return -1;
|
||||
}
|
||||
|
||||
deskey(ctxt->state.desrfb.key, EN0);
|
||||
|
||||
for (i = 0; i < len; i += 8) {
|
||||
des((void *)in + i, out + i);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static int qcrypto_cipher_decrypt_des_rfb(QCryptoCipher *cipher,
|
||||
const void *in,
|
||||
void *out,
|
||||
size_t len,
|
||||
Error **errp)
|
||||
{
|
||||
QCryptoCipherBuiltin *ctxt = cipher->opaque;
|
||||
size_t i;
|
||||
|
||||
if (len % 8) {
|
||||
error_setg(errp, "Buffer size must be multiple of 8 not %zu",
|
||||
len);
|
||||
return -1;
|
||||
}
|
||||
|
||||
deskey(ctxt->state.desrfb.key, DE1);
|
||||
|
||||
for (i = 0; i < len; i += 8) {
|
||||
des((void *)in + i, out + i);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static int qcrypto_cipher_setiv_des_rfb(QCryptoCipher *cipher,
|
||||
const uint8_t *iv, size_t niv,
|
||||
Error **errp)
|
||||
{
|
||||
error_setg(errp, "Setting IV is not supported");
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
static int qcrypto_cipher_init_des_rfb(QCryptoCipher *cipher,
|
||||
const uint8_t *key, size_t nkey,
|
||||
Error **errp)
|
||||
{
|
||||
QCryptoCipherBuiltin *ctxt;
|
||||
|
||||
if (cipher->mode != QCRYPTO_CIPHER_MODE_ECB) {
|
||||
error_setg(errp, "Unsupported cipher mode %d", cipher->mode);
|
||||
return -1;
|
||||
}
|
||||
|
||||
ctxt = g_new0(QCryptoCipherBuiltin, 1);
|
||||
|
||||
ctxt->state.desrfb.key = g_new0(uint8_t, nkey);
|
||||
memcpy(ctxt->state.desrfb.key, key, nkey);
|
||||
ctxt->state.desrfb.nkey = nkey;
|
||||
|
||||
ctxt->free = qcrypto_cipher_free_des_rfb;
|
||||
ctxt->setiv = qcrypto_cipher_setiv_des_rfb;
|
||||
ctxt->encrypt = qcrypto_cipher_encrypt_des_rfb;
|
||||
ctxt->decrypt = qcrypto_cipher_decrypt_des_rfb;
|
||||
|
||||
cipher->opaque = ctxt;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg)
|
||||
{
|
||||
switch (alg) {
|
||||
case QCRYPTO_CIPHER_ALG_DES_RFB:
|
||||
case QCRYPTO_CIPHER_ALG_AES_128:
|
||||
case QCRYPTO_CIPHER_ALG_AES_192:
|
||||
case QCRYPTO_CIPHER_ALG_AES_256:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
QCryptoCipher *qcrypto_cipher_new(QCryptoCipherAlgorithm alg,
|
||||
QCryptoCipherMode mode,
|
||||
const uint8_t *key, size_t nkey,
|
||||
Error **errp)
|
||||
{
|
||||
QCryptoCipher *cipher;
|
||||
|
||||
cipher = g_new0(QCryptoCipher, 1);
|
||||
cipher->alg = alg;
|
||||
cipher->mode = mode;
|
||||
|
||||
if (!qcrypto_cipher_validate_key_length(alg, nkey, errp)) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
switch (cipher->alg) {
|
||||
case QCRYPTO_CIPHER_ALG_DES_RFB:
|
||||
if (qcrypto_cipher_init_des_rfb(cipher, key, nkey, errp) < 0) {
|
||||
goto error;
|
||||
}
|
||||
break;
|
||||
case QCRYPTO_CIPHER_ALG_AES_128:
|
||||
case QCRYPTO_CIPHER_ALG_AES_192:
|
||||
case QCRYPTO_CIPHER_ALG_AES_256:
|
||||
if (qcrypto_cipher_init_aes(cipher, key, nkey, errp) < 0) {
|
||||
goto error;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
error_setg(errp,
|
||||
"Unsupported cipher algorithm %d", cipher->alg);
|
||||
goto error;
|
||||
}
|
||||
|
||||
return cipher;
|
||||
|
||||
error:
|
||||
g_free(cipher);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void qcrypto_cipher_free(QCryptoCipher *cipher)
|
||||
{
|
||||
QCryptoCipherBuiltin *ctxt = cipher->opaque;
|
||||
if (!cipher) {
|
||||
return;
|
||||
}
|
||||
|
||||
ctxt->free(cipher);
|
||||
g_free(cipher);
|
||||
}
|
||||
|
||||
|
||||
int qcrypto_cipher_encrypt(QCryptoCipher *cipher,
|
||||
const void *in,
|
||||
void *out,
|
||||
size_t len,
|
||||
Error **errp)
|
||||
{
|
||||
QCryptoCipherBuiltin *ctxt = cipher->opaque;
|
||||
|
||||
return ctxt->encrypt(cipher, in, out, len, errp);
|
||||
}
|
||||
|
||||
|
||||
int qcrypto_cipher_decrypt(QCryptoCipher *cipher,
|
||||
const void *in,
|
||||
void *out,
|
||||
size_t len,
|
||||
Error **errp)
|
||||
{
|
||||
QCryptoCipherBuiltin *ctxt = cipher->opaque;
|
||||
|
||||
return ctxt->decrypt(cipher, in, out, len, errp);
|
||||
}
|
||||
|
||||
|
||||
int qcrypto_cipher_setiv(QCryptoCipher *cipher,
|
||||
const uint8_t *iv, size_t niv,
|
||||
Error **errp)
|
||||
{
|
||||
QCryptoCipherBuiltin *ctxt = cipher->opaque;
|
||||
|
||||
return ctxt->setiv(cipher, iv, niv, errp);
|
||||
}
|
||||
49
crypto/cipher.c
Normal file
49
crypto/cipher.c
Normal file
@ -0,0 +1,49 @@
|
||||
/*
|
||||
* QEMU Crypto cipher algorithms
|
||||
*
|
||||
* Copyright (c) 2015 Red Hat, Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "crypto/cipher.h"
|
||||
|
||||
static size_t alg_key_len[QCRYPTO_CIPHER_ALG_LAST] = {
|
||||
[QCRYPTO_CIPHER_ALG_AES_128] = 16,
|
||||
[QCRYPTO_CIPHER_ALG_AES_192] = 24,
|
||||
[QCRYPTO_CIPHER_ALG_AES_256] = 32,
|
||||
[QCRYPTO_CIPHER_ALG_DES_RFB] = 8,
|
||||
};
|
||||
|
||||
static bool
|
||||
qcrypto_cipher_validate_key_length(QCryptoCipherAlgorithm alg,
|
||||
size_t nkey,
|
||||
Error **errp)
|
||||
{
|
||||
if ((unsigned)alg >= QCRYPTO_CIPHER_ALG_LAST) {
|
||||
error_setg(errp, "Cipher algorithm %d out of range",
|
||||
alg);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (alg_key_len[alg] != nkey) {
|
||||
error_setg(errp, "Cipher key length %zu should be %zu",
|
||||
alg_key_len[alg], nkey);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
#include "crypto/cipher-builtin.c"
|
||||
210
include/crypto/cipher.h
Normal file
210
include/crypto/cipher.h
Normal file
@ -0,0 +1,210 @@
|
||||
/*
|
||||
* QEMU Crypto cipher algorithms
|
||||
*
|
||||
* Copyright (c) 2015 Red Hat, Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef QCRYPTO_CIPHER_H__
|
||||
#define QCRYPTO_CIPHER_H__
|
||||
|
||||
#include "qemu-common.h"
|
||||
#include "qapi/error.h"
|
||||
|
||||
typedef struct QCryptoCipher QCryptoCipher;
|
||||
|
||||
typedef enum {
|
||||
QCRYPTO_CIPHER_ALG_AES_128,
|
||||
QCRYPTO_CIPHER_ALG_AES_192,
|
||||
QCRYPTO_CIPHER_ALG_AES_256,
|
||||
QCRYPTO_CIPHER_ALG_DES_RFB, /* A stupid variant on DES for VNC */
|
||||
|
||||
QCRYPTO_CIPHER_ALG_LAST
|
||||
} QCryptoCipherAlgorithm;
|
||||
|
||||
typedef enum {
|
||||
QCRYPTO_CIPHER_MODE_ECB,
|
||||
QCRYPTO_CIPHER_MODE_CBC,
|
||||
|
||||
QCRYPTO_CIPHER_MODE_LAST
|
||||
} QCryptoCipherMode;
|
||||
|
||||
/**
|
||||
* QCryptoCipher:
|
||||
*
|
||||
* The QCryptoCipher object provides a way to perform encryption
|
||||
* and decryption of data, with a standard API, regardless of the
|
||||
* algorithm used. It further isolates the calling code from the
|
||||
* details of the specific underlying implementation, whether
|
||||
* built-in, libgcrypt or nettle.
|
||||
*
|
||||
* Each QCryptoCipher object is capable of performing both
|
||||
* encryption and decryption, and can operate in a number
|
||||
* or modes including ECB, CBC.
|
||||
*
|
||||
* <example>
|
||||
* <title>Encrypting data with AES-128 in CBC mode</title>
|
||||
* <programlisting>
|
||||
* QCryptoCipher *cipher;
|
||||
* uint8_t key = ....;
|
||||
* size_t keylen = 16;
|
||||
* uint8_t iv = ....;
|
||||
*
|
||||
* if (!qcrypto_cipher_supports(QCRYPTO_CIPHER_ALG_AES_128)) {
|
||||
* error_report(errp, "Feature <blah> requires AES cipher support");
|
||||
* return -1;
|
||||
* }
|
||||
*
|
||||
* cipher = qcrypto_cipher_new(QCRYPTO_CIPHER_ALG_AES_128,
|
||||
* QCRYPTO_CIPHER_MODE_CBC,
|
||||
* key, keylen,
|
||||
* errp);
|
||||
* if (!cipher) {
|
||||
* return -1;
|
||||
* }
|
||||
*
|
||||
* if (qcrypto_cipher_set_iv(cipher, iv, keylen, errp) < 0) {
|
||||
* return -1;
|
||||
* }
|
||||
*
|
||||
* if (qcrypto_cipher_encrypt(cipher, rawdata, encdata, datalen, errp) < 0) {
|
||||
* return -1;
|
||||
* }
|
||||
*
|
||||
* qcrypto_cipher_free(cipher);
|
||||
* </programlisting>
|
||||
* </example>
|
||||
*
|
||||
*/
|
||||
|
||||
struct QCryptoCipher {
|
||||
QCryptoCipherAlgorithm alg;
|
||||
QCryptoCipherMode mode;
|
||||
void *opaque;
|
||||
};
|
||||
|
||||
/**
|
||||
* qcrypto_cipher_supports:
|
||||
* @alg: the cipher algorithm
|
||||
*
|
||||
* Determine if @alg cipher algorithm is supported by the
|
||||
* current configured build
|
||||
*
|
||||
* Returns: true if the algorithm is supported, false otherwise
|
||||
*/
|
||||
bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg);
|
||||
|
||||
|
||||
/**
|
||||
* qcrypto_cipher_new:
|
||||
* @alg: the cipher algorithm
|
||||
* @mode: the cipher usage mode
|
||||
* @key: the private key bytes
|
||||
* @nkey: the length of @key
|
||||
* @errp: pointer to an uninitialized error object
|
||||
*
|
||||
* Creates a new cipher object for encrypting/decrypting
|
||||
* data with the algorithm @alg in the usage mode @mode.
|
||||
*
|
||||
* The @key parameter provides the bytes representing
|
||||
* the encryption/decryption key to use. The @nkey parameter
|
||||
* specifies the length of @key in bytes. Each algorithm has
|
||||
* one or more valid key lengths, and it is an error to provide
|
||||
* a key of the incorrect length.
|
||||
*
|
||||
* The returned cipher object must be released with
|
||||
* qcrypto_cipher_free() when no longer required
|
||||
*
|
||||
* Returns: a new cipher object, or NULL on error
|
||||
*/
|
||||
QCryptoCipher *qcrypto_cipher_new(QCryptoCipherAlgorithm alg,
|
||||
QCryptoCipherMode mode,
|
||||
const uint8_t *key, size_t nkey,
|
||||
Error **errp);
|
||||
|
||||
/**
|
||||
* qcrypto_cipher_free:
|
||||
* @cipher: the cipher object
|
||||
*
|
||||
* Release the memory associated with @cipher that
|
||||
* was previously allocated by qcrypto_cipher_new()
|
||||
*/
|
||||
void qcrypto_cipher_free(QCryptoCipher *cipher);
|
||||
|
||||
/**
|
||||
* qcrypto_cipher_encrypt:
|
||||
* @cipher: the cipher object
|
||||
* @in: buffer holding the plain text input data
|
||||
* @out: buffer to fill with the cipher text output data
|
||||
* @len: the length of @in and @out buffers
|
||||
* @errp: pointer to an uninitialized error object
|
||||
*
|
||||
* Encrypts the plain text stored in @in, filling
|
||||
* @out with the resulting ciphered text. Both the
|
||||
* @in and @out buffers must have the same size,
|
||||
* given by @len.
|
||||
*
|
||||
* Returns: 0 on success, or -1 on error
|
||||
*/
|
||||
int qcrypto_cipher_encrypt(QCryptoCipher *cipher,
|
||||
const void *in,
|
||||
void *out,
|
||||
size_t len,
|
||||
Error **errp);
|
||||
|
||||
|
||||
/**
|
||||
* qcrypto_cipher_decrypt:
|
||||
* @cipher: the cipher object
|
||||
* @in: buffer holding the cipher text input data
|
||||
* @out: buffer to fill with the plain text output data
|
||||
* @len: the length of @in and @out buffers
|
||||
* @errp: pointer to an uninitialized error object
|
||||
*
|
||||
* Decrypts the cipher text stored in @in, filling
|
||||
* @out with the resulting plain text. Both the
|
||||
* @in and @out buffers must have the same size,
|
||||
* given by @len.
|
||||
*
|
||||
* Returns: 0 on success, or -1 on error
|
||||
*/
|
||||
int qcrypto_cipher_decrypt(QCryptoCipher *cipher,
|
||||
const void *in,
|
||||
void *out,
|
||||
size_t len,
|
||||
Error **errp);
|
||||
|
||||
/**
|
||||
* qcrypto_cipher_setiv:
|
||||
* @cipher: the cipher object
|
||||
* @iv: the initialization vector bytes
|
||||
* @niv: the length of @iv
|
||||
* @errpr: pointer to an uninitialized error object
|
||||
*
|
||||
* If the @cipher object is setup to use a mode that requires
|
||||
* initialization vectors, this sets the initialization vector
|
||||
* bytes. The @iv data should have the same length as the
|
||||
* cipher key used when originally constructing the cipher
|
||||
* object. It is an error to set an initialization vector
|
||||
* if the cipher mode does not require one.
|
||||
*
|
||||
* Returns: 0 on success, -1 on error
|
||||
*/
|
||||
int qcrypto_cipher_setiv(QCryptoCipher *cipher,
|
||||
const uint8_t *iv, size_t niv,
|
||||
Error **errp);
|
||||
|
||||
#endif /* QCRYPTO_CIPHER_H__ */
|
||||
1
tests/.gitignore
vendored
1
tests/.gitignore
vendored
@ -10,6 +10,7 @@ rcutorture
|
||||
test-aio
|
||||
test-bitops
|
||||
test-coroutine
|
||||
test-crypto-cipher
|
||||
test-crypto-hash
|
||||
test-cutils
|
||||
test-hbitmap
|
||||
|
||||
@ -75,6 +75,7 @@ gcov-files-test-qemu-opts-y = qom/test-qemu-opts.c
|
||||
check-unit-y += tests/test-write-threshold$(EXESUF)
|
||||
gcov-files-test-write-threshold-y = block/write-threshold.c
|
||||
check-unit-$(CONFIG_GNUTLS_HASH) += tests/test-crypto-hash$(EXESUF)
|
||||
check-unit-y += tests/test-crypto-cipher$(EXESUF)
|
||||
|
||||
check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
|
||||
|
||||
@ -341,6 +342,7 @@ tests/test-opts-visitor$(EXESUF): tests/test-opts-visitor.o $(test-qapi-obj-y) l
|
||||
tests/test-mul64$(EXESUF): tests/test-mul64.o libqemuutil.a
|
||||
tests/test-bitops$(EXESUF): tests/test-bitops.o libqemuutil.a
|
||||
tests/test-crypto-hash$(EXESUF): tests/test-crypto-hash.o libqemuutil.a libqemustub.a
|
||||
tests/test-crypto-cipher$(EXESUF): tests/test-crypto-cipher.o libqemuutil.a libqemustub.a
|
||||
|
||||
libqos-obj-y = tests/libqos/pci.o tests/libqos/fw_cfg.o tests/libqos/malloc.o
|
||||
libqos-obj-y += tests/libqos/i2c.o tests/libqos/libqos.o
|
||||
|
||||
290
tests/test-crypto-cipher.c
Normal file
290
tests/test-crypto-cipher.c
Normal file
@ -0,0 +1,290 @@
|
||||
/*
|
||||
* QEMU Crypto cipher algorithms
|
||||
*
|
||||
* Copyright (c) 2015 Red Hat, Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <glib.h>
|
||||
|
||||
#include "crypto/init.h"
|
||||
#include "crypto/cipher.h"
|
||||
|
||||
typedef struct QCryptoCipherTestData QCryptoCipherTestData;
|
||||
struct QCryptoCipherTestData {
|
||||
const char *path;
|
||||
QCryptoCipherAlgorithm alg;
|
||||
QCryptoCipherMode mode;
|
||||
const char *key;
|
||||
const char *plaintext;
|
||||
const char *ciphertext;
|
||||
const char *iv;
|
||||
};
|
||||
|
||||
/* AES test data comes from appendix F of:
|
||||
*
|
||||
* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
|
||||
*/
|
||||
static QCryptoCipherTestData test_data[] = {
|
||||
{
|
||||
/* NIST F.1.1 ECB-AES128.Encrypt */
|
||||
.path = "/crypto/cipher/aes-ecb-128",
|
||||
.alg = QCRYPTO_CIPHER_ALG_AES_128,
|
||||
.mode = QCRYPTO_CIPHER_MODE_ECB,
|
||||
.key = "2b7e151628aed2a6abf7158809cf4f3c",
|
||||
.plaintext =
|
||||
"6bc1bee22e409f96e93d7e117393172a"
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51"
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef"
|
||||
"f69f2445df4f9b17ad2b417be66c3710",
|
||||
.ciphertext =
|
||||
"3ad77bb40d7a3660a89ecaf32466ef97"
|
||||
"f5d3d58503b9699de785895a96fdbaaf"
|
||||
"43b1cd7f598ece23881b00e3ed030688"
|
||||
"7b0c785e27e8ad3f8223207104725dd4"
|
||||
},
|
||||
{
|
||||
/* NIST F.1.3 ECB-AES192.Encrypt */
|
||||
.path = "/crypto/cipher/aes-ecb-192",
|
||||
.alg = QCRYPTO_CIPHER_ALG_AES_192,
|
||||
.mode = QCRYPTO_CIPHER_MODE_ECB,
|
||||
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
|
||||
.plaintext =
|
||||
"6bc1bee22e409f96e93d7e117393172a"
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51"
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef"
|
||||
"f69f2445df4f9b17ad2b417be66c3710",
|
||||
.ciphertext =
|
||||
"bd334f1d6e45f25ff712a214571fa5cc"
|
||||
"974104846d0ad3ad7734ecb3ecee4eef"
|
||||
"ef7afd2270e2e60adce0ba2face6444e"
|
||||
"9a4b41ba738d6c72fb16691603c18e0e"
|
||||
},
|
||||
{
|
||||
/* NIST F.1.5 ECB-AES256.Encrypt */
|
||||
.path = "/crypto/cipher/aes-ecb-256",
|
||||
.alg = QCRYPTO_CIPHER_ALG_AES_256,
|
||||
.mode = QCRYPTO_CIPHER_MODE_ECB,
|
||||
.key =
|
||||
"603deb1015ca71be2b73aef0857d7781"
|
||||
"1f352c073b6108d72d9810a30914dff4",
|
||||
.plaintext =
|
||||
"6bc1bee22e409f96e93d7e117393172a"
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51"
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef"
|
||||
"f69f2445df4f9b17ad2b417be66c3710",
|
||||
.ciphertext =
|
||||
"f3eed1bdb5d2a03c064b5a7e3db181f8"
|
||||
"591ccb10d410ed26dc5ba74a31362870"
|
||||
"b6ed21b99ca6f4f9f153e7b1beafed1d"
|
||||
"23304b7a39f9f3ff067d8d8f9e24ecc7",
|
||||
},
|
||||
{
|
||||
/* NIST F.2.1 CBC-AES128.Encrypt */
|
||||
.path = "/crypto/cipher/aes-cbc-128",
|
||||
.alg = QCRYPTO_CIPHER_ALG_AES_128,
|
||||
.mode = QCRYPTO_CIPHER_MODE_CBC,
|
||||
.key = "2b7e151628aed2a6abf7158809cf4f3c",
|
||||
.iv = "000102030405060708090a0b0c0d0e0f",
|
||||
.plaintext =
|
||||
"6bc1bee22e409f96e93d7e117393172a"
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51"
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef"
|
||||
"f69f2445df4f9b17ad2b417be66c3710",
|
||||
.ciphertext =
|
||||
"7649abac8119b246cee98e9b12e9197d"
|
||||
"5086cb9b507219ee95db113a917678b2"
|
||||
"73bed6b8e3c1743b7116e69e22229516"
|
||||
"3ff1caa1681fac09120eca307586e1a7",
|
||||
},
|
||||
{
|
||||
/* NIST F.2.3 CBC-AES128.Encrypt */
|
||||
.path = "/crypto/cipher/aes-cbc-192",
|
||||
.alg = QCRYPTO_CIPHER_ALG_AES_192,
|
||||
.mode = QCRYPTO_CIPHER_MODE_CBC,
|
||||
.key = "8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
|
||||
.iv = "000102030405060708090a0b0c0d0e0f",
|
||||
.plaintext =
|
||||
"6bc1bee22e409f96e93d7e117393172a"
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51"
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef"
|
||||
"f69f2445df4f9b17ad2b417be66c3710",
|
||||
.ciphertext =
|
||||
"4f021db243bc633d7178183a9fa071e8"
|
||||
"b4d9ada9ad7dedf4e5e738763f69145a"
|
||||
"571b242012fb7ae07fa9baac3df102e0"
|
||||
"08b0e27988598881d920a9e64f5615cd",
|
||||
},
|
||||
{
|
||||
/* NIST F.2.5 CBC-AES128.Encrypt */
|
||||
.path = "/crypto/cipher/aes-cbc-256",
|
||||
.alg = QCRYPTO_CIPHER_ALG_AES_256,
|
||||
.mode = QCRYPTO_CIPHER_MODE_CBC,
|
||||
.key =
|
||||
"603deb1015ca71be2b73aef0857d7781"
|
||||
"1f352c073b6108d72d9810a30914dff4",
|
||||
.iv = "000102030405060708090a0b0c0d0e0f",
|
||||
.plaintext =
|
||||
"6bc1bee22e409f96e93d7e117393172a"
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51"
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef"
|
||||
"f69f2445df4f9b17ad2b417be66c3710",
|
||||
.ciphertext =
|
||||
"f58c4c04d6e5f1ba779eabfb5f7bfbd6"
|
||||
"9cfc4e967edb808d679f777bc6702c7d"
|
||||
"39f23369a9d9bacfa530e26304231461"
|
||||
"b2eb05e2c39be9fcda6c19078c6a9d1b",
|
||||
},
|
||||
{
|
||||
.path = "/crypto/cipher/des-rfb-ecb-56",
|
||||
.alg = QCRYPTO_CIPHER_ALG_DES_RFB,
|
||||
.mode = QCRYPTO_CIPHER_MODE_ECB,
|
||||
.key = "0123456789abcdef",
|
||||
.plaintext =
|
||||
"6bc1bee22e409f96e93d7e117393172a"
|
||||
"ae2d8a571e03ac9c9eb76fac45af8e51"
|
||||
"30c81c46a35ce411e5fbc1191a0a52ef"
|
||||
"f69f2445df4f9b17ad2b417be66c3710",
|
||||
.ciphertext =
|
||||
"8f346aaf64eaf24040720d80648c52e7"
|
||||
"aefc616be53ab1a3d301e69d91e01838"
|
||||
"ffd29f1bb5596ad94ea2d8e6196b7f09"
|
||||
"30d8ed0bf2773af36dd82a6280c20926",
|
||||
},
|
||||
};
|
||||
|
||||
|
||||
static inline int unhex(char c)
|
||||
{
|
||||
if (c >= 'a' && c <= 'f') {
|
||||
return 10 + (c - 'a');
|
||||
}
|
||||
if (c >= 'A' && c <= 'F') {
|
||||
return 10 + (c - 'A');
|
||||
}
|
||||
return c - '0';
|
||||
}
|
||||
|
||||
static inline char hex(int i)
|
||||
{
|
||||
if (i < 10) {
|
||||
return '0' + i;
|
||||
}
|
||||
return 'a' + (i - 10);
|
||||
}
|
||||
|
||||
static size_t unhex_string(const char *hexstr,
|
||||
uint8_t **data)
|
||||
{
|
||||
size_t len;
|
||||
size_t i;
|
||||
|
||||
if (!hexstr) {
|
||||
*data = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
len = strlen(hexstr);
|
||||
*data = g_new0(uint8_t, len / 2);
|
||||
|
||||
for (i = 0; i < len; i += 2) {
|
||||
(*data)[i/2] = (unhex(hexstr[i]) << 4) | unhex(hexstr[i+1]);
|
||||
}
|
||||
return len / 2;
|
||||
}
|
||||
|
||||
static char *hex_string(const uint8_t *bytes,
|
||||
size_t len)
|
||||
{
|
||||
char *hexstr = g_new0(char, len * 2 + 1);
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
hexstr[i*2] = hex((bytes[i] >> 4) & 0xf);
|
||||
hexstr[i*2+1] = hex(bytes[i] & 0xf);
|
||||
}
|
||||
hexstr[len*2] = '\0';
|
||||
|
||||
return hexstr;
|
||||
}
|
||||
|
||||
static void test_cipher(const void *opaque)
|
||||
{
|
||||
const QCryptoCipherTestData *data = opaque;
|
||||
|
||||
QCryptoCipher *cipher;
|
||||
Error *err = NULL;
|
||||
uint8_t *key, *iv, *ciphertext, *plaintext, *outtext;
|
||||
size_t nkey, niv, nciphertext, nplaintext;
|
||||
char *outtexthex;
|
||||
|
||||
g_test_message("foo");
|
||||
nkey = unhex_string(data->key, &key);
|
||||
niv = unhex_string(data->iv, &iv);
|
||||
nciphertext = unhex_string(data->ciphertext, &ciphertext);
|
||||
nplaintext = unhex_string(data->plaintext, &plaintext);
|
||||
|
||||
g_assert(nciphertext == nplaintext);
|
||||
|
||||
outtext = g_new0(uint8_t, nciphertext);
|
||||
|
||||
cipher = qcrypto_cipher_new(
|
||||
data->alg, data->mode,
|
||||
key, nkey,
|
||||
&err);
|
||||
g_assert(cipher != NULL);
|
||||
g_assert(err == NULL);
|
||||
|
||||
|
||||
if (iv) {
|
||||
g_assert(qcrypto_cipher_setiv(cipher,
|
||||
iv, niv,
|
||||
&err) == 0);
|
||||
g_assert(err == NULL);
|
||||
}
|
||||
g_assert(qcrypto_cipher_encrypt(cipher,
|
||||
plaintext,
|
||||
outtext,
|
||||
nplaintext,
|
||||
&err) == 0);
|
||||
g_assert(err == NULL);
|
||||
|
||||
outtexthex = hex_string(outtext, nciphertext);
|
||||
|
||||
g_assert_cmpstr(outtexthex, ==, data->ciphertext);
|
||||
|
||||
g_free(outtext);
|
||||
g_free(outtexthex);
|
||||
g_free(key);
|
||||
g_free(iv);
|
||||
g_free(ciphertext);
|
||||
g_free(plaintext);
|
||||
qcrypto_cipher_free(cipher);
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
g_test_init(&argc, &argv, NULL);
|
||||
|
||||
g_assert(qcrypto_init(NULL) == 0);
|
||||
|
||||
for (i = 0; i < G_N_ELEMENTS(test_data); i++) {
|
||||
g_test_add_data_func(test_data[i].path, &test_data[i], test_cipher);
|
||||
}
|
||||
return g_test_run();
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user