本文主要講解一個多方的PSI協議，文章轉載：隱私計算關鍵技術：多方隱私集合求交（PSI）從原理到實現以及多方隱私求交——基於OPPRF的MULTI-PARTY PSI；原論文：Practical Multi-party Private Set Intersection from Symmetric-Key Techniques[ACM CCS 2017]；開源庫
上次介紹了兩方PSI協議：隱私集合求交（PSI）-兩方，用到了cuckoo hash和OPRF技術，下面介紹的多方PSI在基於這些技術上進行改進。
問題
在絕大多數情況下，隱私計算的參與方是要多於3方的。因此我們更需要一種能夠實現任意多方之間PSI的方法，同時在性能上也要能滿足大量樣本計算的要求。
多方PSI思路
我們假設有\(X\)個參與方，每個參與方都持有一些樣本，所有的樣本都是集合\(X\)中的元素。我們可以分兩步完成多方樣本交集的計算。爲了方便說明原理，我們假設自己作爲可信第三方，來協助各個參與方完成計算過程。而實際上的算法實現，就是用技術手段替代掉了這個可信第三方，保證整個過程中各個參與方都沒有任何數據泄露給任何人。
有條件的祕密共享
這裏的有條件的指的是有可信第三方
我們對集合\(X\)中的每一個元素，都隨機生成\(n\)個數字（每個參與方一個數字），保證這\(n\)個數字的和是\(0\)。然後我們給\(n\)個參與方分發這些數字：如果參與方持有這個元素，我們就把生成的數字發給他，如果參與方沒有持有這個元素，我們就隨機生成另一個數字發給他。
這就是Zero-Sharing技術，具體如下：
可以看出，假如有一個元素是所有參與方都持有的，那麼把所有參與方拿到的數字加起來，就是\(0\)。假如這個元素不是每個參與方都有，所有的參與方的數字加起來，就是一個隨機數。
有條件的解密
對集合\(X\)中的每一個元素，詢問每個參與方在上一步中得到的數字，並把得到的全部數字相加，如果結果爲\(0\)，就表明所有參與方都持有這個元素（是PSI計算結果中的一個）。對\(X\)中的每個元素都執行這個過程後，我們就得到了多方PSI的結果。
忽略技術細節和這兩個步驟的名字的話，多方PSI計算的原理，是不是還挺簡單的。
但是我們是在可信第三方的協助下完成了計算，這個可信第三方是知道了每個參與方的全部樣本數據的，這並不符合PSI的要求，即每個參與方的全部樣本數據，不能對任何外部人泄露。所以，爲了不泄露額外的信息，我們使用OPPRF協議來替代掉可信第三方，實現上述的有條件地祕密分享與解密兩個步驟。
多方PSI+OPPRF
OPPRF是基於OPRF來構建的（少了一個Programmable，即可編程性），我們首先得了解OPRF，然後在OPRF的基礎上擴展出OPPRF。
OPRF
OPRF的講解在上篇文章已說過，如下圖：
OPRF的全稱是Oblivious Pseudo-Random Function，即不經意僞隨機函數。
OPRF是一個兩方的協議，協議中，一方爲發送者\(S\)，一方爲接收者\(R\)。協議運行前，接收者\(S\)有一系列輸入\(q_1,q_2,...,q_t\)。運行OPRF協議之後，發送者\(S\)可以得到一個PRF（僞隨機函數）\(F\)的密鑰\(K\)，接收者\(R\)可以得到一系列僞隨機函數的計算結果\(F(K,q_1),F(K,q_2),...,F(K,q_t)\)，同時，發送者\(S\)不知道接收者\(R\)的輸入，接收者\(R\)也不知道發送者\(S\)得到的密鑰\(K\)。這就好像是有一個“上帝”，隨機選了個\(K\)作爲PRF的密鑰，把\(K\)發給了發送者\(S\)，然後計算了\(F(K,q_1),F(K,q_2),...,F(K,q_t)\)，並將他們發送給接收者\(R\)。當然，實際上不存在這樣一個第三方的“上帝”，OPRF完全是由發送者\(S\)與接收者\(R\)兩方實現的。
在上篇文章中使用OPRF實現了一個兩方的PSI算法。
假設發送者\(S\)與接收者\(R\)分別持有\(a_1,a_2,...,a_n\)和\(b_1,b_2,...,b_m\)，他們要進行PSI，接收者[公式]可以把他持有的元素[公式]作爲OPRF的輸入，那麼接收者\(R\)可以得到\(F(K,b_1),F(K,b_2),...,F(K,b_m)\)，發送者\(S\)已知\(K\)，在本地即可計算出\(F(K,a_1),F(K,a_2),...,F(K,a_n)\)。發送者\(S\)將本地計算的\(F(K,a_1),F(K,a_2),...,F(K,a_n)\)發送給接收者\(R\)，接收者\(R\)在本地與\(F(K,b_1),F(K,b_2),...,F(K,b_m)\)進行對比，即可完成PSI。在這個過程中，發送者[公式]全程沒看到接收方\(S\)的輸入，而接收方\(R\)看到的都是PRF的輸出結果，無法反推輸入，同時也沒有密鑰\(K\)，無法得到結果後暴力搜索，這就保證了PSI中兩方的數據隱私。
OPPRF
OPPRF的全稱是Oblivious Programmable Pseudo-Random Function，即可編程的不經意僞隨機函數。與OPRF相比，多了一條可編程的性質，即發送者\(S\)可以設置PRF在某些點上的輸出，這些點以及PRF的輸出由發送者\(S\)選定。先不管是怎麼實現的，反正OPPRF可以實現這樣的功能：
我有三個數據：\(a,b,c\)，當別人來找我查數據，如果別人查的是這三個中的一個，我就返回一個預先定義好的數字，如果別人查的不是這三個中的一個，我就返回一個隨機數。並且，我全程不知道別人查的是什麼，他也不知道拿到的到底是隨機數還是預先定義好的結果。
這個功能看起來，是不是和之前PSI原理的第一步特別相關。正是通過OPPRF實現的這個功能，我們做到了在不暴露各個參與方的數據的前提下，完成了祕密分享的分發。
下面具體講一講OPPRF算法：
OPPRF的正確性：
OPPRF需要保證，對於\((x,y)\in P,(k,hint)\leftarrow P,F(k,hint,x)=y\)一定成立。
類似OPRF，OPPRF的機制可以這麼描述：發送者\(S\)有一系列點 \(P=(x,_1,y_1),(x_2,y_2),...,(x_n,y_n)\)，接收者\(R\)有一系列輸入\(q_1,q_2,..,q_t\)，運行OPPRF後，發送者\(S\)得到了\(KeyGen(P)\)的輸出\((k,hint)\)，接收者\(R\)得到了\(F(k,hint,q_1),F(k,hint,q_2),...,F(k,hint,q_t),\)以及\(hint\)。
OPPRF的安全性：
相比OPRF，OPPRF的接收者\(R\)額外獲得了一部分信息，即\(hint\)，而\(hint\)是根據發送者的輸入\(P\)生成的，這可能會帶來一些額外的安全隱患。
所以，在安全性上，OPPRF需要保證，即使得到了\(hint\)以及PRF在\(q_1,q_2,..,q_t\)上的輸出，接收者\(R\)也無法區分出某個點\(x\)是否屬於\(P\)（前提是\(P\)中的\(y_1,y_2,...,y_n\)都是隨機的，不能是一個固定的值）。這一點，我們稱爲OPPRF的安全性。安全性其實隱含了對於不屬於\(P\)的點\(x\)，PRF在\(x\)上的輸出也是隨機的。
由於OPPRF與OPRF的形式很類似，只是多了個\(hint\)，所以，OPPRF是在OPRF的基礎上構建的。OPPRF有多種構建方式，他們的區別只是在如何構建\(hint\)，以及如何使用\(hint\)來保證正確性。
下面，我們介紹三種不同的OPPRF構建方式。
基於多項式的
首先，我們介紹基於多項式構建的OPPRF的兩個算法：
顯然，上述算法是滿足OPPRF的正確性的。對於
在安全性上，只要\(y_i\)是隨機選擇的，那麼多項式\(p(x)\)的係數也是隨機的，對於任意的點\(x\notin P\)，\(p(x)\)的值也都是隨機的，因此，上述算法滿足OPPRF的安全性。
想要用OPRF來實現上述兩個算法，非常簡單。我們可以先在發送者\(S\)和接收者\(R\)之間，運行一次OPRF，發送者\(S\)得到密鑰\(k\)，接收者\(R\)得到\(F(k,q_i)\)，\(q_i\in (q_1,q_2,...,q_t)\)。然後，發送者\(S\)根據密鑰\(k\)以及點集\(P\)計算\(hint\)，並將\(hint\)發送給接收者\(R\)，接收者\(R\)根據\(hint\)，計算\(\widehat{F}(k,hint,q_i)=F(h,q_i)\bigoplus p(q_i)\)。
這種方法構造的OPPRF，計算開銷很大\(O(n^2)\)，通信開銷很小\(n\)。
在計算開銷上，計算多項式插值的開銷是\(O(n^2)\)，當點集\(P\)很大時，這個開銷會非常大。但是，這種方法的傳輸開銷很小，\(hint\)是多項式的係數，大小爲\(n\)，不可能有比這個更小的傳輸開銷了。
基於布隆過濾器的
首先介紹一下混淆布隆過濾器（Garbled Bloom Filter， GBF），這裏的介紹也不是很清晰:
GBF是一個長度爲\(N\)的數組\(G\)，配合\(k\)個哈希函數\(h_1,h_2,...,h_k:{0,1}^*\rightarrow [N]\)。用GBF可以實現鍵值對存儲的功能，對於一個鍵\(x\)， 其對應的值爲\(\bigoplus _{j=1}^{k}G[(h_j(x))]\)。
我們可以先在發送者\(S\)和接收者\(R\)之間，運行一次OPRF，發送者\(S\)得到密鑰\(k\)和\(F(k,x_i)\)，接收者\(R\)得到\(F(k,q_i)\)，\(q_i\in (q_1,q_2,...,q_t)\)。
可以按照如下方法，將一個\((x_i,y_i\bigoplus F(k,x_i))\)插入到GBF中：
下面的描述就有點不懂了，有點亂！
- 將長度爲\(N\)的數組\(G\)中的每個元素，初始化爲空，記爲\(null\)。
- 對於每一個鍵值對\((x,y)\)，設\(J=(h_i(x)|G[h_i(x)],j\in [k])\)爲\(x\)對應的位置，如果\(J\)位置不爲空，退出；否則，爲\(G[j],j\in J\)賦隨機值，使得等式\(y=\bigoplus _{j=1}^{k}G[(h_j(x))]\)成立。
- 對於數組\(G\)中仍然爲空的位置，給它們賦上隨機值。
我們可以看出，除非GBF在插入的過程中退出，那麼GBF就可以實現儲存鍵值對的功能，同時無法從GBF中推測出其是否包含鍵\(x\)。使用GBF實現OPPRF與基於多項式的實現方法類似，只是將多項式插值，改爲將點集\((x_1,y_1\bigoplus F(k,x_1)),(x_2,y_2\bigoplus F(k,x_2)),...,(x_n,y_n\bigoplus F(k,x_n))\)插入GBF，並將GBF作爲\(hint\)，發送給接收者\(R\)。顯然，這樣的實現是滿足OPPRF的正確性與安全性的。
使用GBF的問題是，在插入的過程中，有可能會因爲\(J\neq 0\)而退出。這個退出的概率，與GBF的數組長度\(N\)，以及插入的元素個數\(n\)是相關的。具體來說，如果想要將退出的概率控制在\(2^{\lambda }\)以下，則需滿足\(N=n.\lambda .loge\)。 假設\(\lambda =40\)，則可以設\(N=60n\)，同時\(k=40\)，即40個哈希函數。
基於布隆過濾器的OPPRF，計算開銷爲\(O(n)\)；通信開銷爲\(O(n)\)
在計算開銷上，插入GBF的開銷是\(O(n)\)，相比多項式插值的\(O(n^2)\)要高效很多。在傳輸開銷上，也是\(O(n)\)，但是其係數非常大（需要傳輸\(60n\)，而不是\(n\)），當\(n\)很大時，這很可能會成爲算法的瓶頸。
基於hash的
先簡單介紹一下，基於哈希表構造OPPRF的大致思路。
首先，發送者\(S\)與接收者\(R\)之間，運行OPRF協議，發送者\(S\)得到\(F(k,x_i),i\in [n]\)，接收者\(R\)得到\(F(k,q)\)。發送者\(S\)使用\(F(k,x_i)\)作爲加密的密鑰，來加密\(x_i\)對應的\(y_i\)。把加密得到的密文集合\(T\)作爲OPPRF的\(hint\)，發送給接收者\(R\)。接收者\(R\)使用\(F(k,q)\)解密\(T\)中某一個對應的密文，得到結果。
在上述思路中，主要的難點在於：
- 不能讓接收者\(R\)知道它解密出來的結果，是一個隨機值，還是某個\(y_i\)。
- 必須讓接收者\(R\)知道，它應該解密\(T\)中的哪個密文。
想要解決難點2，我們可以讓\(T\)變成一個哈希表，每一個\(F(k,x_i)\)對應哈希表中的一個位置，這樣接收者\(R\)就可以根據\(F(k,q)\)的值，找到哈希表中對應的密文，進行解密。
要解決難點1，我們需要讓接收者\(R\)在密鑰不對的情況下，也能解密出一個隨機值，而不是直接解密失敗，這樣，接收者\(R\)就無法區分解密出的是隨機值還是\(y_i\)了（因爲\(y_i\)本身就是一個隨機值）。要想達到這一點，我們可以使用one time pad加密。不過，要使用one time pad加密，我們就需要保證接收者\(R\)只能有一個\(q\)，否則如果多個不同\(q\)對應到了哈希表\(T\)中的同一個位置，就可能造成重用密鑰，從而破壞one time pad的安全性。
有了上述的思路之後，我們來看具體的實現。假設\(n=20\)，即發送者\(S\)有20對\((x_i,y_i)\)，那麼發送者構造一個大小爲32的哈希表\(T\)（32爲大於20的最小的2的冪次）。發送者\(S\)隨機選取一個nonce (隨機數)\(v\)，使得\(H(F(k,x_i)||v)\)中每個元素，都互不相同，其中\(H:{0,1}^*\to {0,1}^5\)是一個哈希函數。對於每個\(x_i\)，發送者\(S\)計算\(h_i=H(F(k,x_i)||v)\)，並且設\(T[h_i]=H(F(k,x_i))\bigoplus y_i\)。對於哈希表\(T\)中其餘的12個位置，放入隨機值。將表T和nonce \(v\)發送給接收者\(R\)，接收者\(R\)可以計算出，\(T[h_i']\bigoplus F(k,q)\)就是結果。
綜上，基於哈希表的OPPRF的兩個算法爲：
顯然，上述算法是滿足OPPRF的正確性的。
在安全性上，因爲\(hint\)現在包含哈希表\(T\)和nonce \(v\)，我們需要分別考慮這兩部分的安全性。對於哈希表\(T\)來說，只要\(y_i\)是隨機選取的，那麼\(T\)中的所有元素，也都是隨機的，不會暴露發送者\(S\)的信息。對於\(v\)來說，我們需要證明的是，接收者\(R\)無法通過\(v\)來判斷，他持有的元素\(q\)是否在發送者\(S\)的集合\(p\)中。對於PRF函數\(F()\)來說，某一個\(F(k,x_i)\)與其他的輸出，是互相獨立的。由於哈希函數\(H\)的性質，某一個\(H(F(k,x_i)||v)\)與其他的點也是互相獨立的。因此，是否選擇某個\(v\)，與任意一個單獨的\(x_i\)都是獨立的。由於接收者\(R\)只有1個\(q\)，所以\(v\)的選擇對於\(q\)來說，也是獨立的。因此，發送\(v\)給接收者\(R\)是安全的。
相比之前的兩種構造方法，基於哈希表的構造，在計算開銷和傳輸開銷上都十分有優勢。
在傳輸開銷上，\(T\)的大小是\(O(n)\)，常數最壞情況也只是2，外加一個固定長度的\(v\)。在計算開銷上，一共需要計算\(n\tau\)次哈希函數\(H\)，這裏\(\tau\)是選擇nonce \(v\)的次數。雖然最差情況下\(\tau\)可能很大，但是當\(n\)很小的情況下，\(\tau\)也會很小，因此整體計算開銷也很小。
有條件的祕密分享
在之前的原理介紹中，有條件的祕密分享要對整個樣本空間\(X\)中的元素生成祕密分享，但是實際實現中，只要每個參與方\(P_i\)對自己持有的樣本集合\(X_i\)中的元素生成祕密分享就可以了。
假設有n個參與者
準確的來說，每個參與方\(P_i\)對自己持有的樣本集合\(X_i\)中的每個元素\(x_k^i\)，生成\(n\)個祕密分享\(x_k^{i,1},x_k^{i,2},...,x_k^{i,n}\)，使得\(x_k^{i,1}\bigoplus x_k^{i,2}\bigoplus ...\bigoplus x_k^{i,n}=0\)。
然後，在每一對參與者\(P_i\)與\(P_j\)兩兩之間，運行OPPRF。\(P_i\)作爲發送者，\(P_j\)做爲接收者。接收者\(P_j\)對於自己持有的每一個樣本\(x_k^{j}\in X_j\)，去發送者\(P_i\)獲取對應的祕密分享。OPPRF保證了當發送者\(P_i\)也持有這個樣本的時候\(x_k^{j}\in X_i\)，接收者\(P_j\)得到了\(x_k^{i,j}\)，否則$P_j $得到的就是一個隨機值。
\(P_j\)作爲接收者，需要和其他全部的\(n-1\)個參與方\(P_i\)運行OPPRF協議。對於每個\(x_k^{j}\in X_j\)，它都能從\(n-1\)個發送方\(P_i\)處收到一個\(P_i\)的分享值\(\widehat{s}_k^{i,j}\)，還有自己生成的分享值，一共\(n\)個。\(P_j\)將這些分享值全部異或起來，做爲自己的針對樣本\(x_k^j\)的祕密分享，即\(S_j(x_k^j)=\bigoplus_{i=1}^{n}\widehat{s}_k^{i,j}\)，其中\(\widehat{s}_k^{i,j}\)是\(P_j\)自己生成的\(x_k^j\)的分享值）。
每個參與方，都要做爲接收者，和其他全部參與方執行上面的步驟，得到自己的祕密分享\(S_j(x_k^j)\)。如果每個參與方都持有元素\(x\)，那麼\(\bigoplus_{j=1}^{n}S_j(x)=0\)。這樣，每個參與方\(P_j\)記下元素\(x_k^j\)對應的\(S_j(x_k^j)\)，就實現了有條件的祕密分享。
有條件的解密
這裏要選出一個leader收集祕密分享，例如\(P_1\)
接下來，我們就可以進行有條件的解密了。這一步我們需要挑選一個參與方來收集大家的祕密分享，計算出最終的PSI的結果，再發給大家。不失一般性，我們挑選\(P_1\)來作爲解密的那個人。
解密的計算本身很簡單，對於\(P_1\)所持有的每一個樣本\(x_k^1\)，從其他全部參與方那裏獲取對應的祕密分享的值\(S_j(s_k^j)\)，把全部的值，和自己的值一起，異或起來，如果是\(0\)，說明這個樣本\(x_k^1\)是所有參與方共有的，\(P_1\)對自己的每一個樣本都執行上述操作，最後得到的全部異或爲\(0\)的元素的集合，就是最終的PSI結果。
但是如果只是這樣計算的話，同樣暴露了\(P_1\)的全部樣本，以及其他參與方是否有某個樣本的額外信息，因此這一步，仍然需要用OPPRF來實現。\(P_1\)作爲接收者，對於自己的每一個樣本，都和全部參與方執行OPPRF協議，發送方如果有這個樣本，就發送真實的祕密分享的值，如果沒有，就發送隨機值。這樣\(P_1\)對於結果的判斷方法不變，同時保證了包括\(P_1\)在內的各方持有的集合都不對外泄露。
算法的正確性和安全性
假陽性：可以看作錯誤率，一般出現在cuckoo hash時，可以通過調參，控制假陽性。
在正確性上，這種構造方法是有可能出現假陽性（false positive）的情況的，即某個\(x\)不屬於所有參與方的交集，但是[公式]依然成立。出現假陽性的概率，與在Cuckoo Hashing中無法插入元素的概率$\lambda $相關，所以只要根據每個參與方集合的大小，合理設置Cuckoo Hashing表的大小，就可以將假陽性的概率控制在一個很小的範圍內。關於Cuckoo Hashing我們會在下文介紹OPPRF的原理時詳細介紹。
安全性：抵抗半誠實的接收者
對於安全性而言，我們這裏先給出結論，上述的構造在半誠實的模型下，可以在至多\(n-1\)個串謀的惡意參與方情況下，保證安全。這裏，半誠實的模型，意思是那些串謀的惡意參與方，也會按照協議的要求，正常執行，只不過會盡力去窺探其他誠實方的數據。這裏安全的意思是，串謀的惡意參與方，無法得知哪一個誠實方持有元素\(x\)，哪一個沒有持有\(x\)。這一點其實不難證明。大體的思路是，只要有一個參與方不持有\(x\)，那麼在OPPRF中，其他參與方對\(x\)的輸出必然是一個隨機值，由於在有條件的祕密分享中，每一個\(P_j\)的最終的祕密分享\(S_j(x)\)，都是由所有參與方的\(s_k^{i,j}\)異或得到，只要有一個\(s_k^{i,j}\)是隨機的，那麼所有人的\(S_j(x)\)看起來就都是隨機的，無法區分，那麼在有條件的解密時，就無法區分一個\(S_j(x)\)與一個隨機值，這就保證了安全。
在效率上，在有條件的祕密分享階段，每一對參與方之間，都需要運行一次OPPRF協議，總共需要\(O(n^2)\)次OPPRF協議；在有條件的解密階段，只有一個參與方作爲解密方，總共需要運行\(n-1\)次OPPRF協議。我們可以將每個OPPRF協議並行化地運行，這樣可以使得協議整體的運行輪次固定下來，與參與方數量和每個參與方輸入的大小無關。至於OPPRF的開銷，我們會在後續章節詳細介紹。
PSI+OPPRF+Cuckoo hash
上面，我們對比了3中不同的OPPRF實現方式，其中基於哈希表的實現，在計算開銷和傳輸開銷上，平衡的最好。但是，基於哈希表的實現，限制也是最大的，不僅要求接收者\(R\)只能有一個\(q\)（即\(t=1\)），同時要求發送者\(S\)的點集大小\(n\)不能太大，才能達到很高的計算效率。在實際的應用場景中，這顯然是不現實的。所以，我們需要使用Cuckoo Hashing，來使基於哈希表的OPPRF能滿足\(n\)與\(t\)很大的情況。
從宏觀上將，我們需要發送者\(S\)和接收者\(R\)都將它們持有的集合映射到一個哈希表中去，哈希表中的每個位置對應接收者\(R\)的某一個\(q\)，以及一小部分的發送者\(S\)的的\(P\)，這樣，就將\(n\)與\(t\)很大的情況下的OPPRF，分解爲很多個小的OPPRF。在這裏，我們使用Cuckoo Hashing來實現這種哈希映射。
Cuckoo hash
布穀鳥hash在上篇文章已經介紹過，更多請參考上一篇
這裏先簡單介紹一下Cuckoo Hashing（布穀鳥哈希）。
Cuckoo Hashing用\(k\)個哈希函數\(h_1,h_2,...,h_k\)，將元素放入\(m\)個桶中。對於一個元素\(q\)，我們計算\(h_1(q),h_2(q),...,h_k(q)\)，如果這些桶中有空的桶，就將\(q\)放入其中一個空桶中，結束插入；如果\(k\)個桶都有元素，就從中隨機選擇一個桶，踢出原來桶中的元素\(\widehat{q}\)，把\(q\)放入這個桶中，然後循環插入\(\widehat{q}\)，直至結束，或者到達循環次數的上限。
對於達到循環次數上限的元素，Cuckoo Hashing的不同變體，有不同的處理方式。在文章[2]中，他們使用一個額外的stash來儲存達到循環次數上限的元素，但是這樣做，會導致stash中有很多元素，這些元素都需要與對方進行對比，不夠高效。
這裏使用兩個hash表來存儲：
在這裏，爲了保證Cuckoo Hashing中每一個桶都只包含一個元素，我們使用另一個額外的Cuckoo Hashing表來替代stash，儲存這些達到循環次數上限的元素。簡單來說，我們有主副兩個Cuckoo Hashing表，主表使用3個哈希函數，副表使用2個，當一個元素在主表中達到插入上限時，將他插入到副表中。當主表和副表的大小設置合理時，可以使得主表副表都無法插入一個元素的概率，不超過\(2^{-\lambda }\)。
現在來看如何使用Cuckoo Hashing擴展OPPRF。
首先，發送者\(S\)與接收者\(R\)使用相同的哈希函數，以及表的大小。接收者\(R\)使用Cuckoo Hashing，將持有的\(t\)個元素\(q_i\)，映射到哈希表中，表中每個位置都只有至多一個元素。對於表中空的位置，則賦一個隨機值。
對於發送者\(S\)，將它持有的\(n\)個\(x_i\)，使用與接收者\(R\)相同的\(k\)個哈希函數，映射到表中\(h_1(x_i),h_2(x_i),...,h_k(q_i)\)的位置，即一個元素，插入哈希表\(k\)次。這樣，發送者\(S\)與接收者\(R\)的哈希表每個位置一一對應，都包含一個\(q\)與數量很小的幾個\(x_i\)，我們只需爲哈希表的每個位置，構造一個OPPRF即可。
需要注意的是，發送者\(S\)的表中，每個位置包含的元素大小不同，而且有可能有空的位置，這會暴露一些信息，並不安全。所以，我們可以根據表的大小、元素個數\(n\)以及哈希函數的數量\(k\)，計算出表中每個位置包含元素數量的上限\(\beta\)，然後把發送者\(S\)的表中每個位置都填充上隨機值，使每個位置都包含\(\beta\)個元素。
優化
無條件的祕密分享
在之前的多方PSI構造中，我們可以看到，有條件地祕密分享，需要\(O(n^2)\)次OPPRF，即使並行化，也依然是一個很大的通信開銷。這一步，如果放寬安全條件，其實是可以進行優化的。如果我們的安全條件放寬到至多\(n-2\)個串謀的參與方，也就是至少2個誠實的參與方的情況下，可以使用無條件地祕密分享，來替代有條件地祕密分享。
下面沒看太明白，以後補充
合併hint
在使用Cuckoo Hashing擴展OPPRF的時候，我們會發現，發送者\(S\)中的每個元素，都在Cuckoo Hashing的哈希表中出現了多次，也就會出現在多個OPPRF實例的\(hint\)中，這造成了一定傳輸開銷的浪費。我們可以通過將這些\(hint\)合併起來，減少傳輸開銷：
- 對於基於多項式的OPPRF構造，我們可以針對哈希表中的每個桶中的元素，計算一個多項式插值，因爲每個桶中的元素很少，這大大減少了計算多項式插值的開銷，但是會增大傳輸開銷；也可以針對Cuckoo Hashing中的每個哈希函數，計算一次多項式插值，這使得\(hint\)的數量減少到\(k\)個，減少了傳輸開銷，但是當元素數量很多時，計算開銷很大。
- 對於基於GBF的OPPRF構造，由於每個元素在Cuckoo Hashing的哈希表中出現了\(k\)，所以需要插入\(k\)次鍵值對\((x,y\bigoplus F(k_{h_i},x))\)，這會使GBF所需的空間變大。作爲替代，可以在GBF裏插入\((x,(y\bigoplus F(k_{h_1},x)\bigoplus(y\bigoplus F(k_{h_2},x)\bigoplus...\bigoplus(y\bigoplus F(k_{h_k},x))\)，即將這些鍵值對中的值拼接起來一起插入，這可以節省GBF的空間。
參考
[1] Kolesnikov V, Matania N, Pinkas B, et al. Practical multi-party private set intersection from symmetric-key techniques[C]//Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security. 2017: 1257-1272.
[2] Kolesnikov V, Kumaresan R, Rosulek M, et al. Efficient batched oblivious PRF with applications to private set intersection[C]//Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security. 2016: 818-829.
[3] Freedman M J, Ishai Y, Pinkas B, et al. Keyword search and oblivious pseudorandom functions[C]//Theory of Cryptography Conference. Springer, Berlin, Heidelberg, 2005: 303-324.