BIND 10 master, updated. d22ff00401ed90df31342dcce12bb4ceb493f232 [master] Merge branch 'trac954'
BIND 10 source code commits
bind10-changes at lists.isc.org
Wed Jun 1 21:03:21 UTC 2011
The branch, master has been updated
via d22ff00401ed90df31342dcce12bb4ceb493f232 (commit)
via ddcbd508353cff40985a2e40334a82d91bf95341 (commit)
via 505839e902948071f5e7876d274db4345b28b49d (commit)
via 78def66fe5de6f50a555b24d3134d5ec0dc32021 (commit)
from 9500689fabae67565bee456d33953ae7b139a209 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit d22ff00401ed90df31342dcce12bb4ceb493f232
Merge: 9500689 ddcbd50
Author: JINMEI Tatuya <jinmei at isc.org>
Date: Wed Jun 1 13:59:43 2011 -0700
[master] Merge branch 'trac954'
-----------------------------------------------------------------------
Summary of changes:
src/lib/cryptolink/tests/Makefile.am | 1 +
src/lib/cryptolink/tests/crypto_unittests.cc | 426 +++++++++-----------------
2 files changed, 141 insertions(+), 286 deletions(-)
-----------------------------------------------------------------------
diff --git a/src/lib/cryptolink/tests/Makefile.am b/src/lib/cryptolink/tests/Makefile.am
index c2c2a5c..fbdd13f 100644
--- a/src/lib/cryptolink/tests/Makefile.am
+++ b/src/lib/cryptolink/tests/Makefile.am
@@ -18,6 +18,7 @@ run_unittests_SOURCES += crypto_unittests.cc
run_unittests_CPPFLAGS = $(AM_CPPFLAGS) $(GTEST_INCLUDES)
run_unittests_LDFLAGS = ${BOTAN_LDFLAGS} $(AM_LDFLAGS) $(GTEST_LDFLAGS)
run_unittests_LDADD = $(GTEST_LDADD)
+run_unittests_LDADD += $(top_builddir)/src/lib/util/libutil.la
run_unittests_LDADD += $(top_builddir)/src/lib/cryptolink/libcryptolink.la
run_unittests_LDADD += $(top_builddir)/src/lib/util/unittests/libutil_unittests.la
run_unittests_LDADD += $(top_builddir)/src/lib/exceptions/libexceptions.la
diff --git a/src/lib/cryptolink/tests/crypto_unittests.cc b/src/lib/cryptolink/tests/crypto_unittests.cc
index 9cc4a14..4abeb87 100644
--- a/src/lib/cryptolink/tests/crypto_unittests.cc
+++ b/src/lib/cryptolink/tests/crypto_unittests.cc
@@ -13,8 +13,16 @@
// PERFORMANCE OF THIS SOFTWARE.
#include <config.h>
+
+#include <string>
+#include <vector>
+
+#include <boost/lexical_cast.hpp>
+
#include <gtest/gtest.h>
+#include <util/encode/hex.h>
+
#include <cryptolink/cryptolink.h>
#include <cryptolink/crypto_hmac.h>
@@ -23,7 +31,9 @@
#include <boost/shared_ptr.hpp>
+using namespace boost;
using namespace isc::util;
+using namespace isc::util::encode;
using namespace isc::cryptolink;
namespace {
@@ -340,314 +350,158 @@ TEST(CryptoLinkTest, DISABLED_HMAC_SHA1_RFC2202_SIGN_TRUNCATED) {
//
// Test values taken from RFC 4231
//
-//
// Test data from RFC4231, including secret key
// and source data, they are common for sha224/256/384/512
-// so put them together in seperate space
-namespace {
- static const uint8_t secret1[] = {
- 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
- 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
- 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b
- };
-
- static const uint8_t secret2[] = "Jefe";
- static const uint8_t secret3[] = {
- 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
- 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
- 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
- 0xaa, 0xaa
- };
- static const uint8_t secret4[] = {
+// so put them together within the separate function.
+void
+doRFC4231Tests(HashAlgorithm hash_algorithm,
+ const std::vector<std::vector<uint8_t> >& hmac_list)
+{
+ std::vector<std::string> data_list;
+ std::vector<std::string> secret_list;
+
+ data_list.push_back("Hi There");
+ data_list.push_back("what do ya want for nothing?");
+ data_list.push_back(std::string(50, 0xdd));
+ data_list.push_back(std::string(50, 0xcd));
+ data_list.push_back("Test With Truncation");
+ data_list.push_back("Test Using Larger Than Block-Size Key - "
+ "Hash Key First");
+ data_list.push_back("This is a test using a larger than block-size "
+ "key and a larger than block-size data. The key "
+ "needs to be hashed before being used by the HMAC "
+ "algorithm.");
+
+ secret_list.push_back(std::string(20, 0x0b));
+ secret_list.push_back("Jefe");
+ secret_list.push_back(std::string(20, 0xaa));
+ const uint8_t secret_array[] = {
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
};
- static const uint8_t secret5[] = {
- 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
- 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
- 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
- 0x0c, 0x0c
- };
-
- static uint8_t secret6[131];
- static uint8_t secret7[131];
-
- static const std::string data1("Hi There");
- static const std::string data2("what do ya want for nothing?");
- static const std::string data3(std::string(50, 0xdd));
- static const std::string data4(std::string(50, 0xcd));
- static const std::string data5("Test With Truncation");
- static const std::string data6("Test Using Larger Than Block-Size Key - Hash Key First");
- static const std::string data7("This is a test using a larger than block-size key and a"
- " larger than block-size data. The key needs to be hashe"
- "d before being used by the HMAC algorithm.");
-#define SECRECT(n) secret##n
-#define DATA(n) data##n
-#define HMAC_EXPECTED(n) hmac_expected##n
-
-#define RUN_NTH_TEST_CASE_FOR_ALG(index, hash_algorithm) do {\
- doHMACTest(DATA(index), \
- SECRECT(index), sizeof(SECRECT(index)), \
- (hash_algorithm), HMAC_EXPECTED(index), \
- sizeof(HMAC_EXPECTED(index)));\
- }while(0)
-
-#define RUN_TEST_CASES_FOR_ALG(alg) do {\
- memcpy(secret6, std::string(131, 0xaa).c_str(), 131); \
- memcpy(secret7, std::string(131, 0xaa).c_str(), 131); \
- RUN_NTH_TEST_CASE_FOR_ALG(1, alg); \
- RUN_NTH_TEST_CASE_FOR_ALG(2, alg); \
- RUN_NTH_TEST_CASE_FOR_ALG(3, alg); \
- RUN_NTH_TEST_CASE_FOR_ALG(4, alg); \
- RUN_NTH_TEST_CASE_FOR_ALG(5, alg); \
- RUN_NTH_TEST_CASE_FOR_ALG(6, alg); \
- RUN_NTH_TEST_CASE_FOR_ALG(7, alg); \
- }while(0)
-
-
-};
+ secret_list.push_back(std::string(secret_array,
+ secret_array + sizeof(secret_array)));
+ secret_list.push_back(std::string(20, 0x0c));
+ secret_list.push_back(std::string(131, 0xaa));
+ secret_list.push_back(std::string(131, 0xaa));
+
+ // Make sure we provide a consistent size of test data
+ ASSERT_EQ(secret_list.size(), data_list.size());
+ ASSERT_EQ(secret_list.size(), hmac_list.size());
+
+ for (int i = 0; i < data_list.size(); ++i) {
+ SCOPED_TRACE("RFC4231 HMAC test for algorithm ID: " +
+ lexical_cast<std::string>(hash_algorithm) +
+ ", data ID: " + lexical_cast<std::string>(i));
+ // Until #920 is resolved we have to skip truncation cases.
+ if (data_list[i] == "Test With Truncation") {
+ continue;
+ }
+ doHMACTest(data_list[i], secret_list[i].c_str(), secret_list[i].size(),
+ hash_algorithm, &hmac_list[i][0], hmac_list[i].size());
+ }
+}
TEST(CryptoLinkTest, HMAC_SHA256_RFC4231_SIGN) {
- const uint8_t hmac_expected1[] = { 0xb0, 0x34, 0x4c, 0x61, 0xd8,
- 0xdb, 0x38, 0x53, 0x5c, 0xa8,
- 0xaf, 0xce, 0xaf, 0x0b, 0xf1,
- 0x2b, 0x88, 0x1d, 0xc2, 0x00,
- 0xc9, 0x83, 0x3d, 0xa7, 0x26,
- 0xe9, 0x37, 0x6c, 0x2e, 0x32,
- 0xcf, 0xf7 };
- const uint8_t hmac_expected2[] = { 0x5b, 0xdc, 0xc1, 0x46, 0xbf,
- 0x60, 0x75, 0x4e, 0x6a, 0x04,
- 0x24, 0x26, 0x08, 0x95, 0x75,
- 0xc7, 0x5a, 0x00, 0x3f, 0x08,
- 0x9d, 0x27, 0x39, 0x83, 0x9d,
- 0xec, 0x58, 0xb9, 0x64, 0xec,
- 0x38, 0x43 };
- const uint8_t hmac_expected3[] = { 0x77, 0x3e, 0xa9, 0x1e, 0x36,
- 0x80, 0x0e, 0x46, 0x85, 0x4d,
- 0xb8, 0xeb, 0xd0, 0x91, 0x81,
- 0xa7, 0x29, 0x59, 0x09, 0x8b,
- 0x3e, 0xf8, 0xc1, 0x22, 0xd9,
- 0x63, 0x55, 0x14, 0xce, 0xd5,
- 0x65, 0xfe };
- const uint8_t hmac_expected4[] = { 0x82, 0x55, 0x8a, 0x38, 0x9a,
- 0x44, 0x3c, 0x0e, 0xa4, 0xcc,
- 0x81, 0x98, 0x99, 0xf2, 0x08,
- 0x3a, 0x85, 0xf0, 0xfa, 0xa3,
- 0xe5, 0x78, 0xf8, 0x07, 0x7a,
- 0x2e, 0x3f, 0xf4, 0x67, 0x29,
- 0x66, 0x5b };
-// const uint8_t hmac_expected5[] = { 0xa3, 0xb6, 0x16, 0x74, 0x73,
-// 0x10, 0x0e, 0xe0, 0x6e, 0x0c,
-// 0x79, 0x6c, 0x29, 0x55, 0x55,
-// 0x2b };
- const uint8_t hmac_expected6[] = { 0x60, 0xe4, 0x31, 0x59, 0x1e,
- 0xe0, 0xb6, 0x7f, 0x0d, 0x8a,
- 0x26, 0xaa, 0xcb, 0xf5, 0xb7,
- 0x7f, 0x8e, 0x0b, 0xc6, 0x21,
- 0x37, 0x28, 0xc5, 0x14, 0x05,
- 0x46, 0x04, 0x0f, 0x0e, 0xe3,
- 0x7f, 0x54 };
- const uint8_t hmac_expected7[] = { 0x9b, 0x09, 0xff, 0xa7, 0x1b,
- 0x94, 0x2f, 0xcb, 0x27, 0x63,
- 0x5f, 0xbc, 0xd5, 0xb0, 0xe9,
- 0x44, 0xbf, 0xdc, 0x63, 0x64,
- 0x4f, 0x07, 0x13, 0x93, 0x8a,
- 0x7f, 0x51, 0x53, 0x5c, 0x3a,
- 0x35, 0xe2 };
-
- memcpy(secret6, std::string(131, 0xaa).c_str(), 131);
- memcpy(secret7, std::string(131, 0xaa).c_str(), 131);
- RUN_NTH_TEST_CASE_FOR_ALG(1, SHA256);
- RUN_NTH_TEST_CASE_FOR_ALG(2, SHA256);
- RUN_NTH_TEST_CASE_FOR_ALG(3, SHA256);
- RUN_NTH_TEST_CASE_FOR_ALG(4, SHA256);
- RUN_NTH_TEST_CASE_FOR_ALG(6, SHA256);
- RUN_NTH_TEST_CASE_FOR_ALG(7, SHA256);
-
+ std::vector<std::vector<uint8_t> > hmac_expected_list(7);
+
+ int i = 0;
+ decodeHex(
+ "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7",
+ hmac_expected_list[i++]);
+ decodeHex(
+ "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
+ hmac_expected_list[i++]);
+ decodeHex(
+ "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe",
+ hmac_expected_list[i++]);
+ decodeHex(
+ "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b",
+ hmac_expected_list[i++]);
+ decodeHex("a3b6167473100ee06e0c796c2955552b", hmac_expected_list[i++]);
+ decodeHex(
+ "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54",
+ hmac_expected_list[i++]);
+ decodeHex(
+ "9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2",
+ hmac_expected_list[i++]);
+
+ doRFC4231Tests(SHA256, hmac_expected_list);
}
-
//
// Test values taken from RFC 4231, test optional algorithm 224,384,512
//
TEST(CryptoLinkTest, HMAC_SHA224_RFC4231_SIGN) {
- const uint8_t hmac_expected1[] = {
- 0x89,0x6f,0xb1,0x12,0x8a,0xbb,0xdf,0x19,0x68,0x32,0x10,0x7c,
- 0xd4,0x9d,0xf3,0x3f,0x47,0xb4,0xb1,0x16,0x99,0x12,0xba,0x4f,
- 0x53,0x68,0x4b,0x22
- };
- const uint8_t hmac_expected2[] = {
- 0xa3,0x0e,0x01,0x09,0x8b,0xc6,0xdb,0xbf,0x45,0x69,0x0f,0x3a,
- 0x7e,0x9e,0x6d,0x0f,0x8b,0xbe,0xa2,0xa3,0x9e,0x61,0x48,0x00,
- 0x8f,0xd0,0x5e,0x44
- };
-
- const uint8_t hmac_expected3[] = {
- 0x7f,0xb3,0xcb,0x35,0x88,0xc6,0xc1,0xf6,0xff,0xa9,0x69,0x4d,
- 0x7d,0x6a,0xd2,0x64,0x93,0x65,0xb0,0xc1,0xf6,0x5d,0x69,0xd1,
- 0xec,0x83,0x33,0xea
- };
-
- const uint8_t hmac_expected4[] = {
- 0x6c,0x11,0x50,0x68,0x74,0x01,0x3c,0xac,0x6a,0x2a,0xbc,0x1b,
- 0xb3,0x82,0x62,0x7c,0xec,0x6a,0x90,0xd8,0x6e,0xfc,0x01,0x2d,
- 0xe7,0xaf,0xec,0x5a
- };
-
-// const uint8_t hmac_expected5[] = {
-// 0x0e,0x2a,0xea,0x68,0xa9,0x0c,0x8d,0x37,0xc9,0x88,0xbc,0xdb,0x9f,
-// 0xca,0x6f,0xa8
-// };
-
- const uint8_t hmac_expected6[] = {
- 0x95,0xe9,0xa0,0xdb,0x96,0x20,0x95,0xad,0xae,0xbe,0x9b,0x2d,0x6f,
- 0x0d,0xbc,0xe2,0xd4,0x99,0xf1,0x12,0xf2,0xd2,0xb7,0x27,0x3f,0xa6,
- 0x87,0x0e
- };
-
- const uint8_t hmac_expected7[] = {
- 0x3a,0x85,0x41,0x66,0xac,0x5d,0x9f,0x02,0x3f,0x54,0xd5,0x17,0xd0,
- 0xb3,0x9d,0xbd,0x94,0x67,0x70,0xdb,0x9c,0x2b,0x95,0xc9,0xf6,0xf5,
- 0x65,0xd1
- };
-
- memcpy(secret6, std::string(131, 0xaa).c_str(), 131);
- memcpy(secret7, std::string(131, 0xaa).c_str(), 131);
- RUN_NTH_TEST_CASE_FOR_ALG(1, SHA224);
- RUN_NTH_TEST_CASE_FOR_ALG(2, SHA224);
- RUN_NTH_TEST_CASE_FOR_ALG(3, SHA224);
- RUN_NTH_TEST_CASE_FOR_ALG(4, SHA224);
- RUN_NTH_TEST_CASE_FOR_ALG(6, SHA224);
- RUN_NTH_TEST_CASE_FOR_ALG(7, SHA224);
+ std::vector<std::vector<uint8_t> > hmac_expected_list(7);
+
+ int i = 0;
+ decodeHex("896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22",
+ hmac_expected_list[i++]);
+ decodeHex("a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44",
+ hmac_expected_list[i++]);
+ decodeHex("7fb3cb3588c6c1f6ffa9694d7d6ad2649365b0c1f65d69d1ec8333ea",
+ hmac_expected_list[i++]);
+ decodeHex("6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a",
+ hmac_expected_list[i++]);
+ decodeHex("0e2aea68a90c8d37c988bcdb9fca6fa8", hmac_expected_list[i++]);
+ decodeHex("95e9a0db962095adaebe9b2d6f0dbce2d499f112f2d2b7273fa6870e",
+ hmac_expected_list[i++]);
+ decodeHex("3a854166ac5d9f023f54d517d0b39dbd946770db9c2b95c9f6f565d1",
+ hmac_expected_list[i++]);
+
+ doRFC4231Tests(SHA224, hmac_expected_list);
}
-
TEST(CryptoLinkTest, HMAC_SHA384_RFC4231_SIGN) {
- const uint8_t hmac_expected1[] = {
- 0xaf,0xd0,0x39,0x44,0xd8,0x48,0x95,0x62,0x6b,0x08,0x25,0xf4,
- 0xab,0x46,0x90,0x7f,0x15,0xf9,0xda,0xdb,0xe4,0x10,0x1e,0xc6,
- 0x82,0xaa,0x03,0x4c,0x7c,0xeb,0xc5,0x9c,0xfa,0xea,0x9e,0xa9,
- 0x07,0x6e,0xde,0x7f,0x4a,0xf1,0x52,0xe8,0xb2,0xfa,0x9c,0xb6
- };
-
- const uint8_t hmac_expected2[] = {
- 0xaf,0x45,0xd2,0xe3,0x76,0x48,0x40,0x31,0x61,0x7f,0x78,0xd2,
- 0xb5,0x8a,0x6b,0x1b,0x9c,0x7e,0xf4,0x64,0xf5,0xa0,0x1b,0x47,
- 0xe4,0x2e,0xc3,0x73,0x63,0x22,0x44,0x5e,0x8e,0x22,0x40,0xca,
- 0x5e,0x69,0xe2,0xc7,0x8b,0x32,0x39,0xec,0xfa,0xb2,0x16,0x49
- };
-
- const uint8_t hmac_expected3[] = {
- 0x88,0x06,0x26,0x08,0xd3,0xe6,0xad,0x8a,0x0a,0xa2,0xac,0xe0,
- 0x14,0xc8,0xa8,0x6f,0x0a,0xa6,0x35,0xd9,0x47,0xac,0x9f,0xeb,
- 0xe8,0x3e,0xf4,0xe5,0x59,0x66,0x14,0x4b,0x2a,0x5a,0xb3,0x9d,
- 0xc1,0x38,0x14,0xb9,0x4e,0x3a,0xb6,0xe1,0x01,0xa3,0x4f,0x27
- };
-
- const uint8_t hmac_expected4[] = {
- 0x3e,0x8a,0x69,0xb7,0x78,0x3c,0x25,0x85,0x19,0x33,0xab,0x62,
- 0x90,0xaf,0x6c,0xa7,0x7a,0x99,0x81,0x48,0x08,0x50,0x00,0x9c,
- 0xc5,0x57,0x7c,0x6e,0x1f,0x57,0x3b,0x4e,0x68,0x01,0xdd,0x23,
- 0xc4,0xa7,0xd6,0x79,0xcc,0xf8,0xa3,0x86,0xc6,0x74,0xcf,0xfb,
- };
-
-// const uint8_t hmac_expected5[] = {
-// 0x3a,0xbf,0x34,0xc3,0x50,0x3b,0x2a,0x23,0xa4,0x6e,0xfc,0x61,0x9b,
-// 0xae,0xf8,0x97,
-// };
-
- const uint8_t hmac_expected6[] = {
- 0x4e,0xce,0x08,0x44,0x85,0x81,0x3e,0x90,0x88,0xd2,0xc6,0x3a,0x04,
- 0x1b,0xc5,0xb4,0x4f,0x9e,0xf1,0x01,0x2a,0x2b,0x58,0x8f,0x3c,0xd1,
- 0x1f,0x05,0x03,0x3a,0xc4,0xc6,0x0c,0x2e,0xf6,0xab,0x40,0x30,0xfe,
- 0x82,0x96,0x24,0x8d,0xf1,0x63,0xf4,0x49,0x52
- };
-
- const uint8_t hmac_expected7[] = {
- 0x66,0x17,0x17,0x8e,0x94,0x1f,0x02,0x0d,0x35,0x1e,0x2f,0x25,0x4e,
- 0x8f,0xd3,0x2c,0x60,0x24,0x20,0xfe,0xb0,0xb8,0xfb,0x9a,0xdc,0xce,
- 0xbb,0x82,0x46,0x1e,0x99,0xc5,0xa6,0x78,0xcc,0x31,0xe7,0x99,0x17,
- 0x6d,0x38,0x60,0xe6,0x11,0x0c,0x46,0x52,0x3e
- };
-
- memcpy(secret6, std::string(131, 0xaa).c_str(), 131);
- memcpy(secret7, std::string(131, 0xaa).c_str(), 131);
- RUN_NTH_TEST_CASE_FOR_ALG(1, SHA384);
- RUN_NTH_TEST_CASE_FOR_ALG(2, SHA384);
- RUN_NTH_TEST_CASE_FOR_ALG(3, SHA384);
- RUN_NTH_TEST_CASE_FOR_ALG(4, SHA384);
- RUN_NTH_TEST_CASE_FOR_ALG(6, SHA384);
- RUN_NTH_TEST_CASE_FOR_ALG(7, SHA384);
+ std::vector<std::vector<uint8_t> > hmac_expected_list(7);
+
+ int i = 0;
+ decodeHex("afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc5"
+ "9cfaea9ea9076ede7f4af152e8b2fa9cb6", hmac_expected_list[i++]);
+ decodeHex("af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec373632244"
+ "5e8e2240ca5e69e2c78b3239ecfab21649", hmac_expected_list[i++]);
+ decodeHex("88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e5596614"
+ "4b2a5ab39dc13814b94e3ab6e101a34f27", hmac_expected_list[i++]);
+ decodeHex("3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e1f573b"
+ "4e6801dd23c4a7d679ccf8a386c674cffb", hmac_expected_list[i++]);
+ decodeHex("3abf34c3503b2a23a46efc619baef897", hmac_expected_list[i++]);
+ decodeHex("4ece084485813e9088d2c63a041bc5b44f9ef1012a2b588f3cd11f05033ac4"
+ "c60c2ef6ab4030fe8296248df163f44952", hmac_expected_list[i++]);
+ decodeHex("6617178e941f020d351e2f254e8fd32c602420feb0b8fb9adccebb82461e99"
+ "c5a678cc31e799176d3860e6110c46523e", hmac_expected_list[i++]);
+
+ doRFC4231Tests(SHA384, hmac_expected_list);
}
TEST(CryptoLinkTest, HMAC_SHA512_RFC4231_SIGN) {
- const uint8_t hmac_expected1[] = {
- 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,0xda,0xa8,0x33,0xb7,
- 0xd6,0xb8,0xa7,0x02,0x03,0x8b,0x27,0x4e,0xae,0xa3,0xf4,0xe4,
- 0xbe,0x9d,0x91,0x4e,0xeb,0x61,0xf1,0x70,0x2e,0x69,0x6c,0x20,
- 0x3a,0x12,0x68,0x54
- };
- const uint8_t hmac_expected2[] = {
- 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,0x97,0x58,0xbf,0x75,
- 0xc0,0x5a,0x99,0x4a,0x6d,0x03,0x4f,0x65,0xf8,0xf0,0xe6,0xfd,
- 0xca,0xea,0xb1,0xa3,0x4d,0x4a,0x6b,0x4b,0x63,0x6e,0x07,0x0a,
- 0x38,0xbc,0xe7,0x37
- };
-
- const uint8_t hmac_expected3[] = {
- 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,0xbf,0x3e,0x84,0x82,
- 0x79,0xa7,0x22,0xc8,0x06,0xb4,0x85,0xa4,0x7e,0x67,0xc8,0x07,
- 0xb9,0x46,0xa3,0x37,0xbe,0xe8,0x94,0x26,0x74,0x27,0x88,0x59,
- 0xe1,0x32,0x92,0xfb
- };
-
- const uint8_t hmac_expected4[] = {
- 0xb0,0xba,0x46,0x56,0x37,0x45,0x8c,0x69,0x90,0xe5,0xa8,0xc5,
- 0xf6,0x1d,0x4a,0xf7,0xe5,0x76,0xd9,0x7f,0xf9,0x4b,0x87,0x2d,
- 0xe7,0x6f,0x80,0x50,0x36,0x1e,0xe3,0xdb,0xa9,0x1c,0xa5,0xc1,
- 0x1a,0xa2,0x5e,0xb4,0xd6,0x79,0x27,0x5c,0xc5,0x78,0x80,0x63,
- 0xa5,0xf1,0x97,0x41,0x12,0x0c,0x4f,0x2d,0xe2,0xad,0xeb,0xeb,
- 0x10,0xa2,0x98,0xdd
- };
-
-// const uint8_t hmac_expected5[] = {
-// 0x41,0x5f,0xad,0x62,0x71,0x58,0x0a,0x53,0x1d,0x41,0x79,0xbc,0x89,
-// 0x1d,0x87,0xa6,
-// };
-
- const uint8_t hmac_expected6[] = {
- 0x80,0xb2,0x42,0x63,0xc7,0xc1,0xa3,0xeb,0xb7,0x14,0x93,0xc1,0xdd,
- 0x7b,0xe8,0xb4,0x9b,0x46,0xd1,0xf4,0x1b,0x4a,0xee,0xc1,0x12,0x1b,
- 0x01,0x37,0x83,0xf8,0xf3,0x52,0x6b,0x56,0xd0,0x37,0xe0,0x5f,0x25,
- 0x98,0xbd,0x0f,0xd2,0x21,0x5d,0x6a,0x1e,0x52,0x95,0xe6,0x4f,0x73,
- 0xf6,0x3f,0x0a,0xec,0x8b,0x91,0x5a,0x98,0x5d,0x78,0x65,0x98
- };
-
- const uint8_t hmac_expected7[] = {
- 0xe3,0x7b,0x6a,0x77,0x5d,0xc8,0x7d,0xba,0xa4,0xdf,0xa9,0xf9,0x6e,
- 0x5e,0x3f,0xfd,0xde,0xbd,0x71,0xf8,0x86,0x72,0x89,0x86,0x5d,0xf5,
- 0xa3,0x2d,0x20,0xcd,0xc9,0x44,0xb6,0x02,0x2c,0xac,0x3c,0x49,0x82,
- 0xb1,0x0d,0x5e,0xeb,0x55,0xc3,0xe4,0xde,0x15,0x13,0x46,0x76,0xfb,
- 0x6d,0xe0,0x44,0x60,0x65,0xc9,0x74,0x40,0xfa,0x8c,0x6a,0x58
- };
-
- memcpy(secret6, std::string(131, 0xaa).c_str(), 131);
- memcpy(secret7, std::string(131, 0xaa).c_str(), 131);
- RUN_NTH_TEST_CASE_FOR_ALG(1, SHA512);
- RUN_NTH_TEST_CASE_FOR_ALG(2, SHA512);
- RUN_NTH_TEST_CASE_FOR_ALG(3, SHA512);
- RUN_NTH_TEST_CASE_FOR_ALG(4, SHA512);
- RUN_NTH_TEST_CASE_FOR_ALG(6, SHA512);
- RUN_NTH_TEST_CASE_FOR_ALG(7, SHA512);
+ std::vector<std::vector<uint8_t> > hmac_expected_list(7);
+
+ int i = 0;
+ decodeHex("87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17c"
+ "dedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a12"
+ "6854", hmac_expected_list[i++]);
+ decodeHex("164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505"
+ "549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bc"
+ "e737", hmac_expected_list[i++]);
+ decodeHex("fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d"
+ "39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e132"
+ "92fb", hmac_expected_list[i++]);
+ decodeHex("b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3"
+ "dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a2"
+ "98dd", hmac_expected_list[i++]);
+ decodeHex("415fad6271580a531d4179bc891d87a6", hmac_expected_list[i++]);
+ decodeHex("80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f3"
+ "526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d78"
+ "6598", hmac_expected_list[i++]);
+ decodeHex("e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc9"
+ "44b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c"
+ "6a58", hmac_expected_list[i++]);
+
+ doRFC4231Tests(SHA512, hmac_expected_list);
}
TEST(CryptoLinkTest, DISABLED_HMAC_SHA256_RFC2202_SIGN_TRUNCATED) {
More information about the bind10-changes
mailing list