def __init__(self, prefix, maxCount=1): self.keyChain = KeyChain() self.prefix = Name(prefix) self.isDone = False # Initialize list for Data packet storage. # We'll treat the indices as equivalent to the sequence # number requested by Interests. self.data = [] finalBlock = Name.Component.fromNumberWithMarker(maxCount - 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(maxCount): dataName = Name(prefix).appendSegment(i) data = Data(dataName) data.setContent("Hello, " + dataName.toUri()) data.getMetaInfo().setFinalBlockID(finalBlock) data.getMetaInfo().setFreshnessPeriod(hourMilliseconds) self.keyChain.sign(data, self.keyChain.getDefaultCertificateName()) self.data.append(data)
def onInterest(self, prefix, interest, transport, registeredPrefixId): """Called when an interest for the specified name is recieved""" # keep track of when first interest was recieved self._initial_time['download_time'] = time.time() # set data to a byte array of a specified size interestName = interest.getName() data = Data(interestName) data.setContent(self._byte_array) # sign and send data data.getMetaInfo().setFreshnessPeriod(3600 * 1000) self._key_chain.sign(data, self._key_chain.getDefaultCertificateName()) transport.send(data.wireEncode().toBuffer()) # print additional information if verobse flag is set if self._verbose: dump("Replied to:", interestName.toUri()) # increment appropriate variables self._interests_recieved += 1 self._interests_satisfied += 1 self._num_interests += 1 # stop loop if the required number of interests have been satisified if self._num_interests >= self._max_interests: self.shutdown()
def generateData(baseName): ''' This appends the segment number to the data name ''' # just make up some data and return it ts = (time.time()) segmentId = 0 # compatible with repo-ng test: may change to test segmented data versionComponent = baseName.get(-1) # should have a ts dataName = Name(baseName) dataName.appendSegment(segmentId) d = Data(dataName) content = "(" + str(ts) + ") Data named " + dataName.toUri() d.setContent(content) d.getMetaInfo().setFinalBlockID(segmentId) d.getMetaInfo().setFreshnessPeriod(-1) if shouldSign: keychain.sign(d, certName) else: d.setSignature(fakeSignature) if shouldCollectStats: info = getInfoForVersion(versionComponent.toEscapedString()) if info is not None: info['publish_time'] = ts return d
def publishData(self): timestamp = time.time() info = {''} if self._pir == None: cpu_use = ps.cpu_percent() users = [u.name for u in ps.users()] nProcesses = len(ps.pids()) memUse = ps.virtual_memory().percent swapUse = ps.swap_memory().percent info = {'count': self._count, 'cpu_usage':cpu_use, 'users':users, 'processes':nProcesses, 'memory_usage':memUse, 'swap_usage':swapUse} else: info = {'count': self._count, 'pir_bool': self._pir.read()} self._count += 1 dataOut = Data(Name(self._dataPrefix).appendVersion(int(timestamp))) dataOut.setContent(json.dumps(info)) dataOut.getMetaInfo().setFreshnessPeriod(10000) self.signData(dataOut) #self._dataCache.add(dataOut) # instead of adding data to content cache, we put data to nfd anyway self.send(dataOut.wireEncode().buf()) print('data name: ' + dataOut.getName().toUri() + '; content: ' + str(info)) # repeat every 1 seconds self.loop.call_later(1, self.publishData)
def handleDataInterests(self, prefix, interest, transport, prefixId): # TODO: verification # we match the components to the name, and any '_' components # are discarded. Then we run a MongoDB query and append the # object id to allow for excludes chosenSchema = (s for s in self.schemaList if s.dbPrefix.match(prefix)).next() interestName = interest.getName() responseName = Name(interestName) nameFields = chosenSchema.matchNameToSchema(interestName) self.log.info("Data requested with params:\n\t{}".format(nameFields)) allResults = [] segment = 0 try: segmentComponent = interest.getName()[-4] segment = segmentComponent.toSegment() except RuntimeError: pass (startPos, results) = self._segmentResponseData(nameFields, segment) for result in results: dataId = result[u'_id'] self.log.debug("Found object {}".format(dataId)) allResults.append(result) #responseName.append(str(dataId)) totalCount = results.count(False) responseObject = {'count':totalCount, 'skip':startPos, 'results':allResults} responseData = Data(responseName) resultEncoded = BSON.encode(responseObject) responseData.setContent(resultEncoded) transport.send(responseData.wireEncode().buf())
def publishData(self): timestamp = time.time() cpu_use = ps.cpu_percent() users = [u.name for u in ps.users()] nProcesses = len(ps.pids()) memUse = ps.virtual_memory().percent swapUse = ps.swap_memory().percent info = { 'cpu_usage': cpu_use, 'users': users, 'processes': nProcesses, 'memory_usage': memUse, 'swap_usage': swapUse } dataOut = Data(Name(self._dataPrefix).appendVersion(int(timestamp))) dataOut.setContent(json.dumps(info)) dataOut.getMetaInfo().setFreshnessPeriod(10000) self.signData(dataOut) self._dataCache.add(dataOut) # repeat every 5 seconds self.loop.call_later(5, self.publishData)
def wrap_content(self, name, content, key=None, key_locator=None): """ @param name - name of the data @param content - data to be wrapped @param key - key used to sign the data @return the content object created wraps the given name and content into a content object """ co = Data(Name(name)) co.setContent(content) co.getMetaInfo().setFreshnessPeriod(5000) co.getMetaInfo().setFinalBlockID(Name("/%00%09")[0]) identityStorage = MemoryIdentityStorage() privateKeyStorage = MemoryPrivateKeyStorage() identityManager = IdentityManager(identityStorage, privateKeyStorage) keyChain = KeyChain(identityManager, None) # Initialize the storage. keyName = Name("/ndn/bms/DSK-default") certificateName = keyName.getSubName(0, keyName.size() - 1).append( "KEY").append(keyName[-1]).append("ID-CERT").append("0") identityStorage.addKey(keyName, KeyType.RSA, Blob(DEFAULT_PUBLIC_KEY_DER)) privateKeyStorage.setKeyPairForKeyName(keyName, DEFAULT_PUBLIC_KEY_DER, DEFAULT_PRIVATE_KEY_DER) keyChain.sign(co, certificateName) _data = co.wireEncode() return _data.toRawStr()
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 _onConfigurationReceived(self, prefix, interest, transport, prefixId): # the interest we get here is signed by HMAC, let's verify it self.tempPrefixId = prefixId # didn't get it from register because of the event loop interestName = interest.getName() replyData = Data(interestName) if len(interestName) == len(prefix): # this is a discovery request. Check the exclude to see if we should # return our serial serial = self.getSerial() serialComponent = Name.Component(serial) if not interest.getExclude().matches(serialComponent): replyData.setContent(serial) self.sendData(replyData, transport, False) # no point in signing elif (self._hmacHandler.verifyInterest(interest)): # we have a match! decode the network parameters configComponent = interest.getName()[len(prefix)+1] replyData.setContent('200') self._hmacHandler.signData(replyData, keyName=self.prefix) transport.send(replyData.wireEncode().buf()) 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 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 onLightingCommand(self, prefix, interest, transport, prefixId): interestName = Name(interest.getName()) #d = Data(interest.getName().getPrefix(prefix.size()+1)) d = Data(interest.getName()) # get the command parameters from the name try: commandComponent = interest.getName().get(prefix.size()) commandParams = interest.getName().get(prefix.size()+1) lightingCommand = LightCommandMessage() ProtobufTlv.decode(lightingCommand, commandParams.getValue()) self.log.info("Command: " + commandComponent.toEscapedString()) requestedColor = lightingCommand.command.pattern.colors[0] colorStr = str((requestedColor.r, requestedColor.g, requestedColor.b)) self.log.info("Requested color: " + colorStr) self.setPayloadColor(0, requestedColor) self.sendLightPayload(1) d.setContent("Gotcha: " + colorStr+ "\n") except Exception as e: print e d.setContent("Bad command\n") finally: d.getMetaInfo().setFinalBlockID(0) self.signData(d) encodedData = d.wireEncode() transport.send(encodedData.toBuffer())
def onDataInterest(prefix, interest, transport, pxID): ''' For publishing face ''' # just make up some data and return it interestName = interest.getName() logger.info("Interest for " + interestName.toUri()) ## CURRENTLY ASSUMES THERE'S A VERSION/SEGMENT SUFFIX! dataName = Name(interestName.getPrefix(-1)) ts = (time.time()) segmentId = 0 try: segmentId = interestName().get(-1).toSegment() except: logger.debug("Could not find segment id!") dataName.appendSegment(segmentId) versionStr = interestName.get(-2).getValue().toRawStr() logger.debug('publishing ' + versionStr) info = getInfoForVersion(versionStr) d = Data(dataName) content = "(" + str(ts) + ") Data named " + dataName.toUri() d.setContent(content) d.getMetaInfo().setFinalBlockID(segmentId) keychain.sign(d, certName) encodedData = d.wireEncode() now = time.time() if info is not None: info['publish_time'] = now transport.send(encodedData.toBuffer())
def test_copy_fields(self): data = Data(self.freshData.getName()) data.setContent(self.freshData.getContent()) data.setMetaInfo(self.freshData.getMetaInfo()) self.credentials.signData(data) freshDump = dumpData(data) self.assertTrue(dataDumpsEqual(freshDump, initialDump), 'Freshly created data does not match original dump')
def loadApplications(self, directory = None, override = False): if not directory: directory = self._applicationDirectory if override: self._applications.clear() if os.path.exists(directory): for f in os.listdir(directory): fullFileName = os.path.join(directory, f) if os.path.isfile(fullFileName) and f.endswith('.conf'): appName = f.rstrip('.conf') if appName in self._applications and not override: print("loadApplications: " + appName + " already exists, do nothing for configuration file: " + fullFileName) else: self._applications[appName] = {"tree": BoostInfoParser(), "dataPrefix": [], "version": int(time.time())} self._applications[appName]["tree"].read(fullFileName) data = Data(Name(self.prefix).append(appName).append("_schema").appendVersion(self._applications[appName]["version"])) data.setContent(str(self._applications[appName]["tree"].getRoot())) self.signData(data) self._memoryContentCache.add(data) try: validatorTree = self._applications[appName]["tree"]["validator"][0] for rule in validatorTree["rule"]: self._applications[appName]["dataPrefix"].append(rule["id"][0].value) # TODO: don't swallow any general exceptions, we want to catch only KeyError (make sure) here except Exception as e: print("loadApplications parse configuration file " + fullFileName + " : " + str(e)) return
def _onConfigurationReceived(self, prefix, interest, transport, prefixId): # the interest we get here is signed by HMAC, let's verify it self.tempPrefixId = prefixId # 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) transport.send(replyData.wireEncode().buf()) 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 onPlayingCommand(self, prefix, interest, transport, prefixId): print "receive interest" interestName = Name(interest.getName()) commandComponent = interest.getName().get(self.prefix.size()) if commandComponent == Name.Component("stop"): pass if commandComponent == Name.Component("play"): pass else: songName = commandComponent.toEscapedString() print songName songList = [] songList = songName.split('%2C') print "songlist and its len",songList,len(songList) for i in songList: self.song = i fmusic = i+str("-music.mp3") self.ftxt = i + str("-os.txt") self.ffreq = i + str("-freq.txt") print "FMUSIC:",fmusic self.thread = threading.Thread(target = self.mp.play_music, args = (fmusic,songList,self.q,)) self.thread.daemon = True g = GetFile(self._repoCommandPrefix, i, self._face, self.getOnset) #g = GetFile(self._repoCommandPrefix, ftxt, self._face, self.lightFunction) g.oStream = open(fmusic,'wb') g.start() d = Data(interest.getName()) d.setContent("start to play: " + songName + "\n") encodedData = d.wireEncode() transport.send(encodedData.toBuffer())
def onDeviceListRequest(self, prefix, interest, transport, registeeredPrefix): interestName = interest.getName() username = interestName.get(4).getValue().toRawStr() #TODO guest check prefix = Name("/home/user/"+username) userHash = self._deviceUserAccessManager.getUserHash(prefix) userHMACKey = HMACKey(0,0,userHash,"userHMACKey") dump("device dict : ",self._deviceDict) if ( self._accessControlManager.verifyInterestWithHMACKey(interest,userHMACKey) ): dump("Verified") deviceProfileList = [] for prefixStr in self._deviceDict.keys(): tmp = self._deviceDict[prefixStr]['deviceProfile'].__dict__ dump("tmp :",tmp) if (type(tmp["_prefix"]) != str): tmp["_prefix"] = tmp["_prefix"].toUri() deviceProfileList.append(tmp) data = Data(interestName) data.setContent(json.dumps(deviceProfileList)) self._accessControlManager.signDataWithHMACKey(data,userHMACKey) self.sendData(data,transport,sign=False) else: dump("Not verified")
def prepare_data(self): """ Shard file into data packets. """ logging.info('preparing data') with open(self.file_path, 'rb') as binary_file: b_array = bytearray(binary_file.read()) if len(b_array) == 0: logging.warning("File is 0 bytes") return self.n_packets = int((len(b_array) - 1) / MAX_BYTES_IN_DATA_PACKET + 1) logging.info('There are {} packets in total'.format(self.n_packets)) seq = 0 for i in range(0, len(b_array), MAX_BYTES_IN_DATA_PACKET): data = Data(Name(self.name_at_repo).append(str(seq))) data.metaInfo.freshnessPeriod = 100000 data.setContent( b_array[i:min(i + MAX_BYTES_IN_DATA_PACKET, len(b_array))]) data.metaInfo.setFinalBlockId( Name.Component.fromSegment(self.n_packets - 1)) self.keychain.signWithSha256(data) self.m_name_str_to_data[str(data.getName())] = data seq += 1
def onVerificationFailedAppRequest(interest): print("application request verify failed!") response = Data(interest.getName()) response.setContent( "{\"status\": 401, \"message\": \"command interest verification failed\" }" ) self.sendData(response)
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 onPublishInterest(self, prefix, interest, transport, pxID): ''' For publishing face ''' # just make up some data and return it interestName = interest.getName() logger.info("Interest for " + interestName.toUri()) ## CURRENTLY ASSUMES THERE'S A VERSION+SEGMENT SUFFIX! dataName = Name(interestName) ts = (time.time()) segmentId = 0 #try: # segmentId = interestName.get(-1).toSegment() #except: #logger.debug("Could not find segment id!") #dataName.appendSegment(segmentId) versionStr = str(interestName.get(-2).getValue()) logger.debug('Publishing ' + versionStr + ' @ ' + str(ts)) d = Data(dataName) content = "(" + str(ts) + ") Data named " + dataName.toUri() d.setContent(content) d.getMetaInfo().setFinalBlockID(segmentId) d.getMetaInfo().setFreshnessPeriod(1000) self.keychain.sign(d, self.certificateName) encodedData = d.wireEncode() stats.insertDataForVersion(versionStr, {'publish_time': time.time()}) transport.send(encodedData.toBuffer())
def prepare_data(filePath, keychain: KeyChain): """ Shard file into data packets. """ temp_data={} logging.info('preparing data for {}'.format(filePath)) print('preparing data for {}'.format(filePath)) with open(filePath, 'rb') as binary_file: b_array = bytearray(binary_file.read()) if len(b_array) == 0: logging.warning("File is 0 bytes") return n_packets = int((len(b_array) - 1) / MAX_BYTES_IN_DATA_PACKET + 1) print('There are {} packets'.format(n_packets)) seq = 0 for i in range(0, len(b_array), MAX_BYTES_IN_DATA_PACKET): data = Data(Name(VIDEO_STREAM_NAME).append(filePath.split('.')[0]).append(str(seq))) data.setContent(b_array[i: min(i + MAX_BYTES_IN_DATA_PACKET, len(b_array))]) data.metaInfo.setFinalBlockId(Name.Component.fromSegment(n_packets - 1)) keychain.signWithSha256(data) temp_data[str(data.getName())] = data seq += 1 print('{} packets prepared: {}'.format(n_packets, str(Name(VIDEO_STREAM_NAME).append(filePath.split('.')[0])))) return temp_data
def onPlayingCommand(self, prefix, interest, transport, prefixId): interestName = Name(interest.getName()) commandComponent = interest.getName().get(self.prefix.size()) if commandComponent == Name.Component("stop"): pass if commandComponent == Name.Component("play"): pass else: songName = commandComponent.toEscapedString() songList = [] songList = songName.split('%2C') for i in songList: fmusic = i + str("-music.mp3") print "started getting music file", i g = GetFile(self._repoCommandPrefix, i, self._face, self.getOnset, i) g.oStream = open(fmusic,'wb') g.start() #self._getFiles.append(g) d = Data(interest.getName()) d.setContent("start to play: " + songName + "\n") encodedData = d.wireEncode() transport.send(encodedData.toBuffer())
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 _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 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(prefix, interest, transport, prefixID): interestCallbackCount[0] += 1 data = Data(interest.getName()) data.setContent("SUCCESS") self.keyChain.sign(data, self.keyChain.getDefaultCertificateName()) encodedData = data.wireEncode() transport.send(encodedData.toBuffer())
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 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 onPlayingCommand(self, prefix, interest, transport, prefixId): interestName = Name(interest.getName()) commandComponent = interest.getName().get(self.prefix.size()) if commandComponent == Name.Component("stop"): pass if commandComponent == Name.Component("play"): pass else: songName = commandComponent.toEscapedString() songList = [] songList = songName.split('%2C') for i in songList: fmusic = i + str("-music.mp3") print "started getting music file", i g = GetFile(self._repoCommandPrefix, i, self._face, self.getOnset, i) g.oStream = open(fmusic, 'wb') g.start() #self._getFiles.append(g) d = Data(interest.getName()) d.setContent("start to play: " + songName + "\n") encodedData = d.wireEncode() transport.send(encodedData.toBuffer())
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 __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 generateData(self, baseName): ''' This appends the segment number to the data name, since repo-ng tends to expect it ''' # just make up some data and return it ts = (time.time()) segmentId = 0 # compatible with repo-ng test: may change to test segmented data versionStr = baseName.get(-1).toEscapedString() dataName = Name(baseName) dataName.appendSegment(segmentId) d = Data(dataName) content = "(" + str(ts) + ") Data named " + dataName.toUri() d.setContent(content) d.getMetaInfo().setFinalBlockID(segmentId) d.getMetaInfo().setFreshnessPeriod(-1) if shouldSign: self.keychain.sign(d, self.certificateName) else: d.setSignature(self.fakeSignature) stats.insertDataForVersion(versionStr, {'publish_time':time.time()}) logger.debug('Publishing: '+d.getName().toUri()) return d
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 onVerifiedAppRequest(interest): # TODO: for now, we automatically grant access to any valid signed interest print("verified! send response!") message = AppRequestMessage() ProtobufTlv.decode( message, interest.getName().get(prefix.size() + 1).getValue()) certName = Name("/".join(message.command.idName.components)) dataPrefix = Name("/".join( message.command.dataPrefix.components)) appName = message.command.appName isUpdated = self.updateTrustSchema(appName, certName, dataPrefix, True) response = Data(interest.getName()) if isUpdated: response.setContent( "{\"status\": 200, \"message\": \"granted, trust schema updated OK\" }" ) self.log.info( "Verified and granted application publish request") else: response.setContent( "{\"status\": 400, \"message\": \"not granted, requested publishing namespace already exists\" }" ) self.log.info( "Verified and but requested namespace already exists") self.sendData(response) 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 onInterest(self, prefix, interest, transport, registeredPrefixId): print "received interest" initInterest = Name(interest.getName()) print "interest name:",initInterest.toUri() 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.loop.close() self.face.shutdown() self.face = None
def createData(self, namePrefix, timestamp, payload, certName): data = Data(Name(self._namespace).append(namePrefix).append(str(int(float(timestamp))))) data.setContent(payload) self._keyChain.sign(data, certName) data.getMetaInfo().setFreshnessPeriod(self.DEFAULT_DATA_LIFETIME) if __debug__: print(data.getName().toUri()) return data
def createFreshData(self): freshData = Data(Name("/ndn/abc")) freshData.setContent("SUCCESS!") freshData.getMetaInfo().setFreshnessPeriod(5000.0) freshData.getMetaInfo().setFinalBlockId(Name("/%00%09")[0]) # Initialize the storage. return freshData
def publishData(self, key, key_ts, payload, timestamp): data = Data(Name(self.prefix).append(bytearray(timestamp))) iv = Random.new().read(AES.block_size) encryptor = AES.new(key, AES.MODE_CBC, iv) data.setContent(bytearray(key_ts + iv + encryptor.encrypt(pad(json.dumps(payload))))) data.getMetaInfo().setFreshnessPeriod(5000) self.keychain.sign(data, self.cert_name) self.publisher.put(data)
def createFreshData(self): freshData = Data(Name("/ndn/abc")) freshData.setContent("SUCCESS!") freshData.getMetaInfo().setFreshnessPeriod(5000.0) freshData.getMetaInfo().setFinalBlockID(Name("/%00%09")[0]) # Initialize the storage. return freshData
def test_encode_decode(self): data = Data() data.wireDecode(codedData) data.setContent(data.getContent()) encoding = data.wireEncode() reDecodedData = Data() reDecodedData.wireDecode(encoding) self.assertEqual(dumpData(reDecodedData), initialDump, 'Re-decoded data does not match original dump')
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 onInterest(self, prefix, interest, face, interestFilterId, filter): print("[*] Got interest") self.rec = 0 data = Data(interest.getName()) content = "hello" data.setContent(content) #self.keyChain.sign(data,self.certName) face.putData(data) print("! finished in onInterest")
def testEmptyContent(self): state = PSyncState() # Simulate getting a buffer of content from a segment fetcher. data = Data() data.setContent(state.wireEncode()) state2 = PSyncState(data.getContent()) self.assertEqual(0, len(state2.getContent()))
def onMemberCertificateData(self, interest, data, accessInterest): print "Member certificate with name retrieved: " + data.getName( ).toUri() + "; member added to group!" self.manager.addMember("schedule1", data) self.needToPublishGroupKeys = True accessResponse = Data(accessInterest.getName()) accessResponse.setContent("granted") self.face.putData(accessResponse)
def sendData(self, prefix, interest, face, registeredPrefixId, content): #onInterest #transport.send(encodedData.toBuffer()) #print(prefix) # Publish segments dataSize = len(content) print("Dat size: ",dataSize) segmentBegin = 0 segmentNo = 0 print "Start" while segmentBegin < dataSize: segmentEnd = segmentBegin + 2000 #Common.MAX_NDN_PACKET_SIZE if segmentEnd > dataSize: segmentEnd = dataSize # Make and sign a Data packet. print("Prefix: ") print(prefix) if not "%" in str(prefix)[-7:]: segmentName = prefix #print("NO % in name: ", segmentName) segmentName.appendSegment(segmentNo) else: segmentName = str(prefix)[:-1] #print("% in name: ",segmentName) segmentName += str(segmentNo) segmentName = Name(segmentName) print("Segment Name: ") print(segmentName) print("Segment Name appended: ", segmentName) print "Segmenting data from %d to %d" % (segmentBegin, segmentEnd) print("COntent: ") print(content[segmentBegin:segmentEnd]) data = Data(segmentName) data.setContent(content[segmentBegin:segmentEnd]) data.getMetaInfo().setFreshnessPeriod(2000) self._keyChain.sign(data, self._certificateName) if segmentEnd >= dataSize: print("yes") data.getMetaInfo().setFinalBlockId(segmentName[-1]) #encodedData = data.wireEncode() segmentBegin = segmentEnd print "Sending data " + segmentName.toUri() #transport.send(encodedData.toBuffer()) face.putData(data) segmentNo += 1 time.sleep(0.5) print "Finish"
def createData(self, namePrefix, timestamp, payload, certName): data = Data( Name(self._namespace).append(namePrefix).append(str(timestamp))) data.setContent(payload) self._keyChain.sign(data, certName) data.getMetaInfo().setFreshnessPeriod(self.DEFAULT_DATA_LIFETIME) if __debug__: print(data.getName().toUri()) return data
def onAccessTokenListRequest(self, prefix, interest, transport, registeredPrefixId): interestName = interest.getName() devicePrefixStr = "/home"+interestName.getSubName(2,3).toUri() dump("device prefix: ",devicePrefixStr) username = interestName.get(6).getValue().toRawStr() userPrefix = Name("/home/user/"+username) userHash = self._deviceUserAccessManager.getUserHash(userPrefix) userHMACKey = HMACKey(0,0,userHash,"userHMACKey") if ( self._accessControlManager.verifyInterestWithHMACKey(interest,userHMACKey) ): dump("Verified") accessTokenInfoList = [] seed = self._deviceUserAccessManager.getSeed(Name(devicePrefixStr)) dump("seed",seed) dump("device dict", self._deviceDict) dump("devicePrefixStr",devicePrefixStr) commandList = [] try : commandList = self._deviceDict[devicePrefixStr]['commandList'] except Exception: dump("No such device") dump("Command List: ",commandList) for eachCommand in commandList: commandTokenNameStr = devicePrefixStr+'/'+eachCommand+'/token/0' commandTokenSequence = 0 seedSequence = 0 commandToken = hmac.new(seed.getKey(), commandTokenNameStr, sha256).digest() accessTokenNameStr = commandTokenNameStr+'/user/'+username+'/token/0' accessToken = hmac.new(commandToken, accessTokenNameStr, sha256).digest() dump("commandTkenName ------------- : ",commandTokenNameStr) dump("commandTken ------------- : ",base64.b64encode(commandToken)) dump("accessTokenName ------------- : ",accessTokenNameStr) dump("accessToken ----------------- : ",base64.b64encode(accessToken)) dump("accessToken hex-------------- : ",hmac.new(commandToken, accessTokenNameStr, sha256).hexdigest()) accessTokenInfo = {} accessTokenInfo['command'] = eachCommand accessTokenInfo['commandTokenSequence'] = commandTokenSequence accessTokenInfo['seedSequence'] = seedSequence accessTokenInfo['accessToken'] = base64.b64encode( accessToken) accessTokenInfo['accessTokenName'] = accessTokenNameStr accessTokenInfoList.append(accessTokenInfo) data = Data(interestName) data.setContent(json.dumps(accessTokenInfoList)) self._accessControlManager.signDataWithHMACKey(data,userHMACKey) self.sendData(data,transport,sign=False) else: dump("Not verified")
def reply_(self, interest, response): if type(response) is Response: data = Data(interest.getName().appendTimestamp( self.microsecondTimestamp_())) data.setContent(json.dumps(response.payload_)) data.getMetaInfo().setFreshnessPeriod(100) self.keyChain_.sign(data) self.face_.putData(data) else: raise "Returned type is not Response"
def set_returndata(self, interest, returndatacontent): interestName = interest.getName() data = Data(interestName) data.setContent( returndatacontent) #suppose the returndatacontent is string hourMilliseconds = 0 # here I should set it 0 since it always need to fresh. data.getMetaInfo().setFreshnessPeriod(hourMilliseconds) self.keyChain.sign(data, self.keyChain.getDefaultCertificateName() ) #need to cheek if it works here. return (data)
def contentCacheAddEntityData(self, name, entityInfo): content = self._serializer.serialize(entityInfo) data = Data(Name(name)) data.setContent(content) data.getMetaInfo().setFreshnessPeriod(self._entityDataFreshnessPeriod) self._keyChain.sign(data, self._certificateName) self._memoryContentCache.add(data) print "added entity to cache: " + data.getName().toUri() + "; " + data.getContent().toRawStr()
def onEntityDataNotFound(self, prefix, interest, face, interestFilterId, filter): name = interest.getName().toUri() if name in self._hostedObjects: content = self._serializer.serialize(self._hostedObjects[name]) data = Data(Name(name)) data.setContent(content) data.getMetaInfo().setFreshnessPeriod(self._entityDataFreshnessPeriod) self._keyChain.sign(data, self._certificateName) self._face.putData(data) return
def test_extension(self): #now add an extension name = "/hello/kitty" trustClass = 0 trustLevel = 300 extValueRoot = DerSequence() extValueName = DerOctetString(Blob(name).buf()) extValueTrustClass = DerInteger(trustClass) extValueTrustLevel = DerInteger(trustLevel) extValueRoot.addChild(extValueName) extValueRoot.addChild(extValueTrustClass) extValueRoot.addChild(extValueTrustLevel) extValueData = extValueRoot.encode() oidString = "1.3.6.1.5.32.1" isCritical = True certExtension = CertificateExtension(oidString, isCritical, extValueData) self.toyCert.encode() cert = Certificate(self.toyCert) cert.addExtension(certExtension) cert.encode() certData = cert.getContent() plainData = Data() plainData.setContent(certData) # The constructor Certificate(Data) calls decode(). decodedCert = Certificate(plainData) self.assertEqual(1, len(decodedCert.getExtensionList()), "Wrong number of certificate extensions after decoding") decodedExtension = decodedCert.getExtensionList()[0] self.assertEqual(oidString, str(decodedExtension.getOid()), "Certificate extension has the wrong OID after decoding") self.assertEqual(isCritical, decodedExtension.getIsCritical(), "Certificate extension has the wrong isCritical value after decoding") # Decode and check the extension value. parsedExtValue = DerNode.parse(decodedExtension.getValue().buf()) decodedExtValueRoot = parsedExtValue.getChildren() self.assertEqual(3, len(decodedExtValueRoot), "Wrong number of certificate extension value items after decoding") decodedName = decodedExtValueRoot[0] decodedTrustClass = decodedExtValueRoot[1] decodedTrustLevel = decodedExtValueRoot[2] # Use Blob to get a string. self.assertEqual(name, Blob(decodedName.toVal()).toRawStr(), "Wrong extension value name after decoding") self.assertEqual(trustClass, decodedTrustClass.toVal(), "Wrong extension value trust class after decoding") self.assertEqual(trustLevel, decodedTrustLevel.toVal(), "Wrong extension value trust level after decoding")
def test_extension(self): #now add an extension name = "/hello/kitty" trustClass = 0 trustLevel = 300 extValueRoot = DerSequence() extValueName = DerOctetString(Blob(name).buf()) extValueTrustClass = DerInteger(trustClass) extValueTrustLevel = DerInteger(trustLevel) extValueRoot.addChild(extValueName) extValueRoot.addChild(extValueTrustClass) extValueRoot.addChild(extValueTrustLevel) extValueData = extValueRoot.encode() oidString = "1.3.6.1.5.32.1" isCritical = True certExtension = CertificateExtension(oidString, isCritical, extValueData) self.toyCert.encode() cert = Certificate(self.toyCert) cert.addExtension(certExtension) cert.encode() certData = cert.getContent() plainData = Data() plainData.setContent(certData) # The constructor Certificate(Data) calls decode(). decodedCert = Certificate(plainData) self.assertEqual(1, len(decodedCert.getExtensionList()), "Wrong number of certificate extensions after decoding") decodedExtension = decodedCert.getExtensionList()[0] self.assertEqual(oidString, str(decodedExtension.getOid()), "Certificate extension has the wrong OID after decoding") self.assertEqual(isCritical, decodedExtension.getIsCritical(), "Certificate extension has the wrong isCritical value after decoding") # Decode and check the extension value. parsedExtValue = DerNode.parse(decodedExtension.getValue().buf()) decodedExtValueRoot = parsedExtValue.getChildren() self.assertEqual(3, len(decodedExtValueRoot), "Wrong number of certificate extension value items after decoding") decodedName = decodedExtValueRoot[0] decodedTrustClass = decodedExtValueRoot[1] decodedTrustLevel = decodedExtValueRoot[2] # Use Blob to get a string. self.assertEqual(name, Blob(decodedName.toVal()).toRawStr(), "Wrong extension value name after decoding") self.assertEqual(trustClass, decodedTrustClass.toVal(), "Wrong extension value trust class after decoding") self.assertEqual(trustLevel, decodedTrustLevel.toVal(), "Wrong extension value trust level after decoding")
def _prepareCapabilitiesList(self, interestName): """ Responds to a directory listing request with JSON """ dataName = Name(interestName).append(Name.Component.fromNumber(int(time.time()))) response = Data(dataName) response.setContent(json.dumps(self._directory)) return response
def onCecCommand(self, interest): self.log.debug("Received CEC command") # check command interest name # verify command interest message = pb.CommandMessage() ProtobufTlv.decode(message, interest.getName().get(3).getValue()) self.loop.call_soon(self.processCommands, message) data = Data(interest.getName()) data.setContent('ACK') return data