def CallGroupIsVerified(self, request, context):
gid = request.id.groupId
calcType = request.calculation
self.cp.myPrint('GroupIsVerified: {0}'.format(gid))
if calcType == enums.LITTLEK:
self.cp.myPrint("presign initiator = {0}".format(
self.cp.Player.isPresignInitiator(gid)))
if self.cp.Player.isPresignInitiator(gid):
self.cp.myPrint("calling remote_presigning for ALPHA")
idMsg = stub.IdentityMessage(userId=self.user, groupId=gid)
response = self.cp.conn.CallPresigning( stub.PresigningRequest \
( id=idMsg, calculation=enums.ALPHA) )
elif calcType == enums.ALPHA:
res = self.cp.Player.getVWshares(gid)
#self.cp.myPrint('res = ')
#self.cp.myPrint( str(res ))
vwdata = stub.VWData(ordinal=res[0], v=res[1][0], w=res[1][1])
idMsg = stub.IdentityMessage(userId=self.user, groupId=gid)
response = self.cp.conn.CallShareVW( stub.ShareVWDataMessage \
( id=idMsg, data=vwdata ) )
elif calcType == enums.PRIVATEKEYSHARE:
if self.cp.Player.isShareInitiator(gid):
response = self.cp.conn.CallPubKeyComplete( stub.IdentityMessage \
(groupId=gid, userId=self.user))
return stub.GroupIsVerifiedReply(success=True)
def CallCreateGroup(self, request, context):
print('user = {0}, m = {1}, n = {2} '.format \
( request.userId, request.m, request.n ) )
results = None
try:
results = self.orchestrator.createGroup(request.userId, request.m,
request.n)
except Exception as inst:
#raise OrchestratorError( inst.args )
print('ERROR in OrchestratorProtocol:CallCreateGroup')
gid = results[0]
inviteList = results[1]
for invitee in inviteList:
idMsg = stub.IdentityMessage(groupId=gid)
call_future = invitee[0].CallInvite.future(
stub.InviteRequest(id=idMsg))
call_future.add_done_callback(self.acceptInviteCallback)
idMsg = stub.IdentityMessage(userId=request.userId, groupId=gid)
print('returning a creategroupreply')
return stub.CreateGroupReply(id=idMsg)
def CallPresigning (self, request, context) :
user = request.id.userId
gid = request.id.groupId
calcType = request.calculation
self.orchestrator.setCalcType( gid, calcType )
print("presigning: user={0}, groupId={1}, calcType={2}".format \
(user, gid, calcType) )
if not self.orchestrator.validGroup(gid) :
errMsg = 'Group Id is not valid: {0}'.format(gid)
#raise OrchestratorError( errMsg )
print('ERROR: ' + errMsg )
participants = self.orchestrator.getParticipants(gid)
if user not in participants :
errMsg = 'user is not in the group: {0}'.format(user)
#raise OrchestratorError( errMsg )
print('ERROR: ' + errMsg )
userRefs = self.orchestrator.getUserReferences(gid)
for ref in userRefs :
print('calling request data...')
idMsg = stub.IdentityMessage( userId=user, groupId=gid )
call_future = ref[0].CallShareSecretData.future \
( stub.ShareSecretDataRequest( id=idMsg ))
call_future.add_done_callback( self.collateDataCallback )
return stub.PresigningReply( success=True )
def CallShareVW(self, request, context) :
gid = request.id.groupId
user = request.id.userId
print("Collating VW Data")
# orchestrator expects a tuple ()
data = ( request.data.v, request.data.w )
idMsg = stub.IdentityMessage( userId=user, groupId=gid )
if self.orchestrator.collateVWData( gid, request.data.ordinal, data ) :
collatedData = self.orchestrator.getCollatedVWData( gid )
vwList = []
for ordinal, vw in collatedData.items() :
vwdata = stub.VWData( ordinal=ordinal, v=vw[0], w=vw[1] )
vwList.append( vwdata )
# send the public data out to all group participants
userRefs = self.orchestrator.getUserReferences( gid )
for ref in userRefs :
ref[0].CallCollatedVWShare( stub.CollatedVWShareRequest \
( id=idMsg, data=vwList ) )
return stub.ShareVWDataMessageReply( id=idMsg, success=True )
def CallShareSecretData(self, request, context):
self.cp.myPrint('CallShareSecretData')
calculation = 'PRIVATEKEYSHARE'
calcType = request.calculation
if calcType == enums.LITTLEK:
calculation = 'LITTLEK'
elif calcType == enums.ALPHA:
calculation = 'ALPHA'
self.cp.myPrint('calculation type = {0}, {1}'.format(
calcType, calculation))
ret = self.cp.Player.requestData(request.id.groupId, calculation)
gid = ret[0]
ordi = ret[1]
hpol = ret[2]
# create list of hidden evaluated polynomials
heval = ret[3]
hepList = []
for key, value in heval.items():
hep = stub.evaluatedPoly(ordinal=key, f_x=value)
hepList.append(hep)
idMsg = stub.IdentityMessage(userId=self.user, groupId=gid)
return stub.ShareSecretDataReply( id=idMsg, \
ordinal=ordi, hiddenPoly=hpol, hiddenEvals=hepList )
def CallShareOfSignature(self, request, context):
ret = self.cp.Player.requestSignatureData(request.groupId,
request.message)
idMsg = stub.IdentityMessage(userId=self.user, groupId=ret[0])
return stub.ShareOfSigReply \
( id=idMsg, ordinal=ret[1], signature=ret[2] , message=ret[3] )
def CallInitShareEvals(self, request, context):
gid = request.id.groupId
self.cp.myPrint('ServerProtocol... CallInitShareEvals')
ordinalList = self.cp.Player.getOrdinalList(gid)
idMsg = stub.IdentityMessage(groupId=gid)
sentToAll = True
for p in ordinalList:
self.cp.myPrint(
'Sending evals to Player {0} and port {1}'.format(
p[0], p[1]))
# create a gRPC channel + stub
channel = grpc.insecure_channel('localhost' + ':' + str(p[1]))
connection = rpc.TSServiceStub(channel)
ret = self.cp.Player.getEvals(gid, p[0])
response = connection.CallDistributeEvals( stub.DistributeEvalsRequest \
( id=idMsg, toOrdinal=p[0], \
fromOrdinal=self.cp.Player.getOrdinal(gid), f_x=ret ) )
if not response:
sentToAll = False
return stub.InitShareEvalsReply(success=sentToAll)
def CallGroupIsSet(self, request, context):
groupId = request.groupId
idMsg = stub.IdentityMessage(userId=self.user,
groupId=request.groupId)
# need to find out my own player ordinal, and an ordinalLIst for the rest of the group
ordinal = 0
ordinalList = []
self.cp.myPrint('in CallGroupIsSet')
for participant in request.participants:
if (participant.playerId.name == self.user):
self.cp.myPrint(
' this is me, setting ordinal to {0}'.format(
participant.ordinal))
ordinal = participant.ordinal
else:
ordinalList.append(
(participant.ordinal, participant.playerId.port))
if ordinal == 0:
self.cp.myPrint(' Ordinal is zero, something has gone wrong')
return stub.GroupIsSetReply(id=idMsg, success=False)
else:
self.cp.myPrint(str(ordinalList))
if not self.cp.Player.addGroup \
( groupId, ordinal, ordinalList, request.degree ) :
print('Error: Group {0} already exists'.format(groupId))
return stub.GroupIsSetReply(id=idMsg, success=False)
return stub.GroupIsSetReply(id=idMsg, success=True)
def CallCompleted(self, request, context):
self.cp.myPrint('CallCompleted')
gid = request.groupId
if self.cp.Player.isPresignInitiator(gid):
numberPresignsLeft = self.cp.Player.numberPresignsLeftToDo(gid)
if numberPresignsLeft > 0:
self.cp.myPrint("number presign left to do = {0}".format(
numberPresignsLeft))
self.cp.myPrint("calling remote_presigning for LITTLEK")
idMsg = stub.IdentityMessage(userId=self.user, groupId=gid)
response = self.cp.conn.CallPresigning( stub.ShareSecretRequest \
( id=idMsg, calculation=enums.LITTLEK) )
else:
self.cp.myPrint(
"I was the presign initiator. Looks like we're FINISHED!!!"
)
response = self.cp.conn.CallPresignComplete( stub.IdentityMessage \
( groupId=gid ) )
return stub.GenericReply(success=True)
def initiatePresignCallback(self, call_future):
res = call_future.result()
self.myPrint('\nstarting presigning for LITTLEK')
self.Player.setPresignInitiator(res.id.groupId, res.number)
idMsg = stub.IdentityMessage(userId=self.user, groupId=res.id.groupId)
response = self.conn.CallPresigning( stub.PresigningRequest \
( id=idMsg, calculation=enums.LITTLEK) )
def CallInvite(self, request, context):
self.cp.myPrint('in CallInvite')
# random sleep to mimic network communications
time.sleep(randint(1, 4))
self.cp.myPrint(
"Received invitation for group {0}, replying with Acceptance".
format(request.id.groupId))
idMsg = stub.IdentityMessage(userId=self.user,
groupId=request.id.groupId)
return stub.InviteReply(id=idMsg, acceptance=True)
def CallInitiatePresign(self, request, context) :
gid = request.id.groupId
if self.orchestrator.isLocked(gid) :
errMsg = 'Group Id is locked, try again later: {0}'.format(gid)
#raise OrchestratorError( errMsg )
print('ERROR: ' + errMsg )
self.orchestrator.lock( gid )
idMsg = stub.IdentityMessage( userId=request.id.userId, groupId=gid )
return stub.InitPresignReply \
( id=idMsg, number=request.number )
def presigning(self, gid, num):
if not self.Player.checkGroup(gid):
msg = "GroupID not found: {0}".format(gid)
self.myPrint('ERROR: presigning')
self.myPrint(msg)
idMsg = stub.IdentityMessage(userId=self.user, groupId=gid)
call_future = self.conn.CallInitiatePresign.future( stub.InitPresignRequest \
( id=idMsg, number=num ) )
call_future.add_done_callback(self.initiatePresignCallback)
self.myPrint('initiated presigning ')
def CallSignMessage(self, request, context):
# create dictionary for Player
sigDict = {}
for sig in request.signatures:
sigDict[sig.ordinal] = sig.signature
sig = self.cp.Player.sign(request.id.groupId, request.message,
sigDict)
idMsg = stub.IdentityMessage(userId=self.user,
groupId=request.id.groupId)
return stub.SignMessageReply(id=idMsg)
def shareSecret(self, gid):
if not self.Player.checkGroup(gid):
msg = "GroupID not found: {0}".format(gid)
#raise ClientError( msg )
self.myPrint('ERROR: shareSecret')
self.myPrint(msg)
self.Player.setShareInitiator(gid)
idMsg = stub.IdentityMessage(userId=self.user, groupId=gid)
response = self.conn.CallShareSecret( stub.ShareSecretRequest \
( id=idMsg, calculation=enums.PRIVATEKEYSHARE ) )
self.myPrint(str(response))
def sign(self, gid, msg):
self.myPrint("in sign, gid = {0}, msg={1}".format(gid, msg))
if not self.Player.checkGroup(gid):
msg = "GroupID not found: {0}".format(gid)
self.myPrint(msg)
#raise ClientError( msg )
self.Player.setSigningInitiator(gid)
msg = self.Player.hashMessage(msg)
idMsg = stub.IdentityMessage(userId=self.user, groupId=gid)
response = self.conn.CallInitSignature( stub.InitSignatureRequest \
( id=idMsg, message=msg ) )
self.myPrint('initiated signing ')
def collateDataCallback (self, call_future ) :
res = call_future.result()
print('collateDataCallback')
# if True then ready to distribute data
if self.orchestrator.collateData( res.id.groupId, res.ordinal, res.hiddenPoly, res.hiddenEvals) :
# Call the shareEvals, pass in a different set of ordinal:refs for each
userRefs = self.orchestrator.getUserReferences( res.id.groupId )
participants = self.orchestrator.getParticipants( res.id.groupId )
idMsg = stub.IdentityMessage( groupId=res.id.groupId )
for ref in userRefs :
ref[0].CallInitShareEvals( stub.InitShareEvalsRequest ( id=idMsg ) )
def CallCollatedVWShare(self, request, context):
self.cp.myPrint('CallSharedVWData')
gid = request.id.groupId
# player needs dict (tuple)
vwDict = {}
for data in request.data:
vw = (data.v, data.w)
vwDict[data.ordinal] = vw
self.cp.Player.setSharedVWData(gid, vwDict)
response = self.cp.conn.CallEphemKeyComplete( stub.IdentityMessage \
( groupId=gid, userId=self.user ) )
idMsg = stub.IdentityMessage(userId=self.user, groupId=gid)
return stub.CollatedVWShareReply( \
id=idMsg, ordinal=self.cp.Player.getOrdinal(gid), success=True )
def secretVerificationCallback (self, call_future ) :
res = call_future.result()
gid = res.id.groupId
user = res.id.userId
print('secretVerificationCallback: ')
idMsg = stub.IdentityMessage( userId=user, groupId=gid )
if self.orchestrator.secretVerification(user, gid) :
calcType = self.orchestrator.calcType(gid)
print("secretVerification complete for: {0}".format(calcType))
# contact all the group participants with verification success
userRefs = self.orchestrator.getUserReferences(gid)
for ref in userRefs :
ref[0].CallGroupIsVerified( stub.GroupIsVerifiedRequest \
( id=idMsg, calculation=calcType ) )
def CallReceivedAllEvals ( self, request, context ) :
gid = request.id.groupId
ord = request.ordinal
print('receivedAllEvals')
# if all Players have received their Eval data then continue
if self.orchestrator.allEvalsReceived( gid, ord ) :
collatedData = self.orchestrator.getCollatedData( gid)
# send the public data out to all group participants
userRefs = self.orchestrator.getUserReferences( gid )
# get hiddenPoly into suitable format
hpList = []
for ordinalB, coeffs in collatedData[0].items() :
hp = stub.hiddenPolynomial(ordinal=ordinalB,coefficients=coeffs)
hpList.append(hp)
# get hidden evals into a suitable format
hidEvalList = []
for ordinalC, evals in collatedData[1].items() :
l_of_hep = stub.listOfPolynomials()
l_of_hep.ordinal = ordinalC
for e in evals :
l_of_hep.ep.add(ordinal=e.ordinal, f_x=e.f_x)
hidEvalList.append(l_of_hep)
idMsg = stub.IdentityMessage( groupId=gid )
for ref in userRefs :
print('calling createsecret...')
call_future = ref[0].CallCollatedSecretShare.future( stub.CollatedSecretRequest( \
id=idMsg, calculation=self.orchestrator.calcType(gid), \
hiddenPolys=hpList, hiddenEvals=hidEvalList ))
call_future.add_done_callback( self.secretVerificationCallback )
print('returning True from CallReceivedAllEvals')
return stub.RxAllEvalsReply( success=True )
def CallDistributeEvals(self, request, context):
gid = request.id.groupId
toOrdinal = request.toOrdinal
fromOrdinal = request.fromOrdinal
f_x = request.f_x
self.cp.myPrint(
'Received evals from Player{0}'.format(fromOrdinal))
idMsg = stub.IdentityMessage(groupId=gid, userId=self.user)
if self.cp.Player.allEvalsReceived(gid, toOrdinal, fromOrdinal,
f_x):
response = self.cp.conn.CallReceivedAllEvals( \
stub.RxAllEvalsRequest ( id=idMsg, ordinal=toOrdinal ) )
return stub.DistributeEvalsReply(id=idMsg, success=True)
def sign(self, gid, index, msg):
self.myPrint("in sign, gid = {0}, ephemeral key index={1}, msg={2}".format \
(gid, index, msg))
if not self.Player.checkGroup(gid):
msg = "GroupID not found: {0}".format(gid)
self.myPrint(msg)
elif not self.Player.validIndex(gid, index):
return
else:
self.Player.setSigningInitiator(gid)
msg = self.Player.hashMessage(msg)
idMsg = stub.IdentityMessage(userId=self.user, groupId=gid)
response = self.conn.CallInitSignature( stub.InitSignatureRequest \
( id=idMsg, message=msg, keyindex=index ) )
self.myPrint('initiated signing ')
def CallShareSecret( self, request, context ) :
print('in CallShareSecret')
gid = request.id.groupId
self.orchestrator.setCalcType (gid, request.calculation )
if not self.orchestrator.validGroup(gid) :
errMsg = 'Group Id is not valid: {0}'.format(gid)
#raise OrchestratorError( errMsg )
print('ERROR in OrchestratorProtocol:CallShareSecret')
print(errMsg)
if self.orchestrator.isLocked(gid) :
errMsg = 'Group Id is locked, try again later: {0}'.format(gid)
#raise OrchestratorError( errMsg )
print('ERROR in OrchestratorProtocol:CallShareSecret')
print(errMsg)
self.orchestrator.lock(gid)
participants = self.orchestrator.getParticipants(gid)
if request.id.userId not in participants :
errMsg = 'user is not in the group: {0}'.format(request.id.userId)
#raise OrchestratorError( errMsg )
print('ERROR in OrchestratorProtocol:CallShareSecret')
print(errMsg)
userRefs = self.orchestrator.getUserReferences(gid)
calcType = self.orchestrator.calcType( gid )
idMsg = stub.IdentityMessage( userId=request.id.userId, groupId=gid )
for ref in userRefs :
print('calling request data...')
call_future = ref[0].CallShareSecretData.future( stub.ShareSecretDataRequest( id=idMsg ))
call_future.add_done_callback( self.collateDataCallback )
return stub.ShareSecretReply( id=idMsg, success=True )
def CallCollatedSecretShare(self, req, context):
self.cp.myPrint('CallCollatedSecretShare ')
# convert received data back into Player expected formats
calculation = 'PRIVATEKEYSHARE'
calcType = req.calculation
if calcType == enums.LITTLEK:
calculation = 'LITTLEK'
elif calcType == enums.ALPHA:
calculation = 'ALPHA'
hiddenPolys = {}
for hp in req.hiddenPolys:
hiddenPolys[hp.ordinal] = hp.coefficients
hiddenEvals = {}
for ev in req.hiddenEvals:
innerEP = {}
for e in ev.ep:
innerEP[e.ordinal] = e.f_x
hiddenEvals[ev.ordinal] = innerEP
try:
self.cp.Player.createSecret( \
req.id.groupId, calculation, \
hiddenPolys, hiddenEvals )
except Exception as inst:
self.cp.myPrint('exception raised')
self.cp.myPrint(str(inst))
#raise ClientError( [self.user, gid, inst.args ] )
idMsg = stub.IdentityMessage(userId=self.user,
groupId=req.id.groupId)
return stub.CollatedSecretReply(id=idMsg)
def signingCallback (self, call_future ) :
res = call_future.result()
gid = res.id.groupId
ordinal = res.ordinal
sig = res.signature
msg = res.message
# if True then ready to distribute data
if self.orchestrator.signature( gid, ordinal, sig) :
signatureDict = self.orchestrator.getSignatureData(gid)
sigList = []
for ord, sig in signatureDict.items() :
sigData = stub.SigData( ordinal=ord, signature=sig )
sigList.append(sigData)
# send the signature data out to the signer
userRef = self.orchestrator.getSignerReference( gid )
idMsg = stub.IdentityMessage( userId=res.id.userId, groupId=gid )
call_future = userRef[0].CallSignMessage.future( stub.SignDataMessage \
( id=idMsg, message=msg, signatures=sigList ) )
call_future.add_done_callback( self.signingCompletedCallback )
