曼哈顿距离的保密计算

最新推荐文章于 2025-04-28 16:31:20 发布

置顶不染心

最新推荐文章于 2025-04-28 16:31:20 发布

阅读量1.1k

点赞数 1

分类专栏：安全多方计算

本文链接：https://blog.csdn.net/qq_38234785/article/details/106290837

版权

安全多方计算专栏收录该内容

7 篇文章

订阅专栏

Goldwasser-Micali 公钥加密系统

文章目录

一、预备知识

1、二次剩余

同余理论中，一个整数 x 对另一个整数 p 的二次剩余指 : 当 $x^2 = d(mod p)\,.$ 成立，则称d 是模 p 的二次剩余；否则称非二次剩余

2、雅可比符号

雅可比符号是勒让德符号的推广，但是根据雅可比符号的值不能判断同余式是否有解。

3、曼哈顿距离

在这里插入图片描述
图中红线代表曼哈顿距离，绿色代表欧氏距离，也就是直线距离，而蓝色和黄色代表等价的曼哈顿距离。曼哈顿距离——两点在南北方向上的距离加上在东西方向上的距离，即 $d (i, j) = ∣ x i - x j ∣ + ∣ y i - y j ∣$

二、加密算法

1、Paillier同态加密算法

$\rule{14.3cm}{0.05em}$
密钥生成 选取两个大素数 $p, q$ , 计算 $N = p q, λ = l c m (p - 1, q - 1) .$ 定义函数 $=\frac{x−1}{N}$ , 随机选择一个生成元 $g \in Z * N$ , 使得 $gcd(L(g^λmod N^2), N ) = 1$ . 则加密方案的公钥为 $(g, N)$ , 私钥为 λ.
加密过程 对于明文 m < N, 选取随机数 r < N, 计算得密文 $c = g^mr^N mod N^2$
解密过程 对密文 c, 计算得明文 $m = D (c)$ $=\frac{L(c^λmod N^2)}{L(g^λ mod N^2)} mod N$
加法同态性: 由于下面性质成立:
$E(m_1) × E(m_2) = g^{m_1}r^{N_1}g^{m_2}r^{N_2}mod N^2= g^{m_1+m_2}(r_1r_2)^Nmod N^2= E((m_1 + m_2) mod N )$

2、Goldwasser-Micali 公钥加密系统

$\rule{14.3cm}{0.05em}$

密钥产生：

大素数 $p ， q$ ，求出 $N = p * q$
任取R，满足 $J(\frac{R}{p})=J(\frac{R}{q})=-1$
$P K (R, N), S K (p, q)$

加密：

$B$ 将明文转化为二进制数字 $M=(m_1,m_2,m_3… m_k) ∈{0,1}$
对于每一个 $m_i$ ，都对应选取一个 $x_i ∈\lbrace1，N_{-1}\rbrace$
若 $m_i=1, c_i=R^1*r^2modN$
若 $m_i=0, c_i=R^0*r^2modN$
$=\lbrace c_1,c_2,c_3…c_k\rbrace$ 将这个 $C$ 发给 $A$

解密：
$计算J(\frac{c}{p}) 和 J(\frac{c}{q}) \;\;\; m_i=\left\{ \begin{aligned} 0 & & 若都=1 \\ 1 & & 若都=-1 \\ \end{aligned} \right.$

可参考上一篇博客：Goldwasser-Micali公钥加密系统

$\rule[-10pt]{14.3cm}{0.05em}$
在这里插入图片描述

三、基于Goldwasser-Micali 公钥加密系统的曼哈顿距离的保密计算

编码方式1 假设全集为 U = {−3, −2, · · · , 4, 5}, 对于点 P(5, 3), 根据编码方法 1, 将横坐标 5 编码为A1 = (1, 1, 1, 1, 1, 1, 1, 1, 1). 将纵坐标 3 编码为 A2= (1, 1, 1, 1, 1, 1, 1, 0, 0),
P(5, 3), A(P ) = (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0)
Q(−3, −2), A(Q) = (1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0)

计算原理 1: 在下面计算中, 假设全集为 $U = {u_1, · · · , u_n},$ Alice 和 Bob 分别拥有点 $P (x_1, y_1)$ 和 $Q(x_2, y_2)$ , 满足 $x_1, y_1, x_2, y_2 ∈ U$ , 在全集 U 之下, 点 P (或 Q) 按照编码方式 1 对应的向量记为 $A = (a_{11}, · · · , a_{1n}, a_{21}, · · · , a_{2n})(或B = (b_{11}, · · · , b_{1n}, b_{21}, · · · , b_{2n}))$ 关于两点 P 和 Q 之间的曼哈顿距离, 有下面的结论.
命题 1 点 P 和 Q 间的曼哈顿距离可由下式计算:
$\mid x_1 - x_2\mid + \mid y_1 - y_2\mid = \sum\limits_{i=1}^2\sum\limits_{j=1}^n(a_{ij} \oplus b_{ij})$
$\rule{14.3cm}{0.05em}$
协议 1 半诚实模型下安全计算两点间的曼哈顿距离
$\rule{14.3cm}{0.1em}$
输入 Alice 输入私密点 $P(x_1, y_1)$ , Bob 输入私密点 $Q(x_2, y_2)$ .
输出 $f_1(P, Q) = f_2(P, Q)=\mid x_1 - x_2\mid + \mid y_1 - y_2\mid$
准备工作 Alice 根据编码方法 1 构造 P 对应的向量 $A = (a_{11}, · · · , a_{1n}, a_{21}, · · · , a_{2n});$ Bob 根据编码方法 1 得到 Q 对应的向量 $B = (b_{11}, · · · , a_{1n}, b_{21}, · · · , b_{2n}).$ Alice 运行 Goldwasser-Micali 加密方案, 生成公钥/私钥对 $p k / s k$ , 将公钥 pk 发送给 Bob.

(1) Alice 用公钥加密向量 A (分别对每个分量加密), 得到 $E(A) = (E(a_{11}), · · · , E(a_{1n}), E(a_{21}), · · · , E(a_{2n}))$ 并将 $E (A)$ 发送给 Bob.

(2) Bob 加密向量 B 的每个分量, 并计算 $R = (E(a11)E(b11), · · · , E(a_{1n})E(b_{1n}), E(a_{21})E(b_{21}), · · · , E(a_{2n})E(b_{2n}))$ 再将 R 的 n 个分量进行随机置换, 得到新的向量, 记为 R`, 并将 R` 发送给 Alice.

(3) Alice 解密 ˆR (分别对每个分量解密), 得到 $D(ˆR) = (d_{11}, · · · , d_{2n})$ 计算 $y = d_{11}+ · · · + d_{2n}$ , 并将 y 发给 Bob.

(4) Alice 和 Bob 输出 y.
$\rule{14.3cm}{0.1em}$

四、增强的曼哈顿距离协议

编码方式2假设全集为 U = {−3, −2, · · · , 4, 5}, 对于点 P(−3, −2), 应用编码方式 2, 将 x1= −3 编码为V1 = (0, 1, 1, 1, 1, 1, 1, 1, 1), 将 y1= −2 编码为 V2= (0, 0, 1, 1, 1, 1, 1, 1, 1), 并得到 P (−3, −2) 应用编码方法 2 对应的向量 V § = (0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1).

计算原理 2: 在下面计算中, 总假设全集为 U = {u_1, · · · , u_n}, Alice 和 Bob 分别拥有点P (x_1, y_1), Q(x_2, y_2), 满足 x_1, y_1, x_2, y_2 ∈ U, 在全集 U 之下, 对点 P (或 Q) 先按照编码方式 1 (或编码方式 2) 进行编码, 再按照编码方式 2 (或编码方式 1) 进行编码, 对应的向量记为 $A = (a_{11}, · · · , a_{1n}, · · · , a_{41}, · · · , a_{4n})$ (或 $V = (v_{11}, · · · , v_{1n}, · · · , v_{41}, · · · , v_{4n}))$ 关于两点 P 和 Q 间的曼哈顿距离, 下面结论成立.

解读上面计算原理2：
对Q(-3, -2)编码：
编码方式1： $A (Q) = （ x 1, y 1 ） = (1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0)$
编码方式1： $V(Q) = （x_1`, y_1`）= (0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1)$
结合在一起： $C_1 (x_1, x_1`, y_1, y_1`)= (1, 0, 0, 0, 0, 0, 0, 0, 0,| 0, 1, 1, 1, 1, 1, 1, 1, 1,|1, 1, 0, 0, 0, 0, 0, 0, 0|,0, 0, 1, 1, 1, 1, 1, 1, 1)$

根据上面所述的计算原理, 并结合应用 Paillier 加密方案和数字承诺思想可设计构造防欺骗场景下计算两点间曼哈顿距离的安全计算

$\rule{14.3cm}{0.05em}$
协议2 防欺骗场景下安全计算两点间的曼哈顿距离输入 Alice
$\rule{14.3cm}{0.1em}$
输入 Alice私密点 $P(x_1, y_1)$ , Bob 输入私密点 $Q(x_2, y_2)$ .
输出 $f_1(P, Q) = f_2(P, Q) = |x_1 − x_2| + |y_1 − y_2|.$
准备工作 Alice 和 Bob 根据上例分别按照编码方法 1 以及编码方法 2 对点 P 和 Q 进行编码, 得到 4n 维向量 $A(P)= (a_1, · · · , a_{4n})$ 以及 $V (Q) = (v_1, · · · , v_{4n})$ , 双方再商定一个哈希函数. 在下面, 将Paillier 加密及解密算法分别记为 E` 以及 D`.

(1) Alice 加密向量 A(P)(逐分量加密), 得到 $R ‘ = (E ‘ (a 1), \cdot \cdot \cdot, E ‘ (a 4 n))$ 并将 R` 发送给 Bob.
(2) Bob 选择随机数 s, 计算 v=hash(s), 利用 Paillier 加密算法加密得到 E`(s), 进一步计算
$\prod \limits_{i=1}^{4n}(E`(a_i))^{vi})E`(s)$
Bob 将 v 以及 T 发送给 Alice.
(3) Alice 解密 T 得到 t` = D`(T), 并将 t` 发送给 Bob.
(4) Bob 计算 d = t` − s, 并将 d 发给 Alice.
(5) Alice 验证 hash(t`− d) = v 是否成立. 若成立, 则输出 d; 否则, 不接受 d.

解读协议2
因为Paillier同态加密： $c = g^mr^N mod N^2$

$1、(E`(a_i))^{vi})=g^{a_iv_i}(r)^{Nv_i}mod N^2=E`(a_iv_i)$
$2、\prod \limits_{i=1}^{4n}(E`(a_i))^{vi}= \sum \limits_{i=1}^{4n}(a_iv_i)$
$\prod \limits_{i=1}^{4n}(E`(a_i))^{vi})E`(s)=\sum \limits_{i=1}^{4n}(a_iv_i) + s$

由 Paillier 加密算法的加法同态性, 协议第 (3) 步 Alice 解密可得到 $\sum \limits_{i=1}^{4n} a_iu_i + s,$ 再由 Bob 在第 (4) 步中计算可知, $s=\sum \limits_{i=1}^{4n}a_iv_i$
这里使用s的目的，就是给Alice一个验证的步骤，以验证Bob是否欺骗自己

$\rule{14.3cm}{0.1em}$

五、仿真实验

1、Paillier同态加密算法

from paillierlib import paillier
from gmpy2 import mpz

key_pair = paillier.keygen()# Optional param.: bit size (default = 2048)
m1 = mpz(50)
m2 = mpz(21)
c1 = paillier.encrypt(m1, key_pair.public_key)
c2 = paillier.encrypt(m2, key_pair.public_key)

print(paillier.decrypt(c1 + c2, key_pair.private_key))# => 71
print(paillier.decrypt(c1 - c2, key_pair.private_key))# => 29
print(paillier.decrypt(c1 + c1 + c2, key_pair.private_key))# => 121
# Multiplication (ciphertext with plaintext)
m3 = mpz(2)
print(paillier.decrypt(c1 * m3, key_pair.private_key))# => 100

2、GM加密系统代码模拟与同态性质验证

这里因为还不是特别了解这个加密算法，在参数选择上比较随意，知识仿真实验一下。

# GM（Goldwasser - Micali）概率公钥加密算法，
# 其基于二次剩余难以复合困难性问题
import math
import random


class Alice:
    p = 0
    q = 0
    N = 0
    R = 0
    M = []
    def __init__(self, p, q, R):
        self.p = p
        self.q = q
        self.N = p * q
        self.R = R
    # 解密
    def Dc(self, eM):
        self.M = []
        for i,em in enumerate(eM):
            temp = '0'
            c = int(math.sqrt(em % self.N))
            # a = int(math.sqrt(em % self.q))
            # 判断加密后的数组元素a, (a mod p) and (a mod q)是否是二次剩余
            if c ** 2 == em:
                temp = '0'
            # if c ** 2 != em and a ** 2 != em:
            else:
                temp = '1'
            self.M.append(temp)
        return self.M

class Bob:
    M = ''
    PK = {
        "R" : 0,
        "N" : 0
    }
    C = []

    def __init__(self, R, N):
        self.PK['R'] = R
        self.PK['N'] = N

    # 加密
    def Ec(self, M):
        C = []
        for i,m in enumerate(M):
            c = 0
            # 产生一个随机数，要满足randomnum是mod N的二次剩余
            randomnum = random.randint(1,20000)
            if m == '1':
                c = (self.PK['R'] * (randomnum ** 2) ) % self.PK["N"]
            else:
                c = (randomnum ** 2) % self.PK["N"]
            C.append(c)
        return C

# 验证同态性质
def testTong(a, b):
    result = []
    for i in range(len(a)):
        result.append(a[i] * b[i])
    return result


if __name__ == '__main__':
    p, q, R = 232312311797, 971179711797, 17
    a = "1011011000111110000110" #

    b = "0011011000101110000111" #

    alice = Alice(p, q, R)
    bob = Bob(R, p * q)
    aa = bob.Ec(a)
    alice.Dc(aa)
    bb = bob.Ec(b)
    print("aa: "+ str(aa))
    print("bb: "+ str(bb))
    print("Dc(aa): "+ str(alice.Dc(aa)))
    print("Dc(bb): "+ str(alice.Dc(bb)))
    #验证加密后的数据是否具有异或同态性质
    temp = testTong(aa, bb)
    print("temp: "+ str(temp))
    print("Dc(temp): "+ str(alice.Dc(temp)))

结果：

aa: [2018287872, 81703521, 3249220625, 6064861248, 270898681, 169433033, 5980388112, 180284329, 3873024, 251001, 1537158377, 3446735057, 498293732, 305186873, 3109735625, 98565184, 132342016, 265103524, 20976400, 2332702532, 966733577, 279057025]
bb: [211033729, 15912121, 313599425, 1603820273, 316412944, 9948825, 1455506153, 294225409, 327392836, 41757444, 135094937, 289748484, 1749312512, 668106137, 3614294537, 200307409, 2515396, 26471025, 167598916, 708778433, 694362977, 1091811332]
Dc(aa): [‘1’, ‘0’, ‘1’, ‘1’, ‘0’, ‘1’, ‘1’, ‘0’, ‘0’, ‘0’, ‘1’, ‘1’, ‘1’, ‘1’, ‘1’, ‘0’, ‘0’, ‘0’, ‘0’, ‘1’, ‘1’, ‘0’]
Dc(bb): [‘0’, ‘0’, ‘1’, ‘1’, ‘0’, ‘1’, ‘1’, ‘0’, ‘0’, ‘0’, ‘1’, ‘0’, ‘1’, ‘1’, ‘1’, ‘0’, ‘0’, ‘0’, ‘0’, ‘1’, ‘1’, ‘1’]
temp: [425926815823634688, 1300076312278041, 1018953719698140625, 9726947422474480704, 85715849180926864, 1685659594536225, 8704491694344053136, 53044230436315561, 1268000311256064, 10481160201444, 207662314099837249, 998686257515403588, 871671460038774784, 203897222783139601, 11239500480951780625, 19743336624648256, 332892577678336, 7017562011392100, 3515621901582400, 1653369245286092356, 671264004491578729, 304677622169207300]
Dc(temp): [‘1’, ‘0’, ‘0’, ‘0’, ‘0’, ‘0’, ‘0’, ‘0’, ‘0’, ‘0’, ‘0’, ‘1’, ‘0’, ‘0’, ‘0’, ‘0’, ‘0’, ‘0’, ‘0’, ‘0’, ‘0’, ‘1’]