async def testNoPredicates(prover1, prover2, verifier, allClaims):
proofRequest = ProofRequest("proof1", "1.0", verifier.generateNonce(),
verifiableAttributes={'attr_uuid1': AttributeInfo(name='name'),
'attr_uuid2': AttributeInfo(name='name')})
assert await presentProofAndVerify(verifier, proofRequest, prover1)
assert await presentProofAndVerify(verifier, proofRequest, prover2)
async def testMultipledRevealed(prover1, allClaims, schemaGvtId, schemaXyzId,
attrRepo, schemaGvt):
proofRequest = ProofRequest("proof1",
"1.0",
1,
verifiableAttributes={
'attr_uuid1': AttributeInfo(name='status'),
'attr_uuid2': AttributeInfo(name='name')
})
claimsGvt = await prover1.wallet.getClaimSignature(schemaGvtId)
claimsXyz = await prover1.wallet.getClaimSignature(schemaXyzId)
proofClaims = {
schemaGvt.seqId: ProofClaims(claimsGvt, ['name'], []),
schemaGvt.seqId: ProofClaims(claimsXyz, ['status'], [])
}
attr1 = attrRepo.getAttributes(schemaXyzId.schemaKey,
prover1.proverId)['status']
attr2 = attrRepo.getAttributes(schemaGvtId.schemaKey,
prover1.proverId)['name']
requestedProof = RequestedProof(
revealed_attrs={
'attr_uuid1': [schemaGvt.seqId, attr1,
str(encodeAttr(attr1))],
'attr_uuid2': [schemaGvt.seqId, attr2,
str(encodeAttr(attr2))]
})
assert proofClaims, requestedProof == await prover1._findClaims(
proofRequest)
async def testAttrNotFound(prover1, allClaims):
proofRequest = ProofRequest("proof1",
"1.0",
1,
verifiableAttributes={
'attr_uuid1': AttributeInfo(name='name'),
'attr_uuid2': AttributeInfo(name='aaa')
})
with pytest.raises(ValueError):
await prover1._findClaims(proofRequest)
async def testGePredicate(prover1, prover2, verifier, allClaims):
proofRequest = ProofRequest("proof1", "1.0", verifier.generateNonce(),
verifiableAttributes={'attr_uuid1': AttributeInfo(name='name')},
predicates={'predicate_uuid1': PredicateGE('age', 18),
'predicate_uuid2': PredicateGE('period', 3)})
assert await presentProofAndVerify(verifier, proofRequest, prover1)
assert await presentProofAndVerify(verifier, proofRequest, prover2)
async def create_proof_request(conn):
# 1. Init entities
public_repo = PublicRepoInMemory()
attr_repo = AttributeRepoInMemory()
issuer = Issuer(IssuerWalletInMemory('issuer1', public_repo), attr_repo)
# 2. Create a Schema
schema = await issuer.genSchema('GVT', '1.0', GVT.attribNames())
schema_id = ID(schema.getKey())
# 3. Create keys for the Schema
global global_dict
await issuer.wallet.submitPublicKeys(schema_id, global_dict['public_key'])
# 4. set attributes for user1
prover_id = 'BzfFCYk'
attributes = GVT.attribs(name='Alex', age=28, height=175, sex='male')
attr_repo.addAttributes(schema.getKey(), prover_id, attributes)
verifier = Verifier(WalletInMemory('verifier1', public_repo))
proof_request = ProofRequest(
name='Test_proof', version='1.0',
nonce=verifier.generateNonce(),
verifiableAttributes={
'attr_uuid': AttributeInfo('name', schema.seqId)},
predicates={'predicate_uuid': PredicateGE('age', 18)})
global_dict['verifier'] = verifier
global_dict['proof_request'] = proof_request
conn.send(json.dumps(proof_request.to_str_dict()).encode())
async def testOneRevealedFromSpecificSchemaAndIssuer(prover1, allClaims,
schemaGvt, schemaGvtId,
attrRepo, keysGvt):
proofRequest = ProofRequest("proof1",
"1.0",
1,
verifiableAttributes={
'uuid':
AttributeInfo(
name='name',
schema_seq_no=schemaGvt.seqId,
issuer_did=schemaGvt.issuerId)
})
claimsGvt = await prover1.wallet.getClaimSignature(schemaGvtId)
proofClaims = {schemaGvt.seqId: ProofClaims(claimsGvt, ['name'], [])}
attr = attrRepo.getAttributes(schemaGvtId.schemaKey,
prover1.proverId)['name']
requestedProof = RequestedProof(revealed_attrs={
'uuid': [str(schemaGvt.seqId), attr,
str(encodeAttr(attr))]
})
assert proofClaims, requestedProof == await prover1._findClaims(
proofRequest)
assert proofClaims, requestedProof == await prover1._findClaims(
proofRequest)
async def testRevealedAndPredicateDifferentIssuers(prover1, allClaims,
schemaGvtId, schemaXyzId,
attrRepo, schemaGvt):
proofRequest = ProofRequest(
"proof1",
"1.0",
1,
verifiableAttributes={'attr_uuid': AttributeInfo(name='status')},
predicates={'predicate_uuid': PredicateGE('age', 18)})
claimsGvt = await prover1.wallet.getClaimSignature(schemaGvtId)
claimsXyz = await prover1.wallet.getClaimSignature(schemaXyzId)
proofClaims = {
schemaGvt.seqId: ProofClaims(claimsGvt, [], [PredicateGE('age', 18)]),
schemaGvt.seqId: ProofClaims(claimsXyz, ['status'], [])
}
attr = attrRepo.getAttributes(schemaXyzId.schemaKey,
prover1.proverId)['status']
requestedProof = RequestedProof(
revealed_attrs={
'attr_uuid': [schemaGvt.seqId, attr,
str(encodeAttr(attr))]
},
predicates={'predicate_uuid': schemaGvt.seqId})
assert proofClaims, requestedProof == await prover1._findClaims(
proofRequest)
async def doTestAnonCredsPrimaryOnly():
# 1. Create a Schema
schema = await issuer.genSchema('GVT', '1.0', GVT.attribNames())
schemaId = ID(schemaKey=schema.getKey(), schemaId=schema.seqId)
# 2. Create keys for the Schema
await issuer.genKeys(schemaId, **primes1)
# 3. Issue accumulator
#TODO: Not implemented yet
#await issuer.issueAccumulator(schemaId=schemaId, iA='110', L=5)
# 4. set attributes for user1
attrs = GVT.attribs(name='Alex', age=28, height=175, sex='male')
proverId = str(prover.proverId)
attrRepo.addAttributes(schema.getKey(), proverId, attrs)
# 5. request Claims
claimsReq = await prover.createClaimRequest(schemaId, proverId, False)
(signature, claims) = await issuer.issueClaim(schemaId, claimsReq)
await prover.processClaim(schemaId, claims, signature)
# 6. proof Claims
proofInput = ProofInput(
verifier.generateNonce(),
{'attr_uuid': AttributeInfo('name', schema.seqId)},
{'predicate_uuid': PredicateGE('age', 18)})
proof = await prover.presentProof(proofInput)
assert proof.requestedProof.revealed_attrs['attr_uuid'][1] == 'Alex'
assert await verifier.verify(proofInput, proof)
async def testGePredicateForEqual(prover1, verifier, claimsProver1Gvt):
proofRequest = ProofRequest(
"proof1",
"1.0",
verifier.generateNonce(),
verifiableAttributes={'attr_uuid': AttributeInfo(name='name')},
predicates={'predicate_uuid': PredicateGE('age', 28)})
assert await presentProofAndVerify(verifier, proofRequest, prover1)
async def testGePredicateNegativeForBoth(prover1, prover2, verifier, allClaims):
proofRequest = ProofRequest("proof1", "1.0", verifier.generateNonce(),
verifiableAttributes={'attr_uuid1': AttributeInfo(name='name')},
predicates={'predicate_uuid1': PredicateGE('age', 38),
'predicate_uuid2': PredicateGE('period', 30)})
with pytest.raises(ValueError):
await presentProofAndVerify(verifier, proofRequest, prover1)
with pytest.raises(ValueError):
await presentProofAndVerify(verifier, proofRequest, prover2)
async def testClaimProofFromToDict(prover1, nonce, claimsProver1Gvt):
proofRequest = ProofRequest("proof1", "1.0", 1,
verifiableAttributes={
'attr_uuid': AttributeInfo(name='name')},
predicates={'predicate_uuid': PredicateGE('age', 18)})
proof = await prover1.presentProof(proofRequest)
assert proof == FullProof.fromStrDict(proof.toStrDict())
async def testPrimaryClaimNoPredicates(prover1, verifier, claimsProver1Gvt,
nonce, schemaGvtId):
proofRequest = ProofRequest(
"proof1",
"1.0",
nonce,
verifiableAttributes={'uuid1': AttributeInfo(name='name')},
predicates={})
claims, requestedProof = await prover1._findClaims(proofRequest)
claims = {
schemaId:
ProofClaims(Claims(primaryClaim=proofClaim.claims.primaryClaim),
[AttributeInfo(name='name')], [])
for schemaId, proofClaim in claims.items()
}
proof = await prover1._prepareProof(claims, proofRequest.nonce,
requestedProof)
assert await verifier.verify(proofRequest, proof)
async def testMultipleGePredicate(prover1, verifier, claimsProver1Gvt):
proofRequest = ProofRequest(
"proof1",
"1.0",
verifier.generateNonce(),
verifiableAttributes={'attr_uuid': AttributeInfo(name='name')},
predicates={
'predicate_uuid1': PredicateGE('age', 18),
'predicate_uuid2': PredicateGE('height', 170)
})
assert await presentProofAndVerify(verifier, proofRequest, prover1)
async def testRevocedWithUpdateWitness(schemaGvtId, issuerGvt, prover1,
verifier, claimsProver1Gvt):
await issuerGvt.revoke(schemaGvtId, 1)
proofRequest = ProofRequest(
"proof1",
"1.0",
verifier.generateNonce(),
verifiableAttributes={'attr_uuid': AttributeInfo(name='name')})
with pytest.raises(ValueError):
await presentProofAndVerify(verifier, proofRequest, prover1)
async def testSingleIssuerMultipleCredDefsSingleProver(primes1, primes2):
# 1. Init entities
publicRepo = PublicRepoInMemory()
attrRepo = AttributeRepoInMemory()
issuer = Issuer(IssuerWalletInMemory('issuer1', publicRepo), attrRepo)
# 2. Create a Schema
schema1 = await issuer.genSchema('GVT', '1.0', GVT.attribNames())
schemaId1 = ID(schema1.getKey())
schema2 = await issuer.genSchema('XYZCorp', '1.0', XYZCorp.attribNames())
schemaId2 = ID(schema2.getKey())
# 3. Create keys for the Schema
await issuer.genKeys(schemaId1, **primes1)
await issuer.genKeys(schemaId2, **primes2)
# 4. Issue accumulator
await issuer.issueAccumulator(schemaId=schemaId1, iA='110', L=5)
await issuer.issueAccumulator(schemaId=schemaId2, iA=9999999, L=5)
# 4. set attributes for user1
userId = '111'
attrs1 = GVT.attribs(name='Alex', age=28, height=175, sex='male')
attrs2 = XYZCorp.attribs(status='FULL', period=8)
attrRepo.addAttributes(schema1.getKey(), userId, attrs1)
attrRepo.addAttributes(schema2.getKey(), userId, attrs2)
# 5. request Claims
prover = Prover(ProverWalletInMemory(userId, publicRepo))
claimsReqs = await prover.createClaimRequests([schemaId1, schemaId2])
claims = await issuer.issueClaims(claimsReqs)
await prover.processClaims(claims)
# 6. proof Claims
verifier = Verifier(WalletInMemory('verifier1', publicRepo))
proofRequest = ProofRequest("proof1",
"1.0",
verifier.generateNonce(),
verifiableAttributes={
'attr_uuid1':
AttributeInfo('name', schema1.seqId)
},
predicates={
'predicate_uuid1': PredicateGE('age', 18),
'predicate_uuid2':
PredicateGE('period', 5)
})
proof = await prover.presentProof(proofRequest)
assert proof.requestedProof.revealed_attrs['attr_uuid1'][1] == 'Alex'
assert await verifier.verify(proofRequest, proof)
async def testRevocedWithoutUpdateWitness(schemaGvtId, issuerGvt, prover1,
verifier, claimsProver1Gvt):
proofRequest = ProofRequest(
"proof1",
"1.0",
verifier.generateNonce(),
verifiableAttributes={'attr_uuid': AttributeInfo(name='name')})
proof = await prover1.presentProof(proofRequest)
await issuerGvt.revoke(schemaGvtId, 1)
return await verifier.verify(proofRequest, proof)
async def testClaimProofFromToDictPrimaryOnly(prover1, nonce, claimsProver1Gvt, schemaGvt):
proofRequest = ProofRequest("proof1", "1.0", 1,
verifiableAttributes={
'attr_uuid': AttributeInfo(name='name')},
predicates={'predicate_uuid': PredicateGE('age', 18)})
proof = await prover1.presentProof(proofRequest)
proofInfo = proof.proofs[str(schemaGvt.seqId)]
proofs = {schemaGvt.seqId: ProofInfo(Proof(primaryProof=proofInfo.proof.primaryProof),
issuer_did=schemaGvt.issuerId,
schema_seq_no=proofInfo.schema_seq_no)}
proof = proof._replace(proofs=proofs)
assert proof == FullProof.fromStrDict(proof.toStrDict())
async def test_proof_from_to_dict(prover1, nonce, claimsProver1Gvt, schemaGvt):
n = (await prover1.wallet.getPublicKey(ID(schemaId=schemaGvt.seqId))).N
proofRequest = ProofRequest("proof1", "1.0", nonce,
verifiableAttributes={
'attr_uuid': AttributeInfo(name='name')},
predicates={'predicate_uuid': PredicateGE('age', 18)})
proof = await prover1.presentProof(proofRequest)
proofInfo = proof.proofs[str(schemaGvt.seqId)]
proof = ProofInfo(Proof(primaryProof=proofInfo.proof.primaryProof),
issuer_did=schemaGvt.issuerId,
schema_seq_no=proofInfo.schema_seq_no)
assert proof == ProofInfo.from_str_dict(proof.to_str_dict(), n)
async def testNonceShouldBeSame(prover1, verifier, claimsProver1Gvt, nonce,
genNonce):
proofRequest = ProofRequest(
"proof1",
"1.0",
verifier.generateNonce(),
verifiableAttributes={'attr_uuid': AttributeInfo(name='name')})
proof = await prover1.presentProof(proofRequest)
proofRequest = ProofRequest(
"proof1",
"1.0",
genNonce,
verifiableAttributes=proofRequest.verifiableAttributes,
predicates=proofRequest.predicates)
assert not await verifier.verify(proofRequest, proof)
async def testUParamShouldBeSame(prover1, verifier, issuerGvt, schemaGvtId,
attrsProver1Gvt, keysGvt,
issueAccumulatorGvt):
claimsReq = await prover1.createClaimRequest(schemaGvtId)
claimsReq = claimsReq._replace(U=claimsReq.U**2)
claim_signature, claim_attributes = await issuerGvt.issueClaim(
schemaGvtId, claimsReq)
await prover1.processClaim(schemaGvtId, claim_attributes, claim_signature)
proofRequest = ProofRequest(
"proof1",
"1.0",
verifier.generateNonce(),
verifiableAttributes={'attr_uuid': AttributeInfo(name='name')},
predicates={})
assert not await presentProofAndVerify(verifier, proofRequest, prover1)
async def testSingleIssuerSingleProverPrimaryOnly(primes1):
# 1. Init entities
publicRepo = PublicRepoInMemory()
attrRepo = AttributeRepoInMemory()
issuer = Issuer(IssuerWalletInMemory('issuer1', publicRepo), attrRepo)
# 2. Create a Schema
schema = await issuer.genSchema('GVT', '1.0', GVT.attribNames())
schemaId = ID(schema.getKey())
# 3. Create keys for the Schema
await issuer.genKeys(schemaId, **primes1)
# 4. Issue accumulator
await issuer.issueAccumulator(schemaId=schemaId, iA='110', L=5)
# 4. set attributes for user1
userId = '111'
attrs = GVT.attribs(name='Alex', age=28, height=175, sex='male')
attrRepo.addAttributes(schema.getKey(), userId, attrs)
# 5. request Claims
prover = Prover(ProverWalletInMemory(userId, publicRepo))
claimsReq = await prover.createClaimRequest(schemaId, None, False)
(claim_signature,
claim_attributes) = await issuer.issueClaim(schemaId, claimsReq)
await prover.processClaim(schemaId, claim_attributes, claim_signature)
# 6. proof Claims
verifier = Verifier(WalletInMemory('verifier1', publicRepo))
proofRequest = ProofRequest(
"proof1",
"1.0",
verifier.generateNonce(),
verifiableAttributes={
'attr_uuid1': AttributeInfo('name', schema.seqId)
},
predicates={'predicate_uuid1': PredicateGE('age', 18)})
proof = await prover.presentProof(proofRequest)
assert proof.requestedProof.revealed_attrs['attr_uuid1'][1] == 'Alex'
assert await verifier.verify(proofRequest, proof)
def __init__(self,
name,
version,
nonce,
attributes,
verifiableAttributes,
predicates=[]):
self.name = name
self.version = version
self.nonce = nonce
self.attributes = attributes
self.verifiableAttributes = \
{str(uuid.uuid4()): AttributeInfo(name=a) for a in verifiableAttributes} if \
isinstance(verifiableAttributes, list) else verifiableAttributes
self.predicates = {
str(uuid.uuid4()): PredicateGE(attrName=p['attrName'],
value=p['value'])
for p in predicates
} if isinstance(predicates, list) else predicates
self.fulfilledByClaims = []
self.selfAttestedAttrs = {}
