格的介绍
参考：链接
数学上的定义
1、定义在非空有限集合上的偏序集合 L，满足集合 L 中的任意元素 a，b，使得 a，b 在 L 中存在一个最大下界，和最小上界。
2、群论中的定义，是 RnRn 中的满足某种性质的子集。当然，也可以是其它群。
格的研究方向
1、格中计算问题的困难性，即这些问题的计算复杂性，主要有：
- SVP 问题 （最短向量问题）
- CVP 问题（最近向量问题）
2、如何求解格中的困难性问题，目前既有近似算法，也有一些精确性算法。
3、基于格的密码分析，即如何利用格理论分析一些已有的密码学算法，目前有如下研究：
- Knapsack cryptosystems（背包密码）
- DSA nonce biases（DSA随机数偏差）
- Factoring RSA keys with bits known（用已知位分解RSA秘钥）
- Small RSA private exponents（小型RSA私有指数）
- Stereotyped messages with small RSA exponents（具有较小RSA指数的定型消息）
4、如何基于格困难问题设计新的密码体制，这也是后量子密码时代的重要研究方向之一，目前有以下研究：
- Fully homomorphic encryption（全同态加密）
- The Goldreich–Goldwasser–Halevi (GGH) cryptosystem（GGH密码）
- The NTRU cryptosystem（NTRU密码）
- The Ajtai–Dwork cryptosystem and the LWE cryptosystem（AD和LWE密码）
格的发展
参考：链接
| 时间 | 标志事件 |
|---|---|
| 18世纪–1982年 | 格经典数学问题的讨论，代表人物：Lagrange，Gues，Hermite，MInkowski等 |
| 1982年–1996年 | 期间标志性事件是LLL算法的提出（Lenstra-Lenstra-Lovasz） |
| 1996年–2005年 | 第一代格密码诞生（Ajtai96, AD97G, GH9） |
| 2005年–2016年 | 第二代格密码出现并逐步完善，并实用化格密码算法 （Regev05, GPV08,MP12 BLISS ,NewHope, Frodo） |
| 2016年– | 格密码逐步得以标准化 |
发展：
| 从前 | 现在 |
|---|---|
| 具有悠久历史的格经典数学问题的研究 | 近30多年来高维格困难问题的求解算法及其计算复杂性理论研究 |
| 使用格困难问题的求解算法分析非格公钥密码体制的安全性 | 基于格困难问题的密码体制的设计 |
优势：
| 格密码 | 经典密码 |
|---|---|
| 量子攻击算法 | Shor算法 |
| 矩阵乘法、多项式乘法 | Shor算法 |
| Worst-case hardness | Average-case hardnes |
| 结构灵活、功能丰富 | 结构简单、功能受限 |
格定义
简而言之，格是n个线性无关向量的所有整系数的线性组合
基础知识
1、det（A）
指方阵A的行列式
2、向量范数
3、基础区域 F
一个格L的任何基础区域都有着相同的 “体积”
下面的平行四边形即为一个【基础区域F】
基础区域 F 的n维体积称为 L 的行列式，记为det L
4、Hadamard 不等式
L是一个格，任意一个基
和基础区域 F ，有
det L = vol（F）≤ || v1|| || v2|| .....|| vm|| ，基向量越接近垂直，等式越成立
vol（F）是F的体积
5、dim（L）
格的维度，即格的基中的向量个数
6、Hadamard比率
用于描述一组向量的正交程度
格的基 B =｛v1，v2，...，vn｝，有
0< H（B）≤1，且越接近1，则基中的向量就越接近两两正交
matlab代码实现：
function [result] = H(m)
% 计算一组基的Hadamard比率
% 输入：基向量作为行向量所构成的方阵
% 输出：当前基的Hadamard比率
% 1、取出矩阵中的每个行向量
% 2、按照Hadamard比率公式计算
% 3、返回计算结果
n = size(m); %m是矩阵，size返回矩阵维度（行，列）
n = n(1); %取行
product = 1;
for i = 1:n
product = product * norm(m(i,:)); % norm求每个行向量的向量范数，product是 ||v1|| ||v2|| ... ||vn||
end
result = (abs(det(m)) / product)^(1/n); %abs取绝对值，det是矩阵的行列式
end
7、格基相互转化
格L的任意两个基可以通过在左边乘上一个特定的矩阵来相互转化，这个矩阵由整数构成，且它的行列式为 ±1
8、生成优质基
随机生成满足Hadamard比率的优质基
matlab代码实现：
function result = good_basis(N,v,h)
% 随机生成一组优质基
% N是基向量的坐标的绝对值上限，v是向量的个数（格的维度），h是Hadamard比率的下限
% 输入：向量中坐标的取值下限，基中向量的个数，Hadamard比率的下限
% 输出：矩阵形式的优质基
% 1、根据取值下限和维度，随机生成矩阵
% 2、调用H（）计算Hadamard比率
% 3、若比率大于下限，则返回该矩阵，否则跳转1
result = unidrnd(2*N,v) - N; %unidrnd 返回随机方阵
while H(result) < h
result = unidrnd(2*N,v) - N;
end
end
9、计算矩阵行范数
matlab代码实现：
function [result] = row_norm(m)
%计算一个矩阵的行范式
% 输入：矩阵形式的一组基
% 输出：一个包含每一个行向量范数的列向量
% 1、取出矩阵中的每个行向量
% 2、计算每个行向量的范数
% 3、返回计算结果
n = size(m);
result = zeros(n(1),1); % 返回一个全0的矩阵（n(1）行，1列）
for i = 1:n(1)
result(i,1) = norm(m(i,:)); % 每个列向量的第一个位向量范数
end
end
10、向量正交化
施密特正交化：
matlab代码实现：
function [M] = orthogonal(m)
% 使用施密特正交化对矩阵m以行为单位进行正交化，并未单位化
% 输入：矩阵形式的一组基
% 输出：正交化后的矩阵
n = size(m);
M = zeros(n);
n = n(1);
M(1,:) = m(1,:);
for i = 2:n
M(i,:) = m(i,:);
for j = 1:i-1
u_ij = dot(m(i,:),M(j,:)) / (norm(M(j,:))^2);
M(i,:) = M(i,:) - u_ij * M(j,:);
end
end
end
格中困难问题
最基本的难题SVP和CVP，其他的困难问题可由这两种问题变形得到。
SVP
Shortest Vector Problem，最短向量问题
在格中寻找一个最短的非零向量，即寻找一个向量 v∈ L，使得它的欧几里得范数 ||v|| 最小
问题：一个格的最短非零向量多长？
高斯期望（高斯启发式）可以求出最短向量问题
CVP
Closest Vector Problem，最近向量问题
给定一个不在格L中的向量 t∈Rm ，寻找一个向量 v∈ L，使得它最接近w，即寻找一个向量 v∈ L，使得它的欧几里得范数 ||w - v|| 最小
问题：如何使向量接近两两正交的基来求解最近向量问题？
方法1：寻找顶点法
“优基”适合，“劣基”不合适
方法2：
Babai算法
LWE
Learning With Error ，错误学习问题
Learning with errors (LWE) is a problem in machine learning that is conjectured to be hard to solve. Introducedby Oded Regev in 2005, it is a generalization of the parity learning problem. Regev showed, furthermore, that the LWE problem is as hard to solve as several worst-caselattice problems. The LWE problem has recentlybeen used as a hardness assumption to create public-key cryptosystems, such as the ring learning with errors key exchange by Peikert.
——From Wiki
错误学习（LWE）是机器学习中的一个问题，被认为很难解决。 由Oded Regev于2005年引入，它是对奇偶学习问题的概括。 Regev进一步表明，LWE问题与几个最坏情况的格问题一样难以解决。 LWE问题最近已被用作创建公钥密码系统的严格假设，例如Peikert进行的带有错误密钥交换的环学习。
格密码大部分加密机制都是基于LWE的
简单地来说，LWE问题就是求解关于秘密向量x的 “近似随机线性方程组的解” 的问题
例如：
egin{array}{l}
15{{
m{x}}_1}{
m{ + }}14{{
m{x}}_2}{
m{ + }}3{{
m{x}}_3}{
m{ + 2}}{{
m{x}}_{
m{4}}}{
m{ }} approx {
m{9(mod 17)}}\
13{{
m{x}}_1}{
m{ + }}13{{
m{x}}_2}{
m{ + 14}}{{
m{x}}_3}{
m{ + 6}}{{
m{x}}_{
m{4}}}{
m{ }} approx 16{
m{(mod 17)}}\
{
m{6}}{{
m{x}}_1}{
m{ + }}10{{
m{x}}_2}{
m{ + 11}}{{
m{x}}_3}{
m{ + 4}}{{
m{x}}_{
m{4}}}{
m{ }} approx {
m{9(mod 17)}}\
10{{
m{x}}_1}{
m{ + }}11{{
m{x}}_2}{
m{ + 8}}{{
m{x}}_3}{
m{ + 12}}{{
m{x}}_{
m{4}}}{
m{ }} approx {
m{9(mod 17)}}\
......\
{
m{5}}{{
m{x}}_1}{
m{ + 8}}{{
m{x}}_2}{
m{ + 4}}{{
m{x}}_3}{
m{ + 11}}{{
m{x}}_{
m{4}}}{
m{ }} approx {
m{9(mod 17)}}
end{array}
在上述每个方程中，加入了一个小的错误，该错误在+1和-1之间，目标是恢复向量x。如果上述方程中没有加入错误，则使用高斯消元法就可以在多项式时间内恢复向量x。但是由于加入了错误，使得该问题变得非常的困难。
--From 《密码学-基础理论与应用（李子臣）》 & 陈智罡博士的博士论文
定义：
| LWE公钥密码系统 |
| 参数：整数（n,m,l,t,r,q,a），实数（误差e >0） |
| 私钥：随机选取 $ S in Z_q^{n imes l}$，S为私钥 |
| 公钥：随机选取 $ A in Z_q^{n imes m}和E in Z_q^{l imes m}$，（A，P= AS+e）为公钥 |
| 加密：明文 V∈$ Z_t^l $，公钥（A，P），随机选择向量a∈{−r,−r+1, . . . , r}m ，密文 u = ATa c = PTa+f(V) |
| 解密：密文（u,c） 私钥S，明文 f-1(c - STu) |
--From
SIS
Small Integer Solution Problem ，最小整数解问题
定义：
给定整数q，矩阵$ A in Z_q^{n imes m} $和实数B，寻找一个非零向量x∈Zm ，使得Ax = 0(mod q)，且||x|| ≤ B
LLL算法
功能：将一个劣质基转换成一个优质基，且优质基中的第一个行向量就是格中的最短非零向量
算法为两部分：
基格约减
劣质基会变得更优，且基中向量的范数也会适当的减小
matlab代码实现：
function [result] = LLL(v)
% 格基约减的控制算法，对矩阵处理，v是每行的行向量
% 输入：矩阵形式的一组基
% 输出： 约减一次后的基
a = LLL_if(v);
b= LLL_if(a);
while a ~= b % a和b不同时
a = b;
b = LLL_if(b);
end
result = b;
end
控制算法
控制基格约减的循环条件
matlab代码实现：
function [result] = LLL_if(v)
% LLL约减算法
% 输入：矩阵形式的一组基
% 输出：约减后的基
% 1、对输入参数，调用LLL（）
% 2、对1的结果再次调用LLL（）
% 3、重复2，直到结果不再变化
% 4、返回不再变化的结果
n = size(v);
n = n(1);
k = 2;
while k <= n
V = orthogonal(v(1:k,:));
for j = 1:k-1
u = dot(v(k,:),V(j,:)) / (norm(V(j,:))^2);
v(k,:) = v(k,:) - round(u) * v(j,:);
end
u = dot(v(k,:),V(k-1,:)) / (norm(V(k-1,:))^2);
if norm(V(k,:))^2 >= (3/4 - u^2) * norm(V(k-1,:))^2
k = k + 1;
else
temp = v(k-1,:);
v(k-1,:) =v(k,:);
v(k,:) = temp;
k = max(k-1,2);
end
end
result = v;
return;
end
GGH
原理
Alice
1、秘钥生成
（1）选择一个优质基 v1,v2,...,vn ，作为私钥
（2）选择一个整数矩阵U，使det（U） = ±1
（3）计算W = UV，并以W的行向量w1,w2,...,wn作为公钥发送给Bob
Bob
2、加密
（1）以小向量m作为明文
（2）随机选择小向量r
（3）使用Alice的公钥计算e = m1w1+.....+mnwn+r
（4）将e作为密文发送给Alice
Alice
3、解密
（1）使用Babai算法计算出最接近e的格向量v = round（eV-1）.V
（2）计算vW-1得到明文m
PS：另外一个版本
交换m和r的位置，即密文e =rW+m ，明文m = e - rW
分析
1、生成私钥
>> V = good_basis(1000,5,0.9)
V =
499 833 -229 -589 -233
291 -792 382 -142 361
-176 305 906 991 -579
63 840 58 806 665
980 -572 -534 209 -117
>> H(V)
ans =
0.9017
V为优质基 ，私钥
2、生成公钥
如何生成一个行列式为 ±1 的矩阵U，通过几个简单地行列式为 ±1 的随机整数矩阵相乘得到
>> U = [1,2,3,5,8;0,-1,4,6,9;0,0,1,7,10;0,0,0,-1,11;0,0,0,0,-1]*[-1,0,0,0,0;12,1,0,0,0;13,16,1,0,0;14,17,19,1,0;15,18,20,21,1]
U =
252 279 258 173 8
259 327 298 195 9
261 315 334 217 10
151 181 201 230 11
-15 -18 -20 -21 -1
>> det(U)
ans =
1.0000
求 W = U * V：
>> W = U*V
W =
180268 208382 288380 208742 6730
193055 206305 342095 255384 13780
186591 246363 370411 309527 2651
117914 230644 224135 272229 65442
-11506 -21407 -22245 -25564 -5271
>> H(W)
ans =
0.0038
W为劣质基，公钥
3、加密明文
m为明文，r为随机数向量
计算密文e：
>> e = [33,26,-112,47,-91]*W +[-3,-7,2,-2,5]
e =
-3340917 -2563822 -10516380 -6017469 3838898
4、LLL破解
攻击者已知密文和公钥的前提下，利用LLL算法破解
W是劣质基，使用LLL算法，将其转换为优质基V1：
>> V1 = LLL(W)
V1 =
291 -792 382 -142 361
-790 -41 -153 731 -128
-614 -346 -1059 -260 451
-936 1536 -1204 -380 -1748
-14817 44613 -22155 7572 -20566
>> H(V1)
ans =
0.3771
额，打脸了，检查了三遍，LLL函数也没写错，待后续发现~
用LLL算法生成的 “优质基”V1解密：
>> v = round(e / V1)*V1
v =
-3340914 -2563815 -10516382 -6017467 3838893
>> m = v / W
m =
33.0000 26.0000 -112.0000 47.0000 -91.0000
解密成功？？，这是什么操作，劣质基也能？
待后续发现~
同余公钥密码系统
同余密码系统
1、秘钥生成
（1）Alice选择一个大整数q，并选择秘密整数 f 和 g ，满足 f ＜ =$ sqrt{q/2} ,sqrt{q/4}< g< sqrt{q/2}$，gcd（f，g）=1。
（2）Alice计算h = f-1g（mod q）,并将（q，h）作为公钥进行发布，私钥（f，g）
2、加密
Bob选择明文m，满足m < $ sqrt{q/2}$，r 是随机数，Bob使用Alice的公钥（q，h）计算e = rh + m （mod q），并发送密文e给Alice
3、解密
Alice计算a = fe（mod q），其中 0< a < q。然后计算 b = f-1a（mod g），0 < b < g，b即为明文
基于格的同余密码
攻击者在已知公钥和密文的前提下，用格进行分析：
目的：还原出私钥f
构造向量 v1 = (1,h)，v2 = （0，q）
利用v1和v2构造一个格L，故私钥构成的向量（f，g）也是L中的向量，故存在整数R使得 （f，g） = f . (1，h）+ R . （0，q）= f . v1 + R . v2
（f，g）很有可能就是格L的最短向量，故找到L的最短向量就找到了私钥
背包密码
背包问题
子集求和问题
给定正整数集合A = ｛a1，a2,....,an｝和n元的0-1集合X = ｛x1，x2，.......，xn｝，A是确定的，集合X将确定集合A中的哪些元素可以放到背包中，背包中元素总数为 $ sumlimits_{{ m{i = 1}}}^n {{x_i}{a_i}} $
当A和X已知时，求S容易，若已知S和A时，求X是困难的，这就是背包问题
向量问题
A = （a1，a2,....,an）是公开的整数向量，Bob选择一个秘密的二进制向量X = （x1，x2，.......，xn），其中xi取值为0或者1，Bob计算总和 $ sumlimits_{{ m{i = 1}}}^n {{x_i}{a_i}} $，并将发送给Alice。
背包问题要求Alice要么找到原始二进制向量X，要么找到另一个二进制向量，使其总和同样为S
Alice可以从向量X中得知哪个ai包含在S中，因为ai是包含于总和S中的，因此，确定二进制向量X等同于确定A的子集
Alice可以通过检查所有的（2n个）长度为n的二进制向量来找X，若n很大时，这是非常困难的，若Alice有一些与A相关的秘密知识或陷门信息，使得得到的X是惟一的，这样可以容易的求出X，从而破解背包问题，即Alice已知S，可以恢复出明文X。
超递增序列背包
在MH背包密码系统中，会利用一种超递增序列的背包问题来构造陷门信息
超递增序列
整数序列A=｛a1，a2,....,an｝，当且仅当对任意1 ≤ i ≤ n-1 ，均有ai+1≥2ai，则称这样的序列为超递增序列
若A是超递增序列，则对于所有的2≤k≤n，有ak > ak-1 + ... + a1
求解算法
穷举法 ，时间O（n）
| 超递增序列背包求解算法 | |
|
输入：超递增序列A=｛a1，a2,....,an｝以及正整数S 输出：X = （x1，x2，.......，xn） 1、令 i =n 2、若S ≥ ai，则令xi =1，同时令S =S - ai，否则令xi = 0 3、令i =i - 1，若i = 0，则算法结束，否则跳转2 |
MH背包公钥密码
Merkle 和 Hellman 提出的
主要思想：以一个秘密的超递增序列作为初始条件，然后利用秘密的模线性运算来进行伪造，最后将伪装后的序列作为公钥进行发布
缺点：若n小于300，不安全，若大于300，私钥长度过大
1、秘钥生成
Alice
超增序列 R = ｛r1，r2，...，rn｝来创建公钥M和私钥对（R，A，B）：
（1）秘密选择两个大整数A和B，满足B > 2rn 和 gcd （A，B） = 1
（2）生成新序列M = ｛M1，M2，....，Mn｝，Mi = Ari （mod B），0 ≤ Mi < B
2、加密
Bob
选择明文X = （x1，x2，.......，xn），其中xi是0或1，计算密文S = x.M = $ sumlimits_{{ m{i = 1}}}^n {{x_i}{M_i}} $ ，将其发送给Alice
3、解密
（1）计算S‘ = A-1S（mod B） ，0 ≤ S’ < B ，这时序列R和S’构成了一个超递增序列求和问题，$ S' = {A^{ - 1}}S = {A^{ - 1}}sumlimits_{i = 1}^n {{x_i}A{r_i}} = sumlimits_{i = 1}^n {{x_i}{r_i}} (mod B)$
（2）Alice可以利用“超递增序列背包求解算法”求出明文X
基于格的背包密码
使用LLL算法对背包问题分析：
（1）构造一个格L，其基写成矩阵形式：
[{B_{M,S}} = left[ {egin{array}{*{20}{c}}
{{v_1}}\
{{v_2}}\
{{v_3}}\
{...}\
{{v_n}}\
{{v_{n + 1}}}
end{array}}
ight] = left[ {egin{array}{*{20}{c}}
2&0&0&{...}&0&{{a_1}}\
0&2&0&{...}&0&{{a_2}}\
0&0&2&{...}&0&{{a_3}}\
{...}&{...}&{...}&{...}&{...}&{...}\
0&0&0&egin{array}{l}
...\
...
end{array}&2&{{a_n}}\
1&1&1&{...}&1&S
end{array}}
ight]]
（2）设背包难题的解X = （x1，x2，.......，xn），其中xi是0或1，则格L中一定包含向量：t = （x1,x2,...,xn,-1).B = x1v1+x2v2+...+xnvn - vn+1 = (2x1 - 1，2x2 - 1，....，2xn-1 - 1，0），xi是0或1，即t的长度为$sqrt n $，故t是一个非常短的向量，即找出L中最短非零向量，也就是还原出了明文。
NTRU
参考：链接