async def test_requested_proof_from_to_dict(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) requested_proof_serialized = { 'revealed_attrs': { 'attr_uuid': ['1', 'Alex', '1139481716457488690172217916278103335'] }, 'predicates': { 'predicate_uuid': '1' }, 'self_attested_attrs': {}, 'unrevealed_attrs': {} } assert proof.requestedProof.to_str_dict() == requested_proof_serialized assert proof.requestedProof == RequestedProof.from_str_dict( requested_proof_serialized) assert proof.requestedProof == RequestedProof.from_str_dict( proof.requestedProof.to_str_dict())
async def verifyProof(self, msg: Any): body, (frm, _) = msg link = self.verifyAndGetLink(msg) if not link: raise NotImplementedError proof = body[PROOF_FIELD] proofRequest = ProofRequest.from_str_dict(body[PROOF_REQUEST_FIELD]) nonce = getNonceForProof(body[NONCE]) proofName = proofRequest.name proofs = {} for key, p in proof['proofs'].items(): schema = await self.verifier.wallet.getSchema( ID(schemaId=int(p['schema_seq_no']))) pk = await self.verifier.wallet.getPublicKey( ID(schemaKey=schema.getKey())) proofs[key] = ProofInfo.from_str_dict(p, str(pk.N)) proof = FullProof( proofs, AggregatedProof.from_str_dict(proof['aggregated_proof']), RequestedProof.from_str_dict(proof['requested_proof'])) result = await self.verifier.verify(proofRequest, proof) self.logger.info('Proof "{}" accepted with nonce {}'.format( proofName, nonce)) self.logger.info('Verifying proof "{}" from {}'.format( proofName, link.name)) status = 'verified' if result else 'failed verification' resp = { TYPE: PROOF_STATUS, DATA: ' Your Proof {} {} was received and {}\n'.format( proofRequest.name, proofRequest.version, status), } self.signAndSend(resp, link.localIdentifier, frm, origReqId=body.get(f.REQ_ID.nm)) if result: for uuid, attribute in proofRequest.verifiableAttributes.items(): # Log attributes that were verified self.logger.info('verified {}: {}'.format( attribute.name, proof.requestedProof.revealed_attrs[uuid][1])) self.logger.info( 'Verified that proof "{}" contains attributes ' 'from claim(s) issued by: {}'.format( proofName, ", ".join( sorted([v.issuer_did for k, v in proof.proofs.items()])))) await self._postProofVerif(proofName, link, frm) else: self.logger.info( 'Verification failed for proof {} from {} '.format( proofName, link.name))
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 testMultipledPredicates(prover1, allClaims, schemaGvtId, schemaXyzId, schemaGvt): proofRequest = ProofRequest("proof1", "1.0", 1, predicates={ 'predicate_uuid1': PredicateGE('age', 18), 'predicate_uuid2': PredicateGE('period', 8) }) claimsGvt = await prover1.wallet.getClaimSignature(schemaGvtId) claimsXyz = await prover1.wallet.getClaimSignature(schemaXyzId) proofClaims = { schemaGvt.seqId: ProofClaims(claimsGvt, [], [PredicateGE('age', 18)]), schemaGvt.seqId: ProofClaims(claimsXyz, [], [PredicateGE('period', 8)]) } requestedProof = RequestedProof(predicates={ 'predicate_uuid1': schemaGvt.seqId, 'predicate_uuid2': schemaGvt.seqId }) assert proofClaims, requestedProof == await prover1._findClaims( proofRequest)
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 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 testEmpty(prover1): proofRequest = ProofRequest("proof1", "1.0", 1, verifiableAttributes={}, predicates={}) assert ({}, RequestedProof([], [], [], [])) == await prover1._findClaims(proofRequest)
async def testOnePredicateOnly(prover1, allClaims, schemaGvtId, schemaGvt): proofRequest = ProofRequest("proof1", "1.0", 1, predicates={'uuid': PredicateGE('age', 18)}) claimsGvt = await prover1.wallet.getClaimSignature(schemaGvtId) proofClaims = {schemaGvt.seqId: ProofClaims(claimsGvt, [], [PredicateGE('age', 18)])} requestedProof = RequestedProof(predicates={'uuid': schemaGvt.seqId}) assert proofClaims, requestedProof == await prover1._findClaims(proofRequest)
async def testRequestedProofFromToDict(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.requestedProof == RequestedProof.fromStrDict( proof.requestedProof.toStrDict())
async def _findClaims(self, proofRequest: ProofRequest) -> ( Dict[SchemaKey, ProofClaims], Dict[str, Any]): revealedAttrs, predicates = proofRequest.verifiableAttributes, proofRequest.predicates foundRevealedAttrs = {} foundPredicates = {} proofClaims = {} schemas = {} allClaimsAttributes = await self.wallet.getAllClaimsAttributes() async def addProof(): revealedAttrsForClaim = [a for a in revealedAttrs.values() if a.name in claim.keys()] revealedPredicatesForClaim = [p for p in predicates.values() if p.attrName in claim.keys()] claims = await self.wallet.getClaimSignature(ID(schemaId=schemaId)) proofClaim = ProofClaims(claims=claims, revealedAttrs=revealedAttrsForClaim, predicates=revealedPredicatesForClaim) proofClaims[schemaId] = proofClaim for schemaKey, c in allClaimsAttributes.items(): schemas[schemaKey] = (await self.wallet.getSchema(ID(schemaKey))) for uuid, revealedAttr in revealedAttrs.items(): matches = [(schemas[key].seqId, c) for key, c in allClaimsAttributes.items() if revealedAttr.name in c and (schemas[key].seqId == revealedAttr.schema_seq_no if revealedAttr.schema_seq_no else True) and (schemas[key].issuerId == revealedAttr.issuer_did if revealedAttr.issuer_did else True)] if len(matches) == 0: raise ValueError("A claim isn't found for the following attributes: {}", revealedAttr.name) schemaId, claim = matches[0] foundRevealedAttrs[uuid] = [str(schemaId), str(claim[revealedAttr.name].raw), str(claim[revealedAttr.name].encoded)] if schemaId not in proofClaims: await addProof() for uuid, predicate in predicates.items(): matches = [(schemas[key].seqId, c) for key, c in allClaimsAttributes.items() if predicate.attrName in c and (schemas[key].seqId == predicate.schema_seq_no if predicate.schema_seq_no else True) and (schemas[key].issuerId == predicate.issuer_did if predicate.issuer_did else True)] if len(matches) == 0: raise ValueError("A claim isn't found for the following predicate: {}", predicate) schemaId, claim = matches[0] foundPredicates[uuid] = str(schemaId) if schemaId not in proofClaims: await addProof() requestedProof = RequestedProof(revealed_attrs=foundRevealedAttrs, predicates=foundPredicates) return proofClaims, requestedProof
async def testPredicatesEmpty(prover1, allClaims, schemaGvtId, attrRepo, schemaGvt): proofRequest = ProofRequest("proof1", "1.0", 1, verifiableAttributes={'uuid': AttributeInfo(name='name')}, predicates={}) 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': [schemaGvt.seqId, attr, str(encodeAttr(attr))]}) assert proofClaims, requestedProof == await prover1._findClaims(proofRequest)
async def verifyProof(self, msg: Any): body, (frm, _) = msg link = self.verifyAndGetLink(msg) if not link: raise NotImplementedError proof = body[PROOF_FIELD] proofRequest = ProofRequest.from_str_dict(body[PROOF_REQUEST_FIELD]) nonce = getNonceForProof(body[NONCE]) proofName = proofRequest.name proofs = {} for key, p in proof['proofs'].items(): schema = await self.verifier.wallet.getSchema(ID(schemaId=int(p['schema_seq_no']))) pk = await self.verifier.wallet.getPublicKey(ID(schemaKey=schema.getKey())) proofs[key] = ProofInfo.from_str_dict(p, str(pk.N)) proof = FullProof( proofs, AggregatedProof.from_str_dict( proof['aggregated_proof']), RequestedProof.from_str_dict( proof['requested_proof'])) result = await self.verifier.verify(proofRequest, proof) self.logger.info('Proof "{}" accepted with nonce {}' .format(proofName, nonce)) self.logger.info('Verifying proof "{}" from {}' .format(proofName, link.name)) status = 'verified' if result else 'failed verification' resp = { TYPE: PROOF_STATUS, DATA: ' Your Proof {} {} was received and {}\n'. format(proofRequest.name, proofRequest.version, status), } self.signAndSend(resp, link.localIdentifier, frm, origReqId=body.get(f.REQ_ID.nm)) if result: for uuid, attribute in proofRequest.verifiableAttributes.items(): # Log attributes that were verified self.logger.info( 'verified {}: {}'. format( attribute.name, proof.requestedProof.revealed_attrs[uuid][1])) self.logger.info('Verified that proof "{}" contains attributes ' 'from claim(s) issued by: {}'.format( proofName, ", ".join( sorted([v.issuer_did for k, v in proof.proofs.items()])))) await self._postProofVerif(proofName, link, frm) else: self.logger.info('Verification failed for proof {} from {} ' .format(proofName, link.name))