d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

app/test: add libcrypto

Browse Source 
This patch contains unit tests for libcrypto PMD. User can
use app/test application to check how to use this pmd and to
verify crypto processing.

Test name is cryptodev_libcrypto_autotest.
For performance test cryptodev_libcrypto_perftest can be used.

Signed-off-by: Piotr Azarewicz <piotrx.t.azarewicz@intel.com>
Signed-off-by: Marcin Kerlin <marcinx.kerlin@intel.com>
Signed-off-by: Daniel Mrzyglod <danielx.t.mrzyglod@intel.com>
Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
This commit is contained in:
Slawomir Mrozowicz 2016-10-04 17:11:21 +02:00 committed by Pablo de Lara
parent e1809db624
commit ffbe3be0d4
9 changed files with 3900 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1397
app/test/test_cryptodev.c
View File

File diff suppressed because it is too large Load Diff

1
app/test/test_cryptodev.h
View File

@ -63,6 +63,7 @@
#define DIGEST_BYTE_LENGTH_SNOW3G_UIA2 (BYTE_LENGTH(32))
#define DIGEST_BYTE_LENGTH_KASUMI_F9 (BYTE_LENGTH(32))
#define AES_XCBC_MAC_KEY_SZ (16)
#define DIGEST_BYTE_LENGTH_AES_GCM (BYTE_LENGTH(128))
#define TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 (12)
#define TRUNCATED_DIGEST_BYTE_LENGTH_SHA224 (16)

306
app/test/test_cryptodev_aes_test_vectors.h
View File

@ -634,12 +634,204 @@ static const struct blockcipher_test_data aes_test_data_9 = {
}
};
static const uint8_t ciphertext512_aes192cbc[] = {
0x45, 0xEE, 0x9A, 0xEA, 0x3C, 0x03, 0xFC, 0x4C,
0x84, 0x36, 0xB0, 0xDA, 0xB0, 0xDC, 0xF3, 0x5B,
0x75, 0xA7, 0xBE, 0x0E, 0xC0, 0x8D, 0x6C, 0xF8,
0xC1, 0x0F, 0xD0, 0x35, 0x1D, 0x82, 0xAE, 0x7C,
0x57, 0xC5, 0x7A, 0x55, 0x87, 0x1B, 0xD4, 0x03,
0x0A, 0x64, 0xC9, 0xE0, 0xF4, 0xC7, 0x6F, 0x57,
0x52, 0xC6, 0x73, 0xBA, 0x84, 0x0B, 0x5B, 0x89,
0x21, 0xD2, 0x9B, 0x88, 0x68, 0xF5, 0xA9, 0x7F,
0x3F, 0x49, 0xEB, 0xF4, 0xD4, 0x52, 0xD2, 0x64,
0x80, 0xB2, 0x53, 0xDA, 0x19, 0xF6, 0x10, 0x24,
0x23, 0x26, 0x7A, 0x7C, 0x07, 0x57, 0x4B, 0x0E,
0x58, 0x49, 0x61, 0xD1, 0xDC, 0x9A, 0x32, 0x6B,
0x0F, 0x43, 0x9E, 0x4D, 0xB4, 0x07, 0x4E, 0xB3,
0x51, 0x74, 0xDE, 0x29, 0xBC, 0x98, 0xF9, 0xDF,
0x78, 0x9A, 0x18, 0x9C, 0xD6, 0x7A, 0x55, 0x7C,
0xE6, 0x1D, 0x5C, 0x1A, 0x99, 0xD2, 0xC3, 0x7B,
0x9F, 0x96, 0x74, 0x2D, 0xE0, 0xEF, 0xD1, 0xE3,
0x08, 0x9F, 0xAF, 0xE6, 0xED, 0xCA, 0xE1, 0xEA,
0x23, 0x6F, 0x7C, 0x81, 0xA8, 0xC0, 0x5B, 0x8B,
0x53, 0x90, 0x51, 0x2D, 0x0F, 0xF6, 0x7D, 0xA7,
0x1C, 0xBD, 0x83, 0x84, 0x54, 0xA4, 0x15, 0xFB,
0x3E, 0x25, 0xA7, 0x3A, 0x0A, 0x73, 0xD9, 0x88,
0x6F, 0x80, 0x78, 0x95, 0x7F, 0x60, 0xAA, 0x86,
0x8A, 0xFC, 0xDF, 0xC1, 0xCB, 0xDE, 0xBB, 0x25,
0x52, 0x20, 0xC6, 0x79, 0xD4, 0x0F, 0x25, 0xE7,
0xDB, 0xB2, 0x17, 0xA4, 0x6F, 0x3C, 0x6F, 0x91,
0xF6, 0x44, 0x1E, 0xB6, 0x85, 0xBC, 0x7A, 0x14,
0x10, 0x72, 0xBD, 0x16, 0x63, 0x39, 0x9E, 0x7B,
0x84, 0x5B, 0x17, 0x61, 0xB1, 0x5D, 0x82, 0x0B,
0x6D, 0x37, 0xD7, 0x79, 0xB8, 0x24, 0x91, 0x30,
0x82, 0x91, 0x02, 0xB1, 0x18, 0x4B, 0xE0, 0xF4,
0x13, 0x1B, 0xB2, 0x4C, 0xDA, 0xB8, 0x99, 0x96,
0x83, 0x2F, 0xBE, 0x53, 0x8D, 0xDE, 0xFA, 0xAD,
0xF6, 0x5C, 0xDB, 0xE5, 0x66, 0x26, 0x8F, 0x13,
0x2B, 0x76, 0x47, 0x73, 0xDE, 0x1A, 0x74, 0xA6,
0x30, 0xAF, 0x42, 0xA0, 0xE5, 0xD2, 0x8F, 0xC2,
0xED, 0x3E, 0x9E, 0x29, 0x54, 0x3C, 0xDE, 0x9F,
0x5D, 0x30, 0x2B, 0x63, 0xFB, 0xE3, 0xB1, 0x07,
0xEE, 0x74, 0x4A, 0xAF, 0xB1, 0x20, 0x8D, 0xEC,
0xE6, 0x78, 0x16, 0x8D, 0xA4, 0x6E, 0x34, 0x7D,
0x47, 0xFB, 0x0B, 0xC1, 0x32, 0xD7, 0x0D, 0x6C,
0x6F, 0x93, 0x9C, 0x5E, 0xEF, 0x1F, 0x9C, 0x45,
0x80, 0x6B, 0x74, 0xA6, 0x81, 0xF2, 0xF6, 0xFA,
0xAA, 0x9D, 0x4F, 0xCA, 0xB5, 0x90, 0x59, 0xB0,
0x3B, 0xF2, 0xF0, 0x75, 0xFD, 0x8A, 0xD8, 0x97,
0x65, 0x88, 0x56, 0x4C, 0x44, 0xDF, 0x73, 0xF7,
0x56, 0x9C, 0x48, 0x7E, 0xB0, 0x1F, 0x1D, 0x7D,
0x6A, 0x11, 0xF5, 0xC2, 0xF4, 0x17, 0xEF, 0x58,
0xD8, 0x2A, 0xAF, 0x56, 0x2F, 0xCF, 0xEC, 0xA4,
0x58, 0x8B, 0x60, 0xCE, 0xD4, 0x0F, 0x9C, 0x21,
0xEC, 0x3E, 0x74, 0x7B, 0x81, 0x3D, 0x69, 0xC6,
0x5E, 0x12, 0x83, 0xE9, 0xEF, 0x81, 0x58, 0x36,
0x6A, 0x60, 0x0F, 0x54, 0x28, 0x11, 0xF9, 0x64,
0x36, 0xAD, 0x79, 0xF5, 0x1C, 0x74, 0xD0, 0xC3,
0x7B, 0x61, 0xE1, 0x92, 0xB0, 0x13, 0x91, 0x87,
0x32, 0x1F, 0xF2, 0x5A, 0xDA, 0x25, 0x69, 0xEB,
0xD7, 0x32, 0x7F, 0xF5, 0x23, 0x21, 0x54, 0x47,
0x7B, 0x1B, 0x33, 0xB0, 0x3D, 0xF6, 0xE2, 0x7E,
0x3E, 0xA2, 0x9E, 0xCA, 0x48, 0x0B, 0x4A, 0x29,
0x81, 0xD4, 0x4E, 0xD5, 0x69, 0xFB, 0xCD, 0x37,
0x8A, 0xC1, 0x5B, 0x50, 0xFF, 0xB5, 0x7D, 0x43,
0x0F, 0xAE, 0xA6, 0xC2, 0xE5, 0x8F, 0x45, 0xB2,
0x85, 0x99, 0x02, 0xA2, 0x9B, 0xBE, 0x90, 0x43,
0x4F, 0x2F, 0x50, 0xE2, 0x77, 0x62, 0xD9, 0xCC
};
/** AES-192-CBC test vector */
static const struct blockcipher_test_data aes_test_data_10 = {
.crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
.cipher_key = {
.data = {
0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0
},
.len = 24
},
.iv = {
.data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
},
.len = 16
},
.plaintext = {
.data = plaintext_aes_common,
.len = 512
},
.ciphertext = {
.data = ciphertext512_aes192cbc,
.len = 512
}
};
static const uint8_t ciphertext512_aes256cbc[] = {
0xF3, 0xDD, 0xF0, 0x0B, 0xFF, 0xA2, 0x6A, 0x04,
0xBE, 0xDA, 0x52, 0xA6, 0xFE, 0x6B, 0xA6, 0xA7,
0x48, 0x1D, 0x7D, 0x98, 0x65, 0xDB, 0xEF, 0x06,
0x26, 0xB5, 0x8E, 0xEB, 0x05, 0x0E, 0x77, 0x98,
0x17, 0x8E, 0xD0, 0xD4, 0x7B, 0x92, 0x8F, 0x5C,
0xD0, 0x74, 0x5C, 0xA8, 0x4B, 0x54, 0xB6, 0x2F,
0x83, 0x72, 0x2C, 0xFF, 0x72, 0xE9, 0xE4, 0x15,
0x4C, 0x32, 0xAF, 0xC8, 0xC9, 0x89, 0x3C, 0x6E,
0x31, 0xD5, 0xC0, 0x16, 0xC0, 0x31, 0x7D, 0x11,
0xAB, 0xCB, 0xDE, 0xD2, 0xD6, 0xAA, 0x76, 0x5E,
0xBA, 0xF6, 0xE2, 0x92, 0xCB, 0x86, 0x07, 0xFA,
0xD4, 0x9E, 0x83, 0xED, 0xFD, 0xB8, 0x70, 0x54,
0x6B, 0xBE, 0xEC, 0x72, 0xDD, 0x28, 0x5E, 0x95,
0x78, 0xA5, 0x28, 0x43, 0x3D, 0x6D, 0xB1, 0xD9,
0x69, 0x1F, 0xC9, 0x66, 0x0E, 0x32, 0x44, 0x08,
0xD2, 0xAE, 0x2C, 0x43, 0xF2, 0xD0, 0x7D, 0x26,
0x70, 0xE5, 0xA1, 0xCA, 0x37, 0xE9, 0x7D, 0xC7,
0xA3, 0xFA, 0x81, 0x91, 0x64, 0xAA, 0x64, 0x91,
0x9A, 0x95, 0x2D, 0xC9, 0xF9, 0xCE, 0xFE, 0x9F,
0xC4, 0xD8, 0x81, 0xBE, 0x57, 0x84, 0xC5, 0x02,
0xDB, 0x30, 0xC1, 0xD9, 0x0E, 0xA0, 0xA6, 0x00,
0xD6, 0xF3, 0x52, 0x7E, 0x0D, 0x23, 0x6B, 0x2B,
0x34, 0x99, 0x1F, 0x70, 0x27, 0x6D, 0x58, 0x84,
0x93, 0x77, 0xB8, 0x3E, 0xF1, 0x71, 0x58, 0x42,
0x8B, 0x2B, 0xC8, 0x6D, 0x05, 0x84, 0xFF, 0x4E,
0x85, 0xEF, 0x4A, 0x9D, 0x91, 0x6A, 0xD5, 0xE1,
0xAF, 0x01, 0xEB, 0x83, 0x8F, 0x23, 0x7C, 0x7F,
0x12, 0x91, 0x05, 0xF0, 0x4E, 0xD9, 0x17, 0x62,
0x75, 0xBB, 0xAC, 0x97, 0xEE, 0x3B, 0x4E, 0xC7,
0xE5, 0x92, 0xF8, 0x9D, 0x4C, 0xF9, 0xEE, 0x55,
0x18, 0xBB, 0xCC, 0xB4, 0xF2, 0x59, 0xB9, 0xFC,
0x7A, 0x0F, 0x98, 0xD4, 0x8B, 0xFE, 0xF7, 0x83,
0x46, 0xE2, 0x83, 0x33, 0x3E, 0x95, 0x8D, 0x17,
0x1E, 0x85, 0xF8, 0x8C, 0x51, 0xB0, 0x6C, 0xB5,
0x5E, 0x95, 0xBA, 0x4B, 0x69, 0x1B, 0x48, 0x69,
0x0B, 0x8F, 0xA5, 0x18, 0x13, 0xB9, 0x77, 0xD1,
0x80, 0x32, 0x32, 0x6D, 0x53, 0xA1, 0x95, 0x40,
0x96, 0x8A, 0xCC, 0xA3, 0x69, 0xF8, 0x9F, 0xB5,
0x8E, 0xD2, 0x68, 0x07, 0x4F, 0xA7, 0xEC, 0xF8,
0x20, 0x21, 0x58, 0xF8, 0xD8, 0x9E, 0x5F, 0x40,
0xBA, 0xB9, 0x76, 0x57, 0x3B, 0x17, 0xAD, 0xEE,
0xCB, 0xDF, 0x07, 0xC1, 0xDF, 0x66, 0xA8, 0x0D,
0xC2, 0xCE, 0x8F, 0x79, 0xC3, 0x32, 0xE0, 0x8C,
0xFE, 0x5A, 0xF3, 0x55, 0x27, 0x73, 0x6F, 0xA1,
0x54, 0xC6, 0xFC, 0x28, 0x9D, 0xBE, 0x97, 0xB9,
0x54, 0x97, 0x72, 0x3A, 0x61, 0xAF, 0x6F, 0xDE,
0xF8, 0x0E, 0xBB, 0x6B, 0x96, 0x84, 0xDD, 0x9B,
0x62, 0xBA, 0x47, 0xB5, 0xC9, 0x3B, 0x4E, 0x8C,
0x78, 0x2A, 0xCC, 0x0A, 0x69, 0x54, 0x25, 0x5E,
0x8B, 0xAC, 0x56, 0xD9, 0xFE, 0x48, 0xBA, 0xCE,
0xA9, 0xCE, 0xA6, 0x1D, 0xBF, 0x3E, 0x3C, 0x66,
0x40, 0x71, 0x79, 0xAD, 0x5B, 0x26, 0xAD, 0xBE,
0x58, 0x13, 0x64, 0x60, 0x7C, 0x05, 0xFC, 0xE3,
0x51, 0x7A, 0xF2, 0xCC, 0x54, 0x16, 0x2C, 0xA4,
0xCE, 0x5F, 0x59, 0x12, 0x77, 0xEB, 0xD9, 0x23,
0xE3, 0x86, 0xFB, 0xD7, 0x48, 0x76, 0x9D, 0xE3,
0x89, 0x87, 0x39, 0xFA, 0x7B, 0x21, 0x0B, 0x76,
0xB2, 0xED, 0x1C, 0x27, 0x4B, 0xD5, 0x27, 0x05,
0x8C, 0x7D, 0x58, 0x6C, 0xCA, 0xA5, 0x54, 0x9A,
0x0F, 0xCB, 0xE9, 0x88, 0x31, 0xAD, 0x49, 0xEE,
0x38, 0xFB, 0xC9, 0xFB, 0xB4, 0x7A, 0x00, 0x58,
0x20, 0x32, 0xD3, 0x53, 0x5A, 0xDD, 0x74, 0x95,
0x60, 0x59, 0x09, 0xAE, 0x7E, 0xEC, 0x74, 0xA3,
0xB7, 0x1C, 0x6D, 0xF2, 0xAE, 0x79, 0xA4, 0x7C
};
/** AES-256-CBC test vector */
static const struct blockcipher_test_data aes_test_data_11 = {
.crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
.cipher_key = {
.data = {
0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0,
0x37, 0x07, 0xB8, 0x23, 0xA2, 0xA3, 0xB5, 0x8D
},
.len = 32
},
.iv = {
.data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
},
.len = 16
},
.plaintext = {
.data = plaintext_aes_common,
.len = 512
},
.ciphertext = {
.data = ciphertext512_aes256cbc,
.len = 512
}
};
static const struct blockcipher_test_case aes_chain_test_cases[] = {
{
.test_descr = "AES-128-CTR HMAC-SHA1 Encryption Digest",
.test_data = &aes_test_data_1,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
@ -648,6 +840,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_1,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
@ -669,6 +862,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_3,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
@ -677,6 +871,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_3,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
@ -684,6 +879,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_4,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
@ -692,6 +888,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_4,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
@ -699,6 +896,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_5,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
@ -707,6 +905,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_5,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
@ -714,6 +913,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_6,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
@ -722,7 +922,8 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_6,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.feature_mask = BLOCKCIPHER_TEST_FEATURE_SESSIONLESS,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "AES-128-CBC HMAC-SHA512 Decryption Digest "
@ -730,6 +931,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_6,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
@ -752,7 +954,8 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_4,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_QAT
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_QAT |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "AES-128-CBC HMAC-SHA1 Decryption Digest "
@ -760,13 +963,15 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_4,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_QAT
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_QAT |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "AES-128-CBC HMAC-SHA224 Encryption Digest",
.test_data = &aes_test_data_8,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
@ -775,6 +980,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_8,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
@ -782,6 +988,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_9,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
@ -790,8 +997,101 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = {
.test_data = &aes_test_data_9,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB |
BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "AES-128-CBC HMAC-SHA1 Encryption Digest "
"Sessionless",
.test_data = &aes_test_data_4,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.feature_mask = BLOCKCIPHER_TEST_FEATURE_SESSIONLESS,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr =
"AES-128-CBC HMAC-SHA1 Decryption Digest "
"Verify Sessionless",
.test_data = &aes_test_data_4,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.feature_mask = BLOCKCIPHER_TEST_FEATURE_SESSIONLESS,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
};
static const struct blockcipher_test_case aes_cipheronly_test_cases[] = {
{
.test_descr = "AES-128-CBC Encryption",
.test_data = &aes_test_data_4,
.op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "AES-128-CBC Decryption",
.test_data = &aes_test_data_4,
.op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "AES-192-CBC Encryption",
.test_data = &aes_test_data_10,
.op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "AES-192-CBC Decryption",
.test_data = &aes_test_data_10,
.op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "AES-256-CBC Encryption",
.test_data = &aes_test_data_11,
.op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "AES-256-CBC Decryption",
.test_data = &aes_test_data_11,
.op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "AES-128-CTR Encryption",
.test_data = &aes_test_data_1,
.op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "AES-128-CTR Decryption",
.test_data = &aes_test_data_1,
.op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "AES-192-CTR Encryption",
.test_data = &aes_test_data_2,
.op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "AES-192-CTR Decryption",
.test_data = &aes_test_data_2,
.op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "AES-256-CTR Encryption",
.test_data = &aes_test_data_3,
.op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "AES-256-CTR Decryption",
.test_data = &aes_test_data_3,
.op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
};
#endif /* TEST_CRYPTODEV_AES_TEST_VECTORS_H_ */

22
app/test/test_cryptodev_blockcipher.c
View File

@ -43,6 +43,8 @@
#include "test.h"
#include "test_cryptodev_blockcipher.h"
#include "test_cryptodev_aes_test_vectors.h"
#include "test_cryptodev_des_test_vectors.h"
#include "test_cryptodev_hash_test_vectors.h"
static int
test_blockcipher_one_case(const struct blockcipher_test_case *t,
@ -79,6 +81,7 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t,
switch (cryptodev_type) {
case RTE_CRYPTODEV_QAT_SYM_PMD:
case RTE_CRYPTODEV_LIBCRYPTO_PMD:
digest_len = tdata->digest.len;
break;
case RTE_CRYPTODEV_AESNI_MB_PMD:
@ -472,9 +475,25 @@ test_blockcipher_all_tests(struct rte_mempool *mbuf_pool,
tcs = aes_chain_test_cases;
break;
case BLKCIPHER_AES_CIPHERONLY_TYPE:
n_test_cases = sizeof(aes_cipheronly_test_cases) /
sizeof(aes_cipheronly_test_cases[0]);
tcs = aes_cipheronly_test_cases;
break;
case BLKCIPHER_3DES_CHAIN_TYPE:
n_test_cases = sizeof(triple_des_chain_test_cases) /
sizeof(triple_des_chain_test_cases[0]);
tcs = triple_des_chain_test_cases;
break;
case BLKCIPHER_3DES_CIPHERONLY_TYPE:
n_test_cases = sizeof(triple_des_cipheronly_test_cases) /
sizeof(triple_des_cipheronly_test_cases[0]);
tcs = triple_des_cipheronly_test_cases;
break;
case BLKCIPHER_AUTHONLY_TYPE:
n_test_cases = sizeof(hash_test_cases) /
sizeof(hash_test_cases[0]);
tcs = hash_test_cases;
break;
default:
break;
}
@ -486,6 +505,9 @@ test_blockcipher_all_tests(struct rte_mempool *mbuf_pool,
case RTE_CRYPTODEV_QAT_SYM_PMD:
target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_QAT;
break;
case RTE_CRYPTODEV_LIBCRYPTO_PMD:
target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO;
break;
default:
TEST_ASSERT(0, "Unrecognized cryptodev type");
break;

1
app/test/test_cryptodev_blockcipher.h
View File

@ -48,6 +48,7 @@
#define BLOCKCIPHER_TEST_TARGET_PMD_MB 0x0001 /* Multi-buffer flag */
#define BLOCKCIPHER_TEST_TARGET_PMD_QAT 0x0002 /* QAT flag */
#define BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO 0x0004 /* SW LIBCRYPTO flag */
#define BLOCKCIPHER_TEST_OP_CIPHER (BLOCKCIPHER_TEST_OP_ENCRYPT | \
BLOCKCIPHER_TEST_OP_DECRYPT)

955
app/test/test_cryptodev_des_test_vectors.h Normal file
View File

@ -0,0 +1,955 @@
/*
* BSD LICENSE
*
* Copyright(c) 2016 Intel Corporation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef TEST_CRYPTODEV_DES_TEST_VECTORS_H_
#define TEST_CRYPTODEV_DES_TEST_VECTORS_H_
static const uint8_t plaintext_des[] = {
"What a lousy earth! He wondered how many people "
"were destitute that same night even in his own "
"prosperous country, how many homes were "
"shanties, how many husbands were drunk and "
"wives socked, and how many children were "
"bullied, abused, or abandoned. How many "
"families hungered for food they could not "
"afford to buy? How many hearts were broken? How "
"many suicides would take place that same night, "
"how many people would go insane? How many "
"cockroaches and landlords would triumph? How "
"many winners were losers, successes failures, "
"and rich men poor men? How many wise guys were "
"stupid? How many happy endings were unhappy "
"endings? How many honest men were liars, brave "
"men cowards, loyal men traitors, how many "
"sainted men were corrupt, how many people in "
"positions of trust had sold their souls to "
"bodyguards, how many had never had souls? How "
"many straight-and-narrow paths were crooked "
"paths? How many best families were worst "
"families and how many good people were bad "
"people? When you added them all up and then "
"subtracted, you might be left with only the "
"children, and perhaps with Albert Einstein and "
"an old violinist or sculptor somewhere."
};
static const uint8_t ciphertext512_des128ctr[] = {
0x13, 0x39, 0x3B, 0xBC, 0x1D, 0xE3, 0x23, 0x09,
0x9B, 0x08, 0xD1, 0x09, 0x52, 0x93, 0x78, 0x29,
0x11, 0x21, 0xBA, 0x01, 0x15, 0xCD, 0xEC, 0xAA,
0x79, 0x77, 0x58, 0xAE, 0xAE, 0xBC, 0x97, 0x33,
0x94, 0xA9, 0x2D, 0xC0, 0x0A, 0xA9, 0xA4, 0x4B,
0x19, 0x07, 0x88, 0x06, 0x7E, 0x81, 0x0F, 0xB5,
0x60, 0xCF, 0xA7, 0xC3, 0x2A, 0x43, 0xFF, 0x16,
0x3A, 0x5F, 0x11, 0x2D, 0x11, 0x38, 0x37, 0x94,
0x2A, 0xC8, 0x3D, 0x20, 0xBB, 0x93, 0x95, 0x54,
0x12, 0xFF, 0x0C, 0x47, 0x89, 0x7D, 0x73, 0xD1,
0x2E, 0x3A, 0x80, 0x52, 0xA8, 0x92, 0x93, 0x99,
0x16, 0xB8, 0x12, 0x1B, 0x8B, 0xA8, 0xC1, 0x81,
0x95, 0x18, 0x82, 0xD6, 0x5A, 0xA7, 0xFE, 0xCF,
0xC4, 0xAC, 0x85, 0x91, 0x0C, 0x2F, 0x1D, 0x10,
0x9A, 0x65, 0x07, 0xB0, 0x2E, 0x5A, 0x2D, 0x48,
0x26, 0xF8, 0x17, 0x7A, 0x53, 0xD6, 0xB8, 0xDF,
0xB1, 0x10, 0x48, 0x7E, 0x8F, 0xBE, 0x2E, 0xA1,
0x0D, 0x9E, 0xA9, 0xF1, 0x3B, 0x3B, 0x33, 0xCD,
0xDC, 0x52, 0x7E, 0xC0, 0x0E, 0xA0, 0xD8, 0xA7,
0xC6, 0x34, 0x5A, 0xAA, 0x29, 0x8B, 0xA9, 0xAC,
0x1F, 0x78, 0xAD, 0xEE, 0x34, 0x59, 0x30, 0xFB,
0x2A, 0x20, 0x3D, 0x4D, 0x30, 0xA7, 0x7D, 0xD8,
0xA0, 0xC6, 0xA2, 0xD3, 0x9A, 0xFB, 0x50, 0x97,
0x4D, 0x25, 0xA2, 0x37, 0x51, 0x54, 0xB7, 0xEB,
0xED, 0x77, 0xDB, 0x94, 0x35, 0x8B, 0x70, 0x95,
0x4A, 0x00, 0xA7, 0xF1, 0x8A, 0x66, 0x0E, 0xC6,
0x05, 0x7B, 0x69, 0x05, 0x42, 0x03, 0x96, 0x2C,
0x55, 0x00, 0x1B, 0xC0, 0x19, 0x4D, 0x0D, 0x2E,
0xF5, 0x81, 0x11, 0x64, 0xCA, 0xBB, 0xF2, 0x0F,
0x9C, 0x60, 0xE2, 0xCC, 0x02, 0x6E, 0x83, 0xD5,
0x24, 0xF4, 0x12, 0x0E, 0x6A, 0xEA, 0x4F, 0x6C,
0x79, 0x69, 0x65, 0x67, 0xDB, 0xF7, 0xEA, 0x98,
0x5D, 0x56, 0x98, 0xB7, 0x88, 0xE7, 0x23, 0xC9,
0x17, 0x32, 0x92, 0x33, 0x5A, 0x0C, 0x15, 0x20,
0x3B, 0x1C, 0xF9, 0x0F, 0x4D, 0xD1, 0xE8, 0xE6,
0x9E, 0x5E, 0x24, 0x1B, 0xA4, 0xB8, 0xB9, 0xE9,
0x2F, 0xFC, 0x89, 0xB4, 0xB9, 0xF4, 0xA6, 0xAD,
0x55, 0xF4, 0xDF, 0x58, 0x63, 0x25, 0xE3, 0x41,
0x70, 0xDF, 0x10, 0xE7, 0x13, 0x87, 0x8D, 0xB3,
0x62, 0x4F, 0xF5, 0x86, 0x85, 0x8F, 0x59, 0xF0,
0x21, 0x0E, 0x8F, 0x11, 0xAD, 0xBF, 0xDD, 0x61,
0x68, 0x3F, 0x54, 0x57, 0x49, 0x38, 0xC8, 0x24,
0x8E, 0x0A, 0xAC, 0xCA, 0x2C, 0x36, 0x3E, 0x5F,
0x0A, 0xCE, 0xFD, 0x1A, 0x60, 0x63, 0x5A, 0xE6,
0x06, 0x64, 0xB5, 0x94, 0x3C, 0xC9, 0xAF, 0x7C,
0xCD, 0x49, 0x10, 0xCF, 0xAF, 0x0E, 0x2E, 0x79,
0x27, 0xB2, 0x67, 0x02, 0xED, 0xEE, 0x80, 0x77,
0x7C, 0x6D, 0x4B, 0xDB, 0xCF, 0x8D, 0x68, 0x00,
0x2E, 0xD9, 0xF0, 0x8E, 0x08, 0xBF, 0xA6, 0x9B,
0xFE, 0xA4, 0xFB, 0x19, 0x46, 0xAF, 0x1B, 0xA9,
0xF8, 0x22, 0x81, 0x21, 0x97, 0xFC, 0xC0, 0x8A,
0x26, 0x58, 0x13, 0x29, 0xB6, 0x69, 0x94, 0x4B,
0xAB, 0xB3, 0x88, 0x0D, 0xA9, 0x48, 0x0E, 0xE8,
0x70, 0xFC, 0xA1, 0x21, 0xC4, 0x2C, 0xE5, 0x99,
0xB4, 0xF1, 0x6F, 0xB2, 0x4B, 0x4B, 0xCD, 0x48,
0x15, 0x47, 0x2D, 0x72, 0x39, 0x99, 0x9D, 0x24,
0x0C, 0x8B, 0xDC, 0xA1, 0xEE, 0xF6, 0xF4, 0x73,
0xC3, 0xB8, 0x0C, 0x23, 0x0D, 0xA7, 0xC4, 0x7D,
0x27, 0xE2, 0x14, 0x11, 0x53, 0x19, 0xE7, 0xCA,
0x94, 0x4E, 0x0D, 0x2C, 0xF7, 0x36, 0x47, 0xDB,
0x77, 0x3C, 0x22, 0xAC, 0xBE, 0xE1, 0x06, 0x55,
0xE5, 0xDD, 0x8B, 0x65, 0xE8, 0xE9, 0x91, 0x52,
0x59, 0x97, 0xFC, 0x8C, 0xEE, 0x96, 0x22, 0x60,
0xEE, 0xBF, 0x82, 0xF0, 0xCA, 0x14, 0xF9, 0xD3
};
static const struct blockcipher_test_data
triple_des128ctr_test_vector = {
.crypto_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
.cipher_key = {
.data = {
0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
},
.len = 16
},
.iv = {
.data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
},
.len = 8
},
.plaintext = {
.data = plaintext_des,
.len = 512
},
.ciphertext = {
.data = ciphertext512_des128ctr,
.len = 512
}
};
static const struct blockcipher_test_data
triple_des128ctr_sha1_test_vector = {
.crypto_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
.cipher_key = {
.data = {
0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
},
.len = 16
},
.iv = {
.data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
},
.len = 8
},
.plaintext = {
.data = plaintext_des,
.len = 512
},
.ciphertext = {
.data = ciphertext512_des128ctr,
.len = 512
},
.auth_algo = RTE_CRYPTO_AUTH_SHA1,
.digest = {
.data = {
0xC3, 0x40, 0xD5, 0xD9, 0x8F, 0x8A, 0xC0, 0xF0,
0x46, 0x28, 0x02, 0x01, 0xB5, 0xC1, 0x87, 0x4D,
0xAC, 0xFE, 0x48, 0x76
},
.len = 20
}
};
static const struct blockcipher_test_data
triple_des128ctr_hmac_sha1_test_vector = {
.crypto_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
.cipher_key = {
.data = {
0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
},
.len = 16
},
.iv = {
.data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
},
.len = 8
},
.plaintext = {
.data = plaintext_des,
.len = 512
},
.ciphertext = {
.data = ciphertext512_des128ctr,
.len = 512
},
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
.auth_key = {
.data = {
0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
0xDE, 0xF4, 0xDE, 0xAD
},
.len = 20
},
.digest = {
.data = {
0xF1, 0xC1, 0xDB, 0x4D, 0xFA, 0x7F, 0x2F, 0xE5,
0xF8, 0x49, 0xEA, 0x1D, 0x7F, 0xCB, 0x42, 0x59,
0xC4, 0x1E, 0xB1, 0x18
},
.len = 20
}
};
static const uint8_t ciphertext512_des192ctr[] = {
0xFF, 0x32, 0x52, 0x97, 0x10, 0xBF, 0x0B, 0x10,
0x68, 0x0F, 0x4F, 0x56, 0x8B, 0x2C, 0x7B, 0x8E,
0x39, 0x1E, 0x1A, 0x2F, 0x83, 0xDE, 0x5E, 0x35,
0xC8, 0x4B, 0xDF, 0xD5, 0xBC, 0x84, 0x50, 0x1A,
0x02, 0xDF, 0xB3, 0x11, 0xE4, 0xDA, 0xB8, 0x0E,
0x47, 0xC6, 0x0C, 0x51, 0x09, 0x62, 0x9C, 0x5D,
0x71, 0x40, 0x49, 0xD8, 0x55, 0xBD, 0x7D, 0x90,
0x71, 0xC5, 0xF7, 0x07, 0x6F, 0x08, 0x71, 0x2A,
0xB1, 0x77, 0x9B, 0x0F, 0xA1, 0xB0, 0xD6, 0x10,
0xB2, 0xE5, 0x31, 0xEC, 0x21, 0x13, 0x89, 0x2A,
0x09, 0x7E, 0x30, 0xDB, 0xA0, 0xF0, 0xDC, 0xE4,
0x74, 0x64, 0x39, 0xA3, 0xB0, 0xB1, 0x80, 0x66,
0x52, 0xD4, 0x4E, 0xC9, 0x5A, 0x52, 0x6A, 0xC7,
0xB5, 0x2B, 0x61, 0xD5, 0x17, 0xD5, 0xF3, 0xCC,
0x41, 0x61, 0xD2, 0xA6, 0xF4, 0x51, 0x24, 0x3A,
0x63, 0x5D, 0x23, 0xB1, 0xF0, 0x22, 0xE7, 0x45,
0xFA, 0x5F, 0x7E, 0x99, 0x00, 0x11, 0x28, 0x35,
0xA3, 0xF4, 0x61, 0x94, 0x0E, 0x98, 0xCE, 0x35,
0xDD, 0x91, 0x1B, 0x0B, 0x4D, 0xEE, 0xFF, 0xFF,
0x0B, 0xD4, 0xDC, 0x56, 0xFC, 0x71, 0xE9, 0xEC,
0xE8, 0x36, 0x51, 0xF8, 0x8B, 0x6A, 0xE1, 0x8C,
0x2B, 0x25, 0x91, 0x91, 0x9B, 0x92, 0x76, 0xB5,
0x3D, 0x26, 0xA8, 0x53, 0xEA, 0x30, 0x5B, 0x4D,
0xDA, 0x16, 0xDA, 0x7D, 0x04, 0x88, 0xF5, 0x22,
0xA8, 0x0C, 0xB9, 0x41, 0xC7, 0x91, 0x64, 0x86,
0x99, 0x7D, 0x18, 0xB9, 0x67, 0xA2, 0x6E, 0x05,
0x1A, 0x82, 0x8F, 0xA2, 0xEB, 0x4D, 0x0B, 0x8C,
0x88, 0x2D, 0xBA, 0x77, 0x87, 0x32, 0x50, 0x3C,
0x4C, 0xD8, 0xD3, 0x50, 0x39, 0xFA, 0xDF, 0x48,
0x3E, 0x30, 0xF5, 0x76, 0x06, 0xB0, 0x1A, 0x05,
0x60, 0x2C, 0xD3, 0xA0, 0x63, 0x1A, 0x19, 0x2D,
0x6B, 0x76, 0xF2, 0x31, 0x4C, 0xA7, 0xE6, 0x5C,
0x1B, 0x23, 0x20, 0x41, 0x32, 0xE5, 0x83, 0x47,
0x04, 0xB6, 0x3E, 0xE0, 0xFD, 0x49, 0x1E, 0x1B,
0x75, 0x10, 0x11, 0x46, 0xE9, 0xF9, 0x96, 0x9A,
0xD7, 0x59, 0xFE, 0x38, 0x31, 0xFE, 0x79, 0xC4,
0xC8, 0x46, 0x88, 0xDE, 0x2E, 0xAE, 0x20, 0xED,
0x77, 0x50, 0x40, 0x38, 0x26, 0xD3, 0x35, 0xF6,
0x29, 0x55, 0x6A, 0x6B, 0x38, 0x69, 0xFE, 0x90,
0x5B, 0xA7, 0xFA, 0x6B, 0x73, 0x4F, 0xB9, 0x5D,
0xDC, 0x6F, 0x98, 0xC3, 0x6A, 0xC4, 0xB5, 0x09,
0xC5, 0x84, 0xA5, 0x6A, 0x84, 0xA4, 0xB3, 0x8A,
0x5F, 0xCA, 0x92, 0x64, 0x9E, 0xC3, 0x0F, 0x84,
0x8B, 0x2D, 0x48, 0xC6, 0x67, 0xAE, 0x07, 0xE0,
0x28, 0x38, 0x6D, 0xC4, 0x4D, 0x13, 0x87, 0xE0,
0xB2, 0x2F, 0xAA, 0xC0, 0xCF, 0x68, 0xD7, 0x9C,
0xB8, 0x07, 0xE4, 0x51, 0xD7, 0x75, 0x86, 0xFA,
0x0C, 0x50, 0x74, 0x68, 0x00, 0x64, 0x2A, 0x27,
0x59, 0xE9, 0x80, 0xEB, 0xC2, 0xA3, 0xFA, 0x58,
0xCC, 0x03, 0xE7, 0x7B, 0x66, 0x53, 0xFF, 0x90,
0xA0, 0x85, 0xE2, 0xF8, 0x82, 0xFE, 0xC6, 0x2B,
0xFF, 0x5E, 0x70, 0x85, 0x34, 0xB7, 0x22, 0x38,
0xDB, 0xBC, 0x15, 0x30, 0x59, 0xC1, 0x48, 0x42,
0xE5, 0x38, 0x8D, 0x37, 0x59, 0xDB, 0xA3, 0x20,
0x17, 0x36, 0x1D, 0x4B, 0xBF, 0x4E, 0xA4, 0x35,
0xCC, 0xFE, 0xF5, 0x7A, 0x73, 0xB4, 0x6D, 0x20,
0x1D, 0xC0, 0xE5, 0x21, 0x5C, 0xD2, 0x8A, 0x65,
0x08, 0xB6, 0x63, 0xAC, 0x9A, 0x1E, 0x3F, 0x3C,
0xAB, 0xB6, 0x6D, 0x34, 0xB2, 0x3A, 0x08, 0xDA,
0x29, 0x63, 0xD1, 0xA4, 0x83, 0x52, 0xB0, 0x63,
0x1B, 0x89, 0x35, 0x57, 0x59, 0x2C, 0x0F, 0x72,
0x72, 0xFD, 0xA0, 0xAC, 0xDB, 0xB4, 0xA3, 0xA1,
0x18, 0x10, 0x12, 0x97, 0x99, 0x63, 0x38, 0x98,
0x96, 0xB5, 0x16, 0x07, 0x4E, 0xE9, 0x2C, 0x97
};
static const struct blockcipher_test_data
triple_des192ctr_test_vector = {
.crypto_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
.cipher_key = {
.data = {
0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0
},
.len = 24
},
.iv = {
.data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
},
.len = 8
},
.plaintext = {
.data = plaintext_des,
.len = 512
},
.ciphertext = {
.data = ciphertext512_des192ctr,
.len = 512
}
};
static const struct blockcipher_test_data
triple_des192ctr_sha1_test_vector = {
.crypto_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
.cipher_key = {
.data = {
0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0
},
.len = 24
},
.iv = {
.data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
},
.len = 8
},
.plaintext = {
.data = plaintext_des,
.len = 512
},
.ciphertext = {
.data = ciphertext512_des192ctr,
.len = 512
},
.auth_algo = RTE_CRYPTO_AUTH_SHA1,
.digest = {
.data = {
0xEA, 0x62, 0xB9, 0xB2, 0x78, 0x6C, 0x8E, 0xDB,
0xA3, 0xB6, 0xFF, 0x23, 0x3A, 0x47, 0xD8, 0xC8,
0xED, 0x5E, 0x20, 0x1D
},
.len = 20
}
};
static const struct blockcipher_test_data
triple_des192ctr_hmac_sha1_test_vector = {
.crypto_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
.cipher_key = {
.data = {
0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0
},
.len = 24
},
.iv = {
.data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
},
.len = 8
},
.plaintext = {
.data = plaintext_des,
.len = 512
},
.ciphertext = {
.data = ciphertext512_des192ctr,
.len = 512
},
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
.auth_key = {
.data = {
0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
0xDE, 0xF4, 0xDE, 0xAD
},
.len = 20
},
.digest = {
.data = {
0x32, 0xD5, 0x19, 0x8F, 0x79, 0x3A, 0xAA, 0x7B,
0x70, 0x67, 0x4E, 0x63, 0x88, 0xA3, 0x9A, 0x82,
0x07, 0x33, 0x12, 0x94
},
.len = 20
}
};
static const uint8_t ciphertext512_des128cbc[] = {
0x28, 0x2a, 0xff, 0x15, 0x5c, 0xdf, 0xd9, 0x6b,
0x54, 0xbc, 0x7b, 0xfb, 0xc5, 0x64, 0x4d, 0xdd,
0x3e, 0xf2, 0x9e, 0xb7, 0x53, 0x65, 0x37, 0x05,
0xe0, 0xdf, 0xae, 0xf7, 0xc9, 0x27, 0xe4, 0xec,
0x11, 0x27, 0xc2, 0x9e, 0x02, 0x4e, 0x03, 0x3b,
0x33, 0xf2, 0x66, 0x08, 0x24, 0x5f, 0xab, 0xc2,
0x7e, 0x21, 0x19, 0x5d, 0x51, 0xc3, 0xe2, 0x97,
0x6f, 0x2e, 0xb4, 0xaa, 0x34, 0x70, 0x88, 0x78,
0x4e, 0xe7, 0x3d, 0xe1, 0x9f, 0x87, 0x1c, 0x8b,
0xac, 0x8d, 0xa1, 0x1a, 0xcd, 0xb0, 0xf8, 0xb6,
0x24, 0x36, 0xe3, 0x8c, 0x07, 0xe7, 0xe4, 0x92,
0x13, 0x86, 0x6f, 0x13, 0xec, 0x04, 0x5c, 0xe9,
0xb9, 0xca, 0x45, 0x8a, 0x2c, 0x46, 0xda, 0x54,
0x1d, 0xb5, 0x81, 0xb1, 0xcd, 0xf3, 0x7d, 0x11,
0x6b, 0xb3, 0x0a, 0x45, 0xe5, 0x6e, 0x51, 0x3e,
0x2c, 0xac, 0x7c, 0xbc, 0xa7, 0x7e, 0x22, 0x4d,
0xe6, 0x02, 0xe3, 0x3f, 0x77, 0xd7, 0x73, 0x72,
0x0e, 0xfb, 0x42, 0x85, 0x80, 0xdf, 0xa8, 0x91,
0x60, 0x40, 0x48, 0xcd, 0x1b, 0xd9, 0xbf, 0x2f,
0xf2, 0xdf, 0xd0, 0xbd, 0x3f, 0x82, 0xce, 0x15,
0x9d, 0x6e, 0xc6, 0x59, 0x6f, 0x27, 0x0d, 0xf9,
0x26, 0xe2, 0x11, 0x29, 0x50, 0xc3, 0x0a, 0xb7,
0xde, 0x9d, 0xe9, 0x55, 0xa1, 0xe9, 0x01, 0x33,
0x56, 0x51, 0xa7, 0x3a, 0x9e, 0x63, 0xc5, 0x08,
0x01, 0x3b, 0x03, 0x4b, 0xc6, 0xc4, 0xa1, 0xc0,
0xc0, 0xd0, 0x0e, 0x48, 0xe5, 0x4c, 0x55, 0x6b,
0x4a, 0xc1, 0x0a, 0x24, 0x4b, 0xd0, 0x02, 0xf4,
0x31, 0x63, 0x11, 0xbd, 0xa6, 0x1f, 0xf4, 0xae,
0x23, 0x5a, 0x40, 0x7e, 0x0e, 0x4e, 0x63, 0x8b,
0x66, 0x3d, 0x55, 0x46, 0x6e, 0x5c, 0x76, 0xa7,
0x68, 0x31, 0xce, 0x5d, 0xca, 0xe2, 0xb4, 0xb0,
0xc1, 0x1f, 0x66, 0x18, 0x75, 0x64, 0x73, 0xa9,
0x9e, 0xd5, 0x0e, 0x0e, 0xf7, 0x77, 0x61, 0xf8,
0x89, 0xc6, 0xcf, 0x0c, 0x41, 0xd3, 0x8f, 0xfd,
0x22, 0x52, 0x4f, 0x94, 0x5c, 0x19, 0x11, 0x3a,
0xb5, 0x63, 0xe8, 0x81, 0x33, 0x13, 0x54, 0x3c,
0x93, 0x36, 0xb5, 0x5b, 0x51, 0xaf, 0x51, 0xa2,
0x08, 0xae, 0x83, 0x15, 0x77, 0x07, 0x28, 0x0d,
0x98, 0xe1, 0x2f, 0x69, 0x0e, 0xfb, 0x9a, 0x2e,
0x27, 0x27, 0xb0, 0xd5, 0xce, 0xf8, 0x16, 0x55,
0xfd, 0xaa, 0xd7, 0x1a, 0x1b, 0x2e, 0x4c, 0x86,
0x7a, 0x6a, 0x90, 0xf7, 0x0a, 0x07, 0xd3, 0x81,
0x4b, 0x75, 0x6a, 0x79, 0xdb, 0x63, 0x45, 0x0f,
0x31, 0x7e, 0xd0, 0x2a, 0x14, 0xff, 0xee, 0xcc,
0x97, 0x8a, 0x7d, 0x74, 0xbd, 0x9d, 0xaf, 0x00,
0xdb, 0x7e, 0xf3, 0xe6, 0x22, 0x76, 0x77, 0x58,
0xba, 0x1c, 0x06, 0x96, 0xfb, 0x6f, 0x41, 0x71,
0x66, 0x98, 0xae, 0x31, 0x7d, 0x29, 0x18, 0x71,
0x0e, 0xe4, 0x98, 0x7e, 0x59, 0x5a, 0xc9, 0x78,
0x9c, 0xfb, 0x6c, 0x81, 0x44, 0xb4, 0x0f, 0x5e,
0x18, 0x53, 0xb8, 0x6f, 0xbc, 0x3b, 0x15, 0xf0,
0x10, 0xdd, 0x0d, 0x4b, 0x0a, 0x36, 0x0e, 0xb4,
0x76, 0x0f, 0x16, 0xa7, 0x5c, 0x9d, 0xcf, 0xb0,
0x6d, 0x38, 0x02, 0x07, 0x05, 0xe9, 0xe9, 0x46,
0x08, 0xb8, 0x52, 0xd6, 0xd9, 0x4c, 0x81, 0x63,
0x1d, 0xe2, 0x5b, 0xd0, 0xf6, 0x5e, 0x1e, 0x81,
0x48, 0x08, 0x66, 0x3a, 0x85, 0xed, 0x65, 0xfe,
0xe8, 0x05, 0x7a, 0xe1, 0xe6, 0x12, 0xf2, 0x52,
0x83, 0xdd, 0x82, 0xbe, 0xf6, 0x34, 0x8a, 0x6f,
0xc5, 0x83, 0xcd, 0x3f, 0xbe, 0x58, 0x8b, 0x11,
0x78, 0xdc, 0x0c, 0x83, 0x72, 0x5d, 0x05, 0x2a,
0x01, 0x29, 0xee, 0x48, 0x9a, 0x67, 0x00, 0x6e,
0x14, 0x60, 0x2d, 0x00, 0x52, 0x87, 0x98, 0x5e,
0x43, 0xfe, 0xf1, 0x10, 0x14, 0xf1, 0x91, 0xcc
};
static const struct blockcipher_test_data
triple_des128cbc_test_vector = {
.crypto_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
.cipher_key = {
.data = {
0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
},
.len = 16
},
.iv = {
.data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
},
.len = 8
},
.plaintext = {
.data = plaintext_des,
.len = 512
},
.ciphertext = {
.data = ciphertext512_des128cbc,
.len = 512
}
};
static const struct blockcipher_test_data
triple_des128cbc_sha1_test_vector = {
.crypto_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
.cipher_key = {
.data = {
0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
},
.len = 16
},
.iv = {
.data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
},
.len = 8
},
.plaintext = {
.data = plaintext_des,
.len = 512
},
.ciphertext = {
.data = ciphertext512_des128cbc,
.len = 512
},
.auth_algo = RTE_CRYPTO_AUTH_SHA1,
.digest = {
.data = {
0x94, 0x45, 0x7B, 0xDF, 0xFE, 0x80, 0xB9, 0xA6,
0xA0, 0x7A, 0xE8, 0x93, 0x40, 0x7B, 0x85, 0x02,
0x1C, 0xD7, 0xE8, 0x87
},
.len = 20
}
};
static const struct blockcipher_test_data
triple_des128cbc_hmac_sha1_test_vector = {
.crypto_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
.cipher_key = {
.data = {
0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
},
.len = 16
},
.iv = {
.data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
},
.len = 8
},
.plaintext = {
.data = plaintext_des,
.len = 512
},
.ciphertext = {
.data = ciphertext512_des128cbc,
.len = 512
},
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
.auth_key = {
.data = {
0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
0xDE, 0xF4, 0xDE, 0xAD
},
.len = 20
},
.digest = {
.data = {
0x7E, 0xBA, 0xFF, 0x86, 0x8D, 0x65, 0xCD, 0x08,
0x76, 0x34, 0x94, 0xE9, 0x9A, 0xCD, 0xB2, 0xBB,
0xBF, 0x65, 0xF5, 0x42
},
.len = 20
}
};
static const uint8_t ciphertext512_des192cbc[] = {
0xd0, 0xc9, 0xdc, 0x51, 0x29, 0x97, 0x03, 0x64,
0xcd, 0x22, 0xba, 0x3d, 0x2b, 0xbc, 0x21, 0x37,
0x7b, 0x1e, 0x29, 0x23, 0xeb, 0x51, 0x6e, 0xac,
0xbe, 0x5b, 0xd3, 0x67, 0xe0, 0x3f, 0xc3, 0xb5,
0xe3, 0x04, 0x17, 0x42, 0x2b, 0xaa, 0xdd, 0xd6,
0x0e, 0x69, 0xd0, 0x8f, 0x8a, 0xfc, 0xb4, 0x55,
0x67, 0x06, 0x51, 0xbb, 0x00, 0x57, 0xee, 0x95,
0x28, 0x79, 0x3f, 0xd9, 0x97, 0x2b, 0xb0, 0x02,
0x35, 0x08, 0xce, 0x7a, 0xc3, 0x43, 0x2c, 0x87,
0xaa, 0x97, 0x6a, 0xad, 0xf0, 0x26, 0xea, 0x1d,
0xbb, 0x08, 0xe9, 0x52, 0x11, 0xd3, 0xaf, 0x36,
0x17, 0x14, 0x21, 0xb2, 0xbc, 0x42, 0x51, 0x33,
0x27, 0x8c, 0xd8, 0x45, 0xb9, 0x76, 0xa0, 0x11,
0x24, 0x34, 0xde, 0x4d, 0x13, 0x67, 0x1b, 0xc3,
0x31, 0x12, 0x66, 0x56, 0x59, 0xd2, 0xb1, 0x8f,
0xec, 0x1e, 0xc0, 0x10, 0x7a, 0x86, 0xb1, 0x60,
0xc3, 0x01, 0xd6, 0xa8, 0x55, 0xad, 0x58, 0x63,
0xca, 0x68, 0xa9, 0x33, 0xe3, 0x93, 0x90, 0x7d,
0x8f, 0xca, 0xf8, 0x1c, 0xc2, 0x9e, 0xfb, 0xde,
0x9c, 0xc7, 0xf2, 0x6c, 0xff, 0xcc, 0x39, 0x17,
0x49, 0x33, 0x0d, 0x7c, 0xed, 0x07, 0x99, 0x91,
0x91, 0x6c, 0x5f, 0x3f, 0x02, 0x09, 0xdc, 0x70,
0xf9, 0x3b, 0x8d, 0xaa, 0xf4, 0xbc, 0x0e, 0xec,
0xf2, 0x26, 0xfb, 0xb2, 0x1c, 0x31, 0xae, 0xc6,
0x72, 0xe8, 0x0b, 0x75, 0x05, 0x57, 0x58, 0x98,
0x92, 0x37, 0x27, 0x8e, 0x3b, 0x0c, 0x25, 0xfb,
0xcf, 0x82, 0x02, 0xd5, 0x0b, 0x1f, 0x89, 0x49,
0xcd, 0x0f, 0xa1, 0xa7, 0x08, 0x63, 0x56, 0xa7,
0x1f, 0x80, 0x3a, 0xef, 0x24, 0x89, 0x57, 0x1a,
0x02, 0xdc, 0x2e, 0x51, 0xbd, 0x4a, 0x10, 0x23,
0xfc, 0x02, 0x1a, 0x3f, 0x34, 0xbf, 0x1c, 0x98,
0x1a, 0x40, 0x0a, 0x96, 0x8e, 0x41, 0xd5, 0x09,
0x55, 0x37, 0xe9, 0x25, 0x11, 0x83, 0xf8, 0xf3,
0xd4, 0xb0, 0xdb, 0x16, 0xd7, 0x51, 0x7e, 0x94,
0xf7, 0xb4, 0x26, 0xe0, 0xf4, 0x80, 0x01, 0x65,
0x51, 0xeb, 0xbc, 0xb0, 0x65, 0x8f, 0xdd, 0xb5,
0xf7, 0x00, 0xec, 0x40, 0xab, 0x7d, 0x96, 0xcc,
0x8d, 0xec, 0x89, 0x80, 0x31, 0x39, 0xa2, 0x5c,
0xb0, 0x55, 0x4c, 0xee, 0xdd, 0x15, 0x2b, 0xa9,
0x86, 0x4e, 0x23, 0x14, 0x36, 0xc5, 0x57, 0xf5,
0xe3, 0xe8, 0x89, 0xc9, 0xb7, 0xf8, 0xeb, 0x08,
0xe5, 0x93, 0x12, 0x5c, 0x0f, 0x79, 0xa1, 0x86,
0xe4, 0xc2, 0xeb, 0xa6, 0xa0, 0x50, 0x6a, 0xec,
0xd3, 0xce, 0x50, 0x78, 0x4e, 0x4f, 0x93, 0xd8,
0xdc, 0xb4, 0xec, 0x02, 0xe9, 0xbd, 0x17, 0x99,
0x1e, 0x16, 0x4e, 0xd7, 0xb0, 0x07, 0x02, 0x55,
0x63, 0x24, 0x4f, 0x7b, 0x8f, 0xc5, 0x7a, 0x12,
0x29, 0xff, 0x5d, 0xc1, 0xe7, 0xae, 0x48, 0xc8,
0x57, 0x53, 0xe7, 0xcd, 0x10, 0x6c, 0x19, 0xfc,
0xcc, 0xb9, 0xb1, 0xbe, 0x48, 0x9f, 0x2d, 0x3f,
0x39, 0x2e, 0xdd, 0x71, 0xde, 0x1b, 0x54, 0xee,
0x7d, 0x94, 0x8f, 0x27, 0x23, 0xe9, 0x74, 0x92,
0x14, 0x93, 0x84, 0x65, 0xc9, 0x22, 0x7c, 0xa8,
0x1b, 0x72, 0x73, 0xb1, 0x23, 0xa0, 0x6b, 0xcc,
0xb5, 0x22, 0x06, 0x15, 0xe5, 0x96, 0x03, 0x4a,
0x52, 0x8d, 0x1d, 0xbf, 0x3e, 0x82, 0x45, 0x9c,
0x75, 0x9e, 0xa9, 0x3a, 0x97, 0xb6, 0x5d, 0xc4,
0x75, 0x67, 0xa1, 0xf3, 0x0f, 0x7a, 0xfd, 0x71,
0x58, 0x04, 0xf9, 0xa7, 0xc2, 0x56, 0x74, 0x04,
0x74, 0x68, 0x6d, 0x8a, 0xf6, 0x6c, 0x5d, 0xd8,
0xb5, 0xed, 0x70, 0x23, 0x32, 0x4d, 0x75, 0x92,
0x88, 0x7b, 0x39, 0x37, 0x02, 0x4b, 0xb2, 0x1c,
0x1f, 0x7e, 0x5b, 0x1b, 0x10, 0xfc, 0x17, 0x21,
0x66, 0x62, 0x63, 0xc2, 0xcd, 0x16, 0x96, 0x3e
};
static const struct blockcipher_test_data
triple_des192cbc_test_vector = {
.crypto_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
.cipher_key = {
.data = {
0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0
},
.len = 24
},
.iv = {
.data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
},
.len = 8
},
.plaintext = {
.data = plaintext_des,
.len = 512
},
.ciphertext = {
.data = ciphertext512_des192cbc,
.len = 512
}
};
static const struct blockcipher_test_data
triple_des192cbc_sha1_test_vector = {
.crypto_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
.cipher_key = {
.data = {
0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0
},
.len = 24
},
.iv = {
.data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
},
.len = 8
},
.plaintext = {
.data = plaintext_des,
.len = 512
},
.ciphertext = {
.data = ciphertext512_des192cbc,
.len = 512
},
.auth_algo = RTE_CRYPTO_AUTH_SHA1,
.digest = {
.data = {
0x53, 0x27, 0xC0, 0xE6, 0xD6, 0x1B, 0xD6, 0x45,
0x94, 0x2D, 0xCE, 0x8B, 0x29, 0xA3, 0x52, 0x14,
0xC1, 0x6B, 0x87, 0x99
},
.len = 20
}
};
static const struct blockcipher_test_data
triple_des192cbc_hmac_sha1_test_vector = {
.crypto_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
.cipher_key = {
.data = {
0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0
},
.len = 24
},
.iv = {
.data = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
},
.len = 8
},
.plaintext = {
.data = plaintext_des,
.len = 512
},
.ciphertext = {
.data = ciphertext512_des192cbc,
.len = 512
},
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
.auth_key = {
.data = {
0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
0xDE, 0xF4, 0xDE, 0xAD
},
.len = 20
},
.digest = {
.data = {
0xBA, 0xAC, 0x74, 0x19, 0x43, 0xB0, 0x72, 0xB8,
0x08, 0xF5, 0x24, 0xC4, 0x09, 0xBD, 0x48, 0xC1,
0x3C, 0x50, 0x1C, 0xDD
},
.len = 20
}
};
static const struct blockcipher_test_case triple_des_chain_test_cases[] = {
{
.test_descr = "3DES-128-CBC HMAC-SHA1 Encryption Digest",
.test_data = &triple_des128cbc_hmac_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-128-CBC HMAC-SHA1 Decryption Digest Verify",
.test_data = &triple_des128cbc_hmac_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-128-CBC SHA1 Encryption Digest",
.test_data = &triple_des128cbc_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "3DES-128-CBC SHA1 Decryption Digest Verify",
.test_data = &triple_des128cbc_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "3DES-192-CBC HMAC-SHA1 Encryption Digest",
.test_data = &triple_des192cbc_hmac_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-192-CBC HMAC-SHA1 Decryption Digest Verify",
.test_data = &triple_des192cbc_hmac_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-192-CBC SHA1 Encryption Digest",
.test_data = &triple_des192cbc_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "3DES-192-CBC SHA1 Decryption Digest Verify",
.test_data = &triple_des192cbc_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "3DES-128-CTR HMAC-SHA1 Encryption Digest",
.test_data = &triple_des128ctr_hmac_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-128-CTR HMAC-SHA1 Decryption Digest Verify",
.test_data = &triple_des128ctr_hmac_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-128-CTR SHA1 Encryption Digest",
.test_data = &triple_des128ctr_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "3DES-128-CTR SHA1 Decryption Digest Verify",
.test_data = &triple_des128ctr_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "3DES-192-CTR HMAC-SHA1 Encryption Digest",
.test_data = &triple_des192ctr_hmac_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-192-CTR HMAC-SHA1 Decryption Digest Verify",
.test_data = &triple_des192ctr_hmac_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-192-CTR SHA1 Encryption Digest",
.test_data = &triple_des192ctr_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "3DES-192-CTR SHA1 Decryption Digest Verify",
.test_data = &triple_des192ctr_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "3DES-128-CBC HMAC-SHA1 Encryption Digest OOP",
.test_data = &triple_des128cbc_hmac_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-128-CBC HMAC-SHA1 Decryption Digest"
" Verify OOP",
.test_data = &triple_des128cbc_hmac_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.feature_mask = BLOCKCIPHER_TEST_FEATURE_OOP,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-128-CBC HMAC-SHA1 Encryption Digest"
" Sessionless",
.test_data = &triple_des128cbc_hmac_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN,
.feature_mask = BLOCKCIPHER_TEST_FEATURE_SESSIONLESS,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr =
"3DES-128-CBC HMAC-SHA1 Decryption Digest"
" Verify Sessionless",
.test_data = &triple_des128cbc_hmac_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC,
.feature_mask = BLOCKCIPHER_TEST_FEATURE_SESSIONLESS,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
};
static const struct blockcipher_test_case triple_des_cipheronly_test_cases[] = {
{
.test_descr = "3DES-128-CBC Encryption",
.test_data = &triple_des128cbc_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-128-CBC Decryption",
.test_data = &triple_des128cbc_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-192-CBC Encryption",
.test_data = &triple_des192cbc_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-192-CBC Decryption",
.test_data = &triple_des192cbc_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-128-CTR Encryption",
.test_data = &triple_des128ctr_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-128-CTR Decryption",
.test_data = &triple_des128ctr_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-192-CTR Encryption",
.test_data = &triple_des192ctr_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
},
{
.test_descr = "3DES-192-CTR Decryption",
.test_data = &triple_des192ctr_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_DECRYPT,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO |
BLOCKCIPHER_TEST_TARGET_PMD_QAT
}
};
#endif /* TEST_CRYPTODEV_DES_TEST_VECTORS_H_ */

36
app/test/test_cryptodev_gcm_test_vectors.h
View File

@ -33,6 +33,8 @@
#ifndef TEST_CRYPTODEV_GCM_TEST_VECTORS_H_
#define TEST_CRYPTODEV_GCM_TEST_VECTORS_H_
#define GMAC_LARGE_PLAINTEXT_LENGTH 65376
struct gcm_test_data {
struct {
uint8_t data[64];
@ -449,7 +451,7 @@ static const struct gcm_test_data gcm_test_case_7 = {
};
/** GMAC Test Vectors */
static uint8_t gmac_plaintext[] = {
static uint8_t gmac_plaintext[GMAC_LARGE_PLAINTEXT_LENGTH] = {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
@ -1201,4 +1203,36 @@ static const struct cryptodev_perf_test_data AES_GCM_128_12IV_0AAD = {
},
};
static const struct gmac_test_data gmac_test_case_4 = {
.key = {
.data = {
0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08
},
.len = 16
},
.iv = {
.data = {
0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
0xde, 0xca, 0xf8, 0x88
},
.len = 12
},
.aad = {
.data = gmac_plaintext,
.len = GMAC_LARGE_PLAINTEXT_LENGTH
},
.plaintext = {
.data = NULL,
.len = 0
},
.gmac_tag = {
.data = {
0x88, 0x82, 0xb4, 0x93, 0x8f, 0x04, 0xcd, 0x06,
0xfd, 0xac, 0x6d, 0x8b, 0x9c, 0x9e, 0x8f, 0xec
},
.len = 16
}
};
#endif /* TEST_CRYPTODEV_GCM_TEST_VECTORS_H_ */

491
app/test/test_cryptodev_hash_test_vectors.h Normal file
View File

@ -0,0 +1,491 @@
/*
* BSD LICENSE
*
* Copyright(c) 2016 Intel Corporation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef TEST_CRYPTODEV_HASH_TEST_VECTORS_H_
#define TEST_CRYPTODEV_HASH_TEST_VECTORS_H_
static const uint8_t plaintext_hash[] = {
"What a lousy earth! He wondered how many people "
"were destitute that same night even in his own "
"prosperous country, how many homes were "
"shanties, how many husbands were drunk and "
"wives socked, and how many children were "
"bullied, abused, or abandoned. How many "
"families hungered for food they could not "
"afford to buy? How many hearts were broken? How "
"many suicides would take place that same night, "
"how many people would go insane? How many "
"cockroaches and landlords would triumph? How "
"many winners were losers, successes failures, "
"and rich men poor men? How many wise guys were "
"stupid? How many happy endings were unhappy "
"endings? How many honest men were liars, brave "
"men cowards, loyal men traitors, how many "
"sainted men were corrupt, how many people in "
"positions of trust had sold their souls to "
"bodyguards, how many had never had souls? How "
"many straight-and-narrow paths were crooked "
"paths? How many best families were worst "
"families and how many good people were bad "
"people? When you added them all up and then "
"subtracted, you might be left with only the "
"children, and perhaps with Albert Einstein and "
"an old violinist or sculptor somewhere."
};
static const struct blockcipher_test_data
md5_test_vector = {
.auth_algo = RTE_CRYPTO_AUTH_MD5,
.ciphertext = {
.data = plaintext_hash,
.len = 512
},
.digest = {
.data = {
0xB3, 0xE6, 0xBB, 0x50, 0x41, 0x35, 0x3C, 0x6B,
0x7A, 0xFF, 0xD2, 0x64, 0xAF, 0xD5, 0x1C, 0xB2
},
.len = 16
}
};
static const struct blockcipher_test_data
hmac_md5_test_vector = {
.auth_algo = RTE_CRYPTO_AUTH_MD5_HMAC,
.ciphertext = {
.data = plaintext_hash,
.len = 512
},
.auth_key = {
.data = {
0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD
},
.len = 16
},
.digest = {
.data = {
0x50, 0xE8, 0xDE, 0xC5, 0xC1, 0x76, 0xAC, 0xAE,
0x15, 0x4A, 0xF1, 0x7F, 0x7E, 0x04, 0x42, 0x9B
},
.len = 16
}
};
static const struct blockcipher_test_data
sha1_test_vector = {
.auth_algo = RTE_CRYPTO_AUTH_SHA1,
.ciphertext = {
.data = plaintext_hash,
.len = 512
},
.digest = {
.data = {
0xA2, 0x8D, 0x40, 0x78, 0xDD, 0x9F, 0xBB, 0xD5,
0x35, 0x62, 0xFB, 0xFA, 0x93, 0xFD, 0x7D, 0x70,
0xA6, 0x7D, 0x45, 0xCA
},
.len = 20
}
};
static const struct blockcipher_test_data
hmac_sha1_test_vector = {
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
.ciphertext = {
.data = plaintext_hash,
.len = 512
},
.auth_key = {
.data = {
0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
0xDE, 0xF4, 0xDE, 0xAD
},
.len = 20
},
.digest = {
.data = {
0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
0x3F, 0x91, 0x64, 0x59
},
.len = 20
}
};
static const struct blockcipher_test_data
sha224_test_vector = {
.auth_algo = RTE_CRYPTO_AUTH_SHA224,
.ciphertext = {
.data = plaintext_hash,
.len = 512
},
.digest = {
.data = {
0x91, 0xE7, 0xCD, 0x75, 0x14, 0x9C, 0xA9, 0xE9,
0x2E, 0x46, 0x12, 0x20, 0x22, 0xF9, 0x68, 0x28,
0x39, 0x26, 0xDF, 0xB5, 0x78, 0x62, 0xB2, 0x6E,
0x5E, 0x8F, 0x25, 0x84
},
.len = 28
}
};
static const struct blockcipher_test_data
hmac_sha224_test_vector = {
.auth_algo = RTE_CRYPTO_AUTH_SHA224_HMAC,
.ciphertext = {
.data = plaintext_hash,
.len = 512
},
.auth_key = {
.data = {
0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
0xDE, 0xF4, 0xDE, 0xAD, 0x26, 0xEB, 0xAB, 0x92,
0xFB, 0xBF, 0xB0, 0x8C
},
.len = 28
},
.digest = {
.data = {
0x70, 0x0F, 0x04, 0x4D, 0x22, 0x02, 0x7D, 0x31,
0x36, 0xDA, 0x77, 0x19, 0xB9, 0x66, 0x37, 0x7B,
0xF1, 0x8A, 0x63, 0xBB, 0x5D, 0x1D, 0xE3, 0x9F,
0x92, 0xF6, 0xAA, 0x19
},
.len = 28
}
};
static const struct blockcipher_test_data
sha256_test_vector = {
.auth_algo = RTE_CRYPTO_AUTH_SHA256,
.ciphertext = {
.data = plaintext_hash,
.len = 512
},
.digest = {
.data = {
0x7F, 0xF1, 0x0C, 0xF5, 0x90, 0x97, 0x19, 0x0F,
0x00, 0xE4, 0x83, 0x01, 0xCA, 0x59, 0x00, 0x2E,
0x1F, 0xC7, 0x84, 0xEE, 0x76, 0xA6, 0x39, 0x15,
0x76, 0x2F, 0x87, 0xF9, 0x01, 0x06, 0xF3, 0xB7
},
.len = 32
}
};
static const struct blockcipher_test_data
hmac_sha256_test_vector = {
.auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
.ciphertext = {
.data = plaintext_hash,
.len = 512
},
.auth_key = {
.data = {
0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
0xDE, 0xF4, 0xDE, 0xAD, 0x26, 0xEB, 0xAB, 0x92,
0xFB, 0xBF, 0xB0, 0x8C, 0x29, 0x87, 0x90, 0xAC
},
.len = 32
},
.digest = {
.data = {
0xAF, 0x8F, 0x70, 0x1B, 0x4B, 0xAF, 0x34, 0xCB,
0x02, 0x24, 0x48, 0x45, 0x83, 0x52, 0x8F, 0x22,
0x06, 0x4D, 0x64, 0x09, 0x0A, 0xCC, 0x02, 0x77,
0x71, 0x83, 0x48, 0x71, 0x07, 0x02, 0x25, 0x17
},
.len = 32
}
};
static const struct blockcipher_test_data
sha384_test_vector = {
.auth_algo = RTE_CRYPTO_AUTH_SHA384,
.ciphertext = {
.data = plaintext_hash,
.len = 512
},
.digest = {
.data = {
0x1D, 0xE7, 0x3F, 0x55, 0x86, 0xFE, 0x48, 0x9F,
0xAC, 0xC6, 0x85, 0x32, 0xFA, 0x8E, 0xA6, 0x77,
0x25, 0x84, 0xA5, 0x98, 0x8D, 0x0B, 0x80, 0xF4,
0xEB, 0x2C, 0xFB, 0x6C, 0xEA, 0x7B, 0xFD, 0xD5,
0xAD, 0x41, 0xAB, 0x15, 0xB0, 0x03, 0x15, 0xEC,
0x9E, 0x3D, 0xED, 0xCB, 0x80, 0x7B, 0xF4, 0xB6
},
.len = 48
}
};
static const struct blockcipher_test_data
hmac_sha384_test_vector = {
.auth_algo = RTE_CRYPTO_AUTH_SHA384_HMAC,
.ciphertext = {
.data = plaintext_hash,
.len = 512
},
.auth_key = {
.data = {
0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
0xDE, 0xF4, 0xDE, 0xAD, 0x26, 0xEB, 0xAB, 0x92,
0xFB, 0xBF, 0xB0, 0x8C, 0x29, 0x87, 0x90, 0xAC,
0x39, 0x8B, 0x5C, 0x49, 0x68, 0x1E, 0x3A, 0x05,
0xCC, 0x68, 0x5C, 0x76, 0xCB, 0x3C, 0x71, 0x89
},
.len = 48
},
.digest = {
.data = {
0xE2, 0x83, 0x18, 0x55, 0xB5, 0x8D, 0x94, 0x9B,
0x01, 0xB6, 0xE2, 0x57, 0x7A, 0x62, 0xF5, 0xF4,
0xAB, 0x39, 0xF3, 0x3C, 0x28, 0xA0, 0x0F, 0xCC,
0xEE, 0x1C, 0xF1, 0xF8, 0x69, 0xF1, 0x24, 0x3B,
0x10, 0x90, 0x0A, 0xE3, 0xF0, 0x59, 0xDD, 0xC0,
0x6F, 0xE6, 0x8C, 0x84, 0xD5, 0x03, 0xF8, 0x9E
},
.len = 48
}
};
static const struct blockcipher_test_data
sha512_test_vector = {
.auth_algo = RTE_CRYPTO_AUTH_SHA512,
.ciphertext = {
.data = plaintext_hash,
.len = 512
},
.digest = {
.data = {
0xB9, 0xBA, 0x28, 0x48, 0x3C, 0xC2, 0xD3, 0x65,
0x4A, 0xD6, 0x00, 0x1D, 0xCE, 0x61, 0x64, 0x54,
0x45, 0x8C, 0x64, 0x0E, 0xED, 0x0E, 0xD8, 0x1C,
0x72, 0xCE, 0xD2, 0x44, 0x91, 0xC8, 0xEB, 0xC7,
0x99, 0xC5, 0xCA, 0x89, 0x72, 0x64, 0x96, 0x41,
0xC8, 0xEA, 0xB2, 0x4E, 0xD1, 0x21, 0x13, 0x49,
0x64, 0x4E, 0x15, 0x68, 0x12, 0x67, 0x26, 0x0F,
0x2C, 0x3C, 0x83, 0x25, 0x27, 0x86, 0xF0, 0xDB
},
.len = 64
}
};
static const struct blockcipher_test_data
hmac_sha512_test_vector = {
.auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC,
.ciphertext = {
.data = plaintext_hash,
.len = 512
},
.auth_key = {
.data = {
0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
0xDE, 0xF4, 0xDE, 0xAD, 0x26, 0xEB, 0xAB, 0x92,
0xFB, 0xBF, 0xB0, 0x8C, 0x29, 0x87, 0x90, 0xAC,
0x39, 0x8B, 0x5C, 0x49, 0x68, 0x1E, 0x3A, 0x05,
0xCC, 0x68, 0x5C, 0x76, 0xCB, 0x3C, 0x71, 0x89,
0xDE, 0xAA, 0x36, 0x44, 0x98, 0x93, 0x97, 0x1E,
0x6D, 0x53, 0x83, 0x87, 0xB3, 0xB7, 0x56, 0x41
},
.len = 64
},
.digest = {
.data = {
0xB8, 0x0B, 0x35, 0x97, 0x3F, 0x24, 0x3F, 0x05,
0x2A, 0x7F, 0x2F, 0xD8, 0xD7, 0x56, 0x58, 0xAD,
0x6F, 0x8D, 0x1F, 0x4C, 0x30, 0xF9, 0xA8, 0x29,
0x7A, 0xE0, 0x8D, 0x88, 0xF5, 0x2E, 0x94, 0xF5,
0x06, 0xF7, 0x5D, 0x57, 0x32, 0xA8, 0x49, 0x29,
0xEA, 0x6B, 0x6D, 0x95, 0xBD, 0x76, 0xF5, 0x79,
0x97, 0x37, 0x0F, 0xBE, 0xC2, 0x45, 0xA0, 0x87,
0xAF, 0x24, 0x27, 0x0C, 0x78, 0xBA, 0xBE, 0x20
},
.len = 64
}
};
static const struct blockcipher_test_case hash_test_cases[] = {
{
.test_descr = "MD5 Digest",
.test_data = &md5_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "MD5 Digest Verify",
.test_data = &md5_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "HMAC-MD5 Digest",
.test_data = &hmac_md5_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "HMAC-MD5 Digest Verify",
.test_data = &hmac_md5_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "SHA1 Digest",
.test_data = &sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "SHA1 Digest Verify",
.test_data = &sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "HMAC-SHA1 Digest",
.test_data = &hmac_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "HMAC-SHA1 Digest Verify",
.test_data = &hmac_sha1_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "SHA224 Digest",
.test_data = &sha224_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "SHA224 Digest Verify",
.test_data = &sha224_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "HMAC-SHA224 Digest",
.test_data = &hmac_sha224_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "HMAC-SHA224 Digest Verify",
.test_data = &hmac_sha224_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "SHA256 Digest",
.test_data = &sha256_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "SHA256 Digest Verify",
.test_data = &sha256_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "HMAC-SHA256 Digest",
.test_data = &hmac_sha256_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "HMAC-SHA256 Digest Verify",
.test_data = &hmac_sha256_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "SHA384 Digest",
.test_data = &sha384_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "SHA384 Digest Verify",
.test_data = &sha384_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "HMAC-SHA384 Digest",
.test_data = &hmac_sha384_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "HMAC-SHA384 Digest Verify",
.test_data = &hmac_sha384_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "SHA512 Digest",
.test_data = &sha512_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "SHA512 Digest Verify",
.test_data = &sha512_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "HMAC-SHA512 Digest",
.test_data = &hmac_sha512_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
{
.test_descr = "HMAC-SHA512 Digest Verify",
.test_data = &hmac_sha512_test_vector,
.op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY,
.pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_LIBCRYPTO
},
};
#endif /* TEST_CRYPTODEV_HASH_TEST_VECTORS_H_ */

712
app/test/test_cryptodev_perf.c
View File

@ -149,7 +149,13 @@ struct crypto_unittest_params {
static struct rte_cryptodev_sym_session *
test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
enum rte_crypto_cipher_algorithm cipher_algo, unsigned cipher_key_len,
enum rte_crypto_cipher_algorithm cipher_algo,
unsigned int cipher_key_len,
enum rte_crypto_auth_algorithm auth_algo);
static struct rte_cryptodev_sym_session *
test_perf_create_libcrypto_session(uint8_t dev_id, enum chain_mode chain,
enum rte_crypto_cipher_algorithm cipher_algo,
unsigned int cipher_key_len,
enum rte_crypto_auth_algorithm auth_algo);
static struct rte_mbuf *
test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz);
@ -157,6 +163,18 @@ static inline struct rte_crypto_op *
test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
struct rte_cryptodev_sym_session *sess, unsigned data_len,
unsigned digest_len);
static inline struct rte_crypto_op *
test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
struct rte_cryptodev_sym_session *sess, unsigned int data_len,
unsigned int digest_len);
static inline struct rte_crypto_op *
test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
struct rte_cryptodev_sym_session *sess, unsigned int data_len,
unsigned int digest_len);
static inline struct rte_crypto_op *
test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
struct rte_cryptodev_sym_session *sess, unsigned int data_len,
unsigned int digest_len);
static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo);
@ -357,6 +375,28 @@ testsuite_setup(void)
}
}
/* Create 2 LIBCRYPTO devices if required */
if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_LIBCRYPTO_PMD) {
#ifndef RTE_LIBRTE_PMD_LIBCRYPTO
RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_LIBCRYPTO must be"
" enabled in config file to run this testsuite.\n");
return TEST_FAILED;
#endif
nb_devs = rte_cryptodev_count_devtype(
RTE_CRYPTODEV_LIBCRYPTO_PMD);
if (nb_devs < 2) {
for (i = nb_devs; i < 2; i++) {
ret = rte_eal_vdev_init(
RTE_STR(CRYPTODEV_NAME_LIBCRYPTO_PMD),
NULL);
TEST_ASSERT(ret == 0, "Failed to create "
"instance %u of pmd : %s", i,
RTE_STR(CRYPTODEV_NAME_LIBCRYPTO_PMD));
}
}
}
#ifndef RTE_LIBRTE_PMD_QAT
if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_QAT_SYM_PMD) {
RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_QAT must be enabled "
@ -367,7 +407,7 @@ testsuite_setup(void)
nb_devs = rte_cryptodev_count();
if (nb_devs < 1) {
RTE_LOG(ERR, USER1, "No crypto devices found?");
RTE_LOG(ERR, USER1, "No crypto devices found?\n");
return TEST_FAILED;
}
@ -2242,6 +2282,161 @@ test_perf_snow3G_vary_burst_size(void)
return 0;
}
static int
test_perf_libcrypto_optimise_cyclecount(struct perf_test_params *pparams)
{
uint32_t num_to_submit = pparams->total_operations;
struct rte_crypto_op *c_ops[num_to_submit];
struct rte_crypto_op *proc_ops[num_to_submit];
uint64_t failed_polls, retries, start_cycles,
end_cycles, total_cycles = 0;
uint32_t burst_sent = 0, burst_received = 0;
uint32_t i, burst_size, num_sent, num_ops_received;
struct crypto_testsuite_params *ts_params = &testsuite_params;
static struct rte_cryptodev_sym_session *sess;
static struct rte_crypto_op *(*test_perf_set_crypto_op)
(struct rte_crypto_op *, struct rte_mbuf *,
struct rte_cryptodev_sym_session *,
unsigned int, unsigned int);
unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
if (rte_cryptodev_count() == 0) {
printf("\nNo crypto devices found. Is PMD build configured?\n");
return TEST_FAILED;
}
/* Create Crypto session*/
sess = test_perf_create_libcrypto_session(ts_params->dev_id,
pparams->chain, pparams->cipher_algo,
pparams->cipher_key_length, pparams->auth_algo);
TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
/* Generate Crypto op data structure(s)*/
for (i = 0; i < num_to_submit ; i++) {
struct rte_mbuf *m = test_perf_create_pktmbuf(
ts_params->mbuf_mp,
pparams->buf_size);
TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
struct rte_crypto_op *op =
rte_crypto_op_alloc(ts_params->op_mpool,
RTE_CRYPTO_OP_TYPE_SYMMETRIC);
TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
switch (pparams->cipher_algo) {
case RTE_CRYPTO_CIPHER_3DES_CBC:
case RTE_CRYPTO_CIPHER_3DES_CTR:
test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
break;
case RTE_CRYPTO_CIPHER_AES_CBC:
case RTE_CRYPTO_CIPHER_AES_CTR:
test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
break;
case RTE_CRYPTO_CIPHER_AES_GCM:
test_perf_set_crypto_op =
test_perf_set_crypto_op_aes_gcm;
break;
default:
return TEST_FAILED;
}
op = test_perf_set_crypto_op(op, m, sess, pparams->buf_size,
digest_length);
TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
c_ops[i] = op;
}
printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
"auth_algo:%s, Packet Size %u bytes",
pmd_name(gbl_cryptodev_perftest_devtype),
ts_params->dev_id, 0,
chain_mode_name(pparams->chain),
cipher_algo_name(pparams->cipher_algo),
pparams->cipher_key_length,
auth_algo_name(pparams->auth_algo),
pparams->buf_size);
printf("\nOps Tx\tOps Rx\tOps/burst ");
printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\t"
"IACycles/Byte");
for (i = 2; i <= 128 ; i *= 2) {
num_sent = 0;
num_ops_received = 0;
retries = 0;
failed_polls = 0;
burst_size = i;
total_cycles = 0;
while (num_sent < num_to_submit) {
start_cycles = rte_rdtsc_precise();
burst_sent = rte_cryptodev_enqueue_burst(
ts_params->dev_id,
0, &c_ops[num_sent],
((num_to_submit - num_sent) <
burst_size) ?
num_to_submit - num_sent : burst_size);
end_cycles = rte_rdtsc_precise();
if (burst_sent == 0)
retries++;
num_sent += burst_sent;
total_cycles += (end_cycles - start_cycles);
/* Wait until requests have been sent. */
rte_delay_ms(1);
start_cycles = rte_rdtsc_precise();
burst_received = rte_cryptodev_dequeue_burst(
ts_params->dev_id, 0, proc_ops,
burst_size);
end_cycles = rte_rdtsc_precise();
if (burst_received < burst_sent)
failed_polls++;
num_ops_received += burst_received;
total_cycles += end_cycles - start_cycles;
}
while (num_ops_received != num_to_submit) {
/* Sending 0 length burst to flush sw crypto device */
rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
NULL, 0);
start_cycles = rte_rdtsc_precise();
burst_received = rte_cryptodev_dequeue_burst(
ts_params->dev_id, 0, proc_ops,
burst_size);
end_cycles = rte_rdtsc_precise();
total_cycles += end_cycles - start_cycles;
if (burst_received == 0)
failed_polls++;
num_ops_received += burst_received;
}
printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
printf("\t\t%"PRIu64, retries);
printf("\t%"PRIu64, failed_polls);
printf("\t\t%"PRIu64, total_cycles/num_ops_received);
printf("\t\t%"PRIu64, (total_cycles/num_ops_received) *
burst_size);
printf("\t\t%"PRIu64,
total_cycles /
(num_ops_received * pparams->buf_size));
}
printf("\n");
for (i = 0; i < num_to_submit ; i++) {
rte_pktmbuf_free(c_ops[i]->sym->m_src);
rte_crypto_op_free(c_ops[i]);
}
return TEST_SUCCESS;
}
static uint32_t get_auth_key_max_length(enum rte_crypto_auth_algorithm algo)
{
switch (algo) {
@ -2257,6 +2452,8 @@ static uint32_t get_auth_key_max_length(enum rte_crypto_auth_algorithm algo)
return 128;
case RTE_CRYPTO_AUTH_SHA512_HMAC:
return 128;
case RTE_CRYPTO_AUTH_AES_GCM:
return 0;
default:
return 0;
}
@ -2277,23 +2474,35 @@ static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo)
return TRUNCATED_DIGEST_BYTE_LENGTH_SHA384;
case RTE_CRYPTO_AUTH_SHA512_HMAC:
return TRUNCATED_DIGEST_BYTE_LENGTH_SHA512;
case RTE_CRYPTO_AUTH_AES_GCM:
return DIGEST_BYTE_LENGTH_AES_GCM;
default:
return 0;
}
}
static uint8_t aes_cbc_key[] = {
static uint8_t aes_key[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static uint8_t aes_cbc_iv[] = {
static uint8_t aes_iv[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static uint8_t triple_des_key[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static uint8_t triple_des_iv[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static uint8_t hmac_sha_key[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -2343,7 +2552,7 @@ test_perf_create_aes_sha_session(uint8_t dev_id, enum chain_mode chain,
cipher_xform.cipher.algo = cipher_algo;
cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
cipher_xform.cipher.key.data = aes_cbc_key;
cipher_xform.cipher.key.data = aes_key;
cipher_xform.cipher.key.length = cipher_key_len;
/* Setup HMAC Parameters */
@ -2421,8 +2630,77 @@ test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
}
}
#define AES_CBC_BLOCK_SIZE 16
#define AES_CBC_CIPHER_IV_LENGTH 16
static struct rte_cryptodev_sym_session *
test_perf_create_libcrypto_session(uint8_t dev_id, enum chain_mode chain,
enum rte_crypto_cipher_algorithm cipher_algo,
unsigned int cipher_key_len,
enum rte_crypto_auth_algorithm auth_algo)
{
struct rte_crypto_sym_xform cipher_xform = { 0 };
struct rte_crypto_sym_xform auth_xform = { 0 };
/* Setup Cipher Parameters */
cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cipher_xform.cipher.algo = cipher_algo;
cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
switch (cipher_algo) {
case RTE_CRYPTO_CIPHER_3DES_CBC:
case RTE_CRYPTO_CIPHER_3DES_CTR:
cipher_xform.cipher.key.data = triple_des_key;
break;
case RTE_CRYPTO_CIPHER_AES_CBC:
case RTE_CRYPTO_CIPHER_AES_CTR:
case RTE_CRYPTO_CIPHER_AES_GCM:
cipher_xform.cipher.key.data = aes_key;
break;
default:
return NULL;
}
cipher_xform.cipher.key.length = cipher_key_len;
/* Setup Auth Parameters */
auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
auth_xform.auth.algo = auth_algo;
switch (auth_algo) {
case RTE_CRYPTO_AUTH_SHA1_HMAC:
auth_xform.auth.key.data = hmac_sha_key;
break;
case RTE_CRYPTO_AUTH_AES_GCM:
auth_xform.auth.key.data = NULL;
break;
default:
return NULL;
}
auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
switch (chain) {
case CIPHER_HASH:
cipher_xform.next = &auth_xform;
auth_xform.next = NULL;
/* Create Crypto session*/
return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
case HASH_CIPHER:
auth_xform.next = &cipher_xform;
cipher_xform.next = NULL;
/* Create Crypto session*/
return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
default:
return NULL;
}
}
#define AES_BLOCK_SIZE 16
#define AES_CIPHER_IV_LENGTH 16
#define TRIPLE_DES_BLOCK_SIZE 8
#define TRIPLE_DES_CIPHER_IV_LENGTH 8
#define SNOW3G_CIPHER_IV_LENGTH 16
static struct rte_mbuf *
@ -2441,7 +2719,7 @@ test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz)
}
static inline struct rte_crypto_op *
test_perf_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
struct rte_cryptodev_sym_session *sess, unsigned data_len,
unsigned digest_len)
{
@ -2455,19 +2733,54 @@ test_perf_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
(m->data_off + data_len);
op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m, data_len);
op->sym->auth.digest.length = digest_len;
op->sym->auth.aad.data = aes_cbc_iv;
op->sym->auth.aad.length = AES_CBC_CIPHER_IV_LENGTH;
op->sym->auth.aad.data = aes_iv;
op->sym->auth.aad.length = AES_CIPHER_IV_LENGTH;
/* Cipher Parameters */
op->sym->cipher.iv.data = aes_cbc_iv;
op->sym->cipher.iv.length = AES_CBC_CIPHER_IV_LENGTH;
op->sym->cipher.iv.data = aes_iv;
op->sym->cipher.iv.length = AES_CIPHER_IV_LENGTH;
/* Data lengths/offsets Parameters */
op->sym->auth.data.offset = 0;
op->sym->auth.data.length = data_len;
op->sym->cipher.data.offset = AES_CBC_BLOCK_SIZE;
op->sym->cipher.data.length = data_len - AES_CBC_BLOCK_SIZE;
op->sym->cipher.data.offset = AES_BLOCK_SIZE;
op->sym->cipher.data.length = data_len - AES_BLOCK_SIZE;
op->sym->m_src = m;
return op;
}
static inline struct rte_crypto_op *
test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
struct rte_cryptodev_sym_session *sess, unsigned int data_len,
unsigned int digest_len)
{
if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
rte_crypto_op_free(op);
return NULL;
}
/* Authentication Parameters */
op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
(m->data_off + data_len);
op->sym->auth.digest.phys_addr =
rte_pktmbuf_mtophys_offset(m, data_len);
op->sym->auth.digest.length = digest_len;
op->sym->auth.aad.data = aes_iv;
op->sym->auth.aad.length = AES_CIPHER_IV_LENGTH;
/* Cipher Parameters */
op->sym->cipher.iv.data = aes_iv;
op->sym->cipher.iv.length = AES_CIPHER_IV_LENGTH;
/* Data lengths/offsets Parameters */
op->sym->auth.data.offset = AES_BLOCK_SIZE;
op->sym->auth.data.length = data_len - AES_BLOCK_SIZE;
op->sym->cipher.data.offset = AES_BLOCK_SIZE;
op->sym->cipher.data.length = data_len - AES_BLOCK_SIZE;
op->sym->m_src = m;
@ -2487,7 +2800,8 @@ test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
/* Authentication Parameters */
op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
(m->data_off + data_len);
op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m, data_len);
op->sym->auth.digest.phys_addr =
rte_pktmbuf_mtophys_offset(m, data_len);
op->sym->auth.digest.length = digest_len;
op->sym->auth.aad.data = snow3g_iv;
op->sym->auth.aad.length = SNOW3G_CIPHER_IV_LENGTH;
@ -2508,7 +2822,40 @@ test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
return op;
}
static inline struct rte_crypto_op *
test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
struct rte_cryptodev_sym_session *sess, unsigned int data_len,
unsigned int digest_len)
{
if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
rte_crypto_op_free(op);
return NULL;
}
/* Authentication Parameters */
op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
(m->data_off + data_len);
op->sym->auth.digest.phys_addr =
rte_pktmbuf_mtophys_offset(m, data_len);
op->sym->auth.digest.length = digest_len;
op->sym->auth.aad.data = triple_des_iv;
op->sym->auth.aad.length = TRIPLE_DES_CIPHER_IV_LENGTH;
/* Cipher Parameters */
op->sym->cipher.iv.data = triple_des_iv;
op->sym->cipher.iv.length = TRIPLE_DES_CIPHER_IV_LENGTH;
/* Data lengths/offsets Parameters */
op->sym->auth.data.offset = 0;
op->sym->auth.data.length = data_len;
op->sym->cipher.data.offset = TRIPLE_DES_BLOCK_SIZE;
op->sym->cipher.data.length = data_len - TRIPLE_DES_BLOCK_SIZE;
op->sym->m_src = m;
return op;
}
/* An mbuf set is used in each burst. An mbuf can be used by multiple bursts at
* same time, i.e. as they're not dereferenced there's no need to wait until
@ -2579,7 +2926,7 @@ test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id,
"and free ops below.");
} else {
for (i = 0; i < ops_needed; i++)
ops[i] = test_perf_set_crypto_op(ops[i],
ops[i] = test_perf_set_crypto_op_aes(ops[i],
mbufs[i + (pparams->burst_size *
(j % NUM_MBUF_SETS))],
sess, pparams->buf_size, digest_length);
@ -2790,6 +3137,155 @@ test_perf_snow3g(uint8_t dev_id, uint16_t queue_id,
return TEST_SUCCESS;
}
static int
test_perf_libcrypto(uint8_t dev_id, uint16_t queue_id,
struct perf_test_params *pparams)
{
uint16_t i, k, l, m;
uint16_t j = 0;
uint16_t ops_unused = 0;
uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
uint64_t processed = 0, failed_polls = 0, retries = 0;
uint64_t tsc_start = 0, tsc_end = 0;
unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
struct rte_crypto_op *ops[pparams->burst_size];
struct rte_crypto_op *proc_ops[pparams->burst_size];
struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
struct crypto_testsuite_params *ts_params = &testsuite_params;
static struct rte_cryptodev_sym_session *sess;
static struct rte_crypto_op *(*test_perf_set_crypto_op)
(struct rte_crypto_op *, struct rte_mbuf *,
struct rte_cryptodev_sym_session *,
unsigned int, unsigned int);
switch (pparams->cipher_algo) {
case RTE_CRYPTO_CIPHER_3DES_CBC:
case RTE_CRYPTO_CIPHER_3DES_CTR:
test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
break;
case RTE_CRYPTO_CIPHER_AES_CBC:
case RTE_CRYPTO_CIPHER_AES_CTR:
test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
break;
case RTE_CRYPTO_CIPHER_AES_GCM:
test_perf_set_crypto_op = test_perf_set_crypto_op_aes_gcm;
break;
default:
return TEST_FAILED;
}
if (rte_cryptodev_count() == 0) {
printf("\nNo crypto devices found. Is PMD build configured?\n");
return TEST_FAILED;
}
/* Create Crypto session*/
sess = test_perf_create_libcrypto_session(ts_params->dev_id,
pparams->chain, pparams->cipher_algo,
pparams->cipher_key_length, pparams->auth_algo);
TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
/* Generate a burst of crypto operations */
for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
mbufs[i] = test_perf_create_pktmbuf(
ts_params->mbuf_mp,
pparams->buf_size);
if (mbufs[i] == NULL) {
printf("\nFailed to get mbuf - freeing the rest.\n");
for (k = 0; k < i; k++)
rte_pktmbuf_free(mbufs[k]);
return -1;
}
}
tsc_start = rte_rdtsc_precise();
while (total_enqueued < pparams->total_operations) {
uint16_t burst_size =
total_enqueued + pparams->burst_size <=
pparams->total_operations ? pparams->burst_size :
pparams->total_operations - total_enqueued;
uint16_t ops_needed = burst_size - ops_unused;
if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
printf("\nFailed to alloc enough ops, finish dequeuing "
"and free ops below.");
} else {
for (i = 0; i < ops_needed; i++)
ops[i] = test_perf_set_crypto_op(ops[i],
mbufs[i + (pparams->burst_size *
(j % NUM_MBUF_SETS))],
sess, pparams->buf_size, digest_length);
/* enqueue burst */
burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
queue_id, ops, burst_size);
if (burst_enqueued < burst_size)
retries++;
ops_unused = burst_size - burst_enqueued;
total_enqueued += burst_enqueued;
}
/* dequeue burst */
burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
proc_ops, pparams->burst_size);
if (burst_dequeued == 0)
failed_polls++;
else {
processed += burst_dequeued;
for (l = 0; l < burst_dequeued; l++)
rte_crypto_op_free(proc_ops[l]);
}
j++;
}
/* Dequeue any operations still in the crypto device */
while (processed < pparams->total_operations) {
/* Sending 0 length burst to flush sw crypto device */
rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
/* dequeue burst */
burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
proc_ops, pparams->burst_size);
if (burst_dequeued == 0)
failed_polls++;
else {
processed += burst_dequeued;
for (m = 0; m < burst_dequeued; m++)
rte_crypto_op_free(proc_ops[m]);
}
}
tsc_end = rte_rdtsc_precise();
double ops_s = ((double)processed / (tsc_end - tsc_start))
* rte_get_tsc_hz();
double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
/ 1000000000;
printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
ops_s / 1000000, throughput, retries, failed_polls);
for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
rte_pktmbuf_free(mbufs[i]);
printf("\n");
return TEST_SUCCESS;
}
/*
perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA1);
@ -2936,6 +3432,167 @@ test_perf_snow3G_vary_pkt_size(void)
return 0;
}
static int
test_perf_libcrypto_vary_pkt_size(void)
{
unsigned int total_operations = 1000000;
unsigned int burst_size = { 64 };
unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
1792, 2048 };
uint8_t i, j;
struct perf_test_params params_set[] = {
{
.chain = CIPHER_HASH,
.cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
.cipher_key_length = 16,
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
},
{
.chain = CIPHER_HASH,
.cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
.cipher_key_length = 24,
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
},
{
.chain = CIPHER_HASH,
.cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
.cipher_key_length = 16,
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
},
{
.chain = CIPHER_HASH,
.cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
.cipher_key_length = 32,
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
},
{
.chain = CIPHER_HASH,
.cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
.cipher_key_length = 16,
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
},
{
.chain = CIPHER_HASH,
.cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
.cipher_key_length = 24,
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
},
{
.chain = CIPHER_HASH,
.cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
.cipher_key_length = 16,
.auth_algo = RTE_CRYPTO_AUTH_AES_GCM
},
};
for (i = 0; i < RTE_DIM(params_set); i++) {
params_set[i].total_operations = total_operations;
params_set[i].burst_size = burst_size;
printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
" burst_size: %d ops\n",
chain_mode_name(params_set[i].chain),
cipher_algo_name(params_set[i].cipher_algo),
auth_algo_name(params_set[i].auth_algo),
params_set[i].cipher_key_length,
burst_size);
printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
"EmptyPolls\n");
for (j = 0; j < RTE_DIM(buf_lengths); j++) {
params_set[i].buf_size = buf_lengths[j];
test_perf_libcrypto(testsuite_params.dev_id, 0,
&params_set[i]);
}
}
return 0;
}
static int
test_perf_libcrypto_vary_burst_size(void)
{
unsigned int total_operations = 4096;
uint16_t buf_lengths[] = { 40 };
uint8_t i, j;
struct perf_test_params params_set[] = {
{
.chain = CIPHER_HASH,
.cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
.cipher_key_length = 16,
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
},
{
.chain = CIPHER_HASH,
.cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
.cipher_key_length = 24,
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
},
{
.chain = CIPHER_HASH,
.cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
.cipher_key_length = 16,
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
},
{
.chain = CIPHER_HASH,
.cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
.cipher_key_length = 32,
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
},
{
.chain = CIPHER_HASH,
.cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
.cipher_key_length = 16,
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
},
{
.chain = CIPHER_HASH,
.cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
.cipher_key_length = 24,
.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
},
{
.chain = CIPHER_HASH,
.cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
.cipher_key_length = 16,
.auth_algo = RTE_CRYPTO_AUTH_AES_GCM
},
};
printf("\n\nStart %s.", __func__);
printf("\nThis Test measures the average IA cycle cost using a "
"constant request(packet) size. ");
printf("Cycle cost is only valid when indicators show device is not"
" busy, i.e. Retries and EmptyPolls = 0");
for (i = 0; i < RTE_DIM(params_set); i++) {
printf("\n");
params_set[i].total_operations = total_operations;
for (j = 0; j < RTE_DIM(buf_lengths); j++) {
params_set[i].buf_size = buf_lengths[j];
test_perf_libcrypto_optimise_cyclecount(&params_set[i]);
}
}
return 0;
}
static int
test_perf_aes_cbc_vary_burst_size(void)
{
@ -3377,6 +4034,19 @@ static struct unit_test_suite cryptodev_snow3g_testsuite = {
}
};
static struct unit_test_suite cryptodev_libcrypto_testsuite = {
.suite_name = "Crypto Device LIBCRYPTO Unit Test Suite",
.setup = testsuite_setup,
.teardown = testsuite_teardown,
.unit_test_cases = {
TEST_CASE_ST(ut_setup, ut_teardown,
test_perf_libcrypto_vary_pkt_size),
TEST_CASE_ST(ut_setup, ut_teardown,
test_perf_libcrypto_vary_burst_size),
TEST_CASES_END() /**< NULL terminate unit test array */
}
};
static int
perftest_aesni_gcm_cryptodev(void)
{
@ -3417,8 +4087,18 @@ perftest_qat_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
}
static int
perftest_libcrypto_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
{
gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_LIBCRYPTO_PMD;
return unit_test_suite_runner(&cryptodev_libcrypto_testsuite);
}
REGISTER_TEST_COMMAND(cryptodev_aesni_mb_perftest, perftest_aesni_mb_cryptodev);
REGISTER_TEST_COMMAND(cryptodev_qat_perftest, perftest_qat_cryptodev);
REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_perftest, perftest_sw_snow3g_cryptodev);
REGISTER_TEST_COMMAND(cryptodev_qat_snow3g_perftest, perftest_qat_snow3g_cryptodev);
REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_perftest, perftest_aesni_gcm_cryptodev);
REGISTER_TEST_COMMAND(cryptodev_libcrypto_perftest,
perftest_libcrypto_cryptodev);