async def submitPublicKeys(self, id: ID, pk: PublicKey, pkR: RevocationPublicKey = None, signatureType='CL') -> \ (PublicKey, RevocationPublicKey): data = {} if pk is not None: data[PRIMARY] = pk.to_str_dict() if pkR is not None: data[REVOCATION] = pkR.toStrDict() op = { TXN_TYPE: CLAIM_DEF, REF: id.schemaId, DATA: data, SIGNATURE_TYPE: signatureType } _, seqNo = await self._sendSubmitReq(op) if seqNo: pk = pk._replace(seqId=seqNo) if pkR is not None: pkR = pkR._replace(seqId=seqNo) return pk, pkR
def test_pk_from_to_dict(): pk = PublicKey(N=cmod.integer(12345), Rms=cmod.integer(12) % cmod.integer(12345), Rctxt=cmod.integer(13) % cmod.integer(12345), R={ 'name': cmod.integer(1) % cmod.integer(12345), 'age': cmod.integer(2) % cmod.integer(12345) }, S=cmod.integer(14) % cmod.integer(12345), Z=cmod.integer(15) % cmod.integer(12345)) pk_serialized = { 'n': '12345', 'rms': '12', 'rctxt': '13', 'r': { 'name': '1', 'age': '2' }, 's': '14', 'z': '15', } assert pk.to_str_dict() == pk_serialized assert pk == PublicKey.from_str_dict(pk_serialized)
async def submitPublicKeys(self, id: ID, pk: PublicKey, pkR: RevocationPublicKey = None ) -> (PublicKey, RevocationPublicKey): pkData = pk.toStrDict() pkRData = pkR.toStrDict() op = { TXN_TYPE: ISSUER_KEY, REF: id.schemaId, DATA: { PRIMARY: pkData, REVOCATION: pkRData } } try: data, seqNo = await self._sendSubmitReq(op) except TimeoutError: logger.error('Operation timed out {}'.format(op)) return None if not seqNo: return None pk = pk._replace(seqId=seqNo) pkR = pkR._replace(seqId=seqNo) return pk, pkR
def testPKFromToDict(): pk = PublicKey(N=cmod.integer(11), Rms=cmod.integer(12), Rctxt=cmod.integer(13), R={'a': cmod.integer(1), 'b': cmod.integer(2)}, S=cmod.integer(14), Z=cmod.integer(15)) assert pk == PublicKey.fromStrDict(pk.toStrDict())
def main(): sock = socket.socket() sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind((ip, port)) sock.listen(1) logging.debug('Listening') conn, _ = sock.accept() logging.debug('Connected') while True: data = json.loads(conn.recv(chunk_size).decode("utf-8")) logging.debug('received data: {}'.format(data)) if ('type' in data) & (data['type'] == 'receive_claim_def'): logging.debug('receive_claim_def -> start') global global_dict global_dict['public_key'] = PublicKey.from_str_dict( data['data']['data']['primary']) logging.debug('receive_claim_def -> done') if ('type' in data) & (data['type'] == 'get_proof_request'): logging.debug('get_proof_request -> start') create_request = asyncio.ensure_future(create_proof_request(conn)) loop.run_until_complete(create_request) logging.debug('get_proof_request -> done') if ('type' in data) & (data['type'] == 'check_proof'): logging.debug('check_proof -> start') check_proof = asyncio.ensure_future(verify(data['data'], conn)) loop.run_until_complete(check_proof) logging.debug('check_proof -> done') if (('type' in data) & (data['type'] == 'close')) | (not data): break sock.close()
async def submitPublicKeys(self, id: ID, pk: PublicKey, pkR: RevocationPublicKey = None) -> ( PublicKey, RevocationPublicKey): pkData = pk.toStrDict() pkRData = pkR.toStrDict() op = { TXN_TYPE: ISSUER_KEY, REF: id.schemaId, DATA: {PRIMARY: pkData, REVOCATION: pkRData} } data, seqNo = await self._sendSubmitReq(op) if not seqNo: return None pk = pk._replace(seqId=seqNo) pkR = pkR._replace(seqId=seqNo) return pk, pkR
async def getPublicKey(self, id: ID, signatureType='CL') -> PublicKey: op = { TXN_TYPE: GET_CLAIM_DEF, REF: id.schemaId, ORIGIN: id.schemaKey.issuerId, SIGNATURE_TYPE: signatureType } data, seqNo = await self._sendGetReq(op) data = data[DATA][PRIMARY] pk = PublicKey.fromStrDict(data)._replace(seqId=seqNo) return pk
async def getPublicKey(self, id: ID) -> PublicKey: op = { TXN_TYPE: GET_ISSUER_KEY, REF: id.schemaId, ORIGIN: id.schemaKey.issuerId } data, seqNo = await self._sendGetReq(op) data = data[DATA][PRIMARY] pk = PublicKey.fromStrDict(data)._replace(seqId=seqNo) return pk
async def getPublicKey(self, id: ID, signatureType = 'CL') -> Optional[PublicKey]: op = { TXN_TYPE: GET_CLAIM_DEF, REF: id.schemaId, ORIGIN: id.schemaKey.issuerId, SIGNATURE_TYPE: signatureType } data, seqNo = await self._sendGetReq(op) if not data: return None data = data[PRIMARY] pk = PublicKey.from_str_dict(data)._replace(seqId=seqNo) return pk
async def submitPublicKeys(self, schemaId: ID, pk: PublicKey, pkR: RevocationPublicKey = None ) -> (PublicKey, RevocationPublicKey): pk = pk._replace(seqId=self._pkId) self._pkId += 1 await self._cacheValueForId(self._pks, schemaId, pk) if pkR: pkR = pkR._replace(seqId=self._pkRId) self._pkRId += 1 await self._cacheValueForId(self._pkRs, schemaId, pkR) return pk, pkR
async def getPublicKey(self, id: ID, signatureType='CL') -> Optional[PublicKey]: op = { TXN_TYPE: GET_CLAIM_DEF, REF: id.schemaId, ORIGIN: id.schemaKey.issuerId, SIGNATURE_TYPE: signatureType } data, seqNo = await self._sendGetReq(op) if not data: return None data = data[PRIMARY] pk = PublicKey.from_str_dict(data)._replace(seqId=seqNo) return pk
async def getPublicKey(self, id: ID = None, signatureType='CL') -> Optional[PublicKey]: op = { TXN_TYPE: GET_CLAIM_DEF, REF: id.schemaId, ORIGIN: id.schemaKey.issuerId, SIGNATURE_TYPE: signatureType } data, seqNo = await self._sendGetReq(op) if not data: raise ValueError( 'No CLAIM_DEF for schema with ID={} and key={}'.format( id.schemaId, id.schemaKey)) data = data[PRIMARY] pk = PublicKey.from_str_dict(data)._replace(seqId=seqNo) return pk
async def getPublicKey(self, id: ID) -> PublicKey: op = { TXN_TYPE: GET_ISSUER_KEY, REF: id.schemaId, ORIGIN: id.schemaKey.issuerId } try: data, seqNo = await self._sendGetReq(op) except TimeoutError: logger.error('Operation timed out {}'.format(op)) return None if not data: return None data = data[DATA][PRIMARY] pk = PublicKey.fromStrDict(data)._replace(seqId=seqNo) return pk
async def genKeys(self, schemaId: ID, p_prime=None, q_prime=None) -> (PublicKey, SecretKey): schema = await self._wallet.getSchema(schemaId) if not schema.attrNames and isinstance(schema.attrNames, list): raise ValueError("List of attribute names is required to " "setup credential definition") p_prime = p_prime if p_prime else PrimaryClaimIssuer._genPrime() p = 2 * p_prime + 1 q_prime = q_prime if q_prime else PrimaryClaimIssuer._genPrime() q = 2 * q_prime + 1 n = p * q # Generate a random quadratic number S = randomQR(n) # Generate random numbers corresponding to every attributes Xz = PrimaryClaimIssuer._genX(p_prime, q_prime) Xr = {} for name in schema.attrNames: Xr[str(name)] = PrimaryClaimIssuer._genX(p_prime, q_prime) # Generate `Z` as the exponentiation of the quadratic random 'S' . # over the random `Xz` in the group defined by modulus `n` Z = (S**Xz) % n # Generate random numbers corresponding to every attributes R = {} for name in schema.attrNames: R[str(name)] = (S**Xr[str(name)]) % n # Rms is a random number needed corresponding to master secret m1 Rms = (S**PrimaryClaimIssuer._genX(p_prime, q_prime)) % n # Rctxt is a random number needed corresponding to context attribute m2 Rctxt = (S**PrimaryClaimIssuer._genX(p_prime, q_prime)) % n return PublicKey(n, Rms, Rctxt, R, S, Z), SecretKey(p_prime, q_prime)