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 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 prepareFramePacket(self, frame, segment):
name = self._name_frames.append(frame)
co = pyccn.ContentObject(name, segment, self._signed_info_frames)
co.sign(self._key)
return co
def prepareContent(self, content, key):
# create a new data packet
co = pyccn.ContentObject()
# since they want us to use versions and segments append those to our name
co.name = self.name.appendVersion().appendSegment(0)
# place the content
co.content = content
si = co.signedInfo
# key used to sign data (required by ccnx)
si.publisherPublicKeyDigest = key.publicKeyID
# how to obtain the key (required by ccn); here we attach the
# key to the data (not too secure), we could also provide name
# of the key under which it is stored in DER format
si.keyLocator = pyccn.KeyLocator(key)
# data type (not needed, since DATA is the default)
si.type = pyccn.CONTENT_DATA
# number of the last segment (0 - i.e. this is the only
# segment)
si.finalBlockID = pyccn.Name.num2seg(0)
# signing the packet
co.sign(key)
return co
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 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 make_content(name):
global key
co = pyccn.ContentObject()
co.name = pyccn.Name(name)
co.signedInfo.publisherPublicKeyDigest = key.publicKeyID
co.sign(key)
return co
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
#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 send_data(self, packet):
name = self._name_segments.appendSegment(self._segment)
self._segment += 1
# Make sure the timestamp is regenerated
self._signed_info.ccn_data_dirty = True
co = pyccn.ContentObject(name, packet, self._signed_info)
co.sign(self._key)
self.publisher.put(co)
def prepare_frame_packet(self, frame, segment):
name = self._name_frames.append(frame)
# Make sure the timestamp is regenerated
self._signed_info_frames.ccn_data_dirty = True
co = pyccn.ContentObject(name, segment, self._signed_info_frames)
co.sign(self._key)
return co
def prepare_stream_info_packet(self, caps):
name = self._basename.append("stream_info")
# Make sure the timestamp is regenerated
self._signed_info.ccn_data_dirty = True
co = pyccn.ContentObject(name, self._caps, self._signed_info)
co.sign(self._key)
return co
def preparePacket(self, segment, left, data):
name = self._name_segments.appendSegment(segment)
#print("preparing %s" % name)
packet = utils.buffer2packet(left, data)
co = pyccn.ContentObject(name, packet, self._signed_info)
co.sign(self._key)
return co
def __call__(self, chunk, segment, segments):
name = self.name + pyccn.Name.num2seg(segment)
self.signed_info.finalBlockID = pyccn.Name.num2seg(segments - 1)
co = pyccn.ContentObject(name=name,
content=chunk,
signed_info=self.signed_info)
co.sign(self.key)
return co
def publish_stream_info(self, pad, args):
if self._caps:
return
self._caps = pad.get_negotiated_caps()
name = self._basename.append("stream_info")
print "Publishing %s under %s" % (self._caps, name)
co = pyccn.ContentObject(name, self._caps, self._signed_info)
co.sign(self._key)
self._flow_controller.put(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 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(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
def upcall(self, kind, upcallInfo):
global flag_terminate
if kind == pyccn.UPCALL_CONTENT or kind == pyccn.UPCALL_CONTENT_UNVERIFIED:
co = upcallInfo.ContentObject
print "kds on data"
print co.name
keylocator = str(co.signedInfo.keyLocator.keyName)
anchor_pubkey = self.authorize_by_anchor(str(co.name), keylocator)
if anchor_pubkey != None:
root_key = pyccn.Key()
root_key.fromPEM(public=anchor_pubkey)
flag = co.verify_signature(root_key)
while flag == True and len(self.stack) > 0:
key = pyccn.Key()
key.fromDER(public=co.content)
flag = self.stack[len(self.stack) -
1].verify_signature(key)
co = self.stack.pop()
if len(self.stack) == 0:
usrpubkey = co.content
print usrpubkey
#publish
usrkey = pyccn.Key()
usrkey.fromDER(public=usrpubkey)
key_t = RSA.importKey(usrpubkey)
cipher = PKCS1_v1_5.new(key_t)
ciphertext = cipher.encrypt(self.symkey)
userdataname = self.prefix.append(
self.timestamp).appendKeyID(usrkey)
CO = pyccn.ContentObject(name=userdataname,
content=ciphertext,
signed_info=self.kds_si)
CO.sign(self.kds_key)
self.publisher.put(CO)
print CO.name
self.index = self.index + 1
if self.index < len(self.acl):
nextname = pyccn.Name(str(self.acl[self.index]))
handler.expressInterest(nextname, self, interest_tmpl)
else:
#print "overrrrrrrrrr"
flag_terminate = 1
#print flag_terminate
elif self.authorize_by_rule(str(co.name), keylocator) == True:
self.stack.append(co)
handler.expressInterest(pyccn.Name(keylocator), self,
interest_tmpl)
else:
print "verification failed"
flag_terminate = 1
elif kind == pyccn.UPCALL_INTEREST_TIMED_OUT:
return pyccn.RESULT_REEXPRESS
return pyccn.RESULT_OK
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"
