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
]