port NAC to security v2
This commit is based on Lei Pi's commit, which changed certificate version from v1 to v2.
The later changes fix some bugs and refactor algo part of the library to get rid of cryptopp.
Change-Id: I3be7e0341fe85ee69f1b5f1c3ed7421a6c61d0b5
diff --git a/tests/boost-test.hpp b/tests/boost-test.hpp
index f1b30b8..de1cfa2 100644
--- a/tests/boost-test.hpp
+++ b/tests/boost-test.hpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
- * Copyright (c) 2014-2015, Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
*
* This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
* See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -24,8 +24,8 @@
#pragma GCC system_header
#pragma clang system_header
-#include <boost/test/unit_test.hpp>
#include <boost/concept_check.hpp>
#include <boost/test/output_test_stream.hpp>
+#include <boost/test/unit_test.hpp>
#endif // NDN_GEP_TESTS_BOOST_TEST_HPP
diff --git a/tests/unit-tests/algo/aes.t.cpp b/tests/unit-tests/algo/aes.t.cpp
index 740855e..a2bf151 100644
--- a/tests/unit-tests/algo/aes.t.cpp
+++ b/tests/unit-tests/algo/aes.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
- * Copyright (c) 2014-2015, Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
*
* This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
* See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -27,65 +27,64 @@
namespace algo {
namespace tests {
-const uint8_t key[] = {
- 0xdd, 0x60, 0x77, 0xec, 0xa9, 0x6b, 0x23, 0x1b,
- 0x40, 0x6b, 0x5a, 0xf8, 0x7d, 0x3d, 0x55, 0x32
-};
+const uint8_t key[] = {0xdd, 0x60, 0x77, 0xec, 0xa9, 0x6b, 0x23, 0x1b,
+ 0x40, 0x6b, 0x5a, 0xf8, 0x7d, 0x3d, 0x55, 0x32};
-const uint8_t plaintext[] = { // plaintext: AES-Encrypt-Test
- 0x41, 0x45, 0x53, 0x2d, 0x45, 0x6e, 0x63, 0x72,
- 0x79, 0x70, 0x74, 0x2d, 0x54, 0x65, 0x73, 0x74
-};
+// plaintext: AES-Encrypt-Test
+const uint8_t plaintext[] = { 0x41, 0x45, 0x53, 0x2d, 0x45, 0x6e, 0x63, 0x72,
+ 0x79, 0x70, 0x74, 0x2d, 0x54, 0x65, 0x73, 0x74};
-const uint8_t ciphertext_ecb[] = {
- 0xcb, 0xe5, 0x6a, 0x80, 0x41, 0x24, 0x58, 0x23,
- 0x84, 0x14, 0x15, 0x61, 0x80, 0xb9, 0x5e, 0xbd,
- 0xce, 0x32, 0xb4, 0xbe, 0xbc, 0x91, 0x31, 0xd6,
- 0x19, 0x00, 0x80, 0x8b, 0xfa, 0x00, 0x05, 0x9c
-};
+// const uint8_t ciphertext_ecb[] = {0xcb, 0xe5, 0x6a, 0x80, 0x41, 0x24, 0x58, 0x23, 0x84, 0x14, 0x15,
+// 0x61, 0x80, 0xb9, 0x5e, 0xbd, 0xce, 0x32, 0xb4, 0xbe, 0xbc, 0x91,
+// 0x31, 0xd6, 0x19, 0x00, 0x80, 0x8b, 0xfa, 0x00, 0x05, 0x9c};
-const uint8_t initvector[] = {
- 0x6f, 0x53, 0x7a, 0x65, 0x58, 0x6c, 0x65, 0x75,
- 0x44, 0x4c, 0x77, 0x35, 0x58, 0x63, 0x78, 0x6e
-};
+const uint8_t initvector[] = {0x6f, 0x53, 0x7a, 0x65, 0x58, 0x6c, 0x65, 0x75,
+ 0x44, 0x4c, 0x77, 0x35, 0x58, 0x63, 0x78, 0x6e};
-const uint8_t ciphertext_cbc_iv[] = {
- 0xb7, 0x19, 0x5a, 0xbb, 0x23, 0xbf, 0x92, 0xb0,
- 0x95, 0xae, 0x74, 0xe9, 0xad, 0x72, 0x7c, 0x28,
- 0x6e, 0xc6, 0x73, 0xb5, 0x0b, 0x1a, 0x9e, 0xb9,
- 0x4d, 0xc5, 0xbd, 0x8b, 0x47, 0x1f, 0x43, 0x00
-};
+const uint8_t ciphertext_cbc_iv[] = {0xb7, 0x19, 0x5a, 0xbb, 0x23, 0xbf, 0x92, 0xb0,
+ 0x95, 0xae, 0x74, 0xe9, 0xad, 0x72, 0x7c, 0x28,
+ 0x6e, 0xc6, 0x73, 0xb5, 0x0b, 0x1a, 0x9e, 0xb9,
+ 0x4d, 0xc5, 0xbd, 0x8b, 0x47, 0x1f, 0x43, 0x00};
BOOST_AUTO_TEST_SUITE(TestAesAlgorithm)
BOOST_AUTO_TEST_CASE(EncryptionDecryption)
{
- RandomNumberGenerator rng;
AesKeyParams params;
-
EncryptParams eparams(tlv::AlgorithmAesEcb, 16);
DecryptKey<Aes> decryptKey(Buffer(key, sizeof(key)));
EncryptKey<Aes> encryptKey = Aes::deriveEncryptKey(decryptKey.getKeyBits());
// check if loading key and key derivation
- BOOST_CHECK_EQUAL_COLLECTIONS(encryptKey.getKeyBits().begin(), encryptKey.getKeyBits().end(), key, key + sizeof(key));
- BOOST_CHECK_EQUAL_COLLECTIONS(decryptKey.getKeyBits().begin(), decryptKey.getKeyBits().end(), key, key + sizeof(key));
+ BOOST_CHECK_EQUAL_COLLECTIONS(encryptKey.getKeyBits().begin(),
+ encryptKey.getKeyBits().end(),
+ key, key + sizeof(key));
+ BOOST_CHECK_EQUAL_COLLECTIONS(decryptKey.getKeyBits().begin(),
+ decryptKey.getKeyBits().end(),
+ key, key + sizeof(key));
- // encrypt data in AES_ECB
- Buffer cipherBuf = Aes::encrypt(key, sizeof(key), plaintext, sizeof(plaintext), eparams);
- BOOST_CHECK_EQUAL_COLLECTIONS(cipherBuf.begin(), cipherBuf.end(),
- ciphertext_ecb, ciphertext_ecb + sizeof(ciphertext_ecb));
+ // Comment out the test of AES_ECB because NAC no longer supports CBC.
+ // Compared with ECB, CBC is more secure.
- // decrypt data in AES_ECB
- Buffer recvBuf = Aes::decrypt(key, sizeof(key), cipherBuf.buf(), cipherBuf.size(), eparams);
- BOOST_CHECK_EQUAL_COLLECTIONS(recvBuf.begin(), recvBuf.end(),
- plaintext, plaintext + sizeof(plaintext));
+ // // encrypt data in AES_ECB
+ // Buffer cipherBuf = Aes::encrypt(key, sizeof(key), plaintext, sizeof(plaintext), eparams);
+ // BOOST_CHECK_EQUAL_COLLECTIONS(cipherBuf.begin(),
+ // cipherBuf.end(),
+ // ciphertext_ecb,
+ // ciphertext_ecb + sizeof(ciphertext_ecb));
+
+ // // decrypt data in AES_ECB
+ // Buffer recvBuf = Aes::decrypt(key, sizeof(key), cipherBuf.data(), cipherBuf.size(), eparams);
+ // BOOST_CHECK_EQUAL_COLLECTIONS(recvBuf.begin(),
+ // recvBuf.end(),
+ // plaintext,
+ // plaintext + sizeof(plaintext));
// encrypt/decrypt data in AES_CBC with auto-generated IV
eparams.setAlgorithmType(tlv::AlgorithmAesCbc);
- cipherBuf = Aes::encrypt(key, sizeof(key), plaintext, sizeof(plaintext), eparams);
- recvBuf = Aes::decrypt(key, sizeof(key), cipherBuf.buf(), cipherBuf.size(), eparams);
+ Buffer cipherBuf = Aes::encrypt(key, sizeof(key), plaintext, sizeof(plaintext), eparams);
+ Buffer recvBuf = Aes::decrypt(key, sizeof(key), cipherBuf.data(), cipherBuf.size(), eparams);
BOOST_CHECK_EQUAL_COLLECTIONS(recvBuf.begin(), recvBuf.end(),
plaintext, plaintext + sizeof(plaintext));
@@ -96,7 +95,7 @@
ciphertext_cbc_iv, ciphertext_cbc_iv + sizeof(ciphertext_cbc_iv));
// decrypt data in AES_CBC with specified IV
- recvBuf = Aes::decrypt(key, sizeof(key), cipherBuf.buf(), cipherBuf.size(), eparams);
+ recvBuf = Aes::decrypt(key, sizeof(key), cipherBuf.data(), cipherBuf.size(), eparams);
BOOST_CHECK_EQUAL_COLLECTIONS(recvBuf.begin(), recvBuf.end(),
plaintext, plaintext + sizeof(plaintext));
}
diff --git a/tests/unit-tests/algo/encryptor.t.cpp b/tests/unit-tests/algo/encryptor.t.cpp
index d6c0451..59a3d5b 100644
--- a/tests/unit-tests/algo/encryptor.t.cpp
+++ b/tests/unit-tests/algo/encryptor.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
- * Copyright (c) 2014-2015, Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
*
* This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
* See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -17,14 +17,13 @@
* ndn-group-encrypt, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
*/
-#include "random-number-generator.hpp"
-#include "encrypted-content.hpp"
#include "algo/encryptor.hpp"
-#include "algo/rsa.hpp"
+#include "encrypted-content.hpp"
#include "algo/aes.hpp"
+#include "algo/rsa.hpp"
-#include <boost/mpl/list.hpp>
#include "boost-test.hpp"
+#include <boost/mpl/list.hpp>
#include <algorithm>
namespace ndn {
@@ -34,51 +33,6 @@
BOOST_AUTO_TEST_SUITE(TestEncryptor)
-class TestDataAesEcb
-{
-public:
- TestDataAesEcb()
- : keyName("/test")
- , encryptParams(tlv::AlgorithmAesEcb)
- {
- const uint8_t raw_content[] = {
- 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
- 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
- 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73
- };
- plainText = Buffer(raw_content, sizeof(raw_content));
-
- const uint8_t aes_key[] = {
- 0xdd, 0x60, 0x77, 0xec, 0xa9, 0x6b, 0x23, 0x1b,
- 0x40, 0x6b, 0x5a, 0xf8, 0x7d, 0x3d, 0x55, 0x32
- };
- key = Buffer(aes_key, sizeof(aes_key));
-
- const uint8_t encrypted_content[] = {
- 0x15, 0x31,
- 0x82, 0x2f,
- 0x1c, 0x08,
- 0x07, 0x06,
- 0x08, 0x04, 0x74, 0x65, 0x73, 0x74,
- 0x83, 0x01,
- 0x00,
- 0x84, 0x20,
- 0x13, 0x80, 0x1a, 0xc0, 0x4c, 0x75, 0xa7, 0x7f,
- 0x43, 0x5e, 0xd7, 0xa6, 0x3f, 0xd3, 0x68, 0x94,
- 0xe2, 0xcf, 0x54, 0xb1, 0xc2, 0xce, 0xad, 0x9b,
- 0x56, 0x6e, 0x1c, 0xe6, 0x55, 0x1d, 0x79, 0x04
- };
- encryptedContent = Buffer(encrypted_content, sizeof(encrypted_content));
- }
-
-public:
- Buffer plainText;
- Buffer key;
- Name keyName;
- EncryptParams encryptParams;
- Buffer encryptedContent;
-};
-
class TestDataAesCbc
{
public:
@@ -134,29 +88,39 @@
Buffer encryptedContent;
};
-typedef boost::mpl::list<TestDataAesCbc,
- TestDataAesEcb> EncryptorAesTestInputs;
+typedef boost::mpl::list<TestDataAesCbc> EncryptorAesTestInputs;
BOOST_AUTO_TEST_CASE_TEMPLATE(ContentSymmetricEncrypt, T, EncryptorAesTestInputs)
{
T input;
Data data;
- encryptData(data, input.plainText.buf(), input.plainText.size(),
- input.keyName, input.key.buf(), input.key.size(), input.encryptParams);
+ encryptData(data,
+ input.plainText.data(),
+ input.plainText.size(),
+ input.keyName,
+ input.key.data(),
+ input.key.size(),
+ input.encryptParams);
BOOST_CHECK_EQUAL(data.getName(), Name("/FOR").append(input.keyName));
- BOOST_CHECK_EQUAL_COLLECTIONS(input.encryptedContent.begin(), input.encryptedContent.end(),
- data.getContent().wire(), data.getContent().wire() + data.getContent().size());
+ BOOST_CHECK_EQUAL_COLLECTIONS(input.encryptedContent.begin(),
+ input.encryptedContent.end(),
+ data.getContent().wire(),
+ data.getContent().wire() + data.getContent().size());
EncryptedContent content(data.getContent().blockFromValue());
- const Buffer& decryptedOutput = Aes::decrypt(input.key.buf(), input.key.size(),
- content.getPayload().buf(), content.getPayload().size(),
+ const Buffer& decryptedOutput = Aes::decrypt(input.key.data(),
+ input.key.size(),
+ content.getPayload().data(),
+ content.getPayload().size(),
input.encryptParams);
- BOOST_CHECK_EQUAL_COLLECTIONS(input.plainText.begin(), input.plainText.end(),
- decryptedOutput.begin(), decryptedOutput.end());
+ BOOST_CHECK_EQUAL_COLLECTIONS(input.plainText.begin(),
+ input.plainText.end(),
+ decryptedOutput.begin(),
+ decryptedOutput.end());
}
class TestDataRsaOaep
@@ -166,6 +130,7 @@
: type(tlv::AlgorithmRsaOaep)
{
}
+
public:
tlv::AlgorithmTypeValue type;
};
@@ -177,30 +142,27 @@
: type(tlv::AlgorithmRsaPkcs)
{
}
+
public:
tlv::AlgorithmTypeValue type;
};
-typedef boost::mpl::list<TestDataRsaOaep,
- TestDataRsaPkcs> EncryptorRsaTestInputs;
+typedef boost::mpl::list<TestDataRsaOaep, TestDataRsaPkcs> EncryptorRsaTestInputs;
BOOST_AUTO_TEST_CASE_TEMPLATE(ContentAsymmetricEncryptSmall, T, EncryptorRsaTestInputs)
{
T type;
- const uint8_t raw_content[] = {
- 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
- 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
- 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73
- };
+ const uint8_t raw_content[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
+ 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
+ 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73};
Data data;
- RandomNumberGenerator rng;
RsaKeyParams rsaParams(1024);
Name keyName("test");
- DecryptKey<Rsa> decryptKey = Rsa::generateKey(rng, rsaParams);
+ DecryptKey<Rsa> decryptKey = Rsa::generateKey(rsaParams);
EncryptKey<Rsa> encryptKey = Rsa::deriveEncryptKey(decryptKey.getKeyBits());
Buffer eKey = encryptKey.getKeyBits();
@@ -208,8 +170,7 @@
EncryptParams encryptParams(type.type);
- encryptData(data, raw_content, sizeof(raw_content),
- keyName, eKey.buf(), eKey.size(), encryptParams);
+ encryptData(data, raw_content, sizeof(raw_content), keyName, eKey.data(), eKey.size(), encryptParams);
BOOST_CHECK_EQUAL(data.getName(), Name("/FOR").append(keyName));
@@ -223,69 +184,53 @@
BOOST_CHECK_EQUAL(extractContent.getAlgorithmType(), type.type);
const Buffer& recovered = extractContent.getPayload();
- Buffer decrypted = Rsa::decrypt(dKey.buf(), dKey.size(), recovered.buf(), recovered.size(), encryptParams);
- BOOST_CHECK_EQUAL_COLLECTIONS(raw_content, raw_content + sizeof(raw_content),
- decrypted.begin(), decrypted.end());
+ Buffer decrypted =
+ Rsa::decrypt(dKey.data(), dKey.size(), recovered.data(), recovered.size());
+ BOOST_CHECK_EQUAL_COLLECTIONS(raw_content,
+ raw_content + sizeof(raw_content),
+ decrypted.begin(),
+ decrypted.end());
}
BOOST_AUTO_TEST_CASE_TEMPLATE(ContentAsymmetricEncryptLarge, T, EncryptorRsaTestInputs)
{
T type;
- const uint8_t large_content[] = {
- 0x73, 0x5a, 0xbd, 0x47, 0x0c, 0xfe, 0xf8, 0x7d,
- 0x2e, 0x17, 0xaa, 0x11, 0x6f, 0x23, 0xc5, 0x10,
- 0x23, 0x36, 0x88, 0xc4, 0x2a, 0x0f, 0x9a, 0x72,
- 0x54, 0x31, 0xa8, 0xb3, 0x51, 0x18, 0x9f, 0x0e,
- 0x1b, 0x93, 0x62, 0xd9, 0xc4, 0xf5, 0xf4, 0x3d,
- 0x61, 0x9a, 0xca, 0x05, 0x65, 0x6b, 0xc6, 0x41,
- 0xf9, 0xd5, 0x1c, 0x67, 0xc1, 0xd0, 0xd5, 0x6f,
- 0x7b, 0x70, 0xb8, 0x8f, 0xdb, 0x19, 0x68, 0x7c,
- 0xe0, 0x2d, 0x04, 0x49, 0xa9, 0xa2, 0x77, 0x4e,
- 0xfc, 0x60, 0x0d, 0x7c, 0x1b, 0x93, 0x6c, 0xd2,
- 0x61, 0xc4, 0x6b, 0x01, 0xe9, 0x12, 0x28, 0x6d,
- 0xf5, 0x78, 0xe9, 0x99, 0x0b, 0x9c, 0x4f, 0x90,
- 0x34, 0x3e, 0x06, 0x92, 0x57, 0xe3, 0x7a, 0x8f,
- 0x13, 0xc7, 0xf3, 0xfe, 0xf0, 0xe2, 0x59, 0x48,
- 0x15, 0xb9, 0xdb, 0x77, 0x07, 0x1d, 0x6d, 0xb5,
- 0x65, 0x17, 0xdf, 0x76, 0x6f, 0xb5, 0x43, 0xde,
- 0x71, 0xac, 0xf1, 0x22, 0xbf, 0xb2, 0xe5, 0xd9,
- 0x22, 0xf1, 0x67, 0x76, 0x71, 0x0c, 0xff, 0x99,
- 0x7b, 0x94, 0x9b, 0x24, 0x20, 0x80, 0xe3, 0xcc,
- 0x06, 0x4a, 0xed, 0xdf, 0xec, 0x50, 0xd5, 0x87,
- 0x3d, 0xa0, 0x7d, 0x9c, 0xe5, 0x13, 0x10, 0x98,
- 0x14, 0xc3, 0x90, 0x10, 0xd9, 0x25, 0x9a, 0x59,
- 0xe9, 0x37, 0x26, 0xfd, 0x87, 0xd7, 0xf4, 0xf9,
- 0x11, 0x91, 0xad, 0x5c, 0x00, 0x95, 0xf5, 0x2b,
- 0x37, 0xf7, 0x4e, 0xb4, 0x4b, 0x42, 0x7c, 0xb3,
- 0xad, 0xd6, 0x33, 0x5f, 0x0b, 0x84, 0x57, 0x7f,
- 0xa7, 0x07, 0x73, 0x37, 0x4b, 0xab, 0x2e, 0xfb,
- 0xfe, 0x1e, 0xcb, 0xb6, 0x4a, 0xc1, 0x21, 0x5f,
- 0xec, 0x92, 0xb7, 0xac, 0x97, 0x75, 0x20, 0xc9,
- 0xd8, 0x9e, 0x93, 0xd5, 0x12, 0x7a, 0x64, 0xb9,
- 0x4c, 0xed, 0x49, 0x87, 0x44, 0x5b, 0x4f, 0x90,
- 0x34, 0x3e, 0x06, 0x92, 0x57, 0xe3, 0x7a, 0x8f,
- 0x13, 0xc7, 0xf3, 0xfe, 0xf0, 0xe2, 0x59, 0x48,
- 0x15, 0xb9, 0xdb, 0x77, 0x07, 0x1d, 0x6d, 0xb5,
- 0x65, 0x17, 0xdf, 0x76, 0x6f, 0xb5, 0x43, 0xde,
- 0x71, 0xac, 0xf1, 0x22, 0xbf, 0xb2, 0xe5, 0xd9
- };
+ const uint8_t large_content[] =
+ {0x73, 0x5a, 0xbd, 0x47, 0x0c, 0xfe, 0xf8, 0x7d, 0x2e, 0x17, 0xaa, 0x11, 0x6f, 0x23, 0xc5,
+ 0x10, 0x23, 0x36, 0x88, 0xc4, 0x2a, 0x0f, 0x9a, 0x72, 0x54, 0x31, 0xa8, 0xb3, 0x51, 0x18,
+ 0x9f, 0x0e, 0x1b, 0x93, 0x62, 0xd9, 0xc4, 0xf5, 0xf4, 0x3d, 0x61, 0x9a, 0xca, 0x05, 0x65,
+ 0x6b, 0xc6, 0x41, 0xf9, 0xd5, 0x1c, 0x67, 0xc1, 0xd0, 0xd5, 0x6f, 0x7b, 0x70, 0xb8, 0x8f,
+ 0xdb, 0x19, 0x68, 0x7c, 0xe0, 0x2d, 0x04, 0x49, 0xa9, 0xa2, 0x77, 0x4e, 0xfc, 0x60, 0x0d,
+ 0x7c, 0x1b, 0x93, 0x6c, 0xd2, 0x61, 0xc4, 0x6b, 0x01, 0xe9, 0x12, 0x28, 0x6d, 0xf5, 0x78,
+ 0xe9, 0x99, 0x0b, 0x9c, 0x4f, 0x90, 0x34, 0x3e, 0x06, 0x92, 0x57, 0xe3, 0x7a, 0x8f, 0x13,
+ 0xc7, 0xf3, 0xfe, 0xf0, 0xe2, 0x59, 0x48, 0x15, 0xb9, 0xdb, 0x77, 0x07, 0x1d, 0x6d, 0xb5,
+ 0x65, 0x17, 0xdf, 0x76, 0x6f, 0xb5, 0x43, 0xde, 0x71, 0xac, 0xf1, 0x22, 0xbf, 0xb2, 0xe5,
+ 0xd9, 0x22, 0xf1, 0x67, 0x76, 0x71, 0x0c, 0xff, 0x99, 0x7b, 0x94, 0x9b, 0x24, 0x20, 0x80,
+ 0xe3, 0xcc, 0x06, 0x4a, 0xed, 0xdf, 0xec, 0x50, 0xd5, 0x87, 0x3d, 0xa0, 0x7d, 0x9c, 0xe5,
+ 0x13, 0x10, 0x98, 0x14, 0xc3, 0x90, 0x10, 0xd9, 0x25, 0x9a, 0x59, 0xe9, 0x37, 0x26, 0xfd,
+ 0x87, 0xd7, 0xf4, 0xf9, 0x11, 0x91, 0xad, 0x5c, 0x00, 0x95, 0xf5, 0x2b, 0x37, 0xf7, 0x4e,
+ 0xb4, 0x4b, 0x42, 0x7c, 0xb3, 0xad, 0xd6, 0x33, 0x5f, 0x0b, 0x84, 0x57, 0x7f, 0xa7, 0x07,
+ 0x73, 0x37, 0x4b, 0xab, 0x2e, 0xfb, 0xfe, 0x1e, 0xcb, 0xb6, 0x4a, 0xc1, 0x21, 0x5f, 0xec,
+ 0x92, 0xb7, 0xac, 0x97, 0x75, 0x20, 0xc9, 0xd8, 0x9e, 0x93, 0xd5, 0x12, 0x7a, 0x64, 0xb9,
+ 0x4c, 0xed, 0x49, 0x87, 0x44, 0x5b, 0x4f, 0x90, 0x34, 0x3e, 0x06, 0x92, 0x57, 0xe3, 0x7a,
+ 0x8f, 0x13, 0xc7, 0xf3, 0xfe, 0xf0, 0xe2, 0x59, 0x48, 0x15, 0xb9, 0xdb, 0x77, 0x07, 0x1d,
+ 0x6d, 0xb5, 0x65, 0x17, 0xdf, 0x76, 0x6f, 0xb5, 0x43, 0xde, 0x71, 0xac, 0xf1, 0x22, 0xbf,
+ 0xb2, 0xe5, 0xd9};
Data data;
- RandomNumberGenerator rng;
RsaKeyParams rsaParams(1024);
Name keyName("test");
- DecryptKey<Rsa> decryptKey = Rsa::generateKey(rng, rsaParams);
+ DecryptKey<Rsa> decryptKey = Rsa::generateKey(rsaParams);
EncryptKey<Rsa> encryptKey = Rsa::deriveEncryptKey(decryptKey.getKeyBits());
Buffer eKey = encryptKey.getKeyBits();
Buffer dKey = decryptKey.getKeyBits();
EncryptParams encryptParams(type.type);
- encryptData(data, large_content, sizeof(large_content),
- keyName, eKey.buf(), eKey.size(), encryptParams);
+ encryptData(data, large_content, sizeof(large_content), keyName, eKey.data(), eKey.size(), encryptParams);
BOOST_CHECK_EQUAL(data.getName(), Name("/FOR").append(keyName));
@@ -317,20 +262,25 @@
BOOST_CHECK(it == largeDataContent.elements_end());
const Buffer& bufferNonce = encryptedNonce.getPayload();
- Buffer nonce = Rsa::decrypt(dKey.buf(), dKey.size(), bufferNonce.buf(), bufferNonce.size(), encryptParams);
+ Buffer nonce =
+ Rsa::decrypt(dKey.data(), dKey.size(), bufferNonce.data(), bufferNonce.size());
encryptParams.setAlgorithmType(tlv::AlgorithmAesCbc);
- encryptParams.setIV(encryptedPayload.getInitialVector().buf(), encryptedPayload.getInitialVector().size());
+ encryptParams.setIV(encryptedPayload.getInitialVector().data(),
+ encryptedPayload.getInitialVector().size());
const Buffer& bufferPayload = encryptedPayload.getPayload();
- Buffer largePayload = Aes::decrypt(nonce.buf(), nonce.size(), bufferPayload.buf(), bufferPayload.size(), encryptParams);
+ Buffer largePayload =
+ Aes::decrypt(nonce.data(), nonce.size(), bufferPayload.data(), bufferPayload.size(), encryptParams);
- BOOST_CHECK_EQUAL_COLLECTIONS(large_content, large_content + sizeof(large_content),
- largePayload.begin(), largePayload.end());
+ BOOST_CHECK_EQUAL_COLLECTIONS(large_content,
+ large_content + sizeof(large_content),
+ largePayload.begin(),
+ largePayload.end());
}
BOOST_AUTO_TEST_SUITE_END()
-} // namespace algo
} // namespace tests
+} // namespace algo
} // namespace gep
} // namespace ndn
diff --git a/tests/unit-tests/algo/rsa.t.cpp b/tests/unit-tests/algo/rsa.t.cpp
index d9ee899..6b7bbcb 100644
--- a/tests/unit-tests/algo/rsa.t.cpp
+++ b/tests/unit-tests/algo/rsa.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
- * Copyright (c) 2014-2015, Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
*
* This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
* See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -17,109 +17,53 @@
* ndn-group-encrypt, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
*/
-#include <ndn-cxx/encoding/buffer-stream.hpp>
-#include "algo/encrypt-params.hpp"
#include "algo/rsa.hpp"
-
+#include "algo/encrypt-params.hpp"
#include "boost-test.hpp"
+#include <ndn-cxx/security/key-params.hpp>
+#include <ndn-cxx/security/transform/private-key.hpp>
+#include <ndn-cxx/security/transform/public-key.hpp>
+#include <ndn-cxx/encoding/buffer-stream.hpp>
#include <algorithm>
#include <string>
-using namespace CryptoPP;
-
namespace ndn {
namespace gep {
namespace algo {
namespace tests {
-const std::string privateKey = {
- "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAMLY2w1PmsuZNvZ4"
- "rJs1pESLrxF1Xlk9Zg4Sc0r2HIEn/eme8f7cOxXq8OtxIjowEfjceHGvfc7YG1Nw"
- "LDh+ka4Jh6QtYqPEL9GHfrBeufynd0g2PAPVXySBvOJr/Isk+4/Fsj5ihrIPgrQ5"
- "wTBBuLYjDgwPppC/+vddsr5wu5bbAgMBAAECgYBYmRLB8riIa5q6aBTUXofbQ0jP"
- "v3avTWPicjFKnK5JbE3gtQ2Evc+AH9x8smzF2KXTayy5RPsH2uxR/GefKK5EkWbB"
- "mLwWDJ5/QPlLK1STxPs8B/89mp8sZkZ1AxnSHhV/a3dRcK1rVamVcqPMdFyM5PfX"
- "/apL3MlL6bsq2FipAQJBAOp7EJuEs/qAjh8hgyV2acLdsokUEwXH4gCK6+KQW8XS"
- "xFWAG4IbbLfq1HwEpHC2hJSzifCQGoPAxYBRgSK+h6sCQQDUuqF04o06+Qpe4A/W"
- "pWCBGE33+CD4lBtaeoIagsAs/lgcFmXiJZ4+4PhyIORmwFgql9ZDFHSpl8rAYsfk"
- "dz2RAkEAtUKpFe/BybYzJ3Galg0xuMf0ye7QvblExjKeIqiBqS1DRO0hVrSomIxZ"
- "8f0MuWz+lI0t5t8fABa3FnjrINa0vQJBAJeZKNaTXPJZ5/oU0zS0RkG5gFbmjRiY"
- "86VXCMC7zRhDaacajyDKjithR6yNpDdVe39fFWJYgYsakXLo8mruTwECQGqywoy9"
- "epf1flKx4YCCrw+qRKmbkcXWcpFV32EG2K2D1GsxkuXv/b3qO67Uxx1Arxp9o8dl"
- "k34WfzApRjNjho0="
-};
-
-const std::string publicKey = {
- "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDC2NsNT5rLmTb2eKybNaREi68R"
- "dV5ZPWYOEnNK9hyBJ/3pnvH+3DsV6vDrcSI6MBH43Hhxr33O2BtTcCw4fpGuCYek"
- "LWKjxC/Rh36wXrn8p3dINjwD1V8kgbzia/yLJPuPxbI+YoayD4K0OcEwQbi2Iw4M"
- "D6aQv/r3XbK+cLuW2wIDAQAB"
-};
-
-const uint8_t plaintext[] = { // plaintext: RSA-Encrypt-Test
- 0x52, 0x53, 0x41, 0x2d, 0x45, 0x6e, 0x63, 0x72,
- 0x79, 0x70, 0x74, 0x2d, 0x54, 0x65, 0x73, 0x74
-};
-
-const uint8_t ciphertext[] = {
- 0x33, 0xfb, 0x32, 0xd4, 0x2d, 0x45, 0x75, 0x3f, 0x34, 0xde, 0x3b,
- 0xaa, 0x80, 0x5f, 0x74, 0x6f, 0xf0, 0x3f, 0x01, 0x31, 0xdd, 0x2b,
- 0x85, 0x02, 0x1b, 0xed, 0x2d, 0x16, 0x1b, 0x96, 0xe5, 0x77, 0xde,
- 0xcd, 0x44, 0xe5, 0x3c, 0x32, 0xb6, 0x9a, 0xa9, 0x5d, 0xaa, 0x4b,
- 0x94, 0xe2, 0xac, 0x4a, 0x4e, 0xf5, 0x35, 0x21, 0xd0, 0x03, 0x4a,
- 0xa7, 0x53, 0xae, 0x13, 0x08, 0x63, 0x38, 0x2c, 0x92, 0xe3, 0x44,
- 0x64, 0xbf, 0x33, 0x84, 0x8e, 0x51, 0x9d, 0xb9, 0x85, 0x83, 0xf6,
- 0x8e, 0x09, 0xc1, 0x72, 0xb9, 0x90, 0x5d, 0x48, 0x63, 0xec, 0xd0,
- 0xcc, 0xfa, 0xab, 0x44, 0x2b, 0xaa, 0xa6, 0xb6, 0xca, 0xec, 0x2b,
- 0x5f, 0xbe, 0x77, 0xa5, 0x52, 0xeb, 0x0a, 0xaa, 0xf2, 0x2a, 0x19,
- 0x62, 0x80, 0x14, 0x87, 0x42, 0x35, 0xd0, 0xb6, 0xa3, 0x47, 0x4e,
- 0xb6, 0x1a, 0x88, 0xa3, 0x16, 0xb2, 0x19
-};
+// plaintext: RSA-Encrypt-Test
+const uint8_t plainText[] = { 0x52, 0x53, 0x41, 0x2d, 0x45, 0x6e, 0x63, 0x72,
+ 0x79, 0x70, 0x74, 0x2d, 0x54, 0x65, 0x73, 0x74};
BOOST_AUTO_TEST_SUITE(TestRsaAlgorithm)
+BOOST_AUTO_TEST_CASE(TransformEncryptionDecryption)
+{
+ RsaKeyParams params;
+ auto sKey = security::transform::generatePrivateKey(params);
+ security::transform::PublicKey pKey;
+ ConstBufferPtr pKeyBits = sKey->derivePublicKey();
+ pKey.loadPkcs8(pKeyBits->data(), pKeyBits->size());
+
+ auto cipherText = pKey.encrypt(plainText, sizeof(plainText));
+ auto decrypted = sKey->decrypt(cipherText->data(), cipherText->size());
+ BOOST_CHECK_EQUAL_COLLECTIONS(plainText, plainText + sizeof(plainText),
+ decrypted->begin(), decrypted->end());
+}
+
BOOST_AUTO_TEST_CASE(EncryptionDecryption)
{
- RandomNumberGenerator rng;
RsaKeyParams params;
- EncryptParams eparams(tlv::AlgorithmRsaOaep);
+ DecryptKey<Rsa> sKey = Rsa::generateKey(params);
+ EncryptKey<Rsa> pKey = Rsa::deriveEncryptKey(sKey.getKeyBits());
- OBufferStream privateKeyBuffer, publicKeyBuffer;
- StringSource privPipe(privateKey, true,
- new Base64Decoder(new FileSink(privateKeyBuffer)));
- StringSource publPipe(publicKey, true,
- new Base64Decoder(new FileSink(publicKeyBuffer)));
-
- DecryptKey<Rsa> decryptKey(std::move(*(privateKeyBuffer.buf())));
- EncryptKey<Rsa> encryptKey = Rsa::deriveEncryptKey(decryptKey.getKeyBits());
-
- const Buffer& encodedPublicKey = *(publicKeyBuffer.buf());
- const Buffer& derivedPublicKey = encryptKey.getKeyBits();
- const Buffer& encodedPrivateKey = *(privateKeyBuffer.buf());
- const Buffer& derivedPrivateKey = decryptKey.getKeyBits();
-
- BOOST_CHECK_EQUAL_COLLECTIONS(encodedPublicKey.begin(),
- encodedPublicKey.end(),
- derivedPublicKey.begin(),
- derivedPublicKey.end());
-
- const Buffer& encryptBuf = Rsa::encrypt(encodedPublicKey.buf(), encodedPublicKey.size(),
- plaintext, sizeof(plaintext),
- eparams);
-
- const Buffer& recvBuf = Rsa::decrypt(encodedPrivateKey.buf(), encodedPrivateKey.size(),
- encryptBuf.buf(), encryptBuf.size(),
- eparams);
-
- BOOST_CHECK_EQUAL_COLLECTIONS(plaintext, plaintext + sizeof(plaintext),
- recvBuf.begin(), recvBuf.end());
-
- const Buffer& convBuf = Rsa::decrypt(derivedPrivateKey.buf(), derivedPrivateKey.size(),
- ciphertext, sizeof(ciphertext),
- eparams);
-
- BOOST_CHECK_EQUAL_COLLECTIONS(plaintext, plaintext + sizeof(plaintext),
- convBuf.begin(), convBuf.end());
+ auto cipherText = Rsa::encrypt(pKey.getKeyBits().data(), pKey.getKeyBits().size(),
+ plainText, sizeof(plainText));
+ auto decrypted = Rsa::decrypt(sKey.getKeyBits().data(), sKey.getKeyBits().size(),
+ cipherText.data(), cipherText.size());
+ BOOST_CHECK_EQUAL_COLLECTIONS(plainText, plainText + sizeof(plainText),
+ decrypted.begin(), decrypted.end());
}
BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/unit-tests/consumer-db.t.cpp b/tests/unit-tests/consumer-db.t.cpp
index bad6213..67c33ce 100644
--- a/tests/unit-tests/consumer-db.t.cpp
+++ b/tests/unit-tests/consumer-db.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
- * Copyright (c) 2014-2015, Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
*
* This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
* See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -16,13 +16,13 @@
* You should have received a copy of the GNU General Public License along with
* ndn-group-encrypt, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
*
- * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
+ * @author Zhiyi Zhang <zhiyi@cs.ucla.edu>
*/
#include "consumer-db.hpp"
-#include "algo/rsa.hpp"
-#include "algo/aes.hpp"
#include "boost-test.hpp"
+#include "algo/aes.hpp"
+#include "algo/rsa.hpp"
#include <boost/filesystem.hpp>
@@ -47,9 +47,8 @@
void
generateRsaKey(Buffer& encryptionKeyBuf, Buffer& decryptionKeyBuf)
{
- RandomNumberGenerator rng;
RsaKeyParams params;
- DecryptKey<algo::Rsa> dKey = algo::Rsa::generateKey(rng, params);
+ DecryptKey<algo::Rsa> dKey = algo::Rsa::generateKey(params);
decryptionKeyBuf = dKey.getKeyBits();
EncryptKey<algo::Rsa> eKey = algo::Rsa::deriveEncryptKey(decryptionKeyBuf);
encryptionKeyBuf = eKey.getKeyBits();
@@ -58,9 +57,8 @@
void
generateAesKey(Buffer& encryptionKeyBuf, Buffer& decryptionKeyBuf)
{
- RandomNumberGenerator rng;
AesKeyParams params;
- DecryptKey<algo::Aes> memberDecryptKey = algo::Aes::generateKey(rng, params);
+ DecryptKey<algo::Aes> memberDecryptKey = algo::Aes::generateKey(params);
decryptionKeyBuf = memberDecryptKey.getKeyBits();
EncryptKey<algo::Aes> memberEncryptKey = algo::Aes::deriveEncryptKey(decryptionKeyBuf);
encryptionKeyBuf = memberEncryptKey.getKeyBits();
@@ -89,8 +87,7 @@
db.addKey(keyName, dKeyBuf);
Buffer resultBuf = db.getKey(keyName);
- BOOST_CHECK_EQUAL_COLLECTIONS(dKeyBuf.begin(), dKeyBuf.end(),
- resultBuf.begin(), resultBuf.end());
+ BOOST_CHECK_EQUAL_COLLECTIONS(dKeyBuf.begin(), dKeyBuf.end(), resultBuf.begin(), resultBuf.end());
db.deleteKey(keyName);
resultBuf = db.getKey(keyName);
@@ -115,8 +112,7 @@
db.addKey(keyName, dKeyBuf);
Buffer resultBuf = db.getKey(keyName);
- BOOST_CHECK_EQUAL_COLLECTIONS(dKeyBuf.begin(), dKeyBuf.end(),
- resultBuf.begin(), resultBuf.end());
+ BOOST_CHECK_EQUAL_COLLECTIONS(dKeyBuf.begin(), dKeyBuf.end(), resultBuf.begin(), resultBuf.end());
db.deleteKey(keyName);
resultBuf = db.getKey(keyName);
diff --git a/tests/unit-tests/consumer.t.cpp b/tests/unit-tests/consumer.t.cpp
index 15ede8b..174e247 100644
--- a/tests/unit-tests/consumer.t.cpp
+++ b/tests/unit-tests/consumer.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
- * Copyright (c) 2014-2016, Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
*
* This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
* See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -16,41 +16,35 @@
* You should have received a copy of the GNU General Public License along with
* ndn-group-encrypt, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
*
- * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
+ * @author Zhiyi Zhang <zhiyi@cs.ucla.edu>
* @author Yingdi Yu <yingdi@cs.ucla.edu>
*/
#include "consumer.hpp"
#include "boost-test.hpp"
-#include "algo/encryptor.hpp"
#include "unit-test-time-fixture.hpp"
+#include "algo/encryptor.hpp"
#include <ndn-cxx/security/key-chain.hpp>
#include <ndn-cxx/util/dummy-client-face.hpp>
#include <ndn-cxx/util/time-unit-test-clock.hpp>
-#include <boost/filesystem.hpp>
#include <boost/asio.hpp>
+#include <boost/filesystem.hpp>
namespace ndn {
namespace gep {
namespace tests {
-static const uint8_t DATA_CONTEN[] = {
- 0xcb, 0xe5, 0x6a, 0x80, 0x41, 0x24, 0x58, 0x23,
- 0x84, 0x14, 0x15, 0x61, 0x80, 0xb9, 0x5e, 0xbd,
- 0xce, 0x32, 0xb4, 0xbe, 0xbc, 0x91, 0x31, 0xd6,
- 0x19, 0x00, 0x80, 0x8b, 0xfa, 0x00, 0x05, 0x9c
-};
+static const uint8_t DATA_CONTEN[] = {0xcb, 0xe5, 0x6a, 0x80, 0x41, 0x24, 0x58, 0x23,
+ 0x84, 0x14, 0x15, 0x61, 0x80, 0xb9, 0x5e, 0xbd,
+ 0xce, 0x32, 0xb4, 0xbe, 0xbc, 0x91, 0x31, 0xd6,
+ 0x19, 0x00, 0x80, 0x8b, 0xfa, 0x00, 0x05, 0x9c};
-static const uint8_t AES_KEY[] = {
- 0xdd, 0x60, 0x77, 0xec, 0xa9, 0x6b, 0x23, 0x1b,
- 0x40, 0x6b, 0x5a, 0xf8, 0x7d, 0x3d, 0x55, 0x32
-};
+static const uint8_t AES_KEY[] =
+ {0xdd, 0x60, 0x77, 0xec, 0xa9, 0x6b, 0x23, 0x1b, 0x40, 0x6b, 0x5a, 0xf8, 0x7d, 0x3d, 0x55, 0x32};
-static const uint8_t IV[] = {
- 0x73, 0x6f, 0x6d, 0x65, 0x72, 0x61, 0x6e, 0x64,
- 0x6f, 0x6d, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72
-};
+static const uint8_t IV[] =
+ {0x73, 0x6f, 0x6d, 0x65, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72};
class ConsumerFixture : public UnitTestTimeFixture
{
@@ -74,13 +68,12 @@
boost::filesystem::create_directories(tmpPath);
// generate e/d key
- RandomNumberGenerator rng;
RsaKeyParams params;
- fixtureDKeyBuf = algo::Rsa::generateKey(rng, params).getKeyBits();
+ fixtureDKeyBuf = algo::Rsa::generateKey(params).getKeyBits();
fixtureEKeyBuf = algo::Rsa::deriveEncryptKey(fixtureDKeyBuf).getKeyBits();
// generate user key
- fixtureUDKeyBuf = algo::Rsa::generateKey(rng, params).getKeyBits();
+ fixtureUDKeyBuf = algo::Rsa::generateKey(params).getKeyBits();
fixtureUEKeyBuf = algo::Rsa::deriveEncryptKey(fixtureUDKeyBuf).getKeyBits();
// load C-KEY
@@ -98,8 +91,13 @@
shared_ptr<Data> contentData = make_shared<Data>(contentName);
algo::EncryptParams eparams(tlv::AlgorithmAesCbc);
eparams.setIV(IV, sizeof(IV));
- algo::encryptData(*contentData, DATA_CONTEN, sizeof(DATA_CONTEN), cKeyName,
- fixtureCKeyBuf.buf(), fixtureCKeyBuf.size(), eparams);
+ algo::encryptData(*contentData,
+ DATA_CONTEN,
+ sizeof(DATA_CONTEN),
+ cKeyName,
+ fixtureCKeyBuf.data(),
+ fixtureCKeyBuf.size(),
+ eparams);
keyChain.sign(*contentData);
return contentData;
}
@@ -109,8 +107,13 @@
{
shared_ptr<Data> cKeyData = make_shared<Data>(cKeyName);
algo::EncryptParams eparams(tlv::AlgorithmRsaOaep);
- algo::encryptData(*cKeyData, fixtureCKeyBuf.buf(), fixtureCKeyBuf.size(), dKeyName,
- fixtureEKeyBuf.buf(), fixtureEKeyBuf.size(), eparams);
+ algo::encryptData(*cKeyData,
+ fixtureCKeyBuf.data(),
+ fixtureCKeyBuf.size(),
+ dKeyName,
+ fixtureEKeyBuf.data(),
+ fixtureEKeyBuf.size(),
+ eparams);
keyChain.sign(*cKeyData);
return cKeyData;
}
@@ -120,8 +123,13 @@
{
shared_ptr<Data> dKeyData = make_shared<Data>(dKeyName);
algo::EncryptParams eparams(tlv::AlgorithmRsaOaep);
- algo::encryptData(*dKeyData, fixtureDKeyBuf.buf(), fixtureDKeyBuf.size(), uKeyName,
- fixtureUEKeyBuf.buf(), fixtureUEKeyBuf.size(), eparams);
+ algo::encryptData(*dKeyData,
+ fixtureDKeyBuf.data(),
+ fixtureDKeyBuf.size(),
+ uKeyName,
+ fixtureUEKeyBuf.data(),
+ fixtureUEKeyBuf.size(),
+ eparams);
keyChain.sign(*dKeyData);
return dKeyData;
}
@@ -202,26 +210,24 @@
// decrypt
consumer.decrypt(cKeyData->getContent().blockFromValue(),
fixtureDKeyBuf,
- [=](const Buffer& result){
- BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(),
+ [=] (const Buffer& result) {
+ BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(),
+ result.end(),
aesKeyBuf.begin(),
aesKeyBuf.end());
},
- [=](const ErrorCode&, const std::string&){
- BOOST_CHECK(false);
- });
+ [=] (const ErrorCode&, const std::string&) { BOOST_CHECK(false); });
// decrypt
consumer.decrypt(contentData->getContent().blockFromValue(),
fixtureCKeyBuf,
- [=](const Buffer& result){
- BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(),
+ [=] (const Buffer& result) {
+ BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(),
+ result.end(),
DATA_CONTEN,
DATA_CONTEN + sizeof(DATA_CONTEN));
},
- [=](const ErrorCode&, const std::string&){
- BOOST_CHECK(false);
- });
+ [=] (const ErrorCode&, const std::string&) { BOOST_CHECK(false); });
}
BOOST_AUTO_TEST_CASE(Consume)
@@ -256,7 +262,7 @@
return;
},
RegisterPrefixSuccessCallback(),
- [] (const Name&, const std::string& e) { });
+ [] (const Name&, const std::string& e) {});
do {
advanceClocks(time::milliseconds(10), 20);
@@ -270,15 +276,14 @@
int finalCount = 0;
consumer.consume(contentName,
- [&](const Data& data, const Buffer& result){
+ [&] (const Data& data, const Buffer& result) {
finalCount = 1;
- BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(),
+ BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(),
+ result.end(),
DATA_CONTEN,
DATA_CONTEN + sizeof(DATA_CONTEN));
},
- [&](const ErrorCode& code, const std::string& str){
- BOOST_CHECK(false);
- });
+ [&] (const ErrorCode& code, const std::string& str) { BOOST_CHECK(false); });
do {
advanceClocks(time::milliseconds(10), 20);
@@ -305,7 +310,7 @@
// prepare face1
face1.setInterestFilter(prefix,
[&] (const InterestFilter&, const Interest& i) {
- BOOST_CHECK(i.getLink().getDelegations().size() == 3);
+ BOOST_CHECK(i.getForwardingHint().size() == 3);
if (i.matchesData(*contentData)) {
contentCount++;
face1.put(*contentData);
@@ -324,7 +329,7 @@
return;
},
RegisterPrefixSuccessCallback(),
- [] (const Name&, const std::string& e) { });
+ [] (const Name&, const std::string& e) {});
do {
advanceClocks(time::milliseconds(10), 20);
@@ -345,13 +350,11 @@
consumer.addDecryptionKey(uKeyName, fixtureUDKeyBuf);
consumer.consume(contentName,
- [&](const Data& data, const Buffer& result){
+ [&] (const Data& data, const Buffer& result) {
BOOST_CHECK(true);
resultCount++;
},
- [](const ErrorCode& code, const std::string& str){
- BOOST_CHECK(false);
- },
+ [] (const ErrorCode& code, const std::string& str) { BOOST_CHECK(false); },
datalink);
do {
@@ -366,6 +369,6 @@
BOOST_AUTO_TEST_SUITE_END()
-} // namespace test
+} // namespace tests
} // namespace gep
} // namespace ndn
diff --git a/tests/unit-tests/encrypted-content.t.cpp b/tests/unit-tests/encrypted-content.t.cpp
index f6877fc..413fad9 100644
--- a/tests/unit-tests/encrypted-content.t.cpp
+++ b/tests/unit-tests/encrypted-content.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
- * Copyright (c) 2014-2015, Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
*
* This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
* See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
diff --git a/tests/unit-tests/group-manager-db.t.cpp b/tests/unit-tests/group-manager-db.t.cpp
index 16a2c81..0800af3 100644
--- a/tests/unit-tests/group-manager-db.t.cpp
+++ b/tests/unit-tests/group-manager-db.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
- * Copyright (c) 2014-2015, Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
*
* This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
* See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -16,13 +16,12 @@
* You should have received a copy of the GNU General Public License along with
* ndn-group-encrypt, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
*
- * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
+ * @author Zhiyi Zhang <zhiyi@cs.ucla.edu>
*/
#include "group-manager-db.hpp"
-#include "algo/rsa.hpp"
#include "boost-test.hpp"
-
+#include "algo/rsa.hpp"
#include <boost/filesystem.hpp>
namespace ndn {
@@ -136,9 +135,8 @@
Schedule schedule(scheduleBlock);
// create member
- RandomNumberGenerator rng;
RsaKeyParams params;
- DecryptKey<algo::Rsa> decryptKey = algo::Rsa::generateKey(rng, params);
+ DecryptKey<algo::Rsa> decryptKey = algo::Rsa::generateKey(params);
EncryptKey<algo::Rsa> encryptKey = algo::Rsa::deriveEncryptKey(decryptKey.getKeyBits());
Buffer keyBuf = encryptKey.getKeyBits();
diff --git a/tests/unit-tests/group-manager.t.cpp b/tests/unit-tests/group-manager.t.cpp
index dc64eda..5994d66 100644
--- a/tests/unit-tests/group-manager.t.cpp
+++ b/tests/unit-tests/group-manager.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
- * Copyright (c) 2014-2015, Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
*
* This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
* See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -16,17 +16,16 @@
* You should have received a copy of the GNU General Public License along with
* ndn-group-encrypt, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
*
- * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
+ * @author Zhiyi Zhang <zhiyi@cs.ucla.edu>
*/
#include "group-manager.hpp"
#include "boost-test.hpp"
-#include "algo/rsa.hpp"
-#include "algo/aes.hpp"
#include "encrypted-content.hpp"
-
-#include <boost/filesystem.hpp>
+#include "algo/aes.hpp"
+#include "algo/rsa.hpp"
#include <ndn-cxx/encoding/buffer-stream.hpp>
+#include <boost/filesystem.hpp>
#include <string>
namespace ndn {
@@ -35,33 +34,25 @@
using namespace boost::posix_time;
-const uint8_t SIG_INFO[] = {
- 0x16, 0x1b, // SignatureInfo
- 0x1b, 0x01, // SignatureType
- 0x01,
- 0x1c, 0x16, // KeyLocator
- 0x07, 0x14, // Name
- 0x08, 0x04,
- 0x74, 0x65, 0x73, 0x74,
- 0x08, 0x03,
- 0x6b, 0x65, 0x79,
- 0x08, 0x07,
- 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72
-};
+const uint8_t SIG_INFO[] = {0x16, 0x1b, // SignatureInfo
+ 0x1b, 0x01, // SignatureType
+ 0x01, 0x1c, 0x16, // KeyLocator
+ 0x07, 0x14, // Name
+ 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x03, 0x6b, 0x65,
+ 0x79, 0x08, 0x07, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72};
-const uint8_t SIG_VALUE[] = {
- 0x17, 0x80, // SignatureValue
- 0x2f, 0xd6, 0xf1, 0x6e, 0x80, 0x6f, 0x10, 0xbe, 0xb1, 0x6f, 0x3e, 0x31, 0xec,
- 0xe3, 0xb9, 0xea, 0x83, 0x30, 0x40, 0x03, 0xfc, 0xa0, 0x13, 0xd9, 0xb3, 0xc6,
- 0x25, 0x16, 0x2d, 0xa6, 0x58, 0x41, 0x69, 0x62, 0x56, 0xd8, 0xb3, 0x6a, 0x38,
- 0x76, 0x56, 0xea, 0x61, 0xb2, 0x32, 0x70, 0x1c, 0xb6, 0x4d, 0x10, 0x1d, 0xdc,
- 0x92, 0x8e, 0x52, 0xa5, 0x8a, 0x1d, 0xd9, 0x96, 0x5e, 0xc0, 0x62, 0x0b, 0xcf,
- 0x3a, 0x9d, 0x7f, 0xca, 0xbe, 0xa1, 0x41, 0x71, 0x85, 0x7a, 0x8b, 0x5d, 0xa9,
- 0x64, 0xd6, 0x66, 0xb4, 0xe9, 0x8d, 0x0c, 0x28, 0x43, 0xee, 0xa6, 0x64, 0xe8,
- 0x55, 0xf6, 0x1c, 0x19, 0x0b, 0xef, 0x99, 0x25, 0x1e, 0xdc, 0x78, 0xb3, 0xa7,
- 0xaa, 0x0d, 0x14, 0x58, 0x30, 0xe5, 0x37, 0x6a, 0x6d, 0xdb, 0x56, 0xac, 0xa3,
- 0xfc, 0x90, 0x7a, 0xb8, 0x66, 0x9c, 0x0e, 0xf6, 0xb7, 0x64, 0xd1
-};
+const uint8_t SIG_VALUE[] = {0x17, 0x80, // SignatureValue
+ 0x2f, 0xd6, 0xf1, 0x6e, 0x80, 0x6f, 0x10, 0xbe, 0xb1, 0x6f, 0x3e, 0x31,
+ 0xec, 0xe3, 0xb9, 0xea, 0x83, 0x30, 0x40, 0x03, 0xfc, 0xa0, 0x13, 0xd9,
+ 0xb3, 0xc6, 0x25, 0x16, 0x2d, 0xa6, 0x58, 0x41, 0x69, 0x62, 0x56, 0xd8,
+ 0xb3, 0x6a, 0x38, 0x76, 0x56, 0xea, 0x61, 0xb2, 0x32, 0x70, 0x1c, 0xb6,
+ 0x4d, 0x10, 0x1d, 0xdc, 0x92, 0x8e, 0x52, 0xa5, 0x8a, 0x1d, 0xd9, 0x96,
+ 0x5e, 0xc0, 0x62, 0x0b, 0xcf, 0x3a, 0x9d, 0x7f, 0xca, 0xbe, 0xa1, 0x41,
+ 0x71, 0x85, 0x7a, 0x8b, 0x5d, 0xa9, 0x64, 0xd6, 0x66, 0xb4, 0xe9, 0x8d,
+ 0x0c, 0x28, 0x43, 0xee, 0xa6, 0x64, 0xe8, 0x55, 0xf6, 0x1c, 0x19, 0x0b,
+ 0xef, 0x99, 0x25, 0x1e, 0xdc, 0x78, 0xb3, 0xa7, 0xaa, 0x0d, 0x14, 0x58,
+ 0x30, 0xe5, 0x37, 0x6a, 0x6d, 0xdb, 0x56, 0xac, 0xa3, 0xfc, 0x90, 0x7a,
+ 0xb8, 0x66, 0x9c, 0x0e, 0xf6, 0xb7, 0x64, 0xd1};
class GroupManagerFixture
{
@@ -72,18 +63,15 @@
boost::filesystem::create_directories(tmpPath);
// generate the certificate public key
- RandomNumberGenerator rng;
RsaKeyParams params;
- DecryptKey<algo::Rsa> memberDecryptKey = algo::Rsa::generateKey(rng, params);
+ DecryptKey<algo::Rsa> memberDecryptKey = algo::Rsa::generateKey(params);
decryptKeyBuf = memberDecryptKey.getKeyBits();
EncryptKey<algo::Rsa> memberEncryptKey = algo::Rsa::deriveEncryptKey(decryptKeyBuf);
encryptKeyBuf = memberEncryptKey.getKeyBits();
// generate certificate
cert.setName(Name("/ndn/memberA/KEY/ksk-123/ID-CERT/123"));
- PublicKey contentPubKey(encryptKeyBuf.buf(), encryptKeyBuf.size());
- cert.setPublicKeyInfo(contentPubKey);
- cert.encode();
+ cert.setContent(encryptKeyBuf.data(), encryptKeyBuf.size());
Block sigInfoBlock(SIG_INFO, sizeof(SIG_INFO));
Block sigValueBlock(SIG_VALUE, sizeof(SIG_VALUE));
@@ -101,13 +89,20 @@
Schedule schedule1;
RepetitiveInterval interval11(from_iso_string("20150825T000000"),
from_iso_string("20150827T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::DAY);
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::DAY);
RepetitiveInterval interval12(from_iso_string("20150825T000000"),
from_iso_string("20150827T000000"),
- 6, 8, 1, RepetitiveInterval::RepeatUnit::DAY);
+ 6,
+ 8,
+ 1,
+ RepetitiveInterval::RepeatUnit::DAY);
RepetitiveInterval interval13(from_iso_string("20150827T000000"),
from_iso_string("20150827T000000"),
- 7, 8);
+ 7,
+ 8);
schedule1.addWhiteInterval(interval11);
schedule1.addWhiteInterval(interval12);
schedule1.addBlackInterval(interval13);
@@ -116,13 +111,18 @@
Schedule schedule2;
RepetitiveInterval interval21(from_iso_string("20150825T000000"),
from_iso_string("20150827T000000"),
- 9, 12, 1, RepetitiveInterval::RepeatUnit::DAY);
+ 9,
+ 12,
+ 1,
+ RepetitiveInterval::RepeatUnit::DAY);
RepetitiveInterval interval22(from_iso_string("20150827T000000"),
from_iso_string("20150827T000000"),
- 6, 8);
+ 6,
+ 8);
RepetitiveInterval interval23(from_iso_string("20150827T000000"),
from_iso_string("20150827T000000"),
- 2, 4);
+ 2,
+ 4);
schedule2.addWhiteInterval(interval21);
schedule2.addWhiteInterval(interval22);
schedule2.addBlackInterval(interval23);
@@ -156,7 +156,7 @@
boost::filesystem::path tmpPath;
Buffer decryptKeyBuf;
Buffer encryptKeyBuf;
- IdentityCertificate cert;
+ Certificate cert;
};
BOOST_FIXTURE_TEST_SUITE(TestGroupManager, GroupManagerFixture)
@@ -169,11 +169,15 @@
GroupManager manager(Name("Alice"), Name("data_type"), dbDir, 2048, 1);
Block newCertBlock = cert.wireEncode();
- IdentityCertificate newCert(newCertBlock);
+ Certificate newCert(newCertBlock);
// encrypt D-KEY
- Data data = manager.createDKeyData("20150825T000000", "20150827T000000", Name("/ndn/memberA/KEY"),
- decryptKeyBuf, newCert.getPublicKeyInfo().get());
+ Data data = manager.createDKeyData("20150825T000000",
+ "20150827T000000",
+ Name("/ndn/memberA/KEY"),
+ decryptKeyBuf,
+ Buffer(newCert.getContent().value(),
+ newCert.getContent().value_size()));
// verify encrypted D-KEY
Block dataContent = data.getContent();
@@ -189,9 +193,10 @@
BOOST_CHECK_EQUAL(encryptedNonce.getAlgorithmType(), tlv::AlgorithmRsaOaep);
const Buffer& bufferNonce = encryptedNonce.getPayload();
- algo::EncryptParams decryptParams(tlv::AlgorithmRsaOaep);
- Buffer nonce = algo::Rsa::decrypt(decryptKeyBuf.buf(), decryptKeyBuf.size(),
- bufferNonce.buf(), bufferNonce.size(), decryptParams);
+ Buffer nonce = algo::Rsa::decrypt(decryptKeyBuf.data(),
+ decryptKeyBuf.size(),
+ bufferNonce.data(),
+ bufferNonce.size());
// get D-KEY
contentIterator++;
@@ -201,16 +206,20 @@
BOOST_CHECK_EQUAL(encryptedPayload.getInitialVector().size(), 16);
BOOST_CHECK_EQUAL(encryptedPayload.getAlgorithmType(), tlv::AlgorithmAesCbc);
- decryptParams.setAlgorithmType(tlv::AlgorithmAesCbc);
- decryptParams.setIV(encryptedPayload.getInitialVector().buf(),
+ algo::EncryptParams decryptParams(tlv::AlgorithmAesCbc);
+ decryptParams.setIV(encryptedPayload.getInitialVector().data(),
encryptedPayload.getInitialVector().size());
const Buffer& bufferPayload = encryptedPayload.getPayload();
- Buffer largePayload = algo::Aes::decrypt(nonce.buf(), nonce.size(),
- bufferPayload.buf(), bufferPayload.size(),
+ Buffer largePayload = algo::Aes::decrypt(nonce.data(),
+ nonce.size(),
+ bufferPayload.data(),
+ bufferPayload.size(),
decryptParams);
- BOOST_CHECK_EQUAL_COLLECTIONS(largePayload.begin(), largePayload.end(),
- decryptKeyBuf.begin(), decryptKeyBuf.end());
+ BOOST_CHECK_EQUAL_COLLECTIONS(largePayload.begin(),
+ largePayload.end(),
+ decryptKeyBuf.begin(),
+ decryptKeyBuf.end());
}
BOOST_AUTO_TEST_CASE(CreateEKeyData)
@@ -228,9 +237,10 @@
"/Alice/READ/data_type/E-KEY/20150825T090000/20150825T110000");
Buffer contentBuf(data.getContent().value(), data.getContent().value_size());
- BOOST_CHECK_EQUAL_COLLECTIONS(encryptKeyBuf.begin(), encryptKeyBuf.end(),
- contentBuf.begin(), contentBuf.end());
-
+ BOOST_CHECK_EQUAL_COLLECTIONS(encryptKeyBuf.begin(),
+ encryptKeyBuf.end(),
+ contentBuf.begin(),
+ contentBuf.end());
}
BOOST_AUTO_TEST_CASE(CalculateInterval)
@@ -286,13 +296,14 @@
std::list<Data>::iterator dataIterator = result.begin();
BOOST_CHECK_EQUAL(dataIterator->getName().toUri(),
"/Alice/READ/data_type/E-KEY/20150825T090000/20150825T100000");
- EncryptKey<algo::Rsa> groupEKey(Buffer(dataIterator->getContent().value(),
- dataIterator->getContent().value_size()));
+
+ EncryptKey<algo::Rsa> groupEKey(
+ Buffer(dataIterator->getContent().value(), dataIterator->getContent().value_size()));
// second data and decrypt
dataIterator++;
BOOST_CHECK_EQUAL(dataIterator->getName().toUri(),
- "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberA/ksk-123");
+ "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberA/KEY/ksk-123");
//////////////////////////////////////////////////////////////////////// start decryption
Block dataContent = dataIterator->getContent();
@@ -308,11 +319,12 @@
BOOST_CHECK_EQUAL(encryptedNonce.getInitialVector().size(), 0);
BOOST_CHECK_EQUAL(encryptedNonce.getAlgorithmType(), tlv::AlgorithmRsaOaep);
- algo::EncryptParams decryptParams(tlv::AlgorithmRsaOaep);
const Buffer& bufferNonce = encryptedNonce.getPayload();
- Buffer nonce = algo::Rsa::decrypt(decryptKeyBuf.buf(), decryptKeyBuf.size(),
- bufferNonce.buf(), bufferNonce.size(), decryptParams);
+ Buffer nonce = algo::Rsa::decrypt(decryptKeyBuf.data(),
+ decryptKeyBuf.size(),
+ bufferNonce.data(),
+ bufferNonce.size());
// get buffer payload
contentIterator++;
Block payloadContent(*contentIterator);
@@ -321,34 +333,37 @@
BOOST_CHECK_EQUAL(encryptedPayload.getInitialVector().size(), 16);
BOOST_CHECK_EQUAL(encryptedPayload.getAlgorithmType(), tlv::AlgorithmAesCbc);
- decryptParams.setAlgorithmType(tlv::AlgorithmAesCbc);
- decryptParams.setIV(encryptedPayload.getInitialVector().buf(),
+ algo::EncryptParams decryptParams(tlv::AlgorithmAesCbc);
+ decryptParams.setIV(encryptedPayload.getInitialVector().data(),
encryptedPayload.getInitialVector().size());
const Buffer& bufferPayload = encryptedPayload.getPayload();
- Buffer largePayload = algo::Aes::decrypt(nonce.buf(), nonce.size(),
- bufferPayload.buf(), bufferPayload.size(),
+ Buffer largePayload = algo::Aes::decrypt(nonce.data(),
+ nonce.size(),
+ bufferPayload.data(),
+ bufferPayload.size(),
decryptParams);
// get group D-KEY
- DecryptKey<algo::Rsa> groupDKey(Buffer(largePayload.buf(), largePayload.size()));
+ DecryptKey<algo::Rsa> groupDKey(Buffer(largePayload.data(), largePayload.size()));
/////////////////////////////////////////////////////////////////////// end decryption
// check the D-KEY
EncryptKey<algo::Rsa> derivedGroupEKey = algo::Rsa::deriveEncryptKey(groupDKey.getKeyBits());
- BOOST_CHECK_EQUAL_COLLECTIONS(groupEKey.getKeyBits().begin(), groupEKey.getKeyBits().end(),
+ BOOST_CHECK_EQUAL_COLLECTIONS(groupEKey.getKeyBits().begin(),
+ groupEKey.getKeyBits().end(),
derivedGroupEKey.getKeyBits().begin(),
derivedGroupEKey.getKeyBits().end());
// third data and decrypt
dataIterator++;
BOOST_CHECK_EQUAL(dataIterator->getName().toUri(),
- "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberB/ksk-123");
+ "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberB/KEY/ksk-123");
// second data and decrypt
dataIterator++;
BOOST_CHECK_EQUAL(dataIterator->getName().toUri(),
- "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberC/ksk-123");
+ "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberC/KEY/ksk-123");
// invalid time stamp to get group key
TimeStamp tp2(from_iso_string("20150826T083000"));
@@ -378,13 +393,13 @@
std::list<Data>::iterator dataIterator1 = result1.begin();
BOOST_CHECK_EQUAL(dataIterator1->getName().toUri(),
"/Alice/READ/data_type/E-KEY/20150825T090000/20150825T100000");
- EncryptKey<algo::Rsa> groupEKey1(Buffer(dataIterator1->getContent().value(),
- dataIterator1->getContent().value_size()));
+ EncryptKey<algo::Rsa> groupEKey1(
+ Buffer(dataIterator1->getContent().value(), dataIterator1->getContent().value_size()));
// second data
dataIterator1++;
BOOST_CHECK_EQUAL(dataIterator1->getName().toUri(),
- "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberA/ksk-123");
+ "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberA/KEY/ksk-123");
// add new members to the database
Block dataBlock = cert.wireEncode();
@@ -399,19 +414,21 @@
std::list<Data>::iterator dataIterator2 = result2.begin();
BOOST_CHECK_EQUAL(dataIterator2->getName().toUri(),
"/Alice/READ/data_type/E-KEY/20150825T090000/20150825T100000");
- EncryptKey<algo::Rsa> groupEKey2(Buffer(dataIterator2->getContent().value(),
- dataIterator2->getContent().value_size()));
- BOOST_CHECK_EQUAL_COLLECTIONS(groupEKey1.getKeyBits().begin(), groupEKey1.getKeyBits().end(),
- groupEKey2.getKeyBits().begin(), groupEKey2.getKeyBits().end());
+ EncryptKey<algo::Rsa> groupEKey2(
+ Buffer(dataIterator2->getContent().value(), dataIterator2->getContent().value_size()));
+ BOOST_CHECK_EQUAL_COLLECTIONS(groupEKey1.getKeyBits().begin(),
+ groupEKey1.getKeyBits().end(),
+ groupEKey2.getKeyBits().begin(),
+ groupEKey2.getKeyBits().end());
// second data
dataIterator2++;
BOOST_CHECK_EQUAL(dataIterator2->getName().toUri(),
- "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberA/ksk-123");
+ "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberA/KEY/ksk-123");
}
BOOST_AUTO_TEST_SUITE_END()
-} // namespace test
+} // namespace tests
} // namespace gep
} // namespace ndn
diff --git a/tests/unit-tests/interval.t.cpp b/tests/unit-tests/interval.t.cpp
index e9cf6d9..c50384a 100644
--- a/tests/unit-tests/interval.t.cpp
+++ b/tests/unit-tests/interval.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
- * Copyright (c) 2014-2015, Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
*
* This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
* See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -16,7 +16,7 @@
* You should have received a copy of the GNU General Public License along with
* ndn-group-encrypt, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
*
- * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
+ * @author Zhiyi Zhang <zhiyi@cs.ucla.edu>
*/
#include "interval.hpp"
@@ -33,8 +33,7 @@
BOOST_AUTO_TEST_CASE(Construction)
{
// construct with the right parameters
- Interval interval1(from_iso_string("20150825T120000"),
- from_iso_string("20150825T160000"));
+ Interval interval1(from_iso_string("20150825T120000"), from_iso_string("20150825T160000"));
BOOST_CHECK_EQUAL(to_iso_string(interval1.getStartTime()), "20150825T120000");
BOOST_CHECK_EQUAL(to_iso_string(interval1.getEndTime()), "20150825T160000");
BOOST_CHECK_EQUAL(interval1.isValid(), true);
@@ -51,8 +50,7 @@
BOOST_AUTO_TEST_CASE(CoverTimePoint)
{
- Interval interval(from_iso_string("20150825T120000"),
- from_iso_string("20150825T160000"));
+ Interval interval(from_iso_string("20150825T120000"), from_iso_string("20150825T160000"));
TimeStamp tp1 = from_iso_string("20150825T120000");
TimeStamp tp2 = from_iso_string("20150825T130000");
@@ -67,23 +65,17 @@
BOOST_AUTO_TEST_CASE(IntersectionAndUnion)
{
- Interval interval1(from_iso_string("20150825T030000"),
- from_iso_string("20150825T050000"));
+ Interval interval1(from_iso_string("20150825T030000"), from_iso_string("20150825T050000"));
// no intersection
- Interval interval2(from_iso_string("20150825T050000"),
- from_iso_string("20150825T070000"));
+ Interval interval2(from_iso_string("20150825T050000"), from_iso_string("20150825T070000"));
// no intersection
- Interval interval3(from_iso_string("20150825T060000"),
- from_iso_string("20150825T070000"));
+ Interval interval3(from_iso_string("20150825T060000"), from_iso_string("20150825T070000"));
// there's an intersection
- Interval interval4(from_iso_string("20150825T010000"),
- from_iso_string("20150825T040000"));
+ Interval interval4(from_iso_string("20150825T010000"), from_iso_string("20150825T040000"));
// right in the interval1, there's an intersection
- Interval interval5(from_iso_string("20150825T030000"),
- from_iso_string("20150825T040000"));
+ Interval interval5(from_iso_string("20150825T030000"), from_iso_string("20150825T040000"));
// wrap the interval1, there's an intersection
- Interval interval6(from_iso_string("20150825T010000"),
- from_iso_string("20150825T050000"));
+ Interval interval6(from_iso_string("20150825T010000"), from_iso_string("20150825T050000"));
// empty interval
Interval interval7(true);
diff --git a/tests/unit-tests/producer-db.t.cpp b/tests/unit-tests/producer-db.t.cpp
index bcf09e0..881f40e 100644
--- a/tests/unit-tests/producer-db.t.cpp
+++ b/tests/unit-tests/producer-db.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
- * Copyright (c) 2014-2015, Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
*
* This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
* See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -20,8 +20,8 @@
*/
#include "producer-db.hpp"
-#include "algo/aes.hpp"
#include "boost-test.hpp"
+#include "algo/aes.hpp"
#include <boost/filesystem.hpp>
@@ -59,10 +59,9 @@
ProducerDB db(dbDir);
// create member
- RandomNumberGenerator rng;
AesKeyParams params(128);
- Buffer keyBuf1 = algo::Aes::generateKey(rng, params).getKeyBits();
- Buffer keyBuf2 = algo::Aes::generateKey(rng, params).getKeyBits();
+ Buffer keyBuf1 = algo::Aes::generateKey(params).getKeyBits();
+ Buffer keyBuf2 = algo::Aes::generateKey(params).getKeyBits();
system_clock::TimePoint point1(time::fromIsoString("20150101T100000"));
system_clock::TimePoint point2(time::fromIsoString("20150102T100000"));
@@ -85,16 +84,10 @@
// get content key
Buffer keyResult = db.getContentKey(point1);
- BOOST_CHECK_EQUAL_COLLECTIONS(keyResult.begin(),
- keyResult.end(),
- keyBuf1.begin(),
- keyBuf1.end());
+ BOOST_CHECK_EQUAL_COLLECTIONS(keyResult.begin(), keyResult.end(), keyBuf1.begin(), keyBuf1.end());
keyResult = db.getContentKey(point3);
- BOOST_CHECK_EQUAL_COLLECTIONS(keyResult.begin(),
- keyResult.end(),
- keyBuf2.begin(),
- keyBuf2.end());
+ BOOST_CHECK_EQUAL_COLLECTIONS(keyResult.begin(), keyResult.end(), keyBuf2.begin(), keyBuf2.end());
// throw exception when there is no such timeslot in database
BOOST_CHECK_THROW(db.getContentKey(point4), ProducerDB::Error);
diff --git a/tests/unit-tests/producer.t.cpp b/tests/unit-tests/producer.t.cpp
old mode 100755
new mode 100644
index 37d08d2..87bddaa
--- a/tests/unit-tests/producer.t.cpp
+++ b/tests/unit-tests/producer.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
- * Copyright (c) 2014-2016, Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
*
* This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
* See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -18,16 +18,13 @@
*/
#include "producer.hpp"
-#include "algo/encryptor.hpp"
-#include "algo/rsa.hpp"
-#include "algo/aes.hpp"
#include "encrypted-content.hpp"
#include "unit-test-time-fixture.hpp"
-#include "random-number-generator.hpp"
-
-#include <ndn-cxx/util/dummy-client-face.hpp>
-
+#include "algo/aes.hpp"
+#include "algo/encryptor.hpp"
+#include "algo/rsa.hpp"
#include "boost-test.hpp"
+#include <ndn-cxx/util/dummy-client-face.hpp>
#include <boost/asio.hpp>
#include <boost/filesystem.hpp>
@@ -35,12 +32,10 @@
namespace gep {
namespace tests {
-static const uint8_t DATA_CONTEN[] = {
- 0xcb, 0xe5, 0x6a, 0x80, 0x41, 0x24, 0x58, 0x23,
- 0x84, 0x14, 0x15, 0x61, 0x80, 0xb9, 0x5e, 0xbd,
- 0xce, 0x32, 0xb4, 0xbe, 0xbc, 0x91, 0x31, 0xd6,
- 0x19, 0x00, 0x80, 0x8b, 0xfa, 0x00, 0x05, 0x9c
-};
+static const uint8_t DATA_CONTEN[] = {0xcb, 0xe5, 0x6a, 0x80, 0x41, 0x24, 0x58, 0x23,
+ 0x84, 0x14, 0x15, 0x61, 0x80, 0xb9, 0x5e, 0xbd,
+ 0xce, 0x32, 0xb4, 0xbe, 0xbc, 0x91, 0x31, 0xd6,
+ 0x19, 0x00, 0x80, 0x8b, 0xfa, 0x00, 0x05, 0x9c};
class ProducerFixture : public UnitTestTimeFixture
{
@@ -65,16 +60,15 @@
void
createEncryptionKey(Name eKeyName, const Name& timeMarker)
{
- RandomNumberGenerator rng;
RsaKeyParams params;
eKeyName.append(timeMarker);
- Buffer dKeyBuf = algo::Rsa::generateKey(rng, params).getKeyBits();
+ Buffer dKeyBuf = algo::Rsa::generateKey(params).getKeyBits();
Buffer eKeyBuf = algo::Rsa::deriveEncryptKey(dKeyBuf).getKeyBits();
decryptionKeys[eKeyName] = dKeyBuf;
shared_ptr<Data> keyData = make_shared<Data>(eKeyName);
- keyData->setContent(eKeyBuf.buf(), eKeyBuf.size());
+ keyData->setContent(eKeyBuf.data(), eKeyBuf.size());
keyChain.sign(*keyData);
encryptionKeys[eKeyName] = keyData;
}
@@ -156,16 +150,17 @@
}
face2.setInterestFilter(prefix,
- [&] (const InterestFilter&, const Interest& i) {
- Name interestName = i.getName();
- interestName.append(timeMarker);
- BOOST_REQUIRE_EQUAL(encryptionKeys.find(interestName) !=
- encryptionKeys.end(), true);
- face2.put(*(encryptionKeys[interestName]));
- return;
- },
- RegisterPrefixSuccessCallback(),
- [] (const Name&, const std::string& e) { });
+ [&] (const InterestFilter&, const Interest& i) {
+ Name interestName = i.getName();
+ interestName.append(timeMarker);
+ BOOST_REQUIRE_EQUAL(encryptionKeys.find(interestName) !=
+ encryptionKeys.end(),
+ true);
+ face2.put(*(encryptionKeys[interestName]));
+ return;
+ },
+ RegisterPrefixSuccessCallback(),
+ [] (const Name&, const std::string& e) {});
do {
advanceClocks(time::milliseconds(10), 20);
@@ -177,50 +172,46 @@
ProducerDB testDb(dbDir);
Buffer contentKey;
- auto checkEncryptionKeys =
- [&](const std::vector<Data>& result,
- const time::system_clock::TimePoint& testTime,
- const name::Component& roundedTime) {
- BOOST_CHECK_EQUAL(testDb.hasContentKey(testTime), true);
- contentKey = testDb.getContentKey(testTime);
+ auto checkEncryptionKeys = [&] (const std::vector<Data>& result,
+ const time::system_clock::TimePoint& testTime,
+ const name::Component& roundedTime) {
+ BOOST_CHECK_EQUAL(testDb.hasContentKey(testTime), true);
+ contentKey = testDb.getContentKey(testTime);
- algo::EncryptParams params(tlv::AlgorithmRsaOaep);
- std::vector<Data>::const_iterator it;
- for (it = result.begin(); it != result.end(); ++it) {
- Name keyName = it->getName();
- BOOST_CHECK_EQUAL(keyName.getSubName(0,6), cKeyName);
- BOOST_CHECK_EQUAL(keyName.get(6), roundedTime);
- BOOST_CHECK_EQUAL(keyName.get(7), NAME_COMPONENT_FOR);
- BOOST_CHECK_EQUAL(decryptionKeys.find(keyName.getSubName(8)) !=
- decryptionKeys.end(), true);
- Name testName = it->getName().getSubName(-8);
- Buffer decryptionKey;
+ std::vector<Data>::const_iterator it;
+ for (it = result.begin(); it != result.end(); ++it) {
+ Name keyName = it->getName();
+ BOOST_CHECK_EQUAL(keyName.getSubName(0, 6), cKeyName);
+ BOOST_CHECK_EQUAL(keyName.get(6), roundedTime);
+ BOOST_CHECK_EQUAL(keyName.get(7), NAME_COMPONENT_FOR);
+ BOOST_CHECK_EQUAL(decryptionKeys.find(keyName.getSubName(8)) != decryptionKeys.end(), true);
+ Name testName = it->getName().getSubName(-8);
+ Buffer decryptionKey;
- decryptionKey = decryptionKeys.at(keyName.getSubName(8));
- BOOST_CHECK_EQUAL(decryptionKey.size() != 0, true);
- Block encryptedKeyBlock = it->getContent();
- encryptedKeyBlock.parse();
+ decryptionKey = decryptionKeys.at(keyName.getSubName(8));
+ BOOST_CHECK_EQUAL(decryptionKey.size() != 0, true);
+ Block encryptedKeyBlock = it->getContent();
+ encryptedKeyBlock.parse();
- EncryptedContent content(*(encryptedKeyBlock.elements_begin()));
- const Buffer& encryptedKey = content.getPayload();
- Buffer retrievedKey = algo::Rsa::decrypt(decryptionKey.buf(),
- decryptionKey.size(),
- encryptedKey.buf(),
- encryptedKey.size(),
- params);
+ EncryptedContent content(*(encryptedKeyBlock.elements_begin()));
+ const Buffer& encryptedKey = content.getPayload();
+ Buffer retrievedKey = algo::Rsa::decrypt(decryptionKey.data(),
+ decryptionKey.size(),
+ encryptedKey.data(),
+ encryptedKey.size());
- BOOST_CHECK_EQUAL_COLLECTIONS(contentKey.begin(),
- contentKey.end(),
- retrievedKey.begin(),
- retrievedKey.end());
- }
- BOOST_CHECK_EQUAL(result.size(), 3);
- };
+ BOOST_CHECK_EQUAL_COLLECTIONS(contentKey.begin(),
+ contentKey.end(),
+ retrievedKey.begin(),
+ retrievedKey.end());
+ }
+ BOOST_CHECK_EQUAL(result.size(), 3);
+ };
// Initial test to confirm that keys are created for this timeslot
Name contentKeyName1 =
- producer.createContentKey(testTime1,
- std::bind(checkEncryptionKeys, _1, testTime1, testTimeRounded1));
+ producer.createContentKey(testTime1,
+ std::bind(checkEncryptionKeys, _1, testTime1, testTimeRounded1));
do {
advanceClocks(time::milliseconds(10), 20);
@@ -228,8 +219,8 @@
// Verify that we do not repeat the search for e-keys, don't advance clock
Name contentKeyName2 =
- producer.createContentKey(testTime2,
- std::bind(checkEncryptionKeys, _1, testTime2, testTimeRounded2));
+ producer.createContentKey(testTime2,
+ std::bind(checkEncryptionKeys, _1, testTime2, testTimeRounded2));
// Confirm content key names are correct
BOOST_CHECK_EQUAL(contentKeyName1.getPrefix(-1), cKeyName);
@@ -242,10 +233,10 @@
producer.produce(testData, testTime2, DATA_CONTEN, sizeof(DATA_CONTEN));
Name producedName = testData.getName();
- BOOST_CHECK_EQUAL(producedName.getSubName(0,5), cKeyName.getPrefix(-1));
+ BOOST_CHECK_EQUAL(producedName.getSubName(0, 5), cKeyName.getPrefix(-1));
BOOST_CHECK_EQUAL(producedName.get(5), testTimeComponent2);
BOOST_CHECK_EQUAL(producedName.get(6), NAME_COMPONENT_FOR);
- BOOST_CHECK_EQUAL(producedName.getSubName(7,6), cKeyName);
+ BOOST_CHECK_EQUAL(producedName.getSubName(7, 6), cKeyName);
BOOST_CHECK_EQUAL(producedName.get(13), testTimeRounded2);
Block dataBlock = testData.getContent();
@@ -256,9 +247,9 @@
const Buffer& iv = dataContent.getInitialVector();
algo::EncryptParams params(tlv::AlgorithmAesCbc, 16);
- params.setIV(iv.buf(), iv.size());
- Buffer decryptTest = algo::Aes::decrypt(contentKey.buf(), contentKey.size(),
- encData.buf(), encData.size(), params);
+ params.setIV(iv.data(), iv.size());
+ Buffer decryptTest =
+ algo::Aes::decrypt(contentKey.data(), contentKey.size(), encData.data(), encData.size(), params);
BOOST_CHECK_EQUAL_COLLECTIONS(decryptTest.begin(),
decryptTest.end(),
DATA_CONTEN,
@@ -295,31 +286,31 @@
size_t requestCount = 0;
face2.setInterestFilter(prefix,
- [&] (const InterestFilter&, const Interest& i) {
- BOOST_REQUIRE_EQUAL(i.getName(), expectedInterest);
- Name interestName = i.getName();
- switch(requestCount) {
- case 0:
- interestName.append(timeMarkerFirstHop);
- break;
+ [&] (const InterestFilter&, const Interest& i) {
+ BOOST_REQUIRE_EQUAL(i.getName(), expectedInterest);
+ Name interestName = i.getName();
+ switch (requestCount) {
+ case 0:
+ interestName.append(timeMarkerFirstHop);
+ break;
- case 1:
- interestName.append(timeMarkerSecondHop);
- break;
+ case 1:
+ interestName.append(timeMarkerSecondHop);
+ break;
- case 2:
- interestName.append(timeMarkerThirdHop);
- break;
+ case 2:
+ interestName.append(timeMarkerThirdHop);
+ break;
- default:
- break;
- }
- face2.put(*(encryptionKeys[interestName]));
- requestCount++;
- return;
- },
- RegisterPrefixSuccessCallback(),
- [] (const Name&, const std::string& e) { });
+ default:
+ break;
+ }
+ face2.put(*(encryptionKeys[interestName]));
+ requestCount++;
+ return;
+ },
+ RegisterPrefixSuccessCallback(),
+ [] (const Name&, const std::string& e) {});
do {
advanceClocks(time::milliseconds(10), 20);
@@ -328,19 +319,17 @@
// Verify that if a key is found, but not within the right timeslot, the search
// is refined until a valid timeslot is found.
Producer producer(prefix, suffix, face1, dbDir);
- producer.createContentKey(testTime,
- [&](const std::vector<Data>& result){
- BOOST_CHECK_EQUAL(requestCount, 3);
- BOOST_CHECK_EQUAL(result.size(), 1);
+ producer.createContentKey(testTime, [&] (const std::vector<Data>& result) {
+ BOOST_CHECK_EQUAL(requestCount, 3);
+ BOOST_CHECK_EQUAL(result.size(), 1);
- Data keyData = result[0];
- Name keyName = keyData.getName();
- BOOST_CHECK_EQUAL(keyName.getSubName(0,4), cKeyName);
- BOOST_CHECK_EQUAL(keyName.get(4), timeMarkerThirdHop[0]);
- BOOST_CHECK_EQUAL(keyName.get(5), NAME_COMPONENT_FOR);
- BOOST_CHECK_EQUAL(keyName.getSubName(6),
- expectedInterest.append(timeMarkerThirdHop));
- });
+ Data keyData = result[0];
+ Name keyName = keyData.getName();
+ BOOST_CHECK_EQUAL(keyName.getSubName(0, 4), cKeyName);
+ BOOST_CHECK_EQUAL(keyName.get(4), timeMarkerThirdHop[0]);
+ BOOST_CHECK_EQUAL(keyName.get(5), NAME_COMPONENT_FOR);
+ BOOST_CHECK_EQUAL(keyName.getSubName(6), expectedInterest.append(timeMarkerThirdHop));
+ });
do {
advanceClocks(time::milliseconds(10), 20);
} while (passPacket());
@@ -362,13 +351,13 @@
size_t timeoutCount = 0;
face2.setInterestFilter(prefix,
- [&] (const InterestFilter&, const Interest& i) {
- BOOST_CHECK_EQUAL(i.getName(), expectedInterest);
- timeoutCount++;
- return;
- },
- RegisterPrefixSuccessCallback(),
- [] (const Name&, const std::string& e) { });
+ [&] (const InterestFilter&, const Interest& i) {
+ BOOST_CHECK_EQUAL(i.getName(), expectedInterest);
+ timeoutCount++;
+ return;
+ },
+ RegisterPrefixSuccessCallback(),
+ [] (const Name&, const std::string& e) {});
do {
advanceClocks(time::milliseconds(10), 20);
@@ -377,11 +366,10 @@
// Verify that if no response is received, the producer appropriately times out.
// The result vector should not contain elements that have timed out.
Producer producer(prefix, suffix, face1, dbDir);
- producer.createContentKey(testTime,
- [&](const std::vector<Data>& result){
- BOOST_CHECK_EQUAL(timeoutCount, 4);
- BOOST_CHECK_EQUAL(result.size(), 0);
- });
+ producer.createContentKey(testTime, [&] (const std::vector<Data>& result) {
+ BOOST_CHECK_EQUAL(timeoutCount, 4);
+ BOOST_CHECK_EQUAL(result.size(), 0);
+ });
do {
advanceClocks(time::milliseconds(10), 500);
@@ -404,14 +392,14 @@
size_t timeoutCount = 0;
face2.setInterestFilter(prefix,
- [&] (const InterestFilter&, const Interest& i) {
- BOOST_CHECK_EQUAL(i.getName(), expectedInterest);
- BOOST_CHECK(i.getLink().getDelegations().size() == 3);
- timeoutCount++;
- return;
- },
- RegisterPrefixSuccessCallback(),
- [] (const Name&, const std::string& e) { });
+ [&] (const InterestFilter&, const Interest& i) {
+ BOOST_CHECK_EQUAL(i.getName(), expectedInterest);
+ BOOST_CHECK(i.getForwardingHint().size() == 3);
+ timeoutCount++;
+ return;
+ },
+ RegisterPrefixSuccessCallback(),
+ [] (const Name&, const std::string& e) {});
do {
advanceClocks(time::milliseconds(10), 20);
@@ -422,11 +410,10 @@
Link link("test", {{10, "/test1"}, {20, "/test2"}, {100, "/test3"}});
keyChain.sign(link);
Producer producer(prefix, suffix, face1, dbDir, 3, link);
- producer.createContentKey(testTime,
- [&](const std::vector<Data>& result){
- BOOST_CHECK_EQUAL(timeoutCount, 4);
- BOOST_CHECK_EQUAL(result.size(), 0);
- });
+ producer.createContentKey(testTime, [&] (const std::vector<Data>& result) {
+ BOOST_CHECK_EQUAL(timeoutCount, 4);
+ BOOST_CHECK_EQUAL(result.size(), 0);
+ });
do {
advanceClocks(time::milliseconds(10), 800);
diff --git a/tests/unit-tests/repetitive-interval.t.cpp b/tests/unit-tests/repetitive-interval.t.cpp
index 51abdf8..d5baa21 100644
--- a/tests/unit-tests/repetitive-interval.t.cpp
+++ b/tests/unit-tests/repetitive-interval.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
- * Copyright (c) 2014-2015, Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
*
* This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
* See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -16,7 +16,7 @@
* You should have received a copy of the GNU General Public License along with
* ndn-group-encrypt, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
*
- * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
+ * @author Zhiyi Zhang <zhiyi@cs.ucla.edu>
*/
#include "repetitive-interval.hpp"
@@ -34,7 +34,8 @@
{
RepetitiveInterval repetitiveInterval1(from_iso_string("20150825T000000"),
from_iso_string("20150825T000000"),
- 5, 10);
+ 5,
+ 10);
BOOST_CHECK_EQUAL(to_iso_string(repetitiveInterval1.getStartDate()), "20150825T000000");
BOOST_CHECK_EQUAL(to_iso_string(repetitiveInterval1.getEndDate()), "20150825T000000");
@@ -43,21 +44,30 @@
RepetitiveInterval repetitiveInterval2(from_iso_string("20150825T000000"),
from_iso_string("20150827T000000"),
- 5, 10, 1, RepetitiveInterval::RepeatUnit::DAY);
+ 5,
+ 10,
+ 1,
+ RepetitiveInterval::RepeatUnit::DAY);
BOOST_CHECK_EQUAL(repetitiveInterval2.getNRepeats(), 1);
BOOST_CHECK(repetitiveInterval2.getRepeatUnit() == RepetitiveInterval::RepeatUnit::DAY);
RepetitiveInterval repetitiveInterval3(from_iso_string("20150825T000000"),
from_iso_string("20151227T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::MONTH);
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::MONTH);
BOOST_CHECK_EQUAL(repetitiveInterval3.getNRepeats(), 2);
BOOST_CHECK(repetitiveInterval3.getRepeatUnit() == RepetitiveInterval::RepeatUnit::MONTH);
RepetitiveInterval repetitiveInterval4(from_iso_string("20150825T000000"),
from_iso_string("20301227T000000"),
- 5, 10, 5, RepetitiveInterval::RepeatUnit::YEAR);
+ 5,
+ 10,
+ 5,
+ RepetitiveInterval::RepeatUnit::YEAR);
BOOST_CHECK_EQUAL(repetitiveInterval4.getNRepeats(), 5);
BOOST_CHECK(repetitiveInterval4.getRepeatUnit() == RepetitiveInterval::RepeatUnit::YEAR);
@@ -74,20 +84,23 @@
RepetitiveInterval repetitiveInterval1(from_iso_string("20150825T000000"),
from_iso_string("20150925T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::DAY);
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::DAY);
Interval resultInterval;
bool isPositive = false;
TimeStamp tp1 = from_iso_string("20150825T050000");
- std::tie(isPositive,resultInterval) = repetitiveInterval1.getInterval(tp1);
+ std::tie(isPositive, resultInterval) = repetitiveInterval1.getInterval(tp1);
BOOST_CHECK_EQUAL(isPositive, true);
BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getStartTime()), "20150825T050000");
BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getEndTime()), "20150825T100000");
TimeStamp tp2 = from_iso_string("20150902T060000");
- std::tie(isPositive,resultInterval) = repetitiveInterval1.getInterval(tp2);
+ std::tie(isPositive, resultInterval) = repetitiveInterval1.getInterval(tp2);
BOOST_CHECK_EQUAL(isPositive, true);
BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getStartTime()), "20150902T050000");
BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getEndTime()), "20150902T100000");
@@ -100,21 +113,24 @@
RepetitiveInterval repetitiveInterval2(from_iso_string("20150825T000000"),
from_iso_string("20160825T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::MONTH);
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::MONTH);
TimeStamp tp4 = from_iso_string("20150825T050000");
- std::tie(isPositive,resultInterval) = repetitiveInterval2.getInterval(tp4);
+ std::tie(isPositive, resultInterval) = repetitiveInterval2.getInterval(tp4);
BOOST_CHECK_EQUAL(isPositive, true);
BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getStartTime()), "20150825T050000");
BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getEndTime()), "20150825T100000");
TimeStamp tp5 = from_iso_string("20151025T060000");
- std::tie(isPositive,resultInterval) = repetitiveInterval2.getInterval(tp5);
+ std::tie(isPositive, resultInterval) = repetitiveInterval2.getInterval(tp5);
BOOST_CHECK_EQUAL(isPositive, true);
BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getStartTime()), "20151025T050000");
- BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getEndTime()), "20151025T100000");
+ BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getEndTime()), "20151025T100000");
TimeStamp tp6 = from_iso_string("20151226T050000");
@@ -128,18 +144,21 @@
RepetitiveInterval repetitiveInterval3(from_iso_string("20150825T000000"),
from_iso_string("20300825T000000"),
- 5, 10, 3, RepetitiveInterval::RepeatUnit::YEAR);
+ 5,
+ 10,
+ 3,
+ RepetitiveInterval::RepeatUnit::YEAR);
TimeStamp tp8 = from_iso_string("20150825T050000");
- std::tie(isPositive,resultInterval) = repetitiveInterval3.getInterval(tp8);
+ std::tie(isPositive, resultInterval) = repetitiveInterval3.getInterval(tp8);
BOOST_CHECK_EQUAL(isPositive, true);
BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getStartTime()), "20150825T050000");
BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getEndTime()), "20150825T100000");
TimeStamp tp9 = from_iso_string("20180825T060000");
- std::tie(isPositive,resultInterval) = repetitiveInterval3.getInterval(tp9);
+ std::tie(isPositive, resultInterval) = repetitiveInterval3.getInterval(tp9);
BOOST_CHECK_EQUAL(isPositive, true);
BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getStartTime()), "20180825T050000");
BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getEndTime()), "20180825T100000");
@@ -154,27 +173,21 @@
BOOST_CHECK(std::get<0>(repetitiveInterval3.getInterval(tp12)) == false);
}
-const uint8_t REPETITIVE_INTERVAL[] = {
- 0x8c, 0x2e, // RepetitiveInterval
- 0x86, 0x0f,
- 0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x32, 0x35, 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
- 0x87, 0x0f,
- 0x32, 0x30, 0x31, 0x35, 0x30, 0x39, 0x32, 0x31, 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
- 0x88, 0x01,
- 0x05,
- 0x89, 0x01,
- 0x0a,
- 0x8a, 0x01,
- 0x04,
- 0x8b, 0x01,
- 0x01
-};
+const uint8_t REPETITIVE_INTERVAL[] = {0x8c, 0x2e, // RepetitiveInterval
+ 0x86, 0x0f, 0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x32, 0x35,
+ 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x87, 0x0f, 0x32,
+ 0x30, 0x31, 0x35, 0x30, 0x39, 0x32, 0x31, 0x54, 0x30, 0x30,
+ 0x30, 0x30, 0x30, 0x30, 0x88, 0x01, 0x05, 0x89, 0x01, 0x0a,
+ 0x8a, 0x01, 0x04, 0x8b, 0x01, 0x01};
BOOST_AUTO_TEST_CASE(EncodeAndDecode)
{
RepetitiveInterval repetitiveInterval1(from_iso_string("20150825T000000"),
from_iso_string("20150921T000000"),
- 5, 10, 4, RepetitiveInterval::RepeatUnit::DAY);
+ 5,
+ 10,
+ 4,
+ RepetitiveInterval::RepeatUnit::DAY);
Block block1 = repetitiveInterval1.wireEncode();
Block block2(REPETITIVE_INTERVAL, sizeof(REPETITIVE_INTERVAL));
@@ -203,45 +216,75 @@
static bool
check(const RepetitiveInterval& small, const RepetitiveInterval& big)
{
- return (small < big && !(big < small));
+ return (small < big && !(big < small));
}
BOOST_AUTO_TEST_CASE(Comparison)
{
BOOST_CHECK(check(RepetitiveInterval(from_iso_string("20150825T000000"),
from_iso_string("20150828T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::DAY),
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::DAY),
RepetitiveInterval(from_iso_string("20150826T000000"),
from_iso_string("20150828T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::DAY)));
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::DAY)));
BOOST_CHECK(check(RepetitiveInterval(from_iso_string("20150825T000000"),
from_iso_string("20150828T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::DAY),
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::DAY),
RepetitiveInterval(from_iso_string("20150825T000000"),
from_iso_string("20150828T000000"),
- 6, 10, 2, RepetitiveInterval::RepeatUnit::DAY)));
+ 6,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::DAY)));
BOOST_CHECK(check(RepetitiveInterval(from_iso_string("20150825T000000"),
from_iso_string("20150828T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::DAY),
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::DAY),
RepetitiveInterval(from_iso_string("20150825T000000"),
from_iso_string("20150828T000000"),
- 5, 11, 2, RepetitiveInterval::RepeatUnit::DAY)));
+ 5,
+ 11,
+ 2,
+ RepetitiveInterval::RepeatUnit::DAY)));
BOOST_CHECK(check(RepetitiveInterval(from_iso_string("20150825T000000"),
from_iso_string("20150828T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::DAY),
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::DAY),
RepetitiveInterval(from_iso_string("20150825T000000"),
from_iso_string("20150828T000000"),
- 5, 10, 3, RepetitiveInterval::RepeatUnit::DAY)));
+ 5,
+ 10,
+ 3,
+ RepetitiveInterval::RepeatUnit::DAY)));
BOOST_CHECK(check(RepetitiveInterval(from_iso_string("20150825T000000"),
from_iso_string("20150828T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::DAY),
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::DAY),
RepetitiveInterval(from_iso_string("20150825T000000"),
from_iso_string("20150828T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::MONTH)));
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::MONTH)));
}
BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/unit-tests/schedule.t.cpp b/tests/unit-tests/schedule.t.cpp
index 1d86787..64c0024 100644
--- a/tests/unit-tests/schedule.t.cpp
+++ b/tests/unit-tests/schedule.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
- * Copyright (c) 2014-2015, Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
*
* This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
* See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -16,7 +16,7 @@
* You should have received a copy of the GNU General Public License along with
* ndn-group-encrypt, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
*
- * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
+ * @author Zhiyi Zhang <zhiyi@cs.ucla.edu>
*/
#include "schedule.hpp"
@@ -35,16 +35,24 @@
Schedule schedule;
RepetitiveInterval interval1(from_iso_string("20150825T000000"),
from_iso_string("20150827T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::DAY);
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::DAY);
RepetitiveInterval interval2(from_iso_string("20150825T000000"),
from_iso_string("20150827T000000"),
- 6, 8, 1, RepetitiveInterval::RepeatUnit::DAY);
+ 6,
+ 8,
+ 1,
+ RepetitiveInterval::RepeatUnit::DAY);
RepetitiveInterval interval3(from_iso_string("20150827T000000"),
from_iso_string("20150827T000000"),
- 7, 8);
+ 7,
+ 8);
RepetitiveInterval interval4(from_iso_string("20150825T000000"),
from_iso_string("20150825T000000"),
- 4, 7);
+ 4,
+ 7);
schedule.addWhiteInterval(interval1);
schedule.addWhiteInterval(interval2);
@@ -104,13 +112,20 @@
Schedule schedule;
RepetitiveInterval interval1(from_iso_string("20150825T000000"),
from_iso_string("20150827T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::DAY);
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::DAY);
RepetitiveInterval interval2(from_iso_string("20150825T000000"),
from_iso_string("20150827T000000"),
- 6, 8, 1, RepetitiveInterval::RepeatUnit::DAY);
+ 6,
+ 8,
+ 1,
+ RepetitiveInterval::RepeatUnit::DAY);
RepetitiveInterval interval3(from_iso_string("20150825T000000"),
from_iso_string("20150825T000000"),
- 4, 7);
+ 4,
+ 7);
schedule.addWhiteInterval(interval1);
schedule.addWhiteInterval(interval2);
@@ -162,10 +177,16 @@
Schedule schedule;
RepetitiveInterval interval1(from_iso_string("20150825T000000"),
from_iso_string("20150827T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::DAY);
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::DAY);
RepetitiveInterval interval2(from_iso_string("20150825T000000"),
from_iso_string("20150827T000000"),
- 6, 8, 1, RepetitiveInterval::RepeatUnit::DAY);
+ 6,
+ 8,
+ 1,
+ RepetitiveInterval::RepeatUnit::DAY);
schedule.addBlackInterval(interval1);
schedule.addBlackInterval(interval2);
@@ -259,16 +280,24 @@
RepetitiveInterval interval1(from_iso_string("20150825T000000"),
from_iso_string("20150828T000000"),
- 5, 10, 2, RepetitiveInterval::RepeatUnit::DAY);
+ 5,
+ 10,
+ 2,
+ RepetitiveInterval::RepeatUnit::DAY);
RepetitiveInterval interval2(from_iso_string("20150825T000000"),
from_iso_string("20150828T000000"),
- 6, 8, 1, RepetitiveInterval::RepeatUnit::DAY);
+ 6,
+ 8,
+ 1,
+ RepetitiveInterval::RepeatUnit::DAY);
RepetitiveInterval interval3(from_iso_string("20150827T000000"),
from_iso_string("20150827T000000"),
- 7, 8);
+ 7,
+ 8);
RepetitiveInterval interval4(from_iso_string("20150825T000000"),
from_iso_string("20150825T000000"),
- 4, 7);
+ 4,
+ 7);
schedule.addWhiteInterval(interval1);
schedule.addWhiteInterval(interval2);