From patchwork Mon Aug 21 22:00:15 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Github ODP bot X-Patchwork-Id: 110594 Delivered-To: patch@linaro.org Received: by 10.182.109.195 with SMTP id hu3csp4587006obb; Mon, 21 Aug 2017 15:06:09 -0700 (PDT) X-Received: by 10.55.20.92 with SMTP id e89mr26695692qkh.304.1503353169359; Mon, 21 Aug 2017 15:06:09 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1503353169; cv=none; d=google.com; s=arc-20160816; b=MphAYEHN2SoO8yD27uhWbqlg5Rj7+U6r/GmJo5SayGCn3y53x8qGsg/dQOsbRSQEh6 qMqVpRMPyeS+rcs55TPB5v8ZIni3GP14C3HWnk+zJjRmR9n00ReIx+qgTeQzTMI/+SoT tDCZbZnnLBVpCN7ehoATg1DXg5K1Ux3y4Fa+3ycNTVx1H21uKxQBKTljaXv2EjBlydCG F4nYrWZzUcHpvXnlDiyuf2Kn91bBgWjKHc4EvfhtOEQZcmrMDh5hIT54+QNBLMyjCdwZ OE21C32GZmKLOPN1nIPRk359iEd+59k4nlytogBSmsP5YM3qwyTpBQtSpa/Xlvt2mgpA jzEw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:subject:github-pr-num :references:in-reply-to:message-id:date:to:from:delivered-to :arc-authentication-results; bh=QefuLTSJYyVmPJkMg76T9MFxeGaF6q6pbUXsBtV5Xuo=; b=MC64UDslu3yRvDevlwuX0pVKLdlf5arp3ODrWWicKAQJJMRQKCKRvNrcPDiWVPvrq5 msYSl54gfnPbgRnSujN46ov5L3DYEpqAVIbKcEqX0Qixf2FcDPvV0QVpqm5JPGIqxfUK 0fB0bxJqi9iP29952a3ZW7jlNkckb+7757LnIHK0gIxIt/ooSsEs5T2wh7y/2e/mUdmD iUuBtu5mljfWviXiXI9tRAPcn4ZovSDV3GRh1sxfTHtAHmMFapF1JExLgyal3cUHpXYT gnZKLo8izTQu2jFZ/4VpbQhwpS4cuFiEn6vNN3tExhC2MOzhejKrdwPYfkLWP0wnthDi 6fnw== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) smtp.mailfrom=lng-odp-bounces@lists.linaro.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=yandex.ru Return-Path: Received: from lists.linaro.org (lists.linaro.org. [54.225.227.206]) by mx.google.com with ESMTP id 21si12562545qtw.554.2017.08.21.15.06.09; Mon, 21 Aug 2017 15:06:09 -0700 (PDT) Received-SPF: pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) client-ip=54.225.227.206; Authentication-Results: mx.google.com; spf=pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) smtp.mailfrom=lng-odp-bounces@lists.linaro.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=yandex.ru Received: by lists.linaro.org (Postfix, from userid 109) id DE02F6071D; Mon, 21 Aug 2017 22:06:08 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on ip-10-142-244-252 X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,URIBL_BLOCKED autolearn=disabled version=3.4.0 Received: from [127.0.0.1] (localhost [127.0.0.1]) by lists.linaro.org (Postfix) with ESMTP id 9343964495; Mon, 21 Aug 2017 22:02:14 +0000 (UTC) X-Original-To: lng-odp@lists.linaro.org Delivered-To: lng-odp@lists.linaro.org Received: by lists.linaro.org (Postfix, from userid 109) id 88725644A7; Mon, 21 Aug 2017 22:01:50 +0000 (UTC) Received: from forward102j.mail.yandex.net (forward102j.mail.yandex.net [5.45.198.243]) by lists.linaro.org (Postfix) with ESMTPS id 7187164495 for ; Mon, 21 Aug 2017 22:00:22 +0000 (UTC) Received: from mxback10o.mail.yandex.net (mxback10o.mail.yandex.net [IPv6:2a02:6b8:0:1a2d::24]) by forward102j.mail.yandex.net (Yandex) with ESMTP id 2EA5C5604618 for ; Tue, 22 Aug 2017 01:00:21 +0300 (MSK) Received: from smtp4p.mail.yandex.net (smtp4p.mail.yandex.net [2a02:6b8:0:1402::15:6]) by mxback10o.mail.yandex.net (nwsmtp/Yandex) with ESMTP id nIWRrWyLcu-0LpajD7C; Tue, 22 Aug 2017 01:00:21 +0300 Received: by smtp4p.mail.yandex.net (nwsmtp/Yandex) with ESMTPSA id 1rAWfL7pdM-0JhWBBIv; Tue, 22 Aug 2017 01:00:19 +0300 (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (Client certificate not present) From: Github ODP bot To: lng-odp@lists.linaro.org Date: Tue, 22 Aug 2017 01:00:15 +0300 Message-Id: <1503352817-2136-2-git-send-email-odpbot@yandex.ru> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1503352817-2136-1-git-send-email-odpbot@yandex.ru> References: <1503352817-2136-1-git-send-email-odpbot@yandex.ru> Github-pr-num: 94 Subject: [lng-odp] [PATCH API-NEXT v5 1/3] validation: crypto: rework testsuite X-BeenThere: lng-odp@lists.linaro.org X-Mailman-Version: 2.1.16 Precedence: list List-Id: "The OpenDataPlane \(ODP\) List" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: lng-odp-bounces@lists.linaro.org Sender: "lng-odp" From: Dmitry Eremin-Solenikov Currently crypto testsuite contains tons of similar c&p code setting keys, iv, data, etc. Data is scattered into different arrays. Refactor crypto testsuite so that all data is kept in the structured way, removing most of similar code from individual testing functions. Signed-off-by: Dmitry Eremin-Solenikov --- /** Email created from pull request 94 (lumag:crypto-long-keys) ** https://github.com/Linaro/odp/pull/94 ** Patch: https://github.com/Linaro/odp/pull/94.patch ** Base sha: 3547226b19e6982bf74fc8c258b89db2c5f6a39c ** Merge commit sha: 639b51978ac4cd2c4db537873fee719de65e575b **/ .../validation/api/crypto/odp_crypto_test_inp.c | 1084 ++++---------------- .../validation/api/crypto/test_vectors.h | 888 ++++++++-------- .../validation/api/crypto/test_vectors_len.h | 23 +- 3 files changed, 686 insertions(+), 1309 deletions(-) diff --git a/test/common_plat/validation/api/crypto/odp_crypto_test_inp.c b/test/common_plat/validation/api/crypto/odp_crypto_test_inp.c index df4ac0c4..5b41e2ba 100644 --- a/test/common_plat/validation/api/crypto/odp_crypto_test_inp.c +++ b/test/common_plat/validation/api/crypto/odp_crypto_test_inp.c @@ -23,6 +23,16 @@ struct suite_context_s { static struct suite_context_s suite_context; +static int packet_cmp_mem(odp_packet_t pkt, uint32_t offset, + void *s, uint32_t len) +{ + uint8_t buf[len]; + + odp_packet_copy_to_mem(pkt, offset, len, buf); + + return memcmp(buf, s, len); +} + static const char *auth_alg_name(odp_auth_alg_t auth) { switch (auth) { @@ -71,7 +81,7 @@ static int alg_op(odp_packet_t pkt, uint32_t aad_len, unsigned int plaintext_len) { - int data_off = 0, rc; + int rc; odp_crypto_op_result_t result; odp_crypto_op_param_t op_params; odp_bool_t posted; @@ -84,19 +94,8 @@ static int alg_op(odp_packet_t pkt, op_params.out_pkt = pkt; op_params.ctx = (void *)0xdeadbeef; - if (cipher_range) { - op_params.cipher_range = *cipher_range; - data_off = cipher_range->offset; - } else { - op_params.cipher_range.offset = data_off; - op_params.cipher_range.length = plaintext_len; - } - if (auth_range) { - op_params.auth_range = *auth_range; - } else { - op_params.auth_range.offset = data_off; - op_params.auth_range.length = plaintext_len; - } + op_params.cipher_range = *cipher_range; + op_params.auth_range = *auth_range; if (op_iv_ptr) op_params.override_iv_ptr = op_iv_ptr; @@ -159,7 +158,7 @@ static int alg_packet_op(odp_packet_t pkt, uint32_t aad_len, unsigned int plaintext_len) { - int data_off = 0, rc; + int rc; odp_crypto_packet_result_t result; odp_crypto_packet_op_param_t op_params; odp_event_subtype_t subtype; @@ -169,19 +168,8 @@ static int alg_packet_op(odp_packet_t pkt, memset(&op_params, 0, sizeof(op_params)); op_params.session = session; - if (cipher_range) { - op_params.cipher_range = *cipher_range; - data_off = cipher_range->offset; - } else { - op_params.cipher_range.offset = data_off; - op_params.cipher_range.length = plaintext_len; - } - if (auth_range) { - op_params.auth_range = *auth_range; - } else { - op_params.auth_range.offset = data_off; - op_params.auth_range.length = plaintext_len; - } + op_params.cipher_range = *cipher_range; + op_params.auth_range = *auth_range; if (op_iv_ptr) op_params.override_iv_ptr = op_iv_ptr; @@ -226,7 +214,7 @@ static int alg_packet_op_enq(odp_packet_t pkt, uint32_t aad_len, unsigned int plaintext_len) { - int data_off = 0, rc; + int rc; odp_event_t event; odp_crypto_packet_result_t result; odp_crypto_packet_op_param_t op_params; @@ -237,19 +225,8 @@ static int alg_packet_op_enq(odp_packet_t pkt, memset(&op_params, 0, sizeof(op_params)); op_params.session = session; - if (cipher_range) { - op_params.cipher_range = *cipher_range; - data_off = cipher_range->offset; - } else { - op_params.cipher_range.offset = data_off; - op_params.cipher_range.length = plaintext_len; - } - if (auth_range) { - op_params.auth_range = *auth_range; - } else { - op_params.auth_range.offset = data_off; - op_params.auth_range.length = plaintext_len; - } + op_params.cipher_range = *cipher_range; + op_params.auth_range = *auth_range; if (op_iv_ptr) op_params.override_iv_ptr = op_iv_ptr; @@ -306,33 +283,34 @@ static int alg_packet_op_enq(odp_packet_t pkt, * buffer can be used. * */ static void alg_test(odp_crypto_op_t op, - odp_bool_t should_fail, odp_cipher_alg_t cipher_alg, - odp_crypto_iv_t ses_iv, - uint8_t *op_iv_ptr, - odp_crypto_key_t cipher_key, odp_auth_alg_t auth_alg, - odp_crypto_key_t auth_key, - odp_packet_data_range_t *cipher_range, - odp_packet_data_range_t *auth_range, - uint8_t *aad, - uint32_t aad_len, - const uint8_t *plaintext, - unsigned int plaintext_len, - const uint8_t *ciphertext, - unsigned int ciphertext_len, - const uint8_t *digest, - uint32_t digest_len) + crypto_test_reference_t *ref, + odp_bool_t ovr_iv) { odp_crypto_session_t session; odp_crypto_capability_t capa; int rc; odp_crypto_ses_create_err_t status; odp_bool_t ok = false; + odp_bool_t should_fail = false; odp_crypto_session_param_t ses_params; - uint8_t *data_addr; odp_crypto_cipher_capability_t cipher_capa[MAX_ALG_CAPA]; odp_crypto_auth_capability_t auth_capa[MAX_ALG_CAPA]; + odp_packet_data_range_t cipher_range; + odp_packet_data_range_t auth_range; + odp_crypto_key_t cipher_key = { + .data = ref->cipher_key, + .length = ref->cipher_key_length + }; + odp_crypto_key_t auth_key = { + .data = ref->auth_key, + .length = ref->auth_key_length + }; + odp_crypto_iv_t iv = { + .data = ovr_iv ? NULL : ref->iv, + .length = ref->iv_length + }; int num, i; int found; @@ -394,13 +372,18 @@ static void alg_test(odp_crypto_op_t op, /* Search for the test case */ for (i = 0; i < num; i++) { if (cipher_capa[i].key_len == cipher_key.length && - cipher_capa[i].iv_len == ses_iv.length) { + cipher_capa[i].iv_len == iv.length) { found = 1; break; } } - CU_ASSERT(found); + if (!found) { + printf("\n Unsupported: alg=%s, key_len=%" PRIu32 ", " + "iv_len=%" PRIu32 "\n", cipher_alg_name(cipher_alg), + cipher_key.length, iv.length); + return; + } num = odp_crypto_auth_capability(auth_alg, auth_capa, MAX_ALG_CAPA); @@ -414,14 +397,19 @@ static void alg_test(odp_crypto_op_t op, /* Search for the test case */ for (i = 0; i < num; i++) { - if (auth_capa[i].digest_len == digest_len && + if (auth_capa[i].digest_len == ref->digest_length && auth_capa[i].key_len == auth_key.length) { found = 1; break; } } - CU_ASSERT(found); + if (!found) { + printf("\n Unsupported: alg=%s, key_len=%" PRIu32 ", " + "digest_len=%" PRIu32 "\n", auth_alg_name(auth_alg), + auth_key.length, ref->digest_length); + return; + } /* Create a crypto session */ odp_crypto_session_param_init(&ses_params); @@ -434,9 +422,9 @@ static void alg_test(odp_crypto_op_t op, ses_params.compl_queue = suite_context.queue; ses_params.output_pool = suite_context.pool; ses_params.cipher_key = cipher_key; - ses_params.iv = ses_iv; + ses_params.iv = iv; ses_params.auth_key = auth_key; - ses_params.auth_digest_len = digest_len; + ses_params.auth_digest_len = ref->digest_length; rc = odp_crypto_session_create(&ses_params, &session, &status); CU_ASSERT_FATAL(!rc); @@ -444,29 +432,49 @@ static void alg_test(odp_crypto_op_t op, CU_ASSERT(odp_crypto_session_to_u64(session) != odp_crypto_session_to_u64(ODP_CRYPTO_SESSION_INVALID)); + cipher_range.offset = 0; + cipher_range.length = ref->length; + auth_range.offset = 0; + auth_range.length = ref->length; + /* Prepare input data */ odp_packet_t pkt = odp_packet_alloc(suite_context.pool, - plaintext_len + digest_len); + ref->length + ref->digest_length); CU_ASSERT(pkt != ODP_PACKET_INVALID); - data_addr = odp_packet_data(pkt); - memcpy(data_addr, plaintext, plaintext_len); - if (0 != digest_len) { - memcpy(data_addr + plaintext_len, - digest, digest_len); +restart: + if (op == ODP_CRYPTO_OP_ENCODE) { + odp_packet_copy_from_mem(pkt, 0, ref->length, ref->plaintext); + } else { + odp_packet_copy_from_mem(pkt, 0, ref->length, ref->ciphertext); + odp_packet_copy_from_mem(pkt, ref->length, + ref->digest_length, + ref->digest); + if (should_fail) { + uint8_t byte = ~ref->digest[0]; + + odp_packet_copy_from_mem(pkt, ref->length, + 1, &byte); + } } if (!suite_context.packet) - rc = alg_op(pkt, &ok, session, op_iv_ptr, - cipher_range, auth_range, aad, aad_len, - plaintext_len); + rc = alg_op(pkt, &ok, session, + ovr_iv ? ref->iv : NULL, + &cipher_range, &auth_range, + ref->aad, ref->aad_length, + ref->length); else if (ODP_CRYPTO_ASYNC == suite_context.op_mode) - rc = alg_packet_op_enq(pkt, &ok, session, op_iv_ptr, - cipher_range, auth_range, aad, aad_len, - plaintext_len); + rc = alg_packet_op_enq(pkt, &ok, session, + ovr_iv ? ref->iv : NULL, + &cipher_range, &auth_range, + ref->aad, ref->aad_length, + ref->length); else - rc = alg_packet_op(pkt, &ok, session, op_iv_ptr, - cipher_range, auth_range, aad, aad_len, - plaintext_len); + rc = alg_packet_op(pkt, &ok, session, + ovr_iv ? ref->iv : NULL, + &cipher_range, &auth_range, + ref->aad, ref->aad_length, + ref->length); if (rc < 0) { goto cleanup; } @@ -478,13 +486,23 @@ static void alg_test(odp_crypto_op_t op, CU_ASSERT(ok); - data_addr = odp_packet_data(pkt); - if (cipher_alg != ODP_CIPHER_ALG_NULL) - CU_ASSERT(!memcmp(data_addr, ciphertext, ciphertext_len)); + if (op == ODP_CRYPTO_OP_ENCODE) { + CU_ASSERT(!packet_cmp_mem(pkt, 0, + ref->ciphertext, + ref->length)); + CU_ASSERT(!packet_cmp_mem(pkt, ref->length, + ref->digest, + ref->digest_length)); + } else { + CU_ASSERT(!packet_cmp_mem(pkt, 0, + ref->plaintext, + ref->length)); + if (ref->digest_length != 0) { + should_fail = true; + goto restart; + } + } - if (op == ODP_CRYPTO_OP_ENCODE && auth_alg != ODP_AUTH_ALG_NULL) - CU_ASSERT(!memcmp(data_addr + plaintext_len, - digest, digest_len)); cleanup: rc = odp_crypto_session_destroy(session); CU_ASSERT(!rc); @@ -569,76 +587,6 @@ static int check_alg_support(odp_cipher_alg_t cipher, odp_auth_alg_t auth) return ODP_TEST_ACTIVE; } -/** - * Check if given cipher options are supported - * - * @param cipher Cipher algorithm - * @param key_len Key length - * @param iv_len IV length - * - * @retval non-zero if both cipher options are supported - * @retval 0 if both options are not supported - */ -static int check_cipher_options(odp_cipher_alg_t cipher, uint32_t key_len, - uint32_t iv_len) -{ - int i; - int num; - odp_crypto_cipher_capability_t cipher_capa[MAX_ALG_CAPA]; - - num = odp_crypto_cipher_capability(cipher, cipher_capa, MAX_ALG_CAPA); - CU_ASSERT_FATAL(num >= 1); - - for (i = 0; i < num; i++) { - if (key_len == cipher_capa[i].key_len && - iv_len == cipher_capa[i].iv_len) - break; - } - - if (i == num) { - printf("\n Unsupported: alg=%s, key_len=%" PRIu32 ", " - "iv_len=%" PRIu32 "\n", cipher_alg_name(cipher), key_len, - iv_len); - return 0; - } - return 1; -} - -/** - * Check if given authentication options are supported - * - * @param auth Authentication algorithm - * @param key_len Key length - * @param digest_len Digest length - * - * @retval non-zero if both authentication options are supported - * @retval 0 if both options are not supported - */ -static int check_auth_options(odp_auth_alg_t auth, uint32_t key_len, - uint32_t digest_len) -{ - int i; - int num; - odp_crypto_auth_capability_t capa[MAX_ALG_CAPA]; - - num = odp_crypto_auth_capability(auth, capa, MAX_ALG_CAPA); - CU_ASSERT_FATAL(num >= 1); - - for (i = 0; i < num; i++) { - if (key_len == capa[i].key_len && - digest_len == capa[i].digest_len) - break; - } - - if (i == num) { - printf("\n Unsupported: alg=%s, key_len=%" PRIu32 ", " - "digest_len=%" PRIu32 "\n", auth_alg_name(auth), key_len, - digest_len); - return 0; - } - return 1; -} - static int check_alg_null(void) { return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_NULL); @@ -646,64 +594,30 @@ static int check_alg_null(void) void crypto_test_enc_alg_null(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = 0}; - unsigned int test_vec_num = (sizeof(null_reference_length) / - sizeof(null_reference_length[0])); + unsigned int test_vec_num = (sizeof(null_reference) / + sizeof(null_reference[0])); unsigned int i; - for (i = 0; i < test_vec_num; i++) { - if (!check_cipher_options(ODP_CIPHER_ALG_NULL, - cipher_key.length, iv.length)) - continue; - + for (i = 0; i < test_vec_num; i++) alg_test(ODP_CRYPTO_OP_ENCODE, - 0, ODP_CIPHER_ALG_NULL, - iv, - NULL, - cipher_key, ODP_AUTH_ALG_NULL, - auth_key, - NULL, NULL, - NULL, 0, - null_reference_plaintext[i], - null_reference_length[i], - null_reference_plaintext[i], - null_reference_length[i], NULL, 0); - } + &null_reference[i], + false); } void crypto_test_dec_alg_null(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = 0 }; - unsigned int test_vec_num = (sizeof(null_reference_length) / - sizeof(null_reference_length[0])); + unsigned int test_vec_num = (sizeof(null_reference) / + sizeof(null_reference[0])); unsigned int i; - for (i = 0; i < test_vec_num; i++) { - if (!check_cipher_options(ODP_CIPHER_ALG_NULL, - cipher_key.length, iv.length)) - continue; - + for (i = 0; i < test_vec_num; i++) alg_test(ODP_CRYPTO_OP_DECODE, - 0, ODP_CIPHER_ALG_NULL, - iv, - NULL, - cipher_key, ODP_AUTH_ALG_NULL, - auth_key, - NULL, NULL, - NULL, 0, - null_reference_plaintext[i], - null_reference_length[i], - null_reference_plaintext[i], - null_reference_length[i], NULL, 0); - } + &null_reference[i], + false); } static int check_alg_3des_cbc(void) @@ -717,38 +631,16 @@ static int check_alg_3des_cbc(void) * packet buffer as completion event buffer.*/ void crypto_test_enc_alg_3des_cbc(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv; - unsigned int test_vec_num = (sizeof(tdes_cbc_reference_length) / - sizeof(tdes_cbc_reference_length[0])); + unsigned int test_vec_num = (sizeof(tdes_cbc_reference) / + sizeof(tdes_cbc_reference[0])); unsigned int i; - for (i = 0; i < test_vec_num; i++) { - cipher_key.data = tdes_cbc_reference_key[i]; - cipher_key.length = sizeof(tdes_cbc_reference_key[i]); - iv.data = tdes_cbc_reference_iv[i]; - iv.length = sizeof(tdes_cbc_reference_iv[i]); - - if (!check_cipher_options(ODP_CIPHER_ALG_3DES_CBC, - cipher_key.length, iv.length)) - continue; - + for (i = 0; i < test_vec_num; i++) alg_test(ODP_CRYPTO_OP_ENCODE, - 0, ODP_CIPHER_ALG_3DES_CBC, - iv, - NULL, - cipher_key, ODP_AUTH_ALG_NULL, - auth_key, - NULL, NULL, - NULL, 0, - tdes_cbc_reference_plaintext[i], - tdes_cbc_reference_length[i], - tdes_cbc_reference_ciphertext[i], - tdes_cbc_reference_length[i], NULL, 0); - } + &tdes_cbc_reference[i], + false); } /* This test verifies the correctness of encode (plaintext -> ciphertext) @@ -756,36 +648,16 @@ void crypto_test_enc_alg_3des_cbc(void) * */ void crypto_test_enc_alg_3des_cbc_ovr_iv(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = TDES_CBC_IV_LEN }; - unsigned int test_vec_num = (sizeof(tdes_cbc_reference_length) / - sizeof(tdes_cbc_reference_length[0])); + unsigned int test_vec_num = (sizeof(tdes_cbc_reference) / + sizeof(tdes_cbc_reference[0])); unsigned int i; - for (i = 0; i < test_vec_num; i++) { - cipher_key.data = tdes_cbc_reference_key[i]; - cipher_key.length = sizeof(tdes_cbc_reference_key[i]); - - if (!check_cipher_options(ODP_CIPHER_ALG_3DES_CBC, - cipher_key.length, iv.length)) - continue; - + for (i = 0; i < test_vec_num; i++) alg_test(ODP_CRYPTO_OP_ENCODE, - 0, ODP_CIPHER_ALG_3DES_CBC, - iv, - tdes_cbc_reference_iv[i], - cipher_key, ODP_AUTH_ALG_NULL, - auth_key, - NULL, NULL, - NULL, 0, - tdes_cbc_reference_plaintext[i], - tdes_cbc_reference_length[i], - tdes_cbc_reference_ciphertext[i], - tdes_cbc_reference_length[i], NULL, 0); - } + &tdes_cbc_reference[i], + true); } /* This test verifies the correctness of decode (ciphertext -> plaintext) @@ -795,38 +667,16 @@ void crypto_test_enc_alg_3des_cbc_ovr_iv(void) * */ void crypto_test_dec_alg_3des_cbc(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = 0 }; - unsigned int test_vec_num = (sizeof(tdes_cbc_reference_length) / - sizeof(tdes_cbc_reference_length[0])); + unsigned int test_vec_num = (sizeof(tdes_cbc_reference) / + sizeof(tdes_cbc_reference[0])); unsigned int i; - for (i = 0; i < test_vec_num; i++) { - cipher_key.data = tdes_cbc_reference_key[i]; - cipher_key.length = sizeof(tdes_cbc_reference_key[i]); - iv.data = tdes_cbc_reference_iv[i]; - iv.length = sizeof(tdes_cbc_reference_iv[i]); - - if (!check_cipher_options(ODP_CIPHER_ALG_3DES_CBC, - cipher_key.length, iv.length)) - continue; - + for (i = 0; i < test_vec_num; i++) alg_test(ODP_CRYPTO_OP_DECODE, - 0, ODP_CIPHER_ALG_3DES_CBC, - iv, - NULL, - cipher_key, ODP_AUTH_ALG_NULL, - auth_key, - NULL, NULL, - NULL, 0, - tdes_cbc_reference_ciphertext[i], - tdes_cbc_reference_length[i], - tdes_cbc_reference_plaintext[i], - tdes_cbc_reference_length[i], NULL, 0); - } + &tdes_cbc_reference[i], + false); } /* This test verifies the correctness of decode (ciphertext -> plaintext) @@ -836,36 +686,16 @@ void crypto_test_dec_alg_3des_cbc(void) * */ void crypto_test_dec_alg_3des_cbc_ovr_iv(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = TDES_CBC_IV_LEN }; - unsigned int test_vec_num = (sizeof(tdes_cbc_reference_length) / - sizeof(tdes_cbc_reference_length[0])); + unsigned int test_vec_num = (sizeof(tdes_cbc_reference) / + sizeof(tdes_cbc_reference[0])); unsigned int i; - for (i = 0; i < test_vec_num; i++) { - cipher_key.data = tdes_cbc_reference_key[i]; - cipher_key.length = sizeof(tdes_cbc_reference_key[i]); - - if (!check_cipher_options(ODP_CIPHER_ALG_3DES_CBC, - cipher_key.length, iv.length)) - continue; - + for (i = 0; i < test_vec_num; i++) alg_test(ODP_CRYPTO_OP_DECODE, - 0, ODP_CIPHER_ALG_3DES_CBC, - iv, - tdes_cbc_reference_iv[i], - cipher_key, ODP_AUTH_ALG_NULL, - auth_key, - NULL, NULL, - NULL, 0, - tdes_cbc_reference_ciphertext[i], - tdes_cbc_reference_length[i], - tdes_cbc_reference_plaintext[i], - tdes_cbc_reference_length[i], NULL, 0); - } + &tdes_cbc_reference[i], + true); } static int check_alg_aes_gcm(void) @@ -879,46 +709,16 @@ static int check_alg_aes_gcm(void) * packet buffer as completion event buffer.*/ void crypto_test_enc_alg_aes128_gcm(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = AES128_GCM_IV_LEN }; - unsigned int test_vec_num = (sizeof(aes128_gcm_reference_length) / - sizeof(aes128_gcm_reference_length[0])); + unsigned int test_vec_num = (sizeof(aes128_gcm_reference) / + sizeof(aes128_gcm_reference[0])); unsigned int i; for (i = 0; i < test_vec_num; i++) { - cipher_key.data = aes128_gcm_reference_key[i]; - cipher_key.length = sizeof(aes128_gcm_reference_key[i]); - iv.data = aes128_gcm_reference_iv[i]; - iv.length = sizeof(aes128_gcm_reference_iv[i]); - - if (!check_cipher_options(ODP_CIPHER_ALG_AES_GCM, - cipher_key.length, iv.length)) - continue; - if (!check_auth_options(ODP_AUTH_ALG_AES_GCM, - auth_key.length, - aes128_gcm_reference_tag_length[i])) - continue; - alg_test(ODP_CRYPTO_OP_ENCODE, - 0, ODP_CIPHER_ALG_AES_GCM, - iv, - NULL, - cipher_key, ODP_AUTH_ALG_AES_GCM, - auth_key, - &aes128_gcm_cipher_range[i], - &aes128_gcm_cipher_range[i], - aes128_gcm_reference_aad[i], - aes128_gcm_reference_aad_length[i], - aes128_gcm_reference_plaintext[i], - aes128_gcm_reference_length[i], - aes128_gcm_reference_ciphertext[i], - aes128_gcm_reference_length[i], - aes128_gcm_reference_ciphertext[i] + - aes128_gcm_reference_length[i], - aes128_gcm_reference_tag_length[i]); + &aes128_gcm_reference[i], + false); } } @@ -928,44 +728,16 @@ void crypto_test_enc_alg_aes128_gcm(void) * packet buffer as completion event buffer.*/ void crypto_test_enc_alg_aes128_gcm_ovr_iv(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = AES128_GCM_IV_LEN }; - unsigned int test_vec_num = (sizeof(aes128_gcm_reference_length) / - sizeof(aes128_gcm_reference_length[0])); + unsigned int test_vec_num = (sizeof(aes128_gcm_reference) / + sizeof(aes128_gcm_reference[0])); unsigned int i; for (i = 0; i < test_vec_num; i++) { - cipher_key.data = aes128_gcm_reference_key[i]; - cipher_key.length = sizeof(aes128_gcm_reference_key[i]); - - if (!check_cipher_options(ODP_CIPHER_ALG_AES_GCM, - cipher_key.length, iv.length)) - continue; - if (!check_auth_options(ODP_AUTH_ALG_AES_GCM, - auth_key.length, - aes128_gcm_reference_tag_length[i])) - continue; - alg_test(ODP_CRYPTO_OP_ENCODE, - 0, ODP_CIPHER_ALG_AES_GCM, - iv, - aes128_gcm_reference_iv[i], - cipher_key, ODP_AUTH_ALG_AES_GCM, - auth_key, - &aes128_gcm_cipher_range[i], - &aes128_gcm_cipher_range[i], - aes128_gcm_reference_aad[i], - aes128_gcm_reference_aad_length[i], - aes128_gcm_reference_plaintext[i], - aes128_gcm_reference_length[i], - aes128_gcm_reference_ciphertext[i], - aes128_gcm_reference_length[i], - aes128_gcm_reference_ciphertext[i] + - aes128_gcm_reference_length[i], - aes128_gcm_reference_tag_length[i]); + &aes128_gcm_reference[i], + true); } } @@ -976,68 +748,16 @@ void crypto_test_enc_alg_aes128_gcm_ovr_iv(void) * */ void crypto_test_dec_alg_aes128_gcm(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = AES128_GCM_IV_LEN }; - uint8_t wrong_digest[AES128_GCM_DIGEST_LEN]; - unsigned int test_vec_num = (sizeof(aes128_gcm_reference_length) / - sizeof(aes128_gcm_reference_length[0])); + unsigned int test_vec_num = (sizeof(aes128_gcm_reference) / + sizeof(aes128_gcm_reference[0])); unsigned int i; - memset(wrong_digest, 0xa5, sizeof(wrong_digest)); - for (i = 0; i < test_vec_num; i++) { - cipher_key.data = aes128_gcm_reference_key[i]; - cipher_key.length = sizeof(aes128_gcm_reference_key[i]); - iv.data = aes128_gcm_reference_iv[i]; - iv.length = sizeof(aes128_gcm_reference_iv[i]); - - if (!check_cipher_options(ODP_CIPHER_ALG_AES_GCM, - cipher_key.length, iv.length)) - continue; - if (!check_auth_options(ODP_AUTH_ALG_AES_GCM, - auth_key.length, - aes128_gcm_reference_tag_length[i])) - continue; - alg_test(ODP_CRYPTO_OP_DECODE, - 0, ODP_CIPHER_ALG_AES_GCM, - iv, - NULL, - cipher_key, ODP_AUTH_ALG_AES_GCM, - auth_key, - &aes128_gcm_cipher_range[i], - &aes128_gcm_cipher_range[i], - aes128_gcm_reference_aad[i], - aes128_gcm_reference_aad_length[i], - aes128_gcm_reference_ciphertext[i], - aes128_gcm_reference_length[i], - aes128_gcm_reference_plaintext[i], - aes128_gcm_reference_length[i], - aes128_gcm_reference_ciphertext[i] + - aes128_gcm_reference_length[i], - aes128_gcm_reference_tag_length[i]); - - alg_test(ODP_CRYPTO_OP_DECODE, - 1, - ODP_CIPHER_ALG_AES_GCM, - iv, - NULL, - cipher_key, - ODP_AUTH_ALG_AES_GCM, - auth_key, - &aes128_gcm_cipher_range[i], - &aes128_gcm_cipher_range[i], - aes128_gcm_reference_aad[i], - aes128_gcm_reference_aad_length[i], - aes128_gcm_reference_ciphertext[i], - aes128_gcm_reference_length[i], - aes128_gcm_reference_plaintext[i], - aes128_gcm_reference_length[i], - wrong_digest, - aes128_gcm_reference_tag_length[i]); + &aes128_gcm_reference[i], + false); } } @@ -1048,66 +768,16 @@ void crypto_test_dec_alg_aes128_gcm(void) * */ void crypto_test_dec_alg_aes128_gcm_ovr_iv(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = AES128_GCM_IV_LEN }; - uint8_t wrong_digest[AES128_GCM_DIGEST_LEN]; - unsigned int test_vec_num = (sizeof(aes128_gcm_reference_length) / - sizeof(aes128_gcm_reference_length[0])); + unsigned int test_vec_num = (sizeof(aes128_gcm_reference) / + sizeof(aes128_gcm_reference[0])); unsigned int i; - memset(wrong_digest, 0xa5, sizeof(wrong_digest)); - for (i = 0; i < test_vec_num; i++) { - cipher_key.data = aes128_gcm_reference_key[i]; - cipher_key.length = sizeof(aes128_gcm_reference_key[i]); - - if (!check_cipher_options(ODP_CIPHER_ALG_AES_GCM, - cipher_key.length, iv.length)) - continue; - if (!check_auth_options(ODP_AUTH_ALG_AES_GCM, - auth_key.length, - aes128_gcm_reference_tag_length[i])) - continue; - - alg_test(ODP_CRYPTO_OP_DECODE, - 0, - ODP_CIPHER_ALG_AES_GCM, - iv, - aes128_gcm_reference_iv[i], - cipher_key, - ODP_AUTH_ALG_AES_GCM, - auth_key, - &aes128_gcm_cipher_range[i], - &aes128_gcm_cipher_range[i], - aes128_gcm_reference_aad[i], - aes128_gcm_reference_aad_length[i], - aes128_gcm_reference_ciphertext[i], - aes128_gcm_reference_length[i], - aes128_gcm_reference_plaintext[i], - aes128_gcm_reference_length[i], - aes128_gcm_reference_ciphertext[i] + - aes128_gcm_reference_length[i], - aes128_gcm_reference_tag_length[i]); - alg_test(ODP_CRYPTO_OP_DECODE, - 1, ODP_CIPHER_ALG_AES_GCM, - iv, - aes128_gcm_reference_iv[i], - cipher_key, ODP_AUTH_ALG_AES_GCM, - auth_key, - &aes128_gcm_cipher_range[i], - &aes128_gcm_cipher_range[i], - aes128_gcm_reference_aad[i], - aes128_gcm_reference_aad_length[i], - aes128_gcm_reference_ciphertext[i], - aes128_gcm_reference_length[i], - aes128_gcm_reference_plaintext[i], - aes128_gcm_reference_length[i], - wrong_digest, - aes128_gcm_reference_tag_length[i]); + &aes128_gcm_reference[i], + true); } } @@ -1122,37 +792,16 @@ static int check_alg_aes_cbc(void) * packet buffer as completion event buffer.*/ void crypto_test_enc_alg_aes128_cbc(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv; - unsigned int test_vec_num = (sizeof(aes128_cbc_reference_length) / - sizeof(aes128_cbc_reference_length[0])); + unsigned int test_vec_num = (sizeof(aes128_cbc_reference) / + sizeof(aes128_cbc_reference[0])); unsigned int i; for (i = 0; i < test_vec_num; i++) { - cipher_key.data = aes128_cbc_reference_key[i]; - cipher_key.length = sizeof(aes128_cbc_reference_key[i]); - iv.data = aes128_cbc_reference_iv[i]; - iv.length = sizeof(aes128_cbc_reference_iv[i]); - - if (!check_cipher_options(ODP_CIPHER_ALG_AES_CBC, - cipher_key.length, iv.length)) - continue; - alg_test(ODP_CRYPTO_OP_ENCODE, - 0, ODP_CIPHER_ALG_AES_CBC, - iv, - NULL, - cipher_key, ODP_AUTH_ALG_NULL, - auth_key, - NULL, NULL, - NULL, 0, - aes128_cbc_reference_plaintext[i], - aes128_cbc_reference_length[i], - aes128_cbc_reference_ciphertext[i], - aes128_cbc_reference_length[i], NULL, 0); + &aes128_cbc_reference[i], + false); } } @@ -1161,35 +810,16 @@ void crypto_test_enc_alg_aes128_cbc(void) * */ void crypto_test_enc_alg_aes128_cbc_ovr_iv(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = AES128_CBC_IV_LEN }; - unsigned int test_vec_num = (sizeof(aes128_cbc_reference_length) / - sizeof(aes128_cbc_reference_length[0])); + unsigned int test_vec_num = (sizeof(aes128_cbc_reference) / + sizeof(aes128_cbc_reference[0])); unsigned int i; for (i = 0; i < test_vec_num; i++) { - cipher_key.data = aes128_cbc_reference_key[i]; - cipher_key.length = sizeof(aes128_cbc_reference_key[i]); - - if (!check_cipher_options(ODP_CIPHER_ALG_AES_CBC, - cipher_key.length, iv.length)) - continue; - alg_test(ODP_CRYPTO_OP_ENCODE, - 0, ODP_CIPHER_ALG_AES_CBC, - iv, - aes128_cbc_reference_iv[i], - cipher_key, ODP_AUTH_ALG_NULL, - auth_key, - NULL, NULL, - NULL, 0, - aes128_cbc_reference_plaintext[i], - aes128_cbc_reference_length[i], - aes128_cbc_reference_ciphertext[i], - aes128_cbc_reference_length[i], NULL, 0); + &aes128_cbc_reference[i], + true); } } @@ -1200,37 +830,16 @@ void crypto_test_enc_alg_aes128_cbc_ovr_iv(void) * */ void crypto_test_dec_alg_aes128_cbc(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = 0 }; - unsigned int test_vec_num = (sizeof(aes128_cbc_reference_length) / - sizeof(aes128_cbc_reference_length[0])); + unsigned int test_vec_num = (sizeof(aes128_cbc_reference) / + sizeof(aes128_cbc_reference[0])); unsigned int i; for (i = 0; i < test_vec_num; i++) { - cipher_key.data = aes128_cbc_reference_key[i]; - cipher_key.length = sizeof(aes128_cbc_reference_key[i]); - iv.data = aes128_cbc_reference_iv[i]; - iv.length = sizeof(aes128_cbc_reference_iv[i]); - - if (!check_cipher_options(ODP_CIPHER_ALG_AES_CBC, - cipher_key.length, iv.length)) - continue; - alg_test(ODP_CRYPTO_OP_DECODE, - 0, ODP_CIPHER_ALG_AES_CBC, - iv, - NULL, - cipher_key, ODP_AUTH_ALG_NULL, - auth_key, - NULL, NULL, - NULL, 0, - aes128_cbc_reference_ciphertext[i], - aes128_cbc_reference_length[i], - aes128_cbc_reference_plaintext[i], - aes128_cbc_reference_length[i], NULL, 0); + &aes128_cbc_reference[i], + false); } } @@ -1241,35 +850,16 @@ void crypto_test_dec_alg_aes128_cbc(void) * */ void crypto_test_dec_alg_aes128_cbc_ovr_iv(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = AES128_CBC_IV_LEN }; - unsigned int test_vec_num = (sizeof(aes128_cbc_reference_length) / - sizeof(aes128_cbc_reference_length[0])); + unsigned int test_vec_num = (sizeof(aes128_cbc_reference) / + sizeof(aes128_cbc_reference[0])); unsigned int i; for (i = 0; i < test_vec_num; i++) { - cipher_key.data = aes128_cbc_reference_key[i]; - cipher_key.length = sizeof(aes128_cbc_reference_key[i]); - - if (!check_cipher_options(ODP_CIPHER_ALG_AES_CBC, - cipher_key.length, iv.length)) - continue; - alg_test(ODP_CRYPTO_OP_DECODE, - 0, ODP_CIPHER_ALG_AES_CBC, - iv, - aes128_cbc_reference_iv[i], - cipher_key, ODP_AUTH_ALG_NULL, - auth_key, - NULL, NULL, - NULL, 0, - aes128_cbc_reference_ciphertext[i], - aes128_cbc_reference_length[i], - aes128_cbc_reference_plaintext[i], - aes128_cbc_reference_length[i], NULL, 0); + &aes128_cbc_reference[i], + true); } } @@ -1287,93 +877,30 @@ static int check_alg_hmac_md5(void) * */ void crypto_test_gen_alg_hmac_md5(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = 0 }; - - unsigned int test_vec_num = (sizeof(hmac_md5_reference_length) / - sizeof(hmac_md5_reference_length[0])); + unsigned int test_vec_num = (sizeof(hmac_md5_reference) / + sizeof(hmac_md5_reference[0])); unsigned int i; - for (i = 0; i < test_vec_num; i++) { - auth_key.data = hmac_md5_reference_key[i]; - auth_key.length = sizeof(hmac_md5_reference_key[i]); - - if (!check_auth_options(ODP_AUTH_ALG_MD5_HMAC, auth_key.length, - hmac_md5_reference_digest_length[i])) - continue; - + for (i = 0; i < test_vec_num; i++) alg_test(ODP_CRYPTO_OP_ENCODE, - 0, ODP_CIPHER_ALG_NULL, - iv, - iv.data, - cipher_key, ODP_AUTH_ALG_MD5_HMAC, - auth_key, - NULL, NULL, - NULL, 0, - hmac_md5_reference_plaintext[i], - hmac_md5_reference_length[i], - NULL, 0, - hmac_md5_reference_digest[i], - hmac_md5_reference_digest_length[i]); - } + &hmac_md5_reference[i], + false); } void crypto_test_check_alg_hmac_md5(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = 0 }; - uint8_t wrong_digest[HMAC_MD5_DIGEST_LEN]; - - unsigned int test_vec_num = (sizeof(hmac_md5_reference_length) / - sizeof(hmac_md5_reference_length[0])); + unsigned int test_vec_num = (sizeof(hmac_md5_reference) / + sizeof(hmac_md5_reference[0])); unsigned int i; - memset(wrong_digest, 0xa5, sizeof(wrong_digest)); - - for (i = 0; i < test_vec_num; i++) { - auth_key.data = hmac_md5_reference_key[i]; - auth_key.length = sizeof(hmac_md5_reference_key[i]); - - if (!check_auth_options(ODP_AUTH_ALG_MD5_HMAC, auth_key.length, - hmac_md5_reference_digest_length[i])) - continue; - - alg_test(ODP_CRYPTO_OP_DECODE, - 0, - ODP_CIPHER_ALG_NULL, - iv, - iv.data, - cipher_key, - ODP_AUTH_ALG_MD5_HMAC, - auth_key, - NULL, NULL, - NULL, 0, - hmac_md5_reference_plaintext[i], - hmac_md5_reference_length[i], - NULL, 0, - hmac_md5_reference_digest[i], - hmac_md5_reference_digest_length[i]); - + for (i = 0; i < test_vec_num; i++) alg_test(ODP_CRYPTO_OP_DECODE, - 1, ODP_CIPHER_ALG_NULL, - iv, - iv.data, - cipher_key, ODP_AUTH_ALG_MD5_HMAC, - auth_key, - NULL, NULL, - NULL, 0, - hmac_md5_reference_plaintext[i], - hmac_md5_reference_length[i], - NULL, 0, - wrong_digest, - hmac_md5_reference_digest_length[i]); - } + &hmac_md5_reference[i], + false); } static int check_alg_hmac_sha1(void) @@ -1390,97 +917,30 @@ static int check_alg_hmac_sha1(void) * */ void crypto_test_gen_alg_hmac_sha1(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = 0 }; - - unsigned int test_vec_num = (sizeof(hmac_sha1_reference_length) / - sizeof(hmac_sha1_reference_length[0])); - + unsigned int test_vec_num = (sizeof(hmac_sha1_reference) / + sizeof(hmac_sha1_reference[0])); unsigned int i; - for (i = 0; i < test_vec_num; i++) { - auth_key.data = hmac_sha1_reference_key[i]; - auth_key.length = sizeof(hmac_sha1_reference_key[i]); - - if (!check_auth_options(ODP_AUTH_ALG_SHA1_HMAC, - auth_key.length, - HMAC_SHA1_96_CHECK_LEN)) - continue; - + for (i = 0; i < test_vec_num; i++) alg_test(ODP_CRYPTO_OP_ENCODE, - 0, ODP_CIPHER_ALG_NULL, - iv, - iv.data, - cipher_key, ODP_AUTH_ALG_SHA1_HMAC, - auth_key, - NULL, NULL, - NULL, 0, - hmac_sha1_reference_plaintext[i], - hmac_sha1_reference_length[i], - NULL, 0, - hmac_sha1_reference_digest[i], - HMAC_SHA1_96_CHECK_LEN); - } + &hmac_sha1_reference[i], + false); } void crypto_test_check_alg_hmac_sha1(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = 0 }; - uint8_t wrong_digest[HMAC_SHA1_DIGEST_LEN]; - - unsigned int test_vec_num = (sizeof(hmac_sha1_reference_length) / - sizeof(hmac_sha1_reference_length[0])); - + unsigned int test_vec_num = (sizeof(hmac_sha1_reference) / + sizeof(hmac_sha1_reference[0])); unsigned int i; - memset(wrong_digest, 0xa5, sizeof(wrong_digest)); - - for (i = 0; i < test_vec_num; i++) { - auth_key.data = hmac_sha1_reference_key[i]; - auth_key.length = sizeof(hmac_sha1_reference_key[i]); - - if (!check_auth_options(ODP_AUTH_ALG_SHA1_HMAC, - auth_key.length, - HMAC_SHA1_96_CHECK_LEN)) - continue; - + for (i = 0; i < test_vec_num; i++) alg_test(ODP_CRYPTO_OP_DECODE, - 0, ODP_CIPHER_ALG_NULL, - iv, - iv.data, - cipher_key, ODP_AUTH_ALG_SHA1_HMAC, - auth_key, - NULL, NULL, - NULL, 0, - hmac_sha1_reference_plaintext[i], - hmac_sha1_reference_length[i], - NULL, 0, - hmac_sha1_reference_digest[i], - HMAC_SHA1_96_CHECK_LEN); - - alg_test(ODP_CRYPTO_OP_DECODE, - 1, - ODP_CIPHER_ALG_NULL, - iv, - iv.data, - cipher_key, - ODP_AUTH_ALG_SHA1_HMAC, - auth_key, - NULL, NULL, - NULL, 0, - hmac_sha1_reference_plaintext[i], - hmac_sha1_reference_length[i], - NULL, 0, - wrong_digest, - HMAC_SHA1_96_CHECK_LEN); - } + &hmac_sha1_reference[i], + false); } static int check_alg_hmac_sha256(void) @@ -1497,97 +957,30 @@ static int check_alg_hmac_sha256(void) * */ void crypto_test_gen_alg_hmac_sha256(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = 0 }; - - unsigned int test_vec_num = (sizeof(hmac_sha256_reference_length) / - sizeof(hmac_sha256_reference_length[0])); - + unsigned int test_vec_num = (sizeof(hmac_sha256_reference) / + sizeof(hmac_sha256_reference[0])); unsigned int i; - for (i = 0; i < test_vec_num; i++) { - auth_key.data = hmac_sha256_reference_key[i]; - auth_key.length = sizeof(hmac_sha256_reference_key[i]); - - if (!check_auth_options(ODP_AUTH_ALG_SHA256_HMAC, - auth_key.length, - hmac_sha256_reference_digest_length[i])) - continue; - + for (i = 0; i < test_vec_num; i++) alg_test(ODP_CRYPTO_OP_ENCODE, - 0, ODP_CIPHER_ALG_NULL, - iv, - iv.data, - cipher_key, ODP_AUTH_ALG_SHA256_HMAC, - auth_key, - NULL, NULL, - NULL, 0, - hmac_sha256_reference_plaintext[i], - hmac_sha256_reference_length[i], - NULL, 0, - hmac_sha256_reference_digest[i], - hmac_sha256_reference_digest_length[i]); - } + &hmac_sha256_reference[i], + false); } void crypto_test_check_alg_hmac_sha256(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = 0 }; - uint8_t wrong_digest[HMAC_SHA256_DIGEST_LEN]; - - unsigned int test_vec_num = (sizeof(hmac_sha256_reference_length) / - sizeof(hmac_sha256_reference_length[0])); - + unsigned int test_vec_num = (sizeof(hmac_sha256_reference) / + sizeof(hmac_sha256_reference[0])); unsigned int i; - memset(wrong_digest, 0xa5, sizeof(wrong_digest)); - - for (i = 0; i < test_vec_num; i++) { - auth_key.data = hmac_sha256_reference_key[i]; - auth_key.length = sizeof(hmac_sha256_reference_key[i]); - - if (!check_auth_options(ODP_AUTH_ALG_SHA256_HMAC, - auth_key.length, - hmac_sha256_reference_digest_length[i])) - continue; - + for (i = 0; i < test_vec_num; i++) alg_test(ODP_CRYPTO_OP_DECODE, - 0, ODP_CIPHER_ALG_NULL, - iv, - iv.data, - cipher_key, ODP_AUTH_ALG_SHA256_HMAC, - auth_key, - NULL, NULL, - NULL, 0, - hmac_sha256_reference_plaintext[i], - hmac_sha256_reference_length[i], - NULL, 0, - hmac_sha256_reference_digest[i], - hmac_sha256_reference_digest_length[i]); - - alg_test(ODP_CRYPTO_OP_DECODE, - 1, - ODP_CIPHER_ALG_NULL, - iv, - iv.data, - cipher_key, - ODP_AUTH_ALG_SHA256_HMAC, - auth_key, - NULL, NULL, - NULL, 0, - hmac_sha256_reference_plaintext[i], - hmac_sha256_reference_length[i], - NULL, 0, - wrong_digest, - hmac_sha256_reference_digest_length[i]); - } + &hmac_sha256_reference[i], + false); } static int check_alg_hmac_sha512(void) @@ -1604,97 +997,30 @@ static int check_alg_hmac_sha512(void) * */ void crypto_test_gen_alg_hmac_sha512(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = 0 }; - - unsigned int test_vec_num = (sizeof(hmac_sha512_reference_length) / - sizeof(hmac_sha512_reference_length[0])); - + unsigned int test_vec_num = (sizeof(hmac_sha512_reference) / + sizeof(hmac_sha512_reference[0])); unsigned int i; - for (i = 0; i < test_vec_num; i++) { - auth_key.data = hmac_sha512_reference_key[i]; - auth_key.length = sizeof(hmac_sha512_reference_key[i]); - - if (!check_auth_options(ODP_AUTH_ALG_SHA512_HMAC, - auth_key.length, - HMAC_SHA512_256_CHECK_LEN)) - continue; - + for (i = 0; i < test_vec_num; i++) alg_test(ODP_CRYPTO_OP_ENCODE, - 0, ODP_CIPHER_ALG_NULL, - iv, - iv.data, - cipher_key, ODP_AUTH_ALG_SHA512_HMAC, - auth_key, - NULL, NULL, - NULL, 0, - hmac_sha512_reference_plaintext[i], - hmac_sha512_reference_length[i], - NULL, 0, - hmac_sha512_reference_digest[i], - HMAC_SHA512_256_CHECK_LEN); - } + &hmac_sha512_reference[i], + false); } void crypto_test_check_alg_hmac_sha512(void) { - odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, - auth_key = { .data = NULL, .length = 0 }; - odp_crypto_iv_t iv = { .data = NULL, .length = 0 }; - uint8_t wrong_digest[HMAC_SHA512_DIGEST_LEN]; - - unsigned int test_vec_num = (sizeof(hmac_sha512_reference_length) / - sizeof(hmac_sha512_reference_length[0])); - + unsigned int test_vec_num = (sizeof(hmac_sha512_reference) / + sizeof(hmac_sha512_reference[0])); unsigned int i; - memset(wrong_digest, 0xa5, sizeof(wrong_digest)); - - for (i = 0; i < test_vec_num; i++) { - auth_key.data = hmac_sha512_reference_key[i]; - auth_key.length = sizeof(hmac_sha512_reference_key[i]); - - if (!check_auth_options(ODP_AUTH_ALG_SHA512_HMAC, - auth_key.length, - HMAC_SHA512_256_CHECK_LEN)) - continue; - + for (i = 0; i < test_vec_num; i++) alg_test(ODP_CRYPTO_OP_DECODE, - 0, ODP_CIPHER_ALG_NULL, - iv, - iv.data, - cipher_key, ODP_AUTH_ALG_SHA512_HMAC, - auth_key, - NULL, NULL, - NULL, 0, - hmac_sha512_reference_plaintext[i], - hmac_sha512_reference_length[i], - NULL, 0, - hmac_sha512_reference_digest[i], - HMAC_SHA512_256_CHECK_LEN); - - alg_test(ODP_CRYPTO_OP_DECODE, - 1, - ODP_CIPHER_ALG_NULL, - iv, - iv.data, - cipher_key, - ODP_AUTH_ALG_SHA512_HMAC, - auth_key, - NULL, NULL, - NULL, 0, - hmac_sha512_reference_plaintext[i], - hmac_sha512_reference_length[i], - NULL, 0, - wrong_digest, - HMAC_SHA512_256_CHECK_LEN); - } + &hmac_sha512_reference[i], + false); } int crypto_suite_sync_init(void) diff --git a/test/common_plat/validation/api/crypto/test_vectors.h b/test/common_plat/validation/api/crypto/test_vectors.h index bd8bf347..f9ca9eb5 100644 --- a/test/common_plat/validation/api/crypto/test_vectors.h +++ b/test/common_plat/validation/api/crypto/test_vectors.h @@ -9,442 +9,498 @@ #include "test_vectors_len.h" -/** length in bytes */ -static uint32_t null_reference_length[] = { 8, 16 }; - -static uint8_t -null_reference_plaintext[][NULL_MAX_DATA_LEN] = { - {0x32, 0x6a, 0x49, 0x4c, 0xd3, 0x3f, 0xe7, 0x56}, - - {0x84, 0x40, 0x1f, 0x78, 0xfe, 0x6c, 0x10, 0x87, 0x6d, 0x8e, 0xa2, 0x30, - 0x94, 0xea, 0x53, 0x09} +typedef struct crypto_test_reference_s { + uint32_t cipher_key_length; + uint8_t cipher_key[MAX_KEY_LEN]; + uint32_t auth_key_length; + uint8_t auth_key[MAX_KEY_LEN]; + uint32_t iv_length; + uint8_t iv[MAX_IV_LEN]; + uint32_t length; + uint8_t plaintext[MAX_DATA_LEN]; + uint8_t ciphertext[MAX_DATA_LEN]; + uint32_t aad_length; + uint8_t aad[MAX_AAD_LEN]; + uint32_t digest_length; + uint8_t digest[MAX_DIGEST_LEN]; +} crypto_test_reference_t; + +static crypto_test_reference_t null_reference[] = { + { + .length = 8, + .plaintext = { 0x32, 0x6a, 0x49, 0x4c, 0xd3, 0x3f, 0xe7, 0x56 }, + .ciphertext = { 0x32, 0x6a, 0x49, 0x4c, 0xd3, 0x3f, 0xe7, 0x56 } + }, + { + .length = 16, + .plaintext = { 0x84, 0x40, 0x1f, 0x78, 0xfe, 0x6c, 0x10, 0x87, + 0x6d, 0x8e, 0xa2, 0x30, 0x94, 0xea, 0x53, 0x09 }, + .ciphertext = { 0x84, 0x40, 0x1f, 0x78, 0xfe, 0x6c, 0x10, 0x87, + 0x6d, 0x8e, 0xa2, 0x30, 0x94, 0xea, 0x53, 0x09 } + } }; /* TDES-CBC reference vectors, according to * "http://csrc.nist.gov/groups/STM/cavp/documents/des/DESMMT.pdf" */ -static uint8_t tdes_cbc_reference_key[][TDES_CBC_KEY_LEN] = { - {0x62, 0x7f, 0x46, 0x0e, 0x08, 0x10, 0x4a, 0x10, 0x43, 0xcd, 0x26, 0x5d, - 0x58, 0x40, 0xea, 0xf1, 0x31, 0x3e, 0xdf, 0x97, 0xdf, 0x2a, 0x8a, 0x8c, - }, - - {0x37, 0xae, 0x5e, 0xbf, 0x46, 0xdf, 0xf2, 0xdc, 0x07, 0x54, 0xb9, 0x4f, - 0x31, 0xcb, 0xb3, 0x85, 0x5e, 0x7f, 0xd3, 0x6d, 0xc8, 0x70, 0xbf, 0xae} -}; - -static uint8_t tdes_cbc_reference_iv[][TDES_CBC_IV_LEN] = { - {0x8e, 0x29, 0xf7, 0x5e, 0xa7, 0x7e, 0x54, 0x75}, - - {0x3d, 0x1d, 0xe3, 0xcc, 0x13, 0x2e, 0x3b, 0x65} -}; - -/** length in bytes */ -static uint32_t tdes_cbc_reference_length[] = { 8, 16 }; - -static uint8_t -tdes_cbc_reference_plaintext[][TDES_CBC_MAX_DATA_LEN] = { - {0x32, 0x6a, 0x49, 0x4c, 0xd3, 0x3f, 0xe7, 0x56}, - - {0x84, 0x40, 0x1f, 0x78, 0xfe, 0x6c, 0x10, 0x87, 0x6d, 0x8e, 0xa2, 0x30, - 0x94, 0xea, 0x53, 0x09} -}; - -static uint8_t -tdes_cbc_reference_ciphertext[][TDES_CBC_MAX_DATA_LEN] = { - {0xb2, 0x2b, 0x8d, 0x66, 0xde, 0x97, 0x06, 0x92}, - - {0x7b, 0x1f, 0x7c, 0x7e, 0x3b, 0x1c, 0x94, 0x8e, 0xbd, 0x04, 0xa7, 0x5f, - 0xfb, 0xa7, 0xd2, 0xf5} -}; - -static uint8_t aes128_cbc_reference_key[][AES128_CBC_KEY_LEN] = { - {0x06, 0xa9, 0x21, 0x40, 0x36, 0xb8, 0xa1, 0x5b, - 0x51, 0x2e, 0x03, 0xd5, 0x34, 0x12, 0x00, 0x06 }, - {0xc2, 0x86, 0x69, 0x6d, 0x88, 0x7c, 0x9a, 0xa0, - 0x61, 0x1b, 0xbb, 0x3e, 0x20, 0x25, 0xa4, 0x5a }, - {0x6c, 0x3e, 0xa0, 0x47, 0x76, 0x30, 0xce, 0x21, - 0xa2, 0xce, 0x33, 0x4a, 0xa7, 0x46, 0xc2, 0xcd }, - {0x56, 0xe4, 0x7a, 0x38, 0xc5, 0x59, 0x89, 0x74, - 0xbc, 0x46, 0x90, 0x3d, 0xba, 0x29, 0x03, 0x49 } +static crypto_test_reference_t tdes_cbc_reference[] = { + { + .cipher_key_length = TDES_CBC_KEY_LEN, + .cipher_key = { 0x62, 0x7f, 0x46, 0x0e, 0x08, 0x10, 0x4a, 0x10, + 0x43, 0xcd, 0x26, 0x5d, 0x58, 0x40, 0xea, 0xf1, + 0x31, 0x3e, 0xdf, 0x97, 0xdf, 0x2a, 0x8a, 0x8c}, + .iv_length = TDES_CBC_IV_LEN, + .iv = { 0x8e, 0x29, 0xf7, 0x5e, 0xa7, 0x7e, 0x54, 0x75 }, + .length = 8, + .plaintext = { 0x32, 0x6a, 0x49, 0x4c, 0xd3, 0x3f, 0xe7, 0x56 }, + .ciphertext = { 0xb2, 0x2b, 0x8d, 0x66, 0xde, 0x97, 0x06, 0x92 } + }, + { + .cipher_key_length = TDES_CBC_KEY_LEN, + .cipher_key = { 0x37, 0xae, 0x5e, 0xbf, 0x46, 0xdf, 0xf2, 0xdc, + 0x07, 0x54, 0xb9, 0x4f, 0x31, 0xcb, 0xb3, 0x85, + 0x5e, 0x7f, 0xd3, 0x6d, 0xc8, 0x70, 0xbf, 0xae}, + .iv_length = TDES_CBC_IV_LEN, + .iv = {0x3d, 0x1d, 0xe3, 0xcc, 0x13, 0x2e, 0x3b, 0x65 }, + .length = 16, + .plaintext = { 0x84, 0x40, 0x1f, 0x78, 0xfe, 0x6c, 0x10, 0x87, + 0x6d, 0x8e, 0xa2, 0x30, 0x94, 0xea, 0x53, 0x09 }, + .ciphertext = { 0x7b, 0x1f, 0x7c, 0x7e, 0x3b, 0x1c, 0x94, 0x8e, + 0xbd, 0x04, 0xa7, 0x5f, 0xfb, 0xa7, 0xd2, 0xf5 } + } }; -static uint8_t aes128_cbc_reference_iv[][AES128_CBC_IV_LEN] = { - { 0x3d, 0xaf, 0xba, 0x42, 0x9d, 0x9e, 0xb4, 0x30, - 0xb4, 0x22, 0xda, 0x80, 0x2c, 0x9f, 0xac, 0x41 }, - { 0x56, 0x2e, 0x17, 0x99, 0x6d, 0x09, 0x3d, 0x28, - 0xdd, 0xb3, 0xba, 0x69, 0x5a, 0x2e, 0x6f, 0x58 }, - { 0xc7, 0x82, 0xdc, 0x4c, 0x09, 0x8c, 0x66, 0xcb, - 0xd9, 0xcd, 0x27, 0xd8, 0x25, 0x68, 0x2c, 0x81 }, - { 0x8c, 0xe8, 0x2e, 0xef, 0xbe, 0xa0, 0xda, 0x3c, - 0x44, 0x69, 0x9e, 0xd7, 0xdb, 0x51, 0xb7, 0xd9 } -}; - -/** length in bytes */ -static uint32_t aes128_cbc_reference_length[] = { 16, 32, 48, 64 }; - -static uint8_t -aes128_cbc_reference_plaintext[][AES128_CBC_MAX_DATA_LEN] = { - "Single block msg", - { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, - 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, - 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, - 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f }, - "This is a 48-byte message (exactly 3 AES blocks)", - { 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, - 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, - 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, - 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, - 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, - 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, - 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, - 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf } -}; - -static uint8_t -aes128_cbc_reference_ciphertext[][AES128_CBC_MAX_DATA_LEN] = { - { 0xe3, 0x53, 0x77, 0x9c, 0x10, 0x79, 0xae, 0xb8, - 0x27, 0x08, 0x94, 0x2d, 0xbe, 0x77, 0x18, 0x1a }, - { 0xd2, 0x96, 0xcd, 0x94, 0xc2, 0xcc, 0xcf, 0x8a, - 0x3a, 0x86, 0x30, 0x28, 0xb5, 0xe1, 0xdc, 0x0a, - 0x75, 0x86, 0x60, 0x2d, 0x25, 0x3c, 0xff, 0xf9, - 0x1b, 0x82, 0x66, 0xbe, 0xa6, 0xd6, 0x1a, 0xb1 }, - { 0xd0, 0xa0, 0x2b, 0x38, 0x36, 0x45, 0x17, 0x53, - 0xd4, 0x93, 0x66, 0x5d, 0x33, 0xf0, 0xe8, 0x86, - 0x2d, 0xea, 0x54, 0xcd, 0xb2, 0x93, 0xab, 0xc7, - 0x50, 0x69, 0x39, 0x27, 0x67, 0x72, 0xf8, 0xd5, - 0x02, 0x1c, 0x19, 0x21, 0x6b, 0xad, 0x52, 0x5c, - 0x85, 0x79, 0x69, 0x5d, 0x83, 0xba, 0x26, 0x84 }, - { 0xc3, 0x0e, 0x32, 0xff, 0xed, 0xc0, 0x77, 0x4e, - 0x6a, 0xff, 0x6a, 0xf0, 0x86, 0x9f, 0x71, 0xaa, - 0x0f, 0x3a, 0xf0, 0x7a, 0x9a, 0x31, 0xa9, 0xc6, - 0x84, 0xdb, 0x20, 0x7e, 0xb0, 0xef, 0x8e, 0x4e, - 0x35, 0x90, 0x7a, 0xa6, 0x32, 0xc3, 0xff, 0xdf, - 0x86, 0x8b, 0xb7, 0xb2, 0x9d, 0x3d, 0x46, 0xad, - 0x83, 0xce, 0x9f, 0x9a, 0x10, 0x2e, 0xe9, 0x9d, - 0x49, 0xa5, 0x3e, 0x87, 0xf4, 0xc3, 0xda, 0x55 } +static crypto_test_reference_t aes128_cbc_reference[] = { + { + .cipher_key_length = AES128_CBC_KEY_LEN, + .cipher_key = { 0x06, 0xa9, 0x21, 0x40, 0x36, 0xb8, 0xa1, 0x5b, + 0x51, 0x2e, 0x03, 0xd5, 0x34, 0x12, 0x00, 0x06}, + .iv_length = AES128_CBC_IV_LEN, + .iv = { 0x3d, 0xaf, 0xba, 0x42, 0x9d, 0x9e, 0xb4, 0x30, + 0xb4, 0x22, 0xda, 0x80, 0x2c, 0x9f, 0xac, 0x41 }, + .length = 16, + .plaintext = "Single block msg", + .ciphertext = { 0xe3, 0x53, 0x77, 0x9c, 0x10, 0x79, 0xae, 0xb8, + 0x27, 0x08, 0x94, 0x2d, 0xbe, 0x77, 0x18, 0x1a } + }, + { + .cipher_key_length = AES128_CBC_KEY_LEN, + .cipher_key = { 0xc2, 0x86, 0x69, 0x6d, 0x88, 0x7c, 0x9a, 0xa0, + 0x61, 0x1b, 0xbb, 0x3e, 0x20, 0x25, 0xa4, 0x5a}, + .iv_length = AES128_CBC_IV_LEN, + .iv = { 0x56, 0x2e, 0x17, 0x99, 0x6d, 0x09, 0x3d, 0x28, + 0xdd, 0xb3, 0xba, 0x69, 0x5a, 0x2e, 0x6f, 0x58 }, + .length = 32, + .plaintext = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f }, + .ciphertext = { 0xd2, 0x96, 0xcd, 0x94, 0xc2, 0xcc, 0xcf, 0x8a, + 0x3a, 0x86, 0x30, 0x28, 0xb5, 0xe1, 0xdc, 0x0a, + 0x75, 0x86, 0x60, 0x2d, 0x25, 0x3c, 0xff, 0xf9, + 0x1b, 0x82, 0x66, 0xbe, 0xa6, 0xd6, 0x1a, 0xb1 } + }, + { + .cipher_key_length = AES128_CBC_KEY_LEN, + .cipher_key = { 0x6c, 0x3e, 0xa0, 0x47, 0x76, 0x30, 0xce, 0x21, + 0xa2, 0xce, 0x33, 0x4a, 0xa7, 0x46, 0xc2, 0xcd}, + .iv_length = AES128_CBC_IV_LEN, + .iv = { 0xc7, 0x82, 0xdc, 0x4c, 0x09, 0x8c, 0x66, 0xcb, + 0xd9, 0xcd, 0x27, 0xd8, 0x25, 0x68, 0x2c, 0x81 }, + .length = 48, + .plaintext = "This is a 48-byte message (exactly 3 AES blocks)", + .ciphertext = { 0xd0, 0xa0, 0x2b, 0x38, 0x36, 0x45, 0x17, 0x53, + 0xd4, 0x93, 0x66, 0x5d, 0x33, 0xf0, 0xe8, 0x86, + 0x2d, 0xea, 0x54, 0xcd, 0xb2, 0x93, 0xab, 0xc7, + 0x50, 0x69, 0x39, 0x27, 0x67, 0x72, 0xf8, 0xd5, + 0x02, 0x1c, 0x19, 0x21, 0x6b, 0xad, 0x52, 0x5c, + 0x85, 0x79, 0x69, 0x5d, 0x83, 0xba, 0x26, 0x84 } + }, + { + .cipher_key_length = AES128_CBC_KEY_LEN, + .cipher_key = { 0x56, 0xe4, 0x7a, 0x38, 0xc5, 0x59, 0x89, 0x74, + 0xbc, 0x46, 0x90, 0x3d, 0xba, 0x29, 0x03, 0x49}, + .iv_length = AES128_CBC_IV_LEN, + .iv = { 0x8c, 0xe8, 0x2e, 0xef, 0xbe, 0xa0, 0xda, 0x3c, + 0x44, 0x69, 0x9e, 0xd7, 0xdb, 0x51, 0xb7, 0xd9 }, + .length = 64, + .plaintext = { 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, + 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, + 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, + 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, + 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, + 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, + 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, + 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf }, + .ciphertext = { 0xc3, 0x0e, 0x32, 0xff, 0xed, 0xc0, 0x77, 0x4e, + 0x6a, 0xff, 0x6a, 0xf0, 0x86, 0x9f, 0x71, 0xaa, + 0x0f, 0x3a, 0xf0, 0x7a, 0x9a, 0x31, 0xa9, 0xc6, + 0x84, 0xdb, 0x20, 0x7e, 0xb0, 0xef, 0x8e, 0x4e, + 0x35, 0x90, 0x7a, 0xa6, 0x32, 0xc3, 0xff, 0xdf, + 0x86, 0x8b, 0xb7, 0xb2, 0x9d, 0x3d, 0x46, 0xad, + 0x83, 0xce, 0x9f, 0x9a, 0x10, 0x2e, 0xe9, 0x9d, + 0x49, 0xa5, 0x3e, 0x87, 0xf4, 0xc3, 0xda, 0x55 } + } }; /* AES-GCM test vectors extracted from * https://tools.ietf.org/html/draft-mcgrew-gcm-test-01#section-2 */ -static uint8_t aes128_gcm_reference_key[][AES128_GCM_KEY_LEN] = { - { 0x4c, 0x80, 0xcd, 0xef, 0xbb, 0x5d, 0x10, 0xda, - 0x90, 0x6a, 0xc7, 0x3c, 0x36, 0x13, 0xa6, 0x34 }, - { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c, - 0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08 }, - { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, - { 0x3d, 0xe0, 0x98, 0x74, 0xb3, 0x88, 0xe6, 0x49, - 0x19, 0x88, 0xd0, 0xc3, 0x60, 0x7e, 0xae, 0x1f } -}; - -static uint8_t aes128_gcm_reference_iv[][AES128_GCM_IV_LEN] = { - { 0x2e, 0x44, 0x3b, 0x68, 0x49, 0x56, 0xed, 0x7e, - 0x3b, 0x24, 0x4c, 0xfe }, - { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad, - 0xde, 0xca, 0xf8, 0x88 }, - { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00 }, - { 0x57, 0x69, 0x0e, 0x43, 0x4e, 0x28, 0x00, 0x00, - 0xa2, 0xfc, 0xa1, 0xa3 } +static crypto_test_reference_t aes128_gcm_reference[] = { + { + .cipher_key_length = AES128_GCM_KEY_LEN, + .cipher_key = { 0x4c, 0x80, 0xcd, 0xef, 0xbb, 0x5d, 0x10, 0xda, + 0x90, 0x6a, 0xc7, 0x3c, 0x36, 0x13, 0xa6, 0x34}, + .iv_length = AES128_GCM_IV_LEN, + .iv = { 0x2e, 0x44, 0x3b, 0x68, 0x49, 0x56, 0xed, 0x7e, + 0x3b, 0x24, 0x4c, 0xfe }, + .length = 72, + .plaintext = { 0x45, 0x00, 0x00, 0x48, 0x69, 0x9a, 0x00, 0x00, + 0x80, 0x11, 0x4d, 0xb7, 0xc0, 0xa8, 0x01, 0x02, + 0xc0, 0xa8, 0x01, 0x01, 0x0a, 0x9b, 0xf1, 0x56, + 0x38, 0xd3, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x04, 0x5f, 0x73, 0x69, + 0x70, 0x04, 0x5f, 0x75, 0x64, 0x70, 0x03, 0x73, + 0x69, 0x70, 0x09, 0x63, 0x79, 0x62, 0x65, 0x72, + 0x63, 0x69, 0x74, 0x79, 0x02, 0x64, 0x6b, 0x00, + 0x00, 0x21, 0x00, 0x01, 0x01, 0x02, 0x02, 0x01 }, + .ciphertext = { 0xfe, 0xcf, 0x53, 0x7e, 0x72, 0x9d, 0x5b, 0x07, + 0xdc, 0x30, 0xdf, 0x52, 0x8d, 0xd2, 0x2b, 0x76, + 0x8d, 0x1b, 0x98, 0x73, 0x66, 0x96, 0xa6, 0xfd, + 0x34, 0x85, 0x09, 0xfa, 0x13, 0xce, 0xac, 0x34, + 0xcf, 0xa2, 0x43, 0x6f, 0x14, 0xa3, 0xf3, 0xcf, + 0x65, 0x92, 0x5b, 0xf1, 0xf4, 0xa1, 0x3c, 0x5d, + 0x15, 0xb2, 0x1e, 0x18, 0x84, 0xf5, 0xff, 0x62, + 0x47, 0xae, 0xab, 0xb7, 0x86, 0xb9, 0x3b, 0xce, + 0x61, 0xbc, 0x17, 0xd7, 0x68, 0xfd, 0x97, 0x32}, + .aad_length = 12, + .aad = { 0x00, 0x00, 0x43, 0x21, 0x87, 0x65, 0x43, 0x21, + 0x00, 0x00, 0x00, 0x00 }, + .digest_length = AES128_GCM_DIGEST_LEN, + .digest = { 0x45, 0x90, 0x18, 0x14, 0x8f, 0x6c, 0xbe, 0x72, + 0x2f, 0xd0, 0x47, 0x96, 0x56, 0x2d, 0xfd, 0xb4 } + }, + { + .cipher_key_length = AES128_GCM_KEY_LEN, + .cipher_key = { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c, + 0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08}, + .iv_length = AES128_GCM_IV_LEN, + .iv = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad, + 0xde, 0xca, 0xf8, 0x88 }, + .length = 64, + .plaintext = { 0x45, 0x00, 0x00, 0x3e, 0x69, 0x8f, 0x00, 0x00, + 0x80, 0x11, 0x4d, 0xcc, 0xc0, 0xa8, 0x01, 0x02, + 0xc0, 0xa8, 0x01, 0x01, 0x0a, 0x98, 0x00, 0x35, + 0x00, 0x2a, 0x23, 0x43, 0xb2, 0xd0, 0x01, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x03, 0x73, 0x69, 0x70, 0x09, 0x63, 0x79, 0x62, + 0x65, 0x72, 0x63, 0x69, 0x74, 0x79, 0x02, 0x64, + 0x6b, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01 }, + .ciphertext = { 0xde, 0xb2, 0x2c, 0xd9, 0xb0, 0x7c, 0x72, 0xc1, + 0x6e, 0x3a, 0x65, 0xbe, 0xeb, 0x8d, 0xf3, 0x04, + 0xa5, 0xa5, 0x89, 0x7d, 0x33, 0xae, 0x53, 0x0f, + 0x1b, 0xa7, 0x6d, 0x5d, 0x11, 0x4d, 0x2a, 0x5c, + 0x3d, 0xe8, 0x18, 0x27, 0xc1, 0x0e, 0x9a, 0x4f, + 0x51, 0x33, 0x0d, 0x0e, 0xec, 0x41, 0x66, 0x42, + 0xcf, 0xbb, 0x85, 0xa5, 0xb4, 0x7e, 0x48, 0xa4, + 0xec, 0x3b, 0x9b, 0xa9, 0x5d, 0x91, 0x8b, 0xd1}, + .aad_length = 8, + .aad = { 0x00, 0x00, 0xa5, 0xf8, 0x00, 0x00, 0x00, 0x0a }, + .digest_length = AES128_GCM_DIGEST_LEN, + .digest = { 0x83, 0xb7, 0x0d, 0x3a, 0xa8, 0xbc, 0x6e, 0xe4, + 0xc3, 0x09, 0xe9, 0xd8, 0x5a, 0x41, 0xad, 0x4a } + }, + { + .cipher_key_length = AES128_GCM_KEY_LEN, + .cipher_key = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, + .iv_length = AES128_GCM_IV_LEN, + .iv = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00 }, + .length = 64, + .plaintext = { 0x45, 0x00, 0x00, 0x3c, 0x99, 0xc5, 0x00, 0x00, + 0x80, 0x01, 0xcb, 0x7a, 0x40, 0x67, 0x93, 0x18, + 0x01, 0x01, 0x01, 0x01, 0x08, 0x00, 0x07, 0x5c, + 0x02, 0x00, 0x44, 0x00, 0x61, 0x62, 0x63, 0x64, + 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, + 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, + 0x75, 0x76, 0x77, 0x61, 0x62, 0x63, 0x64, 0x65, + 0x66, 0x67, 0x68, 0x69, 0x01, 0x02, 0x02, 0x01 }, + .ciphertext = { 0x46, 0x88, 0xda, 0xf2, 0xf9, 0x73, 0xa3, 0x92, + 0x73, 0x29, 0x09, 0xc3, 0x31, 0xd5, 0x6d, 0x60, + 0xf6, 0x94, 0xab, 0xaa, 0x41, 0x4b, 0x5e, 0x7f, + 0xf5, 0xfd, 0xcd, 0xff, 0xf5, 0xe9, 0xa2, 0x84, + 0x45, 0x64, 0x76, 0x49, 0x27, 0x19, 0xff, 0xb6, + 0x4d, 0xe7, 0xd9, 0xdc, 0xa1, 0xe1, 0xd8, 0x94, + 0xbc, 0x3b, 0xd5, 0x78, 0x73, 0xed, 0x4d, 0x18, + 0x1d, 0x19, 0xd4, 0xd5, 0xc8, 0xc1, 0x8a, 0xf3}, + .aad_length = 8, + .aad = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, + .digest_length = AES128_GCM_DIGEST_LEN, + .digest = { 0xf8, 0x21, 0xd4, 0x96, 0xee, 0xb0, 0x96, 0xe9, + 0x8a, 0xd2, 0xb6, 0x9e, 0x47, 0x99, 0xc7, 0x1d } + }, + { + .cipher_key_length = AES128_GCM_KEY_LEN, + .cipher_key = { 0x3d, 0xe0, 0x98, 0x74, 0xb3, 0x88, 0xe6, 0x49, + 0x19, 0x88, 0xd0, 0xc3, 0x60, 0x7e, 0xae, 0x1f}, + .iv_length = AES128_GCM_IV_LEN, + .iv = { 0x57, 0x69, 0x0e, 0x43, 0x4e, 0x28, 0x00, 0x00, + 0xa2, 0xfc, 0xa1, 0xa3 }, + .length = 28, + .plaintext = { 0x45, 0x00, 0x00, 0x1c, 0x42, 0xa2, 0x00, 0x00, + 0x80, 0x01, 0x44, 0x1f, 0x40, 0x67, 0x93, 0xb6, + 0xe0, 0x00, 0x00, 0x02, 0x0a, 0x00, 0xf5, 0xff, + 0x01, 0x02, 0x02, 0x01 }, + .ciphertext = { 0xfb, 0xa2, 0xca, 0x84, 0x5e, 0x5d, 0xf9, 0xf0, + 0xf2, 0x2c, 0x3e, 0x6e, 0x86, 0xdd, 0x83, 0x1e, + 0x1f, 0xc6, 0x57, 0x92, 0xcd, 0x1a, 0xf9, 0x13, + 0x0e, 0x13, 0x79, 0xed }, + .aad_length = 12, + .aad = { 0x42, 0xf6, 0x7e, 0x3f, 0x10, 0x10, 0x10, 0x10, + 0x10, 0x10, 0x10, 0x10 }, + .digest_length = AES128_GCM_DIGEST_LEN, + .digest = { 0x36, 0x9f, 0x07, 0x1f, 0x35, 0xe0, 0x34, 0xbe, + 0x95, 0xf1, 0x12, 0xe4, 0xe7, 0xd0, 0x5d, 0x35 } + }, }; -static uint32_t aes128_gcm_reference_length[] = { 72, 64, 64, 28}; - -static uint32_t aes128_gcm_reference_tag_length[] = { 16, 16, 16, 16}; - -static uint32_t aes128_gcm_reference_aad_length[] = { 12, 8, 8, 12}; - -static odp_packet_data_range_t aes128_gcm_cipher_range[] = { - { .offset = 0, .length = 72 }, - { .offset = 0, .length = 64 }, - { .offset = 0, .length = 64 }, - { .offset = 0, .length = 28 }, -}; - -static uint8_t aes128_gcm_reference_aad[][AES128_GCM_MAX_DATA_LEN] = { - { 0x00, 0x00, 0x43, 0x21, 0x87, 0x65, 0x43, 0x21, - 0x00, 0x00, 0x00, 0x00, }, - { 0x00, 0x00, 0xa5, 0xf8, 0x00, 0x00, 0x00, 0x0a, }, - { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, }, - { 0x42, 0xf6, 0x7e, 0x3f, 0x10, 0x10, 0x10, 0x10, - 0x10, 0x10, 0x10, 0x10, }, -}; - -static uint8_t -aes128_gcm_reference_plaintext[][AES128_GCM_MAX_DATA_LEN] = { - { 0x45, 0x00, 0x00, 0x48, 0x69, 0x9a, 0x00, 0x00, - 0x80, 0x11, 0x4d, 0xb7, 0xc0, 0xa8, 0x01, 0x02, - 0xc0, 0xa8, 0x01, 0x01, 0x0a, 0x9b, 0xf1, 0x56, - 0x38, 0xd3, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x04, 0x5f, 0x73, 0x69, - 0x70, 0x04, 0x5f, 0x75, 0x64, 0x70, 0x03, 0x73, - 0x69, 0x70, 0x09, 0x63, 0x79, 0x62, 0x65, 0x72, - 0x63, 0x69, 0x74, 0x79, 0x02, 0x64, 0x6b, 0x00, - 0x00, 0x21, 0x00, 0x01, 0x01, 0x02, 0x02, 0x01 }, - - { 0x45, 0x00, 0x00, 0x3e, 0x69, 0x8f, 0x00, 0x00, - 0x80, 0x11, 0x4d, 0xcc, 0xc0, 0xa8, 0x01, 0x02, - 0xc0, 0xa8, 0x01, 0x01, 0x0a, 0x98, 0x00, 0x35, - 0x00, 0x2a, 0x23, 0x43, 0xb2, 0xd0, 0x01, 0x00, - 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x73, 0x69, 0x70, 0x09, 0x63, 0x79, 0x62, - 0x65, 0x72, 0x63, 0x69, 0x74, 0x79, 0x02, 0x64, - 0x6b, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01 }, - - { 0x45, 0x00, 0x00, 0x3c, 0x99, 0xc5, 0x00, 0x00, - 0x80, 0x01, 0xcb, 0x7a, 0x40, 0x67, 0x93, 0x18, - 0x01, 0x01, 0x01, 0x01, 0x08, 0x00, 0x07, 0x5c, - 0x02, 0x00, 0x44, 0x00, 0x61, 0x62, 0x63, 0x64, - 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, - 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, - 0x75, 0x76, 0x77, 0x61, 0x62, 0x63, 0x64, 0x65, - 0x66, 0x67, 0x68, 0x69, 0x01, 0x02, 0x02, 0x01 }, - - { 0x45, 0x00, 0x00, 0x1c, 0x42, 0xa2, 0x00, 0x00, - 0x80, 0x01, 0x44, 0x1f, 0x40, 0x67, 0x93, 0xb6, - 0xe0, 0x00, 0x00, 0x02, 0x0a, 0x00, 0xf5, 0xff, - 0x01, 0x02, 0x02, 0x01 } -}; - -static uint8_t -aes128_gcm_reference_ciphertext[][AES128_GCM_MAX_DATA_LEN] = { - { /* Plain */ - 0xfe, 0xcf, 0x53, 0x7e, 0x72, 0x9d, 0x5b, 0x07, - 0xdc, 0x30, 0xdf, 0x52, 0x8d, 0xd2, 0x2b, 0x76, - 0x8d, 0x1b, 0x98, 0x73, 0x66, 0x96, 0xa6, 0xfd, - 0x34, 0x85, 0x09, 0xfa, 0x13, 0xce, 0xac, 0x34, - 0xcf, 0xa2, 0x43, 0x6f, 0x14, 0xa3, 0xf3, 0xcf, - 0x65, 0x92, 0x5b, 0xf1, 0xf4, 0xa1, 0x3c, 0x5d, - 0x15, 0xb2, 0x1e, 0x18, 0x84, 0xf5, 0xff, 0x62, - 0x47, 0xae, 0xab, 0xb7, 0x86, 0xb9, 0x3b, 0xce, - 0x61, 0xbc, 0x17, 0xd7, 0x68, 0xfd, 0x97, 0x32, - /* Digest */ - 0x45, 0x90, 0x18, 0x14, 0x8f, 0x6c, 0xbe, 0x72, - 0x2f, 0xd0, 0x47, 0x96, 0x56, 0x2d, 0xfd, 0xb4 }, - - { /* Plain */ - 0xde, 0xb2, 0x2c, 0xd9, 0xb0, 0x7c, 0x72, 0xc1, - 0x6e, 0x3a, 0x65, 0xbe, 0xeb, 0x8d, 0xf3, 0x04, - 0xa5, 0xa5, 0x89, 0x7d, 0x33, 0xae, 0x53, 0x0f, - 0x1b, 0xa7, 0x6d, 0x5d, 0x11, 0x4d, 0x2a, 0x5c, - 0x3d, 0xe8, 0x18, 0x27, 0xc1, 0x0e, 0x9a, 0x4f, - 0x51, 0x33, 0x0d, 0x0e, 0xec, 0x41, 0x66, 0x42, - 0xcf, 0xbb, 0x85, 0xa5, 0xb4, 0x7e, 0x48, 0xa4, - 0xec, 0x3b, 0x9b, 0xa9, 0x5d, 0x91, 0x8b, 0xd1, - /* Digest */ - 0x83, 0xb7, 0x0d, 0x3a, 0xa8, 0xbc, 0x6e, 0xe4, - 0xc3, 0x09, 0xe9, 0xd8, 0x5a, 0x41, 0xad, 0x4a }, - - { /* Plain */ - 0x46, 0x88, 0xda, 0xf2, 0xf9, 0x73, 0xa3, 0x92, - 0x73, 0x29, 0x09, 0xc3, 0x31, 0xd5, 0x6d, 0x60, - 0xf6, 0x94, 0xab, 0xaa, 0x41, 0x4b, 0x5e, 0x7f, - 0xf5, 0xfd, 0xcd, 0xff, 0xf5, 0xe9, 0xa2, 0x84, - 0x45, 0x64, 0x76, 0x49, 0x27, 0x19, 0xff, 0xb6, - 0x4d, 0xe7, 0xd9, 0xdc, 0xa1, 0xe1, 0xd8, 0x94, - 0xbc, 0x3b, 0xd5, 0x78, 0x73, 0xed, 0x4d, 0x18, - 0x1d, 0x19, 0xd4, 0xd5, 0xc8, 0xc1, 0x8a, 0xf3, - /* Digest */ - 0xf8, 0x21, 0xd4, 0x96, 0xee, 0xb0, 0x96, 0xe9, - 0x8a, 0xd2, 0xb6, 0x9e, 0x47, 0x99, 0xc7, 0x1d }, - - { /* Plain */ - 0xfb, 0xa2, 0xca, 0x84, 0x5e, 0x5d, 0xf9, 0xf0, - 0xf2, 0x2c, 0x3e, 0x6e, 0x86, 0xdd, 0x83, 0x1e, - 0x1f, 0xc6, 0x57, 0x92, 0xcd, 0x1a, 0xf9, 0x13, - 0x0e, 0x13, 0x79, 0xed, - /* Digest */ - 0x36, 0x9f, 0x07, 0x1f, 0x35, 0xe0, 0x34, 0xbe, - 0x95, 0xf1, 0x12, 0xe4, 0xe7, 0xd0, 0x5d, 0x35 } +static crypto_test_reference_t hmac_md5_reference[] = { + { + .auth_key_length = HMAC_MD5_KEY_LEN, + .auth_key = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b }, + .length = 8, + /* "Hi There" */ + .plaintext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65}, + .ciphertext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65}, + .digest_length = HMAC_MD5_96_CHECK_LEN, + .digest = { 0x92, 0x94, 0x72, 0x7a, 0x36, 0x38, 0xbb, 0x1c, + 0x13, 0xf4, 0x8e, 0xf8, 0x15, 0x8b, 0xfc, 0x9d }, + + }, + { + .auth_key_length = HMAC_MD5_KEY_LEN, + /* "Jefe" */ + .auth_key = { 0x4a, 0x65, 0x66, 0x65 }, + .length = 28, + /* what do ya want for nothing?*/ + .plaintext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, + 0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68, + 0x69, 0x6e, 0x67, 0x3f }, + .ciphertext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, + 0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68, + 0x69, 0x6e, 0x67, 0x3f }, + .digest_length = HMAC_MD5_96_CHECK_LEN, + .digest = { 0x75, 0x0c, 0x78, 0x3e, 0x6a, 0xb0, 0xb5, 0x03, + 0xea, 0xa8, 0x6e, 0x31, 0x0a, 0x5d, 0xb7, 0x38 }, + + }, + { + .auth_key_length = HMAC_MD5_KEY_LEN, + .auth_key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa }, + .length = 50, + .plaintext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd }, + .ciphertext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd }, + .digest_length = HMAC_MD5_96_CHECK_LEN, + .digest = { 0x56, 0xbe, 0x34, 0x52, 0x1d, 0x14, 0x4c, 0x88, + 0xdb, 0xb8, 0xc7, 0x33, 0xf0, 0xe8, 0xb3, 0xf6 } + } }; -static uint8_t hmac_md5_reference_key[][HMAC_MD5_KEY_LEN] = { - { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, - 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b }, - - /* "Jefe" */ - { 0x4a, 0x65, 0x66, 0x65 }, - - { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, - 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa } +static crypto_test_reference_t hmac_sha1_reference[] = { + { + .auth_key_length = HMAC_SHA1_KEY_LEN, + .auth_key = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b }, + .length = 8, + /* "Hi There" */ + .plaintext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65}, + .ciphertext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65}, + .digest_length = HMAC_SHA1_96_CHECK_LEN, + .digest = { 0xb6, 0x17, 0x31, 0x86, 0x55, 0x05, + 0x72, 0x64, 0xe2, 0x8b, 0xc0, 0xb6 } + }, + { + .auth_key_length = HMAC_SHA1_KEY_LEN, + /* "Jefe" */ + .auth_key = { 0x4a, 0x65, 0x66, 0x65 }, + .length = 28, + /* what do ya want for nothing?*/ + .plaintext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, + 0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68, + 0x69, 0x6e, 0x67, 0x3f }, + .ciphertext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, + 0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68, + 0x69, 0x6e, 0x67, 0x3f }, + .digest_length = HMAC_SHA1_96_CHECK_LEN, + .digest = { 0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb, + 0x2f, 0xa2, 0xd2, 0x74, 0x16, 0xd5 } + }, + { + .auth_key_length = HMAC_SHA1_KEY_LEN, + .auth_key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa }, + .length = 50, + .plaintext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd }, + .ciphertext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd }, + .digest_length = HMAC_SHA1_96_CHECK_LEN, + .digest = { 0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac, + 0x11, 0xcd, 0x91, 0xa3, 0x9a, 0xf4 } + } }; -static uint32_t hmac_md5_reference_length[] = { 8, 28, 50 }; - -static uint8_t -hmac_md5_reference_plaintext[][HMAC_MD5_MAX_DATA_LEN] = { - /* "Hi There" */ - { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65}, - - /* what do ya want for nothing?*/ - { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, - 0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, - 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68, - 0x69, 0x6e, 0x67, 0x3f }, - - { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd } +static crypto_test_reference_t hmac_sha256_reference[] = { + { + .auth_key_length = HMAC_SHA256_KEY_LEN, + .auth_key = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b }, + .length = 8, + /* "Hi There" */ + .plaintext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65}, + .ciphertext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65}, + .digest_length = HMAC_SHA256_128_CHECK_LEN, + .digest = { 0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53, + 0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b } + }, + { + .auth_key_length = HMAC_SHA256_KEY_LEN, + /* "Jefe" */ + .auth_key = { 0x4a, 0x65, 0x66, 0x65 }, + .length = 28, + /* what do ya want for nothing?*/ + .plaintext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, + 0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68, + 0x69, 0x6e, 0x67, 0x3f }, + .ciphertext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, + 0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68, + 0x69, 0x6e, 0x67, 0x3f }, + .digest_length = HMAC_SHA256_128_CHECK_LEN, + .digest = { 0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e, + 0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7 } + }, + { + .auth_key_length = HMAC_SHA256_KEY_LEN, + .auth_key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa }, + .length = 50, + .plaintext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd }, + .ciphertext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd }, + .digest_length = HMAC_SHA256_128_CHECK_LEN, + .digest = { 0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46, + 0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7 } + } }; -static uint8_t hmac_md5_reference_digest[][HMAC_MD5_DIGEST_LEN] = { - { 0x92, 0x94, 0x72, 0x7a, 0x36, 0x38, 0xbb, 0x1c, - 0x13, 0xf4, 0x8e, 0xf8, 0x15, 0x8b, 0xfc, 0x9d }, - - { 0x75, 0x0c, 0x78, 0x3e, 0x6a, 0xb0, 0xb5, 0x03, - 0xea, 0xa8, 0x6e, 0x31, 0x0a, 0x5d, 0xb7, 0x38 }, - - { 0x56, 0xbe, 0x34, 0x52, 0x1d, 0x14, 0x4c, 0x88, - 0xdb, 0xb8, 0xc7, 0x33, 0xf0, 0xe8, 0xb3, 0xf6 } -}; - -static uint32_t hmac_md5_reference_digest_length[] = { - 12, 12, 12 -}; - -static uint8_t hmac_sha256_reference_key[][HMAC_SHA256_KEY_LEN] = { - { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, - 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, - 0x0b, 0x0b, 0x0b, 0x0b }, - - /* "Jefe" */ - { 0x4a, 0x65, 0x66, 0x65 }, - - { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, - 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, - 0xaa, 0xaa, 0xaa, 0xaa } -}; - -static uint32_t hmac_sha256_reference_length[] = { 8, 28, 50 }; - -static uint8_t -hmac_sha256_reference_plaintext[][HMAC_SHA256_MAX_DATA_LEN] = { - /* "Hi There" */ - { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65}, - - /* what do ya want for nothing?*/ - { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, - 0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, - 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68, - 0x69, 0x6e, 0x67, 0x3f }, - - { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd } -}; - -static uint8_t hmac_sha256_reference_digest[][HMAC_SHA256_DIGEST_LEN] = { - { 0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53, - 0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b }, - - { 0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e, - 0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7 }, - - { 0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46, - 0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7 } -}; - -static uint32_t hmac_sha256_reference_digest_length[] = { - 16, 16, 16 -}; - -static uint8_t hmac_sha1_reference_key[][HMAC_SHA1_KEY_LEN] = { - { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, - 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, - 0x0b, 0x0b, 0x0b, 0x0b }, - - /* "Jefe" */ - { 0x4a, 0x65, 0x66, 0x65 }, - - { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, - 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, - 0xaa, 0xaa, 0xaa, 0xaa } -}; - -static uint32_t hmac_sha1_reference_length[] = { 8, 28, 50 }; - -static uint8_t -hmac_sha1_reference_plaintext[][HMAC_SHA1_MAX_DATA_LEN] = { - /* "Hi There" */ - { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65}, - - /* what do ya want for nothing?*/ - { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, - 0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, - 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68, - 0x69, 0x6e, 0x67, 0x3f }, - - { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd } -}; - -static uint8_t hmac_sha1_reference_digest[][HMAC_SHA1_DIGEST_LEN] = { - { 0xb6, 0x17, 0x31, 0x86, 0x55, 0x05, - 0x72, 0x64, 0xe2, 0x8b, 0xc0, 0xb6 }, - - { 0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb, - 0x2f, 0xa2, 0xd2, 0x74, 0x16, 0xd5 }, - - { 0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac, - 0x11, 0xcd, 0x91, 0xa3, 0x9a, 0xf4 }, -}; - -static uint8_t hmac_sha512_reference_key[][HMAC_SHA512_KEY_LEN] = { - { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, - 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, - 0x0b, 0x0b, 0x0b, 0x0b }, - - /* "Jefe" */ - { 0x4a, 0x65, 0x66, 0x65 }, - - { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, - 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, - 0xaa, 0xaa, 0xaa, 0xaa } -}; - -static uint32_t hmac_sha512_reference_length[] = { 8, 28, 50 }; - -static uint8_t -hmac_sha512_reference_plaintext[][HMAC_SHA512_MAX_DATA_LEN] = { - /* "Hi There" */ - { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65}, - - /* what do ya want for nothing?*/ - { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, - 0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, - 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68, - 0x69, 0x6e, 0x67, 0x3f }, - - { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, - 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd } -}; - -static uint8_t hmac_sha512_reference_digest[][HMAC_SHA512_DIGEST_LEN] = { - { 0x87, 0xaa, 0x7c, 0xde, 0xa5, 0xef, 0x61, 0x9d, - 0x4f, 0xf0, 0xb4, 0x24, 0x1a, 0x1d, 0x6c, 0xb0, - 0x23, 0x79, 0xf4, 0xe2, 0xce, 0x4e, 0xc2, 0x78, - 0x7a, 0xd0, 0xb3, 0x05, 0x45, 0xe1, 0x7c, 0xde }, - - { 0x16, 0x4b, 0x7a, 0x7b, 0xfc, 0xf8, 0x19, 0xe2, - 0xe3, 0x95, 0xfb, 0xe7, 0x3b, 0x56, 0xe0, 0xa3, - 0x87, 0xbd, 0x64, 0x22, 0x2e, 0x83, 0x1f, 0xd6, - 0x10, 0x27, 0x0c, 0xd7, 0xea, 0x25, 0x05, 0x54 }, - - { 0xfa, 0x73, 0xb0, 0x08, 0x9d, 0x56, 0xa2, 0x84, - 0xef, 0xb0, 0xf0, 0x75, 0x6c, 0x89, 0x0b, 0xe9, - 0xb1, 0xb5, 0xdb, 0xdd, 0x8e, 0xe8, 0x1a, 0x36, - 0x55, 0xf8, 0x3e, 0x33, 0xb2, 0x27, 0x9d, 0x39 } +static crypto_test_reference_t hmac_sha512_reference[] = { + { + .auth_key_length = HMAC_SHA512_KEY_LEN, + .auth_key = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b }, + .length = 8, + /* "Hi There" */ + .plaintext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65}, + .ciphertext = { 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65}, + .digest_length = HMAC_SHA512_256_CHECK_LEN, + .digest = { 0x87, 0xaa, 0x7c, 0xde, 0xa5, 0xef, 0x61, 0x9d, + 0x4f, 0xf0, 0xb4, 0x24, 0x1a, 0x1d, 0x6c, 0xb0, + 0x23, 0x79, 0xf4, 0xe2, 0xce, 0x4e, 0xc2, 0x78, + 0x7a, 0xd0, 0xb3, 0x05, 0x45, 0xe1, 0x7c, 0xde } + }, + { + .auth_key_length = HMAC_SHA512_KEY_LEN, + /* "Jefe" */ + .auth_key = { 0x4a, 0x65, 0x66, 0x65 }, + .length = 28, + /* what do ya want for nothing?*/ + .plaintext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, + 0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68, + 0x69, 0x6e, 0x67, 0x3f }, + .ciphertext = { 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, + 0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68, + 0x69, 0x6e, 0x67, 0x3f }, + .digest_length = HMAC_SHA512_256_CHECK_LEN, + .digest = { 0x16, 0x4b, 0x7a, 0x7b, 0xfc, 0xf8, 0x19, 0xe2, + 0xe3, 0x95, 0xfb, 0xe7, 0x3b, 0x56, 0xe0, 0xa3, + 0x87, 0xbd, 0x64, 0x22, 0x2e, 0x83, 0x1f, 0xd6, + 0x10, 0x27, 0x0c, 0xd7, 0xea, 0x25, 0x05, 0x54 } + }, + { + .auth_key_length = HMAC_SHA512_KEY_LEN, + .auth_key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa }, + .length = 50, + .plaintext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd }, + .ciphertext = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd }, + .digest_length = HMAC_SHA512_256_CHECK_LEN, + .digest = { 0xfa, 0x73, 0xb0, 0x08, 0x9d, 0x56, 0xa2, 0x84, + 0xef, 0xb0, 0xf0, 0x75, 0x6c, 0x89, 0x0b, 0xe9, + 0xb1, 0xb5, 0xdb, 0xdd, 0x8e, 0xe8, 0x1a, 0x36, + 0x55, 0xf8, 0x3e, 0x33, 0xb2, 0x27, 0x9d, 0x39 } + } }; #endif diff --git a/test/common_plat/validation/api/crypto/test_vectors_len.h b/test/common_plat/validation/api/crypto/test_vectors_len.h index 20a7ddba..427c564b 100644 --- a/test/common_plat/validation/api/crypto/test_vectors_len.h +++ b/test/common_plat/validation/api/crypto/test_vectors_len.h @@ -6,45 +6,40 @@ #ifndef TEST_VECTORS_LEN_ #define TEST_VECTORS_LEN_ -/* NULL */ -#define NULL_MAX_DATA_LEN 16 +/* Maximum */ +#define MAX_KEY_LEN 64 +#define MAX_IV_LEN 16 +#define MAX_DATA_LEN 128 +#define MAX_AAD_LEN 12 +#define MAX_DIGEST_LEN 64 /* TDES-CBC */ #define TDES_CBC_KEY_LEN 24 #define TDES_CBC_IV_LEN 8 -#define TDES_CBC_MAX_DATA_LEN 16 /* AES128-CBC */ #define AES128_CBC_KEY_LEN 16 #define AES128_CBC_IV_LEN 16 -#define AES128_CBC_MAX_DATA_LEN 64 -/* AES128-CBC */ +/* AES128-GCM */ #define AES128_GCM_KEY_LEN 16 #define AES128_GCM_IV_LEN 12 -#define AES128_GCM_MAX_DATA_LEN 106 #define AES128_GCM_DIGEST_LEN 16 /* HMAC-MD5 */ #define HMAC_MD5_KEY_LEN 16 -#define HMAC_MD5_MAX_DATA_LEN 128 -#define HMAC_MD5_DIGEST_LEN 16 +#define HMAC_MD5_96_CHECK_LEN 12 /* HMAC-SHA256 */ #define HMAC_SHA256_KEY_LEN 32 -#define HMAC_SHA256_MAX_DATA_LEN 128 -#define HMAC_SHA256_DIGEST_LEN 32 +#define HMAC_SHA256_128_CHECK_LEN 16 /* HMAC-SHA1 */ #define HMAC_SHA1_KEY_LEN 20 -#define HMAC_SHA1_MAX_DATA_LEN 128 -#define HMAC_SHA1_DIGEST_LEN 20 #define HMAC_SHA1_96_CHECK_LEN 12 /* HMAC-SHA512 */ #define HMAC_SHA512_KEY_LEN 64 -#define HMAC_SHA512_MAX_DATA_LEN 128 -#define HMAC_SHA512_DIGEST_LEN 64 #define HMAC_SHA512_256_CHECK_LEN 32 #endif From patchwork Mon Aug 21 22:00:16 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Github ODP bot X-Patchwork-Id: 110592 Delivered-To: patch@linaro.org Received: by 10.140.95.78 with SMTP id h72csp1843611qge; Mon, 21 Aug 2017 15:03:06 -0700 (PDT) X-Received: by 10.55.9.20 with SMTP id 20mr24193243qkj.355.1503352986407; Mon, 21 Aug 2017 15:03:06 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1503352986; cv=none; d=google.com; s=arc-20160816; b=upFeW3Wej9j0L93hFtW89pAi61UsQyttFMIzdkQBRprnJBpzLs97WLfdcNsdwNuyZb pYlyDrRxi7SyTrg4Vq+5z+WHNMaW71LTHDM9Ptycg0+BtuUBcxjxlW1NPIdUtEd4asdD x4Tuc/JKbeY3uqoWVEknawL24SYGdhXJw3+qFsK/k8iF8VC+n9DgUewUkgAfmk90DJVm 23Bq93zbWWqYULcTsDUxGw/F3SFcYULO3oeQgSwf9j/ZTEwqRyspDgfR1CO21F2EAWqX TELEbiPSDlNr+ACZRMiql4DkPUvCwozvnMhccavfRhRwO2GBSVcCYd2qNmnkC4nopDRC +fag== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:subject:github-pr-num :references:in-reply-to:message-id:date:to:from:delivered-to :arc-authentication-results; bh=I+y8TykX6WaTmJ2zl5MnRdgdmcHFeUf1ikKmkWUwCVs=; b=K8fN+qe3xmRXz4niW+X9YIwbxqYeGSVzNQB0vOU07rtTrnPHLwNfagDKeXVkneOqHY FRvosfjBeMwGiEwKrDsg+S3SVYeioIN8UCZTyARgy/Con39FNmpo2QWwLxwfaMqT+yVs QV9Du2kfsrWIaLLkR9fAXuRm+SSnVSlaElvDxtQz8ryJTNUXe0AHSQQrHa9dihJf3X5L Zk7pcWJBZtPoZexSwk612iotlfKqkbg+N3A4uYKiuA8J+bnAScjKW1rQebitI/UiPSgg jIlUgZL+4ABmKZEfwhRX+ZVTuFzEs3mCYeFy7OseMx4XA6CMhIOgkoJjSbRNLIzU7zdS r5uQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) smtp.mailfrom=lng-odp-bounces@lists.linaro.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=yandex.ru Return-Path: Received: from lists.linaro.org (lists.linaro.org. [54.225.227.206]) by mx.google.com with ESMTP id x23si3598181qkb.255.2017.08.21.15.03.06; Mon, 21 Aug 2017 15:03:06 -0700 (PDT) Received-SPF: pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) client-ip=54.225.227.206; Authentication-Results: mx.google.com; spf=pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) smtp.mailfrom=lng-odp-bounces@lists.linaro.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=yandex.ru Received: by lists.linaro.org (Postfix, from userid 109) id 01A9664499; Mon, 21 Aug 2017 22:03:05 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on ip-10-142-244-252 X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,URIBL_BLOCKED autolearn=disabled version=3.4.0 Received: from [127.0.0.1] (localhost [127.0.0.1]) by lists.linaro.org (Postfix) with ESMTP id C954B6448F; Mon, 21 Aug 2017 22:01:43 +0000 (UTC) X-Original-To: lng-odp@lists.linaro.org Delivered-To: lng-odp@lists.linaro.org Received: by lists.linaro.org (Postfix, from userid 109) id E638B60CE5; Mon, 21 Aug 2017 22:01:33 +0000 (UTC) Received: from forward100j.mail.yandex.net (forward100j.mail.yandex.net [5.45.198.240]) by lists.linaro.org (Postfix) with ESMTPS id 67FB9644A3 for ; Mon, 21 Aug 2017 22:00:23 +0000 (UTC) Received: from mxback4j.mail.yandex.net (mxback4j.mail.yandex.net [IPv6:2a02:6b8:0:1619::10d]) by forward100j.mail.yandex.net (Yandex) with ESMTP id CB7EB5D83AD5 for ; Tue, 22 Aug 2017 01:00:21 +0300 (MSK) Received: from smtp4p.mail.yandex.net (smtp4p.mail.yandex.net [2a02:6b8:0:1402::15:6]) by mxback4j.mail.yandex.net (nwsmtp/Yandex) with ESMTP id m6yRdBG1nx-0LiSRbQA; Tue, 22 Aug 2017 01:00:21 +0300 Received: by smtp4p.mail.yandex.net (nwsmtp/Yandex) with ESMTPSA id 1rAWfL7pdM-0Lh07UQI; Tue, 22 Aug 2017 01:00:21 +0300 (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (Client certificate not present) From: Github ODP bot To: lng-odp@lists.linaro.org Date: Tue, 22 Aug 2017 01:00:16 +0300 Message-Id: <1503352817-2136-3-git-send-email-odpbot@yandex.ru> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1503352817-2136-1-git-send-email-odpbot@yandex.ru> References: <1503352817-2136-1-git-send-email-odpbot@yandex.ru> Github-pr-num: 94 Subject: [lng-odp] [PATCH API-NEXT v5 2/3] validation: crypto: add AES-192/256 test cases X-BeenThere: lng-odp@lists.linaro.org X-Mailman-Version: 2.1.16 Precedence: list List-Id: "The OpenDataPlane \(ODP\) List" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: lng-odp-bounces@lists.linaro.org Sender: "lng-odp" From: Dmitry Eremin-Solenikov Add testcases for AES192-CBC, AES256-CBC, AES128-GCM, AES256-GCM. Signed-off-by: Dmitry Eremin-Solenikov --- /** Email created from pull request 94 (lumag:crypto-long-keys) ** https://github.com/Linaro/odp/pull/94 ** Patch: https://github.com/Linaro/odp/pull/94.patch ** Base sha: 3547226b19e6982bf74fc8c258b89db2c5f6a39c ** Merge commit sha: 639b51978ac4cd2c4db537873fee719de65e575b **/ test/common_plat/validation/api/crypto/crypto.h | 16 +-- .../validation/api/crypto/odp_crypto_test_inp.c | 80 ++++++------- .../validation/api/crypto/test_vectors.h | 124 ++++++++++++++++++--- .../validation/api/crypto/test_vectors_len.h | 22 +++- 4 files changed, 177 insertions(+), 65 deletions(-) diff --git a/test/common_plat/validation/api/crypto/crypto.h b/test/common_plat/validation/api/crypto/crypto.h index dd15b448..71f862ec 100644 --- a/test/common_plat/validation/api/crypto/crypto.h +++ b/test/common_plat/validation/api/crypto/crypto.h @@ -16,14 +16,14 @@ void crypto_test_enc_alg_3des_cbc(void); void crypto_test_enc_alg_3des_cbc_ovr_iv(void); void crypto_test_dec_alg_3des_cbc(void); void crypto_test_dec_alg_3des_cbc_ovr_iv(void); -void crypto_test_enc_alg_aes128_cbc(void); -void crypto_test_enc_alg_aes128_cbc_ovr_iv(void); -void crypto_test_dec_alg_aes128_cbc(void); -void crypto_test_dec_alg_aes128_cbc_ovr_iv(void); -void crypto_test_enc_alg_aes128_gcm(void); -void crypto_test_enc_alg_aes128_gcm_ovr_iv(void); -void crypto_test_dec_alg_aes128_gcm(void); -void crypto_test_dec_alg_aes128_gcm_ovr_iv(void); +void crypto_test_enc_alg_aes_cbc(void); +void crypto_test_enc_alg_aes_cbc_ovr_iv(void); +void crypto_test_dec_alg_aes_cbc(void); +void crypto_test_dec_alg_aes_cbc_ovr_iv(void); +void crypto_test_enc_alg_aes_gcm(void); +void crypto_test_enc_alg_aes_gcm_ovr_iv(void); +void crypto_test_dec_alg_aes_gcm(void); +void crypto_test_dec_alg_aes_gcm_ovr_iv(void); void crypto_test_gen_alg_hmac_md5(void); void crypto_test_check_alg_hmac_md5(void); void crypto_test_gen_alg_hmac_sha1(void); diff --git a/test/common_plat/validation/api/crypto/odp_crypto_test_inp.c b/test/common_plat/validation/api/crypto/odp_crypto_test_inp.c index 5b41e2ba..d08beaa3 100644 --- a/test/common_plat/validation/api/crypto/odp_crypto_test_inp.c +++ b/test/common_plat/validation/api/crypto/odp_crypto_test_inp.c @@ -707,17 +707,17 @@ static int check_alg_aes_gcm(void) * operation for AES128_GCM algorithm. IV for the operation is the session IV. * In addition the test verifies if the implementation can use the * packet buffer as completion event buffer.*/ -void crypto_test_enc_alg_aes128_gcm(void) +void crypto_test_enc_alg_aes_gcm(void) { - unsigned int test_vec_num = (sizeof(aes128_gcm_reference) / - sizeof(aes128_gcm_reference[0])); + unsigned int test_vec_num = (sizeof(aes_gcm_reference) / + sizeof(aes_gcm_reference[0])); unsigned int i; for (i = 0; i < test_vec_num; i++) { alg_test(ODP_CRYPTO_OP_ENCODE, ODP_CIPHER_ALG_AES_GCM, ODP_AUTH_ALG_AES_GCM, - &aes128_gcm_reference[i], + &aes_gcm_reference[i], false); } } @@ -726,17 +726,17 @@ void crypto_test_enc_alg_aes128_gcm(void) * operation for AES128_GCM algorithm. IV for the operation is the session IV. * In addition the test verifies if the implementation can use the * packet buffer as completion event buffer.*/ -void crypto_test_enc_alg_aes128_gcm_ovr_iv(void) +void crypto_test_enc_alg_aes_gcm_ovr_iv(void) { - unsigned int test_vec_num = (sizeof(aes128_gcm_reference) / - sizeof(aes128_gcm_reference[0])); + unsigned int test_vec_num = (sizeof(aes_gcm_reference) / + sizeof(aes_gcm_reference[0])); unsigned int i; for (i = 0; i < test_vec_num; i++) { alg_test(ODP_CRYPTO_OP_ENCODE, ODP_CIPHER_ALG_AES_GCM, ODP_AUTH_ALG_AES_GCM, - &aes128_gcm_reference[i], + &aes_gcm_reference[i], true); } } @@ -746,17 +746,17 @@ void crypto_test_enc_alg_aes128_gcm_ovr_iv(void) * In addition the test verifies if the implementation can use the * packet buffer as completion event buffer. * */ -void crypto_test_dec_alg_aes128_gcm(void) +void crypto_test_dec_alg_aes_gcm(void) { - unsigned int test_vec_num = (sizeof(aes128_gcm_reference) / - sizeof(aes128_gcm_reference[0])); + unsigned int test_vec_num = (sizeof(aes_gcm_reference) / + sizeof(aes_gcm_reference[0])); unsigned int i; for (i = 0; i < test_vec_num; i++) { alg_test(ODP_CRYPTO_OP_DECODE, ODP_CIPHER_ALG_AES_GCM, ODP_AUTH_ALG_AES_GCM, - &aes128_gcm_reference[i], + &aes_gcm_reference[i], false); } } @@ -766,17 +766,17 @@ void crypto_test_dec_alg_aes128_gcm(void) * In addition the test verifies if the implementation can use the * packet buffer as completion event buffer. * */ -void crypto_test_dec_alg_aes128_gcm_ovr_iv(void) +void crypto_test_dec_alg_aes_gcm_ovr_iv(void) { - unsigned int test_vec_num = (sizeof(aes128_gcm_reference) / - sizeof(aes128_gcm_reference[0])); + unsigned int test_vec_num = (sizeof(aes_gcm_reference) / + sizeof(aes_gcm_reference[0])); unsigned int i; for (i = 0; i < test_vec_num; i++) { alg_test(ODP_CRYPTO_OP_DECODE, ODP_CIPHER_ALG_AES_GCM, ODP_AUTH_ALG_AES_GCM, - &aes128_gcm_reference[i], + &aes_gcm_reference[i], true); } } @@ -790,17 +790,17 @@ static int check_alg_aes_cbc(void) * operation for AES128_CBC algorithm. IV for the operation is the session IV. * In addition the test verifies if the implementation can use the * packet buffer as completion event buffer.*/ -void crypto_test_enc_alg_aes128_cbc(void) +void crypto_test_enc_alg_aes_cbc(void) { - unsigned int test_vec_num = (sizeof(aes128_cbc_reference) / - sizeof(aes128_cbc_reference[0])); + unsigned int test_vec_num = (sizeof(aes_cbc_reference) / + sizeof(aes_cbc_reference[0])); unsigned int i; for (i = 0; i < test_vec_num; i++) { alg_test(ODP_CRYPTO_OP_ENCODE, ODP_CIPHER_ALG_AES_CBC, ODP_AUTH_ALG_NULL, - &aes128_cbc_reference[i], + &aes_cbc_reference[i], false); } } @@ -808,17 +808,17 @@ void crypto_test_enc_alg_aes128_cbc(void) /* This test verifies the correctness of encode (plaintext -> ciphertext) * operation for AES128_CBC algorithm. IV for the operation is the operation IV. * */ -void crypto_test_enc_alg_aes128_cbc_ovr_iv(void) +void crypto_test_enc_alg_aes_cbc_ovr_iv(void) { - unsigned int test_vec_num = (sizeof(aes128_cbc_reference) / - sizeof(aes128_cbc_reference[0])); + unsigned int test_vec_num = (sizeof(aes_cbc_reference) / + sizeof(aes_cbc_reference[0])); unsigned int i; for (i = 0; i < test_vec_num; i++) { alg_test(ODP_CRYPTO_OP_ENCODE, ODP_CIPHER_ALG_AES_CBC, ODP_AUTH_ALG_NULL, - &aes128_cbc_reference[i], + &aes_cbc_reference[i], true); } } @@ -828,17 +828,17 @@ void crypto_test_enc_alg_aes128_cbc_ovr_iv(void) * In addition the test verifies if the implementation can use the * packet buffer as completion event buffer. * */ -void crypto_test_dec_alg_aes128_cbc(void) +void crypto_test_dec_alg_aes_cbc(void) { - unsigned int test_vec_num = (sizeof(aes128_cbc_reference) / - sizeof(aes128_cbc_reference[0])); + unsigned int test_vec_num = (sizeof(aes_cbc_reference) / + sizeof(aes_cbc_reference[0])); unsigned int i; for (i = 0; i < test_vec_num; i++) { alg_test(ODP_CRYPTO_OP_DECODE, ODP_CIPHER_ALG_AES_CBC, ODP_AUTH_ALG_NULL, - &aes128_cbc_reference[i], + &aes_cbc_reference[i], false); } } @@ -848,17 +848,17 @@ void crypto_test_dec_alg_aes128_cbc(void) * In addition the test verifies if the implementation can use the * packet buffer as completion event buffer. * */ -void crypto_test_dec_alg_aes128_cbc_ovr_iv(void) +void crypto_test_dec_alg_aes_cbc_ovr_iv(void) { - unsigned int test_vec_num = (sizeof(aes128_cbc_reference) / - sizeof(aes128_cbc_reference[0])); + unsigned int test_vec_num = (sizeof(aes_cbc_reference) / + sizeof(aes_cbc_reference[0])); unsigned int i; for (i = 0; i < test_vec_num; i++) { alg_test(ODP_CRYPTO_OP_DECODE, ODP_CIPHER_ALG_AES_CBC, ODP_AUTH_ALG_NULL, - &aes128_cbc_reference[i], + &aes_cbc_reference[i], true); } } @@ -1088,21 +1088,21 @@ odp_testinfo_t crypto_suite[] = { check_alg_3des_cbc), ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_3des_cbc_ovr_iv, check_alg_3des_cbc), - ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes128_cbc, + ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_cbc, check_alg_aes_cbc), - ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes128_cbc, + ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_cbc, check_alg_aes_cbc), - ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes128_cbc_ovr_iv, + ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_cbc_ovr_iv, check_alg_aes_cbc), - ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes128_cbc_ovr_iv, + ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_cbc_ovr_iv, check_alg_aes_cbc), - ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes128_gcm, + ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_gcm, check_alg_aes_gcm), - ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes128_gcm_ovr_iv, + ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_gcm_ovr_iv, check_alg_aes_gcm), - ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes128_gcm, + ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_gcm, check_alg_aes_gcm), - ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes128_gcm_ovr_iv, + ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_gcm_ovr_iv, check_alg_aes_gcm), ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_hmac_md5, check_alg_hmac_md5), diff --git a/test/common_plat/validation/api/crypto/test_vectors.h b/test/common_plat/validation/api/crypto/test_vectors.h index f9ca9eb5..652968be 100644 --- a/test/common_plat/validation/api/crypto/test_vectors.h +++ b/test/common_plat/validation/api/crypto/test_vectors.h @@ -70,12 +70,12 @@ static crypto_test_reference_t tdes_cbc_reference[] = { } }; -static crypto_test_reference_t aes128_cbc_reference[] = { +static crypto_test_reference_t aes_cbc_reference[] = { { .cipher_key_length = AES128_CBC_KEY_LEN, .cipher_key = { 0x06, 0xa9, 0x21, 0x40, 0x36, 0xb8, 0xa1, 0x5b, 0x51, 0x2e, 0x03, 0xd5, 0x34, 0x12, 0x00, 0x06}, - .iv_length = AES128_CBC_IV_LEN, + .iv_length = AES_CBC_IV_LEN, .iv = { 0x3d, 0xaf, 0xba, 0x42, 0x9d, 0x9e, 0xb4, 0x30, 0xb4, 0x22, 0xda, 0x80, 0x2c, 0x9f, 0xac, 0x41 }, .length = 16, @@ -87,7 +87,7 @@ static crypto_test_reference_t aes128_cbc_reference[] = { .cipher_key_length = AES128_CBC_KEY_LEN, .cipher_key = { 0xc2, 0x86, 0x69, 0x6d, 0x88, 0x7c, 0x9a, 0xa0, 0x61, 0x1b, 0xbb, 0x3e, 0x20, 0x25, 0xa4, 0x5a}, - .iv_length = AES128_CBC_IV_LEN, + .iv_length = AES_CBC_IV_LEN, .iv = { 0x56, 0x2e, 0x17, 0x99, 0x6d, 0x09, 0x3d, 0x28, 0xdd, 0xb3, 0xba, 0x69, 0x5a, 0x2e, 0x6f, 0x58 }, .length = 32, @@ -104,7 +104,7 @@ static crypto_test_reference_t aes128_cbc_reference[] = { .cipher_key_length = AES128_CBC_KEY_LEN, .cipher_key = { 0x6c, 0x3e, 0xa0, 0x47, 0x76, 0x30, 0xce, 0x21, 0xa2, 0xce, 0x33, 0x4a, 0xa7, 0x46, 0xc2, 0xcd}, - .iv_length = AES128_CBC_IV_LEN, + .iv_length = AES_CBC_IV_LEN, .iv = { 0xc7, 0x82, 0xdc, 0x4c, 0x09, 0x8c, 0x66, 0xcb, 0xd9, 0xcd, 0x27, 0xd8, 0x25, 0x68, 0x2c, 0x81 }, .length = 48, @@ -120,7 +120,7 @@ static crypto_test_reference_t aes128_cbc_reference[] = { .cipher_key_length = AES128_CBC_KEY_LEN, .cipher_key = { 0x56, 0xe4, 0x7a, 0x38, 0xc5, 0x59, 0x89, 0x74, 0xbc, 0x46, 0x90, 0x3d, 0xba, 0x29, 0x03, 0x49}, - .iv_length = AES128_CBC_IV_LEN, + .iv_length = AES_CBC_IV_LEN, .iv = { 0x8c, 0xe8, 0x2e, 0xef, 0xbe, 0xa0, 0xda, 0x3c, 0x44, 0x69, 0x9e, 0xd7, 0xdb, 0x51, 0xb7, 0xd9 }, .length = 64, @@ -140,18 +140,59 @@ static crypto_test_reference_t aes128_cbc_reference[] = { 0x86, 0x8b, 0xb7, 0xb2, 0x9d, 0x3d, 0x46, 0xad, 0x83, 0xce, 0x9f, 0x9a, 0x10, 0x2e, 0xe9, 0x9d, 0x49, 0xa5, 0x3e, 0x87, 0xf4, 0xc3, 0xda, 0x55 } + }, + { + .cipher_key_length = AES192_CBC_KEY_LEN, + .cipher_key = { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c, + 0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08, + 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c}, + .iv_length = AES_CBC_IV_LEN, + .iv = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad, + 0xde, 0xca, 0xf8, 0x88, 0x01, 0x23, 0x45, 0x67 }, + .length = 32, + .plaintext = { 0x45, 0x00, 0x00, 0x28, 0xa4, 0xad, 0x40, 0x00, + 0x40, 0x06, 0x78, 0x80, 0x0a, 0x01, 0x03, 0x8f, + 0x0a, 0x01, 0x06, 0x12, 0x80, 0x23, 0x06, 0xb8, + 0xcb, 0x71, 0x26, 0x02, 0xdd, 0x6b, 0xb0, 0x3e }, + .ciphertext = { 0x0d, 0xbe, 0x02, 0xda, 0x68, 0x9c, 0x8f, 0x30, + 0xce, 0x7c, 0x91, 0x7d, 0x41, 0x08, 0xf6, 0xf1, + 0x8e, 0x0d, 0x7f, 0x02, 0xb6, 0x80, 0x9a, 0x2d, + 0x53, 0x1c, 0xc6, 0x98, 0x85, 0xc3, 0x00, 0xe6}, + }, + { + .cipher_key_length = AES256_CBC_KEY_LEN, + .cipher_key = { 0xab, 0xbc, 0xcd, 0xde, 0xf0, 0x01, 0x12, 0x23, + 0x34, 0x45, 0x56, 0x67, 0x78, 0x89, 0x9a, 0xab, + 0xab, 0xbc, 0xcd, 0xde, 0xf0, 0x01, 0x12, 0x23, + 0x34, 0x45, 0x56, 0x67, 0x78, 0x89, 0x9a, 0xab}, + .iv_length = AES_CBC_IV_LEN, + .iv = { 0x11, 0x22, 0x33, 0x44, 0x01, 0x02, 0x03, 0x04, + 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c }, + .length = 48, + .plaintext = { 0x45, 0x00, 0x00, 0x30, 0x69, 0xa6, 0x40, 0x00, + 0x80, 0x06, 0x26, 0x90, 0xc0, 0xa8, 0x01, 0x02, + 0x93, 0x89, 0x15, 0x5e, 0x0a, 0x9e, 0x00, 0x8b, + 0x2d, 0xc5, 0x7e, 0xe0, 0x00, 0x00, 0x00, 0x00, + 0x70, 0x02, 0x40, 0x00, 0x20, 0xbf, 0x00, 0x00, + 0x02, 0x04, 0x05, 0xb4, 0x01, 0x01, 0x04, 0x02 }, + .ciphertext = { 0x92, 0x1e, 0x2f, 0x37, 0x36, 0x3c, 0x45, 0xda, + 0xc9, 0x58, 0xb7, 0x07, 0x06, 0x56, 0x54, 0xc5, + 0x93, 0x46, 0x90, 0xb8, 0xcf, 0x0d, 0x4f, 0x79, + 0xf1, 0x32, 0xc2, 0xf7, 0x23, 0xb8, 0x83, 0x09, + 0xbc, 0x37, 0x1c, 0xeb, 0x95, 0x2c, 0x42, 0x7b, + 0x39, 0x10, 0xa8, 0x76, 0xfa, 0xbe, 0x91, 0xe9}, } }; /* AES-GCM test vectors extracted from * https://tools.ietf.org/html/draft-mcgrew-gcm-test-01#section-2 */ -static crypto_test_reference_t aes128_gcm_reference[] = { +static crypto_test_reference_t aes_gcm_reference[] = { { .cipher_key_length = AES128_GCM_KEY_LEN, .cipher_key = { 0x4c, 0x80, 0xcd, 0xef, 0xbb, 0x5d, 0x10, 0xda, 0x90, 0x6a, 0xc7, 0x3c, 0x36, 0x13, 0xa6, 0x34}, - .iv_length = AES128_GCM_IV_LEN, + .iv_length = AES_GCM_IV_LEN, .iv = { 0x2e, 0x44, 0x3b, 0x68, 0x49, 0x56, 0xed, 0x7e, 0x3b, 0x24, 0x4c, 0xfe }, .length = 72, @@ -176,7 +217,7 @@ static crypto_test_reference_t aes128_gcm_reference[] = { .aad_length = 12, .aad = { 0x00, 0x00, 0x43, 0x21, 0x87, 0x65, 0x43, 0x21, 0x00, 0x00, 0x00, 0x00 }, - .digest_length = AES128_GCM_DIGEST_LEN, + .digest_length = AES_GCM_DIGEST_LEN, .digest = { 0x45, 0x90, 0x18, 0x14, 0x8f, 0x6c, 0xbe, 0x72, 0x2f, 0xd0, 0x47, 0x96, 0x56, 0x2d, 0xfd, 0xb4 } }, @@ -184,7 +225,7 @@ static crypto_test_reference_t aes128_gcm_reference[] = { .cipher_key_length = AES128_GCM_KEY_LEN, .cipher_key = { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c, 0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08}, - .iv_length = AES128_GCM_IV_LEN, + .iv_length = AES_GCM_IV_LEN, .iv = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad, 0xde, 0xca, 0xf8, 0x88 }, .length = 64, @@ -206,7 +247,7 @@ static crypto_test_reference_t aes128_gcm_reference[] = { 0xec, 0x3b, 0x9b, 0xa9, 0x5d, 0x91, 0x8b, 0xd1}, .aad_length = 8, .aad = { 0x00, 0x00, 0xa5, 0xf8, 0x00, 0x00, 0x00, 0x0a }, - .digest_length = AES128_GCM_DIGEST_LEN, + .digest_length = AES_GCM_DIGEST_LEN, .digest = { 0x83, 0xb7, 0x0d, 0x3a, 0xa8, 0xbc, 0x6e, 0xe4, 0xc3, 0x09, 0xe9, 0xd8, 0x5a, 0x41, 0xad, 0x4a } }, @@ -214,7 +255,7 @@ static crypto_test_reference_t aes128_gcm_reference[] = { .cipher_key_length = AES128_GCM_KEY_LEN, .cipher_key = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - .iv_length = AES128_GCM_IV_LEN, + .iv_length = AES_GCM_IV_LEN, .iv = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, .length = 64, @@ -236,7 +277,7 @@ static crypto_test_reference_t aes128_gcm_reference[] = { 0x1d, 0x19, 0xd4, 0xd5, 0xc8, 0xc1, 0x8a, 0xf3}, .aad_length = 8, .aad = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, - .digest_length = AES128_GCM_DIGEST_LEN, + .digest_length = AES_GCM_DIGEST_LEN, .digest = { 0xf8, 0x21, 0xd4, 0x96, 0xee, 0xb0, 0x96, 0xe9, 0x8a, 0xd2, 0xb6, 0x9e, 0x47, 0x99, 0xc7, 0x1d } }, @@ -244,7 +285,7 @@ static crypto_test_reference_t aes128_gcm_reference[] = { .cipher_key_length = AES128_GCM_KEY_LEN, .cipher_key = { 0x3d, 0xe0, 0x98, 0x74, 0xb3, 0x88, 0xe6, 0x49, 0x19, 0x88, 0xd0, 0xc3, 0x60, 0x7e, 0xae, 0x1f}, - .iv_length = AES128_GCM_IV_LEN, + .iv_length = AES_GCM_IV_LEN, .iv = { 0x57, 0x69, 0x0e, 0x43, 0x4e, 0x28, 0x00, 0x00, 0xa2, 0xfc, 0xa1, 0xa3 }, .length = 28, @@ -259,10 +300,65 @@ static crypto_test_reference_t aes128_gcm_reference[] = { .aad_length = 12, .aad = { 0x42, 0xf6, 0x7e, 0x3f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 }, - .digest_length = AES128_GCM_DIGEST_LEN, + .digest_length = AES_GCM_DIGEST_LEN, .digest = { 0x36, 0x9f, 0x07, 0x1f, 0x35, 0xe0, 0x34, 0xbe, 0x95, 0xf1, 0x12, 0xe4, 0xe7, 0xd0, 0x5d, 0x35 } }, + { + .cipher_key_length = AES192_GCM_KEY_LEN, + .cipher_key = { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c, + 0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08, + 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c}, + .iv_length = AES_GCM_IV_LEN, + .iv = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad, + 0xde, 0xca, 0xf8, 0x88 }, + .length = 40, + .plaintext = { 0x45, 0x00, 0x00, 0x28, 0xa4, 0xad, 0x40, 0x00, + 0x40, 0x06, 0x78, 0x80, 0x0a, 0x01, 0x03, 0x8f, + 0x0a, 0x01, 0x06, 0x12, 0x80, 0x23, 0x06, 0xb8, + 0xcb, 0x71, 0x26, 0x02, 0xdd, 0x6b, 0xb0, 0x3e, + 0x50, 0x10, 0x16, 0xd0, 0x75, 0x68, 0x00, 0x01 }, + .ciphertext = { 0xa5, 0xb1, 0xf8, 0x06, 0x60, 0x29, 0xae, 0xa4, + 0x0e, 0x59, 0x8b, 0x81, 0x22, 0xde, 0x02, 0x42, + 0x09, 0x38, 0xb3, 0xab, 0x33, 0xf8, 0x28, 0xe6, + 0x87, 0xb8, 0x85, 0x8b, 0x5b, 0xfb, 0xdb, 0xd0, + 0x31, 0x5b, 0x27, 0x45, 0x21, 0x44, 0xcc, 0x77}, + .aad_length = 8, + .aad = { 0x00, 0x00, 0xa5, 0xf8, 0x00, 0x00, 0x00, 0x0a }, + .digest_length = AES_GCM_DIGEST_LEN, + .digest = { 0x95, 0x45, 0x7b, 0x96, 0x52, 0x03, 0x7f, 0x53, + 0x18, 0x02, 0x7b, 0x5b, 0x4c, 0xd7, 0xa6, 0x36 } + }, + { + .cipher_key_length = AES256_GCM_KEY_LEN, + .cipher_key = { 0xab, 0xbc, 0xcd, 0xde, 0xf0, 0x01, 0x12, 0x23, + 0x34, 0x45, 0x56, 0x67, 0x78, 0x89, 0x9a, 0xab, + 0xab, 0xbc, 0xcd, 0xde, 0xf0, 0x01, 0x12, 0x23, + 0x34, 0x45, 0x56, 0x67, 0x78, 0x89, 0x9a, 0xab}, + .iv_length = AES_GCM_IV_LEN, + .iv = { 0x11, 0x22, 0x33, 0x44, 0x01, 0x02, 0x03, 0x04, 0x05, + 0x06, 0x07, 0x08 }, + .length = 52, + .plaintext = { 0x45, 0x00, 0x00, 0x30, 0x69, 0xa6, 0x40, 0x00, + 0x80, 0x06, 0x26, 0x90, 0xc0, 0xa8, 0x01, 0x02, + 0x93, 0x89, 0x15, 0x5e, 0x0a, 0x9e, 0x00, 0x8b, + 0x2d, 0xc5, 0x7e, 0xe0, 0x00, 0x00, 0x00, 0x00, + 0x70, 0x02, 0x40, 0x00, 0x20, 0xbf, 0x00, 0x00, + 0x02, 0x04, 0x05, 0xb4, 0x01, 0x01, 0x04, 0x02, + 0x01, 0x02, 0x02, 0x01 }, + .ciphertext = { 0xff, 0x42, 0x5c, 0x9b, 0x72, 0x45, 0x99, 0xdf, + 0x7a, 0x3b, 0xcd, 0x51, 0x01, 0x94, 0xe0, 0x0d, + 0x6a, 0x78, 0x10, 0x7f, 0x1b, 0x0b, 0x1c, 0xbf, + 0x06, 0xef, 0xae, 0x9d, 0x65, 0xa5, 0xd7, 0x63, + 0x74, 0x8a, 0x63, 0x79, 0x85, 0x77, 0x1d, 0x34, + 0x7f, 0x05, 0x45, 0x65, 0x9f, 0x14, 0xe9, 0x9d, + 0xef, 0x84, 0x2d, 0x8e }, + .aad_length = 8, + .aad = { 0x4a, 0x2c, 0xbf, 0xe3, 0x00, 0x00, 0x00, 0x02 }, + .digest_length = AES_GCM_DIGEST_LEN, + .digest = { 0xb3, 0x35, 0xf4, 0xee, 0xcf, 0xdb, 0xf8, 0x31, + 0x82, 0x4b, 0x4c, 0x49, 0x15, 0x95, 0x6c, 0x96 } + } }; static crypto_test_reference_t hmac_md5_reference[] = { diff --git a/test/common_plat/validation/api/crypto/test_vectors_len.h b/test/common_plat/validation/api/crypto/test_vectors_len.h index 427c564b..b1ce719e 100644 --- a/test/common_plat/validation/api/crypto/test_vectors_len.h +++ b/test/common_plat/validation/api/crypto/test_vectors_len.h @@ -17,14 +17,30 @@ #define TDES_CBC_KEY_LEN 24 #define TDES_CBC_IV_LEN 8 +/* AES-CBC common */ +#define AES_CBC_IV_LEN 16 + /* AES128-CBC */ #define AES128_CBC_KEY_LEN 16 -#define AES128_CBC_IV_LEN 16 + +/* AES192-CBC */ +#define AES192_CBC_KEY_LEN 24 + +/* AES256-CBC */ +#define AES256_CBC_KEY_LEN 32 + +/* AES-GCM common */ +#define AES_GCM_IV_LEN 12 +#define AES_GCM_DIGEST_LEN 16 /* AES128-GCM */ #define AES128_GCM_KEY_LEN 16 -#define AES128_GCM_IV_LEN 12 -#define AES128_GCM_DIGEST_LEN 16 + +/* AES192-GCM */ +#define AES192_GCM_KEY_LEN 24 + +/* AES256-GCM */ +#define AES256_GCM_KEY_LEN 32 /* HMAC-MD5 */ #define HMAC_MD5_KEY_LEN 16 From patchwork Mon Aug 21 22:00:17 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Github ODP bot X-Patchwork-Id: 110591 Delivered-To: patch@linaro.org Received: by 10.140.95.78 with SMTP id h72csp1842867qge; Mon, 21 Aug 2017 15:02:23 -0700 (PDT) X-Received: by 10.55.41.10 with SMTP id p10mr26661878qkh.112.1503352943413; Mon, 21 Aug 2017 15:02:23 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1503352943; cv=none; d=google.com; s=arc-20160816; b=leXW6OGTuPuXO4vChzO9GkqCL3vV/cwPicK8QhDmrcoeq2tzWv4+GEGswIiwcv6EyX yXiwDXVsl8J7jLaGNVp1lxjlY8Mc4rQ2yPZ+Ltbl/x7CHuFfYCwDDnX+sTts/86lRWQN DATqHiijjamLi1sApd2DnS89i6ZTP77fMNxEtQ7529dvVhe4Zjo1vo5UHNJH2ahw+Sm9 aaf1Vbvet1cLKy8QaIMkihp0GwPpComMHnFY1Tm/Tx54f+3chy1HVMCHRrmIHwOa911N fJWkFau9wTAaTftl57UxKYS+e8dqYyVo32GUIAoxzUgX5ljqJGgVes/geLm5gLIl+2G/ KhkA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:subject:github-pr-num :references:in-reply-to:message-id:date:to:from:delivered-to :arc-authentication-results; bh=2xxeI6QZJ+vsYHxEaZLaRIOjOaHuMdaPpQdPgi9O+ro=; b=rV52TO638ZBX5/kCwDYLV1ghwGMHx3WvDkR++/kni1dxo0C+LqoMVYmi/V0vkFA8D1 l09vLul21FADB60KFGeXQCVi3ko6Nyq/oEST7YFvqOaaHy8RxJDo7n1WVHKhywUkYasj xXU0rRPjKZLJS4T8vd/iWlrD/zwvDK/0LPNKRJogyozA99n48R7//6TOxO/zYEkEPDd/ sNtpmCivCIRh4Nll5aBOqkSQSNguD4tMwNAsqFLRKFDck3rq06Oe9fNcn6JFV1uN2sYm BZTa7yk7s8shd1dW1S1y/qiJvHdJgb0OqYBJ+aNhX9X0G0SkE0gtfKXqn/sdx6vez8Ui XWFA== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) smtp.mailfrom=lng-odp-bounces@lists.linaro.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=yandex.ru Return-Path: Received: from lists.linaro.org (lists.linaro.org. [54.225.227.206]) by mx.google.com with ESMTP id 55si12299446qto.323.2017.08.21.15.02.23; Mon, 21 Aug 2017 15:02:23 -0700 (PDT) Received-SPF: pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) client-ip=54.225.227.206; Authentication-Results: mx.google.com; spf=pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) smtp.mailfrom=lng-odp-bounces@lists.linaro.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=yandex.ru Received: by lists.linaro.org (Postfix, from userid 109) id 02E00608D3; Mon, 21 Aug 2017 22:02:22 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on ip-10-142-244-252 X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,FREEMAIL_FROM, RCVD_IN_DNSWL_NONE,URIBL_BLOCKED autolearn=disabled version=3.4.0 Received: from [127.0.0.1] (localhost [127.0.0.1]) by lists.linaro.org (Postfix) with ESMTP id 73B6260CD7; Mon, 21 Aug 2017 22:01:35 +0000 (UTC) X-Original-To: lng-odp@lists.linaro.org Delivered-To: lng-odp@lists.linaro.org Received: by lists.linaro.org (Postfix, from userid 109) id EA54760CD7; Mon, 21 Aug 2017 22:01:29 +0000 (UTC) Received: from forward100j.mail.yandex.net (forward100j.mail.yandex.net [5.45.198.240]) by lists.linaro.org (Postfix) with ESMTPS id 640876449C for ; Mon, 21 Aug 2017 22:00:23 +0000 (UTC) Received: from mxback11g.mail.yandex.net (mxback11g.mail.yandex.net [IPv6:2a02:6b8:0:1472:2741:0:8b7:90]) by forward100j.mail.yandex.net (Yandex) with ESMTP id 5F4A25D83AC2 for ; Tue, 22 Aug 2017 01:00:22 +0300 (MSK) Received: from smtp4p.mail.yandex.net (smtp4p.mail.yandex.net [2a02:6b8:0:1402::15:6]) by mxback11g.mail.yandex.net (nwsmtp/Yandex) with ESMTP id QutltVG0YA-0MoixYcK; Tue, 22 Aug 2017 01:00:22 +0300 Received: by smtp4p.mail.yandex.net (nwsmtp/Yandex) with ESMTPSA id 1rAWfL7pdM-0Lh8qxTf; Tue, 22 Aug 2017 01:00:21 +0300 (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (Client certificate not present) From: Github ODP bot To: lng-odp@lists.linaro.org Date: Tue, 22 Aug 2017 01:00:17 +0300 Message-Id: <1503352817-2136-4-git-send-email-odpbot@yandex.ru> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1503352817-2136-1-git-send-email-odpbot@yandex.ru> References: <1503352817-2136-1-git-send-email-odpbot@yandex.ru> Github-pr-num: 94 Subject: [lng-odp] [PATCH API-NEXT v5 3/3] linux-gen: crypto: add support for AES-192 and AES-256 X-BeenThere: lng-odp@lists.linaro.org X-Mailman-Version: 2.1.16 Precedence: list List-Id: "The OpenDataPlane \(ODP\) List" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: lng-odp-bounces@lists.linaro.org Sender: "lng-odp" From: Dmitry Eremin-Solenikov Add support for AES with keys of 192 and 256 bits. Signed-off-by: Dmitry Eremin-Solenikov --- /** Email created from pull request 94 (lumag:crypto-long-keys) ** https://github.com/Linaro/odp/pull/94 ** Patch: https://github.com/Linaro/odp/pull/94.patch ** Base sha: 3547226b19e6982bf74fc8c258b89db2c5f6a39c ** Merge commit sha: 639b51978ac4cd2c4db537873fee719de65e575b **/ platform/linux-generic/odp_crypto.c | 44 ++++++++++++++++++++++++++++++------- 1 file changed, 36 insertions(+), 8 deletions(-) diff --git a/platform/linux-generic/odp_crypto.c b/platform/linux-generic/odp_crypto.c index af166c5d..f7d5d013 100644 --- a/platform/linux-generic/odp_crypto.c +++ b/platform/linux-generic/odp_crypto.c @@ -44,10 +44,14 @@ static const odp_crypto_cipher_capability_t cipher_capa_trides_cbc[] = { {.key_len = 24, .iv_len = 8} }; static const odp_crypto_cipher_capability_t cipher_capa_aes_cbc[] = { -{.key_len = 16, .iv_len = 16} }; +{.key_len = 16, .iv_len = 16}, +{.key_len = 24, .iv_len = 16}, +{.key_len = 32, .iv_len = 16} }; static const odp_crypto_cipher_capability_t cipher_capa_aes_gcm[] = { -{.key_len = 16, .iv_len = 12} }; +{.key_len = 16, .iv_len = 12}, +{.key_len = 24, .iv_len = 12}, +{.key_len = 32, .iv_len = 12} }; /* * Authentication algorithm capabilities @@ -741,23 +745,47 @@ odp_crypto_session_create(odp_crypto_session_param_t *param, case ODP_CIPHER_ALG_3DES_CBC: rc = process_cipher_param(session, EVP_des_ede3_cbc()); break; - case ODP_CIPHER_ALG_AES_CBC: #if ODP_DEPRECATED_API case ODP_CIPHER_ALG_AES128_CBC: + if (param->cipher_key.length == 16) + rc = process_cipher_param(session, EVP_aes_128_cbc()); + else + rc = -1; + break; #endif - rc = process_cipher_param(session, EVP_aes_128_cbc()); + case ODP_CIPHER_ALG_AES_CBC: + if (param->cipher_key.length == 16) + rc = process_cipher_param(session, EVP_aes_128_cbc()); + else if (param->cipher_key.length == 24) + rc = process_cipher_param(session, EVP_aes_192_cbc()); + else if (param->cipher_key.length == 32) + rc = process_cipher_param(session, EVP_aes_256_cbc()); + else + rc = -1; break; #if ODP_DEPRECATED_API case ODP_CIPHER_ALG_AES128_GCM: - if (param->auth_alg == ODP_AUTH_ALG_AES128_GCM) - aes_gcm = 1; - /* Fallthrough */ + /* AES-GCM requires to do both auth and + * cipher at the same time */ + if (param->auth_alg != ODP_AUTH_ALG_AES128_GCM) + rc = -1; + else if (param->cipher_key.length == 16) + rc = process_aes_gcm_param(session, EVP_aes_128_gcm()); + else + rc = -1; + break; #endif case ODP_CIPHER_ALG_AES_GCM: /* AES-GCM requires to do both auth and * cipher at the same time */ - if (param->auth_alg == ODP_AUTH_ALG_AES_GCM || aes_gcm) + if (param->auth_alg != ODP_AUTH_ALG_AES_GCM) + rc = -1; + else if (param->cipher_key.length == 16) rc = process_aes_gcm_param(session, EVP_aes_128_gcm()); + else if (param->cipher_key.length == 24) + rc = process_aes_gcm_param(session, EVP_aes_192_gcm()); + else if (param->cipher_key.length == 32) + rc = process_aes_gcm_param(session, EVP_aes_256_gcm()); else rc = -1; break;