def test_build_proof(): sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64 with basing.openDB(name="sid") as sigDB, \ keeping.openKS(name="sid") as sigKS: sigHab = habbing.Habitat(ks=sigKS, db=sigDB, salt=sidSalt, icount=3, ncount=3, temp=True) sed = dict() sed["$id"] = "" sed["$schema"] = "http://json-schema.org/draft-07/schema#" sed.update(dict( type="object", properties=dict( id=dict( type="string" ), lei=dict( type="string" ) ) )) schemer = scheming.Schemer(sed=sed, typ=scheming.JSONSchema(), code=coring.MtrDex.Blake3_256) credSubject = dict( id="did:keri:Efaavv0oadfghasdfn443fhbyyr4v", # this needs to be generated from a KEL lei="254900OPPU84GM83MG36", issuanceDate="2021-06-27T21:26:21.233257+00:00", ) cache = CacheResolver() cache.add(schemer.said, schemer.raw) creder = credential(issuer=sigHab.pre, schema=schemer.said, subject=credSubject, typ=JSONSchema(resolver=cache)) sigHab.rotate() sigHab.rotate() sigHab.rotate() sigHab.rotate() prefixer = coring.Prefixer(qb64=sigHab.kever.prefixer.qb64) seqner = coring.Seqner(sn=sigHab.kever.lastEst.s) diger = coring.Diger(qb64=sigHab.kever.lastEst.d) sigers = sigHab.mgr.sign(ser=creder.raw, verfers=sigHab.kever.verfers, indexed=True) proof = buildProof(prefixer, seqner, diger, sigers) assert proof == ( b'-FABEiRjCnZfca8gUZqecerjGpjkiY8dIkGudP6GfapWi5MU0AAAAAAAAAAAAAAAAAAAAABAECc96yX1sYswnD6LXEcoNuJ0e' b'hi8gkFMEGedqURhXMBU-AADAAGcSUhma16SY3MiKU7n6mK3JzWS2oAiBRB-jeycIDrQ2Z-36QHrMorzRAO9Iw7FvIKrneaLZP' b'whz6DFFiXM4oBgAB1g2CudOfOFd9BqesyAIlCDRAkxAQynrED4_ot1MkhKwjmK71XUx1Xer25iWtHMa9sny07AsTO-KE3vu9e' b'qTPDQAClDQMXWg3I8qeVEjA6JA9xBW2uESMtMzNVQ8lH31UCizqYVjXort--QEJTsfIt_b0Qq1JOCtaj7Y6U-DWHoulBA') prefixer, seqner, diger, isigers = parseProof(proof) assert prefixer.qb64 == sigHab.pre assert diger.qb64 == sigHab.kever.lastEst.d assert seqner.sn == 4 assert len(isigers) == 3
def runAgent(controller, name="agent", httpPort=5620, tcp=5621, adminHttpPort=5623, adminTcpPort=5624, expire=0.0): """ Setup and run one agent """ logger = help.ogler.getLogger() ks = keeping.Keeper(name=name, temp=False) # not opened by default, doer opens ksDoer = keeping.KeeperDoer( keeper=ks) # doer do reopens if not opened and closes db = basing.Baser(name=name, temp=False, reload=True) # not opened by default, doer opens dbDoer = basing.BaserDoer( baser=db) # doer do reopens if not opened and closes # setup habitat hab = habbing.Habitat(name=name, ks=ks, db=db, temp=False, create=False) habDoer = habbing.HabitatDoer(habitat=hab) # setup doer # kvy = eventing.Kevery(db=hab.db, local=False) # setup doers server = tcpServing.Server(host="", port=tcp) tcpServerDoer = tcpServing.ServerDoer(server=server) directant = directing.Directant(hab=hab, server=server) wallet = walleting.Wallet(hab=hab, name=name) jsonSchema = scheming.JSONSchema(resolver=scheming.jsonSchemaCache) issueHandler = handling.IssueHandler(wallet=wallet, typ=jsonSchema) requestHandler = handling.RequestHandler(wallet=wallet, typ=jsonSchema) exchanger = exchanging.Exchanger(hab=hab, handlers=[issueHandler, requestHandler]) app = falcon.App() exnServer = httping.AgentExnServer(exc=exchanger, app=app) httpKelServer = httping.AgentKelServer(hab=hab, app=app) server = http.Server(port=httpPort, app=exnServer.app) httpServerDoer = http.ServerDoer(server=server) doers = [ ksDoer, dbDoer, habDoer, exchanger, directant, tcpServerDoer, exnServer, httpServerDoer, httpKelServer ] doers.extend(adminInterface(controller, hab, adminHttpPort, adminTcpPort)) try: tock = 0.03125 doist = doing.Doist(limit=expire, tock=tock, real=True) doist.do(doers=doers) except kering.ConfigurationError: print(f"prefix for {name} does not exist, incept must be run first", )
def setupController(secrets, witnessPort=5631, localPort=5629, indirect=False): """ Setup and return doers list to run controller """ secrecies = [] for secret in secrets: # convert secrets to secrecies secrecies.append([secret]) # setup habitat hab = habbing.Habitat(name="han", secrecies=secrecies, temp=True) logger.info( "\nDirect Mode demo of %s:\nNamed %s listening on TCP port %s, witness on TCP Port %s.\n\n", hab.pre, hab.name, localPort, witnessPort) wallet = walleting.Wallet(hab=hab, name="han") # setup doers ksDoer = keeping.KeeperDoer( keeper=hab.ks) # doer do reopens if not opened and closes dbDoer = basing.BaserDoer( baser=hab.db) # doer do reopens if not opened and closes pdbDoer = basing.BaserDoer( baser=wallet.db) # doer do reopens if not opened and closes path = os.path.dirname(__file__) path = os.path.join(path, 'logs') wl = wiring.WireLog(samed=True, filed=True, name="han", prefix='demo', reopen=True, headDirPath=path) wireDoer = wiring.WireLogDoer(wl=wl) jsonSchema = scheming.JSONSchema(resolver=scheming.jsonSchemaCache) issueHandler = handling.IssueHandler(wallet=wallet, typ=jsonSchema) requestHandler = handling.RequestHandler(wallet=wallet, typ=jsonSchema) witnessClient = clienting.Client(host='127.0.0.1', port=witnessPort, wl=wl) witnessClientDoer = clienting.ClientDoer(client=witnessClient) excDoer = exchanging.Exchanger(hab=hab, handlers=[issueHandler, requestHandler]) director = HanDirector(hab=hab, client=witnessClient, exchanger=excDoer, tock=0.125, wallet=wallet) reactor = directing.Reactor(hab=hab, client=witnessClient, indirect=indirect) server = serving.Server(host="", port=localPort) serverDoer = serving.ServerDoer(server=server) directant = directing.Directant(hab=hab, server=server, exchanger=excDoer) return [ ksDoer, dbDoer, pdbDoer, excDoer, wireDoer, witnessClientDoer, director, reactor, serverDoer, directant ]
def test_proving(): sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64 hanSalt = coring.Salter(raw=b'abcdef0123456789').qb64 vicSalt = coring.Salter(raw=b'fedcba9876543210').qb64 with basing.openDB(name="sid") as sidDB, \ keeping.openKS(name="sid") as sidKS, \ basing.openDB(name="vic") as vicDB, \ keeping.openKS(name="vic") as vicKS, \ basing.openDB(name="han") as hanDB, \ keeping.openKS(name="han") as hanKS, \ openPocket(name="han") as hanPDB: limit = 1.0 tock = 1.0 doist = doing.Doist(limit=limit, tock=tock) sidHab = habbing.Habitat(ks=sidKS, db=sidDB, salt=sidSalt, temp=True) assert sidHab.pre == "E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E" sidIcpMsg = sidHab.makeOwnInception() hanKvy = eventing.Kevery(db=hanDB) parsing.Parser().parse(ims=bytearray(sidIcpMsg), kvy=hanKvy) assert hanKvy.kevers[sidHab.pre].sn == 0 # accepted event hanHab = habbing.Habitat(ks=hanKS, db=hanDB, salt=hanSalt, temp=True) assert hanHab.pre == "EKDWzykRd45o5UQyprm_9e8UcltXGo1tZCrdfGBTA8tc" hanIcpMsg = hanHab.makeOwnInception() vicKvy = eventing.Kevery(db=vicDB) parsing.Parser().parse(ims=bytearray(hanIcpMsg), kvy=vicKvy) assert vicKvy.kevers[hanHab.pre].sn == 0 # accepted event vicHab = habbing.Habitat(ks=vicKS, db=vicDB, salt=vicSalt, temp=True) assert vicHab.pre == "E8HQASAgOnZnQ4T7rv3dcvj0-UydrTTtyCprhEASk__o" vicIcpMsg = vicHab.makeOwnInception() parsing.Parser().parse(ims=bytearray(vicIcpMsg), kvy=hanKvy) assert hanKvy.kevers[vicHab.pre].sn == 0 # accepted event sed = dict() sed["$id"] = "" sed["$schema"] = "http://json-schema.org/draft-07/schema#" sed.update( dict(type="object", properties=dict(id=dict(type="string"), lei=dict(type="string")))) schemer = scheming.Schemer(sed=sed, typ=scheming.JSONSchema(), code=coring.MtrDex.Blake3_256) cache = CacheResolver() cache.add(schemer.said, schemer.raw) jsonSchema = JSONSchema(resolver=cache) credSubject = dict( id= "did:keri:Efaavv0oadfghasdfn443fhbyyr4v", # this needs to be generated from a KEL lei="254900OPPU84GM83MG36", issuanceDate="2021-06-27T21:26:21.233257+00:00", ) creder = credential(issuer=sidHab.pre, schema=schemer.said, subject=credSubject, typ=JSONSchema(resolver=cache)) assert creder.said == "EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM" msg = sidHab.endorse(serder=creder) hanWallet = Wallet(hab=hanHab, db=hanPDB) parseCredential(ims=msg, wallet=hanWallet, typ=JSONSchema(resolver=cache)) # verify we can load serialized VC by SAID key = creder.said.encode("utf-8") assert hanPDB.getSers(key) is not None # Create Red's wallet and Issue Handler for receiving the credential hanRequestHandler = RequestHandler(wallet=hanWallet, typ=jsonSchema) hanExc = exchanging.Exchanger(hab=hanHab, tymth=doist.tymen(), handlers=[hanRequestHandler]) # Create the issue credential payload pl = dict(input_descriptors=[dict(x=schemer.said)]) # Create the `exn` message for presentation request vicExcSrdr = exchanging.exchange(route="/presentation/request", payload=pl) excMsg = vicHab.sanction(vicExcSrdr) # Parse the exn presentation request message on Han's side parsing.Parser().parse(ims=bytearray(excMsg), kvy=hanKvy, exc=hanExc) doist.do(doers=[hanExc]) assert doist.tyme == limit resp = hanRequestHandler.cues.popleft() assert resp is not None respSer = coring.Serder(raw=resp.raw) assert respSer.ked['t'] == coring.Ilks.exn assert respSer.ked['r'] == "/presentation/proof" data = respSer.ked['q'] assert "presentation_submission" in data pe = data["presentation_submission"] assert "descriptor_map" in pe dm = pe["descriptor_map"] assert len(dm) == 1 assert dm[0]["id"] == schemer.said assert "verifiableCredential" in data vcs = data["verifiableCredential"] assert len(vcs) == 1 proof = ( "-FABE4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E0AAAAAAAAAAAAAAAAAAAAAAAElHzHwX3V6itsD2Ksg_CNBbUNTBYzLYw" "-AxDNI7_ZmaI-AABAA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA" ) assert vcs[0]["proof"] == proof
def test_proving(): sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64 with basing.openDB(name="sid") as sidDB, \ keeping.openKS(name="sid") as sidKS: sidHab = habbing.Habitat(ks=sidKS, db=sidDB, salt=sidSalt, temp=True) assert sidHab.pre == "E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E" sed = dict() sed["$id"] = "" sed["$schema"] = "http://json-schema.org/draft-07/schema#" sed.update( dict(type="object", properties=dict(id=dict(type="string"), lei=dict(type="string")))) schemer = scheming.Schemer(sed=sed, typ=scheming.JSONSchema(), code=coring.MtrDex.Blake3_256) credSubject = dict( id= "did:keri:Efaavv0oadfghasdfn443fhbyyr4v", # this needs to be generated from a KEL lei="254900OPPU84GM83MG36", issuanceDate="2021-06-27T21:26:21.233257+00:00", ) cache = CacheResolver() cache.add(schemer.said, schemer.raw) creder = credential(issuer=sidHab.pre, schema=schemer.said, subject=credSubject, typ=JSONSchema(resolver=cache)) msg = sidHab.endorse(serder=creder) assert msg == ( b'{"v":"KERI10JSON000136_","i":"EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM",' b'"x":"EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY","ti":"E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E",' b'"d":{"id":"did:keri:Efaavv0oadfghasdfn443fhbyyr4v","lei":"254900OPPU84GM83MG36",' b'"issuanceDate":"2021-06-27T21:26:21.233257+00:00"}}-VA0-FABE4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE' b'-YfcI9E0AAAAAAAAAAAAAAAAAAAAAAAElHzHwX3V6itsD2Ksg_CNBbUNTBYzLYw-AxDNI7_ZmaI' b'-AABAA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA' ) creder = Credentialer(raw=msg, typ=JSONSchema(resolver=cache)) proof = msg[creder.size:] ctr = Counter(qb64b=proof, strip=True) assert ctr.code == CtrDex.AttachedMaterialQuadlets assert ctr.count == 52 pags = ctr.count * 4 assert len(proof) == pags ctr = Counter(qb64b=proof, strip=True) assert ctr.code == CtrDex.TransIndexedSigGroups assert ctr.count == 1 prefixer = Prefixer(qb64b=proof, strip=True) assert prefixer.qb64 == sidHab.pre seqner = Seqner(qb64b=proof, strip=True) assert seqner.sn == sidHab.kever.sn diger = Diger(qb64b=proof, strip=True) assert diger.qb64 == sidHab.kever.serder.dig ictr = Counter(qb64b=proof, strip=True) assert ictr.code == CtrDex.ControllerIdxSigs isigers = [] for i in range(ictr.count): isiger = Siger(qb64b=proof, strip=True) isiger.verfer = sidHab.kever.serder.verfers[i] isigers.append(isiger) assert len(isigers) == 1 siger = isigers[0] assert siger.verfer.verify(siger.raw, creder.raw) is True
def test_wallet(): sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64 with basing.openDB(name="sid") as sidDB, \ keeping.openKS(name="sid") as sidKS, \ openPocket(name="sid") as sidPDB: sidHab = habbing.Habitat(ks=sidKS, db=sidDB, salt=sidSalt, temp=True) assert sidHab.pre == "E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E" sed = dict() sed["$id"] = "" sed["$schema"] = "http://json-schema.org/draft-07/schema#" sed.update(dict( type="object", properties=dict( id=dict( type="string" ), lei=dict( type="string" ) ) )) schemer = scheming.Schemer(sed=sed, typ=scheming.JSONSchema(), code=coring.MtrDex.Blake3_256) credSubject = dict( id="did:keri:Efaavv0oadfghasdfn443fhbyyr4v", # this needs to be generated from a KEL lei="254900OPPU84GM83MG36", issuanceDate="2021-06-27T21:26:21.233257+00:00", ) cache = CacheResolver() cache.add(schemer.said, schemer.raw) creder = credential(issuer=sidHab.pre, schema=schemer.said, subject=credSubject, typ=JSONSchema(resolver=cache)) assert creder.said == "EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM" msg = sidHab.endorse(serder=creder) assert msg == ( b'{"v":"KERI10JSON000136_","i":"EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM",' b'"x":"EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY","ti":"E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E",' b'"d":{"id":"did:keri:Efaavv0oadfghasdfn443fhbyyr4v","lei":"254900OPPU84GM83MG36",' b'"issuanceDate":"2021-06-27T21:26:21.233257+00:00"}}-VA0-FABE4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE' b'-YfcI9E0AAAAAAAAAAAAAAAAAAAAAAAElHzHwX3V6itsD2Ksg_CNBbUNTBYzLYw-AxDNI7_ZmaI' b'-AABAA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA') ser = ( b'{"v":"KERI10JSON000136_","i":"EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM",' b'"x":"EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY","ti":"E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E",' b'"d":{"id":"did:keri:Efaavv0oadfghasdfn443fhbyyr4v","lei":"254900OPPU84GM83MG36",' b'"issuanceDate":"2021-06-27T21:26:21.233257+00:00"}}') seal = ( b'E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E0AAAAAAAAAAAAAAAAAAAAAAAElHzHwX3V6itsD2Ksg_CNBbUNTBYzLYw' b'-AxDNI7_ZmaI') sig0 = ( b'AA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA' ) sidWallet = Wallet(hab=sidHab, db=sidPDB) parseCredential(ims=msg, wallet=sidWallet, typ=JSONSchema(resolver=cache)) # verify we can load serialized VC by SAID key = creder.said.encode("utf-8") assert sidPDB.getSers(key) == ser # verify the signature sigs = sidPDB.getSigs(key) assert len(sigs) == 1 assert sigs[0] == sig0 # verify the seal sl = sidPDB.getSeals(key) assert sl == seal # verify we can look up credential by Schema SAID schema = sidPDB.getSchms(schemer.saider.qb64b) assert len(schema) == 1 assert schema[0] == key
def setupController(secrets, witnessPort=5621, peerPort=5629, indirect=False): """ Setup and return doers list to run controller """ name = "vic" secrecies = [] for secret in secrets: # convert secrets to secrecies secrecies.append([secret]) # setup databases for dependency injection ks = keeping.Keeper(name=name, temp=True) # not opened by default, doer opens ksDoer = keeping.KeeperDoer( keeper=ks) # doer do reopens if not opened and closes db = basing.Baser(name=name, temp=True) # not opened by default, doer opens dbDoer = basing.BaserDoer( baser=db) # doer do reopens if not opened and closes # setup habitat hab = habbing.Habitat(name=name, ks=ks, db=db, temp=True, secrecies=secrecies) habDoer = habbing.HabitatDoer(habitat=hab) # setup doer verifier = verifying.Verifier(name=name, hab=hab) regDoer = basing.BaserDoer(baser=verifier.reger) # setup wirelog to create test vectors path = os.path.dirname(__file__) path = os.path.join(path, 'logs') wl = wiring.WireLog(samed=True, filed=True, name=name, prefix='demo', reopen=True, headDirPath=path) wireDoer = wiring.WireLogDoer(wl=wl) witnessClient = clienting.Client(host='127.0.0.1', port=witnessPort, wl=wl) witnessClientDoer = clienting.ClientDoer(client=witnessClient) peerClient = clienting.Client(host='127.0.0.1', port=peerPort, wl=wl) peerClientDoer = clienting.ClientDoer(client=peerClient) jsonSchema = scheming.JSONSchema(resolver=scheming.jsonSchemaCache) proofs = decking.Deck() proofHandler = handling.ProofHandler(typ=jsonSchema, proofs=proofs) excDoer = exchanging.Exchanger(hab=hab, handlers=[proofHandler]) director = VicDirector(hab=hab, verifier=verifier, witnessClient=witnessClient, peerClient=peerClient, exchanger=excDoer, jsonSchema=jsonSchema, proofs=proofs, tock=0.125) witnessReactor = directing.Reactor(hab=hab, client=witnessClient, verifier=verifier, indirect=indirect) peerReactor = directing.Reactor(hab=hab, client=peerClient, verifier=verifier, indirect=indirect, exchanger=excDoer) logger.info("\nDirect Mode demo of %s:\nNamed %s to TCP port %s.\n\n", hab.pre, hab.name, witnessPort) return [ ksDoer, dbDoer, habDoer, regDoer, excDoer, wireDoer, witnessClientDoer, director, witnessReactor, peerClientDoer, peerReactor ]