基于对称密钥的公开可验证PoR-优快云博客

基于对称密钥的支持公开验证的可检索性证明

摘要

可检索性证明使客户端能够将其数据存储在云服务器上，以便通过执行高效的审计协议来检查服务器是否在未来拥有其全部数据。在审计过程中，服务器必须完全掌握客户端的数据才能通过验证，即使只需访问其中少量数据块。自从朱尔斯和卡利斯基的开创性工作以来，已提出许多 PoR方案，其中一些支持动态更新。然而，所有实现公共可验证性的现有工作均基于传统的公钥密码系统，这会给低功耗客户端（例如移动设备）带来较高的计算负担。

在本研究中，我们探索了 indistinguishability obfuscation以构建一种基于对称密钥原语进行加密且支持公开验证的可检索性证明方案。该方案实现了轻量级存储与证明，但代价是验证时间较长。这在文件外包通常由低功耗客户端执行、而验证可由设备完善的机器（例如第三方服务器）完成的应用场景中可能非常有用。我们还表明，所提出的方案能够支持动态更新。最后，为了更好地评估我们提出的方案，我们给出了该方案的性能分析，并与其他几个现有方案进行了比较，结果表明我们的方案在数据所有者端和服务器端均实现了更优的性能。

关键词

云存储 · 可检索性证明 · Indistinguishabil-混淆

1 引言

如今，存储外包（例如谷歌网盘、多宝箱等）作为云计算的应用之一，正变得越来越流行。它使得客户端可以从任何位置灵活地访问外包数据。然而，存储提供商（即服务器）不一定可信。这种情况引发了一种需求：数据所有者（即客户端）能够高效地验证服务器确实存储了全部数据。更准确地说，客户端可以与不可信服务器运行一个高效的审计协议，其中服务器只有在掌握客户端的整个外包数据的情况下才能通过审计。形式上，这意味着客户端希望从服务器获得两个保证：真实性和可检索性。真实性确保客户端可以验证从服务器获取的数据的正确性。另一方面，可检索性则保证客户端存储在服务器上的数据保持完整，未发生数据丢失。显然，客户端不应需要从服务器下载全部数据来验证数据完整性，因为这在带宽和时间上可能是不可行的。同时，在审计协议执行过程中，要求服务器读取客户端全部外包数据也是不可取的。

实现上述目标的一种方法称为可检索性证明(PoR)，该方法最初由朱尔斯和卡利斯基定义并构造[1]。主要地，PoR方案可分为两类：私有可验证的和公开可验证的。需要注意的是，私有可验证的PoR系统通常仅涉及对称密钥原语，这对数据所有者在加密和上传文件时成本较低。然而，在此类系统中，数据的真实性与可检索性的保证在很大程度上依赖于数据所有者自身，因为他们需要定期执行验证（例如，审计），以便在发生数据丢失时能够尽早做出反应。如今，用户通过低功耗设备（如手机）随时随地创建和上传数据。显然，这种私有可验证的PoR系统从长远来看不可避免地会给低功耗的数据所有者带来昂贵的负担。另一方面，在具有低功耗用户的这一场景下，让一个装备良好的服务器（可信或半可信）代表数据所有者执行审计是合理的，而这需要公开可验证的PoR系统。然而，所有现有的实现公共可验证性的PoR方案都是基于传统的公钥密码学构建的，与简单且高效的对称密钥密码原语相比，这意味着更复杂和昂贵的计算。（这一观察结果也可在支持公开验证的外包计算方案中发现[34–36]。）这意味着使用公钥密码学原语的PoR方案会给低能力客户端带来相对昂贵的开销。人们可能希望构建一种不依赖传统公钥密码学原语的公开可验证 PoR方案。一种有助于克服此限制的密码学原语是不可区分性混淆（iO），它确保实现相同功能的任意两个不同（等大小）程序的混淆在计算上彼此不可区分。 iO自加尔格等人最近的突破性成果以来，[2]已变得极为重要。加尔格等人提出了首个针对以布尔电路形式编写的通用程序的高效不可区分性混淆器的候选构造。随后，萨哈伊和沃特斯[3]展示了 iO作为一种密码学原语的强大能力：他们利用 iO从伪随机函数构造了否认加密、公钥加密以及更多其他功能。最近，通过利用 iO，Ramchen等人[4]构建了一种完全安全且签名快速的签名方案，而Boneh等人[5]提出了一种多方密钥交换协议、一种高效的叛徒追踪系统以及其他应用。

我们的工作

本文中，我们探索了这一新原语 iO，用于构建PoR。具体而言，我们修改了Shacham和Waters的私有可验证PoR方案[6]，并应用 iO构建了一个公开可验证的PoR方案。我们的结果与Ramchen等人的签名方案[4],具有相似的特性，即存储和证明过程较快，但以较长的公开验证时间为代价。这种“不平衡”特性在某些应用场景中可能非常有用，例如文件外包通常由低功耗客户端执行，而验证则可由设备完善的机器（半可信第三方）完成。我们的贡献总结如下：
1. 我们探索了基于混淆技术构建可检索性证明系统。所得到的PoR方案提供了轻量级的外包，因为数据所有者在将文件上传至云服务器时仅需使用对称密钥操作。同样，在审计过程中，与现有的公开可验证的PoR方案相比，服务器的工作负载也更小。
2. 我们表明，通过应用Merkle哈希树技术，所提出的PoR方案可以支持动态更新。我们首先在文件块及其对应的块验证消息 σ上构建一个改进的B+树，然后对该树应用Merkle哈希树以确保真实性与新鲜性。
3. 需要注意的是，当前的 iO构造候选在生成混淆时会带来大量开销，但这仅是系统预处理阶段的一次性成本。因此，该成本可在大量未来的操作中被摊销。除这一一次性成本外，通过分析及与其他近期现有PoR方案的比较，我们表明我们提出的方案在数据所有者端和云服务器端均实现了良好性能。

不可区分性混淆确实提供了吸引人且有趣的特性，但当前的 iO候选构造在生成与评估方面并不实用。鉴于 iO的发展仍处于初期阶段，在附录中，我们讨论了除[2]中讨论的之外，混淆研究领域的一些可能未来方向。

1.1 相关工作

可检索性证明和可验证数据持有

首个PoR方案由朱尔斯和卡利斯基[1], 定义并构造，而首个可验证数据持有（PDP）则由Ateniese等人[7]同时提出。PoR与PDP之间的主要区别在于它们所实现的安全性概念。具体而言，PoR提供的安全保证强于PDP。一次成功的PoR审计保证服务器掌握客户端所有外包数据的知识，而一次成功的PDP审计仅确保服务器正在保留大部分数据。这意味着，在PDP系统中，即使服务器丢失了少量数据，仍有可能以较大概率通过审计。某些PDP方案[8]确实提供了完整安全性。然而，这些方案要求服务器在审计期间读取客户端的全部数据。如果数据量很大，这将变得完全不实际。详细比较可参见[9]。自从PoR和PDP提出以来，它们受到了广泛的研究关注。一方面，后续针对静态数据的工作[6,10–12]致力于提升通信效率和精确安全性。另一方面，[13–15]的研究展示了如何构建支持高效更新的动态PDP方案。尽管自Juels等人以来已提出了许多高效的 PoR方案，但其中只有少数支持高效动态更新[16–18]。

注意，在公开可验证的PoR系统中，外部验证者（称为审计员）能够代表数据所有者与云服务器执行审计协议。然而，当用户和/或外部验证者不诚实的时候，公开PoR系统并不能提供任何安全保证。为了解决这个问题， Armknecht等人最近提出了外包可恢复性证明（OPoR）[19]的概念。特别地， OPoR能够防范恶意审计员、恶意用户和恶意云服务器中任意两方之间的共谋。Armknecht等人提出了一种具体的OPoR方案，名为Fortress，该方案主要基于[6]中的私有PoR方案构建。为了在OPoR安全模型中确保安全性，Fortress 还采用了一种机制，使用户和审计员能够在无交互的情况下利用时间依赖源提取共同的伪随机比特。

不可区分性混淆

程序混淆旨在使计算机程序“难以理解”，同时保持其功能。Barak等人[20]于2001年开启了混淆的正式研究。在他们的工作中，首先提出了一种非常直观的称为虚拟黑盒混淆的概念，并且也展示了其不可能性。受此不可能性结果的启发，他们提出了另一种重要的混淆概念，称为不可区分性混淆(iO)，该概念要求：对于任意两个实现相同功能的不同（等大小）程序，其混淆后的形式在计算上是不可区分的。Garg等人[2]最近的一项突破性成果提出了首个针对以布尔电路形式编写的一般程序的高效不可区分性混淆器的候选构造。该提议的构造基于多线性映射候选[21,22]。

加尔格等人[2]的研究还展示了如何将不可区分性混淆应用于通用电路的函数加密方案的构造。在后续工作中，萨哈伊和沃特斯[3]正式研究了基于不可区分性混淆能够构建哪些密码学机制，并揭示了不可区分性混淆作为一种密码学原语的强大能力。自那以后，许多针对通用混淆的新应用被相继探索[24–28]。最近，Boneh 等人[5]和 Ramchen等人[4]通过混淆的视角重新探讨了一些已有密码学原语的构造，包括广播加密、叛徒追踪和签名。这些提出的构造确实获得了一些吸引人的特性，尽管当前的混淆候选方案会带来难以承受的开销。具体而言，Boneh 等人的广播加密实现了密文大小与用户数量无关，而他们的叛徒追踪系统则以较短的密文、私钥和公钥实现了完全的抗共谋能力。另一方面，Ramchen等人[4]提出了一种不平衡的签名算法，该算法理想情况下比不基于混淆构造的可比签名要快得多。“不平衡”意味着签名速度较快，但代价是验证时间更长。

2 预备知识

在本节中，我们定义可恢复性证明、不可区分性混淆以及我们将要用到的伪随机函数（PRF）的变体。我们所考虑的所有PRF变体都将基于单向函数构造。

2.1 可检索性证明

下文以类似于[6]中的方式给出公开可验证的PoR方案的定义。一个可检索性证明方案定义了四个算法：密钥生成、存储、证明和验证，具体如下所示：

(pk, sk) ← 密钥生成(1λ) 。输入安全参数 λ，该随机算法生成一个公私钥对(pk, sk)。

(M ∗, t) ← 存储(sk, M) 。输入一个私钥 sk和一个文件 M ∈{0, 1}∗，该算法处理 M以生成将被存储在服务器上的 M ∗以及一个标签 t。标签 t包含与文件 M ∗相关的信息。

(0,1) ← 审计(证明,验证) 。随机化的证明和验证算法共同定义了一个用于证明文件可检索性的审计协议。在协议执行过程中，两个算法均以公钥 pk和 Store输出的文件标签 t作为输入。证明算法还以Store输出的处理后的文件描述 M∗作为输入，而验证算法则以公开验证密钥 V K作为输入。协议结束时，验证输出0或1，其中1表示文件正在服务器上存储。我们将双方执行此类协议的一次运行列为：
{0, 1}←(Verify(pk, V K, t) Prove(pk, t, M∗ )).

正确性 。对于密钥生成（KeyGen）输出的所有密钥对(pk, sk)，对于所有文件 M ∈ {0, 1} ∗，以及对于存储（Store）(sk, M)输出的所有(M ∗, t)，当验证算法与有效的证明者交互时，验证通过：
(Verify(pk, V K, t) Prove(pk, t, M ∗ ))= 1.

2.2 混淆预备知识

我们回顾一下来自[2,3]的不可区分性混淆的定义。

定义 1. 不可区分性混淆（iO） 。如果一个均匀PPT机器iO满足以下条件，则称其为电路类{Cλ}λ∈N的不可区分性混淆器：
– 对于所有安全参数 λ ∈ N，对于所有 C ∈ Cλ，对于所有输入 x，我们有Pr[C′ (x) = C(x) : C′ ← iO(λ, C)]= 1。
– 对于任意（不一定是均匀的）PPT区分器(Samp, D)，存在一个可忽略函数 negl(·)，使得以下成立：如果对于所有安全参数 λ ∈ N，Pr[∀x, C0(x) = C1(x) : (C0; C1; τ) ← Samp(1λ)]> 1 −negl(λ)，那么我们有
|Pr[D(τ, iO(λ, C0))= 1:(C0; C1; τ) ← Samp(1λ)]− Pr[D(τ, iO(λ, C1))= 1:(C0; C1; τ) ← Samp(1λ)]| ≤ negl(λ).

2.3 可穿刺PRF

伪随机函数 (PRF) 是一个函数 F: K×M → Y，其中 K←$ K，使得函数 F(K,·) 与随机函数不可区分。受约束PRF [29] 是一种 PRF F(K,·)，它只能在输入空间的某些部分进行求值，而不能在其他地方求值。一种可穿刺的 PRF [3,29] 是一类受约束PRF，允许对特定长度的所有比特串进行求值，除了任意多项式大小集合中的输入。具体而言，它由两个 PPT算法 (EvalF, PunctureF) 定义，且满足以下两个性质：
– 打孔下功能保持。对于每个输入为 1λ并输出集合 S ⊆{0, 1}n的PPT算法A，对所有 x ∈{0, 1}n\S，我们有
Pr[EvalF(K{S}, x)= F(K, x): K ←$ K, K{S}← PunctureF(K, S)]= 1
– 在打孔点处伪随机。对于每一对PPT算法(A1,A2)，使得 A1(1 λ)输出一个集合 S ⊆{0, 1}n和一个状态 σ，考虑一个实验，其中 K ←$ K, K{S}← PunctureF(K, S)。成立的是
|Pr[A2(σ, K{S}, S, F(K, S))= 1)]− Pr[A2(σ, K{S}, S, Um(λ)·|S|)= 1]| ≤ negl(λ)

3 安全定义

真实性和[17,18]中的可检索性的安全定义实质上等同于[6]中可靠性的安全定义。需要注意的是，[17,18]中的安全定义适用于动态PoR系统，而[6]仅考虑静态PoR系统。静态PoR与动态PoR之间的唯一区别在于方案与动态PoR方案的区别在于，后者支持安全动态更新，包括修改、删除和插入。这会影响安全游戏中对预言机的访问。下面我们以与[17,18]相同的方式给出静态PoR系统的安全定义，然后指出如何基于静态定义获得动态PoR系统的安全定义。

3.1 静态可检索性证明的安全定义

真实性 。真实性要求客户端总能检测到服务器发送的任何消息是否偏离了诚实行为。更准确地说，考虑以下挑战者 C、恶意服务器 S和诚实服务器 S之间关于真实性自适应版本的博弈： ˜–挑战者初始化环境并向 S提供安全参数 λ的公共参数。˜–恶意服务器 S指定一个关于安全参数 λ的多项式大小的有效协议序列 P=(op1, op2,···, oppoly(λ))。所指定的操作opt可以是存储或审计。 C与 S以及一个诚实的服务器 S执行该协议。˜如果在执行任意 opj时， S发送的消息与诚实的˜服务器 S不同，且 C未输出拒绝，则攻击者 S获胜，游戏结果为1，否则为0。

定义 2 。如果任何多项式时间敌手在上述安全游戏中获胜的概率不超过negl(λ)，则称该静态可检索性证明方案满足自适应真实性。

可检索性 。可检索性保证了只要恶意服务器以不可忽略的概率通过审计测试，该服务器就必须知晓 M的全部内容；并且可以通过在挑战者 C与服务器 S之间重复运行审计协议来恢复 M。更准确地说，考虑以下安全游戏：
˜–挑战者初始化环境并向 S提供公共参数。˜–恶意服务器 S指定一个关于安全参数 λ的多项式大小的协议序列 P=(op1, op2,···,oppoly(λ))。指定的操作opt可以是 Store 或 Audit。令 M为正确的内容值。˜–挑战者 C依次与 S执行相应的协议。在执行完 P后，设 stC和 stS˜分别为挑战者和恶意服务器的最终配置（状态）。–此时，挑战者获得对处于最终配置(stC, st S˜)的恶意服务器的黑盒回滚访问权限。从配置(stC, st S˜)开始，挑战者在多项式次数˜内重复运行审计协议并与服务器 S交互，尝试提取出内容值为 M′。

如果恶意服务器 S以不可忽略的概率通过审计协议且提取出的内容值为 M′ ≠ M,，则此游戏输出1，否则输出0。

定义 3 。一个静态可检索性证明方案若满足可检索性，则存在一个高效的提取器 E ，使得对于任意多项式时间的 S，如果 S以不可忽略的概率通过审计协议，并且在与 S执行多项式次数的审计协议后，提取器 E仅以可忽略的概率输出内容值 M′ ≠ M。

上述内容表明，如果恶意服务器 S能够以不可忽略的概率通过审计协议，则提取器 E将能够提取出正确的˜内容值 M′= M。这意味着服务器必须保留对 M的完整知识。

3.2 动态可检索性证明的安全定义

动态PoR系统的安全定义与静态PoR系统的安全定义相同，区别在于恶意服务器 S可以访问的预言机包括读取、写入和审计。具体而言，真实性的安全游戏与静态PoR方案的安全游戏相同，区别仅在于恶意服务器˜可以访问读取、写入和审计预言机。这意味着协议序列 P=(op1, op2,···, oppoly(λ))中由 S指定的操作 opt可以是读取、写入或审计。类似地，可检索性的安全游戏也与静态PoR系统相同，区别仅在于恶意服务器 S可以访问读取、写入和审计预言机。注意，两个游戏的获胜条件保持不变。

4 构造

在本节中，我们首先给出一个静态公开可验证的PoR系统的构造。然后，我们讨论如何将该静态PoR方案扩展以支持高效的动态更新。

在提出我们的构造方案之前，我们分析一种使用 iO构建公开可验证的 PoR方案的平凡方法。设 n为文件块的数量， λ1为文件块的大小（此处假设每个文件块大小相等）， λ2为一个块标签 σ的大小， I为验证者请求的挑战索引集I。由于 iO能够将嵌入到混淆程序中的私钥信息对用户隐藏，因此可以构造如下方案：（1）将文件块 mi的标签设置为伪随机函数PRF F(k, mi)在私钥 k下的输出；（2）将密钥 k嵌入验证程序并对其进行混淆；（3）该验证程序仅检查被挑战的文件块的标签是否为PRF的有效输出。注意到该验证程序的输入包括挑战索引集I、被挑战的文件块及其对应的文件标签。因此，该验证程序对应的电路规模为O(poly(|I| · log n+ |I| · λ1+ |I| · λ2))，其中 |I| 是索引集 I的大小，poly(x)是关于 x的一个多项式。显然，由于该方法未提供聚合证明，因此在带宽上消耗也较大。

尽管在我们的构造中，我们修改了[6]中的私有可验证PoR方案。为了与上述分析保持一致，假设文件块不是进一步划分为扇区。然后，验证程序以挑战索引集 I、被挑战的文件块的聚合μ以及聚合的 σ′作为输入。因此，该验证程序的电路规模为 O(poly(|I| · log n+ λ1+ λ2))，远小于平凡构造中的电路规模。显然，平凡构造将导致验证程序的混淆显著增大。

类似地，我们分析当一个文件块被进一步划分为s个扇区时电路的规模，正如 [6]中的方案所做的那样。设文件块中每个扇区的大小为 λ3。在平凡构造中，电路规模保持不变，为 O(poly(|I| ·log n+ |I| · λ1+ |I| · λ2))。而我们构造中的电路规模为O(poly(|I| · log n+ s · λ3+ λ3)) ≈ O(poly(|I| · log n+ λ1+ λ3))，仍然远小于平凡构造中的电路规模。由此可见，尽管 iO是一种强大的密码学原语，但利用它并非平凡之事。

4.1 静态公开可验证PoR方案

我们修改了[6]中Shacham和Waters的私有可验证PoR方案，并将其与 iO结合，以构建一个公开可验证的PoR方案。回顾[6],中的方案，文件 F首先通过纠删码处理，然后被划分为 n个数据块。此外，每个数据块被分割为 s个扇区。这允许在存储开销和通信开销之间进行权衡，如[6]中所讨论的。

在提出静态可检索性证明方案的构造之前，我们简要讨论如何将不可区分性混淆应用于[6]中的可检索性证明方案。为此，我们需要利用在[3],中引入的一种关键技术，名为穿孔程序。从非常高的层次来看，该技术的思想是通过对程序（即将被混淆的程序）进行外科手术式地移除其关键元素来修改程序，在缺少该元素的情况下，攻击者无法赢得其必须参与的安全游戏，但这种方式不会改变程序的功能。请注意，在Shacham和Waters的可检索性证明方案中，对于每个文件块， σi被设置为 fprf(i) +∑ s j=1 αjmij，其中伪随机函数 f的私钥 kprf是针对某个特定文件 M的。这意味着对于不同的文件，会使用不同的PRF密钥kprf。为了使它成为我们在混淆程序中所需的穿孔PRF，我们消除了PRF密钥 kprf与文件 M之间的绑定关系，并且同一个PRF密钥 kprf将用于存储许多不同的文件。因此，PRF密钥 kprf将在客户端的密钥生成步骤中随机选择，而不是在存储步骤中。由于这种修改仍然能在攻击者未获得PRF密钥的情况下向σi提供随机性，因此安全性得以保持。

第二个主要变化与文件标签 t的构造相关。注意到，在Shacham和Waters的方案中， t= n‖c‖MACk mac(n‖c)，其中c= Enckenc(k prf‖ α1‖···‖αs)。在我们提出的方案中，将移除随机选取的元素 α1,···, αs。取而代之的是，我们使用另一个PRF密钥 fprf ′来生成 s伪随机数，这将使通信开销减少(s· log p)，其中logp表示每个元素 αi ∈ Z p 。由于这两项改变，对称密钥加密组件 c不再需要，且σi将被构造为 fp r f( i) +∑ s j =1 fp r f ′(j) · mi j 。

令 F1(k1,·)为一个可穿刺伪随机函数，将 log N 位输入映射到 log Zp 。此处N是文件中数据块数量的上限。令 F2(k2,·)为一个可穿刺伪随机函数，将 log s 位输入映射到 log Zp 。令SSigssk(x)为对 x生成签名的算法。

密钥生成() . 随机选择两个PRF密钥 k1 ∈ K1, k2 ∈ K2以及一个随机签名密钥对(svk, ssk) ← R SKg。设置私钥 sk=(k1, k2, ssk)。令公钥为 svk，并包含验证密钥VK，该验证密钥是下文定义的程序Check的不可区分性混淆。

Store(sk, M) 。给定文件 M和私钥 sk=(k1, k2, ssk)，执行以下步骤：
1. 对 M 应用纠删码得到 M′；
2. 将 M′划分为 n个数据块，每个数据块再划分为 s个扇区，得到{mij}，其中1 ≤ i ≤ n， 1 ≤ j ≤ s；
3. 设置文件标签 t= n‖SSigssk(n)；
4. 对每个 i， 1 ≤ i ≤ n，计算σi= F1(k1, i) +∑s j=1 F2(k2, j) · mij；
5. 输出处理后的文件M′={mij}， 1 ≤ i ≤ n， 1 ≤ j ≤ s、相应的文件标签 t以及{σi}， 1 ≤ i ≤ n。

验证(svk, V K, t) .给定标签 t，解析 t= n‖SSigssk(n) 并使用 svk 验证 t上的签名；如果签名无效，则拒绝并终止。否则，从[1, n]中随机选取一个包含 l个元素的子集 I，并对每个 i ∈ I随机选取一个元素 vi ∈ Zp。将集合 Q={(i, vi)} 发送给证明者。解析证明者的响应以获取μ1,···, μs, σ ∈ Zs+1 p 。若解析失败，则拒绝并终止。否则，输出VK(Q={(i, vi)}i∈I, μ1,···, μs, σ)。

Check: Inputs: Q={(i, vi)}i∈I, μ1,···, μs, σ
Constants: PRF keys k1, k2
if σ=∑(i,vi)∈Q vi · F1(k1, i)+∑s j=1 F2(k2, j)· μj then output 1 else output ⊥

证明(t, M′) 。给定处理后的文件 M′,{σi}, 1 ≤ i ≤ n以及由验证者发送的包含 l个元素的集合 Q，解析M′={mij}, 1 ≤ i ≤ n, 1 ≤ j ≤ s和Q={(i, vi)}。然后计算
μj= ∑(i,vi)∈Q vimij for 1 ≤ j ≤ s, and σ= ∑(i,vi) viσi,并向证明发送响应值 μ1,···, μs 和 σ。

4.2 支持高效动态更新的PoR方案

支持动态更新的PoR方案意味着能够对已存储的文件进行修改、删除和插入。需要注意的是，在静态PoR方案中，每个与mij1≤j≤s相关的σi也绑定到一个文件块索引 i。如果在此静态PoR方案中执行更新操作，则需要更改每个与涉及的文件块相对应的 σi，其代价可能非常高昂。假设客户端需要将一个文件块 Fi插入到位置 i，我们可以看到，这种插入操作需要更新所有i ≤ j ≤ n的σ j中的索引。平均而言，单次插入会导致对 n/2 σ j 的更新。

为了实现高效的插入，我们需要将 σi与索引 i解耦。具体而言，在计算 σi时应消除 F1(k1,·)，从而得到一个修改后的 σi′=∑ s j=1 F2(k2, j) · mij。然而，这将导致方案变得不安全，因为恶意服务器总是可以伪造，例如针对文件块 {mij/2}1≤j≤s的σi′/2= ∑ s j=1 F2(k2, j) ·(mij/2)，利用该 σi′。

相反，我们将 σi构建为 F1(k1, ri) +∑ s j=1 F2(k2, j)· mij，其中 ri是从Zp中选取的一个随机元素。显然，如果不将 σi与索引 i关联起来，就无法保持存储的文件块的顺序。为了确保每个最新版本的文件块都位于指定位置，我们采用一种结合了标准Merkle哈希树技术的改进型B+树数据结构。

请注意，与Shacham和Waters的方案中将文件在纠删编码后划分为n个数据块不同，此处的构造假设每个文件块是“局部地”进行编码的。（Cash等人的工作[17]也从这一点出发。）也就是说，我们不使用以整个文件作为输入的纠删码，而是使用作用于小块的编码。更准确地说，客户端将文件M划分为 n个文件块，即 M=（m1, m2,···, mn），然后将每个文件块mi单独编码为对应的码字块 ci=encode(mi)。接下来，客户端对每个 ci执行以下PoR方案以生成 σi。审计过程如前所述：验证者从[1, n]中随机选择 l个索引以及 l个随机值，并向服务器发起挑战，要求其使用这些 l个随机值以及由 l个索引指定的相应码字计算出一个证明。注意，在此构造中，每个码字 ci在生成 σi的过程中会被进一步划分为 s个扇区（ci1, ci2,···, cis）。关于这一点的更详细讨论以及如何更好地定义块大小的分析，可在[6,17]的附录中找到。

令 F1(k1,·)为一个可穿刺伪随机函数，将 log N位输入映射到 log Zp 。此处 N表示文件中数据块数量的上限。令 F2(k2,·)为一个可穿刺伪随机函数，将 log N位输入映射到 log Zp 。令Enck/Deck为对称密钥加密/解密算法， SSigssk(x)为生成对 x的签名的算法。

密钥生成() . 随机选择可穿刺PRF密钥 k1 ∈ K1 k2 ∈ K2、一个对称加密密钥 kenc ∈ Kenc以及一个随机签名密钥对(svk, ssk) ←R SKg。设置私钥 sk=(k1, k2, kenc, ssk)。令公钥为 svk，并附带验证密钥VK，其中VK是如下定义的程序CheckU的不可区分性混淆。

存储(sk, M) . 给定文件 M和私钥 sk=(k1, k2, kenc, ssk)，按以下步骤进行：
1. 将 M′拆分为 n个数据块，并对每个数据块 mi应用纠删码以得到码字块 m′ i，然后将每个数据块 m′ i 划分为 s个扇区，从而得到{m′ ij} （其中 1 ≤ i ≤ n, 1 ≤ j ≤ s）；
2. 对于每个 i, 1 ≤ i ≤ n，选择一个随机元素 ri ∈ Z p 并计算 σi= F1(k1, ri) +∑ s j =1 F2(k2, j) · m′ i j ；
3. 设 c= Enckenc(r1‖···‖rn)且文件标签 t= n‖c‖SSigssk(n‖c)；
4. 以处理后的文件 M′={m′ i j} , 1 ≤ i ≤ n, 1 ≤ j ≤ s、相应的文件标签 t以及{σi} , 1 ≤ i ≤ n作为输出。

验证(svk, V K, t) . 给定文件标签 t，解析 t= n‖c‖SSigssk(n‖c) 并使用svk验证 t上的签名；如果签名无效，则拒绝并终止。否则，从[1, n]中随机选取一个包含 l个元素的子集 I，并对每个 i ∈ I随机选取一个元素 vi ∈ Zp。将集合 Q={(i, vi)}发送给证明者。解析证明者的响应以获取 μ1,···, μs, σ ∈ Zs+1 p 。若解析失败，则拒绝并终止。否则，输出VK(Q={(i, vi)}i∈I, μ1,···, μs, σ, t)。

CheckU: Inputs: Q={(i, vi)}i∈I, μ1,···, μs, σ, t
Constants: PRF keys k1, k2, symmetric encryption key kenc
n‖c‖SSigssk(n‖c) ← t
r1,···, rn ← Deckenc(c)
if σ=∑(i,vi)∈Q vi · F1(k1, ri)+∑ s j=1 F2(k2, j)· μj then output 1
else output ⊥

证明(t, M′) 。给定处理后的文件 M′,{σi}, 1 ≤ i ≤ n以及由验证者发送的包含 l个元素的集合 Q，解析 M′={m′ ij}, 1 ≤ i ≤ n, 1 ≤ j ≤ s和Q={(i, vi)}。然后计算
μj= ∑(i,vi)∈Q vim′ ij for 1 ≤ j ≤ s, and σ= ∑(i,vi) viσi,并向证明发送响应值 μ1,···, μs 和 σ。

Modified B+ Merkle树

在我们的构造中，我们使用改进的B+树来组织数据文件，然后应用标准Merkle哈希树以提供新鲜性和真实性的保证。在这种改进的B+树中，每个节点最多包含三个条目。叶节点中的每个条目均为数据文件的 σ，并链接到底层附加层级中对应的文件块。内部节点不再包含索引信息。

在介绍该树的构造之前，我们首先定义一些符号：用 label(·)表示条目对应计算得到的 σ，用 rank(·)表示条目的秩（即从此条目可达的文件块数量），用 child(·)表示条目的后代，用 len(·)/ren(·)表示条目的左/右兄弟。
– 叶节点中的条目 w： label(w) = σ, len(w)（如果 w 是最左侧的条目，则 len(w) =0）以及 ren(w)（如果 w 是最右侧的条目，则 ren(w) = 0）；
– 内部节点和根节点中的条目 v： rank(v)， child(v) len(v)以及 ren(v)，其中 len(v)和 ren(v)符合上述规则。

一个示例如图1a所示。根据上述定义，根节点 R中的条目 v1包含：(1) rank(v1) = 3，因为 w1、 w2和 w3可以从 v1到达；(2) child(v1) = w1‖w2‖w3；(3) len(v1) = 0；(4) ren(v1) = v2。叶节点 W1中的条目 w2包含：(1) label(w2) = σ2； (2) len(w2) = w1；(3) ren(w2) = w3。注意，连接叶节点中条目与 F的箭头表示每个条目与其对应的文件块相关联。具体而言，例如，条目 w1与第一个数据块 F 1以及 label(w1)= σ 1相关联。

为了搜索 σ及其对应的文件块，我们需要每个条目的两个额外值： low(·) 和 high(·)。 low(·) 给出了从一个条目可达的最低位置的数据块，而 high(·) 定义了从一个条目可达的最高位置的数据块。注意，这两个值无需存储在树中的每个条目中。我们可以利用秩动态计算它们。对于当前条目 r，假设我们已知 low(r) 和 high(r)。令child(r) 为= v1‖v2‖v3。那么 low(vi) 和 high(vi) 可以通过条目的rank值按以下方式计算：(1) low(v1) = low(r)，且 high(v1) = low(v1) +rank(v1)−1；(2) low(v2) = high(v1) +1，且 high(v2) = low(v2) + rank(v2) −1；(3) low(v3) = high(v2)+ 1，且 high(v3) = high(r)。

利用条目 rank的值，我们可以到达叶节点中的 i‐th数据块（即 i‐th条目）。搜索从根节点中的条目 v1开始。显然，对于树的起始条目，我们有 low(v1)= 1。在搜索过程中的每个条目 v上，如果 i ∈[low(v) high(v)],，则沿着从 v指向其子节点的指针继续搜索；否则，检查 v右侧的下一个条目。我们持续这一过程，直到到达 i‐ th数据块。例如，假设我们要读取图1a中的第6‐th个数据块。我们从条目 v1开始，搜索过程如下：
1. 计算 high(v1) = low(v1) + rank(v1) −1= 3；
2. i= 6∈/[low(v1) high(v1) ],然后检查下一个条目 v2；
3. 计算 low(v2) = high(v1) + 1= 4, high(v2) = low(v2) + rank(v2) −1= 6；
4. i ∈[low(v2) high(v2)],然后跟随指向 v2 子节点的指针；
5. 获取 child(v2) = w4‖w5‖w6；
6. 现在在叶节点中，从左到右检查每个条目，并找到 w6为连接到所需数据块的条目。

现在只需在修改后的B+树上定义Merkle哈希树。注意，在我们修改后的 B+树中，每个节点最多包含3个条目。用大写字母表示节点，小写字母表示条目。对于每个条目，其哈希值计算如下：
– Case 0： w是叶节点中的一个条目，计算 f(w) = h(label(w)) = h(σ)；
– Case 1： v是内部节点中的一个条目，且其子节点为节点 V ′，计算 f(v) = h(rank(v)‖f(V ′))。

对于从左到右包含条目 v1, v2, v3的每个节点（内部节点或叶节点），我们定义 f(V) = h(f(v1)‖f(v2)‖f(v3))。例如，在图1.a中，根节点的哈希值为 f(R) = h(f(v1)‖f(v2)‖f(v3))，其中 f(vi) =h(rank(vi)‖f(Wi)) 且 f(Wi) = h(f(w(i−1)∗3+1)‖f(w(i−1)∗3+2)‖f(w(i−1)∗3+3))。

通过在修改后的B+树上构建的Merkle哈希树，客户端会跟踪根摘要。每次获取数据块后，客户端也会获取其对应的 σ。同时，客户端还会收到从根到该数据块路径上同一节点中其他条目相关的哈希值。然后，客户端可以通过 Merkle树验证数据块的真实性和新鲜性。假设客户端需要验证 F3在图1a中的真实性和新鲜性，其中他/她持有根摘要 f(R)。从根到 F3的路径为(R → W1)。为了验证，除了 σ3外，客户端还会收到来自节点 f(w1) f(w2)和节点 W1中的 f(v2) f(v3)。

更新

主要操作包括更新数据块和更新Merkle树。注意，更新仅影响 Merkle树中从目标数据块到根路径上的节点。因此，更新Merkle树的运行时间为 O(logn)。此外，为了更新Merkle树，需要从服务器获取从数据块到根路径上的一些哈希值。显然，这些值的大小为 O(logn)。更新操作包括修改、删除和插入。我们改进后的B+树上的更新操作基本遵循标准B+树的流程。唯一的细微差别在于节点分裂时的插入操作，原因在于我们改进后的B+树不包含索引信息。

首先，我们讨论修改和删除。要修改一个数据块，客户端只需计算该数据块新的对应 σ，并用此 σ更新Merkle树以获得新的根摘要。然后客户端上传新的数据块和新的 σ。服务器收到这个新的 σ后，只需沿着从该数据块到根的路径更新Merkle树即可。要删除一个数据块，服务器只需根据客户端的指示删除不需要的数据块，然后沿着从该数据块到根的路径更新Merkle树。

接下来，我们给出插入操作的详细过程。如果要插入新数据块的叶节点未满，则该过程与修改操作相同。否则，需要对该叶节点进行分裂，然后指向该叶节点的条目也将被分裂为两个条目，每个条目分别指向一个叶节点。需要注意的是，与标准B+树上的操作不同，我们不会复制索引指向其父节点的第三个条目（即新生成节点的索引）。相反，我们只需创建一个新条目，该条目包含指向该节点的指针，并记录如上所述的相应信息。如果根节点需要被分割，则该Merkle树的深度将增加1。更新操作的示例如图1b和图1c所示。假设客户端想要在第7‐th位置插入一个新的文件块 F10。首先，它按照上述方法定位到该位置。注意，我们可以定位到第6‐th位置或第7‐th位置。这里我们选择定位到第6‐th位置，并在左节点 W2中的 w6之后插入一个新条目 w10。（如果选择定位到第7‐th位置，则应将新条目放在 w7之前。）接下来，这个新文件块 F10对应的信息将被写入条目 w10中，并设置一个从 w10指向 F10的指针，如图1b所示。由于超过了节点所能容纳的最大条目数，该叶节点 W2需要被拆分为两个叶节点 W′ 2和 W4，每个节点包含两个非空条目（这符合B+树的更新规则），如图1c所示。同时，在根节点 R中创建一个新条目 v4，该条目包含一个指向叶节点 W4的指针 v4。类似地，该根节点 R被拆分为两个内部节点 V1 和 V1。最后，构建一个新的根节点 R′，它有两个条目和两个分别指向 V1和 V2的指针。请注意，此时根节点具有条目 r1和 r2，其中 r1是该树的起始条目，表示low(r1) = 1。我们还有 rank(r1) = rank(V1) = rank(v1)+ rank(v2) = 5和 rank(r2) = 5。