def setUp(self): self.paillier_encrypt = PaillierEncrypt() self.paillier_encrypt.generate_key() self.hetero_lr_gradient = HeteroLogisticGradient(self.paillier_encrypt) size = 10 self.wx = eggroll.parallelize( [self.paillier_encrypt.encrypt(i) for i in range(size)]) self.en_sum_wx_square = eggroll.parallelize( [self.paillier_encrypt.encrypt(np.square(i)) for i in range(size)]) self.w = [i for i in range(size)] self.data_inst = eggroll.parallelize([ Instance(features=[1 for _ in range(size)], label=pow(-1, i % 2)) for i in range(size) ], partition=1) # test fore_gradient self.fore_gradient_local = [ -0.5, 0.75, 0, 1.25, 0.5, 1.75, 1, 2.25, 1.5, 2.75 ] # test gradient self.gradient = [ 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125 ] self.gradient_fit_intercept = [ 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125 ] self.loss = 4.505647
def __init__(self, params: FeatureBinningParam): super(HeteroFeatureBinningHost, self).__init__(params) self.encryptor = PaillierEncrypt() self.iv_attrs = [] self.party_name = consts.HOST self._init_binning_obj()
def generate_encrypter(self): LOGGER.info("generate encrypter") if self.encrypt_param.method == consts.PAILLIER: self.encrypter = PaillierEncrypt() self.encrypter.generate_key(self.encrypt_param.key_length) else: raise NotImplementedError("encrypt method not supported yes!!!")
def test_data_type(self, mode="strict", re_encrypted_rate=0.2): from federatedml.secureprotol import PaillierEncrypt from federatedml.secureprotol.encrypt_mode import EncryptModeCalculator encrypter = PaillierEncrypt() encrypter.generate_key(1024) encrypted_calculator = EncryptModeCalculator(encrypter, mode, re_encrypted_rate) data_list = dict( encrypted_calculator.encrypt(self.data_list).collect()) data_tuple = dict( encrypted_calculator.encrypt(self.data_tuple).collect()) data_numpy = dict( encrypted_calculator.encrypt(self.data_numpy).collect()) for key, value in data_list.items(): self.assertTrue(isinstance(value, list)) self.assertTrue(len(value) == len(self.list_data[key])) for key, value in data_tuple.items(): self.assertTrue(isinstance(value, tuple)) self.assertTrue(len(value) == len(self.tuple_data[key])) for key, value in data_numpy.items(): self.assertTrue(type(value).__name__ == "ndarray") self.assertTrue(value.shape[0] == self.numpy_data[key].shape[0])
def _init_model(self, params: LogisticRegressionParam): super()._init_model(params) self.encrypted_mode_calculator_param = params.encrypted_mode_calculator_param if self.role == consts.HOST: self.init_param_obj.fit_intercept = False self.cipher = PaillierEncrypt() self.cipher.generate_key(self.model_param.encrypt_param.key_length) self.transfer_variable = SSHEModelTransferVariable() self.one_vs_rest_obj = one_vs_rest_factory(self, role=self.role, mode=self.mode, has_arbiter=False) self.converge_func_name = params.early_stop self.reveal_every_iter = params.reveal_every_iter self.q_field = self._transfer_q_field() LOGGER.debug(f"q_field: {self.q_field}") if not self.reveal_every_iter: self.self_optimizer = copy.deepcopy(self.optimizer) self.remote_optimizer = copy.deepcopy(self.optimizer) self.batch_generator = batch_generator.Guest( ) if self.role == consts.GUEST else batch_generator.Host() self.batch_generator.register_batch_generator( BatchGeneratorTransferVariable(), has_arbiter=False) self.fixedpoint_encoder = FixedPointEndec(n=self.q_field) self.converge_transfer_variable = ConvergeCheckerTransferVariable() self.secure_matrix_obj = SecureMatrix(party=self.local_party, q_field=self.q_field, other_party=self.other_party)
def test_tensor_op(self): arr1 = np.ones((10, 1, 3)) arr1[0] = np.array([[2, 3, 4]]) arr2 = np.ones((10, 3, 3)) arr3 = np.ones([1, 1, 3]) arr4 = np.ones([50, 1]) arr5 = np.ones([32]) pt = PaillierTensor(arr1) pt2 = PaillierTensor(arr2) pt3 = PaillierTensor(arr3) pt4 = PaillierTensor(arr4) pt5 = PaillierTensor(arr5) encrypter = PaillierEncrypt() encrypter.generate_key(EncryptParam().key_length) encrypted_calculator = EncryptModeCalculator( encrypter, EncryptedModeCalculatorParam().mode, EncryptedModeCalculatorParam().re_encrypted_rate) rs1 = pt * arr2 rs2 = pt * pt2 rs3 = pt.matmul_3d(pt2) enpt = pt2.encrypt(encrypted_calculator) enrs = enpt.matmul_3d(arr1, multiply='right') rng_generator = random_number_generator.RandomNumberGenerator() enpt2 = pt4.encrypt(encrypted_calculator) random_num = rng_generator.generate_random_number(enpt2.shape)
def __init__(self, params: FeatureBinningParam): super(HeteroFeatureBinningGuest, self).__init__(params) self.encryptor = PaillierEncrypt() self.encryptor.generate_key() self.iv_attrs = None self.host_iv_attrs = None
def __init__(self): super(HeteroFeatureBinningGuest, self).__init__() self.encryptor = PaillierEncrypt() self.encryptor.generate_key() self.local_transform_result = None self.party_name = consts.GUEST
def setUp(self): self.paillier_encrypt = PaillierEncrypt() self.paillier_encrypt.generate_key() self.gradient_operator = LogisticGradient() self.taylor_operator = TaylorLogisticGradient() self.X = np.array([[1, 2, 3, 4, 5], [3, 2, 4, 5, 1], [ 2, 2, 3, 1, 1, ]]) / 10 self.X1 = np.c_[self.X, np.ones(3)] self.Y = np.array([[1], [1], [-1]]) self.values = [] for idx, x in enumerate(self.X): inst = Instance(inst_id=idx, features=x, label=self.Y[idx]) self.values.append((idx, inst)) self.values1 = [] for idx, x in enumerate(self.X1): inst = Instance(inst_id=idx, features=x, label=self.Y[idx]) self.values1.append((idx, inst)) self.coef = np.array([2, 2.3, 3, 4, 2.1]) / 10 self.coef1 = np.append(self.coef, [1])
def setUp(self): self.paillier_encrypt = PaillierEncrypt() self.paillier_encrypt.generate_key() # self.hetero_lr_gradient = HeteroLogisticGradient(self.paillier_encrypt) self.hetero_lr_gradient = hetero_lr_gradient_and_loss.Guest() size = 10 self.en_wx = session.parallelize([self.paillier_encrypt.encrypt(i) for i in range(size)], partition=48, include_key=False) # self.en_wx = session.parallelize([self.paillier_encrypt.encrypt(i) for i in range(size)]) self.en_sum_wx_square = session.parallelize([self.paillier_encrypt.encrypt(np.square(i)) for i in range(size)], partition=48, include_key=False) self.wx = np.array([i for i in range(size)]) self.w = self.wx / np.array([1 for _ in range(size)]) self.data_inst = session.parallelize( [Instance(features=np.array([1 for _ in range(size)]), label=pow(-1, i % 2)) for i in range(size)], partition=48, include_key=False) # test fore_gradient self.fore_gradient_local = [-0.5, 0.75, 0, 1.25, 0.5, 1.75, 1, 2.25, 1.5, 2.75] # test gradient self.gradient = [1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125] self.gradient_fit_intercept = [1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125] self.loss = 4.505647
def __init__(self): super(HomoLRGuest, self).__init__() self.gradient_operator = LogisticGradient() self.loss_history = [] self.role = consts.GUEST self.aggregator = aggregator.Guest() self.zcl_encrypt_operator = PaillierEncrypt()
def generate_encrypter(self, param): LOGGER.info("generate encrypter") if param.encrypt_param.method.lower() == consts.PAILLIER.lower(): encrypter = PaillierEncrypt() encrypter.generate_key(param.encrypt_param.key_length) else: raise NotImplementedError("encrypt method not supported yet!!!") return encrypter
def generate_encrypter(self): LOGGER.info("generate encrypter") if self.encrypt_param.method.lower() == consts.PAILLIER.lower(): self.encrypter = PaillierEncrypt() self.encrypter.generate_key(self.encrypt_param.key_length) else: raise NotImplementedError("unknown encrypt type {}".format( self.encrypt_param.method.lower()))
def EINI_guest_predict(data_inst, trees: List[HeteroDecisionTreeGuest], learning_rate, init_score, booster_dim, encrypt_key_length, transfer_var: HeteroSecureBoostTransferVariable, sitename=None, party_list=None, predict_cache=None, pred_leaf=False): if sitename is None: raise ValueError( 'input sitename is None, not able to run EINI predict algorithm') if pred_leaf: raise ValueError( 'EINI predict mode does not support leaf idx prediction') # EINI algorithms id_pos_map_list = get_leaf_idx_map(trees) map_func = functools.partial(generate_leaf_candidates_guest, sitename=sitename, trees=trees, node_pos_map_list=id_pos_map_list, init_score=init_score, learning_rate=learning_rate, booster_dim=booster_dim) position_vec = data_inst.mapValues(map_func) # encryption encrypter = PaillierEncrypt() encrypter.generate_key(encrypt_key_length) encrypter_vec_table = position_vec.mapValues(encrypter.recursive_encrypt) # federation part # send to first host party transfer_var.guest_predict_data.remote(encrypter_vec_table, idx=0, suffix='position_vec', role=consts.HOST) # get from last host party result_table = transfer_var.host_predict_data.get(idx=len(party_list) - 1, suffix='merge_result', role=consts.HOST) # decode result result = result_table.mapValues(encrypter.recursive_decrypt) # reformat result = result.mapValues(lambda x: np.array(x)) if predict_cache: result = result.join(predict_cache, lambda v1, v2: v1 + v2) return result
def __init__(self): super(HomoLRHost, self).__init__() self.gradient_operator = None self.loss_history = [] self.is_converged = False self.role = consts.HOST self.aggregator = aggregator.Host() self.model_weights = None self.cipher = paillier_cipher.Host() self.zcl_encrypt_operator = PaillierEncrypt()
def load_single_model(self, single_model_obj): super(HeteroLRGuest, self).load_single_model(single_model_obj) if not self.is_respectively_reveal: cipher_info = single_model_obj.cipher self.cipher = PaillierEncrypt() public_key = PaillierPublicKey(int(cipher_info.public_key.n)) privacy_key = PaillierPrivateKey(public_key, int(cipher_info.private_key.p), int(cipher_info.private_key.q)) self.cipher.set_public_key(public_key=public_key) self.cipher.set_privacy_key(privacy_key=privacy_key)
class TestHomoLRGradient(unittest.TestCase): def setUp(self): self.paillier_encrypt = PaillierEncrypt() self.paillier_encrypt.generate_key() self.gradient_operator = LogisticGradient() self.taylor_operator = TaylorLogisticGradient() self.X = np.array([[1, 2, 3, 4, 5], [3, 2, 4, 5, 1], [ 2, 2, 3, 1, 1, ]]) / 10 self.X1 = np.c_[self.X, np.ones(3)] self.Y = np.array([[1], [1], [-1]]) self.values = [] for idx, x in enumerate(self.X): inst = Instance(inst_id=idx, features=x, label=self.Y[idx]) self.values.append((idx, inst)) self.values1 = [] for idx, x in enumerate(self.X1): inst = Instance(inst_id=idx, features=x, label=self.Y[idx]) self.values1.append((idx, inst)) self.coef = np.array([2, 2.3, 3, 4, 2.1]) / 10 self.coef1 = np.append(self.coef, [1]) def test_gradient_length(self): fit_intercept = False grad, loss = self.gradient_operator.compute(self.values, self.coef, 0, fit_intercept) self.assertEqual(grad.shape[0], self.X.shape[1]) taylor_grad, loss = self.taylor_operator.compute( self.values, self.coef, 0, fit_intercept) self.assertEqual(taylor_grad.shape[0], self.X.shape[1]) self.assertTrue(np.sum(grad - taylor_grad) < 0.0001) fit_intercept = True grad, loss = self.gradient_operator.compute(self.values, self.coef, 0, fit_intercept) self.assertEqual(grad.shape[0], self.X.shape[1] + 1) taylor_grad, loss = self.taylor_operator.compute( self.values, self.coef, 0, fit_intercept) self.assertEqual(taylor_grad.shape[0], self.X.shape[1] + 1) self.assertTrue(np.sum(grad - taylor_grad) < 0.0001)
def test_diff_mode(self, round=10, mode="strict", re_encrypted_rate=0.2): from federatedml.secureprotol.encrypt_mode import EncryptModeCalculator from federatedml.secureprotol import PaillierEncrypt encrypter = PaillierEncrypt() encrypter.generate_key(1024) encrypted_calculator = EncryptModeCalculator(encrypter, mode, re_encrypted_rate) for i in range(round): data_i = self.data_numpy.mapValues(lambda v: v + i) data_i = encrypted_calculator.encrypt(data_i) decrypt_data_i = dict(data_i.mapValues(lambda arr: np.array([encrypter.decrypt(val) for val in arr])).collect()) for j in range(30): self.assertTrue(np.fabs(self.numpy_data[j] - decrypt_data_i[j] + i).all() < 1e-5)
def load_single_model(self, single_model_obj): LOGGER.info("start to load single model") self.load_single_model_weight(single_model_obj) self.n_iter_ = single_model_obj.iters if not self.is_respectively_reveal: cipher_info = single_model_obj.cipher self.cipher = PaillierEncrypt() public_key = PaillierPublicKey(int(cipher_info.public_key.n)) privacy_key = PaillierPrivateKey(public_key, int(cipher_info.private_key.p), int(cipher_info.private_key.q)) self.cipher.set_public_key(public_key=public_key) self.cipher.set_privacy_key(privacy_key=privacy_key) return self
def __synchronize_encryption(self): """ Communicate with hosts. Specify whether use encryption or not and transfer the public keys. """ # 1. Use Encrypt: Specify which host use encryption host_use_encryption_id = self.transfer_variable.generate_transferid( self.transfer_variable.use_encrypt) host_use_encryption = federation.get( name=self.transfer_variable.use_encrypt.name, tag=host_use_encryption_id, idx=-1) self.host_use_encryption = host_use_encryption LOGGER.info("host use encryption: {}".format(self.host_use_encryption)) # 2. Send pubkey to those use-encryption hosts for idx, use_encryption in enumerate(self.host_use_encryption): if not use_encryption: encrypter = FakeEncrypt() else: encrypter = PaillierEncrypt() encrypter.generate_key(self.encrypt_param.key_length) pub_key = encrypter.get_public_key() pubkey_id = self.transfer_variable.generate_transferid( self.transfer_variable.paillier_pubkey) federation.remote( pub_key, name=self.transfer_variable.paillier_pubkey.name, tag=pubkey_id, role=consts.HOST, idx=idx) # LOGGER.debug("send pubkey to host: {}".format(idx)) self.host_encrypter.append(encrypter) self.has_sychronized_encryption = True
def __init__(self, network_embedding_params: NetworkEmbeddingParam): self.param = network_embedding_params # set params NetworkEmbeddingChecker.check_param(network_embedding_params) self.dim = network_embedding_params.dim self.n_node = network_embedding_params.n_node self.init_param_obj = network_embedding_params.init_param self.learning_rate = network_embedding_params.learning_rate self.encrypted_mode_calculator_param = network_embedding_params.encrypted_mode_calculator_param self.encrypted_calculator = None self.updater = EmUpdater() self.eps = network_embedding_params.eps self.batch_size = network_embedding_params.batch_size self.max_iter = network_embedding_params.max_iter if network_embedding_params.encrypt_param.method == consts.PAILLIER: self.encrypt_operator = PaillierEncrypt() else: self.encrypt_operator = FakeEncrypt() # attribute: self.n_iter_ = 0 self.embedding_ = None self.gradient_operator = None self.initializer = EmbeddingInitializer() self.transfer_variable = None self.model_meta = NetworkEmbeddingModelMeta() self.loss_history = [] self.is_converged = False self.class_name = self.__class__.__name__
def __init__(self, logistic_params: LogisticParam): # set params self.alpha = logistic_params.alpha self.init_param_obj = logistic_params.init_param self.fit_intercept = self.init_param_obj.fit_intercept self.learning_rate = logistic_params.learning_rate if logistic_params.penalty == consts.L1_PENALTY: self.updater = L1Updater(self.alpha, self.learning_rate) elif logistic_params.penalty == consts.L2_PENALTY: self.updater = L2Updater(self.alpha, self.learning_rate) else: self.updater = None self.eps = logistic_params.eps self.batch_size = logistic_params.batch_size self.max_iter = logistic_params.max_iter if logistic_params.encrypt_param.method == consts.PAILLIER: self.encrypt_operator = PaillierEncrypt() else: self.encrypt_operator = FakeEncrypt() # attribute: self.n_iter_ = 0 self.coef_ = None self.intercept_ = 0 self.classes_ = None self.gradient_operator = None self.initializer = Initializer() self.transfer_variable = None self.model_meta = LogisticRegressionModelMeta()
def test_encrypt_and_decrypt(self): from federatedml.secureprotol import PaillierEncrypt from federatedml.secureprotol.encrypt_mode import EncryptModeCalculator encrypter = PaillierEncrypt() encrypter.generate_key(1024) encrypted_calculator = EncryptModeCalculator(encrypter, "fast") encrypter_tensor = self.paillier_tensor1.encrypt(encrypted_calculator) decrypted_tensor = encrypter_tensor.decrypt(encrypter) self.assertTrue(isinstance(encrypter_tensor, PaillierTensor)) self.assertTrue(isinstance(decrypted_tensor, PaillierTensor)) arr = decrypted_tensor.numpy() self.assertTrue(abs(arr.sum() - 10000) < consts.FLOAT_ZERO)
def _init_model(self, params): super()._init_model(params) self.encrypted_mode_calculator_param = params.encrypted_mode_calculator_param self.cipher_operator = PaillierEncrypt() self.transfer_variable = HeteroLRTransferVariable() self.cipher.register_paillier_cipher(self.transfer_variable) self.converge_procedure.register_convergence(self.transfer_variable) self.batch_generator.register_batch_generator(self.transfer_variable) self.gradient_loss_operator.register_gradient_procedure( self.transfer_variable) if len(self.component_properties.host_party_idlist) == 1: self.gradient_loss_operator.set_use_async() self.gradient_loss_operator.set_fixed_float_precision( self.model_param.floating_point_precision) if params.optimizer == 'sqn': gradient_loss_operator = sqn_factory(self.role, params.sqn_param) gradient_loss_operator.register_gradient_computer( self.gradient_loss_operator) gradient_loss_operator.register_transfer_variable( self.transfer_variable) self.gradient_loss_operator = gradient_loss_operator LOGGER.debug( "In _init_model, optimizer: {}, gradient_loss_operator: {}". format(params.optimizer, self.gradient_loss_operator))
def keygen(self, key_length, suffix=tuple()) -> dict: use_cipher = self._use_encrypt.get_parties( parties=self._client_parties, suffix=suffix) ciphers = dict() for party, use_encryption in zip(self._client_parties, use_cipher): if not use_encryption: ciphers[party] = None else: cipher = PaillierEncrypt() cipher.generate_key(key_length) pub_key = cipher.get_public_key() self._pailler_pubkey.remote_parties(obj=pub_key, parties=[party], suffix=suffix) ciphers[party] = cipher return ciphers
def __init__(self): super(BasePoissonRegression, self).__init__() self.model_param = PoissonParam() # attribute: self.model_name = 'PoissonRegression' self.model_param_name = 'PoissonRegressionParam' self.model_meta_name = 'PoissonRegressionMeta' self.cipher_operator = PaillierEncrypt() self.exposure_index = -1
def _init_model(self, params): super()._init_model(params) self.encrypted_mode_calculator_param = params.encrypted_mode_calculator_param self.cipher_operator = PaillierEncrypt() self.transfer_variable = HeteroFMTransferVariable() self.cipher.register_paillier_cipher(self.transfer_variable) self.converge_procedure.register_convergence(self.transfer_variable) self.batch_generator.register_batch_generator(self.transfer_variable) self.gradient_loss_operator.register_gradient_procedure( self.transfer_variable)
class TestHeteroLogisticGradient(unittest.TestCase): def setUp(self): self.paillier_encrypt = PaillierEncrypt() self.paillier_encrypt.generate_key() self.hetero_lr_gradient = HeteroLogisticGradient(self.paillier_encrypt) size = 10 self.wx = eggroll.parallelize([self.paillier_encrypt.encrypt(i) for i in range(size)]) self.en_sum_wx_square = eggroll.parallelize([self.paillier_encrypt.encrypt(np.square(i)) for i in range(size)]) self.w = [i for i in range(size)] self.data_inst = eggroll.parallelize( [Instance(features=[1 for _ in range(size)], label=pow(-1, i % 2)) for i in range(size)], partition=1) # test fore_gradient self.fore_gradient_local = [-0.5, 0.75, 0, 1.25, 0.5, 1.75, 1, 2.25, 1.5, 2.75] # test gradient self.gradient = [1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125] self.gradient_fit_intercept = [1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125] self.loss = 4.505647 def test_compute_fore_gradient(self): fore_gradient = self.hetero_lr_gradient.compute_fore_gradient(self.data_inst, self.wx) fore_gradient_local = [self.paillier_encrypt.decrypt(iterator[1]) for iterator in fore_gradient.collect()] self.assertListEqual(fore_gradient_local, self.fore_gradient_local) def test_compute_gradient(self): fore_gradient = self.hetero_lr_gradient.compute_fore_gradient(self.data_inst, self.wx) gradient = self.hetero_lr_gradient.compute_gradient(self.data_inst, fore_gradient, fit_intercept=False) de_gradient = [self.paillier_encrypt.decrypt(iterator) for iterator in gradient] self.assertListEqual(de_gradient, self.gradient) gradient = self.hetero_lr_gradient.compute_gradient(self.data_inst, fore_gradient, fit_intercept=True) de_gradient = [self.paillier_encrypt.decrypt(iterator) for iterator in gradient] self.assertListEqual(de_gradient, self.gradient_fit_intercept) def test_compute_gradient_and_loss(self): fore_gradient = self.hetero_lr_gradient.compute_fore_gradient(self.data_inst, self.wx) gradient, loss = self.hetero_lr_gradient.compute_gradient_and_loss(self.data_inst, fore_gradient, self.wx, self.en_sum_wx_square, False) de_gradient = [self.paillier_encrypt.decrypt(i) for i in gradient] self.assertListEqual(de_gradient, self.gradient) diff_loss = np.abs(self.loss - self.paillier_encrypt.decrypt(loss)) self.assertLess(diff_loss, 1e-5)
def generate_encrypter(self): LOGGER.info("generate encrypter") if self.encrypt_param.method.lower() == consts.PAILLIER.lower(): self.encrypter = PaillierEncrypt() self.encrypter.generate_key(self.encrypt_param.key_length) elif self.encrypt_param.method.lower() == consts.ITERATIVEAFFINE.lower(): self.encrypter = IterativeAffineEncrypt() self.encrypter.generate_key(self.encrypt_param.key_length) else: raise NotImplementedError("encrypt method not supported yes!!!") self.encrypted_calculator = EncryptModeCalculator(self.encrypter, self.calculated_mode, self.re_encrypted_rate)
def __synchronize_encryption(self, mode='train'): """ Communicate with hosts. Specify whether use encryption or not and transfer the public keys. """ # 2. Send pubkey to those use-encryption guest & hosts encrypter = PaillierEncrypt() encrypter.generate_key(self.key_length) pub_key = encrypter.get_public_key() # LOGGER.debug("Start to remote pub_key: {}, transfer_id: {}".format(pub_key, pubkey_id)) self.transfer_variable.paillier_pubkey.remote(obj=pub_key, role=consts.GUEST, idx=0, suffix=(mode, )) LOGGER.info("send pubkey to guest") pri_key = encrypter.get_privacy_key() self.transfer_variable.paillier_prikey.remote(obj=pri_key, role=consts.GUEST, idx=0, suffix=(mode, )) # LOGGER.debug("Start to remote pri_key: {}, transfer_id: {}".format(pri_key, prikey_id)) LOGGER.info("send prikey to guest") self.transfer_variable.paillier_pubkey.remote(obj=pub_key, role=consts.HOST, idx=-1, suffix=(mode, )) LOGGER.info("send pubkey to host") self.transfer_variable.paillier_prikey.remote(obj=pri_key, role=consts.HOST, idx=-1, suffix=(mode, )) LOGGER.info("send prikey to host")