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 )