格基础

格的介绍

参考：链接

数学上的定义

1、定义在非空有限集合上的偏序集合 L，满足集合 L 中的任意元素 a，b，使得 a，b 在 L 中存在一个最大下界，和最小上界。

2、群论中的定义，是 ${\mathrm{RnRn 中的满足某种性质的子集。当然，也可以是其它群。}}^{}$

格的研究方向 

${\mathrm{1、格中计算问题的困难性，即这些问题的计算复杂性，主要有：}}^{}$

1. SVP 问题 （最短向量问题）
2. CVP 问题（最近向量问题）

2、如何求解格中的困难性问题，目前既有近似算法，也有一些精确性算法。

3、基于格的密码分析，即如何利用格理论分析一些已有的密码学算法，目前有如下研究：

1. Knapsack cryptosystems（背包密码）
2. DSA nonce biases（DSA随机数偏差）
3. Factoring RSA keys with bits known（用已知位分解RSA秘钥）
4. Small RSA private exponents（小型RSA私有指数）
5. Stereotyped messages with small RSA exponents（具有较小RSA指数的定型消息）

4、如何基于格困难问题设计新的密码体制，这也是后量子密码时代的重要研究方向之一，目前有以下研究：

1. Fully homomorphic encryption（全同态加密）
2. The Goldreich–Goldwasser–Halevi (GGH) cryptosystem（GGH密码）
3. The NTRU cryptosystem（NTRU密码）
4. 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∈R^m ，寻找一个向量 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 = A^Ta   c = P^Ta+f(V)

解密：密文（u,c） 私钥S，明文 f^-1(c - S^Tu)

--From

SIS

Small Integer Solution Problem ，最小整数解问题

定义：

给定整数q，矩阵$ A in Z_q^{n imes m} $和实数B，寻找一个非零向量x∈Z^m ，使得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 = ｛a₁，a₂,....,a_n｝和n元的0-1集合X = ｛x₁，x₂，.......，x_n｝，A是确定的，集合X将确定集合A中的哪些元素可以放到背包中，背包中元素总数为 $ sumlimits_{{ m{i = 1}}}^n {{x_i}{a_i}} $

当A和X已知时，求S容易，若已知S和A时，求X是困难的，这就是背包问题

向量问题

A = （a₁，a₂,....,a_n）是公开的整数向量，Bob选择一个秘密的二进制向量X = （x₁，x₂，.......，x_n），其中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可以通过检查所有的（2ⁿ个）长度为n的二进制向量来找X，若n很大时，这是非常困难的，若Alice有一些与A相关的秘密知识或陷门信息，使得得到的X是惟一的，这样可以容易的求出X，从而破解背包问题，即Alice已知S，可以恢复出明文X。

超递增序列背包

在MH背包密码系统中，会利用一种超递增序列的背包问题来构造陷门信息

超递增序列

整数序列A=｛a₁，a₂,....,a_n｝，当且仅当对任意1 ≤ i ≤ n-1 ，均有a_i+1≥2a_i，则称这样的序列为超递增序列

若A是超递增序列，则对于所有的2≤k≤n，有ak > a_k-1 + ... + a₁  

求解算法

穷举法 ，时间O（n）

超递增序列背包求解算法

输入：超递增序列A=｛a₁，a₂,....,a_n｝以及正整数S

输出：X = （x₁，x₂，.......，x_n）

1、令 i =n

2、若S ≥ a_i，则令x_i =1，同时令S =S - a_i，否则令x_i = 0

3、令i =i - 1，若i = 0，则算法结束，否则跳转2

MH背包公钥密码

Merkle 和 Hellman 提出的

主要思想：以一个秘密的超递增序列作为初始条件，然后利用秘密的模线性运算来进行伪造，最后将伪装后的序列作为公钥进行发布

缺点：若n小于300，不安全，若大于300，私钥长度过大

1、秘钥生成

Alice

超增序列 R  = ｛r₁，r₂，...，r_n｝来创建公钥M和私钥对（R，A，B）：

（1）秘密选择两个大整数A和B，满足B > 2r_n 和 gcd （A，B） = 1

（2）生成新序列M = ｛M₁，M₂，....，M_n｝，Mi = Ar_i （mod B），0 ≤ M_i < B

2、加密

Bob

选择明文X = （x₁，x₂，.......，x_n），其中x_i是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 = （x₁，x₂，.......，x_n），其中x_i是0或1，则格L中一定包含向量：t = （x₁,x₂,...,x_n,-1).B = x₁v₁+x₂v₂+...+x_nv_n - v_n+1 = (2x₁ - 1，2x₂ - 1，....，2x_n-1 - 1，0），x_i是0或1，即t的长度为$sqrt n $，故t是一个非常短的向量，即找出L中最短非零向量，也就是还原出了明文。

NTRU

参考：链接