建议看我在github博客上的pdf版本，公式显示正确。

以下内容中公式显示有问题。

论文摘要

目前已知最佳的高维格基规约算法是Schnorr-Euchner的BKZ算法：所有格密码系统的安全性估计都是基于之前NTL中BKZ算法的实现。然而，格枚举算法研究的最新进展表明，当前NTL中的BKZ实现已不再是最好的实现。不过人们还不清楚此进展对格密码的安全性估计的确切影响。我们通过BKZ 2.0的大量实验对影响进行了评估。BKZ 2.0是第一个使用了最新成果的BKZ实现。实现中使用了近期提出的算法改进，例如Gama-Nguyen-Regev剪枝。我们提出了一种高效的模拟算法来模拟BKZ在高维度格且分块大小(blocksize)大于50的情况下的行为。这个模拟算法可以近似地预测输出质量和运行时间，从而修正格的安全性估计。例如，我们的模拟表明最小的NTRU签名参数集（据称可以提供相当于93位密钥的安全性来抵御基于格的密钥恢复攻击）实际上最多只能提供65位密钥的安全性。

1 引言

格是Rm\mathbb{R}^{m}Rm的离散子群。格LLL由一组格基表示，即Rm\mathbb{R}^{m}Rm中一组线性无关向量b1,…,bn\mathbf{b}_{1},\ldots,\mathbf{b}_{n}b1,…,bn。LLL为bi\mathbf{b}_{\mathbf{i}}bi所有整数线性组合构成的集合L(b1,…,bn)={∑i=1nxibi,xi∈Z}L\left( \mathbf{b}_{1},\ldots,\mathbf{b}_{n} \right) = \left\{ \sum_{i = 1}^{n}{x_{i}\mathbf{b}_{i}},x_{i} \in \mathbb{Z} \right\}L(b1,…,bn)={∑i=1nxibi,xi∈Z}。我们称整数nnn是LLL的维数。格基约化的目的是找到格LLL一个由较短且近似正交的向量组成的基。格基规约算法有许多应用（见^[35]），特别是在公钥密码分析中，它们被用于破解RSA和DSA等密码体制的特例（见^[32]和其中的参考文献）。大体上，格基规约算法有两种类型：

- 近似算法，如著名的LLL算法^[22,35]及其衍生出的分块格基规约算法^[41,42,7,8]。这样的算法可以找到相对较短的向量，但在高维的格中通常找不到最短的向量。

- 精确算法，输出最短（或几乎最短）的向量。有空间复杂度能够接受的枚举算法^{[38,20,6,42,43,10]}和空间复杂度为指数级别的算法^[3,36,30,29]。它们的时间复杂度都是2O(n)2^{O\left( n \right)}2O(n)，不过后者在实践中优于前者。

在高维格上我们只能调用近似算法，不过这两种算法是互补的：近似算法会调用精确算法，将其作为它的子算法；而精确算法也会调用近似算法作为预处理。理论上，最佳近似算法是Gama-Nguyen约化^[8]。但实验（如^[9]的实验，或GGH 挑战^[12]的密码分析^[31,21]）表明，实践中已知的高维最佳近似算法是BKZ算法。这个算法由Schnorr和Euchner于1994年发表^[42]，并在NTL^[44]中实现。与所有分块格基规约算法^[41,7,8]一样，BKZ与LLL算法相比有一个额外的输入参数------分块大小β\betaβ，它会影响BKZ算法的运行时间和输出质量：BKZ频繁调用格枚举子算法^[38,20,6,42]，这个子算法会在维数小于等于β\betaβ的投影格中查找几乎最短的向量。随着β\betaβ的增加，输出基约化程度越来越高，但代价却显著增加：枚举子算法的开销在β\betaβ中通常是超指数级别的，即进行2O(β2)2^{O\left( \beta^{2} \right)}2O(β2)次多项式时间的运算（见^[10]）；实验^[9]表明，调用次数随着β\betaβ和格的维数nnn的增加而急剧增加：例如固定β\betaβ大于等于30，如果nnn不是指数的话，调用次数似乎是超多项式级别的。于是BKZ有两个常规用法：

输入格的维度nnn为任意值时选取β≈20\beta \approx 20β≈20，或中等维度nnn时将β\betaβ选取为30-40左右（最多100左右）。这种情况下，BKZ会在可接受的时间内运行完，并且结果通常优于LLL约化。
对于高维数nnn中令分块大小β≥40\beta \geq 40β≥40，寻找越来越短的格向量。这种情况下，BKZ算法不会在合适的时间内完成。在实际应用中，如果输入基比较好的话，算法通常会在几个小时或几天后跑完并给出结果。我们注意到，Hanrot等人^[14]最近对使用了中止技术的BKZ算法（下称中止BKZ）的输出格基质量最坏情况界限给出了证明，它只比不使用中止技术的BKZ稍差一点。一般通过剪枝技术来优化枚举子算法的运行时间^[42,43,10]：例如，NTL中BKZ的实现提出了Schnorr-Horner剪枝^[43] （SH剪枝），它增加了另一个输入参数ppp，其影响在^[10]中才阐明。有人使用分块大小$\ \beta = 40\ 和SH因子和SH因子和SH因子\ p = 14\ $的中止BKZ求解出了最高维数的GGH密码破解挑战^[12]。

如何评估BKZ的输出质量是一个重要问题，因为格算法的实际性能表现往往比理论上的预期更好。格基规约算法输出基的质量由Hermite因子来衡量，这是Gama和Nguyen的建议^[9]。实际上，所有已知的格算法的Hermite因子对于维数nnn通常是指数的，即cnc^{n}cn，其中ccc取决于算法的参数。文献^[9]的实验表明，在实际应用中，BKZ的Hermite因子通常是c(β,n)nc\left( \beta,n \right)^{n}c(β,n)n，其中c(β,n)c\left( \beta,n \right)c(β,n)在β\betaβ一定的情况下随nnn趋于无穷迅速收敛。然而，只有在β\betaβ较小的时候(β≤30)(\beta \leq 30)(β≤30)，c(β,n)c\left( \beta,n \right)c(β,n)的极限值才已知，并且c(β,n)c\left( \beta,n \right)c(β,n)的理论上界^[9,14]显著高于实验值。

格密码体制的所有安全性估计和参数建议（如近期文献[28,39,23]和NTRU文献[18]）都是以之前NTL中的BKZ实现为基准的，但这些估计是否值得参考还待商榷。首先，这些基准都是按照上面的用法1计算的：文献[18]指出对于NTRU挑战，“从未观察到剪枝过程对运行时间有明显的改进，因此推测剪枝过程基本没有被调用”，并使用β≤25\beta \leq 25β≤25，而^[39,23]使用β≤30\beta \leq 30β≤30。这意味着此类安全性估计要么假设BKZ不能在β≥30\beta \geq 30β≥30的情况下运行，要么从β≤30\beta \leq 30β≤30时的情况来推测β\betaβ较大时的c(β,n)c\left( \beta,n \right)c(β,n)。此外最近在格枚举方面的进展^[10]表明，现在可以在比以前想象的更高的维度（例如β≈110\beta \approx 110β≈110）上进行枚举，但是对于β≥50\beta \geq 50β≥50的情况，没有已知的c(β,n)c\left( \beta,n \right)c(β,n)近似值。而NTL的实现并没有参考这些最近的改进，因此这个实现并不是目前最优的实现。

我们的成果：我们首次将β\betaβ较大（β≥40\beta \geq 40β≥40）的BKZ用于高维的格，进行了拓展实验。这是通过实现BKZ 2.0算法（一种改进版BKZ）做到的，该算法应用了最新的算法改进。主要的改进是将Gama、Nguyen和Regev^[10]在EUROCRYPT’10上发明的深度剪枝(sound pruning)技术结合起来。这些修改显著地降低了枚举子算法的运行时间，且在选取适当参数的情况下几乎不会降低输出质量，从而让我们得以使用很大的β\betaβ。BKZ 2.0的性能优于NTL对BKZ的实现（即使是与使用了SH剪枝^[43]的那种BKZ相比），这一点我们通过打破诸如Darmstadt的格挑战^[24]或SVP挑战^[40]等问题的求解记录得以确认：例如，我们在以前的214维NTRU格^[18]中用242.62个时钟周期计算出了最短向量，进行的运算次数至少比之前少70倍^[25]。

更重要的是，通过实验我们提出一种有效的模拟算法来模拟BKZ在（任意）大的分块大小≥50\geq 50≥50的情况下的执行，来猜测此时算法输出向量的近似长度和所需时间。值得提出的是，该算法首次对任意大的β\betaβ提供了c(β,n)c\left( \beta,n \right)c(β,n)的预测(β>50)\left( \beta > 50 \right)(β>50)。对于给定的目标长度，模拟算法可以估算获得这种短向量所需的β\betaβ，以及所需的枚举调用数量。一旦我们知道枚举算法开销的一个精确近似值，就能得到算法的一个近似运行时间。我们为目前最好的枚举子算法计算了这样的近似值。

我们的模拟改进了Gama-Nguyen关于格上困难问题的安全性估计^[9]，原估计没有考虑剪枝，比如NTRU^[19,16]和^[23,39]的安全性估计。我们通过修正安全性估计来说明我们模拟的价值。我们的模拟表明，最小的NTRU签名参数集（据称至少能提供93位的安全性来抵御密钥恢复格攻击）实际上最多能提供65位的安全性。我们利用模拟对Gentry和Halevi最近提出的全同态加密挑战^[11]进行了第一次具体的安全评估。似乎所有这些挑战都没有提供非常高的安全级别，除了最大的一个，它似乎最多提供100位的安全级别。

论文组织结构(roadmap)：我们以第2节为起点，介绍格相关的数学背景和符号。在第3节中我们回顾了BKZ算法。在第4节中我们通过描述如何修改原先BKZ算法，以实现BKZ 2.0。在第5节中我们简要记录了获得的格算法的新记录。我们在第6节中提出了一种仿真算法来预测BKZ 2.0在（任意）分块大小较大情况下的性能，并用其在第7节中修正现有的安全性估计。更多信息可以在完整版本中找到。

2 前置背景知识

符号说明：我们用矩阵的行向量表示格基（与算法实现保持一致），并使用粗体字体表示向量：如果$B = \left( \mathbf{b}{1},\ldots\mathbf{b}{n} \right)\ 是矩阵，则其行向量是是矩阵，则其行向量是是矩阵，则其行向量是\mathbf{b}{i}。向量。向量。向量\mathbf{v} \in \mathbb{R}^{m}的欧氏范数记作的欧氏范数记作的欧氏范数记作\left| \mathbf{v} \right|。我们用。我们用。我们用\text{Ball}{n}\left( R \right)表示半径为表示半径为表示半径为R的的的n维欧氏球，用维欧氏球，用维欧氏球，用V_{n}\left( R \right) = R^{n} \cdot \frac{\pi^{n\text{/}2}}{\Gamma\left( n\text{/}2 + 1 \right)}表示其体积。表示其体积。表示其体积。n维单位球由维单位球由维单位球由\ S^{n - 1}\ 表示。设表示。设表示。设L是是是\mathbb{R}^{m}中的中的中的n维格。它的体积维格。它的体积维格。它的体积\text{vol}\left( L \right)指由指由指由L的任何基生成基本域的的任何基生成基本域的的任何基生成基本域的n$维体积。

正交化：n×mn \times mn×m的基B=(b1,…bn)B = \left( \mathbf{b}_{1},\ldots\mathbf{b}_{n} \right)B=(b1,…bn)可以唯一地写成B=μ⋅D⋅QB = \mu \cdot D \cdot QB=μ⋅D⋅Q，其中μ=(μi,j)\mu = \left( \mu_{i,j} \right)μ=(μi,j)是对角线为1，n×nn \times nn×n的下三角矩阵，DDD是n×nn \times nn×n正定对角矩阵，QQQ是行向量相互正交的n×mn \times mn×m矩阵。那么μD\text{μD}μD是BBB（相对于QQQ）的下三角表示，$B^{} = DQ = \left( \mathbf{b}_{1}^{{*},\cdots,\mathbf{b}_{n}}{} \right)\ 是对基进行施密特正交化后的结果。是对基进行施密特正交化后的结果。是对基进行施密特正交化后的结果。D是由是由是由\ \mathbf{b}{i}^{*}\ 形成的对角矩阵。我们用形成的对角矩阵。我们用形成的对角矩阵。我们用\pi{i}\left( 1 \leq i \leq n + 1 \right)表示表示表示\left( \mathbf{b}{1},\ldots\mathbf{b}{n} \right)^{\bot}$上的正交投影。对于1≤j≤k≤n1 \leq j \leq k \leq n1≤j≤k≤n，我们用B[j,k]B_{\left\lbrack j,k \right\rbrack}B[j,k]表示局部投影块$\left( \pi_{j}\left( \mathbf{b}{j} \right),\pi{j}\left( \mathbf{b}{j + 1} \right),\cdots,\pi{j}\left( \mathbf{b}{k} \right) \right)\ ，用，用，用L{\left\lbrack j,k \right\rbrack}表示由表示由表示由B_{\left\lbrack j,k \right\rbrack}生成的格，其维数为生成的格，其维数为生成的格，其维数为k - j + 1$。

随机格：基于典型群的Haar测度（见^[1]），给定格的体积有随机（实）格这一概念。最近的实验中使用了随机整格这一概念：对于任意整数VVV，一个体积为VVV的随机nnn维整格是指在体积VVV的有限多个nnn维整格中均匀随机选择的一个格。文献^[13]表明，当VVV趋于无穷时，整格按V1/nV^{1\text{/}n}V1/n缩小时，体积VVV的整格上的均匀分布收敛到单位体积的随机（实）格上的分布。在随机格的实验中，我们说的nnn维整格是指在体积为VVV中的格等可能选取时，选出的某一个格，这里的VVV是一个比特长度为10n10n10n的素数：对于体积为素数的情况，使用Hermite标准型在均匀分布中采样是很简单的。理论上比特长度为O(n2)O\left( n^{2} \right)O(n2)更好（根据^[13]的结果），但这样会显著增加算法运行时间，且对实验结果的影响并不明显。

Gaussian Heuristic：给定一个格LLL和一个"好"的集合SSS，Gaussian Heuristic预测S∩LS \cap LS∩L中的点数约为vol(S)/vol(L)\text{vol}\left( S \right)\text{/}\text{vol}\left( L \right)vol(S)/vol(L)。在某些情况下，可以确定这个启发函数是切合实际的^[1]或偏差较大的^[27]。

最短向量：LLL的非零最短向量的范数为λ1(L)=min⁡v∈L,v≠0∥v∥\lambda_{1}\left( L \right) = \min_{\mathbf{v} \in L,\mathbf{v} \neq 0}\left\| \mathbf{v} \right\|λ1(L)=minv∈L,v=0∥v∥。如果Gaussian Heuristic对任意球SSS成立，我们有λ1(L)≈GH(L)\lambda_{1}\left( L \right) \approx \text{GH}\left( L \right)λ1(L)≈GH(L)，其中GH(L)=vol(L)1/n⋅Vn(1)−1/n\text{GH}\left( L \right) = {\text{vol}\left( L \right)}^{1\text{/}n} \cdot V_{n}\left( 1 \right)^{- 1\text{/}n}GH(L)=vol(L)1/n⋅Vn(1)−1/n。Minkowski定理表明，对于任意格LLL，λ1(L)≤2GH(L)\lambda_{1}\left( L \right)\ \leq 2\text{GH}\left( L \right)λ1(L) ≤2GH(L)。对于随机实格，λ1(L)\lambda_{1}\left( L \right)λ1(L)以极大的概率近似于GH(L)\text{GH}\left( L \right)GH(L)（见^[1]）。

约化基：我们回顾了一些经典的约化概念。一组格基B=(b1,…bn)B = \left( \mathbf{b}_{1},\ldots\mathbf{b}_{n} \right)B=(b1,…bn)是：

长度约化的(size reduced)，如果其Gram-Schmidt矩阵μ\muμ满足∣μi,j∣≤1/2(1≤j<i≤n)\left| \mu_{i,j} \right| \leq 1\text{/}2\left( 1 \leq j < i \leq n \right)∣μi,j∣≤1/2(1≤j<i≤n)。
LLL-约化的(LLL-reduced)，如果该格基满足以下条件：给定因子0<ϵ<10 < \epsilon < 10<ϵ<1 ^[22]，基BBB是长度约化的且其Gram-Schmidt正交化满足∥bi+1∗+μi+1,ibi∗∥2≥(1−ϵ)∥bi∗∥2，1≤i<n\left\| \left. \ \mathbf{b}_{i + 1}^{*} + \mu_{i + 1,i}\mathbf{b}_{i}^{*} \right.\ \right\|^{2} \geq \left( 1 - \epsilon \right)\left\| \left. \ \mathbf{b}_{i}^{*} \right.\ \right\|^{2}，1 \leq i < n∥∥ bi+1∗+μi+1,ibi∗ ∥∥2≥(1−ϵ)∥ bi∗ ∥2，1≤i<n。如果忽略因子ϵ\epsilonϵ，则表示因子ϵ=0.01\epsilon = 0.01ϵ=0.01，实践中经常将ϵ\epsilonϵ选择为这个值。
BKZ-约化的(BKZ-reduced)^[41]，如果满足以下条件：给定分块大小β≥2\beta \geq 2β≥2和因子0<ϵ<10 < \epsilon < 10<ϵ<1，该格基对于ϵ\epsilonϵ是LLL-约化的，并且对于1≤j≤n1 \leq j \leq n1≤j≤n有∥bj∗∥=λ1(L[j,k])\left\| \mathbf{b}_{j}^{*} \right\| = \lambda_{1}\left( L_{\left\lbrack j,k \right\rbrack} \right)∥∥bj∗∥∥=λ1(L[j,k])，其中k=min(j+β−1,n)k = \text{min}\left( j + \beta - 1,n \right)k=min(j+β−1,n)。

人们通常感兴趣的是将Hermite因子∥b1∥/vol(L)1/n\left\| \mathbf{b}_{1} \right\|\text{/}{\text{vol}\left( L \right)}^{1\text{/}n}∥b1∥/vol(L)1/n降低（见^[9]）（这个因子完全由数列∥b1∗∥,…,∥bn∗∥\left\| \mathbf{b}_{1}^{*} \right\|,\ldots,\left\| \mathbf{b}_{n}^{*} \right\|∥b1∗∥,…,∥bn∗∥决定）。这是因为Hermite因子决定了在解决重要格难题时算法的表现：关于近似SVP和SVP，参见^[9]，关于SIS和LWE，参见^[28,39,23]。结果表明，在输入基是足够随机的条件下，一般归约算法（如LLL或BKZ）产生的基的Gram-Schmidt系数具有某种"典型形状"^[9,34]。简单来说，形状大致满足∥bi∗∥/∥bi+1∗∥≈q\left\| \mathbf{b}_{i}^{*} \right\|\text{/}\left\| \mathbf{b}_{i + 1}^{*} \right\| \approx q∥bi∗∥/∥∥bi+1∗∥∥≈q，其中qqq取决于归约算法，除了第一个索引iii。这意味着Hermite因子的形式通常是cnc^{n}cn，其中c≈qc \approx \sqrt{q}c≈q。

3 BKZ算法

3.1算法描述

BKZ算法^[42]由格LLL的输入基B=(b1,…bn)B = \left( \mathbf{b}_{1},\ldots\mathbf{b}_{n} \right)B=(b1,…bn)计算出分块大小β≥2\beta \geq 2β≥2且约化因子ϵ>0\epsilon > 0ϵ>0的BKZ约化基。该算法首先对BBB进行LLL约化，然后对每个局部基B[j,min⁡(j+β−1,n)](1≤j≤n)B_{\left\lbrack j,\min\left( j + \beta - 1,n \right) \right\rbrack}\left( 1 \leq j \leq n \right)B[j,min(j+β−1,n)](1≤j≤n)进行约化以确保这局部基中第一个向量在投影格中是最短的。这就是算法1的流程。算法中每个局部块在被枚举之前先进行LLL约化，然后再这样做：将一个索引j\,j\,j初始化为1。在每次迭代中，BKZ对局部投影格L[j,k]L_{\left\lbrack j,k \right\rbrack}L[j,k]进行枚举以找到v=(v1,…,vn)∈Znv = \left( v_{1},\ldots,v_{n} \right) \in \mathbb{Z}^{n}v=(v1,…,vn)∈Zn，满足∥πj(∑i=jkvibi)∥=λ1(L[j,k])\left. \ \left\| \pi_{j}\left( \sum_{i = j}^{k}{v_{i}\mathbf{b}_{i}} \right) \right\|\ \right.\ = \lambda_{1}\left( L_{\left\lbrack j,k \right\rbrack} \right) ∥∥∥πj(∑i=jkvibi)∥∥∥ =λ1(L[j,k])，其中k=min(j+β−1,n)k = \text{min}\left( j + \beta - 1,n \right)k=min(j+β−1,n)。我们令h=min(k+1,n)h = \text{min}\left( k + 1,n \right)h=min(k+1,n)为下一次迭代中新块的尾索引：

如果 ∥bj∗∥>λ1(L[j,k])\left. \ \left\| \mathbf{b}_{j}^{*} \right\|\ \right.\ > \lambda_{1}\left( L_{\left\lbrack j,k \right\rbrack} \right) ∥∥bj∗∥∥ >λ1(L[j,k])，则将bnew=∑i=jkvibi\mathbf{b}^{\text{new}} = \sum_{i = j}^{k}{v_{i}\mathbf{b}_{i}}bnew=∑i=jkvibi插入bj−1\mathbf{b}_{j - 1}bj−1和bj\mathbf{b}_{j}bj之间。这时基已不再是LLL-约化基，因此要对(b1,…,bj−1,bnew,bj,…,bh)\left( \mathbf{b}_{1},\ldots,\mathbf{b}_{j - 1},\mathbf{b}^{\text{n}\text{e}\text{w}},\mathbf{b}_{j},\ldots,\mathbf{b}_{h} \right)(b1,…,bj−1,bnew,bj,…,bh)调用LLL，以产生新的LLL-约化基(b1,…,bh)\left( \mathbf{b}_{1},\ldots,\mathbf{b}_{h} \right)(b1,…,bh)。
否则，对截断的基(b1,…,bh)\left( \mathbf{b}_{1},\ldots,\mathbf{b}_{h} \right)(b1,…,bh)调用LLL。

因此，在每次迭代结束时，基B=(b1,…,bh)B = \left( \mathbf{b}_{1},\ldots,\mathbf{b}_{h} \right)B=(b1,…,bh)必然是LLL-约化基。当$\ j\ 达到达到达到\ n\ 时，除非枚举不成功，否则它会被重置为1。在枚举失败的情况下，算法终止。算法1中，时，除非枚举不成功，否则它会被重置为1。在枚举失败的情况下，算法终止。算法1中，时，除非枚举不成功，否则它会被重置为1。在枚举失败的情况下，算法终止。算法1中，\text{z\ }$就是用来记录失败的的枚举数以检查算法是否需要终止的。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I57oLf9L-1635426868265)(media/image1.png)]{width=“5.583085083114611in” height=“3.465062335958005in”}

算法 1 BKZ算法

3.2 枚举子算法

BKZ需要一个寻找局部投影格L[j,k]L_{\left\lbrack j,k \right\rbrack}L[j,k]中最短向量的子算法：给定两个整数j \text{\ j\ } j 和k \text{\ k\ } k 作为输入，其中j≤k≤nj \leq k \leq nj≤k≤n*，*输出满足∥πj(∑i=jkvibi)∥=λ1(L[j,k])的v=(vj,…,vk)∈Zk−j+1\ \left\| \pi_{j}\left( \sum_{i = j}^{k}{v_{i}\mathbf{b}_{i}} \right) \right\| = \lambda_{1}\left( L_{\left\lbrack j,k \right\rbrack} \right)\ 的\ v = \left( v_{j},\ldots,v_{k} \right) \in \mathbb{Z}^{k - j + 1} ∥∥∥πj(∑i=jkvibi)∥∥∥=λ1(L[j,k]) 的 v=(vj,…,vk)∈Zk−j+1。在实践中以及在BKZ原版论文^[42]中，这子算法是通过枚举实现的。算法将R=∥bj∗∥R = \left\| \mathbf{b}_{j}^{*} \right\|R=∥∥bj∗∥∥赋值为λ1(L[j,k])\lambda_{1}\left( L_{\left\lbrack j,k \right\rbrack} \right)λ1(L[j,k])的初始上界。枚举遍历由局部投影格L[k,k],L[k−1,k],…,L[j,k]L_{\left\lbrack k,k \right\rbrack},L_{\left\lbrack k - 1,k \right\rbrack},\ldots,L_{\left\lbrack j,k \right\rbrack}L[k,k],L[k−1,k],…,L[j,k]的"一半"向量组成的枚举树的L[j,k]L_{\left\lbrack j,k \right\rbrack}L[j,k]范数。树的深度为k−j+1k - j + 1k−j+1，对于每个d∈{0,…,k−j+1}d \in \text{\{}0,\ \ldots,\ k - j + 1\text{\}}d∈{0, …, k−j+1}，深度为d\,d\,d的节点为0\,0\,0。并且当满足u=∑i=jk′uibi\mathbf{u} = \sum_{i = j}^{k^{'}}{u_{i}\mathbf{b}_{i}}u=∑i=jk′uibi（其中对于j≤k′≤k ，uk′>0j \leq k^{'} \leq \text{k\ }，u_{k^{'}} > 0j≤k′≤k ，uk′>0）且∥πk−d+1(u)∥≤R\,\left\| \pi_{k - d + 1}\left( \mathbf{u} \right) \right\| \leq R\,∥πk−d+1(u)∥≤R时，πk−d+1(u)一定在格L[k−d+1,k]中，即πk−d+1(u)∈L[k−d+1,k]\pi_{k - d + 1}\left( \mathbf{u} \right)一定在格L_{\left\lbrack k - d + 1,k \right\rbrack}中，即\pi_{k - d + 1}\left( \mathbf{u} \right) \in L_{\left\lbrack k - d + 1,k \right\rbrack}πk−d+1(u)一定在格L[k−d+1,k]中，即πk−d+1(u)∈L[k−d+1,k]。深度为d\,d\,d的节点u∈L[k−d+1,k]\,\mathbf{u} \in L_{\left\lbrack k - d + 1,k \right\rbrack}\,u∈L[k−d+1,k]的父结点是深度为d−1\,d - 1\,d−1的πk−d+2(u)\,\pi_{k - d + 2}\left( \mathbf{u} \right)πk−d+2(u)。每个节点的子节点是按欧式范数递增排列的。Schnorr-Euchner算法^[42]对树进行深度优先搜索(DFS)，以输出最小范数的非零叶子节点，并进行以下修改:每次发现一个新的(非零的)叶，就将枚举半径R \text{R\ }R 赋值为叶的范数。基约化的程度越高，树中的节点就越少，枚举的时间成本就越低。枚举算法的运行时间为NNN个多项式时间操作，其中NNN为树节点总数。Hanrot和Stehlé^[15]注意到，假设算法不更新RRR，深度ddd的节点数量可以根据Gaussian Heuristic估计为:

Hd(R)=12⋅Vd(R)∏i=k−d+1k|bi∗|=12⋅RdVd(1)∏i=k−d+1k|bi∗|(1)H_{d}\left( R \right) = \frac{1}{2} \cdot \frac{V_{d}\left( R \right)}{\prod_{i = k - d + 1}^{k}{\left. \ \text{|}b_{i}^{*} \right.\ \text{|}}} = \frac{1}{2} \cdot \frac{R^{d}V_{d}\left( 1 \right)}{\prod_{i = k - d + 1}^{k}{\left. \ \text{|}b_{i}^{*} \right.\ \text{|}}}\text{\ \ \ \ }\left( 1 \right)Hd(R)=21⋅∏i=k−d+1k |bi∗ |Vd(R)=21⋅∏i=k−d+1k |bi∗ |RdVd(1) (1)

Gama等人的研究^[10]表明，至少对于足够大的k−j+1k - j\ + \ 1k−j + 1和典型的约化基来说，这个估计与实验所测非常吻合。因此，在实际的（会更新R 的）\text{R\ }的）R 的）Schnorr-Euchner算法中，我们可以通过对$\ \text{R\ }赋值为R = \lambda_{1}\left( L_{\left\lbrack j,k \right\rbrack} \right)\ 并设等式(1)中并设等式(1)中并设等式(1)中R = \left| \mathbf{b}{j}^{*} \right|\ 来给出深度为给出深度为给出深度为dKaTeX parse error: Undefined control sequence: \[ at position 14: 的节点个数的大致范围。由^\̲[̲10\]^可以看出，对于典型的…H{d}\left( R \right)在中深度在中深度在中深度\ d \approx \left( k - j \right)\text{/}2\ 附近最大，附近最大，附近最大，\text{d\ }不在此范围时不在此范围时不在此范围时H_{d}\left( R \right)$明显较小。

3.3 结果分析

BKZ的时间复杂度目前还没有比较精确的上界。（对枚举子算法的）调用数量已知的最佳上界是指数级的（参见^[14]）。在实践中（参见^[9]），BKZ在β=20\beta = 20β=20时是非常实用的，但是当$\ \beta \geq 25\ 时，运行时间显著增加，使得选取时，运行时间显著增加，使得选取时，运行时间显著增加，使得选取\beta \geq 40KaTeX parse error: Undefined control sequence: \[ at position 42: …理论的最佳最差情况边界：根据^\̲[̲9\]^,高维格的Hermit…c\left( \beta,n \right)^{n}$。 c(β,n)c\left( \beta,n \right)c(β,n)似乎在nnn趋于正无穷时收敛速度很快，而理论上界是c′(β)nc^{'}\left( \beta \right)^{n}c′(β)n，且c′(β)c^{'}\left( \beta \right)c′(β)显著大于c(β,n)c\left( \beta,n \right)c(β,n)。例如,对于大nnn，c(20,n)≈1.0128c\left( 20,n \right) \approx 1.0128c(20,n)≈1.0128。此外，近期^[14]表明,如果在BKZ运行了合适的多项式次数后中止，推出的理论上界仍然只是略小于c′(β)nc^{'}\left( \beta \right)^{n}c′(β)n。

4 BKZ 2.0

众所周知^[9]，分块大小足够大时（≥30\geq 30≥30时）BKZ的总体运行时间基本由枚举子算法决定，这子算法能够找到一个mmm维局部投影格L[j,k]L_{\left\lbrack j,k \right\rbrack}L[j,k]的最短向量，枚举半径R \ \text{R\ } R 初始化为∥bj∗∥\left\| \mathbf{b}_{j}^{*} \right\|∥∥bj∗∥∥，其中$1 \leq j \leq k \leq n\ 且且且\ m\ = \ k\ - \ j\ + \ 1$。

在本节中，我们将描述BKZ 2.0。这是BKZ的升级版，相比之前提到的BKZ有四个改进。我们通过修改NTL^[44]的BKZ^[42]实现了这些改进。第一个改进是简单的早期中止，这在密码分析中是很常见的做法，并且最近的成果^[14] 给这种做法带来了一定的理论依据。早期中止的做法是这样的：我们添加一个参数来指定应该执行多少次迭代，即我们预测每次枚举的调用次数。这就已经给BKZ的复杂度带来了一个指数级优化，因为根据^[9]的实验，调用的次数对于选定的β≥30\beta \geq 30β≥30似乎呈指数级增长。其他三个改进旨在减少枚举子算法的运行时间：深度剪枝^[10]、局部基的预处理和更短的枚举半径。虽然这些改进可能是众所周知的，但我们要强调的是，目前BKZ的实现中并没有用到这些改进（除了Schnorr和Hörner^[43]设计的一种较弱的剪枝算法在NTL^[44]中实现了），而且实现它们绝非易事。

4.1 深度剪枝(Sound Pruning)

剪枝就是通过丢弃枚举树的某些分支从而加速枚举，但剪枝后可能不会返回任何向量，或者可能不会返回最短的向量。剪枝枚举的思想最早可以追溯到Schnorr和Euchner的研究^[42]， Schnorr和Hörner^[43]于1995年首次对其进行了分析。Gama等人^[10]最近重新研究了这个问题，他们注意到对^[43]的分析是有缺陷的，因此剪枝不是最优的。他们证明了一个精心选择的高概率剪枝可以在完全枚举的基础上提高2m/42^{m\text{/}4}2m/4的渐近速度，并引入了一种极限剪枝技术，可以在完全枚举的基础上提高2m/22^{m\text{/}2}2m/2的渐近速度。我们使用随机化处理将这两种剪枝结合起来。形式上，剪枝以∥πk+1−d(u)∥≤Rd⋅R\left. \parallel\pi_{k + 1 - d}\left( \mathbf{u} \right) \right.\parallel \leq R_{d} \cdot R∥πk+1−d(u)∥≤Rd⋅R取代了这k−j+1\,k - j\ + 1\,k−j +1个不等式：∥πk+1−d(u)∥≤R, 1≤d≤k−j+1\left. \parallel\pi_{k + 1 - d}\left( \mathbf{u} \right) \right.\parallel \leq R\text{,}\text{\ }1 \leq d \leq k - j + 1\text{\ \ }∥πk+1−d(u)∥≤R, 1≤d≤k−j+1 其中0≤R1≤⋯≤Rk−j+1=10 \leq R_{1} \leq \cdots \leq R_{k - j + 1} = 10≤R1≤⋯≤Rk−j+1=1是由剪枝策略定义的k−j+1\,k - j + 1\,k−j+1个实数。对于任意边界函数(R1,…,Rk−j+1)\left( R_{1},\ldots,R_{k - j + 1} \right)(R1,…,Rk−j+1)，^[10]考虑N′N^{'}N′和psuccp_{\text{succ}}psucc的定义如下：

-N′=∑d=1k−j+1Hd′\,N^{'} = \sum_{d = 1}^{k - j + 1}H_{d}^{'}\,N′=∑d=1k−j+1Hd′是对剪枝枚举树中节点数的启发式估计，其中Hd′=12RdVR1,…,Rd∏i=k+1−dk∥bi∗∥H_{d}^{'} = \frac{1}{2}\frac{R^{d}V_{R_{1},\ldots,R_{d}}}{\prod_{i = k + 1 - d}^{k}\left. \parallel\mathbf{b}_{i}^{*} \right.\parallel}\text{\ }Hd′=21∏i=k+1−dk∥bi∗∥RdVR1,…,Rd 且VR1,…,RdV_{R_{1},\ldots,R_{d}}VR1,…,Rd 是CR1,…,Rd={(x1,…,xd)∈Rd,∀1≤i≤d,∑l=1ixl2≤Ri2}\,C_{R_{1},\ldots,R_{d}} = \left\{ \left( x_{1},\ldots,x_{d} \right) \in \mathbb{R}^{d},\forall 1 \leq i \leq d,\ \sum_{l = 1}^{i}x_{l}^{2} \leq R_{i}^{2} \right\}CR1,…,Rd={(x1,…,xd)∈Rd,∀1≤i≤d, ∑l=1ixl2≤Ri2} 的体积。

- psucc=psucc(R1,…,Rm)=Pr⁡u∼Sm−1(∀i∈[1,m],∑l=1iul2≤Ri2)p_{\text{succ}} = p_{\text{succ}}\left( R_{1},\ldots,R_{m} \right) = \Pr_{\mathbf{u} \sim S^{m - 1}}\left( \forall i \in \left\lbrack 1,m \right\rbrack,\sum_{l = 1}^{i}u_{l}^{2} \leq R_{i}^{2} \right)psucc=psucc(R1,…,Rm)=Pru∼Sm−1(∀i∈[1,m],∑l=1iul2≤Ri2)。设t∈L[j,k]t \in L_{\left\lbrack j,k \right\rbrack}t∈L[j,k]为满足∥πj(t)∥=R\,\left. \parallel \pi_{j}\left( \mathbf{t} \right) \right. \parallel = R\,∥πj(t)∥=R的目标向量。如果局部基B[j,k]B_{\left\lbrack j,k \right\rbrack}B[j,k]是随机的，那么在（理想化的）假设下（即用对局部基B[j,k]B_{\left\lbrack j,k \right\rbrack}B[j,k]标准正交化后得到的Gram-Schmidt基(bj∗/∥bj∗∥,…,bk∗/∥bk∗∥)\left( \mathbf{b}_{j}^{*}/\left. \parallel\mathbf{b}_{j}^{*} \right.\parallel,\ldots,\mathbf{b}_{k}^{*}/\left. \parallel\mathbf{b}_{k}^{*} \right.\parallel \right)(bj∗/∥bj∗∥,…,bk∗/∥bk∗∥)表示出πj(t)\pi_{j}\left( \mathbf{t} \right)πj(t)的坐标后，∥πj(t)∥\left. \parallel\pi_{j}\left( \mathbf{t} \right) \right.\parallel∥πj(t)∥近似地服从均匀分布时），psuccp_{\text{succ}}psucc即为πj(t)\pi_{j}\left( \mathbf{t} \right)πj(t)是剪枝后的枚举树叶子的概率。

我们强调上面所说的只是一种理想情况。在实践中，当mmm很小时，对于局部块B[j,k]B_{\left\lbrack j,k \right\rbrack}B[j,k]中不可忽略的部分，"B[j,k]B_{\left\lbrack j,k \right\rbrack}B[j,k]的一个向量是L[j,k]L_{\left\lbrack j,k \right\rbrack}L[j,k]的最短向量"这个事件的概率应该为零。考虑到BKZ的应用场景，针对不同的psuccp_{\text{succ}}psucc来设置不同的边界函数(bounding functions)是有意义的，比如psuccp_{\text{succ}}psucc取值为1%到95%，但是与此同时要注意尽可能让代价N′\ N^{'} N′小一些。基于^[10]的方法，我们进行了自动搜索来生成这样的边界函数，块大小β\betaβ为35∼9035\ \sim\ 9035 ∼ 90，步长为5,psucc\ p_{\text{succ}} psucc范围为1%∼95%1\%\ \sim\ 95\%1% ∼ 95%。

需要注意的是，BKZ调用格L[j,k]L_{\left\lbrack j,k \right\rbrack}L[j,k]上的枚举子算法，而格L[j,k]L_{\left\lbrack j,k \right\rbrack}L[j,k]的维数m=k−j+1m = k - j + 1m=k−j+1并不一定等于β\betaβ。当j≤n−β+1\,j \leq n - \beta + 1\,j≤n−β+1时，分块大小mmm等于β\,\beta\,β，但当j≥n−β\,j \geq n - \beta\,j≥n−β时，分块大小m\,m\,m严格小于β\,\beta\,β。为了避免给每个维度都生成边界函数，我们决定在这种情况下根据为β\,\beta\,β找到的那些边界函数进行插值拟合，并检查这种拟合对psuccp_{\text{succ}}psucc的影响大不大（我们希望影响不大）。最后，为了提高psuccp_{\text{succ}}psucc，我们添加了一个可选参数ν\nuν，使得BKZ实际执行ν\nuν次剪枝枚举，每个都从同一个局部块的不同的随机基开始。这相当于^[10]的极限剪枝。

4.2局部块的预处理

枚举的开销与局部基的质量紧密相关，特别是当分块大小增加时：局部基越小，局部投影格L[k−d+1,k]L_{\left\lbrack k - d + 1,k \right\rbrack}L[k−d+1,k]的体积就越大，因此在枚举树的最大填充深度中的节点越少。这一点是众所周知的。不过考虑到BKZ每一轮都会改进基的质量，有人可能会认为在枚举前没必要对局部基进行约化。然而：

- 对于每次枚举，虽然整个基的约化程度是有可能高于LLL约化的，但只能保证得到的局部基是LLL约化基。

- 在较大的分块大小中，大多数枚举都是成功的：能够得到比分块中第一个向量更短的向量。这意味着将执行局部LLL格基规约，以从生成集获得基：参见算法1的第1行。在下一次迭代中，枚举往往会在一般的LLL约化基上进行，而不是在约化程度更好的基上进行。

这表明，对于大多数枚举，得到的局部基一般仅仅是LLL约化基，即使在枚举过程中其他局部基可能会被更好地约化。这一点得到了实验的证实。

因此，我们实现了一个简单的加速：确保在每次枚举之前，局部基的约化程度比LLL约化高，但不会花费太多时间。在枚举之前，我们对局部基使用递归的中止BKZ预处理：我们根据β\betaβ自动寻找一个合适的参数。

4.3优化枚举半径

众所周知，枚举成本也会受到初始半径RRR的选择的影响，尽管该半径在枚举过程中会更新。最初，枚举半径是R=∥bj∗∥R = \left. \parallel\mathbf{b}_{j}^{*} \right.\parallelR=∥bj∗∥，但是如果我们事先知道输出向量有多短，我们会选择一个较小的初始半径RRR，从而减少枚举时间。实际上，枚举树深度ddd处的节点数与RdR^{d}Rd成正比（不论剪枝与否）。不幸的是，除了一般的界限外，我们对关于λ1(L[j,k])\lambda_{1}\left( L_{\left\lbrack j,k \right\rbrack} \right)λ1(L[j,k])应该有多小的问题（从理论上看）知之甚少。因此，我们进行了实验，以查看在实践中通过枚举找到的最终范数是什么：图1比较了一轮BKZ的最终范数(通过枚举找到)与GH(L[j,k])\text{GH}\left( L_{\left\lbrack j,k \right\rbrack} \right)GH(L[j,k])，这取决于局部块的起始索引j\ j j。对于最低的指数j\ j j，可以看到最终范数明显低于GH(L[j,k])\text{GH}\left( L_{\left\lbrack j,k \right\rbrack} \right)GH(L[j,k])，而对于最大的指数，其最终范数明显大于GH(L[j,k])\text{GH}\left( L_{\left\lbrack j,k \right\rbrack} \right)GH(L[j,k])。在占大多数枚举的中间，最终范数和Gaussian Heuristic预测之间的比率大多在0.95到1.05之间，而第一个局部基向量的范数和GH(L[j,k])\text{GH}\left( L_{\left\lbrack j,k \right\rbrack} \right)GH(L[j,k])之间的比率通常略低于1.1。因此，我们使用了以下优化：对于除最后30个索引之外的所有索引j，我们设R=min(γGH(L[j,k]),∥bj∗∥)R = min\left( \sqrt{\gamma}\text{GH}\left( L_{\left\lbrack j,k \right\rbrack} \right),\left. \parallel\mathbf{b}_{j}^{*} \right.\parallel \right)R=min(γGH(L[j,k]),∥bj∗∥)。而不是R=∥bj∗∥R = \left. \parallel\mathbf{b}_{j}^{*} \right.\parallelR=∥bj∗∥，其中γ\gammaγ是半径参数。实际上，我们选择了γ=1.1≈1.05\sqrt{\gamma} = \sqrt{1.1} \approx 1.05γ=1.1≈1.05。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tiSLvgB3-1635426868267)(media/image2.png)]{width=“5.674305555555556in” height=“3.1493055555555554in”}

图 1 对于每个局部块B[j,k]B_{\left\lbrack j,k \right\rbrack}B[j,k]，比较∥bj∗∥\left. \parallel\mathbf{b}_{j}^{*} \right.\parallel∥bj∗∥，λ1(L[j,k])\lambda_{1}\left( L_{\left\lbrack j,k \right\rbrack} \right)λ1(L[j,k])和GH(L[j,k])\text{GH}\left( L_{\left\lbrack j,k \right\rbrack} \right)GH(L[j,k])的结果

5 格算法的新纪录

在这里，我们简要报告了使用64位Xeon处理器打破一些格算法记录的实验，这表明BKZ 2.0是目前实际应用中最好的格基规约算法。

5.1 Darmstadt的格挑战问题

Darmstadt格挑战问题于2008年提出。对于每个维度，完成挑战就是要在Ajtai格^[2]中找到范数<q< q<q的向量，其中$\ q\ $取决于维度；并尽量使范数最小化。到目前为止，完成的最难挑战是725维：第一个解决575到725维挑战的方案是由Gama和Nguyen在2008年发现的，他们使用NTL的BKZ和SH剪枝实现了BKZ。自那以后又找到了更短的解决方案（见完整列表^[24]），但没有人完成更高维度的挑战。所有人的求解方法都是通过约化更小维度（通常在150-200左右）的合理选取的子格的基来找到的，这些子格的存在源于Ajtai格的结构。我们也使用了同样的策略。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZYiBB1w0-1635426868270)(media/image3.png)]{width=“5.7652777777777775in” height=“2.4902777777777776in”}

表 1 Darmstadt格挑战的新纪录

分块大小为90的BKZ 2.0（18次成功概率为5%的剪枝枚举）找到了针对挑战750、775和800的第一个解，并且在所有挑战525到725中的向量显著缩短，总共使用了大约3个核心年，如表1所总结的：第一列是挑战的维度，第二列是我们用来寻找解的子格的维度，第三列是BKZ 2.0找到的最佳范数，第四列是以前算法找到的最佳范数，第五列是我们用来寻找解的子格的维度，第六个是子格约化基的Hermite因子，它略低于1.01dim{1.01}^{\text{dim}}1.01dim。2008年，Gama和Nguyen^[9]认为1.01dim{1.01}^{\text{dim}}1.01dim中的系数是当时最先进的极限，这表明了确实有提升。

5.2 SVP挑战

SVP挑战赛^[40]于2010年5月开始。挑战赛中的格LLL是大体积的随机整格，因此λ1(L)≈GH(L)\lambda_{1}\left( L \right) \approx \text{GH}\left( L \right)λ1(L)≈GH(L)的概率很大。这个挑战是要找到一个几乎最短的向量，即范数≤1.05GH(L)\leq 1.05GH\left( L \right)≤1.05GH(L)的非零格向量。我们使用分块大小为75，成功概率为20%的剪枝的BKZ 2.0，成功解决了从90维到112维的所有挑战。

6 利用模拟算法预测 BKZ 2.0

现在，我们提出了一种有效的模拟算法来预测BKZ 2.0在维数高、分块大小较大(β≥50)(\beta \geq 50)(β≥50)下的性能。从运行时间的角度和输出质量来看，我们的模拟与在64位Xeon处理器上使用几个核心年的随机格和Darmstadt格挑战上的实验相当一致。因此我们相信，我们提出的模拟可以用来大致预测使用（比我们在实验中所使用的设备计算能力强很多的）高算力设备能做到什么，从而得出更令人信服的安全性估计。

6.1 模拟算法描述

我们的模拟算法的目标是在执行BKZ的过程中，（更准确地说是在每轮开始时）对Gram-Schmidt序列$\ \left( \mathbf{b}{1}^{{*},\mathbf{b}_{2}}{*},\ldots,\mathbf{b}{n}^{*} \right)\ 进行预测。在算法1的步骤1中，每当进行预测。在算法1的步骤1中，每当进行预测。在算法1的步骤1中，每当\ j = 0\ 时，BKZ算法就会开始新的一轮。所以BKZ的每一轮实际上调用了时，BKZ算法就会开始新的一轮。所以BKZ的每一轮实际上调用了时，BKZ算法就会开始新的一轮。所以BKZ的每一轮实际上调用了n - 1$次枚举。我们假设输入基是一个"随机"的约化基，没有特殊性质。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5kqpALza-1635426868272)(media/image4.png)]{width=“3.6180555555555554in” height=“2.5625in”}

图 2 比较$\ \frac{\lambda_{1}\left( L \right)}{\text{GH}\left( L \right)}\ 在BKZ−在BKZ-在BKZ−\beta约化中不使用极限剪枝的局部块中，和在维数为约化中不使用极限剪枝的局部块中，和在维数为约化中不使用极限剪枝的局部块中，和在维数为\beta$的随机格中的大小。图上给出了有标准差和无标准差的期望。

我们进行模拟的出发点是基于4.3节的直觉，即大多数局部块的第一个最小值看起来像随机格：这在分块大小≤30\leq 30≤30时不成立（如Gama和Nguyen^[9]所指出的），但随着分块大小的增加，它变得越来越接近实际情况，如图2所示，其中我们看到λ1(L)GH(L)\frac{\lambda_{1}\left( L \right)}{\text{GH}\left( L \right)}GH(L)λ1(L)的预期和标准偏差似乎收敛到随机格的预期和标准偏差。直观地讲，这可以用集中现象来解释：随着维数的增加，随机格在格的集合中占据主导地位。因此除非有充分的理由说明我们不能认为给定的格是随机的，我们就总可以就假定它的行为接近随机格。一旦我们能够预测每个局部块的λ1(L[j,k])\lambda_{1}\left( L_{\left\lbrack j,k \right\rbrack} \right)λ1(L[j,k])的值，根据枚举子算法可知这将是∥bj∗∥\left. \parallel\mathbf{b}_{j}^{*} \right.\parallel∥bj∗∥的新值，我们就能预测下一局部块的体积，并由此迭代这一过程直到回合结束。这就有了我们的模拟算法（参见算法2）。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vSjzfoaI-1635426868284)(media/image5.png)]{width=“5.7659722222222225in” height=“5.513194444444444in”}

算法 2 BKZ约化模拟算法

我们以如下方式预测L[j,k]L_{\left\lbrack j,k \right\rbrack}L[j,k]中最短非零向量的范数λ1(L[j,k])\lambda_{1}\left( L_{\left\lbrack j,k \right\rbrack} \right)λ1(L[j,k])：

对于大多数指标jjj，除非∥bj∗∥\left. \parallel\mathbf{b}_{j}^{*} \right.\parallel∥bj∗∥比GH(L[j,k])\text{GH}\left( L_{\left\lbrack j,k \right\rbrack} \right)GH(L[j,k])小，否则我们以GH(L[j,k])\text{GH}\left( L_{\left\lbrack j,k \right\rbrack} \right)GH(L[j,k])作为其预测值。
然而，对于最后一轮的索引jjj，即最后一个β\betaβ维块L[n−β+1,n]L_{\lbrack n - \beta + 1,n\rbrack}L[n−β+1,n]内的索引，我们做了一些不同的事情：由于这最后一个块将在回合结束时被HKZ约化，我们假设它的行为类似于与L[n−β+1,n]L_{\lbrack n - \beta + 1,n\rbrack}L[n−β+1,n]等体积随机格的HKZ-约化基。由于这些平均值对于较大的β\ \beta β计算开销可能比较大，因此我们应用了一个简化的规则：我们用随机45维单位体积格的HKZ约化基的平均Gram-Schmidt范数（通过实验计算）来近似后45个Gram-Schmidt范数，并使用Gaussian Heuristic计算前β−45\beta - 45β−45个Gram-Schmidt范数。但是这个模型可能不适用于某些特殊结构的基，例如NTRU Hermite标准型的部分约化，这也是我们只分析输入为随机约化基这种情况的原因。

此模拟算法允许我们在给定任意分块大小的情况下猜测BKZ 2.0实现的近似Hermite因子，如表2所示：对于给定的维度nnn，应运行模拟算法，因为实际的分块大小也取决于该维度。如第2节所述，Hermite因子决定了解决与密码学相关的格问题的性能：近似SVP和唯一SVP见^[9]，SIS和LWE见[28，39，23]。显然，我们只能希望得到一个近似值，因为当输入基数被随机化时，Hermite因子存在众所周知的变化。在我们知道枚举子算法的成本的情况下，模拟算法还使用轮数为我们提供了大约的运行时间：我们稍后将更精确地讨论这些点。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PuqdS8W5-1635426868285)(media/image6.png)]{width=“4.979166666666667in” height=“0.4027777777777778in”}

表 2 模拟预测的高维BKZ的近似所需分块大小

6.2与实验的一致性

结果表明，我们的模拟与使用随机格和Darmstadt格挑战的实验结果很符合。首先，就随机约化基的Gram-Schmidt序列(b1∗,b2∗,…,bn∗)\ \left( \mathbf{b}_{1}^{*},\mathbf{b}_{2}^{*},\ldots,\mathbf{b}_{n}^{*} \right) (b1∗,b2∗,…,bn∗)而言，我们的模拟算法是相当准确的，如图3所示。这意味着我们的模拟算法可以很好地预测BKZ在任意某轮时的Hermite因子，图4证实了这一点。此外，图4表明，多项式的调用次数似乎足以算出与完全约化差距不大的Hermite因子。主要的约化似乎发生在BKZ的前几轮，这说明使用中止BKZ是合理的。这是对目前BKZ研究的一点补充。图4表明，对于随机约化基，我们的模拟算法是相当准确的，这意味着我们的模拟算法可以很好地预测BKZ的Hermite因子，图4证实了这一点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NFCu9GLq-1635426868289)(media/image7.png)]{width=“4.840277777777778in” height=“3.6180555555555554in”}

图3 200维随机格BKZ-50约化过程中Gram-Schmidt范数的预测值与实际值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-paA9wHcq-1635426868290)(media/image8.png)]{width=“5.766666666666667in” height=“3.7263888888888888in”}

图 4 使用BKZ-90约化完成180维Darmstadt格挑战第500到625挑战时，(∥b1∥/vol(L)1/n)1/n\left( \left. \parallel\mathbf{b}_{1} \right.\parallel/\text{vol}(L)^{1/n} \right)^{1/n}(∥b1∥/vol(L)1/n)1/n的实际值和预测值

6.3 枚举子算法

我们还需要估计枚举半径为Gaussian Heuristic的枚举子算法的成本。首先，我们按照^[10]的搜索方法，对使用了BKZ 2.0进行约化的基上应用极限剪枝来计算上限。表3给出了使用BKZ-75-20%作为预处理，半径等于Gaussian Heuristic的分块大小为100-250的极限剪枝的近似成本（用节点数的对数来表示）。节点数可以近似地换算为时钟周期，方法如下：在^[10]的实现中，一个节点需要大约200个时钟周期进行双精度枚举，但这个数字取决于维度，对于分块大小较大的情况，我们可能需要比双精度更高的精度。例如，表3显示，在分块大小为120的情况下应用极限剪枝最多需要大约253个节点，假设精度加倍，这在1.86 GHz Xeon上不到30个核心年。这对于确定深度攻击的参数非常有用。然而，这些上限并非是严格的，这是因为枚举技术的性能取决于预处理。通过更好的预处理（包括具有不同参数的BKZ 2.0）很可能会获得更好的数据（与表3相比）。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0kdM9opd-1635426868292)(media/image9.png)]{width=“5.288888888888889in” height=“0.3840277777777778in”}

表 3 枚举子算法开销的上限，使用带有中止的BKZ预处理的极限剪枝。成本以log2(节点数)\text{lo}g_{2}\left( 节点数 \right)log2(节点数)表示。

事实上表3还提供了一个更好的上界（这是基于我们对BKZ模拟的结果得到的，模拟中使用分块大小为90-120的BKZ约化作为预处理）。为了提供具有良好安全边际的安全估计，我们需要估计可以取得多大进展。有趣的是，枚举技术有其局限性。Nguyen^[33]在假设Gaussian Heuristic很好地估计了节点数的前提下，对枚举树的每个深度的节点数建立了一个下界（这是分析枚举技术复杂性的常用手法）。下界基于格的Rankin不变量γn,m(L)\gamma_{n,m}\left( L \right)γn,m(L)

KaTeX parse error: Undefined control sequence: \mspace at position 102: …\ \end{matrix}}\̲m̲s̲p̲a̲c̲e̲{2mu}\left( \fr…

特别地，^[33]证明了半径为GH(L)\text{GH}\left( L \right)GH(L)的ddd维格LLL的完全计数的中间深度的节点数是≥Vd/2(1)γd,d/2(L)/Vd(1)\geq V_{d\text{/}2}\left( 1 \right)\sqrt{\gamma_{d,d\text{/}2}\left( L \right)\text{/}V_{d}\left( 1 \right)}≥Vd/2(1)γd,d/2(L)/Vd(1)的。对于典型的格LLL，其Rankin不变量γn,m(L)\gamma_{n,m}\left( L \right)γn,m(L)非常接近于Rankin常数γn,m\gamma_{n,m}γn,m的下界（见^[7]）：

KaTeX parse error: Undefined control sequence: \mspace at position 58: … n - m + 1}^{n}\̲m̲s̲p̲a̲c̲e̲{2mu} Z(j)}{\pr…

其中Z(j)=ζ(j)Γ(j2)/πj2Z\left( j \right) = \zeta\left( j \right)\Gamma\left( \frac{j}{2} \right)\text{/}\pi^{\frac{j}{2}}Z(j)=ζ(j)Γ(2j)/π2j，ζ\zetaζ是黎曼zeta函数：KaTeX parse error: Undefined control sequence: \mspace at position 46: …p = 1}^{\infty}\̲m̲s̲p̲a̲c̲e̲{2mu} p^{- j}。这些下界适用于完全枚举，并且可以据这些下界和剪枝加速效果来得到剪枝枚举的节点数下界（如^[10]中所分析的）。表4分别给出了实战中使用线性剪枝和理论上以渐进加速倍率为2n/22^{n\text{/}2}2n/2进行估计的极限剪枝得到的下界数据。与表3的上限相比，有一个很大的差距：线性剪枝的下限告诉了我们，如果为枚举算法找到更强大的预处理，可以有多大的提升。最后，我们注意到，Sieve算法^[3]的启发式变体^[36,30,45]基本上比剪枝枚举更快。然而，目前还不清楚它对安全估计的意义有多大，因为这些变体需要指数空间，而且在实践中表现更好。而且需要比^[36,30]更多的实验来精确评估它们的实际运行时间。但是我们的模型可以很容易地适应枚举算法中的新进展，这要归功于表2。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pffQ0ziW-1635426868294)(media/image10.png)]{width=“5.305555555555555in” height=“0.6041666666666666in”}

表 4 根据^[33，10]，使用线性剪枝或极限剪枝的枚举子算法的成本（在日志节点中）的下界

7修正安全性预估

在这里，我们将说明如何用我们的模拟算法获得比之前更精确的安全估计。

7.1 NTRU格

在NTRU密码系统^[18]中，用公钥计算私钥相当于在具有特殊结构的高维格中寻找最短向量。因为NTRU安全评估是基于BKZ的基准，所以看到这种方法的局限性是很有趣的。在原始文献^[18]中，最小参数集NTRU-107对应于214维格，估计密钥恢复至少需要250次基本运算。通过直接使用格基约化算法（不使用像^{[25, 26, 9]}这样利用NTRU格特殊结构的特别技术）恢复NTRU-107密钥的最佳实验结果是1999年5月的^[25]，其中记载了一次使用BKZ结合SH剪枝的成功实验^[43]，在200 MHz处理器上进行了663小时，即248.76个时钟周期。我们用BKZ 2.0在10个随机的NTRU-107格上进行了实验：我们应用了LLL和BKZ-20，最多只需要几分钟；我们应用了BKZ-65，进行了5%的剪枝，并每5分钟检查第一个基向量是否是与密钥对应的最短向量，在这种情况下我们终止算法。BKZ 2.0对于每个格都是成功的，在2.83 MHz的单核上，BKZ-65的失败平均只用了不到2000年的时间。因此，总体运行时间不到40分钟，即242.62个时钟周期，与5月的实验相比，这至少加速了70%，而且明显低于250次基本操作。因此，最初的安全预估2502^{50}250和实际安全级别（最多约为40比特）之间差了一个数量级。现在，我们再来回顾一下NTRU签名的最新参数。Hoffstein等人在最近的一篇文章中^[17]总结了NTRU加密和签名的最新参数。特别地，NTRU签名的最小参数是(N,q)=(157,256)\left( N,q \right) = \left( 157,256 \right)(N,q)=(157,256)，据声称有针对所有已知攻击的80位安全性，以及针对密钥恢复格攻击的93位安全性。类似于^[9]，我们估计在2N=3142N = 3142N=314维格中恢复范数$\ < q\ 的向量实质上与找到密钥一样困难，体积的向量实质上与找到密钥一样困难，体积的向量实质上与找到密钥一样困难，体积q^{{N}$，对应于${1.008862}}{N}$的Hermite因子。我们对这些参数运行了我们的模拟算法，以根据分块大小从BKZ-20约化基（其成本在这里可以忽略不计）开始猜测需要多少轮：大约6轮的BKZ-110应该足以破解157维的NTRU签名，这相当于大约2112^{11}211次枚举。根据表3，分块大小为110的极限剪枝枚举可以通过搜索至多2472^{47}247个节点来完成，这大约对应于一般的处理器上的2542^{54}254个时钟周期。这表明最小的NTRU签名参数抵御最先进的格攻击的安全级别最多是65位而不是93位，这两个数据差距很大。

7.2 Gentry-Halevi的全同态加密挑战

我们现在转向Gentry-Halevi的主要全同态加密挑战^[11]，没有给出具体的安全性估计。解密密文相当于求解一个BDD问题实例，这可以使用Babai的最近平面算法来完成，最远距离为KaTeX parse error: Undefined control sequence: \mspace at position 15: \text{mi}n_{i}\̲m̲s̲p̲a̲c̲e̲{2mu}\left. \pa…。以给定的KaTeX parse error: Undefined control sequence: \mspace at position 15: \text{mi}n_{i}\̲m̲s̲p̲a̲c̲e̲{2mu}\left. \pa…为目标可以转化为对偶格中的目标Hermite因子。这允许我们基于BDD实例和格体积的近似距离来估计求解BDD实例所需的Hermite因子，如表5所示。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OASCkOc0-1635426868296)(media/image11.png)]{width=“5.7652777777777775in” height=“0.8388888888888889in”}

表 5 Gentry-Halevi面临的主要挑战的安全评估^[11]

据此我们推测，就玩具模型、小挑战和中型挑战而言，其解密可以使用LLL约化来解决。但由于格的维度很大且格基比特长度巨大，这并不简单。（请注意，基矩阵中元素很大的LLL约化有新的理论进展^[37]）我们使用fplll^[4]的修改版进行了实战约化，从而验证了玩具挑战确实是这种情况。对于中小型挑战，我们根据截断的挑战推断运行时间，利用我们对fplll的修改具有启发式运行时间O(N3d2)O(N^{3}d^{2})O(N3d2)的事实，其中ddd是格体积的比特长度，OOO中的常数取决于浮点精度(随着维度的增加)。根据我们的模拟，完成大型挑战将需要分块大小的LLL-130和大约60000轮（从≈开始），即231个枚举调用。根据表3，此枚举程序最多花费260个节点，因此大型挑战提供的安全性最多约为100位。另一方面，如果发现了更强大的枚举预处理，据表4的数据来预测，安全估计可能要除以2102^{10}210−2402^{40}240范围内的一个因子。

原文致谢

这项工作的一部分由欧共体委员会通过合同ICT-2007216676 ECRYPT II项下的ICT计划提供支持。

原文参考文献

1. Ajtai, M.: Generating random lattices according to the invariant distribution (draft

of March 2006)

2. Ajtai, M.: Generating hard instances of lattice problems. In: Proc. STOC 1996,

pp. 99–108. ACM (1996)

3. Ajtai, M., Kumar, R., Sivakumar, D.: A sieve algorithm for the shortest lattice

vector problem. In: Proc. 33rd STOC 2001, pp. 601–610. ACM (2001)

4. Cadé, D., Pujol, X., Stehlé, D.: FPLLL library, version 3.0 (September 2008)

5. Devroye, L.: Non-uniform random variate generation (1986),

http://cg.scs.carleton.ca/~luc/rnbookindex.html

6. Fincke, U., Pohst, M.: Improved methods for calculating vectors of short length in

a lattice, including a complexity analysis. Mathematics of Computation 44(170),

463–471 (1985)

7. Gama, N., Howgrave-Graham, N., Koy, H., Nguyˆ en, P.Q.: Rankin’s Constant and

Blockwise Lattice Reduction. In: Dwork, C. (ed.) CRYPTO 2006. LNCS, vol. 4117,

pp. 112–130. Springer, Heidelberg (2006)

8. Gama, N., Nguyen, P.Q.: Finding short lattice vectors within Mordell’s inequality.

In: Proc. STOC 2008. ACM (2008)

9. Gama, N., Nguyen, P.Q.: Predicting Lattice Reduction. In: Smart, N.P. (ed.) EU-

ROCRYPT 2008. LNCS, vol. 4965, pp. 31–51. Springer, Heidelberg (2008)

10. Gama, N., Nguyen, P.Q., Regev, O.: Lattice 枚举 Using Extreme Pruning.

In: Gilbert, H. (ed.) EUROCRYPT 2010. LNCS, vol. 6110, pp. 257–278. Springer,

Heidelberg (2010)

11. Gentry, C., Halevi, S.: Public challenges for fully-homomorphic encryption (2010),

http://researcher.ibm.com/researcher/view_project.php?id=1548

12. Goldreich, O., Goldwasser, S., Halevi, S.: Challenges for the GGH cryptosystem

(1997), http://theory.lcs.mit.edu/~shaih/challenge.html

13. Goldstein, D., Mayer, A.: On the equidistribution of Hecke points. Forum

Math. 15(2), 165–189 (2003)

14. Hanrot, G., Pujol, X., Stehlé, D.: Analyzing Blockwise Lattice Algorithms Using

Dynamical Systems. In: Rogaway, P. (ed.) CRYPTO 2011. LNCS, vol. 6841, pp.

447–464. Springer, Heidelberg (2011)

15. Hanrot, G., Stehlé, D.: Improved Analysis of Kannan’s Shortest Lattice Vector

Algorithm. In: Menezes, A. (ed.) CRYPTO 2007. LNCS, vol. 4622, pp. 170–186.

Springer, Heidelberg (2007)

16. Hirschhorn, P.S., Hoffstein, J., Howgrave-Graham, N., Whyte, W.: Choosing

NTRUEncrypt Parameters in Light of Combined Lattice Reduction and MITM

Approaches. In: Abdalla, M., Pointcheval, D., Fouque, P.-A., Vergnaud, D. (eds.)

ACNS 2009. LNCS, vol. 5536, pp. 437–455. Springer, Heidelberg (2009)

17. Hoffstein, J., Howgrave-Graham, N., Pipher, J., Whyte, W.: Practical lattice-based

cryptography: NTRUEncrypt and NTRUSign. In: ^[35] (2010)

18. Hoffstein, J., Pipher, J., Silverman, J.H.: NTRU: A Ring-Based Public Key Cryp-

tosystem. In: Buhler, J.P. (ed.) ANTS 1998. LNCS, vol. 1423, pp. 267–288.

Springer, Heidelberg (1998)

19. Hoffstein, J., Silverman, J.H., Whyte, W.: Estimated breaking times for ntru lat-

tices. Technical report, NTRU Cryptosystems, Report #012, v2 (October 2003)

20. Kannan, R.: Improved algorithms for integer programming and related lattice prob-

lems. In: STOC 1983, pp. 193–206. ACM (1983)

21. Lee, M.S., Hahn, S.G.: Cryptanalysis of the GGH cryptosystem. Mathematics in

Computer Science 3, 201–208 (2010)

22. Lenstra, A.K., Lenstra Jr., H.W., Lovász, L.: Factoring polynomials with rational

coefficients. Mathematische Ann. 261, 513–534 (1982)

23. Lindner, R., Peikert, C.: Better key sizes (and attacks) for lwe-based encryption.

Cryptology ePrint Archive, Report 2010/613, Full version of the CT-RSA 2011

24. Lindner, R., Rückert, M.: TU Darmstadt lattice challenge,

http://www.latticechallenge.org/

25. May, A.: Cryptanalysis of NTRU–107. Draft of 1999, available on May’s webpage

(1999)

26. May, A., Silverman, J.H.: Dimension Reduction Methods for Convolution Modu-

lar Lattices. In: Silverman, J.H. (ed.) CaLC 2001. LNCS, vol. 2146, pp. 110–125.

Springer, Heidelberg (2001)

27. Mazo, J.E., Odlyzko, A.M.: Lattice points in high dimensional spheres. Monatsheft

Mathematik 17, 47–61 (1990)

28. Micciancio, D., Regev, O.: Lattice-based cryptography. In: Post-Quantum Cryp-

tography, pp. 147–191. Springer, Berlin (2009)

29. Micciancio, D., Voulgaris, P.: A deterministic single exponential time algorithm for

most lattice problems based on Voronoi cell computations. In: STOC 2010. ACM

(2010)

30. Micciancio, D., Voulgaris, P.: Faster exponential time algorithms for the shortest

vector problem. In: SODA 2010, pp. 1468–1480. ACM-SIAM (2010)

31. Nguyˆ en, P.Q.: Cryptanalysis of the Goldreich-Goldwasser-Halevi Cryptosystem

from Crypto’97. In: Wiener, M. (ed.) CRYPTO 1999. LNCS, vol. 1666, pp. 288–

304. Springer, Heidelberg (1999)

32. Nguyen, P.Q.: Public-key cryptanalysis. In: Luengo, I. (ed.) Recent Trends in Cryp-

tography. Contemporary Mathematics, vol. 477. AMS–RSME (2009)

33. Nguyen, P.Q.: Hermite’s constant and lattice algorithms. In: ^[35] (2010)

34. Nguyˆ en, P.Q., Stehlé, D.: LLL on the Average. In: Hess, F., Pauli, S., Pohst, M.

(eds.) ANTS 2006. LNCS, vol. 4076, pp. 238–256. Springer, Heidelberg (2006)

35. Nguyen, P.Q., Vallée, B. (eds.): The LLL Algorithm: Survey and Applications.

Information Security and Cryptography. Springer, Heidelberg (2010)

36. Nguyen, P.Q., Vidick, T.: Sieve algorithms for the shortest vector problem are

practical. J. of Mathematical Cryptology 2(2), 181–207 (2008)

37. Novocin, A., Stehlé, D., Villard, G.: An LLL-reduction algorithm with quasi-linear

time complexity. In: Proc. STOC 2011. ACM (2011)

38. Pohst, M.: On the computation of lattice vectors of minimal length, successive

minima and reduced bases with applications. SIGSAM Bull. 15(1), 37–44 (1981)

39. Rückert, M., Schneider, M.: Estimating the security of lattice-based cryptosystems.

Cryptology ePrint Archive, Report 2010/137 (2010)

40. Schneider, M., Gama, N.: SVP challenge,

http://www.latticechallenge.org/svp-challenge/

41. Schnorr, C.-P.: A hierarchy of polynomial lattice basis reduction algorithms. The-

oretical Computer Science 53(2-3), 201–224 (1987)

42. Schnorr, C.-P., Euchner, M.: Lattice basis reduction: improved practical algorithms

and solving subset sum problems. Math. Programming 66, 181–199 (1994)

43. Schnorr, C.-P., Hörner, H.H.: Attacking the Chor-Rivest Cryptosystem by Im-

proved Lattice Reduction. In: Guillou, L.C., Quisquater, J.-J. (eds.) EUROCRYPT

1995. LNCS, vol. 921, pp. 1–12. Springer, Heidelberg (1995)

44. Shoup, V.: Number Theory C++ Library (NTL) version 5.4.1,

http://www.shoup.net/ntl/

45. Wang, X., Liu, M., Tian, C., Bi, J.: Improved Nguyen-Vidick heuristic sieve algo-

rithm for shortest vector problem. In: Cryptology ePrint Archive, Report 2010/647