MPC関連技術 秘密計算

【技術】MPCにおける基数ソート(Oblivious Radix Sort)の解説

はじめに

この記事では、MPC によるソートの一つである、 Oblivious Radix Sort プロトコルを紹介します。原論文は以下のリンクから閲覧できます。また以下の論文で提案されている手法を、論文での名前をそのまま使い、この記事では Oblivious Radix Sort プロトコルと呼ぶことにします。

https://eprint.iacr.org/2014/121.pdf

秘密計算において、キーまたはテーブル(表)の値を明らかにせずにソートをしたい場面は多く存在します。例えば最大・最小値や中央値を求めたり、何番目に大きいかであったり、i 番目に大きい値を知りたい等、データを分析する上でソートをして様々な値を求めたい場面などです。

例えば、上の例でソートするキーのベクトルを $ \mathbf {k} $ 、テーブル(表)を行列にしたものを $ \mathbf {D}$ とした場合、キー $ \mathbf {k}$ または $ \mathbf {D}$ の1列目の値(=キー $ \mathbf {k}$ )に従って並び替えて、以下のように並び替えるような操作に相当します。

このような操作はソートと呼ばれ、クイックソートやマージソート等の従来のアルゴリズムで実装することが可能です。しかし、上記のような一般のソートアルゴリズムは比較演算を多用するため、MPC で実現するには非常に多くの計算コストがかかってしまいます。そのため、MPC による秘密計算では特別に専用のプロトコルを用意する必要があります。

Oblivious Radix Sort プロトコルは、MPC における高速なソートプロトコルの一つであり、多くの論文で引用されています。そこで、本記事では Oblivious Radix Sort の具体的なプロトコルについて解説していきます。

記法の説明

本記事で出てくる記法を説明します。

  • $\mathcal{P}_1, \cdots, \mathcal{P}_m$ はプロトコルに参加している主体を表します(今後はパーティと呼びます)。各パーティは互いにセキュアなチャネルで結ばれているとします。
  • $n$ をシーケンス (キーやテーブルの行数)とし、$m$ をパーティの数とします。
  • $\mathbb{Z}_{P}$ は$P$ を法とした素体を表します。また、$l$ を $P$ のビット長とします。
  • $a\in \mathbb{Z}_{P}$ と書いた場合、$a \in \{ 0, 1, \cdots, P-1 \}$ を意味します。
  • $\mathbb{U} = \{\mathcal{P}_1,...,\mathcal{P}_m\}$ は、全パーティの集合を表します。
  • パーティ$\mathcal{P}_i$ が保有する秘密情報$s$ のシェアを$[[s]]_{\mathcal{P}_i}$ と表します。加法的秘密分散法またはシャミア秘密分散法の両方が使用可能です。
  • 全てのパーティが持つ秘密情報 $s$ のシェアをまとめて表記する場合に、$[[s]]$ と表します。$[[s]]=[[s]]_{\mathcal{P}_i} \ for \ i \in \{1,...,m\}$ ということです。
  • $\mathbb{Z}_{P}$ 以外の別の素体でシェア値を使用することがあり、$\mathbb{Z}_{Q}$ と書きます。これを明示的に示すために、$[[s]]^{(Q)}$ のように上付きの添字を括弧をつけて示します。
  • 大文字太字 $ \mathbf {A}$ を行列、小文字太字 $ \mathbf {a}$ をベクトルとし、$ \mathbf {A}[i,j]$ を行列の $i$ 行 $j$ 列目の要素、$ \mathbf {a}[i]$ をベクトルの $i$ 行目の要素とします。
  • $ \mathbf [[{A}]]_{\mathcal{P}_i}$ や $ \mathbf [[{a}]]_{\mathcal{P}_i}$ を、行列 $\mathbf{A}$ やベクトル $\mathbf{a}$ に対するパーティ$\mathcal{P}_i$ のシェア行列やシェアベクトルを指します。

Oblivious Radix Sortプロトコルの内容

Oblivious Radix Sort プロトコルは、比較演算プロトコル本体と、そのプロトコル内で使用されている6つのサブプロトコルから構成されています。まず、サブプロトコルについて説明し、その後本体のプロトコルについて説明します。

サブプロトコル

Oblivious Radix Sort プロトコルを実装するにあたり、以下の6つのサブプロトコルが必要となります。

  • Bit-Decomposition
  • Shuffling
  • Bit-field-conversion
  • Revealing
  • Destination computation
  • Reveal sort

以下、それぞれのサブプロトコルについて順に説明します。

Bit-Decomposition

各 $\mathcal{P}_i\in\mathbb{U}$ から$[[a]]_{\mathcal{P}_i}$ を入力し、ビット分解して、$[[a_1]]_{\mathcal{P}_i},...,[[a_l]]_{\mathcal{P}_i}$ を出力します。

このプロトコルを以下のように表記します。

$[[a_1]],...,[[a_l]] \gets Bit-Decomposition([[a]])$

これを行う具体的なアルゴリズムについては、以下の論文を参照してください。

https://www.iacr.org/archive/tcc2006/38760286/38760286.pdf

ここの処理の目的は、ある与えられた値を2進数表現に変換することです。つまり、$a_j\in\{0,1\}$ の時 $a=\Sigma_j a_j 2^{j-1}$ となるように分解します。

例えば、$[[a]]_{\mathcal{P}_1}=11$ だったとします。この時、$l=5$ とした場合に、このサブプロトコル実行後にどうなるかを見てみます。

$\Sigma_j a_j 2^{j-1}=a_1 2^{0}+a_2 2^{1}+a_3 2^{2}+a_4 2^{3}+a_5 2^{4}\\ $

$=1\cdot 1+1\cdot2+0\cdot4+1\cdot8+0\cdot16=11$

つまり、$([[a_1]]_{\mathcal{P}1},...,[[a_5]]_{\mathcal{P}_1})=(1,1,0,1,0)$ のように分解されます。2進数表示であることを考えれば、15 までは $l=4$ で十分でした。

Shuffling

各 $\mathcal{P}_i\in \mathbb{U}$ から、$[[\mathbf{k}[1]]]_{\mathcal{P}_i}, ...,[[\mathbf{k}[n]]]_{\mathcal{P}_i}$ を入力し、各 $\mathcal{P}_i\in \mathbb{U}$ に$[[\mathbf{k}''[1]]]_{\mathcal{P}_i}, ...,[[\mathbf{k}''[n]]]_{\mathcal{P}_i}$ を出力します。これは、均一でランダムな置換 $\pi:\{1,...,n\} \to \{1,...,n\}$ により、$\mathbf{k}''[j]=\mathbf{k}_{\pi}[j] \ for \ j\in\{1,...,n\}$ のようになっています。このプロトコルを以下のように表記します。

$[[\mathbf{k}'']]\gets Shuffle([[\mathbf{k}]])$

これを行う具体的なアルゴリズムについては、以下の論文を参照してください。

https://eprint.iacr.org/2011/429.pdf

ここでは、いわゆるランダム置換と呼ばれるもので、ベクトルや行列の各行の要素をランダムに並べ替えると言う操作をします。

ソートする時にキーの要素を公開するため、入力データと出力結果の対応関係を秘匿したい場合に使用します。逆に言えば、秘匿しなくてもいい場合は不要です。

Bit-field-conversion

各 $\mathcal{P}_i\in \mathbb{U}$ から素体 $\mathbb{Z}_{P}$ 上のシェア$[[b]]^{(P)}_{\mathcal{P}_i}$ を入力し、別の体 $\mathbb{Z}_Q$ 上のシェア$[[b]]^{(Q)}_{\mathcal{P}_i}$ を各 $\mathcal{P}_i\in \mathbb{U}$ に出力します。このプロトコルを以下のように表記します。

$[[b]]^{(Q)} \gets Bit-Field-Conversion([[b]]^{(P)})$

具体的なアルゴリズムは以下の論文を参照してください。

https://eprint.iacr.org/2006/017.pdf

このアルゴリズムは、基本的にオーバーフローを防ぐために使用します。オーバーフローが発生しないような、適切な値の空間を最初から選択している場合は、気にする必要はありません。

Revealing

各 $\mathcal{P}_i\in \mathbb{U}$ から$[[a]]_{\mathcal{P}_i}$ を入力し、各 $\mathcal{P}_i\in \mathbb{U}$ に $a$ を出力します。このプロトコルは、マルチパーティ設定での公開アルゴリズムとして機能します。 このプロトコルの実行は、次のように示されます。

$a \gets Reveal([[a]])$

このサブプロトコルではシェアを復号しています。Reveal Sort にシェアを復号するステップがあるので使用します。

Destination computation

まず、準備としてベクトル $\mathbf{k} \in \{0,...,d-1\}^n$ に対して、

$\mathbf{B}_{i,j} = \left\{ \begin{array}{l} 1 \ if \ \mathbf{k}[i]=j-1, \\ 0 \ otherwise \end{array} \right.$

$(i,j) \in \{1,...,n\}\times\{1,...,d\}$

のような $n \times d$ 行列 $\mathbf{B}$ を作成します。そして、各 $\mathcal{P}_i\in \mathbb{U}$ から $[[\mathbf{B}]]_{\mathcal{P}_i}$ を入力し、

$(k[1],1),...,(k[n],n)\ \to \ (k '[1],\pi(1)),...,(k'[n],\pi(n)) $

$ s.t. \ \ k'[i] \leq k '[i+1]\ for \ i \in \{1,...,n−1\}$

のようにソートされるような $\mathbf{c} \ s.t. \ \mathbf{c}[i]=\pi^{-1}(i)$ を計算し、$[[\mathbf{c}]]$ を生成し、最後に各 $\mathcal{P}_i\in \mathbb{U}$ に $[[\mathbf{c}]]_{\mathcal{P}_i}$ を出力します。このプロトコルの実行を以下のように表記します。

$[[\mathbf{c}]] \gets Dest-Comp([[\mathbf{B}]])$

プロトコル

  1. 各パーティは、キーのシェアベクトル$[[\mathbf{k}]]$ から、$[[\mathbf{B}_{i,j}]]$ を作成する。

ここの手順については後述します。

  1. $[[\mathbf{S}[i,j]\ ]] := \Sigma_{(i',j') \ s.t. \ (j'<j)\lor (j'=j\lor i'<i)}[[\mathbf{B}[i',j'] \ ]]$$for \ (i,j) \in \{1,...,n\} \times \{1,...,d\}$
    となるような $[[\mathbf{S}]]$ を計算する。
  2. $[[\mathbf{T}[i,j] \ ]]:=[[\mathbf{S}[i,j] \ ]] \times [[\mathbf{B}[i,j] \ ]] \ for \ (i,j) \in \{1,...,n\}\times\{1,...,d\}$となるような $[[\mathbf{T}]]$ を計算する。
  3. $[[\mathbf{c}[i]\ ]]:=\Sigma^d_{j=1}[[\mathbf{T}[i,j] \ ]] \ for \ i \in \{1,...,n\}$を計算する。
  4. $[[\mathbf{c}]]$ を出力する。

例を見た方がわかりやすいので例示します。例では本質を見るために復号されたものを追っていきますが、実際はシェアに対して同じ作業をすることになります。

 

として、

のような行列を作ります。one-hot-encoding のような操作です。しかし、注意として、シェアのままこのような作業を行うには one-hot-encoding のようなMPC アルゴリズムが必要になります。

それを回避する為に、ビット分解し $\mathbf{k}$ をバイナリにするというBit-Decomposition があります。もし、$\mathbf{k}$ がバイナリだとすると、

として、

とすればよく、これはよく見ると、1列目は $\mathbf{k}$ の否定、2列目は $\mathbf{k}$ そのままを入れることで作ることができます。シェアのまま否定をすることは容易ですから、本体のプロトコルではバイナリに対してのみ適用することになります。

より、

を作成します。$\mathbf{B}$ を1列目、2列目、3列目と言う順番で列方向に合計していって、その要素時点での合計値が $\mathbf{S}$ になります。

を作成します。

これは、$\mathbf{B}$ と $\mathbf{S}$ の要素同士の掛け算で作成します。if文でやっても構いません。

を作成します。

これは、$\mathbf{T}$ を行ごとに足し算することで得ることができます。そして、この値が $\mathbf{k}$ の要素が何番目に小さいかと言うことを示します。同じ値同士は上から順になります。

  1. $\mathbf{c}$ を出力して終わりです。実際には上記の作業を全てシェアのまま行いますので、$[[\mathbf{c}]]_{\mathcal{P}_i}$ を各 $\mathcal{P}_i \in \mathbb{U}$ に出力します。

Reveal Sort

各 $\mathcal{P}_i\in \mathbb{U}$ から $([[\mathbf{k}]]_{\mathcal{P}_i}^{(Q)},[[\mathbf{D}]]_{\mathcal{P}_i})$ を入力し、$\mathbf{k}$ の要素を公開し、

のようにソートされ、$[[\mathbf{D}']]$ を生成します。最後に各 $P_i\in \mathbb{U}$ に $(\mathbf{k}',[[\mathbf{D}']])$ を出力します。このプロトコルの実行を以下のように表します。

$\mathbf{k}',[[\mathbf{D}']] \gets Reveal-Sort(\mathbf[[\mathbf{k}]],[[\mathbf{D}]])$

プロトコル

  1. $([[\mathbf{k}'']],[[\mathbf{D}'']]\gets Shuffle([[\mathbf{k}]],[[\mathbf{D}]])$
    Shuffling プロトコルで $[[\mathbf{k}]],[[\mathbf{D}]]$ をランダム置換し、$[[\mathbf{k}'']],[[\mathbf{D}'']]$ を作成します。全てのシェア、$\mathbf{k},\mathbf{D}$ で同じ置換を適用してください。 このShufflingプロトコルは、入力データと出力結果の対応関係を秘匿したい場合に使用します。逆に言えば、秘匿しなくてもいい場合は不要です。
  2. $\mathbf{k}''[i] \gets Reveal([[\mathbf{k}''[i]]]) \ for \ i \in \{1,...,n\}$
    Reveal プロトコルで全てのキーの要素を復号し、公開します。
  3. $\mathbf{k}''$ に従って、バケットソート(基数ソート)をします。つまり、$\mathbf{k}''$ の要素ごとに箱を作り、その行に対応する$\mathbf{k}''$ や$[[\mathbf{D}'']]$ を放り込み、小さい要素から拾っていきます。

ここで、$\mathbf{k}$ をソートするような表記にはなっていますが、実際には Destination computation で作成する $\mathbf{c}$ に対してこのアルゴリズムを主に実行します。

本体プロトコル

ここからは、本体のソートプロトコルについて説明します。

Oblivious Radix Sort プロトコルは、大まかに分けて以下の4つのステップで成立します。

  1. キー $[[\mathbf{k}]]$ をBit-Decomposition プロトコルにより、ビット分解する。
  2. ビット分解したキー $[[\mathbf{b}_j]]$ に対して、Destination Computation プロトコルで、各桁の大小の順番 $[[\mathbf{c}_j]]$ を計算する。
  3. 基数ソートを実行する。
  4. 実行結果を出力する。

しかし、このアルゴリズムではただの基数ソートではなく、Oblivious Radix Sort と呼ばれるソートアルゴリズムが用いられているので、2.と3.のプロセスは各ビットについて同じループ内で実行されます。

主なアイデアとしては、掛け算や比較演算等の通信を必要とする計算をできるだけ回避してソートを実行することで高速なソートを実行します。

以下で詳しいステップについて解説していきます。

プロトコル

  1. まず、全てのパーティは $\mathbb{Z}_{Q}$ s.t. $n\in\mathbb{Z}_Q$であることと、 $\mathbb{Z}_Q$ のビット長が $\Theta (\log n)$ であることに合意します。
  2. $[[\mathbf{b}_1[i]]],...,[[\mathbf{b}_l[i]]] \gets Bit-Decomposition([[\mathbf{k}[i]]]) \ for \ i \in \{1,...,n\}$
    ここで、BIt-Decomposition プロトコルでキー $\mathbf{k}$ をビット分解します。
  3. $[[\mathbf{b}_j[i]]]^{(Q)} \gets Bit-Field-Conversion([[\mathbf{b}_j[i]]]) $
    $for \ (i,j) \in \{1,...,n\} \times \{1,...,l\}$
    ここで、Bit-Field-Conversion でオーバーフローしないような値の空間になるようにします。オーバーフローしないという意味を込めて右上に $(Q)$ がつきます。
  4. $[[\mathbf{h}]]^{(Q)} \ s.t. \ \mathbf{h}=(1,...,n)^T$ を作成します。
    このベクトルはポインタのように使用される元の位置を格納するベクトルです。
  5. ループの為に以下のような置き換えをします。
    $[[\mathbf{h}_1^{(Q)}]] =[[\mathbf{h}^{(Q)}]]$
    $[[\mathbf{b}_1'^{(Q)}]]=[[\mathbf{b_1}^{(Q)}]]$
    $[[\mathbf{b}_{l+1}^{(Q)}]]=[[\mathbf{D}]]$
    $[[\mathbf{b}_{l+1}'^{(Q)}]]=[[\mathbf{D}']]$
    ここで注意して欲しいのは、$[[\mathbf{h}]]$ は何度も作るのでコピーです。他はポインタ変数でもいいです。
  6. $\mathbf{for} \ j=1 \ \mathbf{to} \ l \ \mathbf{do}$
    以下のステップからビット分解したビットごとについてループに入ります。
  7. $[[\mathbf{B}_j]]^{(Q)}$$[[\mathbf{b}_j']]^{(Q)}$から作成。
    Destination computationのところで行った操作をします。バイナリであるため否定で作成できます。
  8.  $[[\mathbf{c}_j]]^{(Q)} \gets Dest-Comp([[\mathbf{B}_j]]^{(Q)})$
    Destination computationを実行します。
  9.  $\mathbf{h}_j',[[\mathbf{c}_j']]^{(Q)} \gets Reveal-Sort(\mathbf[[\mathbf{h}_j]]^{(Q)},[[\mathbf{c}_j]]^{(Q)})$
    Reveal Sortを使って、まず $\mathbf{c}_j$ を $\mathbf{h}_j$ に従って並び替えます。$\mathbf{h}_j$ は前のループでどのように並び替えられたかと言う情報が入ります。1ループ目は何も起きません。これを使って少し変わった基数ソートをします。
  10.  $[[\mathbf{b}_{j+1}]]^{(\mathcal{Q})}$ と $[[\mathbf{h}]]^{(Q)}$ を準備します。
    $\mathbf{h}$ は常に $\mathbf{h}=(1,...,n)^T$ をコピーして持ってきます。$[[\mathbf{b}_{j+1}]]^{(Q)}$ はラストループで $[[\mathbf{D}]]$ が入ることに注意してください。
  11.  $\mathbf{c}_{j}'',[[\mathbf{b}_{j+1}']]^{(Q)} || \ [[\mathbf{h}_{j+1}]]^{(Q)} \gets Reveal-Sort([[\mathbf{c}_{j}']]^{(Q)},[[\mathbf{b}_{j+1}]]^{(Q)} || \ [[\mathbf{h}]]^{(Q)} )$
    ここで、 $\mathbf{x} \ ||\ \mathbf{y}$ は列ベクトル $\mathbf{x}$ と $\mathbf{y}$を水平方向に結合させたものです。
    つまり、$[[\mathbf{c}_j']]^{(Q)}$$[[\mathbf{c}_j']]^{(\mathcal{Q})}$ に従って、$[[\mathbf{b}_{j+1}]]^{(Q)} || \ [[\mathbf{h}]]^{(Q)}$ を同時に並び替えます。
  12.  $\mathbf{end \ for}$
  13.  $\mathbf{return} \ \ [[\mathbf{b}_{l+1}']]$
    $[[\mathbf{b}_{l+1}']]$ つまり、ソートされた行列   $[[\mathbf{D}]]'$ を返します。

例示

実際に例示した方がわかりやすいと思うので例を使って例示します。

本来はシェアの状態で行われるプロトコルですが、本質を見る為に元の値で実行してみます。本来はもちろんシェアのまま同様の計算を行い、必要に応じて必要な部分を復号することになります。

$l=3$ で表現できそうなので、

  1. Bit-Decomposition で3つのベクトルに分解します。

  1. でBit-Field-Conversion で変換します。しかし、この例ではビット長の最大値を考えないこととするため不要です。実際にはシェアの値によってオーバーフローの可能性がありますので、その時は適宜設定する必要はあるでしょう。
  2. で$[[\mathbf{h}]]^{(Q)}$ を作ります。元の位置を格納するベクトルです。ここでは元の値で表現してるので

となります。

  1. でコピーを作成します。つまり、ループの為に置き換えをします。

6.1 $\mathbf{for} \ j=1 \ \mathbf{to} \ 4 \ \mathbf{do}$

ここでループに入ります。以下では1回目のループを追います。

7.1 で$\mathbf{B}_j$ を作成します。一列目は $\mathbf{b}_j'$ の否定、二列目はそのまま $\mathbf{b}_j'$ です。$\mathbf{b}'_j$ であることに注意してください。これは前のループで並び替えられています。

$

となります。

8.1 $[[\mathbf{c}_j]]^{(Q)} \gets Dest-Comp([[\mathbf{B}_j]]^{(Q)})$

ここでは、$\mathbf{B}_j$を集計した行列が $\mathbf{S}_j$であり、$\mathbf{B}_j,\mathbf{S}_j$ の要素同士をかけたものが $\mathbf{T}_j$ となります。そして、行で集計したものが $\mathbf{c}_j$ です。

9.1 $\mathbf{h}_j',[[\mathbf{c}_j']]^{(Q)} \gets Reveal-Sort(\mathbf[[\mathbf{h}_j]]^{(Q)},[[\mathbf{c}_j]]^{(Q)})$

ここでは、1ループ目は何もしません。$\mathbf{h}_j$ がキーになっている以上1ループ目は $\mathbf{c}_j$ は並び替えられることはありません。今回は特に意味のない作業です。

10.1 $[[\mathbf{b}_{j+1}]]^{(Q)}$ と $[[\mathbf{h}]]^{(Q)}$ を準備します。

11.1 $\mathbf{c}_{j}'',[[\mathbf{b}_{j+1}']]^{(Q)} || \ [[\mathbf{h}_{j+1}]]^{(Q)} \gets Reveal-Sort([[\mathbf{c}_{j}']]^{(Q)},[[\mathbf{b}_{j+1}]]^{(Q)} || \ [[\mathbf{h}]]^{(Q)} )$

ここで、

なので、公開されたキー $\mathbf{c}_j$ に従い並べ替えます。$\mathbf{c}''_j$ は整列されたものになっていると思います。(特に使用はしません)

6.2 次のループ($j=2$)に入ります。

7.2 $\mathbf{B}_j$ を作ります。$\mathbf{b}_2'$ という並び替えられた後のものを使うことに注意してください。 (なお、今回は並び替えられませんでした)

8.2 $\mathbf{c}_j$ を作成します。

9.2 $\mathbf{h}_j',[[\mathbf{c}_j']]^{(Q)} \gets Reveal-Sort(\mathbf[[\mathbf{h}_j]]^{(Q)},[[\mathbf{c}_j]]^{(Q)})$

だったはずなので、$\mathbf{h}_2$ に従って並び替えます。

10.2 $[[\mathbf{b}_{j+1}]]^{(Q)}$ と $[[\mathbf{h}]]^{(Q)}$ を準備します。

11.2 $\mathbf{c}_{j}'',[[\mathbf{b}_{j+1}']]^{(Q)} || \ [[\mathbf{h}_{j+1}]]^{(Q)} \gets Reveal-Sort([[\mathbf{c}_{j}']]^{(Q)},[[\mathbf{b}_{j+1}]]^{(Q)} || \ [[\mathbf{h}]]^{(Q)} )$

6.3 最後の3ループ目($j=3$)に入ります。

7.3 $\mathbf{B}_j$ を作ります。$\mathbf{b}_3'$ という並び替えられた後のものを使うことに注意してください。

8.3 $\mathbf{c}_j$ を作成します。

9.3 $\mathbf{h}_j',[[\mathbf{c}_j']]^{(Q)} \gets Reveal-Sort(\mathbf[[\mathbf{h}_j]]^{(Q)},[[\mathbf{c}_j]]^{(Q)})$

だったはずなので、$\mathbf{h}_3$ に従って並び替えます。

10.3 $[[\mathbf{b}_{j+1}]]^{(Q)}$ と $[[\mathbf{h}]]^{(Q)}$ を準備します。

ここでは、$\mathbf{b}_4=\mathbf{D}$ であることに注意します。

11.3 $\mathbf{c}_{j}'',[[\mathbf{b}_{j+1}']]^{(Q)} || \ [[\mathbf{h}_{j+1}]]^{(Q)} \gets Reveal-Sort([[\mathbf{c}_{j}']]^{(Q)},[[\mathbf{b}_{j+1}]]^{(Q)} || \ [[\mathbf{h}]]^{(Q)} )$

  1. $\mathbf{return} \ \ [[\mathbf{b}_{l+1}']]^{(Q)}$

を出力します。

以上全ての操作をシェアのまま行います。そして、$[[\mathbf{b}_{l+1}']]^{(Q)}=[[\mathbf{D}']]$ を各パーティに出力します。あとは、分析に必要な部分のみ復号を行い様々な分析をすることになります。

負の数・小数への適用について

ここからは論文には書かれていない内容ですが、負の数・小数への適用について説明します。

ビット分解のところのアルゴリズムで、キー $\mathbf{k}$ を符号付きで、固定小数点表現でビット分解してあげます。

固定小数点表現とは、小数部分と整数部分の桁数を決めて、ビット表現に直すことです。ここで、小数部分の桁数 $a=3$ 、 整数部分の桁数 $b=4$、最上位ビットに符号のビットで全 8 桁の表現だとします。

この時、例えば 3.25 という数であれば、以下のようにビット分解されると思います。$3.25=2^1+2^0+2^{-2}$ ですので、

$\begin{pmatrix} 0 & 0 & 0 & 1 & 1 & 0 & 1 & 0 \\ \end{pmatrix}$

のようになると思います。また、例えば、 - 5.5 という数であれば、2の補数表現を使って、$5.5=2^2+2^0+2^{-1}$ なので、

$\begin{pmatrix} 0 & 0 & 1 & 0 & 1 & 1 & 0 & 0 \\ \end{pmatrix}$の補数表現、

$\begin{pmatrix} 1 & 1 & 0 & 1 & 0 & 1 & 0 & 0 \\ \end{pmatrix}$

のようにビット分解されます。このようにビット分解するプロトコルは、以下の論文に記載されています。

https://arxiv.org/abs/2002.05377

このように、固定小数点表現に直せたら、最上位ビットをみて、正の数と負の数に事前に分けます。同じ行に対して、シェアを取り出せばいいです。

その後、正の数はそのまま下位ビットからここで、書いてある Oblivious Radix Sort プロトコルでソートします。最上位ビットは無視していいです。正の数はこれで終わりです。

負の数は、補数表現の場合、そのまま並び替えれば、小さい順になります。つまり今の例だと、

$-0.125=\begin{pmatrix} 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\ \end{pmatrix}$

と言う表現になっていて、

$-15.875=\begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\ \end{pmatrix}$

になってます。これを、下位ビットから Oblivious Radix Sort でそのまま並び替えれば、-15.875 が一番小さい数として認識され、上にきます。-0.125が一番大きい数とそのまま認識され、下にきます。つまり、負の数だけで並び替えれば、負の数も同じように小さい順になります。

最後に必要に応じて、分けた正の数と負の数のベクトルをくっつければ終わりです。このようにして、対応できます。

計算量について

まず、オーダーレベルで見ていくと、以下のようになります。

パーティの数 $m$ と素体ビット長 $l$ が一定であると仮定すると、忘却基数ソートは $O(1)$ラウンド、および $O(n\log n)$ 通信で、非常に効率的な計算量を示します。

$n$ : シーケンスの数

$m$ : パーティの数

$l$ : 基礎となる素体のビット長

$\mathcal{M}=2^m/\sqrt{m}$

 

(出典 : https://eprint.iacr.org/2014/121.pdf, Table 1)

計算量の具体的な値

破損許容度 t = 1 の (2,3) シャミアの秘密シェアスキームにソートアルゴリズムを実装し、パフォーマンスを向上させるために、semi-honest な敵対者に対して安全なプロトコルが実装されています。

すべての値は、素体$\mathbb{Z}_p=\{0,1,...,P-1\}$ 上の要素です。ここで、P は素数$4294967291=2^{32}-5$ であり、$2^{31} <P<2^{32}$ を満たします。つまり、値は32ビットワードです。実験は、Intel Core i7-2640M 2.8 GHzCPU と 8GB の物理メモリを搭載した3台のラップトップマシンで実施されました。これらの3台のマシンは 1GbpsLAN に接続されていました。実装は C++ で記述され、コンパイルには g++ 4.6.3 が使用されました。ソートアルゴリズムの実行時間を表4に示し、グラフを図1に示します。結果は、Oblivious Radix Sort が上記の設定で既存のソートアルゴリズムよりも優れていることを示しています。

 

(出典 : https://eprint.iacr.org/2014/121.pdf, FIg.1)

 

(出典 : https://eprint.iacr.org/2014/121.pdf, Table 4)

まとめ

本記事のまとめは以下の通りです。

  • MPCにおける高速なソートプロトコルである Oblivious Radix Sort プロトコルについて説明しました。
  • Oblivious Radix Sort プロトコルを使用すると、秘密分散をしたまま高速なソートをすることが可能になる。

参考文献

https://eprint.iacr.org/2014/121.pdf

メンバー募集

Acompanyでは、秘密計算の社会実装に向けてメンバーを絶賛募集中です!
優秀なメンバーが集まる環境で世の中に新しい価値を作る挑戦を僕らとしませんか?
以下の分野のメンバーを募集中です!

✅ ソフトウェアエンジニア
✅ マーケティング
✅ バックオフィス

興味がある方は、まずは軽くお話しするだけでも大丈夫ですので、ぜひご連絡ください!😎        

詳細はこちら

       

【無料】秘密計算コンソーシアムメンバー募集中!

秘密計算コンソーシアムは秘密計算を中心とした、プライバシーテックに関連する情報発信およびイベント開催を行うコミュニティです!!
個人情報やプライバシーの付随するデータの活用に悩まれている企業・担当者様にとって、法令遵守した安全安心なデータ活用を実現するヒントが得られる場所となっています。
無料ですので、ぜひご気軽にご加入ください!

コミュニティ参加メンバーへの特典

✅ 月1回のイベント「秘密計算.jp」を優先的にご案内
 初回は豪華メンバーが登壇します!!
✅ 限定メールマガジンの配信
✅ 「2時間でプライバシー保護データ活用がわかる勉強会」特別割引

詳細・申し込みはこちらから!

-MPC関連技術, 秘密計算
-, , , ,

© 2021 秘密計算の国内最大ブログ | Acompany Co., Ltd. Powered by AFFINGER5