---

中文版

概述

Rosetta 是一个基于 TensorFlow 的隐私保护框架。它集成了主流的隐私保护计算技术，包括密码学、联邦学习和可信执行环境。Rosetta 的目标是在无需密码学、联邦学习和可信执行环境专业知识的情况下，为人工智能提供隐私保护解决方案。Rosetta 复用了 TensorFlow 的 API，并允许以最小的改动将传统的 TensorFlow 代码转换为隐私保护模式。例如，只需添加以下一行代码：

import latticex.rosetta

当前版本集成了针对三方的安全多方计算协议。底层协议是 SecureNN 和 Helix，它们在诚实多数的半诚实模型下是安全的。

Rosetta 还集成了高效的零知识证明协议 Mystique，用于复杂 AI 模型（如 ResNet）的安全推理任务。请参阅 示例 了解其使用方法。

安装

目前，Rosetta 运行在 Ubuntu 18.04 上，并基于 TensorFlow 1.14 和 CPU 架构（暂不支持 Windows 操作系统）。您可以按照以下步骤安装 Rosetta。

首先，请确保您的本地系统满足我们的 基础环境要求。

然后，使用以下命令安装原生 TensorFlow。请注意，您也可以从源代码安装，详细信息请参阅 此处。

# 安装 tensorflow
pip3 install tensorflow==1.14.0

接下来，使用我们的一体化脚本构建并安装 Rosetta，具体步骤如下：

# 克隆 rosetta git 仓库
git clone --recurse https://github.com/LatticeX-Foundation/Rosetta.git

或（注：由于近期 GitHub 对个人令牌的更改，SSH 方式仍然有效，请参考 GitHub 获取最新更新）
git clone git@github.com:LatticeX-Foundation/Rosetta.git
git submodule update --init --recursive
cd Rosetta
# 编译、安装。您可以通过运行 `rosetta.sh --help` 查看更多编译选项。
./rosetta.sh compile --enable-protocol-mpc-securenn; ./rosetta.sh install

在运行您的程序之前，您需要根据网络拓扑进行配置，以便建立分布式网络，使各方能够相互通信。

您可以使用一个示例来检查一切是否正常运行。有关 Rosetta 的安装、配置和部署的详细步骤，请参阅 部署指南。

使用

以下是使用 Rosetta 进行矩阵乘法的一个简单 示例。

在这个示例中，我们假设三个人希望计算各自私有矩阵的乘积，但又不希望其他人知道他们持有的内容。为了简洁起见，我们将这三人分别称为 P0、P1 和 P2。

借助 Rosetta，每个人都可以运行以下脚本，从中可以看出，除了原生 TensorFlow 的代码外，只需要少量额外的代码即可实现。

#!/usr/bin/env python3

# 导入 rosetta 包
import latticex.rosetta as rtt
import tensorflow as tf

# 激活后端协议，这里我们使用 SecureNN
rtt.activate("SecureNN")

# 从各方获取私有数据
matrix_a = tf.Variable(rtt.private_console_input(0, shape=(3, 2)))
matrix_b = tf.Variable(rtt.private_console_input(1, shape=(2, 1)))
matrix_c = tf.Variable(rtt.private_console_input(2, shape=(1, 4)))

# 直接使用原生的 tf.matmul 操作。
cipher_result = tf.matmul(tf.matmul(matrix_a, matrix_b), matrix_c)

# 开始执行
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # 查看密文结果
    cipher_result = sess.run(cipher_result)
    print('本地密文结果:', cipher_result)
    # 设置只有 P0 和 P2 可以获得明文结果
    a_and_c_can_get_plain = 0b101 
    # 获取 Rosetta matmul 的结果
    print('明文矩阵乘法结果:', sess.run(rtt.SecureReveal(cipher_result, a_and_c_can_get_plain)))

要联合运行此程序，在完成网络配置后，三个人可以分别运行以下命令行：

python rosetta_demo.py --party_id=0

、

python rosetta_demo.py --party_id=1

以及

python rosetta_demo.py --party_id=2

随后，每个参与者会被提示输入自己的私有矩阵。例如，P0 可能会收到：

2021-10-22 09:46:08.571|info|Rosetta: 协议 [SecureNN] 后端初始化成功！任务：，节点 ID：P0

请输出私有数据（浮点数或整数，共 6 个，用空格分隔）：2 3 1 7 6 2

而 P1 则会收到：

2021-10-22 09:46:08.571|info|Rosetta: 协议 [SecureNN] 后端初始化成功！任务：，节点 ID：P1

请输出私有数据（浮点数或整数，共 2 个，用空格分隔）：1 2

P2 则会收到：

2021-10-22 09:46:08.571|info|Rosetta: 协议 [SecureNN] 后端初始化成功！任务：，节点 ID：P2

请输出私有数据（浮点数或整数，共 4 个，用空格分隔）：2 1 4 3

需要注意的是，这种通过控制台输入的方式仅用于本示例的教学目的。有关生产级的数据 API，请参阅我们的 文档。

最终，P0 和 P2 将获得明文输出，而 P1 则不会，正如预期的那样。具体来说，P0 和 P2 可能会看到：

明文矩阵乘法结果：[[b'16.000000' b'8.000000' b'32.000000' b'24.000000']

[b'30.000000' b'15.000000' b'60.000000' b'45.000000']

[b'20.000000' b'10.000000' b'40.000000' b'30.000000']]

2021-10-22 09:49:58.888|info|Rosetta: 协议 [SecureNN] 后端已释放。

而 P1 则会看到：

明文矩阵乘法结果：[[b'0.000000' b'0.000000' b'0.000000' b'0.000000']

[b'0.000000' b'0.000000' b'0.000000' b'0.000000']

[b'0.000000' b'0.000000' b'0.000000' b'0.000000']]

2021-10-22 09:49:58.887|info|Rosetta: 协议 [SecureNN] 后端已释放。

这就是全部内容，您可以看到 Rosetta 非常易于使用。

那么，如何在 Rosetta 中快速使用 ZKP 呢？与上述 MPC 类似，这里有一个简单的 示例。

#!/usr/bin/env python3

# 导入 Rosetta 包
import latticex.rosetta as rtt
import tensorflow as tf

# 您可以激活一个后端协议，这里我们使用 Mystique
rtt.activate("Mystique")

# P0 是证明者，提供所有见证数据（私密的），而
# P1 是验证者
matrix_a = tf.Variable(rtt.private_console_input(0, shape=(3, 2)))
matrix_b = tf.Variable(rtt.private_console_input(0, shape=(2, 3)))

# 直接使用原生的 tf.matmul 操作。
cipher_result = tf.matmul(matrix_a, matrix_b)

# 开始执行
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # 查看密文结果
    cipher_result_v = sess.run(cipher_result)
    print('本地密文结果:', cipher_result_v)
    # 获取 Rosetta matmul 的结果
    print('明文结果:', sess.run(rtt.SecureReveal(cipher_result)))

rtt.deactivate()

此处 P0 是证明者，负责提供所有见证数据（私密的），输入如下：

2021-10-22 18:12:46.629|info|Rosetta: 协议 [Mystique] 后端初始化成功！任务：，节点 ID：P0

2021-10-22 18:12:46.629|info|创建并激活成功。任务：针对协议：Mystique

请录入私密数据（浮点数或整数，共6项，以空格分隔）：0 1 2 3 4 5

请录入私密数据（浮点数或整数，共6项，以空格分隔）：5 4 3 2 1 0

此处 P1 是验证者，在最后验证成功，并输出明文结果如下：

2021-10-22 18:13:12.860|info|zk 验证成功！！

明文结果：[[b'2.000000' b'1.000000' b'0.000000']

[b'16.000000' b'11.000000' b'6.000000']

[b'30.000000' b'21.000000' b'12.000000']]

2021-10-22 18:13:13.009|info|Rosetta: 协议 [Mystique] 后端已释放。

更多详情，请查看 教程 和 示例。

注：目前 Rosetta 已支持 128 位整数数据类型，可通过设置环境变量 export ROSETTA_MPC_128=ON 并在编译时添加选项 --enable-128bit 来启用。

入门指南

为了帮助您轻松上手第一个可用的 Rosetta 程序，我们的 教程 将引领您进入这个精彩的世界。在这些详尽的教程中，我们将引导您学习 Rosetta 的基本概念，然后通过易于理解的示例向您展示如何使用我们提供的接口，最终帮助您在真实世界的数据集上构建一个可行的隐私保护机器学习模型。

希望本教程以及 示例 中的其他示例能够激发您进一步了解这一隐私保护框架的兴趣。

Rosetta 的工作原理

Rosetta 通过扩展和“黑客式”改造 TensorFlow 的 Python 前端和后端的操作内核来实现其功能。它将 TensorFlow 相关组件的开发与隐私技术分离，使人工智能和密码学领域的开发者都能专注于自己感兴趣的领域。

当运行您的 Rosetta 程序时，首先会转换原生的 TensorFlow 数据流图，在此过程中，图中的原生操作会被替换为 SecureOps。

随后，在第二阶段，会调用基于特定加密协议实现的操作后端内核，以执行底层的安全计算。

参与 Rosetta 的贡献

Rosetta 是一个在 LPGLv3 许可证下开发的开源项目，由 LatticeX 基金会 维护。我们欢迎个人和组织的贡献。在开始之前，请先阅读我们的 贡献指南。我们的项目遵守 行为准则，参与社区的成员应遵守该准则。您也可以点击 这里 提交问题。

文档列表

• Rosetta 教程

• Rosetta 部署指南

• Rosetta 用户 API

• Rosetta 白皮书

• Rosetta 术语表

• Rosetta 发布说明

• 常见问题解答

引用

您可以按以下方式引用我们的工作：

    @misc{Rosetta,
      author = {Yuanfeng Chen 和 Gaofeng Huang 和 Junjie Shi 和 Xiang Xie 和 Yilin Yan},
      title = {{Rosetta：基于 TensorFlow 的隐私保护框架}},
      howpublished = {\url{https://github.com/LatticeX-Foundation/Rosetta}},
      year={2020}
    }

参考资料

请参阅此 维基页面 获取参考资料。

联系方式

您可以通过 电子邮件 与我们联系。欢迎您加入 Rosetta 社区的 Slack ，在这里您可以提出任何问题，并与其他开发者讨论感兴趣的话题。

许可证

Rosetta 库根据 GNU 宽通用公共许可证 v3.0 授权。

Rosetta 快速上手指南

Rosetta 是一个基于 TensorFlow 的隐私保护框架，集成了安全多方计算（MPC）、联邦学习和可信执行环境等技术。它允许开发者通过极少的代码改动（仅需导入一个包），将传统的 TensorFlow 代码转换为隐私保护模式，无需深厚的密码学背景。

1. 环境准备

在开始之前，请确保您的开发环境满足以下要求：

• 操作系统：Ubuntu 18.04（目前不支持 Windows）。
• 硬件架构：CPU（支持 x86_64）。
• Python 版本：需兼容 TensorFlow 1.14 的 Python 环境（通常推荐 Python 3.6 或 3.7）。
• 前置依赖：
  • Git
  • pip3
  • 基础编译工具链 (gcc, g++, make 等)

注意：Rosetta 当前基于 TensorFlow 1.14.0 构建。

2. 安装步骤

第一步：安装原生 TensorFlow

首先安装指定版本的 TensorFlow：

pip3 install tensorflow==1.14.0

第二步：克隆代码库

使用 Git 克隆 Rosetta 仓库及其子模块：

# 方式一：使用 HTTPS
git clone --recurse https://github.com/LatticeX-Foundation/Rosetta.git

# 方式二：使用 SSH (如果配置了 GitHub SSH Key)
# git clone git@github.com:LatticeX-Foundation/Rosetta.git
# cd Rosetta
# git submodule update --init --recursive

第三步：编译与安装

进入目录并使用官方提供的一键脚本进行编译和安装。默认启用 SecureNN 协议：

cd Rosetta

# 编译并安装
./rosetta.sh compile --enable-protocol-mpc-securenn
./rosetta.sh install

提示：如需支持 128 位整数数据类型，请在编译时添加 --enable-128bit 选项，并设置环境变量 export ROSETTA_MPC_128=ON。

第四步：网络配置

Rosetta 需要多方参与通信。在运行程序前，需根据部署拓扑配置网络文件（如 party.conf），确保各参与方（Party）之间可以互相通信。详细配置请参考项目内的 doc/DEPLOYMENT.md。

3. 基本使用

Rosetta 的使用非常简便，只需导入 latticex.rosetta 并激活相应协议，即可复用 TensorFlow API 进行隐私计算。

以下是一个最简单的三方矩阵乘法示例：假设 P0、P1、P2 三方各自持有私有矩阵，希望计算乘积但不泄露原始数据。

代码示例 (rosetta_demo.py)

#!/usr/bin/env python3

# 导入 rosetta 包
import latticex.rosetta as rtt
import tensorflow as tf

# 激活后端协议，此处使用 SecureNN
rtt.activate("SecureNN")

# 获取各方的私有数据 (模拟从控制台输入)
# shape 分别对应 (3, 2), (2, 1), (1, 4)
matrix_a = tf.Variable(rtt.private_console_input(0, shape=(3, 2)))
matrix_b = tf.Variable(rtt.private_console_input(1, shape=(2, 1)))
matrix_c = tf.Variable(rtt.private_console_input(2, shape=(1, 4)))

# 直接使用原生的 tf.matmul 操作
cipher_result = tf.matmul(tf.matmul(matrix_a, matrix_b), matrix_c)

# 启动会话执行
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    
    # 查看密态结果 (可选)
    cipher_result_val = sess.run(cipher_result)
    print('local ciphertext result:', cipher_result_val)
    
    # 设定只有 P0 (bit 0) 和 P2 (bit 2) 可以获取明文结果 (二进制 101 = 5)
    a_and_c_can_get_plain = 0b101 
    
    # 解密并输出结果
    print('plaintext matmul result:', sess.run(rtt.SecureReveal(cipher_result, a_and_c_can_get_plain)))

运行方法

配置好网络后，三个参与方需在各自的终端分别运行以下命令（指定不同的 party_id）：

参与方 0 (P0):

python rosetta_demo.py --party_id=0

参与方 1 (P1):

python rosetta_demo.py --party_id=1

参与方 2 (P2):

python rosetta_demo.py --party_id=2

运行效果

1. 每个进程启动后，会提示输入私有数据（浮点数或整数，空格分隔）。
2. 计算完成后，根据权限设置：
   • P0 和 P2 将看到正确的矩阵乘法明文结果。
   • P1 将看到全零结果（因为未被授权获取明文）。

---

更多高级用法（如零知识证明 Mystique 协议）及详细教程，请参阅项目文档 doc/TUTORIALS.md 和 example 目录。