def test_expired_certificate(self):
# Copy the default certificate.
expiredCertificate = Data(
self._fixture._subIdentity.getDefaultKey().getDefaultCertificate())
info = SigningInfo(self._fixture._identity)
# Validity period from 2 hours ago do 1 hour ago.
now = Common.getNowMilliseconds()
info.setValidityPeriod(
ValidityPeriod(now - 2 * 3600 * 1000, now - 3600 * 1000.0))
self._fixture._keyChain.sign(expiredCertificate, info)
try:
CertificateV2(expiredCertificate).wireEncode()
except Exception as ex:
self.fail("Unexpected exception: " + str(ex))
originalProcessInterest = self._fixture._face._processInterest
def processInterest(interest, onData, onTimeout, onNetworkNack):
if interest.getName().isPrefixOf(expiredCertificate.getName()):
onData(interest, expiredCertificate)
else:
originalProcessInterest.processInterest(
interest, onData, onTimeout, onNetworkNack)
self._fixture._face._processInterest = processInterest
data = Data(Name("/Security/V2/ValidatorFixture/Sub1/Sub2/Data"))
self._fixture._keyChain.sign(data,
SigningInfo(self._fixture._subIdentity))
self.validateExpectFailure(data, "Signed by an expired certificate")
self.assertEqual(1, len(self._fixture._face._sentInterests))
def __init__(self, identityName):
super(DecryptorFixture, self).__init__()
# Include the code here from the NAC unit-tests class
# DecryptorStaticDataEnvironment instead of making it a base class.
self._storage = InMemoryStorageRetaining()
for array in EncryptStaticData.managerPackets:
data = Data()
data.wireDecode(array)
self._storage.insert(data)
for array in EncryptStaticData.encryptorPackets:
data = Data()
data.wireDecode(array)
self._storage.insert(data)
# Import the "/first/user" identity.
self._keyChain.importSafeBag(SafeBag(EncryptStaticData.userIdentity),
Blob("password").buf())
self.addIdentity(Name("/not/authorized"))
self._face = InMemoryStorageFace(self._storage)
self._validator = ValidatorNull()
self._decryptor = DecryptorV2(
self._keyChain.getPib().getIdentity(identityName).getDefaultKey(),
self._validator, self._keyChain, self._face)
def test_malformed_certificate(self):
# Copy the default certificate.
malformedCertificate = Data(
self._fixture._subIdentity.getDefaultKey().getDefaultCertificate())
malformedCertificate.getMetaInfo().setType(ContentType.BLOB)
self._fixture._keyChain.sign(malformedCertificate,
SigningInfo(self._fixture._identity))
# It has the wrong content type and a missing ValidityPeriod.
try:
CertificateV2(malformedCertificate).wireEncode()
self.fail("Did not throw the expected exception")
except CertificateV2.Error:
pass
else:
self.fail("Did not throw the expected exception")
originalProcessInterest = self._fixture._face._processInterest
def processInterest(interest, onData, onTimeout, onNetworkNack):
if interest.getName().isPrefixOf(malformedCertificate.getName()):
onData(interest, malformedCertificate)
else:
originalProcessInterest.processInterest(
interest, onData, onTimeout, onNetworkNack)
self._fixture._face._processInterest = processInterest
data = Data(Name("/Security/V2/ValidatorFixture/Sub1/Sub2/Data"))
self._fixture._keyChain.sign(data,
SigningInfo(self._fixture._subIdentity))
self.validateExpectFailure(data, "Signed by a malformed certificate")
self.assertEqual(1, len(self._fixture._face._sentInterests))
def main():
data = Data()
data.wireDecode(TlvData)
# Use a hard-wired secret for testing. In a real application the signer
# ensures that the verifier knows the shared key and its keyName.
key = Blob(
bytearray([
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
]))
if KeyChain.verifyDataWithHmacWithSha256(data, key):
dump("Hard-coded data signature verification: VERIFIED")
else:
dump("Hard-coded data signature verification: FAILED")
freshData = Data(Name("/ndn/abc"))
signature = HmacWithSha256Signature()
signature.getKeyLocator().setType(KeyLocatorType.KEYNAME)
signature.getKeyLocator().setKeyName(Name("key1"))
freshData.setSignature(signature)
freshData.setContent("SUCCESS!")
dump("Signing fresh data packet", freshData.getName().toUri())
KeyChain.signWithHmacWithSha256(freshData, key)
if KeyChain.verifyDataWithHmacWithSha256(freshData, key):
dump("Freshly-signed data signature verification: VERIFIED")
else:
dump("Freshly-signed data signature verification: FAILED")
def test_self_verification(self):
policyManager = SelfVerifyPolicyManager(self.identityStorage)
keyChain = KeyChain(self.identityManager, policyManager)
identityName = Name('TestValidator/RsaSignatureVerification')
keyChain.createIdentityAndCertificate(identityName)
data = Data(Name('/TestData/1'))
keyChain.signByIdentity(data, identityName)
vr = doVerify(policyManager, data)
self.assertFalse(vr.hasFurtherSteps,
"SelfVerifyPolicyManager returned a ValidationRequest")
self.assertEqual(vr.failureCount, 0,
"Verification of identity-signed data failed")
self.assertEqual(vr.successCount, 1,
"Verification success called {} times instead of 1".format(
vr.successCount))
data2 = Data(Name('/TestData/2'))
vr = doVerify(policyManager,
data2)
self.assertFalse(vr.hasFurtherSteps,
"SelfVerifyPolicyManager returned a ValidationRequest")
self.assertEqual(vr.successCount, 0,
"Verification of unsigned data succeeded")
self.assertEqual(vr.failureCount, 1,
"Verification failure callback called {} times instead of 1".format(
vr.failureCount))
def test_hyperrelation(self):
policyManager = ConfigPolicyManager("policy_config/hyperrelation_ruleset.conf")
dataName = Name('/SecurityTestSecRule/Basic/Longer/Data2')
data1 = Data(dataName)
data2 = Data(dataName)
matchedRule = policyManager._findMatchingRule(dataName, 'data')
self.keyChain.sign(data1, self.defaultCertName)
self.keyChain.sign(data2, self.shortCertName)
signatureName1 = data1.getSignature().getKeyLocator().getKeyName()
signatureName2 = data2.getSignature().getKeyLocator().getKeyName()
self.assertTrue(policyManager._checkSignatureMatch(signatureName1,
dataName, matchedRule))
self.assertFalse(policyManager._checkSignatureMatch(signatureName2,
dataName, matchedRule))
dataName = Name('/SecurityTestSecRule/Basic/Other/Data1')
data1 = Data(dataName)
data2 = Data(dataName)
matchedRule = policyManager._findMatchingRule(dataName, 'data')
self.keyChain.sign(data1, self.defaultCertName)
self.keyChain.sign(data2, self.shortCertName)
signatureName1 = data1.getSignature().getKeyLocator().getKeyName()
signatureName2 = data2.getSignature().getKeyLocator().getKeyName()
self.assertFalse(policyManager._checkSignatureMatch(signatureName1,
dataName, matchedRule))
self.assertTrue(policyManager._checkSignatureMatch(signatureName2,
dataName, matchedRule))
def onGetAllData(self, producedDataName, outerDataName):
maxLng = -1000
minLng = 1000
maxLat = -1000
minLat = 1000
for item in self._tasks[producedDataName]["dataset"]:
dataObject = json.loads(str(item))
if dataObject["lat"] > maxLat:
maxLat = dataObject["lat"]
if dataObject["lat"] < minLat:
minLat = dataObject["lat"]
if dataObject["lng"] > maxLng:
maxLng = dataObject["lng"]
if dataObject["lng"] < minLng:
minLng = dataObject["lng"]
if not self._encryptResult:
innerData = Data(Name(str(producedDataName)))
innerData.setContent(json.dumps({"minLat": minLat, "maxLat": maxLat, "minLng": minLng, "maxLng": maxLng}))
#self.keyChain.sign(innerData)
outerData = Data(Name(str(outerDataName)))
outerData.setContent(innerData.wireEncode())
#self.keyChain.sign(outerData)
self.memoryContentCache.add(outerData)
self.initiateContentStoreInsertion("/ndn/edu/ucla/remap/ndnfit/repo", outerData)
print "Calculation completed, put data to repo"
else:
print "Encrypt result is not implemented"
def test_encode_decode(self):
data = Data()
data.wireDecode(codedData2)
data.setContent(data.getContent())
encoding = data.wireEncode()
reDecodedData = Data()
reDecodedData.wireDecode(encoding)
self.assertEqual(dumpData(reDecodedData), initialDump2, 'Re-decoded data does not match original dump')
def setManager(self, manager):
# Set up the first schedule.
schedule1 = Schedule()
interval11 = RepetitiveInterval(
Schedule.fromIsoString("20150825T000000"),
Schedule.fromIsoString("20150827T000000"), 5, 10, 2,
RepetitiveInterval.RepeatUnit.DAY)
interval12 = RepetitiveInterval(
Schedule.fromIsoString("20150825T000000"),
Schedule.fromIsoString("20150827T000000"), 6, 8, 1,
RepetitiveInterval.RepeatUnit.DAY)
interval13 = RepetitiveInterval(
Schedule.fromIsoString("20150827T000000"),
Schedule.fromIsoString("20150827T000000"), 7, 8)
schedule1.addWhiteInterval(interval11)
schedule1.addWhiteInterval(interval12)
schedule1.addBlackInterval(interval13)
# Set up the second schedule.
schedule2 = Schedule()
interval21 = RepetitiveInterval(
Schedule.fromIsoString("20150825T000000"),
Schedule.fromIsoString("20150827T000000"), 9, 12, 1,
RepetitiveInterval.RepeatUnit.DAY)
interval22 = RepetitiveInterval(
Schedule.fromIsoString("20150827T000000"),
Schedule.fromIsoString("20150827T000000"), 6, 8)
interval23 = RepetitiveInterval(
Schedule.fromIsoString("20150827T000000"),
Schedule.fromIsoString("20150827T000000"), 2, 4)
schedule2.addWhiteInterval(interval21)
schedule2.addWhiteInterval(interval22)
schedule2.addBlackInterval(interval23)
# Add them to the group manager database.
manager.addSchedule("schedule1", schedule1)
manager.addSchedule("schedule2", schedule2)
# Make some adaptions to certificate.
dataBlob = self.certificate.wireEncode()
memberA = Data()
memberA.wireDecode(dataBlob, TlvWireFormat.get())
memberA.setName(Name("/ndn/memberA/KEY/ksk-123/ID-CERT/123"))
memberB = Data()
memberB.wireDecode(dataBlob, TlvWireFormat.get())
memberB.setName(Name("/ndn/memberB/KEY/ksk-123/ID-CERT/123"))
memberC = Data()
memberC.wireDecode(dataBlob, TlvWireFormat.get())
memberC.setName(Name("/ndn/memberC/KEY/ksk-123/ID-CERT/123"))
# Add the members to the database.
manager.addMember("schedule1", memberA)
manager.addMember("schedule1", memberB)
manager.addMember("schedule2", memberC)
def __init__(self, contentPrefix, userKeyName, keyChain, certificateName):
self._enabled = True
self._responseCount = 0
# Imitate test_consumer from the PyNDN integration tests.
contentName0 = Name(contentPrefix).append("Content").appendSegment(0)
contentName1 = Name(contentPrefix).append("Content").appendSegment(1)
cKeyName = Name("/Prefix/SAMPLE/Content/C-KEY/1")
dKeyName = Name("/Prefix/READ/D-KEY/1/2")
# Generate the E-KEY and D-KEY.
params = RsaKeyParams()
fixtureDKeyBlob = RsaAlgorithm.generateKey(params).getKeyBits()
fixtureEKeyBlob = RsaAlgorithm.deriveEncryptKey(
fixtureDKeyBlob).getKeyBits()
# The user key.
fixtureUserEKeyBlob = Blob(FIXTURE_USER_E_KEY)
# Load the C-KEY.
fixtureCKeyBlob = Blob(AES_KEY, False)
# Imitate createEncryptedContent. Make two segments.
encryptParams = EncryptParams(EncryptAlgorithmType.AesCbc)
encryptParams.setInitialVector(Blob(INITIAL_VECTOR, False))
self._contentData0 = Data(contentName0)
Encryptor.encryptData(self._contentData0, Blob(DATA0_CONTENT, False),
cKeyName, fixtureCKeyBlob, encryptParams)
self._contentData0.getMetaInfo().setFinalBlockId(
Name().appendSegment(1)[0])
keyChain.sign(self._contentData0, certificateName)
self._contentData1 = Data(contentName1)
Encryptor.encryptData(self._contentData1, Blob(DATA1_CONTENT, False),
cKeyName, fixtureCKeyBlob, encryptParams)
self._contentData1.getMetaInfo().setFinalBlockId(
Name().appendSegment(1)[0])
keyChain.sign(self._contentData1, certificateName)
# Imitate createEncryptedCKey.
self._cKeyData = Data(cKeyName)
encryptParams = EncryptParams(EncryptAlgorithmType.RsaOaep)
Encryptor.encryptData(self._cKeyData, fixtureCKeyBlob, dKeyName,
fixtureEKeyBlob, encryptParams)
keyChain.sign(self._cKeyData, certificateName)
# Imitate createEncryptedDKey.
self._dKeyData = Data(dKeyName)
encryptParams = EncryptParams(EncryptAlgorithmType.RsaOaep)
Encryptor.encryptData(self._dKeyData, fixtureDKeyBlob, userKeyName,
fixtureUserEKeyBlob, encryptParams)
keyChain.sign(self._dKeyData, certificateName)
def onReadPir(self, interest):
# try to find a matching pir
pirInfo = next((pair[1] for pair in self._pirs.items()
if Name(pair[1]["device"]).match(interest.getName())),
None)
if pirInfo is None:
data = Data(interest.getName())
data.setContent("MALFORMED COMMAND")
data.getMetaInfo().setFreshnessPeriod(
1000) # 1 second, in milliseconds
return data
lastTime = pirInfo["lastTime"]
lastValue = pirInfo["lastVal"]
# If interest exclude doesn't match timestamp from last tx'ed data
# then resend data
if not interest.getExclude().matches(Name.Component(str(lastTime))):
print "Received interest without exclude ACK:", interest.getExclude(
).toUri()
print "\tprevious timestamp:", str(lastTime)
data = Data(Name(interest.getName()).append(str(lastTime)))
payload = {"pir": lastValue}
content = json.dumps(payload)
data.setContent(content)
data.getMetaInfo().setFreshnessPeriod(
1000) # 1 second, in milliseconds
print "Sent data:", data.getName().toUri(), "with content", content
return data
# otherwise, make new data
currentValue = pirInfo["device"].read()
timestamp = int(time.time() * 1000) # in milliseconds
pirInfo["lastTime"] = timestamp
pirInfo["lastVal"] = currentValue
data = Data(Name(interest.getName()).append(str(timestamp)))
payload = {"pir": currentValue}
content = json.dumps(payload)
data.setContent(content)
data.getMetaInfo().setFreshnessPeriod(
1000) # 1 second, in milliseconds
print "Sent data:", data.getName().toUri(), "with content", content
return data
def onInterest(self, prefix, interest, face, interestFilterId, filter):
"""
Append the next segment number to the prefix and send a new data packet.
If the last packet is sent, then call self._onFinished().
"""
maxSegment = 2
if self._segment >= maxSegment:
# We have already called self._onFinished().
return
dump("Got interest", interest.toUri())
# Make and sign a Data packet for the segment.
self._segment += 1
data = Data(Name(prefix).appendSegment(self._segment))
content = "Segment number " + repr(self._segment)
data.content = content
self._keyChain.sign(data, self._certificateName)
face.putData(data)
dump("Sent data packet", data.name.toUri())
if self._segment >= maxSegment:
# We sent the final data packet.
self._onFinished()
def onInterest(self, prefix, interest, face, interestFilterId, filter):
self._callbackCount = 0
# log.debug("prefix: '{}'".format(prefix))
# log.debug("interest: '{}'".format(interest))
# log.debug("face: '{}'".format(face))
# log.debug("interestFilterId: '{}'".format(interestFilterId))
# log.debug("filter: '{}'".format(filter))
data = Data()
#
# log.debug("----")
# for n in self.db:
# log.debug(n)
# log.debug(self.db[n].value)
# log.debug("----")
#
n = str(prefix).split("/")[-1]
log.debug("{} value '{}' ({})".format(prefix, self.db[n].value, self.freshnessPeriod))
data.setContent(str(self.db[n].value)) # TODO: Why does this need to be converted to string?
data.setName(prefix)
meta = MetaInfo()
meta.setFreshnessPeriod(self.freshnessPeriod)
data.setMetaInfo(meta)
self.keyChain.sign(data)
face.putData(data)
def test_full_name(self):
data = Data()
data.wireDecode(codedData)
# Check the full name format.
self.assertEqual(data.getFullName().size(), data.getName().size() + 1)
self.assertEqual(data.getName(), data.getFullName().getPrefix(-1))
self.assertEqual(data.getFullName().get(-1).getValue().size(), 32)
# Check the independent digest calculation.
sha256 = hashes.Hash(hashes.SHA256(), backend=default_backend())
sha256.update(Blob(codedData).toBytes())
newDigest = Blob(bytearray(sha256.finalize()), False)
self.assertTrue(newDigest.equals(
data.getFullName().get(-1).getValue()))
# Check the expected URI.
self.assertEqual(
data.getFullName().toUri(), "/ndn/abc/sha256digest=" +
"96556d685dcb1af04be4ae57f0e7223457d4055ea9b3d07c0d337bef4a8b3ee9")
# Changing the Data packet should change the full name.
saveFullName = Name(data.getFullName())
data.setContent(Blob())
self.assertNotEqual(data.getFullName().get(-1), saveFullName.get(-1))
def onInterest(self, prefix, interest, transport, registeredPrefixId):
print "received interest"
initInterest = Name(interest.getName())
print "interest name:", initInterest.toUri()
#d = Data(interest.getName().getPrefix(prefix.size()+1))
#self.excludeDevice = interest.getName().get(prefix.size())
#initInterest = interest.getName()
d = Data(interest.getName().append(self.deviceComponent))
try:
print "start to set data's content"
currentString = ','.join(currentList)
d.setContent("songList of " + self.device + ":" + currentString +
"\n")
self.face.registerPrefix(self.changePrefix, self.onInterest,
self.onRegisterFailed)
except KeyboardInterrupt:
print "key interrupt"
sys.exit(1)
except Exception as e:
print e
d.setContent("Bad command\n")
finally:
self.keychain.sign(d, self.certificateName)
encodedData = d.wireEncode()
transport.send(encodedData.toBuffer())
print d.getName().toUri()
print d.getContent()
self.stop()
'''print"remove register"
def onInterest(self, prefix, interest, face, interestFilterId, filter):
interestName = interest.getName()
data = Data(interestName)
#print "++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
#pprint(self.DataStore)
print "Interest Name: %s" % interestName
interest_name_components = interestName.toUri().split("/")
if "monitoring" in interest_name_components:
print "Check Pi and Containers Status"
monitoring_agent = termopi()
## Print monitoring data
#monitoring_agent.prt_pi_resources()
print "Update json file"
filename = "piStatus" + self.producerName + ".json"
folder_name = "PIstatus/"
rel_path = os.path.join(self.script_dir, folder_name)
if not os.path.exists(rel_path):
os.makedirs(rel_path)
abs_file_path = os.path.join(rel_path, filename)
monitoring_agent.create_jsonfile_with_pi_status(
abs_file_path, self.producerName)
freshness = 10 #milli second, content will be deleted from the cache after freshness period
self.sendingFile(abs_file_path, interest, face, freshness)
else:
print "Interest name mismatch"
def test_constructor(self):
certificate = CertificateV2()
certificate.wireDecode(Blob(CERT, False))
self.assertEqual(
Name("/ndn/site1/KEY/ksk-1416425377094/0123/%FD%00%00%01I%C9%8B"),
certificate.getName())
self.assertEqual(Name("/ndn/site1/KEY/ksk-1416425377094"),
certificate.getKeyName())
self.assertEqual(Name("/ndn/site1"), certificate.getIdentity())
self.assertEqual(Name.Component("0123"), certificate.getIssuerId())
self.assertEqual(Name.Component("ksk-1416425377094"),
certificate.getKeyId())
self.assertEqual(Name("/ndn/site1/KEY/ksk-2516425377094"),
KeyLocator.getFromSignature(certificate.getSignature()).getKeyName())
self.assertEqual(fromIsoString("20150814T223739"),
certificate.getValidityPeriod().getNotBefore(), 0)
self.assertEqual(fromIsoString("20150818T223738"),
certificate.getValidityPeriod().getNotAfter(), 0)
try:
certificate.getPublicKey()
except:
self.fail("Error in getPublicKey");
data = Data()
data.wireDecode(Blob(CERT, False))
certificate2 = CertificateV2(data)
self.assertEqual(certificate.getName(), certificate2.getName())
self.assertTrue(certificate.getPublicKey().equals(certificate2.getPublicKey()))
def on_commit(self, _prefix, interest: Interest, face, _filter_id, _filter):
param = interest.applicationParameters.toBytes()
if not isinstance(param, bytes):
print("Malformed request")
return
param = param.split(b'\x00')
if len(param) != 4:
print("Malformed request")
return
repo, branch, dest_branch, commit_msg = map(bytes.decode, param)
env = os.environ
env['GIT_COMMITTER_NAME'] = 'GitSync'
env['GIT_WORK_TREE'] = os.path.join(os.path.expanduser(MOUNT_PATH), repo, branch)
env['GIT_DIR'] = os.path.join(env['GIT_WORK_TREE'], '.git')
repo_uri = "ndn::" + Name(GIT_PREFIX).append(repo).toUri()
# Commit (blocking)
subprocess.call(['git', 'commit', '-a', '-m', commit_msg], env=env)
# Push
os.spawnlpe(os.P_NOWAIT, 'git', 'git', 'push', repo_uri, 'HEAD:refs/heads/' + dest_branch, env)
# Respond with Data
data = Data(interest.name)
data.content = struct.pack("i", PUSH_RESPONSE_SUCCESS)
data.metaInfo.freshnessPeriod = 1000
face.putData(data)
def onInterest(self, prefix, interest, transport, registeredPrefixId):
interestName = interest.getName()
interestParams = str(interest.getApplicationParameters())
addPrefixes = interestParams.split("|")
interestParams = interestParams + "|" + get_device_ip()
# For each Prefix recieved save it in local array
# Add route for that prefix from User to gateway router
for i in range(0, len(addPrefixes)):
print addPrefixes[i]
self.prefixesList.append(str(addPrefixes[i]))
os.system("nfdc route add " + str(addPrefixes[i]) + " " +
self.gatewayFace)
# Send prefixesList to gateway router
subprocess.call([
"python", "interestSender.py", "-u /ndnchat/register",
"-p " + interestParams
])
data = Data(interestName)
data.setContent("Register Successful")
hourMilliseconds = 3600 * 1000
data.getMetaInfo().setFreshnessPeriod(hourMilliseconds)
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
transport.send(data.wireEncode().toBuffer())
print "Sent advertisement to gateway router"
def _onConfigurationReceived(self, prefix, interest, face,
interestFilterId, filter):
# the interest we get here is signed by HMAC, let's verify it
self.tempPrefixId = interestFilterId # didn't get it from register because of the event loop
dataName = Name(interest.getName())
replyData = Data(dataName)
if (self._hmacHandler.verifyInterest(interest)):
# we have a match! decode the controller's name
configComponent = interest.getName().get(prefix.size())
replyData.setContent('200')
self._hmacHandler.signData(replyData, keyName=self.prefix)
self.face.putData(replyData)
environmentConfig = DeviceConfigurationMessage()
ProtobufTlv.decode(environmentConfig, configComponent.getValue())
networkPrefix = self._extractNameFromField(
environmentConfig.configuration.networkPrefix)
controllerName = self._extractNameFromField(
environmentConfig.configuration.controllerName)
controllerName = Name(networkPrefix).append(controllerName)
self._policyManager.setEnvironmentPrefix(networkPrefix)
self._policyManager.setTrustRootIdentity(controllerName)
self.deviceSuffix = self._extractNameFromField(
environmentConfig.configuration.deviceSuffix)
self._configureIdentity = Name(networkPrefix).append(
self.deviceSuffix)
self._sendCertificateRequest(self._configureIdentity)
def get_data(self, data_name: str):
"""
get_data() takes a Data name and fetches that Data from the Repo.
It returns the Data from the Repo on success
Returns None on error, e.g. HTTP connection error, Data doesn't exist, etc.
"""
base64_data_name = base64.b64encode(str.encode(data_name)).decode()
data_url = 'http://{}:{}/download/{}'.format(self.addr, self.port,
base64_data_name)
logging.info(
'HTTPGetDataClient instance begin to request data with url {}'.
format(data_url))
try:
data_blob = requests.get(data_url).content
except:
logging.warning(
'HTTP network failure when trying to download Data with name {}'
.format(data_name))
return None # should I raise an Error here?
data = Data()
decoder = Tlv0_2WireFormat()
try:
decoder.decodeData(data, data_blob, False)
except ValueError:
logging.warning(
'Requested data with name {} : Decode failed.'.format(
data_name))
print(data_blob)
return None
return data
def __init__(self, prefix, transferfile):
self.keyChain = KeyChain()
self.prefix = Name(prefix)
self.isDone = False
self.transferfile = transferfile
# Initialize list for Data packet storage.
# We'll treat the indices as equivalent to the sequence
# number requested by Interests.
self.data = []
f = open(transferfile, 'rb')
imgdata = f.read()
chunks = list(chunkstring(imgdata, 8192))
print len(chunks)
finalBlock = Name.Component.fromNumberWithMarker(len(chunks) - 1, 0x00)
hourMilliseconds = 3600 * 1000
# Pre-generate and sign all of Data we can serve.
# We can also set the FinalBlockID in each packet
# ahead of time because we know the entire sequence.
for i in range(0, len(chunks)):
dataName = Name(prefix).appendSegment(i)
print dataName
data = Data(dataName)
data.setContent(chunks[i])
data.getMetaInfo().setFinalBlockID(finalBlock)
data.getMetaInfo().setFreshnessPeriod(hourMilliseconds)
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
self.data.append(data)
def createEncryptedDKey(self):
dKeyData = Data(self.dKeyName)
encryptParams = EncryptParams(EncryptAlgorithmType.RsaOaep)
Encryptor.encryptData(dKeyData, self.fixtureDKeyBlob, self.uKeyName,
self.fixtureUEKeyBlob, encryptParams)
self.keyChain.sign(dKeyData, self.certificateName)
return dKeyData
def _onInterest(self, prefix, interest, face, interestFilterId,
filter):
"""
Send back a Chat Data Packet which contains the user's message.
"""
sequenceNo = int(interest.getName()[-1].toEscapedString())
gotContent = False
content = None
for i in range(len(self._messageCache) - 1, -1, -1):
message = self._messageCache[i]
if message.sequenceNo == sequenceNo:
# Use setattr because "from" is a reserved keyword.
# For now we have one message only...
content = json.dumps({
'names': [message.name.toUri()],
'timestamp':
int(round(message.time / 1000.0))
})
gotContent = True
break
if gotContent:
# TODO: Check if this works in Python 3.
data = Data(interest.getName())
data.setContent(content)
data.getMetaInfo().setFreshnessPeriod(
self._namespaceMessageFreshnessPeriod)
self._keyChain.sign(data, self._certificateName)
try:
face.putData(data)
except Exception as ex:
logging.getLogger(__name__).error(
"Error in transport.send: %s", str(ex))
return
def onInterest(self, prefix, interest, transport, registeredPrefixId):
filepath = 'cpu.txt'
counter = 0.0
avg = 0
fp = open(filepath)
line = fp.readline()
cnt = 0
while line:
conv_int = float(line)
line = fp.readline()
#print("Line {}: {}".format(cnt, line.strip()))
counter = counter + conv_int
cnt += 1
total = (cnt)
#print (total)
avg = (counter) / total
#print (avg)
interestName = interest.getName()
data = Data(interestName)
data.setContent("CPU avg:" + str(avg))
hourMilliseconds = 3600 * 1000
data.getMetaInfo().setFreshnessPeriod(hourMilliseconds)
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
transport.send(data.wireEncode().toBuffer())
print "Replied to: %s" % interestName.toUri()
def test_copy_fields(self):
data = Data(self.freshData.getName())
data.setContent(self.freshData.getContent())
data.setMetaInfo(self.freshData.getMetaInfo())
self.credentials.signData(data)
self.assertTrue(dataDumpsEqual(freshDump, initialDump),
'Freshly created data does not match original dump')
def publish(self, line):
dataObject = json.loads(line)
locationName = Name(
self.msgLocationToHierarchicalName(dataObject["sensor_id"]))
if not (locationName.toUri() in self._sensorList):
print self._sensorLocations
print locationName.toUri()
if locationName.toUri() in self._sensorLocations:
x = self._sensorLocations[locationName.toUri()]['X']
y = self._sensorLocations[locationName.toUri()]['Y']
self._sensorList[locationName.toUri()] = {
"id": locationName.toUri(),
"x": x,
"y": y
}
else:
self._sensorList[locationName.toUri()] = {
"id": locationName.toUri()
}
self.publishMetadata()
dataName = Name(self._namespace).append(locationName).append(
self.msgTimestampToNameComponent(dataObject["timestamp"]))
data = Data(dataName)
data.setContent(line)
data.getMetaInfo().setFreshnessPeriod(self._defaultFreshnessPeriod)
self._keyChain.sign(data)
self._cache.add(data)
print("Data " + dataName.toUri() + " added for record: " + line)
self.startRepoInsertion(data)
def benchmarkDecodeDataSeconds(nIterations, useCrypto, encoding):
"""
Loop to decode a data packet nIterations times.
:param int nIterations: The number of iterations.
:param bool useCrypto: If true, verify the signature. If false, don't
verify.
:param Blob encoding: The wire encoding to decode.
"""
# Initialize the private key storage in case useCrypto is true.
identityStorage = MemoryIdentityStorage()
privateKeyStorage = MemoryPrivateKeyStorage()
keyChain = KeyChain(IdentityManager(identityStorage, privateKeyStorage),
SelfVerifyPolicyManager(identityStorage))
keyName = Name("/testname/DSK-123")
certificateName = keyName.getSubName(
0,
keyName.size() - 1).append("KEY").append(
keyName[-1]).append("ID-CERT").append("0")
identityStorage.addKey(keyName, KeyType.RSA,
Blob(DEFAULT_RSA_PUBLIC_KEY_DER))
start = getNowSeconds()
for i in range(nIterations):
data = Data()
data.wireDecode(encoding)
if useCrypto:
keyChain.verifyData(data, onVerified, onVerifyFailed)
finish = getNowSeconds()
return finish - start
def test_hyper_relation(self):
# Set up the validator.
fetcher = CertificateFetcherOffline()
validator = ValidatorConfig(fetcher)
validator.load(
os.path.join(self._policyConfigDirectory,
"hyperrelation_ruleset.conf"))
# Set up a Data packet and result object.
data = Data()
KeyLocator.getFromSignature(data.getSignature()).setType(
KeyLocatorType.KEYNAME)
result = TestValidationResult(data)
data.setName(Name("/SecurityTestSecRule/Basic/Longer/Data2"))
KeyLocator.getFromSignature(data.getSignature()).setKeyName(
Name("/SecurityTestSecRule/Basic/Longer/KEY/123"))
result.checkPolicy(validator)
self.assertTrue(result._calledFailure and not result.calledContinue_)
KeyLocator.getFromSignature(data.getSignature()).setKeyName(
Name("/SecurityTestSecRule/Basic/KEY/123"))
result.checkPolicy(validator)
self.assertTrue(result._calledFailure and not result.calledContinue_)
data.setName(Name("/SecurityTestSecRule/Basic/Other/Data1"))
KeyLocator.getFromSignature(data.getSignature()).setKeyName(
Name("/SecurityTestSecRule/Basic/Longer/KEY/123"))
result.checkPolicy(validator)
self.assertTrue(result._calledFailure and not result.calledContinue_)
KeyLocator.getFromSignature(data.getSignature()).setKeyName(
Name("/SecurityTestSecRule/Basic/KEY/123"))
result.checkPolicy(validator)
self.assertTrue(result._calledFailure and not result.calledContinue_)
def test_trusted_certificate_caching(self):
data = Data(Name("/Security/V2/ValidatorFixture/Sub1/Sub2/Data"))
self._fixture._keyChain.sign(data,
SigningInfo(self._fixture._subIdentity))
self.validateExpectSuccess(
data,
"Should get accepted, as signed by the policy-compliant certificate"
)
self.assertEqual(1, len(self._fixture._face._sentInterests))
self._fixture._face._sentInterests = []
# Disable responses from the simulated Face.
self._fixture._face._processInterest = None
self.validateExpectSuccess(
data,
"Should get accepted, based on the cached trusted certificate")
self.assertEqual(0, len(self._fixture._face._sentInterests))
self._fixture._face._sentInterests = []
# Make the trusted cache simulate a time 2 hours later, after expiration.
self._fixture._validator._setCacheNowOffsetMilliseconds(2 * 3600 *
1000.0)
self.validateExpectFailure(
data, "Should try and fail to retrieve certificates")
# There should be multiple expressed interests due to retries.
self.assertTrue(len(self._fixture._face._sentInterests) > 1)
self._fixture._face._sentInterests = []
