Exemple #1
0
    def handle_msg(self, msg, peer_wss=None):    
        msg_type = msg[:2]
        if msg_type == "1c":
            msg,proofs = msg.split('&;')
        parts = self.preprocess_msg(msg)
        num_parts = len(parts)
        timestamp = parts[1]
        N = int(parts[2])

        
        if msg_type == "1a" and num_parts == 3:
            # a peer is leader for a ballot, requesting votes
            print('a')
            output_msg = self.phase1b(N)
            return output_msg
            
        elif msg_type == "1b" and num_parts == 6:
            # implies is leader for ballot, has quorum object
            self.logger.debug("got 1b!!!")
            [mb,mv,avsSig] = parts[3:6]
            avs, sig = avsSig.split(';')
            
            if N == self.Q.N:
                self.Q.add_1b(int(mb), msg, peer_wss)
                
                if int(mb) > self.maxBal:
                    try:
                        #b = pickle.loads(b''.join(map(decode_to_bytes, avs.split(','))))
                        b = pickle.loads(decode_to_bytes(avs))
                        self.logger.debug("recording mb and avs update: {}, {}".format(mb, b))
                        self.Q.add_avs(int(mb), b)
                    except:
                        self.logger.debug("could not decode avs sent by {}: {}".format(peer_wss, avs))
            else:
                self.logger.error("got bad 1b msg")
                 
        elif msg_type == "1c" and num_parts == 4:
            self.logger.debug("got 1c")
            v = parts[3]
            signed_msgs = proofs.split(',') # 1b proofs in wss;msg;sig format
            if len(signed_msgs) <= self.peers.num_peers:
                # test against pubkey
                self.logger.debug("testing sig here...")
                num_verified = self.peers.verify_sigs(signed_msgs)
                
                if num_verified >= self.peers.quorum_size():
                    self.logger.debug("signature verification succeeded")
                    output_msg = self.phase2b(N,v)
                    return output_msg
                else:
                    self.logger.error("signature verification failed")
            else:
                self.logger.error("too many signatures")
 
        elif msg_type == "2b" and num_parts == 4:
            self.logger.debug("got 2b")
            self.Q.add_2b(N)
        else:
            self.logger.info("non-paxos msg received")
Exemple #2
0
    def verify_sigs(self, msglist):
        num_verified = 0
        
        for item in msglist:
            wss, msg, sig = item.split(';')
            if wss in self.peers:
                
                rsakey = self.peers[wss]
                h = SHA.new(msg.encode())

                #sigmsg = int(sig).to_bytes(256, byteorder='little')
                sigmsg = decode_to_bytes(sig)
                verifier = PKCS1_v1_5.new(rsakey)
                if verifier.verify(h, sigmsg):
                    num_verified += 1
            else:        
                self.conf['log'].info("missing a key for {}".format(wss))

        return num_verified