Openssl - 标签 - 有价值炮灰 https://evilpan.com/tags/openssl/ Openssl - 标签 - 有价值炮灰 Hugo -- gohugo.iozh-CNi@pppan.net (evilpan) i@pppan.net (evilpan)This work is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License.Sun, 17 May 2020 22:40:00 +0800 椭圆曲线加密与NSA后门考古 https://evilpan.com/2020/05/17/ec-crypto/ Sun, 17 May 2020 22:40:00 +0800 evilpan https://evilpan.com/2020/05/17/ec-crypto/

本文主要介绍椭圆曲线的基本原理以及基于椭圆曲线的密码学实现，包括ECC加密、ECDH秘钥交换以及ECDSA签名算法，并介绍其中潜在的一些安全问题。其中分析了两个ECC实现相关的真实案例，分别是索尼PS3的签名问题和美国国家安全局NSA留下的椭圆曲线后门。

前言

上周写过一篇关于RSA实现的介绍文章。相对于RSA对称加密，椭圆曲线加密要复杂得多，以至于多数的介绍文章都难免涉及大量的数学理论和公式。作为一个非密码学专业的业余爱好者，我的目的只是希望对这些概念有个宏观的理解，因此本文会对涉及到的概念在尽量保证正确的前提下进行简化描述。

椭圆曲线

作为梦开始的地方，椭圆曲线(Elliptic Curve)真的只是一个曲线，和其他曲线一样，都是函数在坐标轴中的一个映射。根据mathworld中给出的椭圆曲线定义，描述椭圆曲线的函数可以定义如下：

y^2 = x^3 + a*x + b

其中a、b是曲线的特征参数，决定了椭圆曲线的形状。当43*a^3 + 27*b^2 = 0时，椭圆曲线退化成奇异曲线，因此不再是合法的椭圆曲线。上述方程的表示方法也称为Weierstrass nomal form。椭圆曲线在坐标系上的形状参考如下：

EllipticCurves
EC

通过观察或者证明都可以得知椭圆曲线是关于x轴对称的。为了理解椭圆曲线，还需要引入一个无穷远点作为曲线的一部分，也称为理想点，用符号0表示。椭圆曲线本身比较直观，在不同取值范围中会存在不同的特性，下面会分别进行介绍。

在数学中，**群(Group)**表示一个特殊的集合，对于集合中的元素我们可以执行二元运算，比如加法(+)。一个集合成为群的前提是需要满足以下4个条件

  1. 封闭性：若a和b属于群G，则a+b也属于群G
  2. 结合性：(a+b)+c = a+(b+c)
  3. 存在单位元θ，使得a + θ = θ + a = a
  4. 群中每个元素都存在逆元素，即对于任意元素a存在b，使得a + b = θ

如果集合满足上述条件且满足第5条：

  • 交换律：a + b = b + a

那么该集合也称为阿贝尔群(abelian group)。

单位元：在二元运算中，单位元与任意元素运算不改变其值，比如实数中加法单位元是0，乘法单位元是1

根据定义，整数集合是一个群(阿贝尔群)，但自然数集合不是一个群，因为不满足第4个条件。

如果一个集合是一个群，那么就可以推导出它也满足其他一些性质，比如单位元唯一性、逆元素唯一性等。

椭圆曲线和群有什么关系？实际上我们可以在椭圆曲线上定义一个群，具体来说：

  • 群的元素是椭圆曲线上的点
  • 单位元是无穷远点0
  • 点P的逆是它关于x轴的对称点
  • 加法的定义为：对于三个同一直线上的非零点P、Q和R，它们的和为P+Q+R =0

用图来表示就是：

group
GROUP

这只是一种几何表示，比如计算P+P，实际上是在P点作一条切线。为了能够进行计算，我们需要将几何加法转换成代数加法，即将上述规则转换为一组方程 。其中涉及到三次方程的解，这里直接给结论，假设P、Q、R的坐标分别是(Px, Py)、(Qx, Qy)、(Rx, Ry)，则：

# 直线斜率为m
m = (Py - Qy) / (Px - Qx)
Rx = m^2 - Px - Qx
Ry = Py + m(Rx - Px)

因此，计算P+Q也就可以在代数上转化为对*(Rx, -Ry)*的计算。

有了加法，自然就可以推出乘法：

n * P = P + P + P + ... + P

其中n是自然数。写成以上形式需要计算n次加法，算法复杂度为O(2^k)，k为n的位宽。实际上可以转换为倍乘相加(double and add)的方式，例如：

151 * P = 2^4 * P + 2^2 * P + 2^1 * P + 2^0 * P

这样可以将算法复杂度减少到O(logn)，或者说O(k)。

有了乘法，自然有除法。给定n和P，我们至少有一种在多项式时间内计算出Q=nP的算法。那么反过来，给定Q和P，是否能计算出n呢？这个问题就是我们常说的对数问题(logarithm problem)。其实这里应该说是除数问题，但大多密码学算法是基于指数计算的，因此求逆称为对数。对数问题求解的时间远大于乘法的计算时间，但连续对数的解存在一些特点，因此并不算是个合格的难题，这里只是引出这个概念，以及我们下面将要看到的真正主角——离散对数问题。

接下来我们将椭圆函数的范围从实数集转到有限集，或者称为有限域(finite field)。域(field)在抽象代数是个专有名词，表示一种支持可进行加减乘除运算的代数结构，并且运算结果不会超出域的集合，其概念是数域和四则运算的拓展。

有理数集合、实数集合都满足域的概念，如果一个域中的元素个数有限，则成为有限域。有限域一个典型是伽罗瓦域(Galois Field)，记作GF(p^n)，其中p是素数，n是正整数。p^n也称为有限域的阶(order)，即有限域中的元素个数。n=1时称为素数域GF(p)。

GF(p)元素集合为所有从0到p-1的整数，其加法和乘法可以转换为模运算，也称为时钟算术，例如对GF(23)：

  • 加法：(18+9) mod 23 = 4
  • 减法：(7-14) mod 23 = 16
  • 乘法：4 * 7 mod 23 = 5
  • 加法逆元：-5 mod 32 = 18
    • (5 + (-5)) mod 23 = (5 + 18) mod 23 = 0
  • 乘法逆元：9^-1 mod 23 = 18
    • 9 * 9^-1 mod 23 = (9 * 18) mod 23 = 1

使用拓展欧几里得算法，我们可以在O(logp)的复杂度内计算出某个数的乘法逆元，这也是除法计算的基础。

在将椭圆曲线的范围限制到有限域中后，椭圆曲线的算式定义也可以做出如下修改：

pic-formula
FORMULA

其中0依旧是无穷远点，而a、b是有限域集合中的两个整数。对于任意x，最多存在两个点，即两个y的解。

举个例子，对于椭圆曲线y^2 ≡ x^3 - 7x + 10 (mod p)，当p的值分别是19、97、127、487时，其在坐标轴上的图像如下：

pic-ecd
ECD

注意这些点的集合在直角坐标中是关于直线y=p/2对称的。虽然之前连续的椭圆曲线现在变成了离散的点，但可以证明这些点的集合同样是一个阿贝尔群，因此也满足群的定义和推论。

那么，我们要如何定义和计算这些离散点的加法呢？与实数集中我们定义几何学上同一直线上的三个点P、Q、R之和为0，有限域中也类似，不过这里的直线并不是实数集中的直线，而是满足*ax + by + c ≡ 0 (mod p)*的点的集合。

举例来说，椭圆曲线y^2 ≡ x^3 - x + 3 (mod 127)，且P=(16, 20)，Q=(41,120)。注意连接它们的“直线” *y ≡ 4x + 83 (mod 127)*实际上在空间中是重复的：

pic-line
LINE

计算对应几何表示的代数加法和前面类似，不过后面都需要加上(mod p)，这是可以推导出来的。

从加法到乘法同样可以使用倍乘加的算法加速运算，同时对于有限域的椭圆曲线，乘法还有个有趣的特点。例如对于椭圆曲线*y^2 ≡ x^3 + 2x + 3 (mod 97)*和点 P=(3,6)，在计算乘积时发现：

  • 0P = 0
  • 1P = (3,6)
  • 2P = (80,10)
  • 3P = (80,87)
  • 4P = (3, 91)
  • 5P = 0
  • 6P = (3, 6)
  • 7P = (80, 10)
  • …

乘积每5次一个循环，也就是说实际上该点的乘积只有5个可能的值，这个规律可以写成：

k * P = (k mod 5) * P

同时，这5个点本身也是封闭的，即这些点相加也是其中某个点：

n * P + m * P = (m + n) * P

因此，P的乘积所组成的集合也是一个群，称为循环子群，P称为该循环子群的生成器(generator)或者基点(base point)。循环子群是椭圆曲线加密的基础，在后面的章节会进行介绍。

循环子群的元素个数称为该子群的阶(order)，比如上述子群的阶为5。通过给定椭圆曲线和基点P我们可以计算出子群的阶。

在椭圆曲线加密中一个常见需求就是找到一个阶比较高的子群。假设椭圆曲线的阶为N，子群的阶为n，想要寻找的基点为P。根据拉格朗日定理h = N / n总是一个整数，h称为子群的余因子(cofactor)。考虑到椭圆曲线中所有点的和NP = 0，我们可以写成：

n(hP) = 0

假设n是一个素数，该等式实际上告诉我们：对于一个随机的点P，以点G = hP为基点的子群阶的阶为n(当G不为0时，G为0则子群阶为1)。当然该算法也要求n是一个素数，否则G的阶只是n的其中一个除数而已。

介绍完了乘法，最后就让我们来看除法：给定点P和Q，并且Q = kP，如何求k的值？这个问题就是椭圆曲线的离散对数问题，这个问题是一个公认的难题，目前没有一个多项式时间的求解算法可以计算出来。与大数分解问题类似，这个难题也只是实践上的，并没有严谨的数学证明不可解。

实际的加密系统中，如DSA签名算法、DH秘钥交换算法和ElGamal算法等，使用的是指数形式而不是乘法形式，即已知a和b，求解k以满足b = a^k mod p。椭圆曲线加密相比于RSA加密而言的优点之一是我们只需要更少位数的k就可以获得和RSA相同甚至更高的安全性。

ECC

ECC(Elliptic Curve Cryptography)即椭圆曲线加密算法。在上文中我们说了，在有限域中的椭圆曲线乘法(指数)是相对容易计算的，但是除法(对数)则很难计算，这也是椭圆曲线得以实现非对称加密的难题假设和理论基础。

椭圆曲线加密算法主要基于椭圆曲线在有限域中的循环子群，因此定义下面一些参数(domain parameters)：

  • p：定义了有限域大小的素数
  • a、b：定义椭圆曲线的特征参数
  • G：生成循环子群的基点
  • n：循环子群的阶(order)
  • h：循环子群的余因子(cofactor)

其中，组成ECC椭圆曲线加密算法的秘钥定义如下：

  • 私钥：一个在*{1, …, n - 1}范围内的随机数d*
  • 公钥：一个椭圆曲线上的点H = dG

就是这么的朴实无华。已知私钥d和G我们可以很容易通过乘法计算出公钥H，但是反过来从公钥计算私钥却要面临离散对数问题。虽然我们可以直接使用这个特性对信息(转换成数字)进行非对称加密，但实践上更多的是使用集成加密方案(IES, Integrated Encryption Scheme)，比如ECIES混合加密方法和EEECC (EC-based ElGamal)方法。

在openssl中使用也是通过ECC私钥生成对称加密的秘钥：

openssl ecparam -genkey -param_enc explicit -out priv.pem -name secp256k1
openssl pkeyutl -derive -inkey priv.pem -peerkey RecipientsPublicKey.pem -out SharedSecret.bin

详见Command Line Elliptic Curve Operations。

DH即Diffie–Hellman，是两个提出者的名字，Whitfield Diffie和 Martin Hellman。ECDH则为DH的其中一个实现，而DH是一个秘钥协商协议。秘钥协商问题可以简化为：如何在通信链路不安全的安全下安全交换秘钥。DH的实现有很多，但本质上也是基于某种不可逆的拆分操作，WiKi中有个比较直观的例子介绍了交换秘钥的过程：

pic-dh
DH

其中所基于的就是颜色混合容易但是分离难的假设，在这个假设前提下，双方可以获得共同的秘钥。注意双方的secret color是没有暴露在通信链路中的，因此即便被监听或者劫持也无法成功伪造对端进行中间人(MITM)攻击。

回到ECDH的实现上，这里的难题假设自然就是椭圆曲线的离散对数问题。假设通信双方还是Alice和Bob，则ECDH的工作流程为：

  1. Alice和Bob使用同样的椭圆曲线，并分别随机生成它们自己的私钥和公钥，其中Alice的私钥为da，公钥为Ha = da * G，Bob的私钥和公钥分别为db和Hb；
  2. Alice和Bob在不安全的信道中交换它们的公钥Ha和Hb；
  3. Alice和Bob分别计算自己私钥和收到的对方公钥的乘积，有：
Sa = da * Hb = da * (db * G) = db * (da * G) = db * Ha = Sb

双方计算出了同样的乘积，即为安全的共享秘钥S，这个秘钥就可以用来作为对称加密的秘钥进行后续通信从而保证安全性。中间人通过偷听只能获得双方的公钥，如果它想要在没有私钥的情况下计算出该乘积，就相当于需要解决这么一个问题：给定椭圆曲线上三个点P、aP和bP，如何计算abP？这个问题在DH中也称为Diffie-Hellman problem，即构成安全秘钥交换基石的难题。

DSA(Digital Signature Algorithm)即数字签名算法。我们之前介绍RSA的时候说过RSA的签名方法，即对数据进行hash然后将其使用私钥加密，对端公钥解密并成功校验hash可认为数据没有被篡改。使用椭圆曲线实现的数字签名算法则称为ECDSA。

与RSA类似，ECDSA主要针对所校验数据的hash而不是数据本身。不同的是hash结果需要被截断，从而保证hash的位数与n(子群的阶)的位数相同，截断后的hash同样是一个整数，记为z。Alice使用私钥da对数据签名的流程如下：

  1. 从*{1,…,n-1}中随机选取一个整数k*
  2. 计算点P = kG
  3. 计算r = Px mod n (Px为点P的x坐标)
  4. 如果r=0，从新选一个k
  5. 计算s = k^-1 (z + r*da) mod n
  6. 如果s=0，从新选一个k

运算的结果*(r, s)则为签名。从计算过程中我们可以看到，s是与哈希z绑定的，而k可以理解为一个临时私钥，用来生成临时公钥r*。

Bob收到签名*(r, s)后，自己也计算一份数据的哈希z*，Ha是Alice的公钥，校验签名的过程如下：

  1. 计算整数u1 = s^-1 * z mod n
  2. 计算整数u1 = s^-1 * r mod n
  3. 计算点P = u1 * G + u2 * Ha
  4. 当r = Px mod n时，表示签名有效，数据未被篡改。Px为点P的x坐标

说实话我也不是很清楚为什么要搞这么绕，但ECDSA就是这么实现的。

安全性

和RSA一样，椭圆曲线加密的安全性根本在于其难题假设的“难度”，一旦这个前提被打破，椭圆曲线的安全性也会在根本上被动摇。打破难题假定的方法有很多，且不去谈量子计算这种未来的可能性，即便聚焦于当下也依然存在。

我们说椭圆曲线在有限域上的的离散对数问题是个难题，这并不完全正确。前面看到了根据a、b不同，椭圆曲线可能有不同的形状，事实上存在一些类型椭圆曲线，它们的安全性是相当脆弱的。对于这些椭圆曲线，可以使用特殊的算法来高效的求解离散对数问题。

比如，对于所有p=hn的曲线(有限域的阶等于椭圆曲线的阶)，就受到一种特殊攻击的影响，攻击者可以用一个普通电脑在多项式时间内求解出离散对数问题。

如果我给你一组椭圆曲线参数(domain parameters)，并告诉你说”OMG! 用它”，这时有一种可能性，即我可能已经秘密地找到了一种方法可以快速地对这条曲线求解离散对数。为了解决这个问题，有时候我们额外引入一个参数，即随机数种子S，并用其生成椭圆曲线特征参数a、b或基点G：

S = random()
H = hash(S)
a = f(H)
b = g(H)
...

使用随机种子生成的椭圆曲线可被认为是验证随机的(verified random)，其中使用hash来生成的参数在密码学中也称为“我的袖子里可没藏东西”数(Nothing-up-my-sleeve number)。

一个生成和校验随机椭圆曲线的标准算法是ANSI X9.62，感兴趣的可以参考SECG标准中Verifiably Random Curves and Base Point Generators一节。

实践中不会每次生成新的椭圆曲线进行加密，因为我们实际上需要的是一个足够大的素数p以及子群阶n，并确保不含人为的预置。所以一般会根据标准如NIST、SECG中建议的方式去选择预置的曲线和随机数种子S，不同的椭圆曲线有不同的安全性、运算速度和不同的秘钥长度。

例如，比特币使用的椭圆曲线secp256k1的参数如下：

curve = EllipticCurve(
    'secp256k1',
    # Field characteristic.
    p=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f,
    # Curve coefficients.
    a=0,
    b=7,
    # Base point.
    g=(0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798,
       0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8),
    # Subgroup order.
    n=0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141,
    # Subgroup cofactor.
    h=1,
)

ECC秘钥的长度取决于所使用的椭圆曲线，在大多数系统中，如OpenSSL、OpenSSH和比特币中默认的ECC秘钥长度都是256位。在OpenSSL中预置的曲线可见：

在生成ECDSA签名时，我们说到要从*{1, …, n}中随机选择一个整数k*。这个k需要秘密保存，一旦泄露就可能让攻击者找到签名方的私钥。秘密保存不只是不将k泄露给别人，也意味着生成k的随机数生成器不可预测，更进一步地，要求签名方不能使用同样的k来进行所有签名。

只不过使用了相同的k签名，会有什么问题呢？在这个场景中，我们假设攻击者有两份信息的签名*(r1, s1)和(r2,s2)，并且计算这两份信息的原始哈希z1和z2*，加上其他已知的椭圆曲线参数(公钥)，攻击方式如下：

  1. 注意到r1 = r2，因为r = Px mod n且P=kG，对两个信息是一样的
  2. (s1 - s2) mod n = k^-1(z1 - z2) mod n
  3. 两边同时乘以k，则 k(s1 - s2) mod n = (z1 - z2) mod n
  4. 两遍同时除*(s1 - s2)，则k = (z1-z2)(s1-s2)^-1 mod n*

最后一个算式中我们可以直接通过两个文件的哈希和签名计算出k，得到k之后就可以计算出私钥d：

s = k^-1(z + r * d) mod n
d = r^-1(s*k - z) mod n

一个现实中的经典案例就是索尼。出于保护目的，PS3只能运行索尼自家ECDSA签名过的游戏，没有索尼签名的游戏或应用无法被PS3的系统加载。但问题是当年索尼的实现是用一个同样的k来对所有游戏进行签名的，最终被黑客发现导致了PS3的沦陷。直到现在我们都经常能看到索尼被人用下面这张XKCD的图片进行嘲讽：

pic-epic
EPIC

除了文章中提到的安全陷阱或隐患，实际上也有其他问题会导致椭圆曲线离散对数的难题假设在一定程度上失效(或者变弱)。比如，有一种称为baby-step,gaint-step的算法可以将求解离散对数的算法和空间复杂度从暴力破解的O(p)降低为O(√n)，当所选的椭圆曲线子群阶n相对较小时，这种方式就能将离散对数的计算时间减少到可接受的水平，从而威胁加密的安全性。

同样类似的算法还有Pollard's rho算法，其进一步将求解离散对数的空间复杂度降到O(1)。对于一些破解椭圆曲线的比赛，如Certicom ecc challenge，通常就是使用该算法的变种求解的。目前的最新记录是2016年破解的117.35位通用椭圆曲线离散对数求解，使用FPGA实现并行Pollard’s rho算法，用到的算力为64至576个FPGA并行运行6个月时间。

除此之外，其他的攻击方式有：

  • Weil pairing / Tate pairing
  • Semaev-Smart-Satoh-Araki attack
  • Gaudry、Hess、Smart等提出的针对二进制域的度为小约数时的一种求解方法
  • …

NSA后门

在前一段时间介绍比特币的文章中，说到中本聪的一个特别之处就是他“避开了NSA的椭圆曲线后门”，当时听起来挺神奇的，但对于密码学家而言其实只是个正常的选择。

前面说椭圆曲线标准时提到了NIST，其全称为National Institute of Standards and Technology，即美国的国家标准技术研究所，负责制定一系列产业统一标准。NIST在2006年颁布了一个标准NIST SP 800-90A (SP表示特别发布)，其标题为 Recommendation for Random Number Generation Using Deterministic Random Bit Generators，这其实只是一个伪随机数生成器的定义标准，其中涉及了4个伪随机数生成器：

  1. Hash_DRBG：基于hash函数
  2. HMAC_DRBG：基于HMAC
  3. CTR_DRBG：基于块加密
  4. Dual_EC_DRBG：基于椭圆曲线加密

四个随机数生成器都是基于现有的密码学原语(cryptographic primitives)构建的。但是第4个比较特殊，用现在的俚语来说就是“画风和别人不太一样”，而且运行速度也较其他三个而言要慢几个数量级，之所以存在于NIST标准中的唯一原因是因为这是NSA建议的。

因此，早在该标准发表后不久，就有人提出了质疑。2006到2007年之间最早提出的主要观点是认为 Dual_EC_DRBG 这个随机数生成器的输出带有一定的偏好(bias)。

随后，在2007年8月的CRYPTO大会上，研究人员进一步提出了这个随机数生成器中的不合理之处。简单来说，就是Dual_EC_DRBG所使用的椭圆曲线是由一系列常数定义的，这些常数定义在NIST标准的附录中，但完全不知道是从何而来。研究人员提出这些常数和另外一个秘密的常数存在某种联系，如果知道了这个秘密常数，那么就可以通过获取Dual_EC_DRBG的32字节输出后预测该随机数生成器所生成的随机数。

然而研究人员并不知道这个秘密常数是什么，也许给出这组椭圆曲线参数的人会知道，也许没人知道。不过这种可能性的存在就足够让人警惕了。值得一提的是NIST在标准的附录中还指出可以通过其他随机数生成器来重新产生常数来替换默认的椭圆曲线参数，但这一步是可选的，实际上大部分Dual_EC_DRBG的实现都不会去额外做这个工作。

在比特币诞生之初，作为密码学专家的中本聪，自然也不会放过这个问题，所以避开这个后门也就理所当然了。

虽然Dual_EC_DRBG饱受质疑，但没有人能拿出实质性的证据，所以很多公司如RSA Security仍然使用Dual_EC_DRBG来实现一些加密项目，并表示问题不大。直到2013年，Edward Snowden跳了出来。在他披露的文件中显示，NSA曾给过1000万美金给RSA，条件是令其将NSA的随机数生成器设为默认。……所以一切就说得通了。

值得一提的是，除了在标准中留后门，NSA还灵活运用了其他方法，比如网络漏洞利用、网络劫持、和工业界进行py、和其他Agent(如英国的GCHQ)进行py等等……这一系列操作构成了网络行动——Operation Bullrun，感兴趣的可以去进一步了解。

2015年，NIST发布新版本的标准，默默地去掉了Dual_EC_DRBG。

参考文章

]]> RSA安全与秘钥基础设施 https://evilpan.com/2020/05/02/rsa-security/ Sat, 02 May 2020 22:40:00 +0800 evilpan https://evilpan.com/2020/05/02/rsa-security/ 之前写过一篇对称加密与攻击案例分析，而对于非对称加密，虽然接触的时间不短了，但一直没有很系统的记录过。因此趁着国庆家里蹲的五天长假，就来好好回顾总结一下。

前言

其实从加密的定语就能看出，对称加密表示通信双方是拥有同样信息的(即信息对称)。信息可以是预共享的秘钥(PSK)，也可以是事先约定的编解码方法(如凯撒密码)。非对称加密则将信息分为两部分，例如秘钥A和秘钥B，通过秘钥A加密的信息可以用秘钥B进行解密，反之通过秘钥B加密的信息也可以通过秘钥A进行解密。通常这对秘钥可以叫做公钥和私钥，公钥对外发布，私钥自己保留，从而在信息不对称的情况下实现加密和认证。

非对称加密的实现方法有很多，大都依赖于难题假设(hardness assumptions)。基于一个常量时间内被公认不可解的难题，将该问题的答案分为不同因子，组成对应非对称密码学算法的公钥和私钥。例如RSA基于大素数分解问题，(EC)DSA基于离散对数问题等。本文重点关注RSA非对称加密。

RSA原理

RSA应该是最早的公钥加密系统之一了，其名称是三个发明者的名字首字母缩写(Rivest–Shamir–Adleman)。其算法所基于的难题假设是质数分解问题，在此之前先简单介绍一下涉及到的数学基础。

  1. 欧拉函数：φ(n)，表示小于n的正整数中与n互质的数的数目。如果n能写做两个不同质数p和q的乘积，那么则有φ(n) = (p - 1)(q - 1)。证明：略。
  2. 同余：给定一个正整m，如果两个整数a和b满足*(a-b)被m整除，那么就称为a和b对模m同余，记作a≡b(mod m)*，其中≡是同余符号。同余的两个数有一些有趣的特性，比如反身性、对称性、传递性等等，详见《数论》。
  3. 模逆元：也叫模倒数(modular multiplicative inverse)。整数a的模逆元为整数x，则满足ax≡1(mod m)，其中m为模(modulus)。
  4. 欧拉公式：若a与n互为质数，则满足a^φ(n)≡1(mod n)，证明：参考拉格朗日定理。
  5. lcm：least common multiple，最小公倍数。
  6. gcd：greatest common devisor，最大公约数。
  7. 互质：co-prime，两个正整数a、b互质意味着能同时被它们整除的数只有1，即gcd(a, b) = 1

有了上面的数学基础，再来看RSA公私钥的组成和生成过程。秘钥生成主要有以下几步，其实每一步在实践上都有注意事项，这个后面单独说。

  1. 找到两个不同的质数p和q
  2. 计算其乘积n=pq
  3. 计算φ(n)，由于p和q是质数，根据欧拉定理得φ(n) = lcm(p-1, q-1)
  4. 选择一个整数e，满足1 < e < φ(n)且gcd(e, φ(n)) = 1，即e和*φ(n)*互质
  5. 计算一个e的模逆元 d，对应模为φ(n)。计算过程涉及拓展欧几里得算法和贝祖恒等式，d就是其中一个贝祖系数(coefficient)

在上面的数字中挑选出构造非对称加密的元素：

  • 公钥：(n, e)
  • 私钥：(n, d)

e和d分别是公钥和私钥的核心，这两个数互为模逆元。要想通过公钥e推算出私钥d，就需要知道φ(n)；而计算φ(n)=(p-1)(q-1)则需要知道p和q；公私钥都已知n=pq，所以这就是难题假设的关键：当n很大的时候很难计算出对应的p和q。

假设我们有公钥*(n, e)，需要加密的内容为m*，m是个小于n的正整数。则密文c为：

m^e ≡ c (mod n)
c = m^e mod n

使用模指数运算，即便数字很大也可以很快算出。

对方拥有私钥*(n, d)，对密文c解密可获得明文m*，方法如下：

c^d ≡ (m^e)^d ≡ m (mod n)
m = c^d mod n

这里值得注意的是，由于明文m是通过模n获取的，所以要求m<n，这也是为什么RSA加密有长度限制的原因。

举一个具体的例子，

  1. p = 61, q = 53
  2. n = 61 x 53 = 3233
  3. φ(n) = lcm(p-1, q-1) = lcm(60, 52) = 780
  4. e = 17
  5. d = 413
  • 公钥: (n = 3233, e = 17)
  • 私钥: (n = 3233, d = 413)

加密和解密函数分别为：

enc(m) = m^e mod n
dec(c) = c^d mod n

假设加密的内容为1337，可以用python进行简单的验证：

enc(1337) = 1337**17 % 3233 = 1306
dec(1306) = 1306**413 % 3233 = 1337

感兴趣的可以自己尝试一下。

RSA算法除了可以用来进行加密，同样也能用来进行签名。签名的目的是确保发送的信息是由对应私钥的持有者发布的，而且信息没有遇到篡改。公钥签名则使用私钥校验，私钥签名则使用公钥校验，和加密方向类似。

签名所依赖的数学原理是指数的运算规则，对于整数h，有：

(h^e)^d = h^(e*d) = h^(d*e) = (h^d)^e ≡ h (mod n)

这里的h可以是我们所发送信息的哈希值，比如md5或者sha256。因此对于私钥的持有者而言，签名实际上就可以转换为用私钥对hash进行加密的过程。

消息的接收方收到信息以及加密的hash，使用发送者的公钥对签名进行解密，并计算消息的hash，将解密后的值与hash进行比对即可实现校验过程。

安全陷阱

回顾上面秘钥构成的一节，有几个地方说得其实有点含糊，比如选择p、q、e的地方，存在了一定的主观性。只要满足条件，就可以任意选择吗？事实上在有些场景下选择不当也会导致潜在的安全问题。

我们知道在秘钥生成的第一步就是选择两个足够大的质数，这两个数都是需要秘密保存的，任何一个数泄露都会导致质数分解的难度假设无效。那么问题来了，多大的数才算够大？这两个数之间的关系会影响难题假设吗？

对于第一个问题，我们可以参考算力增长和近期的挑战情况判断。例如，一个称为YAFU工具可以在20分钟左右分解一个300位的质数，如下：

Bits Time Memory used
128 0.4886 seconds 0.1 MiB
192 3.9979 seconds 0.5 MiB
256 103.1746 seconds 3 MiB
300 1175.7826 seconds 10.9 MiB

截止至2019年，被分解的最大RSA数有795位，分解使用了900个CPU年的算力。

同时，对应权威机构的建议也是其中一个参考来源，例如NIST或者密码局。根据NIST的判断，非对称加密的秘钥强度和对称加密之间有近似的类比关系：

  • 1024位的RSA秘钥强度相当于80位的对称加密秘钥
  • 2048位的RSA秘钥强度相当于112位的对称加密秘钥
  • 3072位的RSA秘钥强度相当于128位的对称加密秘钥

并且NIST建议目前的RSA秘钥安全强度是2048位，如果需要工作到2030年之后，就使用3072位的秘钥。

解决了秘钥长度的问题，我们再看p和q以及它们的关系。判断一个数是不是质数(素数)的方法称为素性测试。其中有一些算法可以提高测试速度，比如启发性测试和费马素性测试，后者通常用来在RSA秘钥生成中快速筛选数据。

在“A Method for Obtaining Digital Signatures and Public-Key Cryptosystems”中提出，出于安全性考量，p和q应该随机选取，而且应该有相似的量级，但是在长度上又有若干位的不同，才能更难被计算机分解。这其实是从实践上考虑的，但也引出了一个问题：什么样的数好分解，什么样的数难分解？只可惜目前并没有明确的结论。也许在数学专家的钻研下，已经有了一种快速分解满足特定条件大数的方法，只不过出于“国家安全”并未公开，这大概也是我们推国密而舍RSA的原因之一吧。

私钥指数就是私钥中的d，在计算时我们提到这是模逆元算式的一个解。事实上该算式通常是多解的，那么在这种情况下如何选择呢？正确答案是随机选择一个解。曾经有过的情况是秘钥生成者为了解密时计算速度更快，选择一个比较小的d作为私钥指数。由于模指数运算的时间复杂度是log2(d)，在模为1024字节的情况下，一个较小的d甚至可以令运算速度提高10倍。

这样看似没怎么影响安全性，但实际上M. Wiener提出了一种攻击方法]令这种情况完全破坏了RSA加密的根基。Wiener定理如下：

attack.png

因此，使用一个过小的私钥指数虽然提升了解密运算速度，但同时也提升了攻击者还原私钥d的计算效率。

详细的证明过程见: M. Wiener. Cryptanalysis of short RSA secret exponents. IEEE Transactions on Information Theory, 36:553-558, 1990

前面秘钥生成的过程中第四步我们说需要选择一个整数e，满足1 < e < φ(n)且gcd(e, φ(n)) = 1，即e和φ(n)互质。这个e是公钥的重要组成，因此称为公钥指数。

作为一个选择困难症患者，依旧是看到选择两个字就犯难。既然要求e和φ(n)互质即可，那么我随便选个满足要求的质数不就行了吗，比如e=3。估计抱有和我同样想法的人不在少数，但这样其实是有问题的，从结论上看会导致攻击者可以在特定情况下较为高效地还原私钥d，据不完全统计，涉及到的攻击场景有下面这些：

  • Hastad’s Broadcast Attack
  • Franklin-Reiter Related Message Attack
  • Coppersmith’s Short Pad Attack
  • Partial Key Exposure Attack
  • …

感兴趣的朋友可以查看文末的参考资料，这里就不展开了。值得一提的是这种情况的危害相对于前面选择过小的私钥指数情形而言相对较轻一些，即便选取了较小的公钥指数，距离成功的攻击也有不少的计算量。现实中私钥指数一般选择e = 2^16 + 1 = 65537就可以很好地防御攻击了，后面在拆解一些现实中的秘钥时也会看到。

我们前面所指的加密、解密和签名运算，明文和密文标的都是一个整数，该整数小于n。这种方式叫做plain RSA(Textbook RSA或裸加密)，在现实中很少直接使用。plain RSA实际上存在许多安全隐患，列举一些如下：

  • 当使用较小的公钥指数e(比如3)加密较小的明文m(比如m<n^(1/e))时，由于m^e严格小于模n，因此只要对密文进行e方根取整，就可以很容易解密获得明文。
  • 如果同样的明文发送给e个以上的接收方，并且接收方的公钥指数e相同，p、q不同，那么通过中国剩余定理(孙子定理)，中间人就可以很容易解密出明文信息。可以参考前面提到的Coppersmith’s Attack。

《孙子算经》：有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二。问物几何？

另外最最重要的一点，由于RSA加密本身没有随机数参与，因此是一种确定性加密算法，即同样的明文加密一定会出现同样的密文。从这点来看，裸RSA加密并不是语义安全的。

非语义安全的加密系统，很有可能会受到Chosen plaintext attack攻击的影响。举例来说，RSA的一个特性是两个密文的乘积等于对应明文的乘积：

m1^e * m2^e ≡ (m1m2)^e (mod n)

如果攻击者想要解密某个特定密文c ≡ m^e (mod n)，他可以让私钥持有方去解密一个构造的密文c′ ≡ cr^e (mod n)，r是攻击者选择的值。由于前面提到的乘积特性，实际上密文c’的明文值是mr (mod n)，因此如果解密成功，攻击者就可以计算出原本密文c的明文m。

除了上面介绍的这些，裸加密很存在许多其他隐患。为了缓解这些问题，真实的RSA实现中通常还会在明文加密之前进行一定的填充。填充要求能引入足够的随机性，但是也需要能够方便地对明文进行还原(unpading)。之前对称加密介绍的一种填充PKCS#5可以实现后者，但是没有随机性。

[PKCS#1][rfc]标准中最初就包含了精心设计的填充方法。虽然是精心设计，但在1998年Bleichenbacher在Crypto会议上对其展示了一种称为adaptive chosen ciphertext attack的攻击方法，两年后在Eurocrypt 大会上也有人提出一些潜在的不安全性。这期间PKCS#1标准也一直进行修订，比如引入OAEP填充方式等。

如果使用过高级语言中封装的RSA加密库，应该也会发现其提供的接口都是可以指定Padding的，比如Python的例子：

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Hash import SHA256

def encrypt(key, plainText) 
    pubkey = RSA.importKey(key)
    cipher = PKCS1_OAEP.new(pubkey, hashAlgo=SHA256)
    encrypted = cipher.encrypt(plaintext)
    return base64.b64encode(encrypted)

Java的例子：

String decrypt(String privateKeyStr, cipherText) {
  byte[] cipherTextBytes = DatatypeConverter.parseBase64Binary(cipherText);
	byte[] privateKeyBytes = DatatypeConverter.parseBase64Binary(privateKeyStr);
  KeyFactory kf = KeyFactory.getInstance("RSA");
	PKCS8EncodedKeySpec ks = new PKCS8EncodedKeySpec(privateKeyBytes);
	PrivateKey privateKey = kf.generatePrivate(ks);

	Cipher c = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
	c.init(Cipher.DECRYPT_MODE, privateKey, new OAEPParameterSpec("SHA-256",
        "MGF1", MGF1ParameterSpec.SHA256, PSource.PSpecified.DEFAULT));
	byte[] plainTextBytes = c.doFinal(cipherTextBytes);
	String plainText = new String(plainTextBytes);
  return plainText;
}

基础设施

介绍完了理论，想必很多人也觉得枯燥无味了。诚然，理论与实践结合才是密码学大放异彩的地方，我们日常生活中每天上网用到的https，手机系统用到的应用签名、Secure Boot，各种认证和校验，无不涉及到非对称加密。实践依赖于背后的数学根基，但同时也在易用性和标准化上做了很多工作，在此基础上构建了广泛应用的秘钥基础设施。值得一提的是，这里的基础设施并不是狭义的PKI，而是涉及到的标准和实践，下面会挑一些来进行介绍。

为了解决高级语言中结构化数据在磁盘、网络中传输后能够进行还原，我们早先有JSON、XML等表示，现在有protobuf、thrift等序列化方法。不过在更早之前就有了跨平台的抽象语法标准ASN.1(Abstract Syntax Notation One)，ASN.1定义在X.208中，提供了标准的IDL接口描述语言，可以用来表示一系列类型和值。

在ASN.1中，类型就是一组值。有些类型包含了有限的值，但是有些类型也可以包含无限的值。ASN.1包含四种类型：

  1. 简单类型，即没有组合的”原子“类型
  2. 结构类型，类型的组合
  3. 标记类型，从其他类型衍生的类型
  4. 其他类型，例如CHOICE和ANY类型

类型和名称都可以通过赋值符号::=进行命名。除了CHIOCE和ANY的每个ASN.1类型都包含一个标记(tag)，tag可以理解成唯一的标识符，当且仅当tag相等时对应类型才相等。tag也有4个种类：

  1. 通用标记(Universal)
  2. 应用标记(Application)
  3. 私有标记(Private)
  4. 上下文标记(Context-Specific)

通用标记是定义在X.208中的，具有全局唯一性，其他标记在不同应用中可能会有不同的含义。拥有通用标记的类型大部分是简单类型，如BIT STRGING、INTEGER、IA5String、OBJECT IDENTIFIER等，也有结构类型如SEQUENCE、SET等。一个简单的ASN.1文件如下：

Person ::= SEQUENCE {
	age INTEGER,
	name OCTETSTRING,
	birth Date, -- 注释：这里的组合类型在下面定义
}
Date ::= SEQUENCE {
	year INTEGER,
	month INTEGER,
	day	INTEGER
}

ASN.1仅仅是一个抽象的表示方法，编码方式则定义在X.209中。常见的编码实现有：

  • BER：Basic Encoding Rules
  • DER：Distinguished Encoding Rules
  • XER：XML Encoding Rules
  • JER：JSON Encoding Rules
  • …

编码实现多种多样，和RSA相关的主要是DER编码。DER是BER的一个子集，编码方式为TLV(Type-Length-Value)结构，具体定义在X.509标准中。

在密码学中，X.509定义了公钥证书的标准(RFC5280)，其最常见的应用场景之一就是HTTPS中的TLS/SSL认证中。公钥证书中包括公钥和身份信息(如域名、组织或个人)，并且是经过签名的。权威认证的签名机构CA(certificate authority )公钥证书预置在我们的浏览器或者操作系统中，因此可以认证签名的有效性。

bili.jpg

X.509同样使用ASN.1来描述，但经历了多个版本的变化，例如：

事实上X.509是由国际电信联盟(ITU)管理的，权威版本可以在ITU的网站上看到，同时ITU也提供了X.509以及对应拓展包的ASN.1压缩包下载。

X509中定义了许多字段，列举一些常见的解释一下：

  • Serial Number：CA所签名的证书都都包含的一个针对该CA的序列号
  • Subject：主题名称，CA所签名的目标对象标识符，通常使用X.500或者LDAP格式来描述
  • Issuer：签发者名称，CA本身的标识符。对于自签名的证书而言，Issuer和Subject是相同的，例如根证书
  • Subject Public Key Info：Subject的公钥信息，包括公钥算法和对应的公钥，例如RSA公钥则包括之前介绍过的模n和公钥指数e的值
  • Signature：Issuer对Subject公钥证书的签名
  • Validity period：Issuer对Subject公钥证书签名的有效时间

以B站的的HTTPS证书为例，我们也可以使用openssl查看公钥详细信息：

$ openssl s_client -connect bilibili.com:443 -showcerts 2>/dev/null | openssl x509 -noout -text -nameopt multiline,-esc_msb,utf8
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number:
            27:6d:f4:81:02:c7:45:53:a7:ee:12:58
    Signature Algorithm: sha256WithRSAEncryption
        Issuer:
            countryName               = BE
            organizationName          = GlobalSign nv-sa
            commonName                = GlobalSign Organization Validation CA - SHA256 - G2
        Validity
            Not Before: Sep 18 09:32:07 2018 GMT
            Not After : Sep 18 09:21:04 2020 GMT
        Subject:
            countryName               = CN
            stateOrProvinceName       = 上海
            localityName              = 上海
            organizationName          = 上海幻电信息科技有限公司
            commonName                = *.bilibili.com
        Subject Public Key Info:
            Public Key Algorithm: rsaEncryption
                Public-Key: (2048 bit)
                Modulus:
                    00:da:ce:77:ab:d9:e2:99:25:28:c1:4c:8e:15:ac:
                    22:5a:8a:31:80:0f:20:3b:1d:a9:a6:d2:76:71:25:
                    a0:8b:08:41:31:7a:7f:b9:d3:12:f4:c0:d6:d5:03:
                    bf:7b:e7:56:f2:f0:5b:c4:69:ca:6f:aa:d5:eb:86:
                    a7:06:2f:67:2b:93:d2:70:33:45:40:f7:18:48:68:
                    d4:4f:65:5c:91:7c:aa:64:d4:e2:37:7b:7e:66:83:
                    fe:b3:be:69:20:9b:20:5d:dd:1a:02:0d:53:e8:2a:
                    91:7a:84:c5:12:66:bb:51:6c:c0:40:4a:9d:b5:19:
                    39:35:3a:1d:80:55:7f:b0:85:61:8e:a5:87:24:7c:
                    32:59:35:0d:2c:2e:80:6d:f1:a4:96:1d:12:aa:c9:
                    a6:88:90:15:18:b3:c6:93:8e:49:36:53:20:d7:23:
                    6c:5c:40:4e:23:87:8b:9f:6b:41:d2:52:ac:18:65:
                    d8:6f:d9:a0:43:e6:e9:45:a2:81:e2:7e:f5:8b:0d:
                    91:d2:c0:93:9b:8c:65:18:93:c1:de:1f:f2:82:0c:
                    43:54:17:e9:79:7d:3d:d3:6b:bf:2b:d2:02:8a:93:
                    7c:13:8f:1f:4f:62:81:58:54:81:4f:70:83:57:b0:
                    47:62:1b:81:00:76:3c:46:6d:e7:07:1d:aa:35:5a:
                    c8:f9
                Exponent: 65537 (0x10001)
        X509v3 extensions:
            X509v3 Key Usage: critical
                Digital Signature, Key Encipherment
            Authority Information Access:
                CA Issuers - URI:http://secure.globalsign.com/cacert/gsorganizationvalsha2g2r1.crt
                OCSP - URI:http://ocsp2.globalsign.com/gsorganizationvalsha2g2

            X509v3 Certificate Policies:
                Policy: 1.3.6.1.4.1.4146.1.20
                  CPS: https://www.globalsign.com/repository/
                Policy: 2.23.140.1.2.2

            X509v3 Basic Constraints:
                CA:FALSE
            X509v3 Subject Alternative Name:
                DNS:*.bilibili.com, DNS:bilibili.com
            X509v3 Extended Key Usage:
                TLS Web Server Authentication, TLS Web Client Authentication
            X509v3 Subject Key Identifier:
                0D:DB:87:B5:F7:C5:57:18:2B:1F:71:56:19:64:1A:DE:C3:C9:12:06
            X509v3 Authority Key Identifier:
                keyid:96:DE:61:F1:BD:1C:16:29:53:1C:C0:CC:7D:3B:83:00:40:E6:1A:7C

            1.3.6.1.4.1.11129.2.4.2:
                ...i.g.u..u..Y|..C._..n.V.GV6.J.`....^......e.........F0D. ^.R..~AV|..A.....@..c.......u ... A$MqBP..iY1Jl]c......}..o.p.(.t..v.......X......gp
.....e.........G0E. s.2...-.*+..!......+Ui..2....j;..!..v..v$-m.R..Z#J. TB....3...7x..Y.v.oSv.1.1.....Q..w.......).....7.....e.........G0E.!....v]W....'.\G.]....B..Hn.c....u. ..Cb.....l0L.-.......O....7.....
    Signature Algorithm: sha256WithRSAEncryption
         35:13:01:e0:20:2c:84:ce:76:c9:91:9f:8e:74:f1:5e:49:0d:
         b9:2d:25:96:ae:e6:87:02:52:ce:0e:d7:64:71:81:8f:30:90:
         85:24:e1:2c:17:9c:78:31:97:c7:e8:c2:b2:3d:fd:b7:b1:41:
         25:94:1b:45:79:d4:33:8c:c0:1b:0c:0d:85:3b:8d:41:eb:0c:
         34:51:54:26:80:e6:a0:d4:ac:75:b3:c9:e9:16:8b:ae:9d:bd:
         2f:9a:2c:a2:29:49:20:aa:53:88:c7:70:64:ea:d6:67:a3:e7:
         c4:48:f1:16:64:a5:7a:6b:93:b0:af:00:ee:1c:5f:8d:d2:07:
         b7:ec:b7:da:1a:d8:e2:07:01:37:e0:78:6a:1c:d7:0d:9b:91:
         f0:7c:36:c6:8e:f2:59:d0:0a:f0:54:a8:db:a3:f5:c3:1a:24:
         03:38:86:b0:37:da:89:c1:70:35:c0:1e:02:a2:65:2a:95:68:
         b1:0e:40:56:0c:82:00:5d:8a:9f:f1:50:d9:ed:4b:43:d9:59:
         c8:70:75:ab:85:37:13:89:09:07:08:81:ca:b2:0a:bd:b9:57:
         52:d0:8d:4e:9c:64:06:4a:87:e3:71:3d:b5:47:91:a1:2d:0f:
         75:46:55:81:ea:a1:31:64:ce:27:c5:59:2e:bf:b5:2c:82:07:
         a2:32:b9:91

可以看到实际中的公钥指数e为65537，这里的Modulus即为n，使用冒号分隔十六进制的方式表示，转换为整数是0x00dace77d9e2...，另外如名字所言，X509第三版(v3)包含了可选的拓展选项，对于HTTPS而言最重要的是Subject Alternative Name，即所认证的域名。其他拓展选项详细说明可以参考RFC5280的介绍。

秘钥分析

最后再来分析几个实际落到我们磁盘上的秘钥结构。

对于开发者而言ssh都不会陌生，其除了可以使用密码登录远程服务器，也可以通过私钥登录。使用ssh-keygen工具可以直接生成私钥id_rsa和公钥id_rsa.pub，格式为RSA-2048。先看公钥：

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDEkBTUATNtj5xzF8S+CXzh+8A3LzTXeHyIZams0g37hAFi1SmYK82QAANxUzypUSZSHTY+WnMjOmNEpqgEmE5MWg3tYp4hK7tSyI2/UYUQu8y9KUPa7dnwYA+gkPWxM4sEu3u3bh6dP6bf/t8u6I1fca4tmiEcIqlq3DRz9YQXwIHr27ld5gHFiyEO6vi1ECtddnz6DKuzpQ6Dj1QNVmCF6N81DXfpmTRmVIZV+vZbfD35f1/iw116jQ5lW5VVF00fz7NqYgdK3KH9TiSexJduXjMczyamrTjotNpWZo98JcltkxJF1vYRPIDgX7rTbOzIV/DiCzgROU3JmacI9lmf evilpan

其中重要的中间的base64，解码后hexdump出来如下：

00000000: 0000 0007 7373 682d 7273 6100 0000 0301  ....ssh-rsa.....
00000010: 0001 0000 0101 00c4 9014 d401 336d 8f9c  ............3m..
00000020: 7317 c4be 097c e1fb c037 2f34 d778 7c88  s....|...7/4.x|.
00000030: 65a9 acd2 0dfb 8401 62d5 2998 2bcd 9000  e.......b.).+...
00000040: 0371 533c a951 2652 1d36 3e5a 7323 3a63  .qS<.Q&R.6>Zs#:c
00000050: 44a6 a804 984e 4c5a 0ded 629e 212b bb52  D....NLZ..b.!+.R
00000060: c88d bf51 8510 bbcc bd29 43da edd9 f060  ...Q.....)C....`
00000070: 0fa0 90f5 b133 8b04 bb7b b76e 1e9d 3fa6  .....3...{.n..?.
00000080: dffe df2e e88d 5f71 ae2d 9a21 1c22 a96a  ......_q.-.!.".j
00000090: dc34 73f5 8417 c081 ebdb b95d e601 c58b  .4s........]....
000000a0: 210e eaf8 b510 2b5d 767c fa0c abb3 a50e  !.....+]v|......
000000b0: 838f 540d 5660 85e8 df35 0d77 e999 3466  ..T.V`...5.w..4f
000000c0: 5486 55fa f65b 7c3d f97f 5fe2 c35d 7a8d  T.U..[|=.._..]z.
000000d0: 0e65 5b95 5517 4d1f cfb3 6a62 074a dca1  .e[.U.M...jb.J..
000000e0: fd4e 249e c497 6e5e 331c cf26 a6ad 38e8  .N$...n^3..&..8.
000000f0: b4da 5666 8f7c 25c9 6d93 1245 d6f6 113c  ..Vf.|%.m..E...<
00000100: 80e0 5fba d36c ecc8 57f0 e20b 3811 394d  .._..l..W...8.9M
00000110: c999 a708 f659 9f                        .....Y.

这些数据怎么解析呢？查阅RFC4253我们可以发现ssh公钥的定义如下：

The "ssh-rsa" key format has the following specific encoding:

      string    "ssh-rsa"
      mpint     e
      mpint     n

而在RFC4251中包含了string和mprint类型的定义：

string

    [...] They are stored as a uint32 containing its length
    (number of bytes that follow) and zero (= empty string) or more
    bytes that are the value of the string.  Terminating null
    characters are not used. [...]

mpint

    Represents multiple precision integers in two's complement format,
    stored as a string, 8 bits per byte, MSB first. [...]

说白了三个字段都是Length-Value格式，转换如下：

(4 bytes)   00 00 00 07          = 7
(7 bytes)   73 73 68 2d 72 73 61 = "ssh-rsa" 字符串
(4 bytes)   00 00 00 03          = 3
(3 bytes)   01 00 01             = 65537 (公钥指数e)
(4 bytes)   00 00 01 01          = 257
(257 bytes) 00 c4 .. f6 59 9f    = 模n

再看私钥：

-----BEGIN OPENSSH PRIVATE KEY-----
b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAABFwAAAAdzc2gtcn
NhAAAAAwEAAQAAAQEAxJAU1AEzbY+ccxfEvgl84fvANy8013h8iGWprNIN+4QBYtUpmCvN
kAADcVM8qVEmUh02PlpzIzpjRKaoBJhOTFoN7WKeISu7UsiNv1GFELvMvSlD2u3Z8GAPoJ
...
-----END OPENSSH PRIVATE KEY-----

注意这里和网上很多文章说的不太一样了，因为之前ssh-keygen生成的直接是RSA私钥，比如：

-----BEGIN RSA PRIVATE KEY-----
MIICXAIBAAKBgQCqGKukO1De7zhZj6+H0qtjTkVxwTCpvKe4eCZ0FPqri0cb2JZfXJ/DgYSF6vUp
wmJG8wVQZKjeGcjDOL5UlsuusFncCzWBQ7RKNUSesmQRMSGkVb1/3j+skZ6UtW+5u09lHNsj6tQ5
1s1SPrCBkedbNf0Tp0GbMJDyR4e9T04ZZwIDAQABAoGAFijko56+qGyN8M0RVyaRAXz++xTqHBLh
...
-----END RSA PRIVATE KEY-----

前者是PKCS#1定义的DER编码私钥，在下一节中详细介绍。以前openssh默认是支持PKCS#1的，不过现在使用了自己的一套格式，大致布局如下：

"openssh-key-v1"0x00    # NULL-terminated "Auth Magic" string
32-bit length, "none"   # ciphername length and string
32-bit length, "none"   # kdfname length and string
32-bit length, nil      # kdf (0 length, no kdf)
32-bit 0x01             # number of keys, hard-coded to 1 (no length)
32-bit length, sshpub   # public key in ssh format
    32-bit length, keytype
    32-bit length, pub0
    32-bit length, pub1
32-bit length for rnd+prv+comment+pad
    64-bit dummy checksum?  # a random 32-bit int, repeated
    32-bit length, keytype  # the private key (including public)
    32-bit length, pub0     # Public Key parts
    32-bit length, pub1
    32-bit length, prv0     # Private Key parts
    ...                     # (number varies by type)
    32-bit length, comment  # comment string
    padding bytes 0x010203  # pad to blocksize (see notes below)

详细关于OpenSSH新的私钥格式详情可以参考：

AVB即Android Verified Boot，是安卓中对系统镜像完整性保护的方案。最近在工作中有对其进行了一点研究，不过这里并不是深入介绍AVB，而只看其中涉及到RSA的秘钥。

在我们自行编译安卓源码(AOSP)时，会发现一系列秘钥：

$ ls  build/target/product/security/
Android.mk  media.x509.pem     shared.pk8       testkey.x509.pem  verity_key
README      platform.pk8       shared.x509.pem  verity.pk8
media.pk8   platform.x509.pem  testkey.pk8      verity.x509.pem

每组秘钥分别负责用来对不同的组件进行签名，我们主要看Verified Boot相关的秘钥verity，安卓中使用该秘钥对boot.img进行签名，并自定义了签名的ASN.1格式：

    AndroidVerifiedBootSignature DEFINITIONS ::=
    BEGIN
        formatVersion ::= INTEGER
        certificate ::= Certificate
        algorithmIdentifier ::= SEQUENCE {
            algorithm OBJECT IDENTIFIER,
            parameters ANY DEFINED BY algorithm OPTIONAL
        }
        authenticatedAttributes ::= SEQUENCE {
            target CHARACTER STRING,
            length INTEGER
        }
        signature ::= OCTET STRING
    END

其中证书Certificate类型是在X.509中定义的。

私钥的存储格式有几种常见类型，比如PKCS#1(RFC3447)和PKCS#8(RFC5208)。

例如PKCS#1中定义私钥的ASN.1表示如下：

  Version ::= INTEGER { two-prime(0), multi(1) }
      (CONSTRAINED BY
      {-- version must be multi if otherPrimeInfos present --})

  RSAPrivateKey ::= SEQUENCE {
      version           Version,
      modulus           INTEGER,  -- n
      publicExponent    INTEGER,  -- e
      privateExponent   INTEGER,  -- d
      prime1            INTEGER,  -- p
      prime2            INTEGER,  -- q
      exponent1         INTEGER,  -- d mod (p-1)
      exponent2         INTEGER,  -- d mod (q-1)
      coefficient       INTEGER,  -- (inverse of q) mod p
      otherPrimeInfos   OtherPrimeInfos OPTIONAL
  }

一般而言，我们保存的私钥都是der格式，即使用DER对相应的ASN.1定义进行编码。许多高级语言中提供了对应的库函数方便从DER中进行反序列化获取原始数据，比如Python的from Crypto.Util.asn1 import DerSequence。同时也有些在线工具可以方便查看DER的反序列化内容，比如：

回到上面的verity私钥，我们将其转换为PKCS#1格式：

openssl pkcs8 -nocrypt -in build/target/product/security/verity.pk8 -inform DER

解析对应的字段并将其与上面的ASN.1对比。

SEQUENCE (3 elem)
  INTEGER 0
  SEQUENCE (2 elem)
    OBJECT IDENTIFIER 1.2.840.113549.1.1.1 rsaEncryption (PKCS #1)
    NULL
  OCTET STRING (1 elem)
    SEQUENCE (9 elem)
      INTEGER 0
      INTEGER (2048 bit) 294034013011457495254632688690709311939827882765990777183788030470572…
      INTEGER 65537
      INTEGER (2047 bit) 152690229409630177395988743674731983661872870808474054654559379297267…
      INTEGER (1024 bit) 172086361699816285157285992007634379277365906572602995588734914497382…
      INTEGER (1024 bit) 170864216145358483792372871509731496788274625374475577044849125456480…
      INTEGER (1024 bit) 121316723122128141459586606081095008794617691006109580880887598144682…
      INTEGER (1024 bit) 160008079977555979458768333051051332108378146438007378884805916911676…
      INTEGER (1024 bit) 111229147058742660120109027367598084873926761525467238165320120548663…

可以对应RSA秘钥的各个元素：

  • n = 2940340130…
  • e = 65537
  • d = 1526902294…
  • …

后记

本文主要介绍了RSA的基本原理以及常见的安全陷阱，其中大部分的实现隐患出在定义中关于选择的地方，比如对于质数p、q以及公钥指数e的选择，在某些情况下选择不当会导致在数学上求解难度骤减；RSA裸加密本身并非语义安全，容易受到CPA攻击。对于现代机器学习而言，通过学习语义从端到端还原明文也不是不可能的事。

除此之外，RSA还存在时序攻击、随机数以及侧信道等潜在威胁没有在文中介绍。即便小心翼翼地按照最佳实践去实现了RSA，也依然有不确定性：大质数分解真的很难吗？这个问题目前并没有确切证伪，只有经验性的结论。有人说RSA-2048坚不可摧，对于这点我还是持怀疑态度，不说NSA已经“破解”了RSA，至少对于满足某些条件的质数，可能存在特别的分解方式，毕竟历史上密码学的后门总是留得猝不及防。

虽然存在不确定性，RSA也已经是当今最为广泛使用的秘钥基础设施根基，所以文章也对常见的实现标准和一些常见秘钥进行了介绍和分析，一方面是对自己学习研究的记录，另一方面也希望能对感兴趣的朋友提供点参考。如果你也对密码学感兴趣，欢迎加群一起交流学习！

参考资料

]]> 非对称加密与OpenSSL https://evilpan.com/2016/10/29/about-openssl/ Sat, 29 Oct 2016 22:40:00 +0800 evilpan https://evilpan.com/2016/10/29/about-openssl/ 随着个人隐私越来越受重视, HTTPS也渐渐的流行起来, 甚至有许多网站都做到了全站HTTPS, 然而这种加密和信任机制也不断遭遇挑战,比如戴尔根证书携带私钥,Xboxlive证书私钥泻露, 还有前一段时间的沃通错误颁发Github根域名SSL证书事件. 因此本文从非对称加密说起, 介绍了证书的签证流程, 并且通过openssl的命令行工具对这些过程都转化为相对具体的命令, 也算是一个温故知新的简要记录吧.

前言

一般来说,常见的数字加密方式都可以分为两类,即对称加密和非对称加密. 对于对称加密来说, 加密和解密用的是同一个密钥, 加密方法有AES,DES,RC4,BlowFish等; 对应的, 非对称加密在 加密和解密时, 用的是不同的密钥, 分别称为公钥或私钥. 非对称加密的加密方法有RSA, DSA, Diffie-Hellman等.

OpenSSL是一个开源项目,为传输层安全(TLS)和安全套接字(SSL)协议提供了比较完整的实现, 同时也致力于将自身打造为一个通用的密码学工具集. 其中包括:

  • libssl : 提供了SSL(包括SSLv3)和TLS的服务器端以及客户端的实现.
  • libcrypto : 通用的密码学库以及对X.509的支持
  • openssl : 一个多功能的命令行工具

本文主要使用openssl的命令行工具来示例非对称加密的流程, 如果有兴趣的话,也可以用其SDK 来实现更具体的操作.

加解密过程

首先用openssl生成私钥:

openssl genrsa -out private.pem 1024 

当然为了更加安全,可以在生成私钥的时候同时指定密码, 这样即使不小心泻露了私钥,也能增加别人的盗用难度:
openssl genrsa -aes256 -passout stdin -out private.pem 1024
openssl genrsa -aes256 -passout file:passwd.txt  -out private.pem 1024
openssl genrsa -aes256 -passout pass:my_password -out private.pem 1024

其中 -passout 指定密码的输入方式,可以分别是stdin,从文件中读取或者紧接着pass:后面输入. 有了私钥,便可以从其中提取出公钥:

openssl rsa -in private.pem -pubout -out public.pem

在一次秘密的信息传输中, 我们首先通过可信的方式(比如面对面)将公钥告知对方, 对方发送机密信息的时候 就可以用我们的公钥加密:

openssl rsautl -encrypt -pubin -inkey public.pem -in file.txt -out file.txt.enc

在发送的过程中即便泄露了文件,也无法查看文件的明文信息. 而我们收到密文后, 用私钥解密即可:

openssl rsautl -decrypt -inkey private.pem -in file.txt.enc -out file.txt.dec

虽然公私钥加密很好用, 但事实上非对称加密的缺点是加解密速度要远远慢于对称加密, 在某些极端情况下, 甚至能比非对称加密慢上千倍. 另外由于RSA算法的工作机理, 如果密钥是n比特的,那么其加密的信息容量就 不能大于(n-11)比特. 因此对于大文件的加密传输, 通常还是使用对称加密的方式, 例如

openssl rand -base64 128 -out aeskey.txt
openssl enc -aes-256-cbc -salt -in file.txt -out file.txt.aesenc -pass file:aeskey.txt
openssl enc -d -aes-256-cbc -in file.txt.aesenc -out file.txt.aesdec -pass file:aeskey.txt

其中aeskey.txt是我们随机生成密码文件, 并且用其可以对大文件进行对称的加解密, 在实际中, 通常还会将密码文件用公私钥加密的方式来发送给对方. 值得一提的是,这也正是PGP的工作方式, 如下图所示:

pgp

证书

对任一个体来说, 它都有公钥,私钥和证书. 其中私钥用来加密发出去的信息,公钥用来解密收到的信息, 而证书则用来证明自己的身份. 一般来说,证书中包含自己的公钥以及额外的信息,如签发机构(CA, Certificate Authority), 证书用途(比如适用的域名)和有效时间等. CA通常是个第三方的可信机构, 比如VeriSign, GeoTrust, DigiCert和沃通等, 当然也可以是未知的主体, 比如说自己.

获得一张证书的流程通常是: 1)用私钥生成证书签名请求(csr), 2)将csr文件发送给CA,待其验证信息无误后, CA会用自己的私钥对其进行签名表示确认.

证书签名请求(Certificate Signing Request)通常以.csr为后缀, 包含了请求方的公钥和主体的详细信息, 如域名,公司名,国家,城市等信息, 其完整内容可以参考这里. 使用openssl也能很方便地生成csr:

openssl req -new -key private.pem -out pppan.csr

默认会在stdin中根据提示交互地输入主体信息,也可以通过 -config 选项来从文件中读取. 生成完之后可以通过:

openssl req -in pppan.csr -noout -text

来查看csr文件中的详细信息.

当CA收到csr文件并且对请求方的域名,公司等内容校验无误后,便可以对csr请求进行确认(签名),

openssl req -x509 -newkey rsa:4096 -nodes -keyout cakey.pem -out cacert.pem -outform PEM
openssl ca -config openssl-ca.cnf -policy SP -extensions SR -infiles pppan.csr -out pppan.crt

虽然这不是重点, 但也稍微解释下这两个命令的意思吧. 第一个命令是CA一开始创建私钥和CA的证书, 第二个命令表示对csr文件进行签名确认, 用-config指定自定义的配置文件, 如果不指定则默认为/usr/lib/ssl/openssl.cnf, SP和SR都是自定义于配置文件中的信息, 此外配置文件中还包括CA证书路径和私钥路径,以及对req的默认校验策略等, 有兴趣的可以查看详细解释.

另外值得一提的是, 我们用自己的私钥也可以生成证书, 并且也能用这个证书来对自己的csr进行签名, 这通常称为自签名(self-signed), 上面CA生成的证书cacert.pem就是自签名的. 一般来说, 如果是自己随便生成自签名证书, 都是会被认为是不可信的, 除非对方也将其添加到信任CA证书列表中.

CA对csr进行签名后, 我们就能得到对应的证书, 这里是pppan.crt, 可以用openssl查看证书的详细信息:

openssl x509 -noout -text -in pppan.crt

可以看到具体的签发机构,签发时间和证书的有效时间等信息. 可以用命令验证证书是否有效:

openssl verify -CAfile Trusts.pem pppan.crt

其中Trusts.pem是一系列所信任的证书集合,其中也包括了上述CA的证书cacert.pem

其他

上面所有用到的证书及其组件,如公钥,私钥,csr等,其格式都是PEM的,这也是最常见的一种格式, 可以用文本便及其打开,通常是以-----BEGIN XXX------开头, 以-----END XXX-----结束, 中间的部分则是实际密钥的base64编码, 其二进制表示也称为DER格式, 两者可以用base64转化, 因此都属于x509实现的证书格式.

还有比较常见的证书格式,为PKCS7和PKCS12. 其中PKCS7是由JAVA使用的开放标准,并且也被 Windows所支持, 其内是不包含私钥信息的; 而PKCS12则是一种非公开的标准,用来提供比PEM的 纯文本格式更高的安全性, 这是Windows建议使用的格式, 其中可以包含私钥信息.

不同格式的转换如下所示.

PEM <-> DER:

openssl x509 -in bar.pem -outform der -out bar.der
openssl x509 -inform der -in foo.der -out foo.pem

PEM <-> PKCS7:

openssl crl2pkcs7 -nocrl -certfile foocert.pem -out foocert.p7b 
openssl pkcs7 -in foocert.p7b  -print_certs -out barcert.pem

PEM <-> PKCS12:

openssl pkcs12 -inkey private.key -in foocert.pem -export -out foocert.pfx
openssl pkcs12 -in foocert.pfx -nodes -out barcert.pem

当今我们使用最多的https本质上就是在http协议的基础上对传输内容进行了非对称的加密, 当然实现过程多了很多复杂的交互, 感兴趣的可以去查看SSL和TLS协议. 我想说的是, 这一切信任机制的基石是对于CA的信任, 如果说CA的私钥泻露,或者我们错误地信任了一个坏CA, 那么https的隐私性也就不复存在了, 因为其可能对无效的csr进行签名, 从而使得https中间人攻击 成为现实. 据说早在两年前伟大的防火墙就已经可以对https进行监听,敏感词识别和连接重置, 后来因为某种原因才从大范围应用转为只对特殊对象使用,不过那是后话了.

]]>