fix based-OTE PRF errors

Author: xiansongq

Diff for: CMakeLists.txt

@@ -117,9 +117,9 @@ TARGET_LINK_LIBRARIES(mytest ${OPENSSL_LIBRARIES} OpenMP::OpenMP_CXX ${CMAKE_DL_
 ADD_EXECUTABLE(mypsu test/mypsuTest.cpp)
 TARGET_LINK_LIBRARIES(mypsu ${OPENSSL_LIBRARIES} OpenMP::OpenMP_CXX ${CMAKE_DL_LIBS})
 
-#myfiletest
-ADD_EXECUTABLE(myfile test/mytest/fileTest.cpp test/mytest/PirTest.cpp)
-TARGET_LINK_LIBRARIES(myfile ${OPENSSL_LIBRARIES} OpenMP::OpenMP_CXX ${CMAKE_DL_LIBS})
+#cwPRF psi
+ADD_EXECUTABLE(test_psi_from_cwprf test/mytest/test_psi_from_cwprf.cpp )
+TARGET_LINK_LIBRARIES(test_psi_from_cwprf ${OPENSSL_LIBRARIES} OpenMP::OpenMP_CXX ${CMAKE_DL_LIBS})
 
 # oprf
 ADD_EXECUTABLE(test_oteoprf test/test_oteoprf.cpp)
@@ -195,13 +195,11 @@ if(NOT SEAL_FOUND)
 else()
     message(STATUS "Microsoft SEAL: ${SEAL_DIR}")
 endif()
-# 找不到头文件的临时解决方法
-#find_path(SEAL_INCLUDE_DIRS seal/seal.h PATH_SUFFIXES SEAL-4.0)
-#include_directories(${SEAL_INCLUDE_DIRS})
+
 
 add_library(sealpir mpc/pir/pir.hpp mpc/pir/pir.cpp mpc/pir/pir_client.hpp mpc/pir/pir_client.cpp mpc/pir/pir_server.hpp
         mpc/pir/pir_server.cpp  )
-# mpc/pir/sealpir_keyword.hpp mpc/pir/seal_pir.hpp
+
 
 target_link_libraries(sealpir SEAL::seal)
 

Diff for: README.md

@@ -152,6 +152,10 @@ do the same modification as in MACOS, then compile it according to
     * mqrpmt_psu.hpp: union
     * mqrpmt_private_id.hpp: private-id protocol based on OTE-based OPRF and cwPRF-based mqRPMT
 
+  - /psi
+    * cwprf_psi.hpp set intersection based on cePRF
+    * psi_from_oprf.hpp private set intersection based on OTE-based OPRF
+    
   - /pir
     * pir.hpp pir.cpp SEALPIR sources code
     * pir_client.hpp pir_client.cpp SEALPIR Client

Diff for: mpc/psi/psi_from_oprf.hpp

@@ -5,17 +5,28 @@
 
 #include "../oprf/ote_oprf.hpp"
 #include "../ot/alsz_ote.hpp"
-//为什么会出现错误率过高的情况
+//基于 bloom的 psi可以使用 直接使用plain的不行
 
 namespace OPRFPSI {
+    std::string uintTostring(std::vector<uint8_t> num) {
+        std::string str = "";
+        for (int i = 0; i < num.size(); i++) {
+            str += std::to_string(static_cast<int>(num[i]));
+
+        }
+        return str;
+    }
+
     std::vector<block> Receive(NetIO &io, OTEOPRF::PP &pp, std::vector<block> &vec_Y) {
-        if(vec_Y.size()!= pp.LEN){
+        if (vec_Y.size() != pp.LEN) {
             std::cerr << "|Y| does not match public parameter" << std::endl;
             exit(1);
         }
         auto start_time = std::chrono::steady_clock::now();
-        std::vector<std::vector<uint8_t>> oprf_value = OTEOPRF::Client(io, pp, vec_Y, vec_Y.size());
+        std::vector<std::vector<uint8_t>> oprf_key = OTEOPRF::Server(io, pp);
+        std::vector<std::vector<uint8_t>> oprf_value = OTEOPRF::Evaluate(pp, oprf_key, vec_Y, vec_Y.size());
         std::vector<uint8_t> vec_indication_bit(vec_Y.size());
+        std::vector<block> ans;
         std::string choice = "bloom";
         if (choice == "bloom") {
             BloomFilter filter;
@@ -24,63 +35,73 @@ namespace OPRFPSI {
             char *buffer = new char[filter_size];
             io.ReceiveBytes(buffer, filter_size);
             filter.ReadObject(buffer);
-
             auto bloom_start_time = std::chrono::steady_clock::now();
-            vec_indication_bit=filter.Contain(oprf_value);
+            vec_indication_bit = filter.Contain(oprf_value);
             auto bloom_end_time = std::chrono::steady_clock::now();
             auto running_time1 = bloom_end_time - bloom_start_time;
-            std::cout << "Receiver excute bloom filter query time "
+            std::cout << "Receiver excute bloom filter query takes time= "
                       << std::chrono::duration<double, std::milli>(running_time1).count() << " ms" << std::endl;
             delete[] buffer;
-
             PrintSplitLine('-');
-            std::cout << "mpOPRF-based PSI: Sender ===> BloomFilter(F_k(x_i)) ===> Receiver ["
+            std::cout << "mpOPRF-based PSI: Receive <=== BloomFilter(F_k(x_i)) <=== Sender ["
                       << (double) (filter_size) / (1 << 20) << " MB]" << std::endl;
+            for (int i = 0; i < vec_indication_bit.size(); i++) {
+                if ((int) vec_indication_bit[i] == 1) ans.push_back(vec_Y[i]);
+            }
+            auto end_time = std::chrono::steady_clock::now();
+            auto running_time = end_time - start_time;
+            std::cout << "mpOPRF-based PSI [bloom filter]: Receiver side takes time "
+                      << std::chrono::duration<double, std::milli>(running_time).count() << " ms" << std::endl;
         }
-        int count=0;
-        for(int i=0;i<vec_indication_bit.size();i++){
-            if((int)vec_indication_bit[i]==1) std::cout<<i<<std::endl,count++;
 
+        if (choice == "plain") {
+
+            std::vector<std::string> rev_oprf_values(pp.LEN);
+            std::unordered_set<std::string> S;
+//#pragma omp parallel for num_threads(thread_count)
+            for (auto i = 0; i < pp.LEN; i++) {
+                int len;
+                io.ReceiveInteger(len);
+                std::string str(len,'0');
+                io.ReceiveString(str);
+                if(i==1 ) std::cout<<str<<std::endl;
+                S.insert(str);
+                //std::cout<<rev_oprf_values[i]<<std::endl;
+            }
+
+#pragma omp parallel for num_threads(thread_count)
+            for (auto i = 0; i < pp.LEN; i++) {
+                if (S.find(uintTostring(oprf_value[i])) == S.end()) vec_indication_bit[i] = 0;
+                else vec_indication_bit[i] = 1;
+            }
+#pragma omp parallel for num_threads(thread_count)
+            for (int i = 0; i < vec_indication_bit.size(); i++) {
+                if ((int) vec_indication_bit[i] == 1) ans[i]=vec_Y[i];
+            }
+            auto end_time = std::chrono::steady_clock::now();
+            auto running_time = end_time - start_time;
+            std::cout << "mpOPRF-based PSI (plain): Receiver side takes time "
+                      << std::chrono::duration<double, std::milli>(running_time).count() << " ms" << std::endl;
         }
-        std::cout<<count<<std::endl;
-        std::vector<block> ans;
-        for(int i=0;i<vec_indication_bit.size();i++){
-            if((int)vec_indication_bit[i]==1) ans.push_back(vec_Y[i]);
-        }
-        //OT
-//        auto stime = std::chrono::steady_clock::now();
-//        ALSZOTE::PP p1;
-//        p1 = ALSZOTE::Setup(128);
-//        std::cout<<"start execute OT"<<std::endl;
-//        std::vector<block> ans = ALSZOTE::OnesidedReceive(io, p1, vec_indication_bit, vec_indication_bit.size());
-//        auto etime = std::chrono::steady_clock::now();
-//        auto running_time = etime - stime;
-//        std::cout << "mpOPRF-based PSI: Receiver OT receive time "
-//                  << std::chrono::duration<double, std::milli>(running_time).count() << " ms" << std::endl;
-        auto end_time = std::chrono::steady_clock::now();
-        auto running_time1 = end_time - start_time;
-        std::cout << "mpOPRF-based PSI: Receiver side takes time "
-                  << std::chrono::duration<double, std::milli>(running_time1).count() << " ms" << std::endl;
         return ans;
     }
 
     void Send(NetIO &io, OTEOPRF::PP &pp, std::vector<block> &vec_X) {
-        if(vec_X.size()!= pp.LEN){
+        if (vec_X.size() != pp.LEN) {
             std::cerr << "|X| does not match public parameter" << std::endl;
             exit(1);
         }
         auto start_time = std::chrono::steady_clock::now();
-        std::vector<std::vector<uint8_t>> oprf_key = OTEOPRF::Server(io, pp);
-        std::vector<std::vector<uint8_t>> oprf_value = OTEOPRF::Evaluate(pp, oprf_key, vec_X, vec_X.size());
+        std::vector<std::vector<uint8_t>> oprf_value = OTEOPRF::Client(io, pp, vec_X, vec_X.size());
+        //std::vector<std::vector<uint8_t>> oprf_value = OTEOPRF::Evaluate(pp, oprf_key, vec_X, vec_X.size());
         std::string choice = "bloom";
         if (choice == "bloom") {
-            BloomFilter filter(pp.LEN, 40);
-
+            BloomFilter filter(oprf_value.size(), 40);
             auto bloom_start_time = std::chrono::steady_clock::now();
             filter.Insert(oprf_value);
             auto bloom_end_time = std::chrono::steady_clock::now();
             auto running_time1 = bloom_end_time - bloom_start_time;
-            std::cout << "Receiver execute bloom filter insert time "
+            std::cout << "Sender execute bloom filter insert takes time= "
                       << std::chrono::duration<double, std::milli>(running_time1).count() << " ms" << std::endl;
 
             size_t filter_size = filter.ObjectSize();
@@ -90,23 +111,41 @@ namespace OPRFPSI {
             io.SendBytes(buffer, filter_size);
             filter.ReadObject(buffer);
             delete[] buffer;
+            std::cout << "mpOPRF-based PSI: Sender ===> BloomFilter(F_k(x_i)) ===> Receiver ["
+                      << (double) (oprf_value.size() * pp.LEN) / (1 << 20) << " MB]" << std::endl;
+            PrintSplitLine('-');
+            auto end_time = std::chrono::steady_clock::now();
+            auto running_time = end_time - start_time;
+            std::cout << "mpOPRF-based PSI [bloom filter]: Sender side takes time "
+                      << std::chrono::duration<double, std::milli>(running_time).count() << " ms" << std::endl;
+        }
+        if (choice == "plain") {
+
+            for (int i = 0; i < oprf_value.size(); i++) {
 
+                std::string str = uintTostring(oprf_value[i]);
+                if(i==1 ) std::cout<<str<<std::endl;
+                io.SendInteger(str.size());
+                io.SendString(str);
+            }
+            auto end_time = std::chrono::steady_clock::now();
+            auto running_time = end_time - start_time;
+            std::cout << "mpOPRF-based PSI: Sender side takes time "
+                      << std::chrono::duration<double, std::milli>(running_time).count() << " ms" << std::endl;
         }
         PrintSplitLine('-');
-//        auto stime = std::chrono::steady_clock::now();
-//        ALSZOTE::PP p1;
-//        p1 = ALSZOTE::Setup(128);
-//        std::cout<<"start execute OT"<<std::endl;
-//        ALSZOTE::OnesidedSend(io, p1, vec_X, vec_X.size());
-//        auto etime = std::chrono::steady_clock::now();
-//        auto running_time = etime - stime;
-//        std::cout << "mpOPRF-based PSI: Sender send OT time "
-//                  << std::chrono::duration<double, std::milli>(running_time).count() << " ms" << std::endl;
-        auto end_time = std::chrono::steady_clock::now();
-        auto running_time1 = end_time - start_time;
-        std::cout << "mpOPRF-based PSI [bloom filter]: Sender side takes time "
-                  << std::chrono::duration<double, std::milli>(running_time1).count() << " ms" << std::endl;
+/*        auto stime = std::chrono::steady_clock::now();
+        ALSZOTE::PP p1;
+        p1 = ALSZOTE::Setup(128);
+        std::cout<<"start execute OT"<<std::endl;
+        ALSZOTE::OnesidedSend(io, p1, vec_X, vec_X.size());
+        auto etime = std::chrono::steady_clock::now();
+        auto running_time = etime - stime;
+        std::cout << "mpOPRF-based PSI: Sender send OT time "
+                  << std::chrono::duration<double, std::milli>(running_time).count() << " ms" << std::endl;*/
+
     }
 }
 
+
 #endif