格密码学习笔记(一)

格密码学习笔记(一)

\qquad 随着当下量子计算机的研制的迅速进展,量子算法亦是相应得以巨大突破。在量子计算模型下,经典数论假设的密码体系(如大整数分解,计算有限域/椭圆曲线上的离散对数问题等),存在多项式时间(PPT)的量子算法,换而言之,经典数论密码体系受到了极大的冲击,将有可能成为旧时代的眼泪。因此,能够抵抗量子计算机攻击的密码——“后量子”或“抗量子”密码便应运而生。

\qquad 目前, 用于构建后量子密码系统的常见数学技巧包括:
1.杂凑函数,多变量方程(在构造签名方案时较有优势)
2.纠错码(更合适构造加密方案)
3.格(最通用的一类, 几乎所有经典密码概念都可以在格密码中实现)
4.超奇异椭圆曲线同源问题(当下较新的一类, 目前其中较受关注的有密钥交换和签名方案的构造,计算效率很低,还达不到实用性的要求)

一.格密码的基本概念:

I.根据向量空间的概念,格的定义如下:
\qquad v 1 , … , v n ∈ R m , v_1,\dots,v_n\in{R^m}, v1,,vnRm,为一组线性无关的向量。由 v 1 , … , v n v_1,\dots,v_n v1,,vn生成的格 L L L指的是向量 v 1 , … , v n v_1,\dots,v_n v1,,vn的线性组合构成的向量集合,且其所使用的系数均在 Z n Z^n Zn中,即
L = { a 1 v 1 + a 2 v 2 + ⋯ + a n v n : a 1 , a 2 , … , a n ∈ Z } \qquad\qquad L=\{a_1v_1+a_2v_2+\dots+a_nv_n:a_1,a_2,\dots,a_n\in{Z}\} L={a1v1+a2v2++anvn:a1,a2,,anZ}
\qquad 任意一组可以生成格的线性无关的向量都称为格的基,格的基中的向量个数称为格的维度。任意两组这样的向量中,向量的个数相同。
\qquad 某种程度上,格可以理解成系数为整数的向量空间。

II.与格相关的基本计算性难题:
1.SVP: Shortest Vector Problem (在格中寻找最短的非零向量)
\qquad 最短向量问题(SVP):在格 L L L中寻找一个最短的非零向量,即寻找一个非零向量 v ∈ L v\in{L} vL,使它的欧几里得范数 ∥ v ∥ \|v\| v最小。

2.CVP: Closet Vector Problem(在格中寻找与指定非格向量最为接近的向量)
\qquad 最近向量问题(CVP):给定一个不在格 L L L中的向量 w ∈ R m w\in{R^m} wRm,寻找一个向量 v ∈ L v\in{L} vL,使它最接近 w w w ,即寻找一个向量 v ∈ L v\in{L} vL,使欧几里得范数 ∥ w − v ∥ \|w-v\| wv最小。

III.格密码简史:

时间标志事件
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年–格密码逐步得以标准化

IV.格密码的发展大体分为两条主线

从前现在
具有悠久历史的格经典数学问题的研究 ⟹ \Longrightarrow 近30多年来高维格困难问题的求解算法及其计算复杂性理论研究
使用格困难问题的求解算法分析非格公钥密码体制的安全性 ⟹ \Longrightarrow 基于格困难问题的密码体制的设计

V.格密码优势:抗量子计算

格密码经典密码
量子攻击算法Shor算法
矩阵乘法、多项式乘法Shor算法
Worst-case hardnessAverage-case hardnes
结构灵活、功能丰富结构简单、功能受限

VI .量子计算对经典密码算法的影响

密码算法量子计算的影响
对称密码算法(SM4,AES)密钥加倍(Grover)
散列函数(SM3,SHA-3)输出长度增加(Grover)
经典公钥算法(RSA,DSA,ECC)多项式算法(Shor)
格密码未找到有效算法
多变量密码(数字签名)未找到有效算法
基于Hash的密码(数字签名)未找到有效算法
基于编码的密码(加密)未找到有效算法
超奇异同源未找到有效算法

二.LLL算法

\qquad LLL算法(Lenstra-Lenstra-Lovasz,lattice reduction)——以格规约(lattice)基数为输入,输出短正交向量基数。
\qquad 给定格 L L L的一组基为 { v 1 , v 2 , … , v n } \{v_1,v_2,\dots,v_n\} {v1,v2,,vn},然后对它进行约减。约减的主要目的是将这组任意给定的基转化为一组正交性较好的优质基,并使得这个优质基中的各个向量尽量最短。也就是说,首先要得到能够通过算法找到的最短向量,然后找到比这个最短向量稍长一点的向量,依次类推,直到最后找到这组基中的最后一个向量为止。或者,要使得在这个优质基中的向量之间具有相当好的正交性,即两个向量的点乘 v i ⋅ v j v_i\cdot{v_j} vivj尽可能地接近于零。
I.基本概念
命题1 \quad B = { v 1 , v 2 , … , v n } B=\{v_1,v_2,\dots,v_n\} B={v1,v2,,vn}为格 L L L的一组基,且 B ∗ = { v 1 ∗ , v 2 ∗ , … , v n ∗ } B^*=\{v_1^*,v_2^*,\dots,v_n^*\} B={v1,v2,,vn}为相应的Gram-Schmidt正交基,则有 det ⁡ L = ∏ i = 1 n ∥ v i ∗ ∥ \det{L}=\prod\limits^n_{i=1}\|v_i^*\| detL=i=1nvi
定义1 \quad V V V表示一个向量空间啊, 是空间 W ⊂ V W\subset{V} WV的一个子空间, W W W V V V中的正交分量为 W ⊥ = { v ∈ V : v ⋅ w = 0 , ∀ w ∈ W } W^{\perp}=\{v\in{V}:v\cdot{w}=0,\forall{w}\in{W}\} W={vV:vw=0,wW}
定理1 \quad L L L表示一个维度为n的格,则 L L L的任意一组LLL约减基 { v 1 , v 2 , … , v n } \{v_1,v_2,\dots,v_n\} {v1v2,,vn}具有如下两条性质:
∏ i = 1 ∗ ∥ v i ∗ ∥ ≤ 2 n ( n − 1 ) / 4 det ⁡ L \qquad\qquad\qquad\qquad\prod\limits_{i=1}^*\|v^*_i\|\le{2^{n(n-1)/4}}\det{L} i=1vi2n(n1)/4detL
∥ v j ∥ ≤ 2 i − 1 / 2 ∥ v i ∗ ∥ , ∀ 1 ≤ j ≤ i ≤ n \qquad\qquad\qquad\quad\|v_j\|\le{2^{i-1}/2}\|v_i^*\|,\forall{1\le{j}\le{i}\le{n}} vj2i1/2vi,1jin
\qquad 此外,LLL约减基的初始向量需满足
∥ v 1 ∥ ≤ 2 ( n − 1 ) / 4 ∣ det ⁡ L ∣ \qquad\qquad\|v_1\|\le{2^{(n-1)/4}}|\det{L}| v12(n1)/4detL ∥ v 1 ∥ ≤ 2 ( n − 1 ) / 2 min ⁡ 0 ̸ = v ∈ L ∥ v ∥ \|v_1\|\le{2^{(n-1)/2}}\min\limits_{0\not=v\in{L}}\|v\| v12(n1)/20̸=vLminv
\qquad 故一组LLL约减基能够以 2 ( n − 1 ) / 2 2^{(n-1)/2} 2(n1)/2系数解决apprSVP问题。
定理2LLL算法 \quad { v 1 , v 2 , … , v n } \{v_1,v_2,\dots,v_n\} {v1,v2,,vn}为格 L L L的一组基,则以下算法一定能够在有限步骤内终止,并且能够返回 L L L的一组LLL约减基。

LLL算法
输入:格的一组基 { v 1 , v 2 , … , v n } \{v_1,v_2,\dots,v_n\} {v1,v2,,vn}
输出:LLL约减基
1. \qquad 1. 1.Input { v 1 , v 2 , … , v n } \{v_1,v_2,\dots,v_n\} {v1,v2,,vn}
2. \qquad 2. 2.Set k = 2 k=2 k=2
3. \qquad 3. 3. Set v i ∗ = v j v_i^*=v_j vi=vj
4. \qquad 4. 4.Loop while k ≤ n k\le{n} kn
5. \qquad 5. 5.Loop j = 1 , 2 , 3 , … , k − 1 j=1,2,3,\dots,k-1 j=1,2,3,,k1
6. \qquad 6. 6.Set v k = v k − [ μ k , j ] v j v_k=v_k-[\mu_{k,j}]v_j vk=vk[μk,j]vj(Size条件)
7. \qquad 7. 7.End j j j Loop
8. \qquad 8. 8.if ∥ v k ∗ ∥ ≥ ( 3 4 − μ k , k − 1 2 ) ∥ v k − 1 ∗ ∥ 2 \|v_k^*\|\ge(\frac{3}{4}-\mu^2_{k,k-1})\|v_{k-1}^*\|^2 vk(43μk,k12)vk12(Lovasz条件)
9. \qquad 9. 9.Set k = k + 1 k=k+1 k=k+1
10. \qquad 10. 10.Else
11. \qquad 11. 11.Swap v k − 1 v_{k-1} vk1 and v k v_k vk
12. \qquad 12. 12.Set k = max ⁡ ( k − 1 , 2 ) k=\max(k-1,2) k=max(k1,2)
13. \qquad 13. 13.End if
14. \qquad 14. 14.End k k k Loop
15. \qquad 15. 15.Return LLL约减基 { v 1 , v 2 , … , v n } \{v_1,v_2,\dots,v_n\} {v1,v2,,vn}

注:每一步中, v 1 ∗ , v 2 ∗ , … , v n ∗ v_1^*,v_2^*,\dots,v_n^* v1,v2,,vn都是通过对当前向量 { v 1 , v 2 , … , v n } \{v_1,v_2,\dots,v_n\} {v1,v2,,vn}值应用Gram-Schmidt正交化所得的正交向量集合, μ i , j \mu_{i,j} μi,j是相应 ( v i ⋅ v j ) / ∥ v j ∗ ∥ 2 (v_i\cdot{v_j})/\|v_j^*\|^2 (vivj)/vj2的值。
\qquad LLL算法是一个多项式时间算法,在最多 O ( n 2 ( log ⁡ n + log ⁡ ( max ⁡ ∥ v i ∥ ) ) ) O(n^2(\log{n} +\log(\max\|v_i\|))) O(n2(logn+log(maxvi))),LLL算法是一个多项式时间算法,在最多 O ( n 6 ( log ⁡ ( max ⁡ ∥ v i ∥ ) ) 2 ) O(n^6(\log(\max\|v_i\|))^2) O(n6(log(maxvi))2)次基本操作后终止。
定理3LLL-apprCVP算法 \quad 存在一个常数 C C C,使得对于任意一个n维的格 L L L ,当给定一组基 { v 1 , v 2 , … , v n } \{v_1,v_2,\dots,v_n\} {v1,v2,,vn}时,下面算法能够在 内解决apprCVP问题。

LLL-apprCVP算法
输入:格的一组基 { v 1 , v 2 , … , v n } \{v_1,v_2,\dots,v_n\} {v1,v2,,vn},目标向量 w w w
输出:apprCVP问题的一个解 v v v
1. \qquad 1. 1.Set k = 2 k=2 k=2
2. \qquad 2. 2. Set v i ∗ = v j v_i^*=v_j vi=vj
3. \qquad 3. 3.Loop while k ≤ n k\le{n} kn
4. \qquad 4. 4.Loop j = 1 , 2 , 3 , … , k − 1 j=1,2,3,\dots,k-1 j=1,2,3,,k1
5. \qquad 5. 5.Set v k = v k − [ μ k , j ] v j v_k=v_k-[\mu_{k,j}]v_j vk=vk[μk,j]vj(Size条件)
6. \qquad 6. 6.End j j j Loop
7. \qquad 7. 7.if ∥ v k ∗ ∥ ≥ ( 3 4 − μ k , k − 1 2 ) ∥ v k − 1 ∗ ∥ 2 \|v_k^*\|\ge(\frac{3}{4}-\mu^2_{k,k-1})\|v_{k-1}^*\|^2 vk(43μk,k12)vk12(Lovasz条件)
8. \qquad 8. 8.Set k = k + 1 k=k+1 k=k+1
9. \qquad 9. 9.Else
10. \qquad 10. 10.Swap v k − 1 v_{k-1} vk1 and v k v_k vk
11. \qquad 11. 11.Set k = max ⁡ ( k − 1 , 2 ) k=\max(k-1,2) k=max(k1,2)
12. \qquad 12. 12.End if
13. \qquad 13. 13.End k k k Loop
14. \qquad 14. 14.Result= LLL约减基 { v 1 , v 2 , … , v n } \{v_1,v_2,\dots,v_n\} {v1,v2,,vn}
15. \qquad 15. 15.Compute w = t 1 v 1 + t 2 v 2 + ⋯ + t n v n , t 1 , t 2 , … , t n ∈ R w=t_1v_1+t_2v_2+\dots+t_nv_n,t_1,t_2,\dots,t_n\in{R} w=t1v1+t2v2++tnvn,t1,t2,,tnR
16. \qquad 16. 16.Loop i = 1 , 2 , … , n i=1,2,\dots,n i=1,2,,n
17. \qquad 17. 17. a i = a_i= ai=round ( t i ) (t_i) (ti)
18. \qquad 18. 18.Return a 1 v 1 + a 2 v 2 + ⋯ + a n v n a_1v_1+a_2v_2+\dots+a_nv_n a1v1+a2v2++anvn

II.LLL算法MATLAB实现
1.计算Hadamard比率函数

计算Hadamard比率
输入:基向量作为行向量构成的方阵
输出:当前基的Hadamard比率
1. \qquad 1. 1.取出矩阵中的每个行向量
2. \qquad 2. 2. 按照Hadamard比率公式进行计算
3. \qquad 3. 3. 返回计算结果
function [result]=H(m)
% 计算一组基的Hadamard比率
n=size(m);
n=n(1);
product=1;
for i=1:n
    product=product*norm(m(i,:));
end
result=(abs(det(m))/product)^(1/n);
end

2.生成优质基函数

生成优质基
输入:向量中坐标的取值上限,基中向量的个数,Hadamard比率的下限
输出:矩阵形式的优质基
1. \qquad 1. 1.根据取值上限和指定维度,随机生成矩阵
2. \qquad 2. 2.调用LLL-apprCVP算法计算矩阵的Hadamard
3. \qquad 3. 3. 若比率大于下限,则返回该矩阵;否则转回步骤1
function result=good_basis(N,v,h)
% 随机生成一组优质基
% N为基向量的坐标的绝对值上限;v为向量的
% 个数;h为Hadamard比率的下限
result=unidrnd(2*N,v)-N;
while H(result)<h
    result=unidrnd(2*N,v)-N;
end
end

3.计算矩阵的行范数函数

计算矩阵的行范数
输入:矩阵形式的一组基
输出:一个包含了各个行向量范数的列向量
1. \qquad 1. 1.取出矩阵中的每个行向量
2. \qquad 2. 2.计算每个行向量的范数
3. \qquad 3. 3. 返回计算结果
function [result]=row_norm(m)
%计算一个矩阵的行范数
n=size(m);
result=zores(n(1),1);
for i=1:n(1)
    result(i,1)=norm(m(i,:));
end
end

4.向量正交化函数

向量正交化
输入:矩阵形式的一组基
输出:正交化后的矩阵
\qquad\quad 具体步骤为Gram-Schmidt正交化算法步骤
function [M]=orthogonal(m)
% 使用Gram-Schmidt方法对矩阵,进行正交化(为单位化)
n=size(m);
M=zeros(n);
n=n(1);
M(1,:)=m(1,:);
for i=2:m
    M(i,:)=m(i,:);
    for j=1:i-1
        u_ij=dot(m(i,:))/(norm(M(j,:))^2);
        M(i,:)=M(i,:)-u_ij*M(j,:);
    end
end
end

5.LLL算法实现

格基约减
输入:矩阵形式的一组基
输出:经过一次约减后的基
\qquad\quad 具体步骤为LLL算法步骤
控制算法
输入:矩阵形式的一组基
输出:经过约减后的基
1. \qquad 1. 1.对于输入参数,调用格基约减算法
2. \qquad 2. 2.对上一步结果再次调用格基约减算法
3. \qquad 3. 3. 重复步骤2,直到结果不再变化
4. \qquad 4. 4. 返回最终结果
function [result]=LLL(v)
%使用LLL格基约减算法,对输入矩阵v进行处理
%其中v各行作为一行向量
%算法中多次调用基础过程,直到得到定值
a=lll(v);
b=lll(a);
while a~=b
    a=b;
    b=lll(b);
end
result=b
end
function [result]=lll(v)
%基础LLL格基约减过程
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

三.LWE(Learning With Errors)

\qquad 2005 年, Regev 提出了带错误的学习问题 (LWE), 证明了 LWE 与格上困难问题 (如近似最短向量问题 Gap-SVP) 相关, 并给出了基于 LWE 的公钥密码方案. 与之前出现的格上困难问题比较, LWE 在构建密码系统时更方便。
\qquad 给定矩阵 A ∈ Z q m × n A\in{Z_q^{m\times{n}}} AZqm×n和向量 b = A s + e b=As+e b=As+e,求解 s ∈ Z n s\in{Z^n} sZn
\qquad 记为 L ( A ) : = { A s : s ∈ Z q n } + q Z m L(A):=\{As:s\in{Z^n_q}\}+qZ^m L(A):={As:sZqn}+qZm

\qquad 其困难性来自方程的误差e
\qquad\qquad\quad
I.LWE的直观困难性

求解方法方程计算复杂度
直观求解之穷搜碰运气 { ⋮ 1 s 1 + 0 s 2 + 0 s 3 + 0 s 4 ≈ 8 ( m o d &ThinSpace;&ThinSpace; 17 ) ⋮ 1 s 1 + 0 s 2 + 0 s 3 + 0 s 4 ≈ 7 ( m o d &ThinSpace;&ThinSpace; 17 ) ⋮ 1 s 1 + 0 s 2 + 0 s 3 + 0 s 4 ≈ 8 ( m o d &ThinSpace;&ThinSpace; 17 ) ⋮ \begin{cases}\begin{aligned}\vdots\\1s_1+0s_2+0s_3&amp;+0s_4\approx8(\mod17)\\\vdots\\1s_1+0s_2+0s_3&amp;+0s_4\approx7(\mod17)\\\vdots\\1s_1+0s_2+0s_3&amp;+0s_4\approx8(\mod17)\\\vdots\end{aligned}\end{cases} 1s1+0s2+0s31s1+0s2+0s31s1+0s2+0s3+0s48(mod17)+0s47(mod17)+0s48(mod17)计算复杂度: O ( 2 n log ⁡ q ) O(2^{n\log{q}}) O(2nlogq)
直观求解之搜索s { 14 s 1 + 15 s 2 5 + 5 s 3 + 2 s 4 ≈ 8 ( m o d &ThinSpace;&ThinSpace; 17 ) 13 s 1 + 14 s 2 5 + 14 s 3 + 6 s 4 ≈ 16 ( m o d &ThinSpace;&ThinSpace; 17 ) 6 s 1 + 10 s 2 5 + 14 s 3 + 1 s 4 ≈ 3 ( m o d &ThinSpace;&ThinSpace; 17 ) 10 s 1 + 4 s 2 5 + 12 s 3 + 16 s 4 ≈ 12 ( m o d &ThinSpace;&ThinSpace; 17 ) 9 s 1 + 4 s 2 5 + 9 s 3 + 6 s 4 ≈ 9 ( m o d &ThinSpace;&ThinSpace; 17 ) 3 s 1 + 6 s 2 5 + 4 s 3 + 5 s 4 ≈ 16 ( m o d &ThinSpace;&ThinSpace; 17 ) 6 s 1 + 7 s 2 5 + 16 s 3 + 2 s 4 ≈ 3 ( m o d &ThinSpace;&ThinSpace; 17 ) \begin{cases}\begin{aligned}&amp;14s_1+15s2_5+5s_3+2s_4\approx{8(\mod{17})}\\&amp;13s_1+14s2_5+14s_3+6s_4\approx{16(\mod{17})}\\&amp;6s_1+10s2_5+14s_3+1s_4\approx{3(\mod{17})}\\&amp;10s_1+4s2_5+12s_3+16s_4\approx{12(\mod{17})}\\&amp;9s_1+4s2_5+9s_3+6s_4\approx{9(\mod{17})}\\&amp;3s_1+6s2_5+4s_3+5s_4\approx{16(\mod{17})}\\&amp;6s_1+7s2_5+16s_3+2s_4\approx{3(\mod{17})}\end{aligned}\end{cases} 14s1+15s25+5s3+2s48(mod17)13s1+14s25+14s3+6s416(mod17)6s1+10s25+14s3+1s43(mod17)10s1+4s25+12s3+16s412(mod17)9s1+4s25+9s3+6s49(mod17)3s1+6s25+4s3+5s416(mod17)6s1+7s25+16s3+2s43(mod17)计算复杂度: O ( 2 n log ⁡ q ) O(2^{n\log{q}}) O(2nlogq)
直观求解之BKW03 { 14 s 1 + 15 s 2 5 ⋮ + 5 s 3 + ⋮ 2 s 4 ≈ 8 ( m o d &ThinSpace;&ThinSpace; 17 ) 13 s 1 + 14 s 2 5 ⋮ + 14 s 3 + ⋮ 6 s 4 ≈ 16 ( m o d &ThinSpace;&ThinSpace; 17 ) 6 s 1 + 10 s 2 5 ⋮ + 14 s 3 + ⋮ 1 s 4 ≈ 3 ( m o d &ThinSpace;&ThinSpace; 17 ) 10 s 1 + 4 s 2 5 ⋮ + 12 s 3 + ⋮ 16 s 4 ≈ 12 ( m o d &ThinSpace;&ThinSpace; 17 ) 9 s 1 + 4 s 2 5 ⋮ + 9 s 3 + ⋮ 6 s 4 ≈ 9 ( m o d &ThinSpace;&ThinSpace; 17 ) 3 s 1 + 6 s 2 5 ⋮ + 4 s 3 + ⋮ 5 s 4 ≈ 16 ( m o d &ThinSpace;&ThinSpace; 17 ) 6 s 1 + 7 s 2 5 ⋮ + 16 s 3 + ⋮ 2 s 4 ≈ 3 ( m o d &ThinSpace;&ThinSpace; 17 ) \begin{cases}\begin{aligned}14s_1+15s2_5&amp;\vdots+5s_3+\vdots 2s_4\approx{8(\mod{17})}&amp;\\13s_1+14s2_5&amp;\vdots+14s_3+\vdots6s_4\approx{16(\mod{17})}&amp;\\6s_1+10s2_5&amp;\vdots+14s_3+\vdots1s_4\approx{3(\mod{17})}&amp;\\10s_1+4s2_5&amp;\vdots+12s_3+\vdots16s_4\approx{12(\mod{17})}&amp;\\9s_1+4s2_5&amp;\vdots+9s_3+\vdots6s_4\approx{9(\mod{17})}&amp;\\3s_1+6s2_5&amp;\vdots+4s_3+\vdots5s_4\approx{16(\mod{17})}&amp;\\6s_1+7s2_5&amp;\vdots+16s_3+\vdots2s_4\approx{3(\mod{17})}&amp;\end{aligned}\end{cases} 14s1+15s2513s1+14s256s1+10s2510s1+4s259s1+4s253s1+6s256s1+7s25+5s3+2s48(mod17)+14s3+6s416(mod17)+14s3+1s43(mod17)+12s3+16s412(mod17)+9s3+6s49(mod17)+4s3+5s416(mod17)+16s3+2s43(mod17)计算复杂度: O ( 2 n ) O(2^n) O(2n)
q-ary格 L ( A ) : = { A t : s ∈ Z q n } + q Z m L ⊥ ( A ) : = { z ∈ Z m : A Z = 0 ∈ Z q n } ⟨ A , ⟨ z , ⟨ A s + e ⟩ ⟩ ⟩ = ⟨ A , z ⟩ \begin{aligned}&amp;L(A):=\{A^t:s\in{Z^n_q}\}+qZ^m\\&amp;L^{\perp}(A):=\{z\in{Z^m}:A_Z=0\in{Z_q^n}\}\\&amp;\langle{A},\langle{z},\langle{As+e}\rangle\rangle\rangle=\langle{A,z}\rangle\end{aligned} L(A):={At:sZqn}+qZmL(A):={zZm:AZ=0Zqn}A,z,As+e=A,zLLL计算随机q-ary格的短基

II.LWE的困难性归约 Worst to Averag
1.困难问题与LWE归约关系

SIVPGapSVP出处
O ~ ( α / n ) \widetilde{O}(\alpha/n) O (α/n) O ~ ( α / n ) \widetilde{O}(\alpha/n) O (α/n) Regev,2005年,首次提出LWE问题并通过量子算法将困难问题规约到LWE,需要 α p &gt; 2 n \alpha{p}&gt;2\sqrt{n} αp>2n
ω [ n log ⁡ n α ( n ) ] \omega[\frac{n\log{n}}{\alpha(n)}] ω[α(n)nlogn] O ~ ( n / α ( n ) ) \widetilde{O}(n/\alpha(n)) O (n/α(n)) Pekert,2009年,通过离散高斯测度(DGS)得到,两个归约都需要量子算法,此结果适用于 p ∈ [ 2 , ∞ ) p\in[2,\infty) p[2,)
O ~ ( n / α log ⁡ n ) \widetilde{O}(n/\alpha\sqrt{\log{n}}) O (n/αlogn ) Peikert, 2009年,首次去量子化,在概率多项式时间内归约,其中 α ∈ ( 0 , 1 ) , q ≥ ζ n ⋅ ω ( log ⁡ n ) , q ≥ 2 n 2 \alpha\in(0,1),q\ge\frac{\zeta}{n}\cdot\omega(\sqrt{\log{n}}),q\ge{2^{\frac{n}{2}}} α(0,1),qnζω(logn ),q22n
O ~ ( k ⋅ q ) \widetilde{O}(\sqrt{k}\cdot{q}) O (k q) Micciancio,peikert,2013年,对应 L W E ( m , n , q ) LWE(m,n,q) LWE(m,n,q),其中 0 &lt; k ≤ n ≤ m − ω ( log ⁡ k ) ≤ k α ( 1 ) , q ≤ k α ( 1 ) 0&lt;k\le{n}\le{m-\omega(\log{k})}\le{k^{\alpha(1)}},q\le{k^{\alpha(1)}} 0<knmω(logk)kα(1),qkα(1),此结果证明了当误差分布足够小(0-1)时LWE是困难的
O ( n ) O(\sqrt{n}) O(n ) O ( n ) O(\sqrt{n}) O(n ) Brakerski,Peikert等,2013年,与Peikert,09相比,将模数 q q q缩小到了 p l o y ( n ) ploy(n) ploy(n)

2.困难问题归约关系
\qquad\qquad
注:
1.当选择合适的参数 n , m , q , χ s , χ e n,m,q,\chi_s,\chi_e n,m,q,χs,χe 时, 搜索型 LWE 问题的难解性与格上困难问题相关。
2.使用量子技术将 LWE 问题的平均情形困难性和随机格上 GapSVP γ \gamma γ和 SIVP γ \gamma γ 问题的最坏情形 困难性联系起来, 其中参数 γ 的选取与 LWE 问题的参数相关。
3.在选取合适的参数时, 判定型 LWE 问题和搜索型 LWE 问题是多项式等价的。

定义1近似最短向量问题aSVP))给定 Z n Z^n Zn中秩为 d d d的格 L L L的一组基 B B B和一个近似参数 γ ≥ 1 \gamma\ge{1} γ1,如何寻找到一个非零向量 u ∈ L u\in{L} uL,使得满足 ∥ u ∥ ≤ min ⁡ v ∈ L ∥ v ∥ \|u\|\le\min\limits_{v\in{L}}\|v\| uvLminv ∥ u ∥ ≤ γ λ 1 \|u\|\le\gamma\lambda_1 uγλ1.

定义2近似最短向量问题对应判断性问题GapSVP))给定 Z n Z^n Zn中秩为 d d d的格 L L L的一组基 B B B,实数 r r r和一个近似参数 γ ≥ 1 \gamma\ge{1} γ1。当 λ 1 ( L ( B ) ) ≤ r \lambda_1(L(B))\le{r} λ1(L(B))r时判定为“YES”,当 λ 1 ( L ( B ) ) ≥ γ r \lambda_1(L(B))\ge\gamma{r} λ1(L(B))γr时判定为“NO”,如果 r ≤ λ 1 ( L ( B ) ) ≤ γ r r\le\lambda_1(L(B))\le\gamma{r} rλ1(L(B))γr时判定为“YES”或“NO”均可。

定义3近似最近向量问题aCVP))给定 Z n Z^n Zn中秩为 d d d的格 L L L的一组基 B B B,一个目标向量 x ∈ s p a n ( L ) x\in{span(L)} xspan(L) x x x不必在格位上)和一个近似参数 γ ≥ 1 \gamma\ge{1} γ1,如何寻找到一个向量 u ∈ L u\in{L} uL,使得满足 ∥ u − x ∥ = d i s t ( x , L ) \|u-x\|=dist(x,L) ux=dist(x,L)

定义4近似最近向量问题对应判断性问题GapCVP))给定 Z n Z^n Zn中秩为 d d d的格 L L L的一组基 B B B,一个目标向量 x ∈ s p a n ( L ) x\in{span(L)} xspan(L) x x x不必在格位上)和一个近似参数 γ ≥ 1 \gamma\ge{1} γ1。当 d i s t ( x , L ) ≤ r dist(x,L)\le{r} dist(x,L)r时判定为“YES”,当 d i s t ( x , L ) ≥ γ r dist(x,L)\ge\gamma{r} dist(x,L)γr时判定为“NO”,如果 r ≤ d i s t ( x , L ) ≤ γ r r\le{dist(x,L)}\le\gamma{r} rdist(x,L)γr时判定为“YES”或“NO”均可。

定义5小整数问题SIS))给定模数 q / g e 1 q/ge{1} q/ge1,常实数 v v v和矩阵 A ∈ Z q n × m A\in{Z^{n\times{m}}_q} AZqn×m ,其中 m ≥ n &gt; 0 m\ge{n}&gt;0 mn>0。如何寻找一个非零向量 u ∈ Z m u\in{Z^m} uZm,使得 A u = 0 m o d &ThinSpace;&ThinSpace; q Au=0\mod{q} Au=0modq ∥ u ∥ ≤ v \|u\|\le{v} uv

定义6搜索型误差学习LWE))给定一个维数 n ≥ 1 n\ge{1} n1,模数 q ≥ 1 q\ge{1} q1 Z q Z_q Zq上一概率分布 χ \chi χ A s , χ A_{s,\chi} As,χ上任意多个抽样,如何确定 s s s

定义7误差学习判定问题LWE))给定一个维数 n ≥ 1 n\ge{1} n1,模数 q ≥ 1 q\ge{1} q1 Z q Z_q Zq 上一概率分布 χ \chi χ。随机从分布 Z q n × Z q Z_q^n\times{Z_q} Zqn×Zq中均匀抽样或 A s , χ A_{s,\chi} As,χ中独立抽样,如果判断此抽样来自 A s , χ A_{s,\chi} As,χ则返回“YES”,如果来自 Z q n × Z q Z_q^n\times{Z_q} Zqn×Zq,则返回“NO”。

定义8有界距离译码BDD))给定 Z n Z^n Zn中秩为 d d d的格 L L L的一组基 B B B,一个距离参数 α &gt; 0 \alpha&gt;0 α>0和一个目标向量 x ∈ s p a n ( L ) x\in{span(L)} xspan(L) x x x不必在格位上),其中 d i s t ( x , L ) &lt; α λ 1 ( L ) dist(x,L)&lt;\alpha\lambda_1(L) dist(x,L)<αλ1(L),如何寻找到一个向量 x ∈ L x\in{L} xL,使得满足 ∥ u − x ∥ = d i s t ( x , L ) \|u-x\|=dist(x,L) ux=dist(x,L)

定义9最短独立向量问题SIVP))给定 Z n Z^n Zn中秩为 d d d的格 L L L的一组基 B B B和一个近似参数 γ ≥ 1 \gamma\ge{1} γ1,如何寻找到一个非零向量 u 1 , u 2 , … , u d ∈ L u_1,u_2,\dots,u_d\in{L} u1,u2,,udL,使得满足 max ⁡ i = 1 , 2 , … , d ∥ u i ∥ = γ λ d ( L ) \max\limits_{i=1,2,\dots,d}\|u_i\|=\gamma\lambda_d(L) i=1,2,,dmaxui=γλd(L)

四.小结

I.大势所趋:
(1)量子密码理论——信息安全领域“军备竞赛”:
(2)各界对于后量子密码系统的实装需求迫切, 预计接下来未来几年将是实用化后量子密码学快速发展时期;
II.我们可以尝试接触的格密码相关方向:
(1)格理论和算法设计;(2)LWE密码方案设计;(3)全同态密码。

  • 74
    点赞
  • 235
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
当然,我可以帮你输出一篇Selenium学笔记。以下是一份简单的学笔记供参考: Selenium学笔记 Selenium是一款用于自动化Web应用程序测试的强大工具。它提供了一组丰富的API,可以与各种编程语言(如Python、Java、C#等)结合使用,以实现Web应用程序的自动化测试。 1. 安装和配置 首先,你需要安装Selenium库。如果你使用Python,可以使用以下命令安装: ``` pip install selenium ``` 安装完成后,你还需要下载并配置相应的浏览器驱动程序。Selenium支持各种浏览器,如Chrome、Firefox、Safari等。你可以在Selenium官方网站上找到相应的驱动程序下载链接。 2. 基本操作 Selenium提供了一系列方法来模拟用户在浏览器中的操作,如打开URL、点击元素、输入文本等。以下是一些常用的基本操作示例: - 打开浏览器并访问URL: ```python from selenium import webdriver driver = webdriver.Chrome() # 使用Chrome浏览器驱动 driver.get("https://www.example.com") # 打开指定URL ``` - 查找元素并操作: ```python element = driver.find_element_by_id("element_id") # 根据元素ID查找 element.click() # 点击元素 input_element = driver.find_element_by_name("input_name") # 根据元素名称查找 input_element.send_keys("Hello, World!") # 输入文本 ``` - 执行JavaScript代码: ```python driver.execute_script("window.scrollTo(0, document.body.scrollHeight);") # 滚动到页面底部 ``` 3. 高级操作 Selenium还提供了一些高级操作,如处理弹窗、切换窗口、等待元素加载等。以下是一些常用的高级操作示例: - 处理弹窗: ```python alert = driver.switch_to.alert # 切换到弹窗 alert.accept() # 接受弹窗 confirm = driver.switch_to.alert # 切换到确认框 confirm.dismiss() # 取消确认框 ``` - 切换窗口: ```python window_handles = driver.window_handles # 获取所有窗口句柄 driver.switch_to.window(window_handles[-1]) # 切换到最后一个窗口 ``` - 等待元素加载: ```python from selenium.webdriver.common.by import By from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC element = WebDriverWait(driver, 10).until( EC.presence_of_element_located((By.ID, "element_id")) ) ``` 4. 测试框架 Selenium还可以与测试框架(如Pytest、JUnit等)结合使用,以便更好地组织和管理测试用例。你可以使用测试框架提供的断言方法来验证测试结果。 ```python import pytest def test_example(): driver = webdriver.Chrome() driver.get("https://www.example.com") assert "Example Domain" in driver.title # 断言页面标题包含指定文本 driver.quit() ``` 以上是一份简单的Selenium学笔记,希望对你有所帮助。当然,Selenium还有很多其他功能和用法,你可以进一步深入学和探索。祝你学愉快!
评论 5
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值