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()); }