【隐私计算篇】混淆电路之深入浅出

源泉的小广场

已于 2024-08-06 11:41:26 修改

阅读量482

点赞数 21

文章标签：隐私计算可信计算混淆电路 yao 姚氏混淆电路百万富翁安全比较

于 2024-08-06 01:15:35 首次发布

本文链接：https://blog.csdn.net/weixin_65514978/article/details/140932691

版权

入门隐私计算的阶段，一般都会涉及对于混淆电路的学习，这是因为混淆电路是多方安全计算中的基础密码原语，也是隐私保护中重要的技术。为了帮助更好地理解混淆电路的原理，今天对其进行原理以及相关优化手段进行解析和分享。

1. 混淆电路简介

混淆电路，也被称为Yao-garbled circuits，是一种用于在加密输入上安全计算函数的密码学技术，广泛应用于安全多方计算协议中。

在混淆电路中，函数的输入和输出被加密，同时电路本身被混淆以隐藏其内部结构，接收方不知道电路中的具体门结构和逻辑。混淆的过程包括为电路的输入和输出线路分配随机标签，并加密每个逻辑门的真值表条目。混淆后的电路会被发送给接收方，接收方拥有必要的解密密钥。

接收方在评估混淆电路时，使用输入标签确定每个逻辑门的正确真值表条目，并解密这些条目以获得输出标签。通过将输出标签与预定义的期望输出标签进行比较，接收方可以获取计算结果，而不会泄露输入或计算函数的任何信息。

混淆电路提供了一种在不向参与计算的任何一方透露敏感信息的情况下，在加密数据上执行安全计算的方法。它们在安全计算协议、隐私信息检索和隐私保护机器学习等各个领域都有广泛应用。

2. 实现原理

混淆电路的实施，主要分为四个主要步骤：混淆方(发送方)准备(生成混淆电路)、通信(OT及混淆表)、评估方(接收方)计算(执行电路)、解码及共享(获得最终结果)。原理图参考OSU Mike Rosulek教授关于GC的分享【1, 2】。

2.1 准备阶段

发送方（混淆方）将要计算的函数表示为一个布尔电路，其中包含输入门、输出门和内部逻辑门。

发送方为每个输入和输出门生成两个随机的比特字符串，称为标签（labels）。一个标签对应于0的输入，另一个标签对应于1的输入。

发送方为每个内部逻辑门生成一个加密的真值表。每个真值表条目包含对应的输入标签的加密结果。

'''
pre-generate garbled truth table
'''

class PreGenerateGTT(object):
    def __init__(self, bits=64, file='compare.json'):
        self.circuit = parse_json(file)
        self.GTTs = []
        self.bits = bits

    def generate_k_garbled_table(self, k):
        for i in range(k):
            b_labels, c_labels, tables, circuit_info = generate_labels(self.circuit)
            self.GTTs.append((b_labels, c_labels, tables, circuit_info))
        return self.GTTs

    def generate_alice_labels(self, batch_a, gtts):
        a_labels_arr = []
        for i in range(len(batch_a)):
            a_bytes = intToBin(batch_a[i], self.bits)[::-1]
            b_labels, c_labels, tables, circuit_info = gtts[i]
            a_labels = generate_a_labels(self.circuit, circuit_info, a_bytes)
            a_labels_arr.append(a_labels)
        return a_labels_arr

2.2 传输阶段

发送方将加密的真值表和标签发送给接收方。
发送方还将混淆电路的结构信息（如门之间的连接关系）发送给接收方，但接收方不知道具体的门结构和逻辑。

2.3 执行阶段

接收方根据自己的输入值，使用输入标签替换电路的输入门，这里涉及到1-out-of-2 OT技术，也就是接收方需要将自己的输入值作为选择bit，从混淆方获得对应的随机标签信息。

接收方根据混淆电路的结构信息，使用加密的真值表来计算每个内部逻辑门的输出标签。这里涉及到使用输入的label对每一个对应的门混淆表进行解密，只能正确解密其中的一个真值标签。
接收方根据输出标签替换电路的输出门。

接收方将最终的输出标签发送回发送方。

2.4 解码阶段

发送方使用自己持有的解密密钥，解密接收到的输出标签。
发送方根据解密的结果确定最终的输出值。

Yao‘s混淆电路的实现依赖于加密技术和零知识证明的概念。通过对输入和输出进行加密和混淆，以及仅通过标签的比较来传递计算结果，Yao‘s混淆电路实现了对计算过程的保密性和隐私性。这种技术被广泛应用于安全多方计算和隐私保护领域，以实现在保护敏感数据的同时进行计算。

3.优化手段

混淆电路虽然是一种比较有效的多方安全计算技术，但是目前业内的应用相对有限，这可能是因为其工程实现以及大规模数据上、低带宽下的性能问题。从章节2中可以看到混淆电路可能涉及大量的逻辑门，将会带来庞大的混淆表通信消耗，。因此，自从Yao提出混淆电路后，后续有一系列对该算法的优化，如下图所示，Classical是经典的实现，之后学术界相继提出了点和置换(Point&Permutation)、Garbled Row Reduction(GRR3)、Free XOR、GRR2、FleXOR、半门（HalfGates），可以看到HalfGates在电路大小和garble环节相对classical有了很大的优化。

3.1 点和置换(Point&Permutation)

随机分配颜色对给每对电线标签，在电线标签中包含颜色（例如，作为最后一位），按密钥的颜色规范地排列四个密文，过解密由你颜色索引的密文来评估。点和置换技术 [BMR90] 使接收方无需尝试解密所有四个密文。它将每根电线 w与两个选择位 p0和 p1以及标签 W0 和 W1相关联。在评估一个门时，接收方使用对应于两个输入电线的选择位（例如， pi和 pj对应于电线 wi和 wj）来确定解密门k中的哪个密文。

def point_and_permute_garble(left_wire, right_wire, output_wire, gate_type):
    truth_table = generate_truth_table(gate_type)
    garbled_table = [None] * 4
    for line in truth_table:
        output_label = output_wire.get_label_by_value(line[2])
        key_left = left_wire.get_label_by_value(line[0])
        key_right = right_wire.get_label_by_value(line[1])
        ciphertext = enc_hash(key_left.label, key_right.label, bytes_to_int(output_label.label))
        garbled_table[2 * key_left.pp_bits + key_right.pp_bits] = ciphertext
    return garbled_table

3.2 混淆行减少 (Garbled Row Reduction, GRR3)

混淆行减少 [NPS999]，允许消除一个密文。这是通过选择一个标签使得对应的密文为0来实现的。（被消除的密文总是由选择位决定的顶部密文。）

def grr3_garble(left_wire, right_wire, output_wire, gate_type):
    set_zero_ciphertext(left_wire, right_wire, output_wire, gate_type)
    garbled_table = [None] * 3
    for left_label in left_wire.labels():
        for right_label in right_wire.labels():
            left_pp = left_label.pp_bits
            right_pp = right_label.pp_bits
            if left_pp or right_pp:
                in1 = left_label.value
                in2 = right_label.value
                boolean_to_str = {True: '1', False: '0'}
                logic_value = boolean_to_str[logic(int(in1), int(in2), gate_type)]
                output_label = output_wire.get_label_by_value(logic_value)
                ciphertext = enc_hash(left_label.label, right_label.label, bytes_to_int(output_label.label))
                garbled_table[2 * left_pp + right_pp - 1] = ciphertext
    return garbled_table

3.3 自由XOR（FreeXOR）

FreeXOR技术 [KS08] 使得计算XOR门变得无通信代价。它通过固定标签 W0 和 W1之间的关系来实现这一点。在混淆电路时，发送方选择一个随机字符串 $R \in \{0,1\}^b$ 。发送方然后随机选择每个标签 W0 并设置 W1=W0⊕R。如果门 gk是一个XOR门，并且以电线 wi 和 wj作为输入，那么电线 wk的新标签可以通过简单地取标签 Wi和 Wj的XOR来计算【3】。

def free_xor_garble(left_wire, right_wire, output_wire, gate_type):
    if gate_type == 'XOR':
        C0 = xor(left_wire.label0.label, right_wire.label0.label)
        C1 = xor(C0, gloVar.R)
        pp_bit = get_last_bit(C0)
        f_label = output_wire.label0
        t_label = output_wire.label1
        f_label.label = C0
        f_label.pp_bits = pp_bit
        t_label.label = C1
        t_label.pp_bits = not pp_bit
        return None

3.4 GRR2

混淆行减少（Garbled Row Reduction，GRR2）[PSSW09]，第二种形式的混淆行减少，允许消除两个密文而不是一个。然而，虽然第一种形式的混淆行减少与Free异或（free-XOR）技术兼容，但这种形式（GRR2）却不兼容。在GRR2中，评估者不是通过解密一次性填充加密来恢复输出标签，而是通过对二次曲线进行多项式插值来完成。输出标签被编码为y轴截距。评估者将拥有三个点来进行插值，这是进行插值所需的最低点数。由于可能存在两个输出标签，因此需要考虑两个不同的二次多项式。它们被设计成在混淆门中包含的两个点上精确相交。

3.5 FleXOR

Kolesnikov等人 [KMR14]提出了通过动态转换电线标签以保持恒定距离R，从而将自由XOR技术与AND门优化相结合的方法。根据是否需要这种转换（即，XOR门的输入是否是AND门的输出），XOR混淆门包含0到2个密文。

3.6 Half Gates

Zahur等人[ZRE15]介绍了第一种仅需要每个混淆AND门两个密文并且与FreeXOR优化兼容的技术。他们利用了对于任意 $b \in \{0,1\}$ ， $v_i \land v_j = (v_i \land (v_j \oplus b)) \oplus (v_i \land b)$ 这一事实。在Half Gates技术中， b 被确定为用来计算选择位 $p_j = v_j \oplus r_j$ 的随机值 $r_j$ 。 $b = r_j$ 由混淆方选择，并且 $v_i \oplus b = p_j$ 被透露给评估方。利用她对 b的了解，混淆方可以通过单个密文有效地混淆“混淆方半门” $v_i \land b$ 。由于评估方知道 $v_i \oplus b$ ，因此可以基于该值进行不同的操作，混淆方可以同样有效地通过单个密文混淆“评估方半门” $v_i \land (v_j \oplus b)$ 。对这两个AND操作取XOR是无通信代价的，因此只需要两个密文。

def half_gates_garble(left_wire, right_wire, output_wire, gate_type):
    if gate_type == 'AND':
        def H(x):
            return hashlib.sha256(x).digest()
        p_a = left_wire.label0.pp_bits
        p_b = right_wire.label0.pp_bits

        C0 = H(left_wire.label0.label)
        # Generator Half Gate
        entry1 = xor(C0, H(left_wire.label1.label))
        if p_b:
            entry1 = xor(entry1, gloVar.R)
        if p_a:
            C0 = xor(C0, entry1)

        # Evaluator Half Gate
        C0_ = H(right_wire.label0.label)
        entry2 = xor(C0_, H(right_wire.label1.label))
        entry2 = xor(entry2, left_wire.label0.label)

        if p_b:
            C0_ = xor(C0_, xor(entry2, left_wire.label0.label))
        table = [entry1, entry2]
        xor_c0_c0_ = xor(C0, C0_)
        update_output_wire(xor_c0_c0_, xor(xor_c0_c0_, gloVar.R), output_wire)
        return table
    elif gate_type == 'XOR':
        return free_xor_garble(left_wire, right_wire, output_wire, gate_type)
    else:
        return grr3_garble(left_wire, right_wire, output_wire, gate_type)