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")
