方案描述

• KeyGen(\(\lambda\))：根据预设的加密方案的安全性，选择一个安全参数\(\lambda\)，安全参数的选择将影响密文模数\(q\)和密文多项式的最高次数\(N\)。在本文中，选择的参数满足128比特安全性。随机采样\(s \leftarrow \mathcal{R}_2\)，\(a \leftarrow \mathcal{U}_{q_L}\)和\(e \leftarrow\mathcal{X}\)。之后，计算私钥\(sk =s\)和公钥\(pk = (pk_1,pk_2) = ([-a\cdot s+te]_{q_L} , a)\)。

• KeySwitchGen(\(sk\))：模交换能够让同态乘法的次数增加，而模交换需要依赖模交换密钥，首先随机采样多项式\(a \leftarrow \mathcal{U}_{q_L}\)和\(e \leftarrow \mathcal{X}\)。然后输出\(ks = (ks_1, ks_2) \equiv ([-a \cdot s + te + sk\cdot sk]_{q_L} , a)\)作为模交换密钥。

• Enc(\(m,pk\))：给定输入消息\(m \in\mathcal{P}\)，首先选择三个随机多项式：\(u \leftarrow \mathcal{R}_2\)，\(e_1 \leftarrow \mathcal{X}\)和\(e_2 \leftarrow\mathcal{X}\)。然后加密器通过计算生成密文\(c\)：\(c=(c_1,c_2)\equiv([pk_1 \cdotu+te_1+m]_{q_L},[pk_2 \cdot u+te_2]_{q_L}) \in\mathcal{C}\)。

• Dec(\(c,sk\))：解密一个密文\(c\)，需要在对应的模数链层次\(l\)执行以下步骤：\(\mathrm{i)}\) 计算\(m' = [c_1 + c_2 \cdotsk]_{q_l}\)，以及\(\mathrm{ii)}\) 输出解密后的明文\(m = m' \pmod{t}\)。

计算模拟

给出模拟代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

def poly_mod_add(poly1, poly2, mod):
    """多项式模环加法"""
    # 确保 poly1 是较长的那个多项式
    if len(poly2) > len(poly1):
        poly1, poly2 = poly2, poly1
    # 将较短的多项式补零
    poly2 += [0] * (len(poly1) - len(poly2))
    # 对应系数相加并取模
    result = [(a + b) % mod for a, b in zip(poly1, poly2)]
    return result

def poly_mod_mult(poly1, poly2, mod, N):
    """多项式模环乘法"""
    # 初始化结果多项式
    result = [0] * (len(poly1) + len(poly2) - 1)
    # 对每个系数进行乘法和加法
    for i, a in enumerate(poly1):
        for j, b in enumerate(poly2):
            result[i + j] += a * b
            result[i + j] %= mod
    for i in range(N):
        try:
            result[i] = (result[i] - result[i+N]) % mod
        except:
            break
    return result[0:N]

def poly_mult_number(poly, num,mod):
    for i in range(len(poly)):
        poly[i] = (poly[i] * num) %mod
    return poly


def Gen_pk(a,s,t,e,mod,N):
    pk1 = poly_mod_mult(a,s,mod,N)
    pk1 = poly_mult_number(pk1,-1,mod)
    pk1 = poly_mod_add(pk1,poly_mult_number(e,t,mod),mod)
    pk2 = a
    return [pk1,pk2]

def Enc(pk,m,u,mod,N):
    pk1 = pk[0]
    pk2 = pk[1]
    c1 = poly_mod_mult(pk1,u,mod,N)
    c1 = poly_mod_add(c1,m,mod)
    c1 = poly_mod_add(c1,poly_mult_number(e1,t,mod),mod)

    c2 = poly_mod_mult(pk2,u,mod,N)
    c2 = poly_mod_add(c2,poly_mult_number(e2,t,mod),mod)
    return [c1,c2]

def dec(c,sk,mod,N,t):
    temp = poly_mod_mult(c[1],sk,mod,N)
    temp = poly_mod_add(c[0],temp,mod)
    for i in range(len(temp)):
        temp[i] = temp[i] % t
    return temp
# 示例使用
m = [-1,2]  # 表示 2+x
a = [1, 1]     # 表示 1+x
s = [1]
e = [2,3]
t = 5
u = [0,1]
e1 = [3,4]
e2 = [5,6]
mod = 133            # 模数
N = 2

# # 计算多项式模环加法
# add_result = poly_mod_add(poly1, poly2, mod)
# print("多项式加法结果:", add_result)
# 计算多项式模环乘法
print("原始明文:",m)
pk = Gen_pk(a,s,t,e,mod,N)
sk = s
print("公钥pk1:", pk[0])
print("公钥pk2:", pk[1])
c = Enc(pk,m,u,mod,N)
print("密文c1:", c[0])
print("密文c2:", c[1])
result = dec(c,sk,mod,N,t)
print("解密后的多项式",result)

加密模拟

sympy

• sympy.mod_inverse(a,p)：模p下的逆元
• sympy.totient(37)：输出某个数的Euler函数
• sympy.gcd_list([4,6])：求最大公因数

基础知识

单位根与分圆多项式

• 有一个域\(F\),元素\(\omega \in F\)如果满足\(\omega^m \equiv1\),那么w是m次单位根，如果找不到一个比\(m\)更小的数\(m’\)，使得\(\omega^{m'} \equiv1\)是F中最小次数的根，那么\(\omega\)称为m次单位原根。

• 如果\(\omega\)是m次原单位根，那么有如下两条性质

  • 性质1：对于唯一的一个\(j \in\mathbb{Z}_m\)每一个m次单位根都能被写为\(\omega^j\)，这是因为\(\omega^{jm} \equiv1\)，所以也是m次单位根。
  • 性质2：对于唯一的一个\(j \in\mathbb{Z}^*_m\)，每一个m次单位原根都能被写为\(\omega^j\)。这是因为\(\omega^j\)是m次单位根，其次找不到比m还小的值使得\(\omega^{jm} \equiv1\)成立（假设d|m，那么\(\omega^{d} \neq1\)从而\(\omega^{jd} \neq1\)，因为j和d互素，jd必不可能是m的倍数）。

• 假设\(\omega = e^{2\pii/m}\)是复数域的m次根，定义分圆多项式： \[\Phi_m(X):=\prod\limits_{j\in\mathbb{Z}_m^*}(X-\omega^j)\in\mathbb{C}[X].\] 有如下性质:

  • 分圆多项式有多项式次数\(\phi(m)\)，j的个数是与m互素的个数
  • \(\Phi_m(X)\in\mathbb{Z}[X]\)
  • 分圆多项式在有理数域上不可约
  • \(X^m-1=\prod\limits_{d|m}\Phi_d(X)\)以及他的变式\(\Phi_m(X)=\dfrac{X^m-1}{\prod\limits_{d\midm}\Phi_d(X)}\)。显然，如果m是个素数p，那么\(\Phi_{p}(x)=\frac{x^{p}-1}{x-1}=\sum^{p-1}_{i=0}{x^i}\)

规范嵌入和无穷范数

基本思想：定义\(\mathcal{A}:=\mathbb{Z}[X]/(\Phi_m(X))\)，\(\omega\)是一个m次单位原根，有一个多项式\(a=[f(X)\text{mod}\Phi_m(X)]\in\mathcal{A}\)，我们可以清晰的定义\(\boldsymbol{a}(\omega^j):=f(\omega^j)\)，而不用在乎\(f(X)\)的具体取值(因为模了一个分圆多项式)。

• 规范嵌入：多项式\(a\in\mathcal{A}\)的规范嵌入是一个向量

\[\operatorname{cannon}(\boldsymbol a):=\Big(\boldsymbola(\omega^j)\Big)_{j\in\mathbb Z_m^*}.\]

• 无穷范数：使用常见的无穷范数作为多项式\(a\in\mathcal{A}\)的大小（size），取规范嵌入后向量元素的最大值即可

\[\quad\|\boldsymbol a\|:=\|\mathrm{cannon}(\boldsymbol a)\|_\infty =\max\{|\boldsymbol a(\omega^j)|:j\in\mathbb Z^*_m\},\]

编码——拉格朗日插值

目前的困境：BGV的明文为一个\(N-1\)次多项式m(x)，我们如何把\(N\)个数值\((a_0,a_1,\dots,a_{N-1})\)编码进一个明文多项式\(m_1(x)\)，另外N个数值\((b_0,b_1,\dots,b_{N-1})\)编码进多项式\(m_2(x)\)。使得当明文多项式做多项式乘法后\(m(x) = m_1(x)*m_2(x)\)，解码\(m(x)\)得到的是对应数值的点乘形式\((a_0*b_0,a_1*b_1,\dots,a_{N-1}*b_{N-1})\)

先介绍一下拉格朗日插值：

假设我们有一些已知点 \((x_i,y_i)\)，我们想要找到一个函数 \(f(x)\)，它在这些点上与 \(y_i\)相等，同时在这些点之间光滑连续。拉格朗日插值的想法是使用一个多项式来近似这个函数，多项式的系数可以通过在这些点上求解一系列的线性方程来获得。

下面是一个使用拉格朗日插值计算多项式的示例。假设我们有三个点 \((0, 1)\)，\((1,2)\) 和 \((2,3)\)。我们可以使用一个二次多项式来近似这些点，形式为 \(f(x) = a + bx +cx^2\)。我们可以通过求解以下三个方程来确定多项式的系数： \[\begin{matrix}f(0)=a+0b+0c=1\\ f(1)=a+1b+1c=2\\f(2)=a+2b+4c=3\end{matrix}\]

通过求解这些方程，我们可以得到多项式的系数 \(a = 1\)，\(b =1\) 和 \(c =-\frac{1}{2}\)。因此，我们的多项式为 \(f(x) = 1 + x - \frac{1}{2}x^2\)。

现在，我们可以将上述思想扩展到任意数量的点。具体来说，我们要使用一个\(n-1\) 次多项式来拟合 \(n\) 个已知点。设 \((x_i, y_i)\) 是这些已知点中的第 \(i\) 个点，我们的多项式可以写成以下形式：\[f(x)=\sum_{i=1}^ny_iL_i(x)\quad\text{}\]

其中 \(L_i(x)\)是拉格朗日基函数，定义为： \[L_i(x)=\prod_{j=1,j\neq i}^n\frac{x-x_j}{x_i-x_j}\]

这个基函数的作用是将多项式 \(f(x)\)在 \(x_i\) 处变为 \(y_i\)，同时在其他点处为零。因此，我们可以将多项式表示为所有基函数的线性组合。

解决方案：

假设多项式是在模\(q\)意义下进行的，我们预计算出一个\(N\)次原根\(\omega\)满足\(\omega^N \equiv 1 \mod{q}\)，我们选取N个点\[(\omega^0,a_0),(\omega^1,a_1),\dots,(\omega^{N-1},a_{N-1})\] 使用拉格朗日插值确定一个多项式\(m_1(x)\)，同理对另外N个点 \[(\omega^0,b_0),(\omega^1,b_1),\dots,(\omega^{N-1},b_{N-1})\] 确定另一个多项式\(m_2(x)\)，这样多项式乘法\(m(x) =m_1(x)*m_2(x)\)后，代入N个横坐标值\((\omega^0,\dots,\omega^{N-1})\)之后得到的纵坐标即为对应位数的点乘\((a_0*b_0,a_1*b_1,\dots,a_{N-1}*b_{N-1})\)

注意：

• 为什么要选取\(N\)次原根\(\omega\) ?因为有良好的性质，即\((\omega^0,\dots,\omega^{N-1})\)在模q意义下每个数都各不相同（如果相同那么\(\omega\)不是\(N\)次原根）
• 如何找\(N\)次原根\(\omega\)?首先找到一个模q的原根g，然后使用快速幂运算去计算\(g^{(q-1)/N}\)即可得到\(\omega\)

seal库参数设置

先看seal库源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

const map<size_t, vector<Modulus>> &GetDefaultCoeffModulus128()
            {
                static const map<size_t, vector<Modulus>> default_coeff_modulus_128{
                    /*
                    Polynomial modulus: 1x^1024 + 1
                    Modulus count: 1
                    Total bit count: 27
                    */
                    { 1024, { 0x7e00001 } },

                    /*
                    Polynomial modulus: 1x^2048 + 1
                    Modulus count: 1
                    Total bit count: 54
                    */
                    { 2048, { 0x3fffffff000001 } },

                    /*
                    Polynomial modulus: 1x^4096 + 1
                    Modulus count: 3
                    Total bit count: 109 = 2 * 36 + 37
                    */
                    { 4096, { 0xffffee001, 0xffffc4001, 0x1ffffe0001 } },

                    /*
                    Polynomial modulus: 1x^8192 + 1
                    Modulus count: 5
                    Total bit count: 218 = 2 * 43 + 3 * 44
                    */
                    { 8192, { 0x7fffffd8001, 0x7fffffc8001, 0xfffffffc001,                               0xffffff6c001, 0xfffffebc001 } },

                    /*
                    Polynomial modulus: 1x^16384 + 1
                    Modulus count: 9
                    Total bit count: 438 = 3 * 48 + 6 * 49
                    */
                    { 16384,
                      { 0xfffffffd8001, 0xfffffffa0001, 0xfffffff00001, 0x1fffffff68001, 0x1fffffff50001,
                        0x1ffffffee8001, 0x1ffffffea0001, 0x1ffffffe88001, 0x1ffffffe48001 } },

                    /*
                    Polynomial modulus: 1x^32768 + 1
                    Modulus count: 16
                    Total bit count: 881 = 15 * 55 + 56
                    */
                    { 32768,
                      { 0x7fffffffe90001, 0x7fffffffbf0001, 0x7fffffffbd0001, 0x7fffffffba0001, 0x7fffffffaa0001,
                        0x7fffffffa50001, 0x7fffffff9f0001, 0x7fffffff7e0001, 0x7fffffff770001, 0x7fffffff380001,
                        0x7fffffff330001, 0x7fffffff2d0001, 0x7fffffff170001, 0x7fffffff150001, 0x7ffffffef00001,
                        0xfffffffff70001 } }
                };

                return default_coeff_modulus_128;
            }

这是BGV的128bit安全性参数设置，随着模多项式的次数\(n\)不同，对应的密文模数的大小\(log(q)\)也有调整，具体的公式可以按照下面的方法计算：\[\lambda \approx -log(\cfrac{A*log(q)}{n})\cfrac{Bn}{logq} +C\sqrt{\cfrac{logq}{n}}log(\cfrac{n}{log(q)})\]

BGV噪声变化

NTT快速数论变换原理

多项式相乘的困难

假设有多项式A(x)，一共有n项,最高次项为\(x^{n-1}\),设其系数为\(a =(a[0],a[1],\cdots,a[n-1])\)，类似的假设另一个多项式B(x),设其系数为\(b =(b[0],b[1],\cdots,b[n-1])\)，如果想要将两个多项式相乘，很明显一共要乘\(n^2\)次，能不能减少乘法的次数，使其复杂度比\(O(n^2)\)更少呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14

void RingMultiplier::mulModBarrett(uint64_t& r, uint64_t a, uint64_t b, uint64_t p, uint64_t pr) 
{
unsigned __int128 mul = static_cast<unsigned __int128>(a) * b;
uint64_t abot = static_cast<uint64_t>(mul);//只会返回a*b的低64位
uint64_t atop = static_cast<uint64_t>(mul >> 64);//得到a*b的高64位
unsigned __int128 tmp = static_cast<unsigned __int128>(abot) * pr;
tmp >>= 64;
tmp += static_cast<unsigned __int128>(atop) * pr;
tmp >>= kbar2 - 64;
tmp *= p;
tmp = mul - tmp;
r = static_cast<uint64_t>(tmp);
if(r >= p) r -= p;
}

背景

国密算法介绍

国密即国家密码局认定的国产密码算法。主要有SM1，SM2，SM3，SM4。密钥长度和分组长度均为128位。

• SM1为对称加密。其加密强度与AES相当。该算法不公开，调用该算法时，需要通过加密芯片的接口进行调用。

• SM2为非对称加密，基于ECC。该算法已公开。由于该算法基于ECC，故其签名速度与秘钥生成速度都快于RSA。ECC256位（SM2采用的就是ECC 256位的一种）安全强度比RSA2048位高，但运算速度快于RSA。

• SM3消息摘要。可以用MD5作为对比理解。该算法已公开。校验结果为256位。

• SM4无线局域网标准的分组数据算法。对称加密，密钥长度和分组长度均为128位。

由于SM1、SM4加解密的分组大小为128bit，故对消息进行加解密时，若消息长度过长，需要进行分组，要消息长度不足，则要进行填充。

SM2算法简介

SM2椭圆曲线公钥密码算法是我国自主设计的公钥密码算法，包括SM2-1椭圆曲线数字签名算法，SM2-2椭圆曲线密钥交换协议，SM2-3椭圆曲线公钥加密算法，分别用于实现数字签名密钥协商和数据加密等功能。SM2算法与RSA算法不同的是，SM2算法是基于椭圆曲线上点群离散对数难题，相对于RSA算法，256位的SM2密码强度已经比2048位的RSA密码强度要高。

sm2主要满足电子认证服务系统等应用需求。

椭圆曲线介绍

• 参考书籍

基本数学形式

椭圆曲线是下面方程的一组解： \[Y^2 = X^3 + AX + B\]这种类型的方程也被称为魏尔斯特拉斯方程，得名于19世纪对其进行广泛研究的数学家。下面给两个曲线的实例并画给出图片：\[E1 : Y^2 = X^3 − 3X + 3 \;and\; E2 : Y ^2 = X^3 − 6X + 5\]

实数域上椭圆曲线

加法运算

令E为如下椭圆曲线： \[Y ^2 = X^3 − 15X + 18.\] 点P = (7, 16) 和 Q = (1, 2)为椭圆曲线上的两点，并构成直线L:\[L : Y = \frac{7}{3}X − 1/3.\] 如下图所示，直线L和椭圆曲线E交于三个点P,Q,R

点R关于x轴对称得到R',我们定义椭圆曲线d上的加法运算, \[P \oplus Q = R',\]和我们通常理解的加法不同，这里的加法是在曲线上进行的，也就是说给出两个点，相加一定可以得到椭圆曲线上的第三个点R'，这个点就是加法的结果。

加法运算瓶颈——无穷远点O

还是按照上面的图片，我们尝试做这样的加法 \[R \oplus R'=?\]按照上一节的加法运算，直线RR‘应该和椭圆曲线交于三个点，但是这里没有第三个点，这时候该怎么办？数学家定义了一个无穷远点\(O\),并假设点\(O\)也在椭圆曲线上，这样RR'就能交于椭圆曲线的点\(O\)了,于是有 \[R \oplus R'=O.\] 基于无穷远点有这样的性质

• 无穷远点\(O\)和椭圆曲线上任意点P的连线一定是垂直于x轴的

结合之前的加法运算，于是有公式： \[P \oplus O = P\]这是不是很类似于一个零点，任何点加这个点都是其本身

除此之外，基于无穷远点还有如下性质 \[P + O = O + P = P \; for \;all\; P ∈ E\\P + (−P) = O \; for \;all\; P ∈ E\\(P + Q) + R = P + (Q + R) \; for \;all\;P, Q, R ∈ E\\P + Q = Q + P \; for \;all\; P, Q ∈ E\]四条公式分别代表Albel群(交换群)的4条性质：存在零元，存在逆元，结合律，交换律

加法运算公式

这里给一张图片，很好的讲述了加法的运算公式

减法运算公式

定义负数元的概念：如果椭圆曲线上的一个点P=(a,b)，那么点P的负数元为\(\ominus P = (a,-b)\)

这样定义有很好的性质：

• \(P\ominus P = O\)

相当于实数域加减法的相反数的概念。

有限域上椭圆曲线

有限域上椭圆曲线定义

从上一节的介绍上可以看到，椭圆曲线上的加法运算构成一个群，所有的点可以是小数，也可以整数。那我们能不能加以限制，令椭圆曲线上的点全部都集中在某个域中呢？

定义1.令\(p\)是一个奇素数，在有限域\(\mathbb{F}_p\)上的椭圆曲线有如下形式, \[E : Y ^2 = X^3 + AX + B \;with\; A, B \in \mathbb{F}_p \;satisfying\;4A^3 + 27B^2 \neq 0\] 这里\(4A^3 + 27B^2 \neq0\)是保证椭圆曲线上没有奇异点。

则定义在有限域上的椭圆曲线坐标是集合. \[E(\mathbb{F}_p) = \{(x, y) | x, y \in \mathbb{F}_p \; satisfying \; y^2= x^3 + Ax + B\}∪ \{O\}\]

一个例子,考虑下面的椭圆曲线： \[E(\mathbb{F}_{13}) : Y ^2 = X^3 + 3X + 8 \;over \;the \;field\;\mathbb{F}_{13}\] 我们取X=0,得到\(Y^2=8\pmod{13}\)，但我们解不出这个Y，因为方程无解

我们再取X = 1,得到\(Y^2=12\pmod{13}\)，解出两个解Y=5或者Y=8，那么得到在\(E(\mathbb{F}_{13})\)有两个点(1,5)和(1,8)

X遍历有限域\(\mathbb{F}_{13}\),我们可以用类似的方法得到下面所有点\[E(\mathbb{F}_{13}) = \{O,(1, 5),(1, 8),(2, 3),(2, 10),(9, 6),(9, 7),(12,2),(12, 11)\}\]

有限域上椭圆曲线运算

类似与实数域上的加法运算，有限域上椭圆曲线的运算，除法用模逆运算代替，所有运算均在有限域上进行（算完之后要模一个p）。这里还是举个例子

椭圆曲线： \[E(\mathbb{F}_p) = \{(x, y) | x, y \in \mathbb{F}_p \; satisfying \; y^2= x^3 + Ax + B\}∪ \{O\}\] 计算P=(9,7)和Q=(1,8)的和 $$ λ = (y_2 − y_1)/(x_2 − x_1) = (8 −7)/(1 − 9) = 1/(-8) = 1/5 = 5^{-1} =8\

x_3 = λ^2 − x_1 − x_2 = 64 − 9 − 1 = 54 = 2\ y_3 = λ(x_1-x_3)-y_1 =8*(9-2) - 7 = 49 = 10 $$ 最终得到P+Q=(2,10)

椭圆曲线的一些名词

椭圆曲线的阶

我们之前说到每个在有限域上的椭圆曲线都由有限个点组成。那么我们不禁要问：到底是多少个点？

首先，我们要定义一下在一个群有多少个点就叫做这个群的“阶”（order）【在此放上wiki关于order的解释】。

椭圆曲线\(E(\mathbb{F}_{13}) : Y ^2 = X^3 +3X + 8 \;over \;the \;field\;\mathbb{F}_{13}\)的阶为9，因为总共有9个点

椭圆曲线的基点

先介绍一下循环子群的概率，方便我们之后基点的讨论

数乘和循环子群

在实数域乘法的定义是： \[nP=\underbrace{P+P+⋯+P}_{n个p}\] 使用倍加运算可以实现，其时间复杂度我们之后再讨论

举个例子：

已知椭圆曲线 \[E(\mathbb{F}_p) = \{(x, y) | x, y \in \mathbb{F}_p \; satisfying \; y^2= x^3 + 3x + 8\}∪ \{O\}\] 取其上一点P(9,7)，其倍点运算为：

• P = (9,7)

• 2P = (9,6)

• 3P = (1,12)

• 4P = (9,7)

可以看出，点P运算4次还是点P，这就是循环子群的概念，可以看出点P的运算结果可以构成一个有限的集合，这种群算方式可以看成群的运算，从而构成循环子群。

基点的概念

可以看出基点就是椭圆曲线上的一个点，基点有一个阶n，点加运算n次即可得到再次得到基点。

基点的生成

基点可以构成一个循环子群，sm2椭圆加密就是在这个子群上进行运算。

假设椭圆曲线的阶为N，对于椭圆曲线上的每一个点，我们都有\(NP =O\)，同时基点G（其阶为n）也能构成一个元素个数的为n的子群，由群论的拉格朗日定理，一定有\(n|N\)，我们设置一个辅因子\(h =N/n\)，随机取椭圆曲线上的一点，可以看出点hP循环n次就是无穷远点，如果n为素数，那么点hp生成的子群阶就是n\[n*h*p = O\]通过下面的运算步骤，我们可以寻找到阶为n的椭圆曲线下的子群。

• 计算椭圆曲线的阶 N 。
• 选择一个阶为 n 的子群。n必须是素数且必须是 N 的因子。
• 计算辅因子 h=N/n 。
• 在曲线上选择一个随机的点 P 。
• 计算 G=hP 。
• 如果 G 是0，那么回到步骤4。否则我们就已经找到了阶为 n 和辅因子是 h的子群的基点。

sm2国密算法流程介绍

最详尽的算法流程步骤请参见这个pdf：sm2技术文档，本人在这里仅仅简单介绍一下流程和步骤，并讲解其中原理。其中流程中的一些符号不给予解释，文档里都有。

加密算法

• A1：用随机数发生器产生随机数k∈[1,n-1]；
• A2：计算椭圆曲线点C1=[k]G=(x1,y1)，按本文本第1部分4.2.8和4.2.4给出的细节，将C1的数据类型转换为比特串；
• A3：计算椭圆曲线点S=[h]PB，若S是无穷远点，则报错并退出；
• A4：计算椭圆曲线点[k]PB=(x2,y2)，将坐标x2、y2 的数据类型转换为比特串；
• A5：计算t=KDF(x2 ∥ y2, klen)，若t为全0比特串，则返回A1；
• A6：计算C2 = M ⊕ t；
• A7：计算C3 = Hash(x2 ∥ M ∥ y2)；
• A8：输出密文C = C1 ∥ C2 ∥ C3。

其中KDF为密钥派生函数，函数原型为KDF(z,klen)可以根据比特串z，和长度klen，从而输出一个长度为klen的比特串。

下面给一个流程图

加密算法原理的一些理解

• 为什么随机数k范围是[1,n-1]，因为如果k=n，那么[k]G =O，这样的点G是无法用坐标表示出来的，也无法参加后面的运算

• 真正的密文在C2里，想要获取C2，必须用密钥派生函数KDF得到比特串t的值，而想要得到t的值，又必须计算\([k]P_B\)，但是k是随机生成的，想要准确的获取k有两种方法。一种是从\([1,n-1]\)遍历，要知道这样的遍历需要计算\(n*(n-1)/2\)次加法运算，n一般是个很大的数（数量级为\(10^{78}\)），这种计算量算到宇宙毁灭也算不出来。另一种是解方程\([x]G=(x_1,y_1)\)，这就回到椭圆曲线上的困难问题ECDLP，所以想要解密是十分的困难。

• C2的长度为klen，即和密文的长度想当

• C3是哈希函数，更多的是为验证接受到的密文是否出现改动

解密算法

设klen为密文中C2的比特长度。 为了对密文C=C1 ∥ C2 ∥ C3进行解密，作为解密者的用户B应实现以下运算步骤：

• B1：从C中取出比特串C1，将C1的数据类型转换为椭圆曲线上的点，验证C1是否满足椭圆曲线方程，若不满足则报错并退出；
• B2：计算椭圆曲线点S=[h]C1，若S是无穷远点，则报错并退出；
• B3：计算[dB]C1=(x2,y2)，将坐标x2、y2的数据类型转 换为比特串；
• B4：计算t=KDF(x2 ∥ y2, klen)，若t为全0比特串，则报错并退出；
• B5：从C中取出比特串C2，计算M′ = C2 ⊕ t；
• B6：计算u = Hash(x2 ∥ M′ ∥ y2)，从C中取出比特串C3，若\(u \neq C3\)则报错并退出；
• B7：输出明文M′。

还是给出一个流程图

解密算法的一些理解

• 为什么计算\([d_B]C_1=[d_B*k]G\)即可得到加密流程中的(x2,y2)，要知道只有\([k]P_B=(x2,y2)\)，理由是：

密钥对的设定是有规则的，即\([d_B]G=P_B\)，所以这里可以等价。试想一下，想要根据公钥PB得到私钥\(d_B\)，又需要解一个ECDLP问题，sm2的安全性就基于此。

Python程序实现

sm2算法的实现有专门的库gmssl，调用其中的库即可实现加解密。

这里仿照gmssl库做出了一些改进，实现了sm2的加解密。

其中椭圆曲线参数的设定和基点的选择参照官方技术文档

1
2
3
4
5
6

基点G的阶:     FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123
素数p:        FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF
基点G横坐标:   32c4ae2c1f1981195f9904466a39c9948fe30bbff2660be1715a4589334c74c7
基点G纵坐标:   bc3736a2f4f6779c59bdcee36b692153d0a9877cc62a474002df32e52139f0a0
椭圆曲线系数a: FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC
椭圆曲线系数b: 28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93

代码实现如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218

import binascii
from random import choice
from gmssl import sm3,func
import base64
# 选择素域，设置椭圆曲线参数

default_ecc_table = \
{
    'n': 'FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123',
    'p': 'FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF',
    'g_x': '32c4ae2c1f1981195f9904466a39c9948fe30bbff2660be1715a4589334c74c7',
    'g_y': 'bc3736a2f4f6779c59bdcee36b692153d0a9877cc62a474002df32e52139f0a0',
    'a': 'FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC',
    'b': '28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93',
}

# default_ecc_table = \
# {
#     'n': '1',
#     'p': 'D',
#     'g_x': '1',
#     'g_y': '1',
#     'a': '3',
#     'b': '8',
# }

class CryptSM2(object):

    def __init__(self, private_key, public_key, ecc_table=default_ecc_table):
        #初始化函数，需要输入公钥和私钥
        self.private_key = private_key
        self.para_len = len(ecc_table['n'])
        self.public_key = self.Str_coordinate_to_jacobian(public_key)
        self.ecc_a3 = (
            int(ecc_table['a'], base=16) + 3) % int(ecc_table['p'], base=16)
        self.ecc_table = ecc_table

    def double_point(self, Point):  # 倍点
        l = len(''.join(Point)) #计算点的16进制长度 
        len_2 = 2 * self.para_len
        x1 = int(Point[0], 16)
        y1 = int(Point[1], 16)
        z1 = int(Point[2], 16)

        p = int(self.ecc_table['p'], base=16)
        #使用计算倍点的公式
        T6 = (z1 * z1) % p
        T2 = (y1 * y1) % p
        T3 = (x1 + T6) % p
        T4 = (x1 - T6) % p
        T1 = (T3 * T4) % p
        T3 = (y1 * z1) % p
        T4 = (T2 * 8) % p
        T5 = (x1 * T4) % p
        T1 = (T1 * 3) % p
        T6 = (T6 * T6) % p
        T6 = (self.ecc_a3 * T6) % p
        T1 = (T1 + T6) % p
        z3 = (T3 + T3) % p
        T3 = (T1 * T1) % p
        T2 = (T2 * T4) % p
        x3 = (T3 - T5) % p

        if (T5 % 2) == 1:
            T4 = (T5 + ((T5 + p) >> 1) - T3) % p
        else:
            T4 = (T5 + (T5 >> 1) - T3) % p

        T1 = (T1 * T4) % p
        y3 = (T1 - T2) % p

        form = '%%0%dx' % self.para_len
        return (form % x3, form % y3, form % z3)

    def add_point(self, P1, P2):  # 点加函数，P2点为仿射坐标即z=1，P1为Jacobian加重射影坐标
        p = int(self.ecc_table['p'], base=16)
        X1 = int(P1[0], 16)
        Y1 = int(P1[1], 16)
        Z1 = int(P1[2],16)

        x2 = int(P2[0], 16)
        y2 = int(P2[1], 16)

        T1 = (Z1 * Z1) % p
        T2 = (y2 * Z1) % p
        T3 = (x2 * T1) % p
        T1 = (T1 * T2) % p
        T2 = (T3 - X1) % p
        T3 = (T3 + X1) % p
        T4 = (T2 * T2) % p
        T1 = (T1 - Y1) % p
        Z3 = (Z1 * T2) % p
        T2 = (T2 * T4) % p
        T3 = (T3 * T4) % p
        T5 = (T1 * T1) % p
        T4 = (X1 * T4) % p
        X3 = (T5 - T3) % p
        T2 = (Y1 * T2) % p
        T3 = (T4 - X3) % p
        T1 = (T1 * T3) % p
        Y3 = (T1 - T2) % p


        form = '%%0%dx' % self.para_len
        
        return (form % X3, form % Y3, form % Z3)

    def kp(self, k_int, Point_xy):  
        # kP运算，即k倍点的运算函数
        Point = Point_xy
        k = k_int
        mask_str = '8'
        for i in range(self.para_len - 1):
            mask_str += '0'
        mask = int(mask_str, 16)
        Temp = Point
        flag = False
        for n in range(self.para_len * 4): #每个16进制4个bit
            if (flag):
                Temp = self.double_point(Temp)
            if (k & mask) != 0: #用与操作判断k的最高位是否为0
                if (flag):
                    Temp = self.add_point(Temp, Point)
                else:
                    flag = True
                    Temp = Point
            k = k << 1
        return self._convert_jacb_to_nor(Temp)
    
    def _convert_jacb_to_nor(self, Point): # Jacobian加重射影坐标转换成仿射坐标
        len_2 = 2 * self.para_len
        x = int(Point[0], 16)
        y = int(Point[1], 16)
        z = int(Point[2], 16)
        p = int(self.ecc_table['p'], base=16)
        z_inv = pow(z, p - 2, p)
        z_invSquar = (z_inv * z_inv) % p
        z_invQube = (z_invSquar * z_inv) % p
        x_new = (x * z_invSquar) % p
        y_new = (y * z_invQube) % p
        z_new = (z * z_inv) % p
        if z_new == 1:
            form = '%%0%dx' % self.para_len
            
            return (form % x_new, form % y_new, form % z_new)
        else:
            return None

    def encrypt(self, data_str):
        # 加密函数，data消息字符串
        data = data_str.encode() #将消息转化为bytes流
        msg = data.hex() # 消息转化为16进制字符串
        G = (self.ecc_table['g_x'],self.ecc_table['g_y'],"1")
        k = 2#int(func.random_hex(self.para_len),16) #1.产生随机数k \in [1,n-1]
        C1 = self.kp(k,G) #2.计算[k]G = (x1,y1)
        C1 = self._convert_jacb_to_nor(C1)
        C1 = C1[0]+C1[1]
        xy = self.kp(k,self.public_key) #3.计算点s = [k]pk
        x2 = xy[0]
        y2 = xy[1]
        m_len = len(msg)
        t = sm3.sm3_kdf((x2+y2).encode('utf8'), m_len/2)#5.计算t = KDF(x2||y2,klen)
        if int(t,16)==0:
            return None
        else:
            form = '%%0%dx' % m_len #两个百分号代表%
            C2 = form % (int(msg, 16) ^ int(t, 16)) #6.计算C2 = M 异或 t，C2的长度理应为消息M的长度
            C3 = sm3.sm3_hash([
                i for i in bytes.fromhex('%s%s%s'% (x2,msg,y2))#7.计算哈希函数C3 = Hash(x2 || M || y2)
            ])
            return bytes.fromhex('%s%s%s' % (C1,C3,C2))

    def decrypt(self, data):
            # 解密函数，data密文（bytes）
            data = data.hex()
            len_2 = 2 * self.para_len
            len_3 = len_2 + 64 
            C1 = self.Str_coordinate_to_jacobian(data[0:len_2]) #1.提取出C1,并转化为坐标点
            C3 = data[len_2:len_3]
            C2 = data[len_3:]
            xyz = self.kp(int(self.private_key,16),C1)#3.计算[sk]C1 = (x2,y2)
            xy = self._convert_jacb_to_nor(xyz)
            # print('xy = %s' % xy)
            x2 = xy[0]
            y2 = xy[1]
            cl = len(C2)
            t = sm3.sm3_kdf((x2+y2).encode('utf8'), cl/2)#4.计算t = KDF(x2||y2,klen)
            if int(t, 16) == 0:
                return None
            else:
                form = '%%0%dx' % cl
                M = form % (int(C2,16) ^ int(t,16))#5.恢复明文M = C2 异或 t
                u = sm3.sm3_hash([
                    i for i in bytes.fromhex('%s%s%s'% (x2,M,y2))
                ])
                return bytes.fromhex(M)
    
    def Str_coordinate_to_jacobian(self,Point_str):
        Point = Point_str
        x = Point[0:self.para_len]
        y = Point[self.para_len:2*self.para_len]
        z = "1"
        return (x,y,z)

if __name__ == "__main__":
    # sm2的公私钥
    SM2_PRIVATE_KEY = '00B9AB0B828FF68872F21A837FC303668428DEA11DCD1B24429D0C99E24EED83D5'
    SM2_PUBLIC_KEY = 'B9C9A6E04E9C91F7BA880429273747D7EF5DDEB0BB2FF6317EB00BEF331A83081A6994B8993F3F5D6EADDDB81872266C87C018FB4162F5AF347B483E24620207'
    operator = CryptSM2(SM2_PRIVATE_KEY,SM2_PUBLIC_KEY)
    c = operator.encrypt("网络空间安全")
    print(base64.b64encode(c))
    result = operator.decrypt(c).decode(encoding="utf-8")
    print(result)

    # n = int(default_ecc_table['n'],16)
    # G = operator.Str_coordinate_to_jacobian(SM2_PRIVATE_KEY)
    # print(operator.kp(n,G))
    

背景介绍

DH(Diffie-Hellman)算法

DH算法用于在不安全的公共通道中协商密钥，安全性体现在：在有限域上计算离散代数非常困难。上两位大牛WhitfieldDiffie 和 Martin Hellman的照片：

算法描述：

假定Alice和Bob期望在一个不安全的网络中协商一个共同的密钥，那么进行如下步骤：

• 两人先说好大素数（质数）p和它的原始根g。
• Alice随机产生一个数a，并计算\(y_A = g^a\mod p\), 发送给Bob。
• Bob随机产生一个数b，并计算\(y_B= g^b \modp\)，发送给Alice。

此时， Alice手握Bob发过来的\(y_B\)，结合自己产生的a，开始这样计算：

\(y_B^a \mod p = (g^b \mod p)^a \mod p =g^{ab} \mod p\)。

Bob也拿到了Alice发来的\(y_A\)，同时结合自己的b，也开始计算：

\(y_A^b \mod p = (g^a \mod p)^b \mod p =g^{ab} \mod g\)。

这样Alice和Bob都得到了相同的密钥。

EIGamal诞生

ElGamal算法是由Tather ElGamal在1985年提出的，它是一种基于离散对数难题的加密体系，与RAS算法一样，既能用于数据加密，也能用于数字签名。ElGamal算法是基于因数分解，而ElGamal算法是基于离散对数问题。与RSA算法相比，ElGamal算法哪怕是使用相同的私钥，对相同的明文进行加密，每次加密后得到的签名也各不相同，有效的防止了网络中可能出现的重放攻击。

• 原文的链接：[Apublic key cryptosystem and a signature scheme based on discretelogarithms](https://ieeexplore.ieee.org/abstract/document/1057074/)

这篇论文在谷歌学术上被引用了将近10000次，可以说有想当广泛的影响力，大家如果有时间可以欣赏一下作者是怎么行文的，EIGamal加密算法十分的简单，看看作者是如何将其扩充到9页，也是一种锻炼自己的方式嘿嘿。

基于离散对数的数学难题

基本描述

如果对于一个整数y和质数p的一个原根g，可以找到一个唯一的指数x，使得：

$y=g^x $其中 \(0≤x≤p−2\)成立，那么指数x称为y的以g为基数的模p的离散对数。

离散对数难题是指：当已知一个大质数p和它的一个原根g，如果给定一个y，要计算x的值是相当困难的。

针对不合理参数的破解方法

当质数满足\(p =2^n+1\)

当\(p =2^n+1\),x可以被转化成二进制序列\(\{b_0,\dots,b_{n-1}\}\),其中\(b_i\in \{0,1\}\),有如下等式 \[x = \sum_{i=0}^{n-1}{b_i*2^i}\] 注意到，因为g是模数p的一个原根，所以集合\(\{g^i|i\in[0,p-2]\}=\{1,\dots,p-1\}\),两个集合即两个集合应该相等，由Euler小定理:\[g^{p-1} \equiv 1 \pmod{p}\] 那么对方程开方: \[g^{(p-1)/2} \equiv -1 \pmod{p}\] 为什么不是等于1呢，因为已经有\(g^0=1\)了，\(g^{(p-1)/2}\)不能和\(g^0\)相等（集合\(\{g^i|i\in[0,p-2]\}\)等于素数p的既约剩余系），所以只能等于-1

有了上面的基础，我们可以简单推导出下面的公式 \[y^{(p-1)/2} \equiv (g^x)^{(p-1)/2} \equiv (-1)^x \pmod{p}\] 根据x的二进制序列，当x的最低位

• \(b_0=0\)时，\(y^{(p-1)/2} \equiv 1 \pmod{p}\)
• \(b_0=1\)时，\(y^{(p-1)/2} \equiv -1 \pmod{p}\)

由此我们可以确定第一位\(b_0\)的值，我们继续令\(z \equiv y*g^{(-b_0)}\equiv g^{x_1}\pmod{p}\),这里 \[x_1 = \sum_{i=1}^{n-1}b_i*2^i\] 如果\(b_1=0\)那么\(x_1\)是4的倍数而不是2的倍数，有下面的等式\[z^{(p-1)/4} \pmod{p} \equiv\begin{equation} \begin{cases} +1,b_1=0\\ -1,b_0=1 \end{cases}\end{equation}\] 由此我们有可以判断一位\(b_1\)，以此类推，我们可以完全复原密文x

当p没有大素数因子

EIGamal流程介绍

密钥产生

• 选取一个强素数\(p\)，而且满足\(p-1\)至少有一个很大的质因数（如果因子很小那么计算离散对数很简单）
• 素数\(p\)的一个本原根\(g\)
• 随机选取整数\(a\)

产生一个公钥\(pk =(p,g,g^a)\)，私钥是随机选取的整数a

加密

假设Alice想发送一个密文m给Bob

• 随机选取一个数\(k\in[1,p-2]\)
• 计算\(c_1 = g^k \mod p\)
• 再计算\(c_2 = (g^a)^k*m \modp\)

如此就计算出了密文，这是一对数\((c_1,c_2)\)，并将其发送给Bob

解密

Bob讲密文恢复成明文m

• 计算\(v \equiv c_1^a\pmod{p}\)
• 计算\(m \equiv c_2*v^{-1}\pmod{p}\)

证明：

\(m \equiv c_2*v^{-1} \pmod{p} \equivm*g^{ak}*(g^{ak})^{-1} \pmod{p} \equiv m \pmod{p}\)

python程序实现

参数生成

强素数满足p-1至少有一个大因子，可以用Crypto.Util.number里的函数getStrongPrime()，这样可以直接产生一个非常强的素数。但是这样有几个问题：

• 这个函数随机生成的强素数的bit位数必须是128的倍数而且大于512。一方面导致了计算时间的增大，令一方面如果p太大可能导致不安全（比如\(g^a \mod p\)可能在数值上就等于\(g^a\)，而有些同学喜欢默认为原根就是2,3,5中的几个，如果a取的不是很大，我们可以直接开方，如果是整数那么这个就是我们要的a）
• 这个素数因为有大因子，在验证g是原根的时候，这几个大因子寻找十分困难，以至于时间很长很长

下面给出一个解决方案：

我们只需要p-1有一个大因子就行了，我们默认大因子为素数q和数字2，这样就有关系p= 2*q+1,如此一来，我们只需要验证p-1的两个因子即可判断是不是原根

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

def Gen_primitive_root(p,q):
    #产生一个本原根，产生方法，从2，3，... ，p-1逐个选取
    #选到2的时候，选取phi(p)的几个非1因子，比如phi(11)=10,10有因子2，5
    #如果2的2次方和5次方都不等于1，那么一定2的10次方等于1，这时候2为本原根
    #但，这样真的很慢很慢

    while True:
        candidate_root = random.randint(2,p-2)
        #按照Gen_para生成的素数p只有两个素因子2和q
        if gmpy2.powmod(candidate_root,2,p)!=1 and  gmpy2.powmod(candidate_root,q,p)!=1:
            return candidate_root     
        
def Gen_para(m):
    digit = len(str(m))
    while True:
        #这里是一个坑，尽量吧q的范围扩大一点，这样有更大的几率让2*q+1是一个素数
        q = sympy.randprime(10**digit, 10**(digit+1))
        p = 2 * q + 1
        if sympy.isprime(q):
            if  gmpy2.is_prime(p):
                break
    g = Gen_primitive_root(p,q)
    a = random.randint(2 , p-2)
    return [p,g,pow(g,a,p)],a

加解密实现

参数生成了之后加解密就没什么好说的了

1
2
3
4
5
6
7
8
9
10
11

def encrypt(m,pk):
    k = random.randint(1,p-2)
    print("参数k的值为:%d"%k)
    c1 = pow(g,k,p)
    c2 = (pow(g_a,k,p) * m)%p
    return  c1,c2 

def decrypt(c1,c2,sk):
    v = pow(c1,sk,p)
    m = c2*sympy.invert(v,p) % p
    return m

完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

import random
import gmpy2
import sympy

def Gen_primitive_root(p,q):
    #产生一个本原根，产生方法，从2，3，... ，p-1逐个选取
    #选到2的时候，选取phi(p)的几个非1因子，比如phi(11)=10,10有因子2，5
    #如果2的2次方和5次方都不等于1，那么一定2的10次方等于1，这时候2为本原根
    #但，这样真的很慢很慢

    while True:
        candidate_root = random.randint(2,p-2)
        #按照Gen_para生成的素数p只有两个素因子2和q
        if gmpy2.powmod(candidate_root,2,p)!=1 and  gmpy2.powmod(candidate_root,q,p)!=1:
            return candidate_root          

def Gen_para(m):
    digit = len(str(m))
    while True:
        #这里是一个坑，尽量吧q的范围扩大一点，这样有更大的几率让2*q+1是一个素数
        q = sympy.randprime(10**digit, 10**(digit+1))
        p = 2 * q + 1
        if sympy.isprime(q):
            if  gmpy2.is_prime(p):
                break
    g = Gen_primitive_root(p,q)
    a = random.randint(2 , p-2)
    return [p,g,pow(g,a,p)],a

def encrypt(m,pk):
    k = random.randint(1,p-2)
    print("参数k的值为:%d"%k)
    c1 = pow(g,k,p)
    c2 = (pow(g_a,k,p) * m)%p
    return  c1,c2 

def decrypt(c1,c2,sk):
    v = pow(c1,sk,p)
    m = c2*sympy.invert(v,p) % p
    return m


if __name__ == "__main__":
    file_name = "secret0.txt"
    f = open(file_name)
    m = int(f.readline())
    pk , sk = Gen_para(m)
    p,g,g_a = pk
    print("素数p为%d"%p)
    print("原根g为%d"%g)
    print("参数g^a为%d"%g_a)
    c1 , c2 = encrypt(m,pk)
    print("密文c1为%d"%c1)
    print("密文c2为%d"%c2)
    m_d = decrypt(c1,c2,sk)
    if m == m_d:
        print("解密正确")

原文：Twenty Years ofAttacks on the RSA Cryptosystem

作者：Dan Boneh@Stanford University(dabo@cs.stanford.edu)

译者：Harper

参考链接：

• Coppersmith相关攻击 - CTF Wiki
• 二十年以来对 RSA密码系统攻击综述

背景介绍

RSA密码系统由Ron Rivest, Adi Shamir和LenAdleman发明，在1977年8月的《科学美国人》杂志上首次公布。密码系统最常用于提供隐私和确保数字数据的真实性。目前，RSA被部署在许多商业系统中。它被网络服务器和浏览器用来保护网络传输，它被用来确保电子邮件的私密性和真实性，它被用来保护远程登录会话，它是电子信用卡支付系统的核心。简而言之，RSA常用于需要考虑数字数据安全性的应用程序中。

RSA加密算法

我们遵循标准命名约定，使用Alice和Bob表示希望相互通信的两个通用方。我们使用Marvin来表示恶意的攻击者，希望窃听或篡改Alice和Bob之间的通信。

参数设置

• 两个质数\(p和q\)，再计算得到\(N = p*q\)
• 一个随机整数\(e\in (1,φ(N))\),再计算\(d \equiv e^{-1}\pmod{\varphi(N)}\)
• 公钥pk = <N,e>
• 私钥sk = <N,d>

参数生成方法

第一步，随机选择两个不相等的质数p和q。

Alice选择了61和53。（实际应用中，这两个质数越大，就越难破解。）

第二步，计算p和q的乘积N。

Alice就把61和53相乘。

N = 61×53 = 3233

N的长度就是密钥长度。3233写成二进制是110010100001，一共有12位，所以这个密钥就是12位。实际应用中，RSA密钥一般是1024位，重要场合则为2048位。

第三步，计算N的欧拉函数φ(N)。

N是质数，则 φ(N)=N-1 N = p1 × p2 φ(N) = φ(p1p2) = φ(p1)φ(p2) =>φ(N) = (p-1)(q-1)

Alice算出φ(3233)等于60×52，即3120。

第四步，随机选择一个整数e，条件是1< e < φ(N)，且e与φ(N)互质。

Alice就在1到3120之间，随机选择了17。（实际应用中，常常选择65537。）

第五步，计算e对于φ(N)的模反元素d。

所谓”模反元素”就是指有一个整数d，可以使得ed被φ(N)除的余数为1,故\(d \equiv e^{-1} \pmod{\varphi(N)}\)

ed ≡ 1 (mod φ(N))

这个式子等价于

ed - 1 = kφ(N)

于是，找到模反元素d，实质上就是对下面这个二元一次方程求解，使用拓展欧几里得算法即可

ex + φ(N)y = 1

第六步，将N和e封装成公钥，N和d封装成私钥。

在Alice的例子中，N=3233，e=17，d=2753，所以公钥就是(3233,17)，私钥就是（3233, 2753）。

实际应用中，公钥和私钥的数据都采用ASN.1格式表达。

加密

密文是一个整数m属于乘法群\(\mathbb{Z^*_{N}}\)，即\(m \in \mathbb{Z^*_{N}}\)

计算密文ciphertext简称c，需要用到公钥pk=<N,e>

\(c \equiv m*e \pmod{N}\)

Alice的公钥是 (3233,17)，Bob的m假设是65，那么可以算出下面的等式：

65^17 ≡ 2790 (mod 3233)

于是，c等于2790，Bob就把2790发给了Alice。

参数生成的效率

RSA密钥对的生成方法是随机选取两个\(\cfrac{n}{2}\)位素数并将其相乘得到N。然后，对于给定的加密$e < (N)\(，使用扩展欧氏算法计算\)de^{-1} $。

由于素数集非常密集，因此可以快速生成一个随机的\(\cfrac{n}{2}\)位素数，方法是选取随机的\(\cfrac{n}{2}\)位整数并用概率素数检验(如Fermat素性检验法)来检验每个整数的素数。

总体来说，生成素数还是比较快的，openssl生成一个1024位的素数在毫秒级即可实现。

解密

Alice拿到Bob发来的2790以后，就用自己的私钥(3233, 2753)进行解密。可以证明，下面的等式一定成立：

\(m \equiv c^d \pmod{N}\)

也就是说，c的d次方除以N的余数为m。现在，c等于2790，私钥是(3233,2753)，那么，Alice算出

2790^2753 ≡ 65 (mod 3233)

因此，Alice知道了Bob加密前的原文就是65。

解密正确性的证明

这里需要使用Euler定理,即

如果正整数 n 和整数 a 互质，那么就有 \(a^{\varphi(n)}≡1\pmod{n})\)其中欧拉函数 φ(n) 是「小于 n 的正整数中和 n互质的数」的个数

下面进入正式的证明过程

\[c^d \equiv (m^e)^d \equiv m^{ed} \\\because e*d \equiv 1 \pmod{\varphi(N)} \\\therefore e*d=k*\varphi(N)+1 \; where \; k \in \mathbf{Z} \\\therefore m^{ed} \equiv m^{k*\varphi(N)+1} \equiv m^{k*\varphi(N)} *m\pmod{N} \\with\;the \; help \; of \; Euler \;theorem:m^{\varphi(N)} \equiv1\pmod{N}\\so: \; m^{ed} \equiv m^{k*\varphi(N)+1} \equiv m^{k*\varphi(N)} *m\equiv 1*m\equiv m \pmod{N}\]

安全性分析

数学难题-大整数的素数分解

我们可以看到，如果不知道d，就没有办法从c求出m。而前面已经说过，要知道d就必须分解N，这是极难做到的，因为至今为止大整数的素数分解依然是一个难题，所以RSA算法保证了通信安全

语义安全-semantic security

RSA不是一个语义安全的加密算法，所谓语义安全，我们不能从密文中获得任何关于明文的信息，比如一段话的第一个字母，一段话中某个数字出现的次数等等。

拿RSA举例，我们可以很简单的获得m在N上的雅各比符号

基本攻击

我们首先描述一些老的基本攻击，这些攻击说明了RSA的公然滥用情况。虽然存在许多这样的攻击，但我们仅举两个例子。

Common modulus-共模

为了避免为每个用户生成不同的模数\(N=p*q\)，人们可能希望一劳永逸地固定使用一个\(N\)，所有用户都使用相同的\(N\)。可信的中央机构可以向用户提供唯一的一对参数\(<e_i,d_i>\)，用户从其中生成公钥\(<N,e_i>\)和私钥\(<N,d_i>\)。

乍一看，这似乎行得通：为Alice准备的密文\(c= m^{e_a} \pmod{N}\)无法由Bob解密，因为Bob不知道\(d_a\)。但是，这是不正确的，由此产生的系统是不安全的。事实上，Bob可以使用他自己的指数\(<e_b,d_b>\)来分解模数\(N\)。一旦被分解，Bob就可以从她的公钥中计算出Alice的私钥。Simmons的这一观察结果表明，RSA模不应被一个以上的实体使用。

Blinding-盲化

设\(<N,d>\)是Bob的私钥，而\(<N,e>\)是相应的公钥。假设攻击者Marvin想要Bob的签名\(m^d_{Bob} \pmod{N} \in\mathbb{Z^{\ast}_N}\)。当然Bob不傻，他拒绝签署。但是Marvin可以尝试以下方法：他随机选择一个\(r \in \mathbb{Z^{\ast}_N}\)并设\(m' =r^e*m_{Bob}\)。然后他让Bob在随机消息\(m'\)上签名。Bob可能愿意在看上去没什么问题的上签名，但是回想一下\(S'=(m')^d\mod{N}\)，Marvin现在简单地计算\(S =S'/r\)就得到Bob在初始上的签名\(S\)。

事实上： \[S^e = (S')^e/(r^e)=(M')^{ed}/r^e \equiv M'/r^e = M \pmod{N}\]这种称为盲化的技术使Marvin能够在他选择的消息上获得有效的签名，方法是让Bob在随机的"盲化"消息上签名。Bob不知道他实际在签名的是什么消息。由于大多数签名方案在签名之前对消息应用"单向散列"算法，因此此种攻击倒不是一个严重的问题。尽管我们将盲化描述为一种攻击，但它实际上是实现匿名数字现金所需的一个有用属性(可以用来购买商品的现金，但不会透露购买者的身份）

Low PrivateExponent-低解密指数攻击

理论

解密使用参数d，如果d非常小，那么可以用此方法进行解密。

Theorem 2 (M. Wiener) 令 \(N = pq\) ，这里 \(q < p < 2q\) . 如果$ d < 1/3N^{1/4}$ 。 给定私钥对\(<N,e>\)，这里\(e*d = 1 \mod{\varphi(N)}\) ,Marvin 可以快速的复原参数 \(d\).

证明详见论文《TWENTY YEARS OF ATTACKS ON THE RSACRYPTOSYSTEM》

最后给出结论： \[\left| \cfrac{e} {N} - \cfrac{k} {d} \right| \le \cfrac{1} {dN^{1/4} }< \cfrac{1} {2d^2} \\这里k满足：k\varphi(N)-ed=1\]

这是一个经典的逼近关系，两个分数在约束内非常逼近。首先\(k\varphi(N)-ed=1\),所以\(gcd(k,d)=1\)，即k和d互素，分数\(\cfrac{k}{d}\)是一个最简分数。虽然d很小，但也只是相对于N（1024bits）比较小，实际上d也有上百比特的长度，所以\(\cfrac{1}{2d^2}\)是一个很小的数，由上面的不等式得到\(\cfrac{e} {N}\)是很接近于\(\cfrac{k} {d}\)的。大致的思路就是在\(\cfrac{e}{N}\)附近寻找一个小数，把小数按照分数的形式展开，分母就是我们想要找的参数\(d\)，但实际上并没有这么简单(论文中使用连分数展开)。

由于通常都是1024位，因此\(d\)必须至少256位长才能避免这种攻击。这对于诸如"智能卡"之类的低功耗设备来说是不幸的，因为小就能节省大量能耗。然而，并不是毫无办法。Wiener提出了许多能够实现快速解密并且不易受其攻击影响的技术

代码

使用python库owiener实现

1
2
3
4
5
6
7
8
9
10
11

import owiener
e = 3047442173541658754667464233797118324917469250436575767227172319344577259865313428705759330024959317716760816959590728238918140105663188172228696589411452947738069773833351725455888549656717874059636289036277785342126992626060696063089487811946920569580454880169977542532087635095357205433679009382368108273

n = 135568509670260054049994954417860747085442883428459182441559553532993752593294067458983143521109377661295622146963670193783017382697726454953197805014428888491744355387957923382241961401063461549210355871385000347645387907568135032087942016502668629010859519249039662555733548461551175133582871220209515648241

d = owiener.attack(e, n)

m=123123123123123123123123123123123113212312312312
c = pow(m,e,n)
m_decrypted = pow(c,d,n)
print(m_decrypted)

计算得到d的值为

1

22299128035876669298809061693021648003426573977341841609779417036458441464337

计算d的位数大概是254位,符合上面的分析，运算时间也是很快，用python基本秒出答案。

Low PrivateExponent-低加密指数攻击

为了减少加密或签名验证时间，习惯上使用一个小的公共指数。 e的最小可能值为3，但为了击败某些攻击，建议使用\(e = 2^{16} + 1 =65537\)。当使用65537时，签名验证需要 17 次乘法，而使用随机 \(e < \varphi(N)\) 时大约需要 1000次乘法。所以对使用小e的攻击连绵不绝。

Coppersmith理论

对低公共指数 RSA 最有效的攻击是基于 Coppersmith的一个定理。Coppersmith定理有很多应用，这里只介绍其中的一部分。想要破解RSA，实际上可以看成一个解决函数零点的问题：\[x^e \equiv c \pmod{N}\]解出这个函数，就是我们想要做的事情，后面关于多项式环的论述也都是基于这个思想。

前置定理

首先介绍一个理论：

Theorem 3 (Coppersmith) Let N be an integer and\(f \in \mathbb{Z}[x]\) be a monicpolynomial of degree d. Set $X = N ^{ {d}- } $ for some \(\epsilon \ge 0\). Then, given $ < N , f> $ Marvin can effciently find all integers $| x_0 | < X $satisfying $f (x_0 ) = 0 $. The running time is dominated by the time ittakes to run the LLL algorithm on a lattice of dimension O (w ) with\(w = min(\frac{1} {\epsilon},log_2N)\).

该定理提供了一种算法，可以有效地找方程\(f(x) \equiv 0 \pmod{N}\) 的所有小于 $X =N^{} $的根

再给出一个引理：

首先我们定义范数的概念，给出多项式\(h(x)=\sum{a_ix^i} \in\mathbb{Z}\),定义范数\(\|h\|^2 =\sum{|a_i|^2}\)

Lemma 4 Let \(h(x) \in \mathbb{Z}\) be a polynomial ofdegree d and let X be a positive integer. Suppose $|h(xX )| < $ . If\(|x_0| < X\) satisfies \(h(x_0) = 0 \mod{N}\) , then \(h(x_0) = 0\) holds over theintegers.

这个引理告诉我们：如果满足前置条件，\(f(x) \equiv 0 \pmod{N}\)的根，也是\(f(x)=0\)在整数域上的根，但实际上函数\(f(x)\)一般都没有这么小的范数能满足前置条件。我们可以构造一个函数\(h(x)=g(x)*f(x)\)，这个函数\(h(x)\)应该有比较小的范数来满足前置条件。这相当于一个问题，找到\(f(x),xf(x),x^2f(x),\dots,x^rf(x)\)的一个线性组合，这个线性组合就是函数\(h(x)\)，且有较低的范数。

解决方案

前面我们介绍过，想要找到函数\(h(x)\)，实际上就是找一个线性组合，DanBoneh在论文中叙述了一个基于格中LLL算法的解决方案。大家可以细看论文(作者关于格的理论已经忘得差不多了)，以后咱再补充。

Hastad广播攻击

所谓广播，就是一个人把消息发给很多人，这里我们假设假设 Bob希望将加密消息 M 发送给多个参与方 $P_1, P_2, ,P_K $。每一方都有自己的RSA 密钥 \(pk=<N_i,e_i>\)。我们假设 M 小于所有的\(N_i\)，即\(M<min(N_1,N2, \dots ,N_K)\)。为了发送 M，天真的Bob 使用每个公钥对其进行加密，并将第 i个密文发送给 第i个参与方\(P_i\)。攻击者Marvin 可以在 Bob 视线之外窃听连接并收集 k 个被传输的密文。

为了便于大家理解，我们举一个例子来说明：

我们假定所有公共指数\(e_i=3\)，如果参与方的个数\(K \ge3\)那么marvin可以破解出明文M，事实上破解只需解下面一个方程即可：\[\begin{equation} \begin{cases} C_1 \equiv M^3 \mod{N_1}\\ C_2 \equiv M^3 \mod{N_2}\\ C_3 \equiv M^3 \mod{N_3} \end{cases}\end{equation}\] 这里假定\(gcd(N_i,N_j)=1\)，即任意两个N之间互素，否则我们可以用\(N_i/N_j\)很简单的求出他们的公因子，从而复原出\(p和q\)，这个假定是有意义的。对于上面的方程，我们使用中国剩余定理(CRT)解出结果即为明文。

实验环境

• 电脑：联想拯救者R9000p
• cpu：AMD Ryzen 7 5800H
• 内存：16GB
• 操作系统：windows11
• python版本：3.10

目标：

• 掌握python基本函数库的使用
• 熟悉抽象代数的基本定理如Fermat小定理的使用
• 理解Fermat素性检验的原理，并编程实现
• 测试一些大数，以一定概率检验其素性

Fermat素性检验介绍

背景

费马素性检验是一种素数判定法则，利用随机化算法判断一个数是合数还是可能是素数。

Fermat小定理

\[对\forall(a,p)=1,p为质数\\\exists a^{p-1} \equiv 1 \pmod{p}\]

证明：

\(\{1,2,3,4...p-1\}\)是p的既约剩余系

\(\because a,p\)互质

\(\therefore \{a*1 , a*2 , a*3 , a*4,\dots,a*(p-1)\}\)也为p的既约剩余系

\(\therefore 1*2*3 \dots*(p-1)≡a*2*a*3*a......(p-1)*a \pmod{p}\)

化简得\(a^{p-1} \equiv 1\pmod{p}\)

Fermat素性检验基本原理

根据费马小定理：如果p是素数，\(1\leq a \leq p-1\)

那么 \[a^{p-1} \equiv 1 \pmod{p}\]如果我们想知道n是否是素数，我们在中间选取a，看看上面等式是否成立。

• 如果对于数值a等式不成立，那么n是合数。
• 如果有很多的a能够使等式成立，那么我们可以说n可能是素数，或者伪素数。

在我们检验过程中，有可能我们选取的a都能让等式成立，然而n却是合数，所以最终得到的结果是，我们以一定概率确定p是否为素数

Fermat素性检验流程

给定奇整数 \(m\geq3\) 和安全参数\(k=5\) （1） 随机选取整数\(a\),令\(2\leq a\leq m-2\) （2） 计算\(g=(a,m)\)，如果\(g=1\)，转（3）；否则，跳出，m为合数 （3） 计算\(r=a^{m-1}\pmod{m}\)，如果r=1,m可能是素数，转（1）；否则，跳出，m为合数（4） 重复上述过程k次，如果每次得到m可能为素数，则m为素数的概率为\(1- \frac1{2^k}\) 。

python代码

需要导入math模块求最大公因数

需要导入random模块来产生随机数

求\(r=a^{m-1}\pmod{m}\)必须使用pow(a,num-1,num)函数一边乘法一边取模运算速度较快，不能先算\(a^{m-1}\)再取模，否则时间太长算不出来

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import math
import random
def is_prime(num, k=7):
    for _ in range(k):
        a=random.randrange(2,num-2)
        if math.gcd(a, num)!=1:
            return False, 1-(0.2)**k
        if pow(a,num-1,num)!=1:
            return False , 1-(0.2)**k
    return True , 1-(0.2)**k
m1 = 743476040059754298379331647007684224429004972336533937786799284757790400765316630522369642718204165253922832684184615021404737105614714107158733905598636152327037707290538422718453498125366750918857659068838460954633737911274770976191590193809661578032117496009853673140977556559136466107768672598883924301125589893895001253674886100289402530711221893
m2 = 5434520625653357625890820149570485819447986258433769976634917091398967074086679540928507095017715540385352266035820823142060119390272763774034231321959236056764511968630360067353876686142517564224926196131349204754111599877101485686283117193149781387816214484583521923017500621725053392290279263586984207169423800476914654441473576611460323772832328657
m3 = 876147742992673125957404768949712978720573116974723188491435550196169965040848206868200084918233743662847668000971402407461887306389122707315529364807593342507936022301657320206278702095378618110195051280478534126716517153056984269659532882692418682262081495725304483536777013188527470348249542840277926802938912332306310470632601156641005608958891
m4 = 9876147742992673125957404768949712978720573116974723188491435550196169965040848206868200084918233743662847668000971402407461887306389122707315529364807593342507936022301657320206278702095378618110195051280478534126716517153056984269659532882692418682262081495725304483536777013188527470348249542840277926802938912332306310470632601156641005608958891

result , pr = is_prime(m4)
if result:
    print("该数以",pr*100,"%的概率判定为素数")
else:
    print("该数不是素数")

最近需要写一些文档，里面会有大量的公式，写出好看的公式的过程真的很治愈:cat:,这一期博客主要来介绍一些常用的latex公式，内容很干。自己用markdown写的公式，渲染出来都是对的，但是放到博客上不知道怎么回事有一些奇奇怪怪的错误，大家直接粘贴代码就行。

参考： https://artofproblemsolving.com/wiki/index.php/LaTeX:Symbolshttps://artofproblemsolving.com/wiki/index.php/LaTeX:Commands

各种类型的符号表

数集符号

操作符

关系符号

关系符号前面加一个n，就可以变成这些关系符号的反义

希腊字母

一些大写的希腊字母

箭头

一些奇奇怪怪的点

字母上的强调符号

当对 \(i\)和\(j\)应用强调符号时，可以使用：

和 有一个更宽的版本，\(\hat{7+x}\)和\(\widehat{7+x}\)两种箭头是有区别的：

其他一些奇怪的符号

括号

In mathematics, sometimes we need to enclose expressions in brackets,braces or parentheses. Some of these work just as you'd imagine inLaTeX; type ( and ) for parentheses, [ and ] for brackets, and | and |for absolute value. However, other symbols have special commands:

编写数学公式

下标和上标

下标和上标（例如指数）可以分别使用下划线_和箭头^符号。

分式

使用来进行渲染

如果分号比较多，建议用，看起来更大也舒服很多

1
2
3
4

\begin{matrix}
    1&0\\
    0&1
\end{matrix}

1
2
3
4

\begin{pmatrix}
    1&0\\
    0&1
\end{pmatrix}

1
2
3
4

\begin{bmatrix}
    1&0\\
    0&1
\end{bmatrix}

1
2
3
4

\begin{Bmatrix}
    1&0\\
    0&1
\end{Bmatrix}

1
2
3
4

\begin{vmatrix}
    1&0\\
    0&1
\end{vmatrix}

1
2
3
4

\begin{Vmatrix}
    1&0\\
    0&1
\end{Vmatrix}

1
2
3
4
5
6
7

$$
\begin{bmatrix}
a_{11} & \dots & a_{1n}\\
&\ddots & \vdots \\
a_{n1}& & a_{nn}
\end{bmatrix}
$$

1
2
3
4
5
6

$$
\begin{bmatrix}
\begin{matrix}1&0\\0&1\end{matrix}& \text{\Large 0}\\
\text{\Large 0}&\begin{matrix}1&0\\0&1\end{matrix}
\end{bmatrix}
$$

1
2
3
4
5
6
7
8

$$
\begin{bmatrix}
a_{11}&a_{12} & \dots & a_{1n}\\
&a_{22}&\dots&a_{2n}\\
&&\ddots&\vdots\\
&{\huge 0}&&a_{nn}
\end{bmatrix}
$$

1
2
3
4
5
6
7
8
9
10

$$
\begin{equation}
    \begin{cases}
        l_{11}y_{1} = 1 \\
        l_{21}y_{1} + l_{22}y_{2} = 0 \\ 
        l_{31}y_{1} + l_{32}y_{2} + l_{33}y_{3} = 0 \\
        l_{41}y_{1} + l_ {42}y_{2} + l_{43}y_{3} + l_{44}y_{4} = 0
     \end{cases}
\end{equation}
$$

opensssl库是常用的加密函数库，主要有以下加密算法

加密算法

• 对称加密：指加密和解密使用相同密钥的加密算法。对称加密算法的优点在于加解密的高速度和使用长密钥时的难破解性。常见的对称加密算法：DES、3DES、DESX、AES、RC4、RC5、RC6等
• 非对称加密：指加密和解密使用不同密钥的加密算法，也称为公私钥加密。常见的非对称加密算法：RSA、DSA（数字签名用）等
• Hash算法：Hash算法它是一种单向算法，用户可以通过Hash算法对目标信息生成一段特定长度的唯一的Hash值，却不能通过这个Hash值逆向获得目标信息。常见的Hash算法：MD2、MD4、MD5、SHA、SHA-1等

下面介绍openssl库的安装

安装方法

打开命令行终端

新手的话按ctrl+alt+t即可

更新/下载编译器 make 和 gcc

1
2
3

sudo apt install make gcc
sudo apt update
sudo apt upgrade

下载OpenSSL安装包

以版本openssl-1.1.1q版本为例，想要其他版本请到官网下载指定版本：

1

sudo wget https://www.openssl.org/source/openssl-1.1.1b.tar.gz

解压缩

1

sudo tar -zxf openssl-1.1.1b.tar.gz && cd openssl-1.1.1b

编译安装

1
2
3

sudo ./config shared
sudo make
sudo make install

修改默认路径

1
2

sudo ln -s /usr/local/bin/openssl /usr/bin/openssl
sudo ldconfig

检查版本

1

openssl version

如果到这一步能输出版本信息

结果测试

测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include<stdio.h>
#include<sys/time.h>
#include<openssl/bn.h>
struct timeval timestart, timeend ;
float timeuse_encrypt = 0 , timeuse_decrypt = 0, timeuse_add = 0 , timeuse_mul = 0 , timeuse = 0 ;
int main()
{   BN_CTX *ctx = BN_CTX_new();
    BN_CTX_start(ctx);
    BIGNUM *r1 = BN_CTX_get(ctx);
    BIGNUM *r2 = BN_CTX_get(ctx);
    BIGNUM *n = BN_CTX_get(ctx);
    BIGNUM *tmp = BN_CTX_get(ctx);
    BIGNUM *dv = BN_CTX_get(ctx);
    BIGNUM *rem = BN_CTX_get(ctx);
    BN_rand(r1, 236896 , 0, 0);
    BN_rand(r2, 236896 , 0, 0);
    BN_rand(n, 236896 , 0, 0);
    
    gettimeofday(&timestart, NULL);//160*236896
    BN_mod_mul(tmp , r1 , r2 , n  , ctx);//a mod q = a/q*q
    gettimeofday(&timeend, NULL);
    timeuse = 1000000 * (timeend.tv_sec - timestart.tv_sec) + timeend.tv_usec - timestart.tv_usec;
    printf("\nmod mul time:%f ms\n", timeuse / 1000);
    
    gettimeofday(&timestart, NULL);//160*236896
    BN_mul(tmp , r1 , r2  , ctx);//a mod q = a/q*q
    gettimeofday(&timeend, NULL);
    timeuse = 1000000 * (timeend.tv_sec - timestart.tv_sec) + timeend.tv_usec - timestart.tv_usec;
    printf("\nmul time:%f ms\n", timeuse / 1000);

    gettimeofday(&timestart, NULL);//160*236896
    BN_div(dv , rem , tmp ,n , ctx);//r1*r2/n
    gettimeofday(&timeend, NULL);
    timeuse = 1000000 * (timeend.tv_sec - timestart.tv_sec) + timeend.tv_usec - timestart.tv_usec;
    printf("\ndiv time:%f ms\n", timeuse / 1000);
    
    gettimeofday(&timestart, NULL);//160*236896
    BN_mod(tmp , tmp , n  , ctx);//r1*r2/n mod q = a/q*q
    gettimeofday(&timeend, NULL);
    timeuse = 1000000 * (timeend.tv_sec - timestart.tv_sec) + timeend.tv_usec - timestart.tv_usec;
    printf("\nmod time:%f ms\n", timeuse / 1000);
    BN_CTX_end(ctx);
    BN_CTX_free(ctx);
    return 0;
}

编译运行

输入如下指令可以编译运行

1
2

gcc test.c -lcrypto
./a.out

可以看到如下输出结果

这学期学习现代密码学，密码的各种加密方式有很多细节，还有大体的框架，浅浅做个笔记记录一下，以后可以随时回顾。

参考博客：

• AES加密算法的详细介绍与实现
• AES五种加密模式（CBC、ECB、CTR、OCF、CFB)

DES

AES

AES简介

高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下图： 下面简单介绍下各个部分的作用与意义：

• 明文P

没有经过加密的数据。

• 密钥K

用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。密钥为接收方与发送方协商产生，但不可以直接在网络上传输，否则会导致密钥泄漏，通常是通过非对称加密算法加密密钥，然后再通过网络传输给对方，或者直接面对面商量密钥。密钥是绝对不可以泄漏的，否则会被攻击者还原密文，窃取机密数据。

• AES加密函数

设AES加密函数为E，则C = E(K,P),其中P为明文，K为密钥，C为密文。也就是说，把明文P和密钥K作为加密函数的参数输入，则加密函数E会输出密文C。

• 密文C

经加密函数处理后的数据

• AES解密函数

设AES解密函数为D，则 P = D(K,C),其中C为密文，K为密钥，P为明文。也就是说，把密文C和密钥K作为解密函数的参数输入，则解密函数会输出明文P。

在这里简单介绍下对称加密算法与非对称加密算法的区别。

• 对称加密算法

加密和解密用到的密钥是相同的，这种加密方式加密速度非常快，适合经常发送数据的场合。缺点是密钥的传输比较麻烦。

• 非对称加密算法

加密和解密用的密钥是不同的，这种加密方式是用数学上的难解问题构造的，通常加密解密的速度比较慢，适合偶尔发送数据的场合。优点是密钥传输方便。常见的非对称加密算法为RSA、ECC和EIGamal。

实际中，一般是通过RSA加密AES的密钥，传输到接收方，接收方解密得到AES密钥，然后发送方和接收方用AES密钥来通信。

本文下面AES原理的介绍参考自《现代密码学教程》，AES的实现在介绍完原理后开始。

AES的基本结构

AES为分组密码，分组密码也就是把明文分成一组一组的，每组长度相等，每次加密一组数据，直到加密完整个明文。在AES标准规范中，分组长度只能是128位，也就是说，每个分组为16个字节（每个字节8位）。密钥的长度可以使用128位、192位或256位。密钥的长度不同，推荐加密轮数也不同，如下表所示：

轮数在下面介绍，这里实现的是AES-128，也就是密钥的长度为128位，加密轮数为10轮。上面说到，AES的加密公式为C =E(K,P)，在加密函数E中，会执行一个轮函数，并且执行10次这个轮函数，这个轮函数的前9次执行的操作是一样的，只有第10次有所不同。也就是说，一个明文分组会被加密10轮。AES的核心就是实现一轮中的所有操作。

AES的处理单位是字节，128位的输入明文分组P和输入密钥K都被分成16个字节，分别记为：

\(P = P0\;P1 \dots P15\)

\(K = K0\;K1 \dots K15\)

如，明文分组为P =abcdefghijklmnop,其中的字符a对应P0，p对应P15。一般地，明文分组用字节为单位的正方形矩阵描述，称为状态矩阵。在算法的每一轮中，状态矩阵的内容不断发生变化，最后的结果作为密文输出。该矩阵中字节的排列顺序为从上到下、从左至右依次排列，如下图所示：

现在假设明文分组P为"abcdefghijklmnop"，则对应上面生成的状态矩阵图如下：上图中，0x61为字符a的十六进制表示。可以看到，明文经过AES加密后，已经面目全非。

• 128位密钥也是用字节为单位的矩阵表示，矩阵的每一列被称为1个32位比特字。
• 通过密钥编排函数该密钥矩阵被扩展成一个44个字组成的序列\(W[0],W[1], …,W[43]\),序列中每个元素的大小为32bit
• 该序列的前4个元素\(W[0],W[1],W[2],W[3]\)是原始密钥，用于加密运算中的初始密钥加（下面介绍）
• 后面40个字分为10组，每组4个字（128比特）分别用于10轮加密运算中的轮密钥加，如下图所示： 上图中，设K = “abcdefghijklmnop”，则\(K0 = a, K15 = p, W[0] = K0 |K1| K2 |K3 =“abcd”\)。

AES的整体结构如下图所示，其中的W[0,3]是指W[0]、W[1]、W[2]和W[3]串联组成的128位密钥。加密的第1轮到第9轮的轮函数一样，包括4个操作：字节代换、行位移、列混合和轮密钥加。最后一轮迭代不执行列混合。另外，在第一轮迭代之前，先将明文和原始密钥进行一次异或加密操作。上图也展示了AES解密过程，解密过程仍为10轮，每一轮的操作是加密操作的逆操作。由于AES的4个轮操作都是可逆的，因此，解密操作的一轮就是顺序执行逆行移位、逆字节代换、轮密钥加和逆列混合。同加密操作类似，最后一轮不执行逆列混合，在第1轮解密之前，要执行1次密钥加操作。

下面分别介绍AES中一轮的4个操作阶段，这4分操作阶段使输入位得到充分的混淆。

AES加解密具体流程

字节代换

把该字节的高4位作为行值，低4位作为列值，取出S盒中对应的元素作为输出

字节代换操作

AES的字节代换其实就是一个简单的查表操作。AES定义了一个S盒和一个逆S盒。AES的S盒：

状态矩阵中的元素按照下面的方式映射为一个新的字节：把该字节的高4位作为行值，低4位作为列值，取出S盒或者逆S盒中对应的行的元素作为输出。例如，加密时，输出的字节S1为0x12,则查S盒的第0x01行和0x02列，得到值0xc9,然后替换S1原有的0x12为0xc9。状态矩阵经字节代换后的图如下：

字节代换逆操作

逆字节代换也就是查逆S盒来变换，逆S盒如下：

行移位

行移位操作

行移位是一个简单的左循环移位操作。当密钥长度为128比特时，状态矩阵的第0行左移0字节，第1行左移1字节，第2行左移2字节，第3行左移3字节，如下图所示：

行移位的逆变换

行移位的逆变换是将状态矩阵中的每一行执行相反的移位操作，例如AES-128中，状态矩阵的第0行右移0字节，第1行右移1字节，第2行右移2字节，第3行右移3字节。

列混合

列混合操作

列混合变换是通过矩阵相乘来实现的，经行移位后的状态矩阵与固定的矩阵相乘，得到混淆后的状态矩阵，如下图的公式所示：

状态矩阵中的第j列(0 ≤j≤3)的列混合可以表示为下图所示：

其中，矩阵元素的乘法和加法都是定义在基于\(GF(2^8)\)上的二元运算,并不是通常意义上的乘法和加法。这里涉及到一些信息安全上的数学知识，不过不懂这些知识也行。其实这种二元运算的加法等价于两个字节的异或，乘法则复杂一点。对于一个8位的二进制数来说，使用域上的乘法乘以(00000010)等价于左移1位(低位补0)后，再根据情况同(00011011)进行异或运算，设\(S1 = (a7 ,a6, a5, a4, a3, a2,a1,a0)\)，刚\(0x02 *S1\)如下图所示： $$ (00000010)* (a7 ,a6, a5, a4, a3, a2 ,a1,a0)=\[\begin{equation} \begin{cases} (a6, a5, a4, a3, a2 ,a1,a0) ,a_7 = 0\\ (a6, a5, a4, a3, a2 ,a1,a0) \oplus (00011011),a_7 = 1\\ \end{cases}\end{equation}\] $$

也就是说，如果a7为1，则进行异或运算，否则不进行。类似地，乘以(00000100)可以拆分成两次乘以(00000010)的运算： 乘以(0000 0011)可以拆分成先分别乘以(0000 0001)和(00000010)，再将两个乘积异或：

因此，我们只需要实现乘以2的函数，其他数值的乘法都可以通过组合来实现。下面举个具体的例子,输入的状态矩阵如下：

下面，进行列混合运算： 以第一列的运算为例： 其它列的计算就不列举了，列混合后生成的新状态矩阵如下：

列混合逆运算

逆向列混合变换可由下图的矩阵乘法定义： 可以验证，逆变换矩阵同正变换矩阵的乘积恰好为单位矩阵。

轮密钥加

轮密钥加是将128位轮密钥Ki同状态矩阵中的数据进行逐位异或操作，如下图所示。其中，密钥Ki中每个字W[4i],W[4i+1],W[4i+2],W[4i+3]为32位比特字，包含4个字节，他们的生成算法下面在下面介绍。轮密钥加过程可以看成是字逐位异或的结果，也可以看成字节级别或者位级别的操作。也就是说，可以看成S0S1 S2 S3 组成的32位字与W[4i]的异或运算。 轮密钥加的逆运算同正向的轮密钥加运算完全一致，这是因为异或的逆操作是其自身。轮密钥加非常简单，但却能够影响S数组中的每一位。

密钥扩展

AES首先将初始密钥输入到一个4*4的状态矩阵中，如下图所示。

• 这个4*4矩阵的每一列的4个字节组成一个字，矩阵4列的4个字依次命名为W[0]、W[1]、W[2]和W[3]，它们构成一个以字为单位的数组W。例如，设密钥K为"abcdefghijklmnop",则K0= ‘a’,K1 = ‘b’, K2 = ‘c’,K3 = ‘d’,W[0] = “abcd”。

• 接着，对W数组扩充40个新列，构成总共44列的扩展密钥数组。新列以如下的递归方式产生：

  • 1.如果i不是4的倍数，那么第i列由如下等式确定： \(W[i]=W[i-4]⨁W[i-1]\)

  • 2.如果i是4的倍数，那么第i列由如下等式确定： \(W[i]=W[i-4]⨁T(W[i-1])\)其中，T是一个有点复杂的函数。函数T由3部分组成：字循环、字节代换和轮常量异或，这3部分的作用分别如下。

    • a.字循环：将1个字中的4个字节循环左移1个字节。即将输入字[b0, b1, b2,b3]变换成[b1,b2,b3,b0]。
    • b.字节代换：对字循环的结果使用S盒进行字节代换。
    • c.轮常量异或：将前两步的结果同轮常量\(Rcon[j]\)进行异或，其中\(j\)表示轮数。轮常量\(Rcon[j]\)是一个字，其值见下表。

下面举个例子：

设初始的128位密钥为： 3C A1 0B 21 57 F0 19 16 90 2E 13 80 AC C1 07 BD那么4个初始值为： W[0] = 3C A1 0B 21 W[1] = 57 F0 19 16 W[2] = 90 2E 1380 W[3] = AC C1 07 BD

下面求扩展的第1轮的子密钥(W[4],W[5],W[6],W[7])。由于4是4的倍数，所以： W[4] = W[0] ⨁ T(W[3])

T(W[3])的计算步骤如下：

• 循环地将W[3]的元素移位：AC C1 07 BD变成C1 07 BD AC;
• 将 C1 07 BD AC 作为S盒的输入，输出为78 C5 7A 91;
• 将78 C5 7A 91与第一轮轮常量Rcon[1]进行异或运算，将得到79 C5 7A91，因此，T(W[3])=79 C5 7A 91，故 W[4] = 3C A1 0B 21 ⨁ 79 C5 7A 91 = 4564 71 B0 其余的3个子密钥段的计算如下： W[5] = W[1] ⨁ W[4] = 57 F0 19 16⨁ 45 64 71 B0 = 12 94 68 A6 W[6] = W[2] ⨁ W[5] =90 2E 13 80 ⨁ 12 94 68A6 = 82 BA 7B 26 W[7] = W[3] ⨁ W[6] = AC C1 07 BD ⨁ 82 BA 7B 26 = 2E 7B7C 9B 所以，第一轮的密钥为 45 64 71 B0 12 94 68 A6 82 BA 7B 26 2E 7B 7C9B。

AES解密

在文章开始的图中，有AES解密的流程图，可以对应那个流程图来进行解密。下面介绍的是另一种等价的解密模式，流程图如下图所示。这种等价的解密模式使得解密过程各个变换的使用顺序同加密过程的顺序一致，只是用逆变换取代原来的变换。

AES四种加密模式

分组密码有五种工作体制：1.电码本模式（Electronic Codebook Book(ECB)）；2.密码分组链接模式（Cipher Block Chaining(CBC)）；3.计算器模式（Counter (CTR)）；4.输出反馈模式（Output FeedBack(OFB)）。

电码本模式（ECB）

将整个明文分成若干段相同的小段，然后对每一小段进行加密

优点：

• 操作简单，易于实现；分组独立，易于并行；误差不会被传送。——简单，可并行，不传送误差。

缺点：

• 掩盖不了明文结构信息，难以抵抗统计分析攻击。——可对明文进行主动攻击。

密码分组链模式（CBC）

先将明文切分成若干小段，然后每一小段与初始块或者上一段的密文段进行异或运算后，再与密钥进行加密

优点：

• 能掩盖明文结构信息，保证相同密文可得不同明文，所以不容易主动攻击，安全性好于ECB，适合传输长度长的报文，是SSL和IPSec的标准。

缺点：

• 不利于并行计算；
• 传递误差——前一个出错则后续全错；
• 第一个明文块需要与一个初始化向量IV进行抑或，初始化向量IV的选取比较复杂。

初始化IV的选取方式：固定IV，计数器IV，随机IV（只能得到伪随机数，用的最多），瞬时IV（难以得到瞬时值）

IV是做什么用的呢？

初始向量IV（InitializationVector）它的作用和MD5的“加盐”有些类似，目的是防止同样的明文块始终加密成同样的密文块。

输出反馈模式（OFB）

密码算法的输出（指密码key而不是密文）会反馈到密码算法的输入中，OFB模式并不是通过密码算法对明文直接加密，而是通过将明文分组和密码算法的输出进行XOR来产生密文分组。

优点：

• 隐藏了明文模式；结合了分组加密和流密码（分组密码转化为流模式）；可以及时加密传送小于分组的数据。

缺点：

• 不利于并行计算；需要生成秘钥流；对明文的主动攻击是可能的。

计数器模式（CTR）

完全的流模式，将瞬时值与计数器连接起来，然后对此进行加密产生密钥流的一个密钥块，再进行XOR操作

优点：

• 不泄露明文；仅需实现加密函数；无需填充；可并行计算。

缺点：

• 需要瞬时值IV，难以保证IV的唯一性。

对比CBC和CTR

1）CBC需要填充；CTR不用填充。

2）CBC不可并行；CTR可并行速度快。

3）CBC需要实现加密和解密函数；CTR实现简单，仅需实现加密函数。

4）鲁棒性：CBC强于CTR——使用重复瞬时值，CBC会泄露初始明文块，CTR会泄露所有信息。

如果有好的瞬时值选择策略，采用CTR，否则采用CBC。

如加密成绩单，可选用CTR，因为学号唯一，可作为瞬时值。

由于在sgx中需要对超级大的整数进行操作，于是引入openssl库，下面是一些安装步骤，主要参考的了官方github给出的教程：

• intel/intel-sgx-ssl:Intel® Software Guard Extensions SSL (github.com)

所用的电脑配置

• 电脑：联想Thinkpad E14

• 操作系统：ubuntu18.04

• 处理器：i5-10210U

• 内存：8G

• 硬盘：1TB

• 在电脑BIOS中启用IntelSGX。重装系统不会更改BIOS中的设置，所以即使重装系统，IntelSGX也会一直保持启用状态。

• 安装如下工具：

  1	sudo apt-get install gcc git cpuid

正式开始配置

预备

• Perl
• Toolchain（需要的工具，参照我的上一个博客安装sgxsdk，执行下面的指令之后可以看到这些工具的路径）

1
2

sudo cp external/toolset/{current_distr}/{as,ld,ld.gold,objdump} /usr/local/bin
which as ld ld.gold objdump

• Intel SGX driver、SDK和PSW
• 准备好OpenSSL源码压缩包openssl-${version}.tar.gz。本博客使用的是openssl-1.1.1q版本，之前计划使用openssl-1.1.1p版本，但是编译的时候报错让我使用openssl-1.1.1q版本，随着时间的推移官方的更新可能之后还需要其他版本，大家自行辨别。

下载sgx-ssl项目

从GitHub拉取intel-sgx-ssl项目，这个网站也是可以访问的

1

git clone https://github.com/intel/intel-sgx-ssl

下载openssl压缩包

1
2

cd intel-sgx-ssl/openssl_source
wget https://openssl.org/source/openssl-1.1.1q.tar.gz

这样openssl-1.1.1q.tar.gz压缩包就到了/intel-sgx-ssl/openssl_source/目录下

编译并安装

我们现在在openssl_source目录，下面进入linux目录Linux/directory

1
2

cd ../Linux
source /opt/intel/sgxsdk/environment  //这里应填写sgx的安装路径，我的是/opt/intel/sgxsdk/

使得sgx开发环境生效。 无脑编译安装

1
2

make all test
sudo make install

安装完毕，可以在/opt/intel/sgxssl/找到编译好的库函数。

参考的文献&博客

• Intel(R)SGX环境在Ubuntu 18.04的安装 | 小木槌 (flxdu.cn)

• Ubuntu18.04安装Intel SGX 2.3.1

• Ubuntu16.04下Intel SGX SDK环境搭建（硬件不支持情况）

• github上非常非常详细的英语教程

主要参考了第一个博客，但是最最详细的是第四个github上的教程，只不过是全英文的有很多linux和sgx方面的专业名词对小白不是很友好。本人主要引用了第一个博客的内容，第一个博客的博主写的很详细，但是本人自己配置的时候还是出现了很多很多意想不到的问题，本博客针对可能出现的问题进行补充和说明。

本人所用的配置

电脑环境

由于现在用的电脑是锐龙处理器，而且没有trustzone，所以使用很久没用的、尘封已久的老、但是跟了我一年的老电脑。操作系统用的是ubuntu（鬼知道重装系统用了多久的时间），装完之后开机要很久，也不知道是不是坏了。

• 电脑：联想Thinkpad E14

• 操作系统：ubuntu18.04

• 处理器：i5-10210U

• 内存：8G

• 硬盘：1TB

• 在电脑BIOS中启用IntelSGX。重装系统不会更改BIOS中的设置，所以即使重装系统，IntelSGX也会一直保持启用状态。

• 安装如下工具：

  1	sudo apt-get install gcc git cpuid

检查硬件情况

这是Intel官方给出来的方法：如何确定英特尔®Software Guard Extensions （英特尔® SGX） 处理器是否支持 DCAP 和FLC

在终端执行

1

cpuid | grep -i sgx

如果看到

1
2

SGX: Software Guard Extensions supported = true
SGX_LC: SGX launch config supported = false

说明本博客安装方法适合你硬件情况。

安装Intel(R) SGX环境

安装共有3大步，分别是：

• 安装Intel(R) SGX Driver
• 安装Intel(R) SGX SDK
• 安装Intel(R) SGX PSW

安装Intel(R) SGX Driver

安装一些工具

1

sudo apt-get install make

检查系统内核头文件是否与现有内核匹配：

1

dpkg-query -s linux-headers-$(uname -r)

如果看到Status: install ok installed说明没有问题

否则要安装匹配的内核头文件：sudo apt-get install linux-headers-$(uname -r)

克隆仓库：

1

git clone https://github.com/intel/linux-sgx-driver.git

编译Intel(R) SGX Driver

1

cd linux-sgx-driver && make

编译完后，依次执行如下命令进行安装

1
2
3
4
5

sudo mkdir -p "/lib/modules/"`uname -r`"/kernel/drivers/intel/sgx"    
sudo cp isgx.ko "/lib/modules/"`uname -r`"/kernel/drivers/intel/sgx"    
sudo sh -c "cat /etc/modules | grep -Fxq isgx || echo isgx >> /etc/modules"    
sudo /sbin/depmod
sudo /sbin/modprobe isgx

至此Intel(R) SGX Driver安装完成。

安装Intel(R) SGX SDK

安装一些工具

1

sudo apt-get install build-essential python ocaml ocamlbuild automake autoconf libtool wget python libssl-dev git cmake perl libcurl4-openssl-dev protobuf-compiler libprotobuf-dev debhelper reprepro unzip

注意这里安装工具可能报错如下

这是因为某些软件包需要保持现状，安装可能会破坏原有的软件包依赖关系，所以要安装这个软件包，必须调节软件包之间的相关关系,给个解决的方法链接,简单来说就是用aptitude来代替apt安装，aptitude能解决软件中的依赖关系。

克隆仓库：

1

git clone https://github.com/intel/linux-sgx.git

预编译

此步会克隆几个GitHub，请走代理（不走代理针的好慢好慢）：

1

cd linux-sgx && make preparation

将预编译出的文件拷贝至系统路径下：

1

sudo cp ~/linux-sgx/external/toolset/ubuntu18.04/* /usr/local/bin

执行如下命令检查是否拷贝成功，如果成功会输出路径：

1

which ar as ld objcopy objdump ranlib

编译Intel(R) SGX SDK

1

make sdk

此步会输出大约五万行内容（真的时间巨长，等吧），请耐心等待。

最后没有报错，说明编译成功。

编译Intel(R) SGX SDK安装器

1

make sdk_install_pkg

此步会输出大约五万行内容（这个时间也很长啊，都看了好多视频了），请耐心等待。

编译完成后会输出Generated sdk installer: ./linux/installer/bin/sgx_linux_x64_sdk_xxx.bin。

安装Intel(R) SGX SDK

首先我们先创建一个目录，作为SDK的安装目录

1

mkdir -p ~/linux-sgx-install-path

此步xxx要改为编译Intel(R) SGXSDK安装器最后的输出，在目录linux-sgx/linux/installer/bin下可以看到此文件

1

cd linux/installer/bin && ./sgx_linux_x64_sdk_xxx.bin --prefix ~/linux-sgx-install-path

根据安装最后的提示输出刷新环境变量

1

source ~/linux-sgx-install-path/sgxsdk/environment

SDK安装完成。

此时进入linux-sgx-install-path/SampleCode下尝试样例代码是不会成功的，需要安装PSW之后才可运行样例。

安装Intel(R) SGX PSW

编译Intel(R) SGX PSW

1

cd ~/linux-sgx && make psw

注意把linux-sgx-install-path下的sgxsdk文件夹移动到根目录下的/opt/intel目录里，再执行上面的这一条指令。此步会输出大约一千行内容，请耐心等待。

编译Intel(R) SGX SDK安装器

1

cd ~/linux-sgx && make deb_psw_pkg

此步会输出大约八千行内容，请耐心等待。

添加本地软件源

按照github上的英文教程，需要先生成sgx_debian_local_repo文件夹，最后在~/linux-sgx/linux/installer/deb目录下可以看见这个文件夹，输入如下指令：

1

make deb_local_repo

需要将本地路径追加到软件源文件中，使用sudo vi /etc/apt/sources.list编辑文件，将下面内容添加到文件末尾，注意：你需要把PATH_TO_LOCAL_REPO替换成~/linux-sgx/linux/installer/deb/sgx_debian_local_repo的绝对路径，注意这里的路径需要自己根据自己的位置设置，建议改成绝对路径，我的添加方式如下，大家自己添加的时候注意改成自己的路径哦！

1

deb [trusted=yes arch=amd64] file:/home/harper/inux-sgx/linux/installer/deb/sgx_debian_local_repo bionic main

添加完之后，刷新软件源

1

sudo apt-get update

安装Intel(R) SGX PSW

1

sudo apt-get install libsgx-launch libsgx-urts libsgx-epid libsgx-quote-ex libsgx-dcap-ql

如果现在去测试样例，会报错failed to load enclave，Intel给出解决方案，要启动aesmd服务。

启动aesmd服务

启动

1

sudo systemctl start aesmd

查看aesmd服务启动状态

1

cat /var/log/syslog | grep -i aesm

设置aesmd服务开机启动

1

sudo systemctl enable aesmd

安装测试

测试本地认证

我们使用SDK给出的样例代码LocalAttestation对安装情况进行测试

1

cd ~/linux-sgx-install-path/sgxsdk/SampleCode/LocalAttestation 

编译样例代码

1

make

执行样例

1

./bin/app

如果看到如下输出，说明安装成功

1
2
3
4

succeed to load enclaves.
succeed to establish secure channel.
Succeed to exchange secure message...
Succeed to close Session...

我自己跑出来是显示没有成功（狗头），应该是aesmd服务出了点问题，大家可以测试下面的enclave样例

测试enclave样例

我们运行enclave代码

1

cd /opt/intel/sgxsdk/SampleCode/SampleEnclave

编译代码

1

sudo make

执行代码

1

./app

看到如下输出证明安装成功

安装教程

• 知乎教程

使用教程

• mysql软件的使用

数据库基本语法

数据库层次结构

启动

1

mysql -u root -p

数据库的创建

创建基本的一个学生-课程数据库

1
2

CREAT DATABASE student_course;
USE student_course;

表操作

基本数据类型

数值类型

日期和时间类型

表示时间值的日期和时间类型为DATETIME、DATE、TIMESTAMP、TIME和YEAR。

每个时间类型有一个有效值范围和一个"零"值，当指定不合法的MySQL不能表示的值时使用"零"值。

TIMESTAMP类型有专有的自动更新特性，将在后面描述。

字符串类型

字符串类型指CHAR、VARCHAR、BINARY、VARBINARY、BLOB、TEXT、ENUM和SET。该节描述了这些类型如何工作以及如何在查询中使用这些类型。

注意：char(n) 和 varchar(n) 中括号中 n代表字符的个数，并不代表字节个数，比如 CHAR(30) 就可以存储 30个字符。

CHAR 和 VARCHAR类型类似，但它们保存和检索的方式不同。它们的最大长度和是否尾部空格被保留等方面也不同。在存储或检索过程中不进行大小写转换。

BINARY 和 VARBINARY 类似于 CHAR 和VARCHAR，不同的是它们包含二进制字符串而不要非二进制字符串。也就是说，它们包含字节字符串而不是字符字符串。这说明它们没有字符集，并且排序和比较基于列值字节的数值值。

BLOB 是一个二进制大对象，可以容纳可变数量的数据。有 4 种 BLOB类型：TINYBLOB、BLOB、MEDIUMBLOB 和LONGBLOB。它们区别在于可容纳存储范围不同。

有 4 种 TEXT 类型：TINYTEXT、TEXT、MEDIUMTEXT 和 LONGTEXT。对应的这 4种 BLOB 类型，可存储的最大长度不同，可根据实际情况选择。

创建一个表和删除一个表

创建

1
2
3
4
5
6
7

mysql> CREATE TABLE student
    -> (Sno CHAR(9) PRIMARY KEY,
    -> Sname CHAR(20) UNIQUE,
    -> Ssex CHAR(2),
    -> Sage SMALLINT,
    -> Sdept CHAR(20)
    -> );

删除

1

DROP TABLE student;

修改表名

1

ALTER TABLE student RENAME stu;

修改列名

1
2

ALTER TABLE SC
CHANGE Crade Grade SMALLINT;

表——增删改查

增

可以用两种方式编写INSERT INTO语句。

第一种方法指定列名和要插入的值：

1
2

INSERT INTO table_name (column1, column2, column3, ...)
VALUES (value1, value2, value3, ...); 

如果要为表的所有列添加值，则无需在SQL查询中指定列名。但是，请确保值的顺序与表中的列的顺序相同。INSERTINTO语法如下：

1
2

INSERT INTO table_name
VALUES (value1, value2, value3, ...); 

代码举例(一定注意：字符型数据需要加引号)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

INSERT INTO student (Sno,Sname,Ssex,Sage,Sdept)     values     ("201215121","李勇","男",20,"CS");
INSERT INTO student (Sno,Sname,Ssex,Sage,Sdept)     values     ("201215122","刘晨","女",19,"CS");
INSERT INTO student (Sno,Sname,Ssex,Sage,Sdept)     values     ("201215123","王敏","女",18,"MA");
INSERT INTO student (Sno,Sname,Ssex,Sage,Sdept)     values     ("201215125","张立","男",19,"IS");
INSERT INTO SC      values     ("201215121","1",92);
INSERT INTO SC      values     ("201215121","2",85);
INSERT INTO SC      values     ("201215121","3",88);
INSERT INTO SC      values     ("201215122","2",90);
INSERT INTO SC      values     ("201215122","3",80);
INSERT INTO course      values     ("1","数据库","5",4);
INSERT INTO course      values     ("2","数学","NULL",2);
INSERT INTO course      values     ("3","信息系统","1",4);
INSERT INTO course      values     ("4","操作系统","6",3);
INSERT INTO course      values     ("5","数据结构","7",4);

最后得到如下几个表：

还有一种插入方式，需要学习select语句，直接把语句放到下面

对于每一个系，求学生的平均年龄，并把结果放到数据库里

1
2
3
4
5
6
7
8
9
10

create table Dept_age
(
sdept char(15)
avg_age smallint
);
insert 
into dept_age(sdept,avg_age)
select sdept , avg(sage)
from student 
group by sdept;

删

1

DELETE FROM course WHERE Cno = 22;

这里的where子句可以配合一些列其他句子使用，如exists,in等等

改

让我们先想想有什么需要修改？

对于列来说：

• 增加新的一列

增加入学时间

1

ALTER TABLE Student ADD S_entrance DATE;

• 修改原有列的数据类型(使用MODIFY或者CHANGE)或者增加约束条件

1
2

ALTER TABLE Student MODIFY S_entrance INT;
ALTER TABLE Student ADD  UNIQUE(S_entrance);

• 删除列和删除约束条件

1
2

ALTER TABLE Student DROP INDEX S_entrance;
ALTER TABLE Student DROP COLUMN S_entrance;

对于行来说：

• 修改一行中已有的数据(使用SET语句)

1
2

UPDATE course SET Cno = '100' where Cno = '1';
SELECT * from course;

这里的where子句可以配合一些列其他句子使用，如exists,in等等

查

使用where子句和列名可以实现查找(查找是一个大块，内容很复杂，后面再介绍)

1
2

SELECT Sno,Ssex from student;
SELECT Sno 学号,Ssex 性别 from student;

如果这样查输出奇怪的东西（sql注入可能用到）