[mirror_qemu.git] / tests / benchmark-crypto-cipher.c

/*
 * QEMU Crypto cipher speed benchmark
 *
 * Copyright (c) 2017 HUAWEI TECHNOLOGIES CO., LTD.
 *
 * Authors:
 *    Longpeng(Mike) <longpeng2@huawei.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or
 * (at your option) any later version.  See the COPYING file in the
 * top-level directory.
 */
#include "qemu/osdep.h"
#include "qemu/units.h"
#include "crypto/init.h"
#include "crypto/cipher.h"

static void test_cipher_speed(size_t chunk_size,
                              QCryptoCipherMode mode,
                              QCryptoCipherAlgorithm alg)
{
    QCryptoCipher *cipher;
    Error *err = NULL;
    double total = 0.0;
    uint8_t *key = NULL, *iv = NULL;
    uint8_t *plaintext = NULL, *ciphertext = NULL;
    size_t nkey;
    size_t niv;

    if (!qcrypto_cipher_supports(alg, mode)) {
        return;
    }

    nkey = qcrypto_cipher_get_key_len(alg);
    niv = qcrypto_cipher_get_iv_len(alg, mode);
    if (mode == QCRYPTO_CIPHER_MODE_XTS) {
        nkey *= 2;
    }

    key = g_new0(uint8_t, nkey);
    memset(key, g_test_rand_int(), nkey);

    iv = g_new0(uint8_t, niv);
    memset(iv, g_test_rand_int(), niv);

    ciphertext = g_new0(uint8_t, chunk_size);

    plaintext = g_new0(uint8_t, chunk_size);
    memset(plaintext, g_test_rand_int(), chunk_size);

    cipher = qcrypto_cipher_new(alg, mode,
                                key, nkey, &err);
    g_assert(cipher != NULL);

    if (mode != QCRYPTO_CIPHER_MODE_ECB)
        g_assert(qcrypto_cipher_setiv(cipher,
                                      iv, niv,
                                      &err) == 0);

    g_test_timer_start();
    do {
        g_assert(qcrypto_cipher_encrypt(cipher,
                                        plaintext,
                                        ciphertext,
                                        chunk_size,
                                        &err) == 0);
        total += chunk_size;
    } while (g_test_timer_elapsed() < 1.0);

    total /= MiB;
    g_print("Enc chunk %zu bytes ", chunk_size);
    g_print("%.2f MB/sec ", total / g_test_timer_last());

    total = 0.0;
    g_test_timer_start();
    do {
        g_assert(qcrypto_cipher_decrypt(cipher,
                                        plaintext,
                                        ciphertext,
                                        chunk_size,
                                        &err) == 0);
        total += chunk_size;
    } while (g_test_timer_elapsed() < 1.0);

    total /= MiB;
    g_print("Dec chunk %zu bytes ", chunk_size);
    g_print("%.2f MB/sec ", total / g_test_timer_last());

    qcrypto_cipher_free(cipher);
    g_free(plaintext);
    g_free(ciphertext);
    g_free(iv);
    g_free(key);
}


static void test_cipher_speed_ecb_aes_128(const void *opaque)
{
    size_t chunk_size = (size_t)opaque;
    test_cipher_speed(chunk_size,
                      QCRYPTO_CIPHER_MODE_ECB,
                      QCRYPTO_CIPHER_ALG_AES_128);
}

static void test_cipher_speed_ecb_aes_256(const void *opaque)
{
    size_t chunk_size = (size_t)opaque;
    test_cipher_speed(chunk_size,
                      QCRYPTO_CIPHER_MODE_ECB,
                      QCRYPTO_CIPHER_ALG_AES_256);
}

static void test_cipher_speed_cbc_aes_128(const void *opaque)
{
    size_t chunk_size = (size_t)opaque;
    test_cipher_speed(chunk_size,
                      QCRYPTO_CIPHER_MODE_CBC,
                      QCRYPTO_CIPHER_ALG_AES_128);
}

static void test_cipher_speed_cbc_aes_256(const void *opaque)
{
    size_t chunk_size = (size_t)opaque;
    test_cipher_speed(chunk_size,
                      QCRYPTO_CIPHER_MODE_CBC,
                      QCRYPTO_CIPHER_ALG_AES_256);
}

static void test_cipher_speed_ctr_aes_128(const void *opaque)
{
    size_t chunk_size = (size_t)opaque;
    test_cipher_speed(chunk_size,
                      QCRYPTO_CIPHER_MODE_CTR,
                      QCRYPTO_CIPHER_ALG_AES_128);
}

static void test_cipher_speed_ctr_aes_256(const void *opaque)
{
    size_t chunk_size = (size_t)opaque;
    test_cipher_speed(chunk_size,
                      QCRYPTO_CIPHER_MODE_CTR,
                      QCRYPTO_CIPHER_ALG_AES_256);
}

static void test_cipher_speed_xts_aes_128(const void *opaque)
{
    size_t chunk_size = (size_t)opaque;
    test_cipher_speed(chunk_size,
                      QCRYPTO_CIPHER_MODE_XTS,
                      QCRYPTO_CIPHER_ALG_AES_128);
}

static void test_cipher_speed_xts_aes_256(const void *opaque)
{
    size_t chunk_size = (size_t)opaque;
    test_cipher_speed(chunk_size,
                      QCRYPTO_CIPHER_MODE_XTS,
                      QCRYPTO_CIPHER_ALG_AES_256);
}


int main(int argc, char **argv)
{
    g_test_init(&argc, &argv, NULL);
    g_assert(qcrypto_init(NULL) == 0);

#define ADD_TEST(mode, cipher, keysize, chunk)                          \
    g_test_add_data_func(                                               \
        "/crypto/cipher/" #mode "-" #cipher "-" #keysize "/chunk-" #chunk, \
        (void *)chunk,                                                  \
        test_cipher_speed_ ## mode ## _ ## cipher ## _ ## keysize)

#define ADD_TESTS(chunk)                        \
    do {                                        \
        ADD_TEST(ecb, aes, 128, chunk);         \
        ADD_TEST(ecb, aes, 256, chunk);         \
        ADD_TEST(cbc, aes, 128, chunk);         \
        ADD_TEST(cbc, aes, 256, chunk);         \
        ADD_TEST(ctr, aes, 128, chunk);         \
        ADD_TEST(ctr, aes, 256, chunk);         \
        ADD_TEST(xts, aes, 128, chunk);         \
        ADD_TEST(xts, aes, 256, chunk);         \
    } while (0)

    ADD_TESTS(512);
    ADD_TESTS(4096);
    ADD_TESTS(16384);
    ADD_TESTS(65536);

    return g_test_run();
}
Commit	Line	Data
1efd9d5e LM	1	/*
	2	* QEMU Crypto cipher speed benchmark
	3	*
	4	* Copyright (c) 2017 HUAWEI TECHNOLOGIES CO., LTD.
	5	*
	6	* Authors:
	7	* Longpeng(Mike) <longpeng2@huawei.com>
	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2 or
	10	* (at your option) any later version. See the COPYING file in the
	11	* top-level directory.
	12	*/
	13	#include "qemu/osdep.h"
68dbb6d0	14	#include "qemu/units.h"
1efd9d5e LM	15	#include "crypto/init.h"
	16	#include "crypto/cipher.h"
	17
a9e08155 DB	18	static void test_cipher_speed(size_t chunk_size,
	19	QCryptoCipherMode mode,
	20	QCryptoCipherAlgorithm alg)
1efd9d5e LM	21	{
	22	QCryptoCipher *cipher;
	23	Error *err = NULL;
	24	double total = 0.0;
1efd9d5e LM	25	uint8_t key = NULL, iv = NULL;
1efd9d5e LM	26	uint8_t plaintext = NULL, ciphertext = NULL;
a9e08155 DB	27	size_t nkey;
	28	size_t niv;
	29
	30	if (!qcrypto_cipher_supports(alg, mode)) {
	31	return;
	32	}
	33
	34	nkey = qcrypto_cipher_get_key_len(alg);
	35	niv = qcrypto_cipher_get_iv_len(alg, mode);
	36	if (mode == QCRYPTO_CIPHER_MODE_XTS) {
	37	nkey *= 2;
	38	}
1efd9d5e LM	39
	40	key = g_new0(uint8_t, nkey);
	41	memset(key, g_test_rand_int(), nkey);
	42
	43	iv = g_new0(uint8_t, niv);
	44	memset(iv, g_test_rand_int(), niv);
	45
	46	ciphertext = g_new0(uint8_t, chunk_size);
	47
	48	plaintext = g_new0(uint8_t, chunk_size);
	49	memset(plaintext, g_test_rand_int(), chunk_size);
	50
a9e08155	51	cipher = qcrypto_cipher_new(alg, mode,
1efd9d5e LM	52	key, nkey, &err);
	53	g_assert(cipher != NULL);
	54
a9e08155 DB	55	if (mode != QCRYPTO_CIPHER_MODE_ECB)
	56	g_assert(qcrypto_cipher_setiv(cipher,
	57	iv, niv,
	58	&err) == 0);
1efd9d5e LM	59
	60	g_test_timer_start();
	61	do {
	62	g_assert(qcrypto_cipher_encrypt(cipher,
	63	plaintext,
	64	ciphertext,
	65	chunk_size,
	66	&err) == 0);
	67	total += chunk_size;
a9e08155	68	} while (g_test_timer_elapsed() < 1.0);
1efd9d5e	69
68dbb6d0	70	total /= MiB;
a9e08155 DB	71	g_print("Enc chunk %zu bytes ", chunk_size);
	72	g_print("%.2f MB/sec ", total / g_test_timer_last());
	73
	74	total = 0.0;
	75	g_test_timer_start();
	76	do {
	77	g_assert(qcrypto_cipher_decrypt(cipher,
	78	plaintext,
	79	ciphertext,
	80	chunk_size,
	81	&err) == 0);
	82	total += chunk_size;
	83	} while (g_test_timer_elapsed() < 1.0);
	84
	85	total /= MiB;
	86	g_print("Dec chunk %zu bytes ", chunk_size);
	87	g_print("%.2f MB/sec ", total / g_test_timer_last());
1efd9d5e LM	88
	89	qcrypto_cipher_free(cipher);
	90	g_free(plaintext);
	91	g_free(ciphertext);
	92	g_free(iv);
	93	g_free(key);
	94	}
	95
a9e08155 DB	96
	97	static void test_cipher_speed_ecb_aes_128(const void *opaque)
	98	{
	99	size_t chunk_size = (size_t)opaque;
	100	test_cipher_speed(chunk_size,
	101	QCRYPTO_CIPHER_MODE_ECB,
	102	QCRYPTO_CIPHER_ALG_AES_128);
	103	}
	104
	105	static void test_cipher_speed_ecb_aes_256(const void *opaque)
1efd9d5e	106	{
a9e08155 DB	107	size_t chunk_size = (size_t)opaque;
	108	test_cipher_speed(chunk_size,
	109	QCRYPTO_CIPHER_MODE_ECB,
	110	QCRYPTO_CIPHER_ALG_AES_256);
	111	}
	112
	113	static void test_cipher_speed_cbc_aes_128(const void *opaque)
	114	{
	115	size_t chunk_size = (size_t)opaque;
	116	test_cipher_speed(chunk_size,
	117	QCRYPTO_CIPHER_MODE_CBC,
	118	QCRYPTO_CIPHER_ALG_AES_128);
	119	}
1efd9d5e	120
a9e08155 DB	121	static void test_cipher_speed_cbc_aes_256(const void *opaque)
	122	{
	123	size_t chunk_size = (size_t)opaque;
	124	test_cipher_speed(chunk_size,
	125	QCRYPTO_CIPHER_MODE_CBC,
	126	QCRYPTO_CIPHER_ALG_AES_256);
	127	}
	128
	129	static void test_cipher_speed_ctr_aes_128(const void *opaque)
	130	{
	131	size_t chunk_size = (size_t)opaque;
	132	test_cipher_speed(chunk_size,
	133	QCRYPTO_CIPHER_MODE_CTR,
	134	QCRYPTO_CIPHER_ALG_AES_128);
	135	}
	136
	137	static void test_cipher_speed_ctr_aes_256(const void *opaque)
	138	{
	139	size_t chunk_size = (size_t)opaque;
	140	test_cipher_speed(chunk_size,
	141	QCRYPTO_CIPHER_MODE_CTR,
	142	QCRYPTO_CIPHER_ALG_AES_256);
	143	}
	144
	145	static void test_cipher_speed_xts_aes_128(const void *opaque)
	146	{
	147	size_t chunk_size = (size_t)opaque;
	148	test_cipher_speed(chunk_size,
	149	QCRYPTO_CIPHER_MODE_XTS,
	150	QCRYPTO_CIPHER_ALG_AES_128);
	151	}
	152
	153	static void test_cipher_speed_xts_aes_256(const void *opaque)
	154	{
	155	size_t chunk_size = (size_t)opaque;
	156	test_cipher_speed(chunk_size,
	157	QCRYPTO_CIPHER_MODE_XTS,
	158	QCRYPTO_CIPHER_ALG_AES_256);
	159	}
	160
	161
	162	int main(int argc, char **argv)
	163	{
1efd9d5e LM	164	g_test_init(&argc, &argv, NULL);
	165	g_assert(qcrypto_init(NULL) == 0);
	166
a9e08155 DB	167	#define ADD_TEST(mode, cipher, keysize, chunk) \
	168	g_test_add_data_func( \
	169	"/crypto/cipher/" #mode "-" #cipher "-" #keysize "/chunk-" #chunk, \
	170	(void *)chunk, \
	171	test_cipher_speed_ ## mode ## _ ## cipher ## _ ## keysize)
	172
	173	#define ADD_TESTS(chunk) \
	174	do { \
	175	ADD_TEST(ecb, aes, 128, chunk); \
	176	ADD_TEST(ecb, aes, 256, chunk); \
	177	ADD_TEST(cbc, aes, 128, chunk); \
	178	ADD_TEST(cbc, aes, 256, chunk); \
	179	ADD_TEST(ctr, aes, 128, chunk); \
	180	ADD_TEST(ctr, aes, 256, chunk); \
	181	ADD_TEST(xts, aes, 128, chunk); \
	182	ADD_TEST(xts, aes, 256, chunk); \
	183	} while (0)
	184
	185	ADD_TESTS(512);
	186	ADD_TESTS(4096);
	187	ADD_TESTS(16384);
	188	ADD_TESTS(65536);
1efd9d5e LM	189
	190	return g_test_run();
	191	}