茫然传输经典协议_naor-pinkas-CSDN博客

本文链接：https://blog.csdn.net/Albery/article/details/104896856

茫然传输(OT)

茫然传输的概念是由Rabin提出的,Even、Goldreich和Lempel首次提出了1-out-of-2茫然传输的概念。由于茫然传输协议在安全多方计算等领域有着重要应用。Naor和Pinkas最早研究了抵抗自适应腐化者的OT传输协议。M.Green.S.Hohenberger等研究了UC安全的OT协议，不过这些协议基本随机预言模型或者基于一些非经典密码学困难性假设，这些协议对于实际应用而言仍然效率显低。
在OT拓展协议方面，不论是抵抗被动攻击者还是主动攻击者的OT拓展协议都取得了较大的进展。

Naor-Pinkas茫然传输协议

Naro和Pinkas通过三次公钥密码学操作实现了半诚实模型下的1-out-of-2茫然传输协议。
输入信息：发送者输入两个长度为 $l$ 比特的字符串 $x_{0},x_{1})$ ，接收者输入一个选择比特 $r$ 。
系统参数：设 $q$ , $p$ 均为素数，且满足 $q ∣ p - 1$ 。 $Z_{q}$ 为 $q$ 阶群， $G_{q}$ 是 $Z_{p}^{*}$ 的 $q$ 阶子群。给定 $Z_{p}^{*}$ 的生成元 $g$ ，满足 $D i f f i e - H e l l m a n$ 困难性假设。
随机预言函数: $H$

Step 1: 发送者生成并公布随机数 $\in {Z_q}$ ，然后发送者生成随机数 $a$ ，并计算 $g_{a}$ 和 $C_{a}$ 。

Step 2: 接收者选择随机数 $\leqslant k \leqslant q$ ,并生成公钥 $pk_{r}$ ， $pk_{1-r}=C/g_{k}$ ，接收者将 $pk_{0}$ 发送给发送者。

Step 3: 发送者计算 $pk_0)^{a}$ ， $pk_1)^{a}=C_{a}/(pk_{0})^{a}$ 。发送者执行加密计算，并将加密结果 $E_0,E_1)$ 发送给接收者。
${E_0} = ({g_a},H({(p{k_0})^a},0) \oplus {x_0})\\{E_1} = ({g_a},H({(p{k_1})^a},1) \oplus {x_1})$

Step 4:接收者计算 $H((pk_{r})^{a})=H((g_a)^k)$ ，然后计算 $x_{r}$ 。

${x_r} = {E_{r,2}} \oplus H({(p{k_r})^a},r)$

其中， $E_{r,2}$ 表示 $E_{r}$ 的第二个元素。

IKN茫然传输协议

Ishai等人提出的茫然传输扩展协议可以将一个 $OT_{l}^{m}$ 协议首先转化为调用一次 $OT_{m}^{\lambda }$ 协议，然后将 $OT_{m}^{\lambda}$ 协议转化为调用 $\lambda$ 次 $OT_{m}^{\lambda}$ 协议。其中， $\lambda$ 表示系统安全参数。 $M_i$ , $M_j$ 分别表示矩阵M的第 $i$ 列和第 $j$ 行， $S$ 与 $R$ 分别表示发送者和接收者。

子协议1： $OT_{l}^{m}$ 转换为 $OT_{m}^{\lambda}$
输入信息：S的输入信息是m对长度 $l$ 比特字符串 $x_{j,0},x_{j,1})$ ，其中， $\leqslant k \leqslant m$ ; $R$ 的输入是m个选择比特 $r=(r_{1},…r_{m})$ 。
随机预言函数： $H [m] \times$ {0,1} $_{k}→$ {0,1} $_{l}$ 。
系统参数：安全参数 $\lambda$ 。
步骤1：S生成随机向量 $\in {\{ 0,1\} _\lambda }$ , $R$ 生成一个 $m×\lambda$ 的随机矩阵 $T$ 。
步骤2：参与者调用 $OT_{m}^{\lambda}$ 协议。在这个协议中，S扮演输入为s的接收者， $R$ 扮演输入为 $(t_{i},r\oplus t_{i})$ 的发送者，其中 $\leqslant i \leqslant \lambda$ 。
步骤3：令 $Q$ 代表 $S$ 在步骤2中接收到的 $m×\lambda$ 的矩阵，即 ${q_i} = ({s_i},r) \oplus {t_i}$ , ${q_j} = ({r_{j}*s}) \oplus {t_j}$ 。对于 $\leqslant j \leqslant m$ , S 向R发送 $y_{j,0}=x_{j,0} \oplus H(j,q_{j})$ ， $y_{j,1}=x_{j,1} \oplus H(j,q_{j} \oplus s)$ 。
步骤4：对于 $\leqslant j \leqslant m$ , $R$ 输出 ${z_j} = {y_{i,r}} \oplus H(j,{t_j})$ 。

子协议2： $OT_{m}^{\lambda}$ 转换为 $OT_{\lambda}^{\lambda}$
输入信息： $S$ 的输入信息是 $\lambda$ 对长度为 $m$ 比特的字符串 $x_{i,0},x_{i,1})$ 。其中 $1\leqslant i \leqslant \lambda$ ； $R$ 的输入是 $\lambda$ 个选择比特 $r=(r_{1},r_{2}…,r_{\lambda})$ 。
系统参数：安全参数 $\lambda$ 。
随机预言函数：一个伪随机数生成器 $G :$ {0,1} $_{\lambda}$ $\to$ {0,1} $_{m}$ 。
步骤1：S随机生成 $\lambda$ 对 $k$ 比特的字符串 $s_{i,0},s_{i,1})$ .
步骤2：参与者调用 $OT^{\lambda}_{\lambda}$ 协议。在这个协议中， $S$ 扮演输入为 $s_{i,0},s_{i,1})$ 的发送者， $R$ 扮演输入为 $r$ 的接收者，其中 $\leqslant i \leqslant \lambda$ 。
步骤3：对于 $\leqslant i \leqslant \lambda$ ， $S$ 向 $R$ 发送 $y_{j,0}$ 和 $y_{j,1}$ ，其中 $y_{i,b}=x_{i,b} \oplus G(s_{i,r_{i}})$ 。
上述协议的调用的 $OT^{\lambda}_{\lambda}$ 协议可以通过调用 $\lambda$ 次 $OT^{1}_{\lambda}$ 协议实现。

子协议3： $OT_{l}^{m}$ 转换为 $OT_{\lambda}^{\lambda}$
输入信息： $S$ 的输入信息是 $m$ 对长度为 $l$ 比特的字符串 $x_{j,0},x_{j,1})$ ，其中 $\leqslant j \leqslant m$ 。 $R$ 的输入是 $m$ 个选择比特 $r=(r_{1},…r_{m})$ 。
系统参数：安全参数 $\lambda$ >
随机预言函数： $H:[m]×{0,1}_{\lambda} \to$ {0,1} $_{l}$ 。
伪随机数生成器： $G:{0,1}_{\lambda} \to {0,1}_{m}$ 。
步骤1： $R$ 生成随机字符串对 $({k_{j,0}},{k_{j,1}}) \in {\{ 0,1\} _{2\lambda }}$ ， $\leqslant j \leqslant m$ 。 $S$ 生成随机向量s $\in {\{ 0,1\} _\lambda }$ 。 $S$ 和 $R$ 执行 $OT^{\lambda}_{\lambda}$ ，其中 $S$ 扮演接收者， $R$ 扮演发送者。协议结束后， $S$ 获得 $k_{j,s_{j}}$ ， $\leqslant j \leqslant \lambda$ 。
步骤2： $R$ 生成一个 $\times$ $\lambda$ 的随机比特矩阵 $T$ ,计算 $v_{j,0}=t_{j} \oplus G(k_{j,0})$ ， $v_{j,1}=t_{j} \oplus G(k_{j,1} \oplus r)$ ，并将 $v_{j,0},v_{j,1}$ 发送给 $S$ ， $\leqslant j \leqslant \lambda$ 。
步骤3： $S$ 生成 $\times\lambda$ 的矩阵 $Q$ ,其中 $q^{j}=v_{j,s_{j}} \oplus G(k_{j,s_{j}})$ ， $\leqslant j \leqslant \lambda$ 。 $S$ 计算 $y_{i,0}=x_{i,0} \oplus H(q_{i})$ ， $y_{i,1}=x_{i,1} \oplus H(q_{i} \oplus s)$ ，并将 $y_{i.0},y_{i,1})$ 发送给 $R$ ， $\leqslant i \leqslant m$ 。
步骤4：对于 $\leqslant j \leqslant m$ , $R$ 输出 $z_{j}=y_{i,r_{j}} \oplus H(t_{j})$ 。
字协议3中， $R$ 共调用 $m$ 次 $H$ ， $2\lambda$ 次 $G$ ，发送数据 $2m\lambda$ 比特； $S$ 共调用 $2 m$ 次 $H$ ， $\lambda$ 次 $G$ ，发送数据 $2 m l$ 比特。当 $\lambda=m$ 时， $OT^{\lambda}_{\lambda}$ 的消耗可以忽略不计。