def __init__ (self):
self.face = ndn.Face ()
self.dataReceived = False
self.timeoutReceived = False
self.face.expressInterest ("/forty/two", self.onData, self.onTimeout)
def run (self):
_LOG.info ('Daemon started')
self._ndns = ndns.ndns_session (self.data_dir)
self._face = ndn.Face ()
self._startZoneServing ()
self._eventLoop = ndn.EventLoop (self._face)
self._eventLoop.run ()
_LOG.info ('Daemon stopped')
def __init__(self, base_name, callback, handle=None, version=None, latest=True): handle = handle or ndn.Face() # some constants self.version_marker = '\xfd' self.first_version_marker = self.version_marker self.last_version_marker = '\xfe\x00\x00\x00\x00\x00\x00' self.base_name = ndn.Name(base_name) self.callback = callback self.handle = handle self.latest_version = version or self.first_version_marker self.start_with_latest = latest
def __init__(self, prefix, callback):
self.gui_callback = callback
self.friendly_names = {}
self.handle = ndn.Face()
self.chat_uri = ndn.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 __init__(self, prefix, nick=getpass.getuser()):
self.handle = ndn.Face()
self.flow = FlowController(prefix, self.handle)
#XXX: temporary, until we allow fetching key from key storage
self.key = self.handle.getDefaultKey()
self.keylocator = ndn.KeyLocator(self.key)
self.prefix = ndn.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 main(args):
if len(sys.argv) != 2:
usage()
name = ndn.Name(sys.argv[1])
data = ndnb_enumerate(generate_names())
key = ndn.Face.getDefaultKey()
name = name.append('\xc1.E.be').appendKeyID(key).appendVersion()
wrapper = Wrapper(name, key)
sgmtr = segmenter(data, wrapper)
handle = ndn.Face()
for seg in sgmtr:
handle.put(seg)
return 0
def verifyAsync(self, face, dataPacket, onVerify, limit_left=10):
"""
onVerify: callback <void, dataPacket, status>
"""
if limit_left <= 0:
onVerify(dataPacket, False)
return
if len(self.anchors) == 0:
onVerify(dataPacket, False)
return
if not face:
face = ndn.Face()
face.defer_verification(True)
data_name = dataPacket.name
key_name = dataPacket.signedInfo.keyLocator.keyName
try:
[key_data, ttl] = self.trustedCache[str(data_name)]
if time.time() > ttl:
del self.trustedCache[str(data_name)]
raise KeyError()
onVerify(dataPacket, True)
return
except KeyError:
pass
_LOG.debug("%s data [%s] signed by [%s]" %
('--' * (11 - limit_left), data_name, key_name))
anchor = self.authorize_by_anchor(data_name, key_name)
if anchor:
verified = dataPacket.verify_signature(anchor)
if verified:
_LOG.info("%s anchor OKs [%s] (**[%s]**)" %
('--' * (11 - limit_left), data_name, key_name))
else:
_LOG.info("%s anchor FAILs [%s]" %
('--' * (11 - limit_left), data_name))
onVerify(dataPacket, verified)
return
if not self.authorize_by_rule(data_name, key_name):
onVerify(dataPacket, False)
return
try:
[key, ttl] = self.trustedCache[str(key_name)]
if time.time() > ttl:
del self.trustedCache[str(key_name)]
raise KeyError()
_LOG.info("%s Using cached trusted version of key [%s]" %
('--' * (11 - limit_left), key_name))
onVerify(dataPacket, dataPacket.verify_signature(key))
return
except KeyError:
zone = ndn.Name()
for comp in key_name:
if comp == "DNS":
break
zone = zone.append(comp)
nextLevelProcessor = NextLevelProcessor(face, self, dataPacket,
onVerify, limit_left,
key_name)
if comp != "DNS":
face.expressInterest(key_name, nextLevelProcessor.onData,
nextLevelProcessor.onTimeout)
elif len(zone) == 0:
self.cachingQuery.expressQueryForRaw(
face,
nextLevelProcessor.onKeyData,
nextLevelProcessor.onError,
key_name,
hint=None,
parse_dns=False,
limit_left=limit_left - 1) #, verify = False)
else:
self.cachingQuery.expressQueryForZoneFh(
face,
nextLevelProcessor.onHintData,
nextLevelProcessor.onError,
zone,
verify=True)
# SignedInfo
si = ndn.SignedInfo()
si.type = ndn.CONTENT_DATA
si.finalBlockID = ndn.Name.num2seg(0)
si.publisherPublicKeyDigest = key.publicKeyID
si.keyLocator = keylocator
# ContentObject
co = ndn.ContentObject()
co.content = content
co.name = co_name
co.signedInfo = si
co.sign(key)
return co
def callback(kind, info):
print(info.ContentObject.content)
fc = FlowController("/test", ndn.Face())
fc.put(publish('/test/1', 'one'))
fc.put(publish('/test/2', 'two'))
fc.put(publish('/test/3', 'three'))
vp = VersionedPull("/chat", callback)
el = ndn.EventLoop(fc.handle, vp.handle)
while True:
vp.requestNext()
el.run_once()
time.sleep(1)
def __init__ (self):
self.face = ndn.Face ()
self.face.setInterestFilter ("/forty", self.onInterest)
def __init__(self, root, handle = None): self.root = ndn.Name(root) self.exclusions = ndn.ExclusionFilter() self.handle = handle or ndn.Face()
TrustPolicy = IdentityPolicy(anchors=[[
pyccn.Name(
"/ndn/keys/ucla.edu/alex/%C1.M.K%00F%8D%E9%C3%EE4%7F%C1Mjqro%C6L%8DGV%91%90%03%24%ECt%95n%F3%9E%A6i%F1%C9"
),
pyccn.Name("/"),
pyccn.Key.createFromPEM(public="""-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDSPdPM7+DjDcUGHtwEDmkq4kO5
tEUI05w5gR4JC1UiZxS0ckMWSLRPWXozHrpJsjNzDeI6OiQrXzup1tF2IN+Xtdr+
Pr3CwyBRloTJJbm5kf+pGuJh4fE9Qk0i/fS9Xs6gFup3oPnr+wFFjJObnRTrUsaM
8TQokOLYZFsatsZOvwIDAQAB
-----END PUBLIC KEY-----""")
]],
rules=[[
"^((/[^/]+)*)/DNS((/[^/]+)*)/[^/]+/NDNCERT$",
"\\1\\3"
]])
if (__name__ == '__main__'):
face = ndn.Face()
face.defer_verification(True)
def onVerify(data, status):
print status
def onData(interest, data):
TrustPolicy.verify(data, onVerify)
face.expressInterest("/ndn/DNS/test/A", onData)
def dig(args, out=None, cachingQuery=None, policy=None):
if out is None:
out = StringIO()
if policy is None:
policy = ndns.TrustPolicy
if cachingQuery is None:
cachingQuery = ndns.CachingQueryObj
if not isinstance(args.zone, ndn.Name):
zone = ndn.Name(args.zone)
else:
zone = args.zone
if args.simple:
if args.name:
if not args.ndn:
args.name = ndns.ndnify(args.name)
name = ndn.Name(args.name)
elif not args.raw:
sys.stderr.write(
"ERROR: For simple query, ``name'' (label) argument is mandatory\n"
)
exit(5)
face = ndn.Face()
loop = ndn.EventLoop(face)
needrun = True
def onResult(result, msg):
if args.no_output:
needrun = False
loop.stop()
return
if not args.quiet:
out.write(";; Got data packet [%s]\n" % result.name)
out.write(";; signed by [%s]\n" %
result.signedInfo.keyLocator.keyName)
out.write("\n")
out.write("%s\n" % msg.to_text())
else:
for rrset in msg.answer:
out.write("%s\n" % rrset.to_text())
needrun = False
loop.stop()
def onError(errmsg, *k, **kw):
if args.no_output:
needrun = False
loop.stop()
return
out.write(";; %s\n" % errmsg)
needrun = False
loop.stop()
def onPreResult(result, msg):
def _onVerify(data, status):
if status:
onResult(result, msg)
else:
onError("Got answer, but it cannot be verified")
if args.verify:
onResult(result, msg)
else:
policy.verifyAsync(face, result, _onVerify)
if args.simple:
if not args.raw:
cachingQuery.expressQueryFor(face,
onPreResult,
onError,
zone,
args.fh,
name,
args.rrtype,
verify=args.verify)
else:
cachingQuery.expressQueryForRaw(face,
onPreResult,
onError,
zone,
hint=args.fh,
verify=args.verify)
elif args.zone_fh_query:
cachingQuery.expressQueryForZoneFh(face, onPreResult, onError, zone,
args.verify)
else:
args.rrtype = args.name
cachingQuery.expressQuery(face, onPreResult, onError, zone,
args.rrtype, args.verify)
if needrun:
loop.run()
if isinstance(out, StringIO):
return out.getvalue()
def __init__(self, name, content):
self.handle = ndn.Face()
self.name = ndn.Name(name)
self.content = self.prepareContent(content,
self.handle.getDefaultKey())
