From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga03.intel.com (mga03.intel.com [134.134.136.65]) by dpdk.org (Postfix) with ESMTP id 38AFCFFA for ; Thu, 10 Mar 2016 17:44:55 +0100 (CET) Received: from fmsmga003.fm.intel.com ([10.253.24.29]) by orsmga103.jf.intel.com with ESMTP; 10 Mar 2016 08:44:54 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.24,316,1455004800"; d="scan'208";a="667136074" Received: from sie-lab-214-241.ir.intel.com (HELO silpixa00382162.ir.intel.com) ([10.237.214.241]) by FMSMGA003.fm.intel.com with ESMTP; 10 Mar 2016 08:44:53 -0800 From: Deepak Kumar JAIN To: dev@dpdk.org Date: Thu, 10 Mar 2016 17:44:10 +0000 Message-Id: <1457631850-205240-1-git-send-email-deepak.k.jain@intel.com> X-Mailer: git-send-email 2.1.0 Subject: [dpdk-dev] [PATCH] snow3g: Bit-wise handling for Wireless Algorithm X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: patches and discussions about DPDK List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 10 Mar 2016 16:44:56 -0000 Wireless algorithms like Snow3G needs input in bits. In this patch, changes have been made to incorporate this requirement in both QAT and SW PMD. Signed-off-by: Deepak Kumar JAIN --- This patch depends on "pmd/snow3g: add new SNOW 3G SW PMD" patch (http://dpdk.org/ml/archives/dev/2016-March/035466.html) app/test/test_cryptodev.c | 118 ++++++++++++--------- app/test/test_cryptodev_snow3g_hash_test_vectors.h | 34 +++++- app/test/test_cryptodev_snow3g_test_vectors.h | 92 +++++++++++++--- doc/guides/cryptodevs/qat.rst | 2 + doc/guides/cryptodevs/snow3g.rst | 2 + drivers/crypto/qat/qat_crypto.c | 26 ++++- drivers/crypto/snow3g/rte_snow3g_pmd.c | 33 ++++-- lib/librte_cryptodev/rte_crypto_sym.h | 16 +++ 8 files changed, 247 insertions(+), 76 deletions(-) diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c index 595b9f9..c432c05 100644 --- a/app/test/test_cryptodev.c +++ b/app/test/test_cryptodev.c @@ -1828,7 +1828,8 @@ create_snow3g_cipher_session(uint8_t dev_id, static int create_snow3g_cipher_operation(const uint8_t *iv, const unsigned iv_len, - const unsigned data_len) + const unsigned cipher_len, + const unsigned cipher_offset) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; @@ -1860,8 +1861,8 @@ create_snow3g_cipher_operation(const uint8_t *iv, const unsigned iv_len, sym_op->cipher.iv.length = iv_pad_len; rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); - sym_op->cipher.data.length = data_len; - sym_op->cipher.data.offset = iv_pad_len; + sym_op->cipher.data.length = cipher_len; + sym_op->cipher.data.offset = cipher_offset; return 0; } @@ -1958,8 +1959,9 @@ static int create_snow3g_hash_operation(const uint8_t *auth_tag, const unsigned auth_tag_len, const uint8_t *aad, const unsigned aad_len, - const unsigned data_len, unsigned data_pad_len, - enum rte_crypto_auth_operation op) + unsigned data_pad_len, + enum rte_crypto_auth_operation op, + const unsigned auth_len, const unsigned auth_offset) { struct crypto_testsuite_params *ts_params = &testsuite_params; @@ -2027,8 +2029,8 @@ create_snow3g_hash_operation(const uint8_t *auth_tag, sym_op->auth.digest.length); #endif - sym_op->auth.data.length = data_len; - sym_op->auth.data.offset = aad_buffer_len; + sym_op->auth.data.length = auth_len; + sym_op->auth.data.offset = auth_offset; return 0; } @@ -2037,9 +2039,11 @@ static int create_snow3g_cipher_hash_operation(const uint8_t *auth_tag, const unsigned auth_tag_len, const uint8_t *aad, const unsigned aad_len, - const unsigned data_len, unsigned data_pad_len, + unsigned data_pad_len, enum rte_crypto_auth_operation op, - const uint8_t *iv, const unsigned iv_len) + const uint8_t *iv, const unsigned iv_len, + const unsigned cipher_len, const unsigned cipher_offset, + const unsigned auth_len, const unsigned auth_offset) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; @@ -2074,8 +2078,8 @@ create_snow3g_cipher_hash_operation(const uint8_t *auth_tag, rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); - sym_op->cipher.data.length = data_len; - sym_op->cipher.data.offset = iv_pad_len; + sym_op->cipher.data.length = cipher_len; + sym_op->cipher.data.offset = cipher_offset; /* aad */ /* @@ -2124,8 +2128,8 @@ create_snow3g_cipher_hash_operation(const uint8_t *auth_tag, sym_op->auth.digest.length); #endif - sym_op->auth.data.length = data_len; - sym_op->auth.data.offset = aad_buffer_len; + sym_op->auth.data.length = auth_len; + sym_op->auth.data.offset = auth_offset; return 0; } @@ -2134,7 +2138,9 @@ static int create_snow3g_auth_cipher_operation(const unsigned auth_tag_len, const uint8_t *iv, const unsigned iv_len, const uint8_t *aad, const unsigned aad_len, - const unsigned data_len, unsigned data_pad_len) + unsigned data_pad_len, + const unsigned cipher_len, const unsigned cipher_offset, + const unsigned auth_len, const unsigned auth_offset) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; @@ -2213,11 +2219,11 @@ create_snow3g_auth_cipher_operation(const unsigned auth_tag_len, sym_op->auth.aad.data, aad_len); #endif - sym_op->cipher.data.length = data_len; - sym_op->cipher.data.offset = aad_buffer_len + iv_pad_len; + sym_op->cipher.data.length = cipher_len; + sym_op->cipher.data.offset = auth_offset + cipher_offset; - sym_op->auth.data.length = data_len; - sym_op->auth.data.offset = aad_buffer_len + iv_pad_len; + sym_op->auth.data.length = auth_len; + sym_op->auth.data.offset = auth_offset + cipher_offset; return 0; } @@ -2248,15 +2254,17 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata) /* Append data which is padded to a multiple of */ /* the algorithms block size */ - plaintext_pad_len = tdata->plaintext.len; + plaintext_pad_len = tdata->plaintext.len >> 3; plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, plaintext_pad_len); - memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); + memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len >> 3); /* Create SNOW3G opertaion */ retval = create_snow3g_hash_operation(NULL, tdata->digest.len, - tdata->aad.data, tdata->aad.len, tdata->plaintext.len, - plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE); + tdata->aad.data, tdata->aad.len, + plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, + tdata->validAuthLenInBits.len, + tdata->validAuthOffsetLenInBits.len); if (retval < 0) return retval; @@ -2302,17 +2310,19 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) /* Append data which is padded to a multiple */ /* of the algorithms block size */ - plaintext_pad_len = tdata->plaintext.len; + plaintext_pad_len = tdata->plaintext.len >> 3; plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, plaintext_pad_len); - memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); + memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len >> 3); /* Create SNOW3G operation */ retval = create_snow3g_hash_operation(tdata->digest.data, tdata->digest.len, tdata->aad.data, tdata->aad.len, - tdata->plaintext.len, plaintext_pad_len, - RTE_CRYPTO_AUTH_OP_VERIFY); + plaintext_pad_len, + RTE_CRYPTO_AUTH_OP_VERIFY, + tdata->validAuthLenInBits.len, + tdata->validAuthOffsetLenInBits.len); if (retval < 0) return retval; @@ -2400,18 +2410,20 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata) * Append data which is padded to a * multiple of the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); + /*tdata->plaintext.len = tdata->plaintext.len >> 3;*/ + plaintext_pad_len = RTE_ALIGN_CEIL((tdata->plaintext.len >> 3), 16); plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf, plaintext_pad_len); - memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); + memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3)); #ifdef RTE_APP_TEST_DEBUG rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); #endif /* Create SNOW3G operation */ retval = create_snow3g_cipher_operation(tdata->iv.data, tdata->iv.len, - tdata->plaintext.len); + tdata->validCipherLenInBits.len, + tdata->validCipherOffsetLenInBits.len); if (retval < 0) return retval; @@ -2430,7 +2442,7 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata) if (lastByteValidBits == 0) lastByteValidBits = 8; lastByteMask = lastByteMask << (8 - lastByteValidBits); - (*(ciphertext + tdata->ciphertext.len - 1)) &= lastByteMask; + (*(ciphertext + (tdata->ciphertext.len >> 3) - 1)) &= lastByteMask; #ifdef RTE_APP_TEST_DEBUG rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); @@ -2439,7 +2451,7 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata) TEST_ASSERT_BUFFERS_ARE_EQUAL( ciphertext, tdata->ciphertext.data, - tdata->ciphertext.len, + tdata->ciphertext.len >> 3, "Snow3G Ciphertext data not as expected"); return 0; } @@ -2473,18 +2485,19 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata) * Append data which is padded to a * multiple of the algorithms block size */ - ciphertext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16); + ciphertext_pad_len = RTE_ALIGN_CEIL((tdata->ciphertext.len >> 3), 16); ciphertext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf, ciphertext_pad_len); - memcpy(ciphertext, tdata->ciphertext.data, tdata->ciphertext.len); + memcpy(ciphertext, tdata->ciphertext.data, tdata->ciphertext.len >> 3); #ifdef RTE_APP_TEST_DEBUG rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); #endif /* Create SNOW3G operation */ retval = create_snow3g_cipher_operation(tdata->iv.data, tdata->iv.len, - tdata->ciphertext.len); + tdata->validCipherLenInBits.len, + tdata->validCipherOffsetLenInBits.len); if (retval < 0) return retval; @@ -2497,11 +2510,11 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata) + tdata->iv.len; else plaintext = ciphertext; - lastByteValidBits = (tdata->validDataLenInBits.len % 8); + lastByteValidBits = (tdata->validDataLenInBits.len % 8); if (lastByteValidBits == 0) lastByteValidBits = 8; lastByteMask = lastByteMask << (8 - lastByteValidBits); - (*(ciphertext + tdata->ciphertext.len - 1)) &= lastByteMask; + (*(ciphertext + (tdata->ciphertext.len >> 3) - 1)) &= lastByteMask; #ifdef RTE_APP_TEST_DEBUG rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); @@ -2509,7 +2522,7 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata) /* Validate obuf */ TEST_ASSERT_BUFFERS_ARE_EQUAL(plaintext, tdata->plaintext.data, - tdata->plaintext.len, + tdata->plaintext.len >> 3, "Snow3G Plaintext data not as expected"); return 0; } @@ -2543,11 +2556,11 @@ test_snow3g_authenticated_encryption(const struct snow3g_test_data *tdata) /* Append data which is padded to a multiple */ /* of the algorithms block size */ - plaintext_pad_len = tdata->plaintext.len; + plaintext_pad_len = tdata->plaintext.len >> 3; plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, plaintext_pad_len); - memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); + memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len >> 3); #ifdef RTE_APP_TEST_DEBUG rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); @@ -2556,9 +2569,13 @@ test_snow3g_authenticated_encryption(const struct snow3g_test_data *tdata) /* Create SNOW3G operation */ retval = create_snow3g_cipher_hash_operation(tdata->digest.data, tdata->digest.len, tdata->aad.data, - tdata->aad.len, tdata->plaintext.len, + tdata->aad.len, /*tdata->plaintext.len,*/ plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, - tdata->iv.data, tdata->iv.len); + tdata->iv.data, tdata->iv.len, + tdata->validCipherLenInBits.len, + tdata->validCipherOffsetLenInBits.len, + tdata->validAuthLenInBits.len, + tdata->validAuthOffsetLenInBits.len); if (retval < 0) return retval; @@ -2575,7 +2592,7 @@ test_snow3g_authenticated_encryption(const struct snow3g_test_data *tdata) if (lastByteValidBits == 0) lastByteValidBits = 8; lastByteMask = lastByteMask << (8-lastByteValidBits); - (*(ciphertext + tdata->ciphertext.len - 1)) &= lastByteMask; + (*(ciphertext + (tdata->ciphertext.len >> 3) - 1)) &= lastByteMask; #ifdef RTE_APP_TEST_DEBUG rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); @@ -2584,7 +2601,7 @@ test_snow3g_authenticated_encryption(const struct snow3g_test_data *tdata) TEST_ASSERT_BUFFERS_ARE_EQUAL( ciphertext, tdata->ciphertext.data, - tdata->ciphertext.len, + tdata->ciphertext.len >> 3, "Snow3G Ciphertext data not as expected"); ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) @@ -2628,11 +2645,11 @@ test_snow3g_encrypted_authentication(const struct snow3g_test_data *tdata) /* Append data which is padded to a multiple */ /* of the algorithms block size */ - plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 8); + plaintext_pad_len = RTE_ALIGN_CEIL((tdata->plaintext.len >> 3), 8); plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, plaintext_pad_len); - memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); + memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len >> 3); #ifdef RTE_APP_TEST_DEBUG rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); @@ -2643,7 +2660,11 @@ test_snow3g_encrypted_authentication(const struct snow3g_test_data *tdata) tdata->digest.len, tdata->iv.data, tdata->iv.len, tdata->aad.data, tdata->aad.len, - tdata->plaintext.len, plaintext_pad_len + plaintext_pad_len, + tdata->validCipherLenInBits.len, + tdata->validCipherOffsetLenInBits.len, + tdata->validAuthLenInBits.len, + tdata->validAuthOffsetLenInBits.len ); if (retval < 0) @@ -2663,10 +2684,9 @@ test_snow3g_encrypted_authentication(const struct snow3g_test_data *tdata) if (lastByteValidBits == 0) lastByteValidBits = 8; lastByteMask = lastByteMask << (8-lastByteValidBits); - (*(ciphertext + tdata->ciphertext.len - 1)) &= lastByteMask; + (*(ciphertext + (tdata->ciphertext.len >> 3) - 1)) &= lastByteMask; ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + plaintext_pad_len + tdata->aad.len + tdata->iv.len; - #ifdef RTE_APP_TEST_DEBUG rte_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); #endif @@ -2674,7 +2694,7 @@ test_snow3g_encrypted_authentication(const struct snow3g_test_data *tdata) TEST_ASSERT_BUFFERS_ARE_EQUAL( ciphertext, tdata->ciphertext.data, - tdata->ciphertext.len, + tdata->ciphertext.len >> 3, "Snow3G Ciphertext data not as expected"); /* Validate obuf */ diff --git a/app/test/test_cryptodev_snow3g_hash_test_vectors.h b/app/test/test_cryptodev_snow3g_hash_test_vectors.h index f4fa36d..fe4906b 100644 --- a/app/test/test_cryptodev_snow3g_hash_test_vectors.h +++ b/app/test/test_cryptodev_snow3g_hash_test_vectors.h @@ -46,10 +46,18 @@ struct snow3g_hash_test_data { struct { uint8_t data[2056]; - unsigned len; + unsigned len; /* length must be in Bits */ } plaintext; struct { + unsigned len; + } validAuthLenInBits; + + struct { + unsigned len; + } validAuthOffsetLenInBits; + + struct { uint8_t data[64]; unsigned len; } digest; @@ -79,7 +87,13 @@ struct snow3g_hash_test_data snow3g_hash_test_case_1 = { 0xB2, 0x4A, 0x03, 0x86, 0x65, 0x42, 0x2B, 0x20, 0xA4, 0x99, 0x27, 0x6A, 0x50, 0x42, 0x70, 0x09 }, - .len = 48 + .len = 384 + }, + .validAuthLenInBits = { + .len = 384 + }, + .validAuthOffsetLenInBits = { + .len = 128 }, .digest = { .data = {0x38, 0xB5, 0x54, 0xC0 }, @@ -121,7 +135,13 @@ struct snow3g_hash_test_data snow3g_hash_test_case_2 = { 0x3D, 0x7C, 0xFE, 0xE9, 0x45, 0x85, 0xB5, 0x88, 0x5C, 0xAC, 0x46, 0x06, 0x8B }, - .len = 125 + .len = 1000 + }, + .validAuthLenInBits = { + .len = 1000 + }, + .validAuthOffsetLenInBits = { + .len = 128 }, .digest = { .data = {0x06, 0x17, 0x45, 0xAE}, @@ -404,7 +424,13 @@ struct snow3g_hash_test_data snow3g_hash_test_case_3 = { 0x11, 0x24, 0xBF, 0x1A, 0xD5, 0x4B, 0x79, 0x25, 0x32, 0x98, 0x3D, 0xD6, 0xC3, 0xA8, 0xB7, 0xD0 }, - .len = 2056 + .len = 16448 + }, + .validAuthLenInBits = { + .len = 16448 + }, + .validAuthOffsetLenInBits = { + .len = 128 }, .digest = { .data = {0x17, 0x9F, 0x2F, 0xA6}, diff --git a/app/test/test_cryptodev_snow3g_test_vectors.h b/app/test/test_cryptodev_snow3g_test_vectors.h index 403406d..51917c1 100644 --- a/app/test/test_cryptodev_snow3g_test_vectors.h +++ b/app/test/test_cryptodev_snow3g_test_vectors.h @@ -46,12 +46,12 @@ struct snow3g_test_data { struct { uint8_t data[1024]; - unsigned len; + unsigned len; /* length must be in Bits */ } plaintext; struct { uint8_t data[1024]; - unsigned len; + unsigned len; /* length must be in Bits */ } ciphertext; struct { @@ -59,6 +59,22 @@ struct snow3g_test_data { } validDataLenInBits; struct { + unsigned len; + } validCipherLenInBits; + + struct { + unsigned len; + } validCipherOffsetLenInBits; + + struct { + unsigned len; + } validAuthLenInBits; + + struct { + unsigned len; + } validAuthOffsetLenInBits; + + struct { uint8_t data[64]; unsigned len; } aad; @@ -99,7 +115,7 @@ struct snow3g_test_data snow3g_test_case_1 = { 0x39, 0x01, 0xA0, 0x8F, 0x4A, 0xB4, 0x1A, 0xAB, 0x9B, 0x13, 0x48, 0x80 }, - .len = 100 + .len = 800 }, .ciphertext = { .data = { @@ -117,11 +133,17 @@ struct snow3g_test_data snow3g_test_case_1 = { 0x05, 0x3D, 0xB5, 0x5A, 0x88, 0xC4, 0xC4, 0xF9, 0x60, 0x5E, 0x41, 0x40 }, - .len = 100 + .len = 800 }, .validDataLenInBits = { .len = 798 }, + .validCipherLenInBits = { + .len = 800 + }, + .validCipherOffsetLenInBits = { + .len = 128 + }, .aad = { .data = { 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00, @@ -157,7 +179,7 @@ struct snow3g_test_data snow3g_test_case_2 = { 0x1C, 0xF9, 0x3B, 0x15, 0x10, 0x37, 0x6B, 0x02, 0x13, 0x0F, 0x81, 0x2A, 0x9F, 0xA1, 0x69, 0xD8 }, - .len = 64 + .len = 512 }, .ciphertext = { .data = { @@ -170,11 +192,17 @@ struct snow3g_test_data snow3g_test_case_2 = { 0x0D, 0xB0, 0xA9, 0xCD, 0x36, 0xC3, 0x4A, 0xE4, 0x18, 0x14, 0x90, 0xB2, 0x9F, 0x5F, 0xA2, 0xFC }, - .len = 64 + .len = 512 }, .validDataLenInBits = { .len = 510 }, + .validCipherLenInBits = { + .len = 512 + }, + .validCipherOffsetLenInBits = { + .len = 128 + }, .aad = { .data = { 0xE2, 0x8B, 0xCF, 0x7B, 0xC0, 0x00, 0x00, 0x00, @@ -204,18 +232,24 @@ struct snow3g_test_data snow3g_test_case_3 = { 0xAD, 0x9C, 0x44, 0x1F, 0x89, 0x0B, 0x38, 0xC4, 0x57, 0xA4, 0x9D, 0x42, 0x14, 0x07, 0xE8 }, - .len = 15 + .len = 120 }, .ciphertext = { .data = { 0xBA, 0x0F, 0x31, 0x30, 0x03, 0x34, 0xC5, 0x6B, 0x52, 0xA7, 0x49, 0x7C, 0xBA, 0xC0, 0x46 }, - .len = 15 + .len = 120 }, .validDataLenInBits = { .len = 120 }, + .validCipherLenInBits = { + .len = 120 + }, + .validCipherOffsetLenInBits = { + .len = 128 + }, .aad = { .data = { 0xFA, 0x55, 0x6B, 0x26, 0x1C, 0x00, 0x00, 0x00, @@ -226,6 +260,12 @@ struct snow3g_test_data snow3g_test_case_3 = { .digest = { .data = {0xE8, 0x60, 0x5A, 0x3E}, .len = 4 + }, + .validAuthLenInBits = { + .len = 120 + }, + .validAuthOffsetLenInBits = { + .len = 128 } }; @@ -251,7 +291,7 @@ struct snow3g_test_data snow3g_test_case_4 = { 0x8C, 0xE3, 0x3E, 0x2C, 0xC3, 0xC0, 0xB5, 0xFC, 0x1F, 0x3D, 0xE8, 0xA6, 0xDC, 0x66, 0xB1, 0xF0 }, - .len = 32 + .len = 256 }, .ciphertext = { .data = { @@ -260,10 +300,16 @@ struct snow3g_test_data snow3g_test_case_4 = { 0xA5, 0x6C, 0x40, 0xC0, 0xAB, 0x9D, 0x81, 0xF7, 0xA2, 0xA9, 0xBA, 0xC6, 0x0E, 0x11, 0xC4, 0xB0 }, - .len = 32 + .len = 256 }, .validDataLenInBits = { .len = 253 + }, + .validCipherLenInBits = { + .len = 256 + }, + .validCipherOffsetLenInBits = { + .len = 128 } }; @@ -298,7 +344,7 @@ struct snow3g_test_data snow3g_test_case_5 = { 0x98, 0x76, 0x45, 0x98, 0x7A, 0x98, 0x6F, 0x2C, 0xB0 }, - .len = 105 + .len = 840 }, .ciphertext = { .data = { @@ -317,10 +363,16 @@ struct snow3g_test_data snow3g_test_case_5 = { 0x43, 0x24, 0x85, 0x50, 0x92, 0x2A, 0xC1, 0x28, 0x18 }, - .len = 105 + .len = 840 }, .validDataLenInBits = { .len = 837 + }, + .validCipherLenInBits = { + .len = 840 + }, + .validCipherOffsetLenInBits = { + .len = 128 } }; struct snow3g_test_data snow3g_test_case_6 = { @@ -354,7 +406,7 @@ struct snow3g_test_data snow3g_test_case_6 = { 0xB2, 0x4A, 0x03, 0x86, 0x65, 0x42, 0x2B, 0x20, 0xA4, 0x99, 0x27, 0x6A, 0x50, 0x42, 0x70, 0x09 }, - .len = 48 + .len = 384 }, .ciphertext = { .data = { @@ -365,7 +417,7 @@ struct snow3g_test_data snow3g_test_case_6 = { 0xBD, 0x91, 0xAA, 0xB6, 0xA4, 0xDC, 0x64, 0xB4, 0xCB, 0xEB, 0x97, 0x06, 0x4C, 0xF7, 0x02, 0x3D }, - .len = 48 + .len = 384 }, .digest = { .data = {0x38, 0xB5, 0x54, 0xC0 }, @@ -373,6 +425,18 @@ struct snow3g_test_data snow3g_test_case_6 = { }, .validDataLenInBits = { .len = 384 + }, + .validCipherLenInBits = { + .len = 384 + }, + .validCipherOffsetLenInBits = { + .len = 128 + }, + .validAuthLenInBits = { + .len = 384 + }, + .validAuthOffsetLenInBits = { + .len = 128 } }; diff --git a/doc/guides/cryptodevs/qat.rst b/doc/guides/cryptodevs/qat.rst index af52047..8f09d32 100644 --- a/doc/guides/cryptodevs/qat.rst +++ b/doc/guides/cryptodevs/qat.rst @@ -67,6 +67,8 @@ Limitations * Only in-place is currently supported (destination address is the same as source address). * Only supports the session-oriented API implementation (session-less APIs are not supported). * Not performance tuned. +* Snow3g(UEA2) supported only if cipher length, cipher offset fields are byte-aligned. +* Snow3g(UIA2) supported only if hash length, hash offset fields are byte-aligned. Installation diff --git a/doc/guides/cryptodevs/snow3g.rst b/doc/guides/cryptodevs/snow3g.rst index f04fbaf..3f24497 100644 --- a/doc/guides/cryptodevs/snow3g.rst +++ b/doc/guides/cryptodevs/snow3g.rst @@ -51,6 +51,8 @@ Limitations ----------- * Chained mbufs are not supported. +* Snow3g(UEA2) supported only if cipher length, cipher offset fields are byte-aligned. +* Snow3g(UIA2) supported only if hash length, hash offset fields are byte-aligned. Installation ------------ diff --git a/drivers/crypto/qat/qat_crypto.c b/drivers/crypto/qat/qat_crypto.c index e0e506d..2bd1753 100644 --- a/drivers/crypto/qat/qat_crypto.c +++ b/drivers/crypto/qat/qat_crypto.c @@ -66,6 +66,7 @@ #include "qat_crypto.h" #include "adf_transport_access_macros.h" +#define BYTE_LENGTH 8 static inline uint32_t adf_modulo(uint32_t data, uint32_t shift); @@ -506,6 +507,19 @@ qat_write_hw_desc_entry(struct rte_crypto_op *op, uint8_t *out_msg) cipher_param->cipher_length = op->sym->cipher.data.length; cipher_param->cipher_offset = op->sym->cipher.data.offset; + if (ctx->qat_cipher_alg == ICP_QAT_HW_CIPHER_ALGO_SNOW_3G_UEA2) { + if (unlikely((cipher_param->cipher_length % BYTE_LENGTH != 0) || + (cipher_param->cipher_offset + % BYTE_LENGTH != 0))) { + PMD_DRV_LOG(ERR, " For Snow3g, QAT PMD only " + "supports byte aligned values"); + op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS; + return -EINVAL; + } + cipher_param->cipher_length >>= 3; + cipher_param->cipher_offset >>= 3; + } + if (op->sym->cipher.iv.length && (op->sym->cipher.iv.length <= sizeof(cipher_param->u.cipher_IV_array))) { rte_memcpy(cipher_param->u.cipher_IV_array, @@ -525,7 +539,17 @@ qat_write_hw_desc_entry(struct rte_crypto_op *op, uint8_t *out_msg) } auth_param->auth_off = op->sym->auth.data.offset; auth_param->auth_len = op->sym->auth.data.length; - + if (ctx->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_SNOW_3G_UIA2) { + if (unlikely((auth_param->auth_off % BYTE_LENGTH != 0) || + (auth_param->auth_len % BYTE_LENGTH != 0))) { + PMD_DRV_LOG(ERR, " For Snow3g, QAT PMD only " + "supports byte aligned values"); + op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS; + return -EINVAL; + } + auth_param->auth_off >>= 3; + auth_param->auth_len >>= 3; + } auth_param->u1.aad_adr = op->sym->auth.aad.phys_addr; /* (GCM) aad length(240 max) will be at this location after precompute */ if (ctx->qat_hash_alg == ICP_QAT_HW_AUTH_ALGO_GALOIS_128 || diff --git a/drivers/crypto/snow3g/rte_snow3g_pmd.c b/drivers/crypto/snow3g/rte_snow3g_pmd.c index c35e66e..6f84e5c 100644 --- a/drivers/crypto/snow3g/rte_snow3g_pmd.c +++ b/drivers/crypto/snow3g/rte_snow3g_pmd.c @@ -43,6 +43,7 @@ #include "rte_snow3g_pmd_private.h" #define SNOW3G_MAX_BURST 8 +#define BYTE_LEN 8 /** * Global static parameter used to create a unique name for each SNOW 3G @@ -203,15 +204,23 @@ process_snow3g_cipher_op(struct rte_crypto_op **ops, break; } + if (((ops[i]->sym->cipher.data.length % BYTE_LEN) != 0) + || ((ops[i]->sym->cipher.data.offset + % BYTE_LEN) != 0)) { + ops[i]->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS; + SNOW3G_LOG_ERR("Data Length or offset"); + break; + } + src[i] = rte_pktmbuf_mtod(ops[i]->sym->m_src, uint8_t *) + - ops[i]->sym->cipher.data.offset; + (ops[i]->sym->cipher.data.offset >> 3); dst[i] = ops[i]->sym->m_dst ? - rte_pktmbuf_mtod(ops[i]->sym->m_dst, uint8_t *) + - ops[i]->sym->cipher.data.offset : - rte_pktmbuf_mtod(ops[i]->sym->m_src, uint8_t *) + - ops[i]->sym->cipher.data.offset; + rte_pktmbuf_mtod(ops[i]->sym->m_dst, uint8_t *) + + (ops[i]->sym->cipher.data.offset >> 3) : + rte_pktmbuf_mtod(ops[i]->sym->m_src, uint8_t *) + + (ops[i]->sym->cipher.data.offset >> 3); IV[i] = ops[i]->sym->cipher.iv.data; - num_bytes[i] = ops[i]->sym->cipher.data.length; + num_bytes[i] = ops[i]->sym->cipher.data.length >> 3; processed_ops++; } @@ -246,10 +255,18 @@ process_snow3g_hash_op(struct rte_crypto_op **ops, break; } - length_in_bits = ops[i]->sym->auth.data.length * 8; + if (((ops[i]->sym->auth.data.length % BYTE_LEN) != 0) + || ((ops[i]->sym->auth.data.offset + % BYTE_LEN) != 0)) { + ops[i]->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS; + SNOW3G_LOG_ERR("Data Length or offset"); + break; + } + + length_in_bits = ops[i]->sym->auth.data.length; src = rte_pktmbuf_mtod(ops[i]->sym->m_src, uint8_t *) + - ops[i]->sym->auth.data.offset; + (ops[i]->sym->auth.data.offset >> 3); if (session->auth_op == RTE_CRYPTO_AUTH_OP_VERIFY) { dst = (uint8_t *)rte_pktmbuf_append(ops[i]->sym->m_src, diff --git a/lib/librte_cryptodev/rte_crypto_sym.h b/lib/librte_cryptodev/rte_crypto_sym.h index 831bbf1..a5c1a17 100644 --- a/lib/librte_cryptodev/rte_crypto_sym.h +++ b/lib/librte_cryptodev/rte_crypto_sym.h @@ -382,6 +382,10 @@ struct rte_crypto_sym_op { * buffer. The result of the cipher operation will be * written back into the output buffer starting at * this location. + * + * @note + * For Snow3G @ RTE_CRYPTO_CIPHER_SNOW3G_UEA2, + * this field should be in bits. */ uint32_t length; @@ -402,6 +406,10 @@ struct rte_crypto_sym_op { * @note * For AES-GMAC @ref RTE_CRYPTO_AUTH_AES_GMAC, this * field should be set to 0. + * + * @note + * For Snow3G @ RTE_CRYPTO_AUTH_SNOW3G_UEA2 + * this field should be in bits. */ } data; /**< Data offsets and length for ciphering */ @@ -470,6 +478,10 @@ struct rte_crypto_sym_op { * @note For AES-GMAC (@ref RTE_CRYPTO_AUTH_AES_GMAC) * mode of operation, this field specifies the start * of the AAD data in the source buffer. + * + * @note + * For Snow3G @ RTE_CRYPTO_AUTH_SNOW3G_UIA2 + * this field should be in bits. */ uint32_t length; @@ -485,6 +497,10 @@ struct rte_crypto_sym_op { * For AES-GMAC @ref RTE_CRYPTO_AUTH_AES_GMAC mode * of operation, this field specifies the length of * the AAD data in the source buffer. + * + * @note + * For Snow3G @ RTE_CRYPTO_AUTH_SNOW3G_UIA2 + * this field should be in bits. */ } data; /**< Data offsets and length for authentication */ -- 2.1.0