def __init__(self, publisher, uri): freshness = 30 * 60 self._chunk_size = 3900 self._segment = 0 self._caps = None self.publisher = publisher self._basename = pyccn.Name(uri) self._name_segments = self._basename.append("segments") self._name_frames = self._basename.append("index") self._name_key = self._basename.append("key") self._key = pyccn.CCN.getDefaultKey() self._signed_info = pyccn.SignedInfo(self._key.publicKeyID, pyccn.KeyLocator(self._name_key), freshness=freshness) self._signed_info_frames = pyccn.SignedInfo(self._key.publicKeyID, pyccn.KeyLocator( self._name_key), freshness=freshness) self._segmenter = DataSegmenter(self.send_data, self._chunk_size) signed_info = pyccn.SignedInfo(self._key.publicKeyID, pyccn.KeyLocator(self._key), freshness=freshness) co = pyccn.ContentObject(self._name_key, self._key.publicToDER(), signed_info) co.sign(self._key) self.publisher.put(co)
def loadAndPublishKey(self): self.ksk = pyccn.Key() self.ksk.generateRSA(1024) #self.ksk.fromPEM(filename = keyFile) self.ksk_name = self.prefix.appendKeyID(self.ksk) self.ksk_si = pyccn.SignedInfo(self.ksk.publicKeyID, pyccn.KeyLocator(self.ksk_name)) self.data_dsk = pyccn.Key() self.data_dsk.generateRSA(1024) self.data_dskname = self.prefix.append( 'data').appendVersion().appendKeyID(self.data_dsk) self.data_si = pyccn.SignedInfo(self.data_dsk.publicKeyID, pyccn.KeyLocator(self.data_dskname)) self.publish_dsk(self.data_dsk, self.data_dskname) print 'Publish data DSK: ' + str(self.data_dskname) self.kds_dsk = pyccn.Key() self.kds_dsk.generateRSA(1024) self.kds_dskname = self.prefix.append( 'kds').appendVersion().appendKeyID(self.kds_dsk) self.kds_si = pyccn.SignedInfo(self.kds_dsk.publicKeyID, pyccn.KeyLocator(self.kds_dskname)) self.publish_dsk(self.kds_dsk, self.kds_dskname) print 'Publish data DSK: ' + str(self.kds_dskname)
def __init__(self, uri, sink): self._sink = sink self._handle = pyccn.CCN() self._basename = pyccn.Name(uri) self._name_segments = self._basename.append("segments") self._name_frames = self._basename.append("frames") self._key = self._handle.getDefaultKey() self._flow_controller = utils.FlowController(self._basename, self._handle) self._signed_info = pyccn.SignedInfo(self._key.publicKeyID, pyccn.KeyLocator(self._key)) self._signed_info_frames = pyccn.SignedInfo(self._key.publicKeyID, pyccn.KeyLocator(self._key))
def run(self): for info in self.device: co_name = pyccn.Name(info['acl_name']) print str(co_name) print info['acl'] content = json.dumps({'acl': info['acl']}) co = pyccn.ContentObject(name=co_name, content=content, signed_info=pyccn.SignedInfo( self.key.publicKeyID, pyccn.KeyLocator(self.keyname))) co.sign(self.key) self.publisher.put(co) InterestBaseName = pyccn.Name('/local/manager') configclosure = ConfigClosure(self) handler.setInterestFilter(InterestBaseName, configclosure) for usr in self.usrlist: name_t = pyccn.Name(str(usr['usrname'])).components username = pyccn.Name(name_t[0:len(name_t) - 1]).append('acl').appendVersion() device_prefix = [] for prefix in usr['prefix']: name_t = pyccn.Name(str(prefix)) if (len(name_t.components) > 5): name_t = pyccn.Name(name_t.components[0:5]) name_str = str(name_t) if ((name_str in self.acl_tree) == True): self.node = [] self.find_device(name_str) #print self.node for device_name in self.node: #print device_name index = self.findbyprefix(device_name) flag = (device_name + '/data_points') in device_prefix #print (index != -1 and flag == False) if (index != -1 and flag == False): device_prefix.append(device_name + '/data_points') print device_prefix data_prefix = pyccn.ContentObject( name=username, content=json.dumps({'prefix': device_prefix}), signed_info=pyccn.SignedInfo(self.key.publicKeyID, pyccn.KeyLocator(self.keyname))) data_prefix.sign(self.dsk) self.publisher.put(data_prefix) print 'Publish Data Points' print username while True: handler.run(1000)
def publish_dsk(self,dsk, dsk_name): key_con = pyccn.ContentObject() key_con.name = dsk_name key_con.content = dsk.publicToDER() key_con.signedInfo = pyccn.SignedInfo(self.ksk.publicKeyID, pyccn.KeyLocator(self.ksk_name), type = pyccn.CONTENT_KEY, final_block = b'\x00') key_con.sign(self.ksk) self.publisher.put(key_con)
def update_acl(self, index): self.device[index]['acl_name'] = pyccn.Name( self.device[index]['acl_name']).components co_name = pyccn.Name(self.device[index]['acl_name'] [0:len(self.device[index]['acl_name']) - 1]).appendVersion() print 'publish acl to repo' print str(co_name) self.device[index]['acl_name'] = str(co_name) content = json.dumps({'acl': self.device[index]['acl']}) ## co = pyccn.ContentObject(name=co_name, content=content, signed_info=pyccn.SignedInfo( self.key.publicKeyID, pyccn.KeyLocator(self.keyname))) co.sign(self.key) self.publisher.put(co) if (self.device[index]['loc_name'] != None): inst_name = pyccn.Name( self.device[index]['loc_name']).append('acl') aclclosure = ConfigClosure(self) handler.expressInterest(inst_name, aclclosure, interest_tmpl) print 'manager expressInterest' print inst_name
def __init__(self, name, key): self.name = name self.key = key kl = pyccn.KeyLocator(key) self.signed_info = pyccn.SignedInfo(key_locator=kl, key_digest=key.publicKeyID)
def __init__(self, uri, sink): self._sink = sink self._handle = pyccn.CCN() self._basename = pyccn.Name(uri) self._name_segments = self._basename.append("segments") self._name_frames = self._basename.append("frames") self._key = self._handle.getDefaultKey() self._signed_info = pyccn.SignedInfo(self._key.publicKeyID, pyccn.KeyLocator(self._key)) self._signed_info_frames = pyccn.SignedInfo( self._key.publicKeyID, pyccn.KeyLocator(self._key)) self._flow_controller = RepoPublisher(self._handle, "/home/takeda/ccnx/repo")
def upcall(self, kind, upcallInfo): if kind == pyccn.UPCALL_CONTENT or kind == pyccn.UPCALL_CONTENT_UNVERIFIED: co = upcallInfo.ContentObject #how to decript print 'G on data' co_content = json.loads(co.content) txt = co_content['ciphertxt'] #iv = encrypted_content[0:16] #ciphertxt = encrypted_content[16:len(encrypted_content)] #decipher = AES.new(symkey, AES.MODE_CBC, iv) #txt = unpad(decipher.decrypt(ciphertxt)) m = hashlib.sha256() m.update(symkey) m.update(co_content['uncripted']) if txt == m.hexdigest() and self.logger == None: content = json.loads(co_content['uncripted']) print 'content' print content aclname = pyccn.Name(str(content['acl_name'])) print aclname self.logger = SensorDataLogger(1000, content['trust_anchor'], content['prefix']) aclclosure = AclClosure(self.logger, self.device_prefix) handler0.expressInterest(aclname, aclclosure, interest_tmpl0) InterestBaseName = pyccn.Name(self.device_prefix).append('acl') print InterestBaseName handler0.setInterestFilter(InterestBaseName, aclclosure) elif kind == pyccn.UPCALL_INTEREST: print 'G on interest' interest = upcallInfo.Interest print interest.name pubkey = ksk.publicToDER() #iv = Random.new().read(AES.block_size) m = hashlib.sha256() m.update(symkey) m.update(pubkey) digest = m.hexdigest() #cipher = AES.new(symkey, AES.MODE_CBC, iv) #cipherkey = cipher.encrypt(pad(digest)) print 'digest' print digest sendpubkey = pyccn.Key() sendpubkey.fromDER(public=pubkey) co = pyccn.ContentObject( name=interest.name, content=digest, signed_info=pyccn.SignedInfo( ksk.publicKeyID, pyccn.KeyLocator(sendpubkey), type=pyccn.CONTENT_KEY, final_block=b'\x00')) #################### co.sign(ksk) handler0.put(co) elif kind == pyccn.UPCALL_INTEREST_TIMED_OUT: return pyccn.RESULT_REEXPRESS return pyccn.RESULT_OK
def upcall(self, kind, upcallInfo): if kind == pyccn.UPCALL_CONTENT or kind == pyccn.UPCALL_CONTENT_UNVERIFIED: co = upcallInfo.ContentObject root_key = pyccn.Key() root_key.fromPEM(public=self.logger.anchor[0]['pubkey']) flag = co.verify_signature(root_key) if flag == True: if co.name.components[len(co.name.components) - 1] == 'acl': print 'getting acl name' inst_name = pyccn.Name(str(co.content)) handler0.expressInterest(inst_name, self, interest_tmpl) elif co.name.components[len(co.name.components) - 2] == 'acl': print 'getting acl' if self.logger.acl == None: self.logger.acl = json.loads(co.content)['acl'] self.logger.start() else: #self.logger.lock.acquire() self.logger.acl = json.loads(co.content)['acl'] #self.logger.lock.release() kds_prefix = str(self.logger.prefix.append('kds')) kds_thread = kds.KDSPublisher( key, time_s, self.logger.kds_dsk, self.logger.kds_si, self.logger.anchor, self.logger.acl, kds_prefix) #,self.logger.lock) kds_thread.start() #I need to trigger the kds to fetch symkey######## #self.logger.join() elif kind == pyccn.UPCALL_INTEREST: interest = upcallInfo.Interest content = 'received' co = pyccn.ContentObject(name=interest.name, content=content, signed_info=pyccn.SignedInfo( ksk.publicKeyID, pyccn.KeyLocator( self.logger.ksk_name))) co.sign(ksk) handler0.put(co) inst_name = pyccn.Name('/local/manager' + self.device_prefix).append('acl') handler0.expressInterest(inst_name, self, interest_tmpl0) elif kind == pyccn.UPCALL_INTEREST_TIMED_OUT: return pyccn.RESULT_REEXPRESS return pyccn.RESULT_OK
def get_signed_info(self, freshness): ''' Get signed info to be included in the Content Object Args: freshness (int): the freshness of the Content Object in seconds Returns: a PyCCN.SignedInfo object ''' si = pyccn.SignedInfo() si.publisherPublicKeyDigest = self.ccnx_key.publicKeyID si.type = pyccn.CONTENT_DATA si.freshnessSeconds = freshness si.keyLocator = self.ccnx_key_locator return si
def publish(self, name, content): # Name co_name = name.appendSegment(0) # SignedInfo si = pyccn.SignedInfo() si.type = pyccn.CONTENT_DATA si.finalBlockID = pyccn.Name.num2seg(0) si.publisherPublicKeyDigest = self.key.publicKeyID si.keyLocator = self.keylocator # ContentObject co = pyccn.ContentObject() co.content = content co.name = co_name co.signedInfo = si co.sign(self.key) return co
def publish(self, name, content): # Name #print name # SignedInfo si = pyccn.SignedInfo() #si.type = pyccn.CCN_CONTENT_DATA si.type = 0x0C04C0 # content type si.finalBlockID = b'\x00' si.publisherPublicKeyDigest = self.key.publicKeyID si.keyLocator = self.keylocator si.freshnessSeconds = FRESHNESS_SECONDS # ContentObject co = ContentObject() co.content = content co.name = name co.signedInfo = si co.sign(self.key) return co
def publish(name, content): key = pyccn.CCN.getDefaultKey() keylocator = pyccn.KeyLocator(key) # Name co_name = pyccn.Name(name).appendSegment(0) # SignedInfo si = pyccn.SignedInfo() si.type = pyccn.CONTENT_DATA si.finalBlockID = pyccn.Name.num2seg(0) si.publisherPublicKeyDigest = key.publicKeyID si.keyLocator = keylocator # ContentObject co = pyccn.ContentObject() co.content = content co.name = co_name co.signedInfo = si co.sign(key) return co
import pyccn k = pyccn.CCN.getDefaultKey() co = pyccn.ContentObject() try: co.sign(k) except AttributeError: pass else: raise AssertionError("this should fail!") co.name = pyccn.Name("/foo/foo") co.signedInfo = pyccn.SignedInfo() co.signedInfo.publisherPublicKeyDigest = k.publicKeyID co.signedInfo.type = pyccn.CONTENT_DATA co.signedInfo.freshness = -1 co.content = "hello!" co.sign(k)
def upcall(self, kind, upcallInfo): if kind == pyccn.UPCALL_CONTENT or kind == pyccn.UPCALL_CONTENT_UNVERIFIED: co = upcallInfo.ContentObject print 'manager on data' print str(co.name) if co.name.components[len(co.name.components) - 1] == 'pubkey': device_name = co.name.components[len(co.name.components) - 3] serial = co.name.components[len(co.name.components) - 2] test = co.signedInfo.keyLocator.key.publicToDER() print 'publicToDER' print test prefix = self.cm.decoder(device_name, serial, co.content, test, 'data') if (prefix != None): keyname = pyccn.Name(prefix).appendVersion().appendKeyID( co.signedInfo.keyLocator.key) content = pyccn.ContentObject(name=keyname, content=test, signed_info=pyccn.SignedInfo( self.cm.key.publicKeyID, pyccn.KeyLocator( self.cm.keyname))) content.sign(self.cm.key) self.cm.publisher.put(content) print 'publish G\'s public key to repo' elif co.name.components[len(co.name.components) - 1] != 'acl': content = json.loads(co.content) userkey = pyccn.Key() userkey.fromDER(public=binascii.unhexlify(content['pubkey'])) userkey_co = pyccn.ContentObject() userkey_co.name = pyccn.Name(str( content['name'])).appendKeyID(userkey) userkey_co.content = binascii.unhexlify(content['pubkey']) userkey_co.signedInfo = pyccn.SignedInfo( self.cm.dsk.publicKeyID, pyccn.KeyLocator(self.cm.dskname), type=pyccn.CONTENT_KEY, final_block=b'\x00') userkey_co.sign(self.cm.dsk) self.cm.publisher.put(userkey_co) newuser = { 'usrname': str(userkey_co.name), 'prefix': content['data_prefix'] } self.cm.usrlist.append(newuser) self.cm.AddUser(newuser) #publish user's data point list device_prefix = [] name_t = pyccn.Name(str(content['name'])).components username = pyccn.Name(name_t[0:len(name_t) - 1]).append('acl').appendVersion() for prefix in content['data_prefix']: name_t = pyccn.Name(str(prefix)) if (len(name_t.components) > 5): name_t = pyccn.Name(name_t.components[0:5]) name_str = str(name_t) if ((name_str in self.cm.acl_tree) == True): self.cm.node = [] self.cm.find_device(name_str) for device_name in self.cm.node: index = self.cm.findbyprefix(device_name) flag = (device_name + '/data_points') in device_prefix if (index != -1 and flag == False): device_prefix.append(device_name + '/data_points') data_prefix = pyccn.ContentObject( name=username, content=json.dumps({'prefix': device_prefix}), signed_info=pyccn.SignedInfo( self.cm.key.publicKeyID, pyccn.KeyLocator(self.cm.keyname))) data_prefix.sign(self.cm.dsk) self.cm.publisher.put(data_prefix) print device_prefix print 'Publish Data Points' #elif co.name.components[len(co.name.components)-1]=='acl': #verify? elif kind == pyccn.UPCALL_INTEREST: interest = upcallInfo.Interest print 'manager on interest' print interest.name if interest.name.components[len(interest.name.components) - 1] == 'userreg': user_prefix = pyccn.Name( interest.name.components[2:len(interest.name.components) - 1]) print user_prefix handler.expressInterest(user_prefix, self, interest_tmpl) elif interest.name.components[len(interest.name.components) - 1] != 'acl': device_name = interest.name.components[ len(interest.name.components) - 3] serial = interest.name.components[len(interest.name.components) - 2] info = interest.name.components[len(interest.name.components) - 1] test = interest.name.components[2:len(interest.name.components ) - 1] test = str(pyccn.Name(test)) sendtxt = self.cm.decoder(device_name, serial, info, test, 'interest') print 'sendtxt:' print sendtxt if (sendtxt != -1): co = pyccn.ContentObject(name=interest.name, content=sendtxt, signed_info=pyccn.SignedInfo( self.cm.key.publicKeyID, pyccn.KeyLocator( self.cm.keyname))) co.sign(self.cm.key) handler.put(co) #express interest for pubkey with the prefix it receive as well as listen acl inst_name = pyccn.Name(test).append('pubkey') #dataclosure = ConfigClosure() handler.expressInterest(inst_name, self, interest_tmpl) print 'M express Interest' print inst_name else: device_name = interest.name.components[ len(interest.name.components) - 3] serial = interest.name.components[len(interest.name.components) - 2] index = self.cm.find(device_name, serial) if index != -1: acl_name = self.cm.device[index]['acl_name'] print 'acl_name:' + acl_name co = pyccn.ContentObject(name=interest.name, content=acl_name, signed_info=pyccn.SignedInfo( self.cm.key.publicKeyID, pyccn.KeyLocator( self.cm.keyname))) co.sign(self.cm.key) handler.put(co) #it's the acl interest asking elif kind == pyccn.UPCALL_INTEREST_TIMED_OUT: print 'Reexpress interest' return pyccn.RESULT_REEXPRESS return pyccn.RESULT_OK
publisher = RepoSocketPublisher(12345) for pair in keychain_config.keychain: signee_name = pair[0] signer_name = pair[1] signee_keyfile = keychain_config.keyfile_folder + keychain_config.keyfiles[ signee_name] signer_keyfile = keychain_config.keyfile_folder + keychain_config.keyfiles[ signer_name] signee_key = pyccn.Key() signee_key.fromPEM(filename=signee_keyfile) signer_key = pyccn.Key() signer_key.fromPEM(filename=signer_keyfile) signee_name = pyccn.Name(signee_name).appendKeyID(signee_key) signer_name = pyccn.Name(signer_name).appendKeyID(signer_key) key_co = pyccn.ContentObject() key_co.name = signee_name key_co.content = signee_key.publicToDER() key_co.signedInfo = pyccn.SignedInfo(signer_key.publicKeyID, pyccn.KeyLocator(signer_name), type=pyccn.CONTENT_KEY, final_block=b'\x00') key_co.sign(signer_key) publisher.put(key_co)
def run(self): #print "child thread started..." # For test purpose, run for 10 seconds only # Push content to repo every second global key, time_s i = 40 data_dsk_count = 1 kds_count = 0 kds_dsk_count = 1 point_count = 0 time_s = struct.pack("!Q", 0) point_con = pyccn.ContentObject() point_con.name = self.prefix.append('data_points') point_con.content = json.dumps({'datapoints': [str(self.data_prefix)] }) ################## point_con.signedInfo = self.data_si point_con.sign(self.data_dsk) self.publisher.put(point_con) print 'publish data points' print point_con.name while (True): # now = strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime()) now = int(time.time() * 1000000000) # in nanoseconds payload = {'ts': str(now), 'val': random.randint(0, 100)} if kds_count % 120 == 0: if kds_dsk_count % 2 == 0: self.kds_dsk = pyccn.Key() self.kds_dsk.generateRSA(1024) self.kds_dskname = self.prefix.append( "kds").appendVersion().appendKeyID(self.kds_dsk) self.kds_si = pyccn.SignedInfo( self.kds_dsk.publicKeyID, pyccn.KeyLocator(self.kds_dskname)) self.publish_dsk(self.kds_dsk, self.kds_dskname) print 'Publish kds DSK: ' + str(self.kds_dskname) kds_dsk_count = 0 kds_dsk_count = kds_dsk_count + 1 time_t = int(time.time() * 1000) time_s = struct.pack("!Q", time_t) key = Random.new().read(32) kds_prefix = str(self.prefix.append('kds')) kds_thread = kds.KDSPublisher(key, time_s, self.kds_dsk, self.kds_si, self.anchor, self.acl, kds_prefix) #, self.lock) kds_thread.start() kds_count = 0 kds_count = kds_count + 1 timestamp = struct.pack("!Q", int( int(payload['ts']) / 1000000)) # timestamp is in milliseconds co = pyccn.ContentObject() co.name = self.data_prefix.append(timestamp) iv = Random.new().read(AES.block_size) encryptor = AES.new(key, AES.MODE_CBC, iv) co.content = time_s + iv + encryptor.encrypt( pad(json.dumps(payload))) co.signedInfo = self.data_si co.sign(self.data_dsk) self.publisher.put(co) if data_dsk_count % 120 == 0: self.data_dsk = pyccn.Key() self.data_dsk.generateRSA(1024) self.data_dskname = self.prefix.append( 'data').appendVersion().appendKeyID(self.data_dsk) self.data_si = pyccn.SignedInfo( self.data_dsk.publicKeyID, pyccn.KeyLocator(self.data_dskname)) self.publish_dsk(self.data_dsk, self.data_dskname) print 'Publish data DSK: ' + str(self.data_dskname) data_dsk_count = 0 data_dsk_count = data_dsk_count + 1 time.sleep(self.interval / 1000.0) print "leave child thread"