void
Pib::initializeMgmtCert()
{
shared_ptr<IdentityCertificate> mgmtCert = m_db.getMgmtCertificate();
if (mgmtCert == nullptr ||
!m_tpm->doesKeyExistInTpm(mgmtCert->getPublicKeyName(), KEY_CLASS_PRIVATE)) {
// If mgmt cert is set, or corresponding private key of the current mgmt cert is missing,
// generate new mgmt cert
// key name: /localhost/pib/[UserName]/mgmt/dsk-...
Name mgmtKeyName = PIB_PREFIX;
mgmtKeyName.append(m_owner).append(MGMT_LABEL);
std::ostringstream oss;
oss << "dsk-" << time::toUnixTimestamp(time::system_clock::now()).count();
mgmtKeyName.append(oss.str());
// self-sign pib root key
m_mgmtCert = prepareCertificate(mgmtKeyName, RsaKeyParams(),
time::system_clock::now(),
time::system_clock::now() + time::days(7300));
// update management certificate in database
m_db.updateMgmtCertificate(*m_mgmtCert);
}
else
m_mgmtCert = mgmtCert;
}
virtual uint64_t
expressInterest
(const Interest& interest, const OnData& onData,
const OnTimeout& onTimeout, const OnNetworkNack& onNetworkNack,
WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
{
if (expectedInterest_ != interest.getName())
throw runtime_error("TestFace::expressInterest: Not the expectedInterest_");
bool gotInterestName = false;
Name interestName;
for (size_t i = 0; i < 3; ++i) {
interestName = Name(interest.getName());
if (i == 0)
interestName.append(timeMarkerFirstHop_);
else if (i == 1)
interestName.append(timeMarkerSecondHop_);
else if (i == 2)
interestName.append(timeMarkerThirdHop_);
// matchesName will check the Exclude.
if (interest.matchesName(interestName)) {
gotInterestName = true;
++(*requestCount_);
break;
}
}
if (gotInterestName)
onData(ptr_lib::make_shared<Interest>(interest),
parent_->encryptionKeys[interestName]);
return 0;
}
shared_ptr<Data>
Response::toData()
{
Name name;
name.append(m_zone)
.append(m_queryType)
.append(m_rrLabel)
.append(m_rrType);
if (m_version.empty()) {
name.appendVersion();
m_version = name.get(-1);
}
else {
name.append(m_version);
}
shared_ptr<Data> data = make_shared<Data>(name);
if (m_contentType != NDNS_BLOB && m_contentType != NDNS_KEY) {
data->setContent(this->wireEncode());
}
else {
data->setContent(m_appContent);
}
data->setFreshnessPeriod(m_freshnessPeriod);
data->setContentType(m_contentType);
return data;
}
TEST_F(TestProducer, ProducerWithLink)
{
Name prefix("/prefix");
Name suffix("/suffix");
Name expectedInterest = prefix;
expectedInterest.append(Encryptor::getNAME_COMPONENT_READ());
expectedInterest.append(suffix);
expectedInterest.append(Encryptor::getNAME_COMPONENT_E_KEY());
MillisecondsSince1970 testTime = fromIsoString("20150101T100001");
int timeoutCount = 0;
// Prepare a TestFace to instantly answer calls to expressInterest.
class TestFace : public Face {
public:
TestFace(const Name& expectedInterest, int* timeoutCount)
: Face("localhost"),
expectedInterest_(expectedInterest),
timeoutCount_(timeoutCount)
{}
virtual uint64_t
expressInterest
(const Interest& interest, const OnData& onData,
const OnTimeout& onTimeout, const OnNetworkNack& onNetworkNack,
WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
{
if (expectedInterest_ != interest.getName())
throw runtime_error("TestFace::expressInterest: Not the expectedInterest_");
if (interest.getLink()->getDelegations().size() != 3)
throw runtime_error
("TestFace::expressInterest: The Interest link does not the expected number of delegates");
++(*timeoutCount_);
onTimeout(ptr_lib::make_shared<Interest>(interest));
return 0;
}
private:
Name expectedInterest_;
int* timeoutCount_;
};
TestFace face(expectedInterest, &timeoutCount);
// Verify that if no response is received, the producer appropriately times
// out. The result vector should not contain elements that have timed out.
Link link;
link.addDelegation(10, Name("/test1"));
link.addDelegation(20, Name("/test2"));
link.addDelegation(100, Name("/test3"));
keyChain->sign(link);
ptr_lib::shared_ptr<ProducerDb> testDb(new Sqlite3ProducerDb(databaseFilePath));
Producer producer(prefix, suffix, &face, keyChain.get(), testDb, 3, link);
producer.createContentKey
(testTime,
bind(&TestProducer::keyTimeoutOnEncryptedKeys, this, _1, &timeoutCount));
}
Name
NameComponents::streamPrefix(MediaStreamParams::MediaStreamType type, std::string basePrefix)
{
Name n = Name(basePrefix);
n.append(ndnrtcSuffix());
return ((type == MediaStreamParams::MediaStreamType::MediaStreamTypeAudio) ?
n.append(NameComponentAudio) : n.append(NameComponentVideo));
}
Name
RegexTopMatcher::expand(const std::string& expandStr)
{
Name result;
shared_ptr<RegexBackrefManager> backrefManager =
(m_isSecondaryUsed ? m_secondaryBackrefManager : m_primaryBackrefManager);
size_t backrefNo = backrefManager->size();
std::string expand;
if (!expandStr.empty())
expand = expandStr;
else
expand = m_expand;
size_t offset = 0;
while (offset < expand.size())
{
std::string item = getItemFromExpand(expand, offset);
if (item[0] == '<')
{
result.append(item.substr(1, item.size() - 2));
}
if (item[0] == '\\')
{
size_t index = boost::lexical_cast<size_t>(item.substr(1, item.size() - 1));
if (0 == index) {
std::vector<name::Component>::iterator it = m_matchResult.begin();
std::vector<name::Component>::iterator end = m_matchResult.end();
for (; it != end; it++)
result.append(*it);
}
else if (index <= backrefNo)
{
std::vector<name::Component>::const_iterator it =
backrefManager->getBackref(index - 1)->getMatchResult().begin();
std::vector<name::Component>::const_iterator end =
backrefManager->getBackref(index - 1)->getMatchResult().end();
for (; it != end; it++)
result.append(*it);
}
else
BOOST_THROW_EXCEPTION(RegexMatcher::Error("Exceed the range of back reference"));
}
}
return result;
}
std::vector<boost::shared_ptr<const Interest>>
Pipeliner::getBatch(Name n, SampleClass cls, bool noParity) const
{
std::vector<boost::shared_ptr<const Interest>> interests;
unsigned int nData = sampleEstimator_->getSegmentNumberEstimation(cls, SegmentClass::Data);
for (int segNo = 0; segNo < nData; ++segNo)
{
Name iname(n);
iname.appendSegment(segNo);
boost::shared_ptr<Interest> i = boost::make_shared<Interest>(iname, interestLifetime_);
i->setMustBeFresh(false);
interests.push_back(i);
}
if (!noParity)
{
n.append(NameComponents::NameComponentParity);
unsigned int nParity = sampleEstimator_->getSegmentNumberEstimation(cls, SegmentClass::Parity);
for (int segNo = 0; segNo < nParity; ++segNo)
{
Name iname(n);
iname.appendSegment(segNo);
boost::shared_ptr<Interest> i = boost::make_shared<Interest>(iname, interestLifetime_);
i->setMustBeFresh(false);
interests.push_back(i);
}
}
return interests;
}
void
generatePacketsAndPopulateFib(size_t nPackets,
size_t nFibEntries,
size_t fibPrefixLength,
size_t interestNameLength,
size_t dataNameLength)
{
BOOST_ASSERT(1 <= fibPrefixLength);
BOOST_ASSERT(fibPrefixLength <= interestNameLength);
BOOST_ASSERT(interestNameLength <= dataNameLength);
for (size_t i = 0; i < nPackets; i++) {
Name prefix(to_string(i / nFibEntries));
extendName(prefix, fibPrefixLength);
m_fib.insert(prefix);
Name interestName = prefix;
if (nPackets > nFibEntries) {
interestName.append(to_string(i));
}
extendName(interestName, interestNameLength);
interests.push_back(make_shared<Interest>(interestName));
Name dataName = interestName;
extendName(dataName, dataNameLength);
data.push_back(make_shared<Data>(dataName));
}
}
Name
InMemoryPibImpl::getKeyName(const Name& identity, const name::Component& keyId) const
{
Name keyName = identity;
keyName.append(keyId);
return keyName;
}
static void
extendName(Name& name, size_t length)
{
BOOST_ASSERT(length >= name.size());
for (size_t i = name.size(); i < length; i++) {
name.append("dup");
}
}
Name
ApolloStoryProducer :: convertStringToName(string str)
{
Name name = Name();
for (unsigned int i=0; i<str.size(); i++)
name.append(string(1,str[i]));
return name;
}
Name
Name::getSubName(size_t iStartComponent) const
{
Name result;
for (size_t i = iStartComponent; i < size(); ++i)
result.append(at(i));
return result;
}
ApolloStoryProducer :: ApolloStoryProducer (string dir)
{
ifstream rFile(dir+string("/task_info.json"));
if (!rFile)
{
cout << "task_info.json does not exist." << endl;
candidate = false;
return;
}
string line;
getline (rFile, line);
Reader reader;
Value metaData;
reader.parse(line, metaData);
Value query = metaData["query"];
Value analysisType = query["analysis_types"];
for (unsigned int i=0; i<analysisType.size(); i++)
{
if (analysisType[i].asString() == string("Diversity"))
{
candidate = true;
break;
}
}
Name nRoot = Name("Apollo");
nRoot.append(Name(query["dataset"].asString()));
this->storyName = query["dataset"].asString();
this->producer = new InfoMaxProducer(nRoot);
vector<Name> nameList;
vector<Data> dataList;
string subdir = string(dir+string("/analysis/Diversity"));
if (readDirintoNameAndData(subdir, &nameList, &dataList))
{
for(unsigned int i=0; i<nameList.size(); i++) {
producer->add(nameList[i], dataList[i]);
}
}
if (!candidate)
{
cout << "This folder doesn't have Diversity folder." << endl;
candidate = false;
return;
}
}
Name
ControlCommand::getRequestName(const Name& commandPrefix,
const ControlParameters& parameters) const
{
this->validateRequest(parameters);
Name name = commandPrefix;
name.append(m_module).append(m_verb);
name.append(parameters.wireEncode());
return name;
}
Name
IdentityManager::getKeyNameFromCertificatePrefix(const Name & certificatePrefix)
{
Name result;
string keyString("KEY");
int i = 0;
for(; i < certificatePrefix.size(); i++) {
if (certificatePrefix.get(i).toEscapedString() == keyString)
break;
}
if (i >= certificatePrefix.size())
throw SecurityException("Identity Certificate Prefix does not have a KEY component");
result.append(certificatePrefix.getSubName(0, i));
result.append(certificatePrefix.getSubName(i + 1, certificatePrefix.size()-i-1));
return result;
}
Name
Name::getSubName(size_t iStartComponent, size_t nComponents) const
{
Name result;
size_t iEnd = iStartComponent + nComponents;
for (size_t i = iStartComponent; i < iEnd && i < size(); ++i)
result.append(at(i));
return result;
}
/** \brief make a Command Interest from parameters
*/
Interest
makeCommandInterest(const ControlParameters& parameters,
const Sign& sign) const
{
this->validateRequest(parameters);
Name name = m_prefix;
name.append(parameters.wireEncode());
Interest commandInterest(name);
sign(commandInterest);
return commandInterest;
}
Name
Name::getSuccessor() const
{
if (size() == 0) {
// Return "/%00".
Name result;
result.append((const uint8_t*)"\0", 1);
return result;
}
else
return getPrefix(-1).append(get(-1).getSuccessor());
}
Name
Name::getSuccessor() const
{
if (empty()) {
static uint8_t firstValue[] = { 0 };
Name firstName;
firstName.append(firstValue, 1);
return firstName;
}
return getPrefix(-1).append(get(-1).getSuccessor());
}
void
keySearchOnEncryptedKeys
(const vector<ptr_lib::shared_ptr<Data> >& result, int* requestCount,
Name cKeyName, Name timeMarkerThirdHop, Name expectedInterest)
{
ASSERT_EQ(3, *requestCount);
ASSERT_EQ(1, result.size());
const Data& keyData = *result[0];
const Name& keyName = keyData.getName();
ASSERT_EQ(cKeyName, keyName.getSubName(0, 4));
ASSERT_EQ(timeMarkerThirdHop.get(0), keyName.get(4));
ASSERT_EQ(Encryptor::getNAME_COMPONENT_FOR(), keyName.get(5));
ASSERT_EQ(expectedInterest.append(timeMarkerThirdHop),
keyName.getSubName(6));
}
void
createEncryptionKey(Name eKeyName, const Name& timeMarker)
{
RsaKeyParams params;
eKeyName = Name(eKeyName);
eKeyName.append(timeMarker);
Blob dKeyBlob = RsaAlgorithm::generateKey(params).getKeyBits();
Blob eKeyBlob = RsaAlgorithm::deriveEncryptKey(dKeyBlob).getKeyBits();
decryptionKeys[eKeyName] = dKeyBlob;
ptr_lib::shared_ptr<Data> keyData(new Data(eKeyName));
keyData->setContent(eKeyBlob);
keyChain->sign(*keyData, certificateName);
encryptionKeys[eKeyName] = keyData;
}
ptr_lib::shared_ptr<IdentityCertificate>
IdentityManager::createIdentityCertificate(const Name& certificatePrefix,
const PublicKey& publicKey,
const Name& signerCertificateName,
const MillisecondsSince1970& notBefore,
const MillisecondsSince1970& notAfter)
{
ptr_lib::shared_ptr<IdentityCertificate> certificate(new IdentityCertificate());
Name keyName = getKeyNameFromCertificatePrefix(certificatePrefix);
Name certificateName = certificatePrefix;
MillisecondsSince1970 ti = ::ndn_getNowMilliseconds();
// Get the number of seconds.
ostringstream oss;
oss << floor(ti / 1000.0);
certificateName.append("ID-CERT").append(oss.str());
certificate->setName(certificateName);
certificate->setNotBefore(notBefore);
certificate->setNotAfter(notAfter);
certificate->setPublicKeyInfo(publicKey);
certificate->addSubjectDescription(CertificateSubjectDescription("2.5.4.41", keyName.toUri()));
certificate->encode();
ptr_lib::shared_ptr<Sha256WithRsaSignature> sha256Sig(new Sha256WithRsaSignature());
KeyLocator keyLocator;
keyLocator.setType(ndn_KeyLocatorType_KEYNAME);
keyLocator.setKeyName(signerCertificateName);
sha256Sig->setKeyLocator(keyLocator);
sha256Sig->getPublisherPublicKeyDigest().setPublisherPublicKeyDigest(publicKey.getDigest());
certificate->setSignature(*sha256Sig);
SignedBlob unsignedData = certificate->wireEncode();
ptr_lib::shared_ptr<IdentityCertificate> signerCertificate = getCertificate(signerCertificateName);
Name signerkeyName = signerCertificate->getPublicKeyName();
Blob sigBits = privateKeyStorage_->sign(unsignedData, signerkeyName);
sha256Sig->setSignature(sigBits);
return certificate;
}
shared_ptr<IdentityCertificate>
Pib::prepareCertificate(const Name& keyName, const KeyParams& keyParams,
const time::system_clock::TimePoint& notBefore,
const time::system_clock::TimePoint& notAfter,
const Name& signerName)
{
// Generate mgmt key
m_tpm->generateKeyPairInTpm(keyName, keyParams);
shared_ptr<PublicKey> publicKey = m_tpm->getPublicKeyFromTpm(keyName);
// Set mgmt cert
auto certificate = make_shared<IdentityCertificate>();
Name certName = keyName.getPrefix(-1);
certName.append("KEY").append(keyName.get(-1)).append("ID-CERT").appendVersion();
certificate->setName(certName);
certificate->setNotBefore(notBefore);
certificate->setNotAfter(notAfter);
certificate->setPublicKeyInfo(*publicKey);
CertificateSubjectDescription subjectName(oid::ATTRIBUTE_NAME, keyName.getPrefix(-1).toUri());
certificate->addSubjectDescription(subjectName);
certificate->encode();
Name signingKeyName;
KeyLocator keyLocator;
if (signerName == EMPTY_SIGNER_NAME) {
// Self-sign mgmt cert
keyLocator = KeyLocator(certificate->getName().getPrefix(-1));
signingKeyName = keyName;
}
else {
keyLocator = KeyLocator(signerName.getPrefix(-1));
signingKeyName = IdentityCertificate::certificateNameToPublicKeyName(signerName);
}
SignatureSha256WithRsa signature(keyLocator);
certificate->setSignature(signature);
EncodingBuffer encoder;
certificate->wireEncode(encoder, true);
Block signatureValue = m_tpm->signInTpm(encoder.buf(), encoder.size(),
signingKeyName, DIGEST_ALGORITHM_SHA256);
certificate->wireEncode(encoder, signatureValue);
return certificate;
}
void
Socket::fetchData(const Name& sessionName, const SeqNo& seqNo,
const ndn::OnDataValidated& dataCallback,
int nRetries)
{
Name interestName;
interestName.append(sessionName).appendNumber(seqNo);
Interest interest(interestName);
interest.setMustBeFresh(true);
ndn::OnDataValidationFailed failureCallback =
bind(&Socket::onDataValidationFailed, this, _1, _2);
m_face.expressInterest(interest,
bind(&Socket::onData, this, _1, _2, dataCallback, failureCallback),
bind(&Socket::onDataTimeout, this, _1, nRetries,
dataCallback, failureCallback));
}
void
Socket::fetchData(const Name& sessionName, const SeqNo& seqNo,
const ndn::OnDataValidated& dataCallback,
const ndn::OnDataValidationFailed& failureCallback,
const ndn::OnTimeout& onTimeout,
int nRetries)
{
_LOG_DEBUG(">> Socket::fetchData");
Name interestName;
interestName.append(sessionName).appendNumber(seqNo);
Interest interest(interestName);
interest.setMustBeFresh(true);
m_face.expressInterest(interest,
bind(&Socket::onData, this, _1, _2, dataCallback, failureCallback),
onTimeout);
_LOG_DEBUG("<< Socket::fetchData");
}
void
SimpleDataRetrieval::sendInterest()
{
Name prefix;
m_context->getContextOption(PREFIX, prefix);
Name suffix;
m_context->getContextOption(SUFFIX, suffix);
if (!suffix.empty())
{
prefix.append(suffix);
}
Interest interest(prefix);
int interestLifetime = 0;
m_context->getContextOption(INTEREST_LIFETIME, interestLifetime);
interest.setInterestLifetime(time::milliseconds(interestLifetime));
SelectorHelper::applySelectors(interest, m_context);
ConsumerInterestCallback onInterestToLeaveContext = EMPTY_CALLBACK;
m_context->getContextOption(INTEREST_LEAVE_CNTX, onInterestToLeaveContext);
if (onInterestToLeaveContext != EMPTY_CALLBACK)
{
onInterestToLeaveContext(*dynamic_cast<Consumer*>(m_context), interest);
}
m_face->expressInterest(interest,
bind(&SimpleDataRetrieval::onData, this, _1, _2),
bind(&SimpleDataRetrieval::onTimeout, this, _1));
bool isAsync = false;
m_context->getContextOption(ASYNC_MODE, isAsync);
if (!isAsync)
{
m_face->processEvents();
}
}
void
Pib::registerPrefix()
{
// register pib prefix
Name pibPrefix = PIB_PREFIX;
pibPrefix.append(m_owner);
m_pibPrefixId =
m_face.registerPrefix(pibPrefix,
[] (const Name& name) {},
[] (const Name& name, const string& msg) {
throw Error("cannot register pib prefix");
});
// set interest filter for management certificate
m_pibMgmtFilterId =
m_face.setInterestFilter(Name(pibPrefix).append(MGMT_LABEL),
[this] (const InterestFilter&, const Interest& interest) {
if (m_mgmtCert != nullptr) {
m_face.put(*m_mgmtCert);
}
});
// set interest filter for get command
m_pibGetFilterId = registerProcessor(Name(pibPrefix).append(GetParam::VERB), m_getProcessor);
// set interest filter for default command
m_pibDefaultFilterId = registerProcessor(Name(pibPrefix).append(DefaultParam::VERB),
m_defaultProcessor);
// set interest filter for list command
m_pibListFilterId = registerProcessor(Name(pibPrefix).append(ListParam::VERB),
m_listProcessor);
// set interest filter for update command
m_pibUpdateFilterId = registerSignedCommandProcessor(Name(pibPrefix).append(UpdateParam::VERB),
m_updateProcessor);
// set interest filter for delete command
m_pibDeleteFilterId = registerSignedCommandProcessor(Name(pibPrefix).append(DeleteParam::VERB),
m_deleteProcessor);
}
Name
NamespaceInfo::getSuffix(int filter) const
{
using namespace suffix_filter;
Name suffix;
if (filter)
{
if (filter&(Library^Stream))
suffix.append(Name(NameComponents::NameComponentApp)).appendVersion(apiVersion_);
if (filter&(Stream^Thread))
{
suffix.append((streamType_ == MediaStreamParams::MediaStreamType::MediaStreamTypeAudio ?
NameComponents::NameComponentAudio : NameComponents::NameComponentVideo)).append(streamName_);
if (threadName_ != "")
suffix.appendTimestamp(streamTimestamp_);
}
if (filter&(Thread^Sample) && threadName_ != "")
suffix.append(threadName_);
if (isMeta_)
{
if ((filter&(Thread^Sample) && threadName_ != "") ||
filter&(Stream^Thread))
suffix.append(NameComponents::NameComponentMeta);
}
if (filter&(Thread^Sample) && threadName_ != "" &&
streamType_ == MediaStreamParams::MediaStreamType::MediaStreamTypeVideo &&
!isMeta_)
suffix.append((class_ == SampleClass::Delta ? NameComponents::NameComponentDelta : NameComponents::NameComponentKey));
if (filter&(Sample^Segment))
{
if (isMeta_)
suffix.appendVersion(metaVersion_);
else
suffix.appendSequenceNumber(sampleNo_);
}
if (filter&(Segment) && hasSegNo_)
{
if (isParity_)
suffix.append(NameComponents::NameComponentParity);
suffix.appendSegment(segNo_);
}
}
return suffix;
}
void
Socket::publishData(const Block& content, const ndn::time::milliseconds& freshness,
const Name& prefix)
{
shared_ptr<Data> data = make_shared<Data>();
data->setContent(content);
data->setFreshnessPeriod(freshness);
SeqNo newSeq = m_logic.getSeqNo(prefix) + 1;
Name dataName;
dataName.append(m_logic.getSessionName(prefix)).appendNumber(newSeq);
data->setName(dataName);
if (m_signingId.empty())
m_keyChain.sign(*data);
else
m_keyChain.signByIdentity(*data, m_signingId);
m_ims.insert(*data);
m_logic.updateSeqNo(newSeq, prefix);
}
TEST_F(TestConsumerDb, OperateAesDecryptionKey)
{
// Test construction.
Sqlite3ConsumerDb database(databaseFilePath);
// Generate key blobs.
Blob encryptionKeyBlob;
Blob decryptionKeyBlob;
generateAesKeys(encryptionKeyBlob, decryptionKeyBlob);
Name keyName
("/alice/health/samples/activity/steps/C-KEY/20150928080000/20150928090000!");
keyName.append(Name("FOR/alice/health/read/activity!"));
database.addKey(keyName, decryptionKeyBlob);
Blob resultBlob = database.getKey(keyName);
ASSERT_TRUE(decryptionKeyBlob.equals(resultBlob));
database.deleteKey(keyName);
resultBlob = database.getKey(keyName);
ASSERT_EQ(0, resultBlob.size());
}
