def h_func(self, x, xsquare): """Computes the h-function as defined in Paillier's paper page. """ return gmpy_math.invert( self.l_func(gmpy_math.powmod(self.public_key.g, x - 1, xsquare), x), x)
def gen_obfuscator(self, random_value=None): r = random_value or random.SystemRandom().randrange(1, self.n) obfuscator = gmpy_math.powmod(r, self.n, self.nsquare) return obfuscator
def cal_host_ids_process_pair(self, data_instances): return data_instances.map( lambda k, v: ( RsaIntersectionHost.hash(gmpy_math.powmod(int(RsaIntersectionHost.hash(k), 16), self.d, self.n)), k) )
def run(self, data_instances): LOGGER.info("Start rsa intersection") public_key = get(name=self.transfer_variable.rsa_pubkey.name, tag=self.transfer_variable.generate_transferid( self.transfer_variable.rsa_pubkey), idx=0) LOGGER.info("Get RSA public_key:{} from Host".format(public_key)) self.e = public_key["e"] self.n = public_key["n"] # generate random value and sent intersect guest ids to guest # table(sid, r) table_random_value = data_instances.mapValues( lambda v: random.SystemRandom().getrandbits(self.random_bit)) # table(sid, hash(sid)) table_hash_sid = data_instances.map( lambda k, v: (k, int(RsaIntersectionGuest.hash(k), 16))) # table(sid. r^e % n *hash(sid)) table_guest_id = table_random_value.join( table_hash_sid, lambda r, h: h * gmpy_math.powmod(r, self.e, self.n)) # table(r^e % n *hash(sid), 1) table_send_guest_id = table_guest_id.map(lambda k, v: (v, 1)) remote(table_send_guest_id, name=self.transfer_variable.intersect_guest_ids.name, tag=self.transfer_variable.generate_transferid( self.transfer_variable.intersect_guest_ids), role=consts.HOST, idx=0) LOGGER.info("Remote guest_id to Host") # table(r^e % n *hash(sid), sid) table_exchange_guest_id = table_guest_id.map(lambda k, v: (v, k)) # Recv host_ids_process # table(host_id_process, 1) table_host_ids_process = get( name=self.transfer_variable.intersect_host_ids_process.name, tag=self.transfer_variable.generate_transferid( self.transfer_variable.intersect_host_ids_process), idx=0) LOGGER.info("Get host_ids_process from Host") # Recv process guest ids # table(r^e % n *hash(sid), guest_id_process) table_recv_guest_ids_process = get( name=self.transfer_variable.intersect_guest_ids_process.name, tag=self.transfer_variable.generate_transferid( self.transfer_variable.intersect_guest_ids_process), # role=consts.HOST, idx=0) LOGGER.info("Get guest_ids_process from Host") # table(r^e % n *hash(sid), sid, guest_ids_process) table_join_guest_ids_process = table_exchange_guest_id.join( table_recv_guest_ids_process, lambda sid, g: (sid, g)) # table(sid, guest_ids_process) table_sid_guest_ids_process = table_join_guest_ids_process.map( lambda k, v: (v[0], v[1])) # table(sid, hash(guest_ids_process/r))) table_sid_guest_ids_process_final = table_sid_guest_ids_process.join( table_random_value, lambda g, r: hashlib.sha256( bytes(str(gmpy2.divm(int(g), int(r), self.n)), encoding="utf-8")).hexdigest()) # table(hash(guest_ids_process/r), sid) table_guest_ids_process_final_sid = table_sid_guest_ids_process_final.map( lambda k, v: (v, k)) # intersect table(hash(guest_ids_process/r), sid) table_encrypt_intersect_ids = table_guest_ids_process_final_sid.join( table_host_ids_process, lambda sid, h: sid) # intersect table(hash(guest_ids_process/r), 1) table_send_intersect_ids = table_encrypt_intersect_ids.mapValues( lambda v: 1) LOGGER.info("Finish intersect_ids computing") # send intersect id if self.send_intersect_id_flag: remote(table_send_intersect_ids, name=self.transfer_variable.intersect_ids.name, tag=self.transfer_variable.generate_transferid( self.transfer_variable.intersect_ids), role=consts.HOST, idx=0) LOGGER.info("Remote intersect ids to Host!") else: LOGGER.info("Not send intersect ids to Host!") # intersect table(sid, "intersect_id") intersect_ids = table_encrypt_intersect_ids.map(lambda k, v: (v, "intersect_id")) return intersect_ids
def run(self, data_instances): LOGGER.info("Start rsa intersection") public_keys = self.transfer_variable.rsa_pubkey.get(-1) LOGGER.info("Get RSA public_key:{} from Host".format(public_keys)) self.e = [int(public_key["e"]) for public_key in public_keys] self.n = [int(public_key["n"]) for public_key in public_keys] cache_version_match_info = self.get_cache_version_match_info() # generate random value and sent intersect guest ids to guest # table(sid, r) random_value = data_instances.mapValues( lambda v: random.SystemRandom().getrandbits(self.random_bit)) # table(sid, hash(sid)) hash_sid = data_instances.map( lambda k, v: (k, int(RsaIntersectionGuest.hash(k), 16))) # table(sid. r^e % n *hash(sid)) for each host guest_id_list = [] for i in range(len(self.e)): guest_id_list.append( random_value.join( hash_sid, lambda r, h: h * gmpy_math.powmod( r, self.e[i], self.n[i]))) # table(r^e % n *hash(sid), 1) for i, guest_id in enumerate(guest_id_list): mask_guest_id = guest_id.map(lambda k, v: (v, 1)) self.transfer_variable.intersect_guest_ids.remote(mask_guest_id, role=consts.HOST, idx=i) LOGGER.info("Remote guest_id to Host {}".format(i)) # table(r^e % n *hash(sid), sid) exchange_guest_id_kv = [ guest_id.map(lambda k, v: (v, k)) for guest_id in guest_id_list ] host_ids_process_list = self.get_host_id_process( cache_version_match_info) LOGGER.info("Get host_ids_process") # Recv process guest ids # table(r^e % n *hash(sid), guest_id_process) recv_guest_ids_process = self.transfer_variable.intersect_guest_ids_process.get( idx=-1) LOGGER.info("Get guest_ids_process from Host") # table(r^e % n *hash(sid), sid, guest_ids_process) join_guest_ids_process = [ v.join(recv_guest_ids_process[i], lambda sid, g: (sid, g)) for i, v in enumerate(exchange_guest_id_kv) ] # table(sid, guest_ids_process) sid_guest_ids_process = [ e.map(lambda k, v: (v[0], v[1])) for e in join_guest_ids_process ] # table(sid, hash(guest_ids_process/r))) sid_guest_ids_process_final = [ v.join( random_value, lambda g, r: RsaIntersectionGuest.hash( gmpy2.divm(int(g), int(r), self.n[i]))) for i, v in enumerate(sid_guest_ids_process) ] # table(hash(guest_ids_process/r), sid) guest_ids_process_final_kv_exchange = [ e.map(lambda k, v: (v, k)) for e in sid_guest_ids_process_final ] # intersect table(hash(guest_ids_process/r), sid) encrypt_intersect_ids = [ v.join(host_ids_process_list[i], lambda sid, h: sid) for i, v in enumerate(guest_ids_process_final_kv_exchange) ] raw_intersect_ids = [ e.map(lambda k, v: (v, 1)) for e in encrypt_intersect_ids ] intersect_ids = self.get_common_intersection(raw_intersect_ids) LOGGER.info("Finish intersect_ids computing") # send intersect id if self.sync_intersect_ids: for i, host_party_id in enumerate(self.host_party_id_list): remote_intersect_id = self.map_raw_id_to_encrypt_id( intersect_ids, encrypt_intersect_ids[i]) self.transfer_variable.intersect_ids.remote( remote_intersect_id, role=consts.HOST, idx=i) LOGGER.info( "Remote intersect ids to Host {}!".format(host_party_id)) else: LOGGER.info("Not send intersect ids to Host!") if not self.only_output_key: intersect_ids = self._get_value_from_data(intersect_ids, data_instances) return intersect_ids
def decrypt(self, value): if self.d is not None and self.n is not None: return gmpy_math.powmod(value, self.d, self.n) else: return None
def guest_id_process(sid, random_bit, rsa_e, rsa_n): r = random.SystemRandom().getrandbits(random_bit) re_hash = gmpy_math.powmod(r, rsa_e, rsa_n) * int( RsaIntersectionGuest.hash(sid), 16) % rsa_n return re_hash, (sid, r)
def run(self, data_instances): LOGGER.info("Start rsa intersection") encrypt_operator = RsaEncrypt() encrypt_operator.generate_key(rsa_bit=1028) self.e, self.d, self.n = encrypt_operator.get_key_pair() LOGGER.info("Generate rsa keys.") public_key = {"e": self.e, "n": self.n} remote(public_key, name=self.transfer_variable.rsa_pubkey.name, tag=self.transfer_variable.generate_transferid( self.transfer_variable.rsa_pubkey), role=consts.GUEST, idx=0) LOGGER.info("Remote public key to Guest.") # (host_id_process, 1) host_ids_process_pair = data_instances.map( lambda k, v: (RsaIntersectionHost.hash( gmpy_math.powmod(int(RsaIntersectionHost.hash(k), 16), self.d, self.n)), k)) host_ids_process = host_ids_process_pair.mapValues(lambda v: 1) remote(host_ids_process, name=self.transfer_variable.intersect_host_ids_process.name, tag=self.transfer_variable.generate_transferid( self.transfer_variable.intersect_host_ids_process), role=consts.GUEST, idx=0) LOGGER.info("Remote host_ids_process to Guest.") # Recv guest ids guest_ids = get(name=self.transfer_variable.intersect_guest_ids.name, tag=self.transfer_variable.generate_transferid( self.transfer_variable.intersect_guest_ids), idx=0) LOGGER.info("Get guest_ids from guest") # Process guest ids and return to guest guest_ids_process = guest_ids.map( lambda k, v: (k, gmpy_math.powmod(int(k), self.d, self.n))) remote(guest_ids_process, name=self.transfer_variable.intersect_guest_ids_process.name, tag=self.transfer_variable.generate_transferid( self.transfer_variable.intersect_guest_ids_process), role=consts.GUEST, idx=0) LOGGER.info("Remote guest_ids_process to Guest.") # recv intersect ids intersect_ids = None if self.get_intersect_ids_flag: encrypt_intersect_ids = get( name=self.transfer_variable.intersect_ids.name, tag=self.transfer_variable.generate_transferid( self.transfer_variable.intersect_ids), idx=0) intersect_ids_pair = encrypt_intersect_ids.join( host_ids_process_pair, lambda e, h: h) intersect_ids = intersect_ids_pair.map(lambda k, v: (v, "intersect_id")) LOGGER.info("Get intersect ids from Guest") return intersect_ids
def pubkey_id_generate(k, pair): r = random.SystemRandom().getrandbits(random_bit) r_e = gmpy_math.powmod(r, rsa_e, rsa_n) for hash_sid, v in pair: processed_id = r_e * hash_sid % rsa_n yield processed_id, (v[0], r)
def calculate_commitment(self, coefficient): return gmpy_math.powmod(self.g, coefficient, self.p)
def sign_id(hash_sid, rsa_d, rsa_n): return gmpy_math.powmod(hash_sid, rsa_d, rsa_n)