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
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 = 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)
