def upcall(self, kind, upcallInfo): if kind == pyccn.UPCALL_CONTENT or kind == pyccn.UPCALL_CONTENT_UNVERIFIED: print 'G on data' co = upcallInfo.ContentObject device_prefix = co.content.strip( ' \t\n\r') + '/device/siemens/' + serial #how to append serial #register prefix device_name print device_prefix InterestBaseName = pyccn.Name(device_prefix).append('pubkey') configclosure = ConfigClosure(device_prefix) ################### handler0.setInterestFilter(InterestBaseName, configclosure) m = hashlib.sha256() m.update(symkey) m.update(device_prefix) #iv = Random.new().read(AES.block_size) #cipher = AES.new(symkey, AES.MODE_CBC, iv) #ciphertext = cipher.encrypt(pad(m.hexdigest())) instname = pyccn.Name('/local/manager' + device_prefix).append( m.hexdigest()) #configclosure1 = ConfigClosure() handler0.expressInterest(instname, configclosure, interest_tmpl0) elif kind == pyccn.UPCALL_INTEREST_TIMED_OUT: print 'interest time out' return pyccn.RESULT_REEXPRESS return pyccn.RESULT_OK
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 getLatestVersion(self, name): try: return self.m_keyCache[str(name)] except: pass base_len = len(name) excludeList = [] version = 0 co = None while True: interestName = pyccn.Name(name) exclude1 = pyccn.ExclusionFilter() exclude1.add_names([pyccn.Name().append(n) for n in excludeList]) interest_tmpl = pyccn.Interest(exclude=exclude1, interestLifetime=self.args.timeout, minSuffixComponents=1, maxSuffixComponents=100, scope=self.args.scope) class Slurp(pyccn.Closure): def __init__(self): self.finished = False self.done = False def upcall(self, kind, upcallInfo): if kind == pyccn.UPCALL_CONTENT or kind == pyccn.UPCALL_CONTENT_UNVERIFIED: self.co = upcallInfo.ContentObject if len(self.co.name) == base_len: self.done = True else: excludeList.append(self.co.name[base_len]) elif kind == pyccn.UPCALL_INTEREST_TIMED_OUT: self.done = True self.finished = True return pyccn.RESULT_OK slurp = Slurp() self.ccn.expressInterest(interestName, slurp, interest_tmpl) while not slurp.finished: # print slurp.finished self.ccn.run(1) if slurp.done: # print "Done with %s" % interestName break try: newversion = pyccn.Name.seg2num(slurp.co.name[len(name)]) if newversion > version: version = newversion co = slurp.co except: print "ERROR: Unversioned content object: %s" % interestName return None self.m_keyCache[str(name)] = co return co
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 GenerateAcl(self): j = 0 for device in self.device: k = 3 name_t = pyccn.Name(device['prefix']) while (k <= len(name_t.components)): temp = str(pyccn.Name(name_t.components[0:k])) if ((temp in self.acl_tree) == True): for acl_t in self.acl_tree[temp]['acl']: self.device[j]['acl'].append(acl_t) k = k + 1 j = j + 1
def FormAclTree(self): self.acl_tree = dict([('/ndn/ucla.edu/bms',{'acl':[],'child':['/ndn/ucla.edu/bms/melnitz','/ndn/ucla.edu/bms/boelter']}), \ ('/ndn/ucla.edu/bms/melnitz',{'acl':[],'child':['/ndn/ucla.edu/bms/melnitz/1405']}), \ ('/ndn/ucla.edu/bms/boelter',{'acl':[],'child':['/ndn/ucla.edu/bms/boelter/4805','/ndn/ucla.edu/bms/boelter/4809']}), \ ('/ndn/ucla.edu/bms/melnitz/1405',{'acl':[],'child':[]}), \ ('/ndn/ucla.edu/bms/boelter/4805',{'acl':[],'child':[]}), \ ('/ndn/ucla.edu/bms/boelter/4809',{'acl':[],'child':[]})]) for usr in usrlist: for prefix in usr['prefix']: name_t = pyccn.Name(prefix) if (len(name_t.components) > 5): name_t = pyccn.Name(name_t.components[0:5]) if ((str(name_t) in self.acl_tree) == True): self.acl_tree[str(name_t)]['acl'].append(usr['usrname'])
def build_interest(self, latest): if self.start_with_latest: latest = True self.start_with_latest = False excl = pyccn.ExclusionFilter() excl.add_any() excl.add_name(pyccn.Name([self.latest_version])) # expected result should be between those two names excl.add_name(pyccn.Name([self.last_version_marker])) excl.add_any() interest = pyccn.Interest(name = self.base_name, exclude = excl, \ minSuffixComponents = 3, maxSuffixComponents = 3) interest.childSelector = 1 if latest else 0 return interest
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 fetch_seek_query(self, ns): index = self.ts2index_add_1(ns) #debug(self, "Fetching segment number before %s" % index) interest = pyccn.Interest(publisherPublicKeyDigest=self.publisher_id, childSelector=1, answerOriginKind=pyccn.AOK_NONE) interest.exclude = pyccn.ExclusionFilter() interest.exclude.add_name(pyccn.Name([index])) interest.exclude.add_any() #debug(self, "Sending interest to %s" % self._name_frames) #debug(self, "Exclusion list %s" % interest.exclude) while True: co = self._get_handle.get(self._name_frames, interest) if co: break debug(self, "Timeout while seeking %d, retrying ..." % (ns)) debug(self, "Got segment: %s" % co.content) index = co.name[-1] segment = int(co.content) return (self.index2ts(index), segment)
def AddUser(self, user): for prefix in user['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.acl_tree[name_str]['acl'].append(user['usrname']) #len_name = len(name_t.components) self.node = [] self.find_device(name_str) for device_name in self.node: index = self.findbyprefix(device_name) if (index != -1): self.device[index]['acl'].append(user['usrname']) self.update_acl(index)
def __init__(self, prefix, handle): self.prefix = pyccn.Name(prefix) self.handle = handle self.content_objects = [] self.cleanup_time = 15 * 60 # keep responses for 15 min handle.setInterestFilter(self.prefix, self)
def __init__(self, acl, key, timestamp, dsk, dsk_si, anchor, prefix): self.kds_key = dsk self.kds_si = dsk_si self.prefix = pyccn.Name(prefix) self.symkey = key self.acl = acl self.index = 0 self.timestamp = timestamp self.publisher = RepoSocketPublisher(12345) self.anchors = anchor #self.acl = acl print 'acl' print acl #[{'name':'/ndn/ucla.edu/bms/%C1.M.K%00%03a%27%95_%7C%1F%CD%C0E%2B54%00%87%AC%84r%DBg%83%07%5D%F9%03%02p%DB%A9%B8%06%B4','namespace': '/ndn/ucla.edu/bms', 'pubkey': \ # '0\x81\x9f0\r\x06\t*\x86H\x86\xf7\r\x01\x01\x01\x05\x00\x03\x81\x8d\x000\x81\x89\x02\x81\x81\x00\xd8\xe8\xa76\xbe|\x99\x1f\x0eO\x8e\xbel\xc1\xed\xfd-p\x8b>\xb1\x0f-\x1b\xf7z#j\xba\x9c\x0c\xa0\x9bh\x08\xfbg\xab\x89\xc7\xb5\xc5\xdb\xde\x90H\xee(F\x17\x86\xaf\xd6O\x12`\x00\xd2)n\x95\x14IV\x1e\xa6\xf4+\xa4\xed1z\x801\x1d\x7f\xbe\xcf3\xd3\xbc\xa7\x83\xda\xe6\x13~\x1e\xc3\xb6\x86\xae\xc96\x16\x8e":c\xa4eg\x11\x85\xa2\xff\xae\xa1\xe4\xc6s28W3\'S.\x87\xc5\x94\'\xf7\x90\xa9\x888c\x02\x03\x01\x00\x01' \ #}] self.rules = [ #rule for 'users' sub-namespace { 'key_pat': re.compile("^(/ndn/ucla.edu/bms/users)/%C1.M.K[^/]+$"), 'key_pat_ext': 0, 'data_pat': re.compile("^(/ndn/ucla.edu/bms/users(?:/[^/]+)*)$"), 'data_pat_ext': 0 } ] self.stack = []
def __init__(self, uri): self._handle = pyccn.CCN() self._get_handle = pyccn.CCN() self._uri = pyccn.Name(uri) self._name_segments = self._uri.append('segments') self._name_frames = self._uri.append('frames') self._pipeline = utils.PipelineFetch(100, self.issue_interest, self.handle_data)
def packet(name, data, key): co = pyccn.ContentObject() co.name = pyccn.Name(name) co.content = data co.signedInfo.publisherPublicKeyDigest = key.publicKeyID co.signedInfo.keyLocator = pyccn.KeyLocator(key) co.sign(key) return co
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 make_content(name): global key co = pyccn.ContentObject() co.name = pyccn.Name(name) co.signedInfo.publisherPublicKeyDigest = key.publicKeyID co.sign(key) return co
def upcall(self, kind, upcallInfo): if kind == pyccn.UPCALL_FINAL: # any cleanup code here (so far I never had need for # this call type) return pyccn.RESULT_OK if kind == pyccn.UPCALL_INTEREST_TIMED_OUT: print("Got timeout!") return pyccn.RESULT_OK # make sure we're getting sane responses if not kind in [ pyccn.UPCALL_CONTENT, pyccn.UPCALL_CONTENT_UNVERIFIED, pyccn.UPCALL_CONTENT_BAD ]: print("Received invalid kind type: %d" % kind) sys.exit(100) matched_comps = upcallInfo.matchedComps response_name = upcallInfo.ContentObject.name org_prefix = response_name[:matched_comps] assert (org_prefix == self.root) if matched_comps == len(response_name): comp = pyccn.Name([upcallInfo.ContentObject.digest()]) disp_name = pyccn.Name(response_name) else: comp = response_name[matched_comps:matched_comps + 1] disp_name = response_name[:matched_comps + 1] if kind == pyccn.UPCALL_CONTENT_BAD: print("*** VERIFICATION FAILURE *** %s" % response_name) print("%s [%s]" % (disp_name, \ "verified" if kind == pyccn.UPCALL_CONTENT else "unverified")) self.exclusions.add_name(comp) self.express_my_interest() # explore next level if matched_comps + 1 < len(response_name): new = Slurp(response_name[:matched_comps + 1], self.handle) new.express_my_interest() return pyccn.RESULT_OK
def check_duration(self): interest = pyccn.Interest(childSelector=1) if self._duration_last: interest.exclude = pyccn.ExclusionFilter() interest.exclude.add_any() interest.exclude.add_name(pyccn.Name([self._duration_last])) self._handle.expressInterest(self._name_frames, self._duration_callback, interest)
def get_latest_version(name): n = pyccn.Name(name) i = pyccn.Interest(childSelector=1, answerOriginKind=pyccn.AOK_NONE) handle = pyccn.CCN() co = handle.get(n, i) if co is None: return None return co.name[:len(n) + 1]
def put(self, content): name = str(self._sequence) self._sequence += 1 of = open(os.path.join(self.import_loc, name), "wb") of.write(_pyccn.dump_charbuf(content.ccn_data)) of.close() self.handle.expressInterest(pyccn.Name(self.name + name), self, self.interest_tpl)
def __init__(self, uri, window=None, retries=None): # size of the pipeline window = window or 1 # how many times to retry request self.interest_retries = retries or 1 # maximum number of buffers we can hold in memory waiting to be processed self.queue = Queue.Queue(window * 2) # duration of the stream (in nanoseconds) self.duration_ns = None # interest timeout self.interest_lifetime = None # whether fetching thread is running self._running = False # caps of the stream self._caps = None # timestamp of the remote machine self._start_time = None self._seek_segment = None self._duration_last = None self._cmd_q = Queue.Queue(2) self._handle = pyccn.CCN() self._get_handle = pyccn.CCN() self._uri = pyccn.Name(uri) self._name_segments = self._uri + 'segments' self._name_frames = self._uri + 'index' self._pipeline = utils.PipelineFetch(window, self.issue_interest, self.process_response) self._segmenter = DataSegmenter(self.push_data) self._stats = { 'srtt': 0.05, 'rttvar': 0.01 \ } self._stats_retries = 0 self._stats_drops = 0 self._timing_clock_diff = None self._timing_pause_diff = 0 self._tmp_retry_requests = {} DurationChecker = type('DurationChecker', (pyccn.Closure, ), dict(upcall=self.duration_process_result)) self._duration_callback = DurationChecker()
def decoder(self, device_name, serial, code, test, flag): #decoding using the symkey k = 0 for info in self.device: if (info['name'] == device_name and info['serial'] == serial): #iv0 = code[0:16] #print iv0 #decipher = AES.new(info['symkey'], AES.MODE_CBC, iv0) #text = unpad(decipher.decrypt(code[16:len(code)])) m = hashlib.sha256() m.update(info['symkey']) m.update(test) digest = m.hexdigest() if code == digest: if flag == 'interest' and self.device[k][ 'loc_name'] == None: self.device[k]['loc_name'] = test content = { 'acl_name': info['acl_name'], 'prefix': info['prefix'], 'trust_anchor': [{ 'name': str(self.keyname), 'namespace': str( pyccn.Name(self.keyname.components[ 0:len(self.keyname.components) - 1])), 'pubkey': str(self.key.publicToPEM()) }] } print content txt = json.dumps(content) #iv = Random.new().read(AES.block_size) m = hashlib.sha256() m.update(info['symkey']) m.update(txt) #cipher = AES.new(info['symkey'], AES.MODE_CBC, iv) #ciphertxt = cipher.encrypt(pad(m.hexdigest())) sendtxt = json.dumps({ 'uncripted': txt, 'ciphertxt': m.hexdigest() }) return sendtxt elif flag == 'data' and self.device[k]['pubkey'] == None: self.device[k]['pubkey'] = test return info['prefix'] else: print "decode failure" return None k = k + 1 return None
def __init__(self): self.key = pyccn.Key() self.key.fromPEM(filename='./keychain/keys/bms_root.pem') self.keyname = pyccn.Name('/ndn/ucla.edu/bms').appendKeyID(self.key) self.publisher = RepoSocketPublisher(12345) self.device = device self.usrlist = usrlist self.acl_count = 1 self.acl_tree = None self.FormAclTree() self.GenerateAcl() self.dsk = pyccn.Key() self.dsk.fromPEM(filename='./keychain/keys/user_root.pem') self.dskname = pyccn.Name('/ndn/ucla.edu/bms/users').appendKeyID( self.dsk) i = 0 while i < len(self.device): #add version self.device[i]['acl_name'] = str( pyccn.Name(self.device[i]['acl_name']).appendVersion()) i = i + 1
def authorizeKey(self, dataName, keyName): if len(keyName) < 1: return { "authorized": False, "formattedName": "%s%s: %s%s" % (bcolors.FAIL, "Invalid key name", str(keyName), bcolors.ENDC) } if len(dataName) <= len(keyName) - 1: return { "authorized": False, "formattedName": "%s%s: %s%s" % (bcolors.FAIL, "Invalid key name", str(keyName), bcolors.ENDC) } keyBase = str(keyName[:-1]) dataBase = str( dataName[0:len(keyName) - 1] ) # this has to be this way (it's keyName length, not dataName length) if keyBase == dataBase: return { "authorized": True, "formattedName": "%s[AUTH KEY]%s %s%s%s%s" % (bcolors.OKBLUE, bcolors.ENDC, bcolors.OKGREEN, keyBase, bcolors.ENDC, str(pyccn.Name().append(keyName[-1]))) } else: return { "authorized": False, "formattedName": "%s[WRONG KEY] %s%s%s" % (bcolors.FAIL, keyBase, bcolors.ENDC, str(pyccn.Name().append(keyName[-1]))) }
def get_latest_version(name, publisher_id): n = pyccn.Name(name) i = pyccn.Interest(publisherPublicKeyDigest=publisher_id, childSelector=1, answerOriginKind=pyccn.AOK_NONE) handle = pyccn.CCN() co = handle.get(n, i) if co is None: return None, None return co.name[:len(n) + 1], co.signedInfo.publisherPublicKeyDigest
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 __init__(self, prefix, callback): self.gui_callback = callback self.friendly_names = {} self.handle = pyccn.CCN() self.chat_uri = pyccn.Name(prefix) self.members_uri = self.chat_uri + "members" self.net_pull = VersionedPull(self.chat_uri, None, handle=self.handle) self.default_key = self.handle.getDefaultKey() digest = fix_digest(self.default_key.publicKeyID) self.friendly_names[digest] = getpass.getuser()
def main(args): gobject.threads_init() if len(args) not in [3, 4]: usage(args[0]) return 1 uri = pyccn.Name(args[1]) mode = [] mode += args[2] pidfile = "publish.pid" if len(args) == 3 else args[3] uri = uri.appendVersion() video_pipe = """v4l2src device=%s ! video/x-raw-yuv,width=%d,height=%d ! aspectratiocrop aspect-ratio=4/3 ! deinterlace mode=1 method=4 fields=top ! videorate ! timeoverlay shaded-background=true valignment=bottom ! \ clockoverlay shaded-background=true halignment=right valignment=bottom ! x264enc byte-stream=true bitrate=%d qp-max=30 interlaced=true ! VideoSink location=%s""" audio_pipe = "autoaudiosrc ! lamemp3enc bitrate=%d ! AudioSink location=%s" pipes = {} pipes['a'] = audio_pipe % (128, uri + "audio") pipes['v'] = video_pipe % ("/dev/video0", 704, 480, 1024, uri + "video") pipes['1'] = video_pipe % ("/dev/video1", 352, 240, 256, uri + "video1") pipes['2'] = video_pipe % ("/dev/video2", 352, 240, 256, uri + "video2") pipes['3'] = video_pipe % ("/dev/video3", 352, 240, 256, uri + "video3") pipes['4'] = video_pipe % ("/dev/video4", 352, 240, 256, uri + "video4") p = [] for m in mode: p.append(pipes[m]) of = open(pidfile, "w") of.write(str(os.getpid())) of.close() pipeline = gst.parse_launch(" ".join(p)) loop = gobject.MainLoop() pipeline.set_state(gst.STATE_PLAYING) try: loop.run() except KeyboardInterrupt: print "Ctrl+C pressed; exiting" pass pipeline.set_state(gst.STATE_NULL) pipeline.get_state(gst.CLOCK_TIME_NONE)
def __init__(self, prefix, nick=getpass.getuser()): self.handle = pyccn.CCN() self.flow = FlowController(prefix, self.handle) #XXX: temporary, until we allow fetching key from key storage self.key = self.handle.getDefaultKey() self.keylocator = pyccn.KeyLocator(self.key) self.prefix = pyccn.Name(prefix) self.members_uri = self.prefix + "members" member_name = self.members_uri.appendKeyID( fix_digest(self.key.publicKeyID)) self.member_message = self.publish(member_name, nick) self.flow.put(self.member_message)
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")