Skip to content

Commit 1cd1f2b

Browse files
xiansongqxiansongq
committed
modified labelpsi and have some error
1 parent e9c3800 commit 1cd1f2b

File tree

3 files changed

+67
-54
lines changed

3 files changed

+67
-54
lines changed

‎CMakeLists.txt

+3-3
Original file line numberDiff line numberDiff line change
@@ -5,9 +5,9 @@ CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
55
PROJECT(Kunlun)
66
# On some machines, the path of OpenSSL is /usr/local/lib64/openssl/libcrypto.a
77
IF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
8-
SET(OPENSSL_LIBRARIES /usr/local/openssl/lib64/libcrypto.a /usr/local/openssl/lib64/libssl.a)
9-
SET(OPENSSL_INCLUDE_DIR /usr/local/openssl/include)
10-
SET(OPENSSL_DIR /usr/local/openssl/lib64)
8+
SET(OPENSSL_LIBRARIES /usr/local/lib64/libcrypto.a /usr/local/lib64/libssl.a)
9+
SET(OPENSSL_INCLUDE_DIR /usr/local/include)
10+
SET(OPENSSL_DIR /usr/local/lib64)
1111
ELSEIF(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
1212
SET(OPENSSL_LIBRARIES /usr/local/lib/libcrypto.a /usr/local/lib/libssl.a)
1313
SET(OPENSSL_INCLUDE_DIR /usr/local/include)

‎mpc/labelpsi/psi.cpp

+59-46
Original file line numberDiff line numberDiff line change
@@ -20,19 +20,19 @@ SecretKey *receiver_key_leaked;
2020
#endif
2121

2222
void multiply_by_random_mask(Ciphertext &ciphertext,
23-
shared_ptr <UniformRandomGenerator> random,
23+
shared_ptr<UniformRandomGenerator> random,
2424
std::unique_ptr<seal::BatchEncoder> encoder,
2525
std::unique_ptr<seal::Evaluator> evaluator,
2626
RelinKeys &relin_keys,
2727
uint64_t plain_modulus) {
2828
size_t slot_count = encoder->slot_count();
2929
Plaintext mask;
30-
vector <uint64_t> mask_coefficients(slot_count, 0);
30+
vector<uint64_t> mask_coefficients;
3131
for (size_t j = 0; j < slot_count; j++) {
32-
mask_coefficients[j] = random_nonzero_integer(random, plain_modulus);
32+
mask_coefficients.push_back( random_nonzero_integer(random, plain_modulus));
3333
}
3434
encoder->encode(mask_coefficients, mask);
35-
evaluator->multiply_plain_inplace(ciphertext, mask, {});
35+
evaluator->multiply_plain_inplace(ciphertext, mask);
3636
evaluator->relinearize_inplace(ciphertext, relin_keys);
3737
}
3838

@@ -113,7 +113,7 @@ void PSIParams::generate_seeds() {
113113
}
114114
}
115115

116-
void PSIParams::set_seeds(vector <uint64_t> &seeds_ext) {
116+
void PSIParams::set_seeds(vector<uint64_t> &seeds_ext) {
117117
assert(seeds_ext.size() == hash_functions());
118118
seeds = seeds_ext;
119119
}
@@ -220,7 +220,7 @@ void PSIParams::set_window_size(size_t new_value) {
220220
}
221221

222222

223-
uint64_t PSIParams::encode_bucket_element(vector <uint64_t> &inputs, bucket_slot &element, bool is_receiver) {
223+
uint64_t PSIParams::encode_bucket_element(vector<uint64_t> &inputs, bucket_slot &element, bool is_receiver) {
224224
uint64_t result;
225225
if (element != BUCKET_EMPTY) {
226226
// we need to encode:
@@ -255,12 +255,13 @@ receiver_key_leaked = &secret_key;
255255
#endif
256256

257257

258-
vector <Ciphertext> PSIReceiver::encrypt_inputs(vector <uint64_t> &inputs, vector <bucket_slot> &buckets) {
258+
vector<Ciphertext> PSIReceiver::encrypt_inputs(vector<uint64_t> &inputs, vector<bucket_slot> &buckets) {
259259
assert(inputs.size() == params.receiver_size);
260260

261-
std::unique_ptr<seal::Encryptor> encryptor=make_unique<Encryptor>(std::move(*(params.context)),std::move(public_key_));
261+
std::unique_ptr<seal::Encryptor> encryptor = make_unique<Encryptor>(std::move(*(params.context)),
262+
std::move(public_key_));
262263
//Encryptor encryptor(params.context, public_key_);
263-
std::unique_ptr<seal::BatchEncoder> encoder=make_unique<BatchEncoder>(std::move(*(params.context)));
264+
std::unique_ptr<seal::BatchEncoder> encoder = make_unique<BatchEncoder>(std::move(*(params.context)));
264265
//BatchEncoder encoder(params.context);
265266

266267
auto random_factory(UniformRandomGeneratorFactory::DefaultFactory());
@@ -271,7 +272,7 @@ vector <Ciphertext> PSIReceiver::encrypt_inputs(vector <uint64_t> &inputs, vecto
271272
bool res = cuckoo_hash(random, inputs, bucket_count_log, buckets, params.seeds);
272273
assert(res); // TODO: handle gracefully
273274

274-
vector <uint64_t> buckets_enc(bucket_count);
275+
vector<uint64_t> buckets_enc(bucket_count);
275276
size_t partition_count = params.sender_partition_count();
276277
size_t max_partition_size = (params.sender_bucket_capacity() + (partition_count - 1)) / partition_count;
277278
Windowing windowing(params.window_size(), max_partition_size);
@@ -280,23 +281,23 @@ vector <Ciphertext> PSIReceiver::encrypt_inputs(vector <uint64_t> &inputs, vecto
280281
buckets_enc[i] = params.encode_bucket_element(inputs, buckets[i], true);
281282
}
282283

283-
vector <Ciphertext> result;
284+
vector<Ciphertext> result;
284285
windowing.prepare(buckets_enc, result, params.plain_modulus(), std::move(encoder), std::move(encryptor));
285286

286287
return result;
287288
}
288289

289290

290-
vector <size_t> PSIReceiver::decrypt_matches(vector <Ciphertext> &encrypted_matches) {
291-
std::unique_ptr<seal::Decryptor> decryptor=make_unique<Decryptor>(*(params.context),secret_key);
292-
std::unique_ptr<seal::BatchEncoder> encoder=make_unique<BatchEncoder>(*(params.context));
291+
vector<size_t> PSIReceiver::decrypt_matches(vector<Ciphertext> &encrypted_matches) {
292+
std::unique_ptr<seal::Decryptor> decryptor = make_unique<Decryptor>(*(params.context), secret_key);
293+
std::unique_ptr<seal::BatchEncoder> encoder = make_unique<BatchEncoder>(*(params.context));
293294
//Decryptor decryptor(params.context, secret_key);
294295
//BatchEncoder encoder(params.context);
295296
size_t slot_count = encoder->slot_count();
296297

297298
size_t bucket_count = (1 << params.bucket_count_log());
298299

299-
vector <size_t> result;
300+
vector<size_t> result;
300301

301302
Plaintext decrypted;
302303
for (size_t i = 0; i < encrypted_matches.size(); i++) {
@@ -313,23 +314,23 @@ vector <size_t> PSIReceiver::decrypt_matches(vector <Ciphertext> &encrypted_matc
313314
return result;
314315
}
315316

316-
vector <pair<size_t, uint64_t>> PSIReceiver::decrypt_labeled_matches(vector <Ciphertext> &encrypted_matches) {
317+
vector<pair<size_t, uint64_t>> PSIReceiver::decrypt_labeled_matches(vector<Ciphertext> &encrypted_matches) {
317318
assert(encrypted_matches.size() % 2 == 0);
318319

319-
// Decryptor decryptor(params.context, secret_key);
320-
// BatchEncoder encoder(params.context);
321-
std::unique_ptr<seal::Decryptor> decryptor=make_unique<Decryptor>(*(params.context),secret_key);
322-
std::unique_ptr<seal::BatchEncoder> encoder=make_unique<BatchEncoder>(*(params.context));
320+
// Decryptor decryptor(params.context, secret_key);
321+
// BatchEncoder encoder(params.context);
322+
std::unique_ptr<seal::Decryptor> decryptor = make_unique<Decryptor>(*(params.context), secret_key);
323+
std::unique_ptr<seal::BatchEncoder> encoder = make_unique<BatchEncoder>(*(params.context));
323324
size_t slot_count = encoder->slot_count();
324325

325326
size_t bucket_count = (1 << params.bucket_count_log());
326327

327-
vector <pair<size_t, uint64_t>> result;
328+
vector<pair<size_t, uint64_t>> result;
328329

329330
Plaintext decrypted_matches, decrypted_labels;
330331
for (size_t i = 0; i < encrypted_matches.size() / 2; i++) {
331-
vector <uint64_t> result1;
332-
vector <uint64_t> lbresult;
332+
vector<uint64_t> result1;
333+
vector<uint64_t> lbresult;
333334
decryptor->decrypt(encrypted_matches[2 * i], decrypted_matches);
334335
encoder->decode(decrypted_matches, result1);
335336
decryptor->decrypt(encrypted_matches[2 * i + 1], decrypted_labels);
@@ -358,11 +359,11 @@ RelinKeys PSIReceiver::relin_keys() {
358359
PSISender::PSISender(PSIParams &params)
359360
: params(params) {}
360361

361-
vector <Ciphertext> PSISender::compute_matches(vector <uint64_t> &inputs,
362-
optional <vector<uint64_t>> &labels,
363-
PublicKey &receiver_public_key,
364-
RelinKeys relin_keys,
365-
vector <Ciphertext> &receiver_inputs) {
362+
vector<Ciphertext> PSISender::compute_matches(vector<uint64_t> &inputs,
363+
optional<vector<uint64_t>> &labels,
364+
PublicKey &receiver_public_key,
365+
RelinKeys relin_keys,
366+
vector<Ciphertext> &receiver_inputs) {
366367
assert(inputs.size() == params.sender_size);
367368
assert(!labels.has_value() || (labels.value().size() == inputs.size()));
368369

@@ -371,16 +372,16 @@ vector <Ciphertext> PSISender::compute_matches(vector <uint64_t> &inputs,
371372

372373
uint64_t plain_modulus = params.plain_modulus();
373374

374-
std::unique_ptr<seal::Encryptor> encryptor=make_unique<Encryptor>(*(params.context),receiver_public_key);
375-
std::unique_ptr<seal::BatchEncoder> encoder=make_unique<BatchEncoder>(*(params.context));
376-
std::unique_ptr<seal::Evaluator> evaluator=make_unique<Evaluator>(*(params.context));
375+
std::unique_ptr<seal::Encryptor> encryptor = make_unique<Encryptor>(*(params.context), receiver_public_key);
376+
std::unique_ptr<seal::BatchEncoder> encoder = make_unique<BatchEncoder>(*(params.context));
377+
std::unique_ptr<seal::Evaluator> evaluator = make_unique<Evaluator>(*(params.context));
377378

378379
// hash all of the sender's inputs, using every possible hash function, into
379380
// a (capacity × bucket_count) hash table.
380381
size_t bucket_count_log = params.bucket_count_log();
381382
size_t bucket_count = (1 << bucket_count_log);
382383
size_t capacity = params.sender_bucket_capacity();
383-
vector <bucket_slot> buckets;
384+
vector<bucket_slot> buckets;
384385
bool res = complete_hash(random, inputs, bucket_count_log, capacity, buckets, params.seeds);
385386
assert(res); // TODO: handle gracefully
386387

@@ -398,20 +399,20 @@ vector <Ciphertext> PSISender::compute_matches(vector <uint64_t> &inputs,
398399

399400
// if we're doing labeled PSI, we need two ciphertexts per partition:
400401
// one for f(x) and one for r*f(x) + g(x)
401-
vector <Ciphertext> result((labels.has_value() ? 2 : 1) * partition_count);
402+
vector<Ciphertext> result((labels.has_value() ? 2 : 1) * partition_count);
402403

403404
// compute all the powers of the receiver's input.
404-
vector <Ciphertext> powers(max_partition_size + 1);
405+
vector<Ciphertext> powers(max_partition_size + 1);
405406
windowing.compute_powers(receiver_inputs, powers, std::move(evaluator), relin_keys);
406407

407408
// we'll need these vectors for each iteration, so let's declare them here
408409
// to avoid reallocating them anew each time.
409-
vector <uint64_t> current_bucket(max_partition_size);
410-
vector <vector<uint64_t>> f_coeffs(bucket_count);
410+
vector<uint64_t> current_bucket(max_partition_size);
411+
vector<vector<uint64_t>> f_coeffs(bucket_count);
411412
// we'll only need these if we're doing labeled PSI, so we set the sizes to
412413
// 0 if we aren't to avoid unnecessarily wasting memory
413-
vector <uint64_t> current_labels(labels.has_value() ? max_partition_size : 0);
414-
vector <vector<uint64_t>> g_coeffs(labels.has_value() ? bucket_count : 0);
414+
vector<uint64_t> current_labels(labels.has_value() ? max_partition_size : 0);
415+
vector<vector<uint64_t>> g_coeffs(labels.has_value() ? bucket_count : 0);
415416

416417
for (size_t partition = 0; partition < partition_count; partition++) {
417418
// figure out which many rows go into this partition
@@ -472,11 +473,17 @@ vector <Ciphertext> PSISender::compute_matches(vector <uint64_t> &inputs,
472473
for (size_t j = 0; j < partition_size + 1; j++) {
473474
// encode the jth coefficients of all polynomials into a vector
474475
Plaintext f_coeffs_enc(bucket_count, bucket_count);
476+
std::vector<uint64_t> temp;
475477
for (size_t k = 0; k < bucket_count; k++) {
476-
f_coeffs_enc[k] = f_coeffs[k][j];
478+
temp.push_back(f_coeffs[k][j]);
477479
}
480+
encoder->encode(temp, f_coeffs_enc);
481+
// for (size_t k = 0; k < bucket_count; k++) {
482+
// encoder->encode(f_coeffs[k][j],f_coeffs_enc[k]);
483+
// f_coeffs_enc[k] = f_coeffs[k][j];
484+
// }
478485
Plaintext f_coeffs_plaintext;
479-
// encoder.encode(f_coeffs_enc,f_coeffs_plaintext);
486+
//encoder->encode(f_coeffs_enc);
480487

481488
Plaintext g_coeffs_enc;
482489
Plaintext g_coeffs_plaintext;
@@ -490,7 +497,7 @@ vector <Ciphertext> PSISender::compute_matches(vector <uint64_t> &inputs,
490497

491498
// encoder.encode(g_coeffs_enc, g_coeffs_plaintext);
492499
}
493-
500+
std::unique_ptr<seal::Evaluator> evaluator = std::make_unique<Evaluator>(*(params.context));
494501
if (j == 0) {
495502
// the constant term just goes straight into the result, and
496503
// then the other terms will be added into it later.
@@ -503,14 +510,15 @@ vector <Ciphertext> PSISender::compute_matches(vector <uint64_t> &inputs,
503510
// multiply_plain does not allow the second parameter to be zero.
504511
if (!f_coeffs_enc.is_zero()) {
505512
Ciphertext term;
506-
evaluator->multiply_plain(powers[j], f_coeffs_plaintext, term);
513+
//std::cout << powers[j].is_transparent() << std::endl;
514+
evaluator->multiply_plain(powers[j], f_coeffs_enc, term);
507515
evaluator->relinearize_inplace(term, relin_keys);
508516
evaluator->add_inplace(f_evaluated, term);
509517
}
510518

511519
if (!g_coeffs_enc.is_zero()) {
512520
Ciphertext term;
513-
evaluator->multiply_plain(powers[j], g_coeffs_plaintext, term);
521+
evaluator->multiply_plain(powers[j], g_coeffs_enc, term);
514522
evaluator->relinearize_inplace(term, relin_keys);
515523
evaluator->add_inplace(g_evaluated, term);
516524
}
@@ -524,16 +532,21 @@ vector <Ciphertext> PSISender::compute_matches(vector <uint64_t> &inputs,
524532
// for unlabeled PSI, return r * f(x)
525533
// for labeled PSI, return (r * f(x), r' * f(x) + g(x))
526534
// where r and r' are random.
527-
multiply_by_random_mask(f_evaluated, random, std::move(encoder), std::move(evaluator), relin_keys, plain_modulus);
535+
std::unique_ptr<seal::BatchEncoder> encoder = std::make_unique<BatchEncoder>(*(params.context));
536+
std::unique_ptr<seal::Evaluator> evaluator = std::make_unique<Evaluator>(*(params.context));
537+
multiply_by_random_mask(f_evaluated, random, std::move(encoder), std::move(evaluator), relin_keys,
538+
plain_modulus);
528539

529540
#ifdef DEBUG_WITH_KEY_LEAK
530541
cerr << "after mask it is " << decryptor.invariant_noise_budget(f_evaluated) << endl;
531542
#endif
532543

533544
if (labels.has_value()) {
534545
result[2 * partition] = f_evaluated;
535-
536-
multiply_by_random_mask(f_evaluated, random, std::move(encoder), std::move(evaluator), relin_keys, plain_modulus);
546+
std::unique_ptr<seal::BatchEncoder> encoder = make_unique<BatchEncoder>(*(params.context));
547+
std::unique_ptr<seal::Evaluator> evaluator = make_unique<Evaluator>(*(params.context));
548+
multiply_by_random_mask(f_evaluated, random, std::move(encoder), std::move(evaluator), relin_keys,
549+
plain_modulus);
537550

538551
#ifdef DEBUG_WITH_KEY_LEAK
539552
cerr << "after second mask it is " << decryptor.invariant_noise_budget(f_evaluated) << endl;

‎test/mytest/test_labelpsi.cpp

+5-5
Original file line numberDiff line numberDiff line change
@@ -109,11 +109,11 @@ int main(){
109109
vector<size_t> receiver_matches;
110110
receiver_matches = user.decrypt_matches(sender_matches);
111111
cout << receiver_matches.size() << " matches found: ";
112-
// for (auto i : receiver_matches) {
113-
// assert(i < receiver_buckets.size());
114-
// assert(receiver_buckets[i] != BUCKET_EMPTY);
115-
// cout << receiver_inputs[receiver_buckets[i].first] << " ";
116-
// }
112+
for (auto i : receiver_matches) {
113+
//std::assert(i < receiver_buckets.size());
114+
//std::assert(receiver_buckets[i] != BUCKET_EMPTY);
115+
cout << receiver_inputs[receiver_buckets[i].first] << " ";
116+
}
117117
}
118118

119119
cout << endl;

0 commit comments

Comments
 (0)