基于离散对数问题的公钥密码体制（二）：离散对数问题

在上一篇文章当中花了较大篇幅对群进行了介绍，通过循环群就可以对本文所提到的离散对数问题（DLP） 进行解释。

首先来看离散对数问题的一般定义：

定义1. 离散对数问题（DLP）

给定一个阶为$n$的群$G$，群操作为$\circ$，有一生成元$\alpha \in G$以及一元素$\beta \in G$，找到一个满足$1\le x\le n$的整数$x$，满足：
$$\beta =\underset{x次}{\underbrace{\alpha \circ \alpha \circ \cdots \circ \alpha }}={\alpha }^x，$$
也可表示为：
$$x={\log }_{\alpha }\beta .$$

DLP可被用来构造单向函数，单向函数指的是假设有一个函数$F$，已知输入$x$计算$y=F(x)$是计算简单的，而已知输出$y$计算$x=F^{-1}(y)$在计算上是困难的。带入到DLP中，我们可以得到正向问题为：$\beta =F(x)={\alpha }^x$；而逆向问题为：$x=F^{-1}(\beta )={\log }_{\alpha }\beta$​。如果选择了合适的群，那么正向计算出$\beta$很容易，而逆向计算出$\alpha$是个很困难的问题。

为了方便大家对DLP的理解，这里先介绍基于群${\mathbb{Z}}_p^{\ast }$​的DLP，其中$p$​是一个素数。在上一篇文章中介绍过，${\mathbb{Z}}_p^{\ast }$​是由小于$n$​且与$n$​互素的正整数所构成的集合，${\mathbb{Z}}_p^{\ast }$​对于模$q$​的乘法构成一个阿贝尔有限循环群。如果参数足够大的话，在群$({\mathbb{Z}}_p^{\ast },\cdot )$中计算离散对数是个非常困难的问题。

示例1

考虑群${\mathbb{Z}}_{47}^{\ast }$内的DLP，其中该群生成元为$\alpha =5$，对于$\beta =41$的DLP可以被表示为：
$$x\equiv {\log }_{5}41\mathrm{m}\mathrm{o}\mathrm{d}47.$$
找到$x$的唯一办法就是暴力搜索，即尝试所有可能的$x$值，最终得到$x=15$。但即使是用这么小的数字，找到$x$​也不是一件容易事。

在实际中，为了安全性（主要为了防止Pohlig-Hellman攻击），群的阶数最好是素数，对于上面提到的${\mathbb{Z}}_p^{\ast }$，其阶为$p-1$，显然不是素数，所以人们常会选择${\mathbb{Z}}_p^{\ast }$的子群中阶为素数的子群来建立DLP，而不是${\mathbb{Z}}_p^{\ast }$本身。

示例2

${\mathbb{Z}}_{47}^{\ast }$的阶为46，根据前一篇文章中的子群性质，可知${\mathbb{Z}}_{47}^{\ast }$的子群的阶只能为1、2、23，由于$ord(2)=23$，所以$\alpha =2$是${\mathbb{Z}}_{47}^{\ast }$的有23个元素的子群$H$的生成元。我们找到一个元素$\beta \in H$，其中$\beta =36$，建立DLP：找到一个正整数$x$（$1\le x\le 23$）使得
$$36\equiv 2^x\mathrm{m}\mathrm{o}\mathrm{d}47.$$
利用暴力搜索可以得到x=17。

需要注意的一点是，并不是在所有循环群中的DLP都是困难的，这样的循环群就不能被用于构造DLP难题，DLP也不会是一个单向函数。

示例3

考虑整数模素数加法群，例如$({\mathbb{Z}}_{11},+)$是一个生成元为$\alpha =2$的有限循环群，下表能够展示出$\alpha$生成整个群的过程：

i	1	2	3	4	5	6	7	8	9	10	11
${\alpha }^i$	2	4	6	8	10	1	3	5	7	9	0

现在我们设$\beta =3$，建立DLP：找到一个整数$x$（$1\le x\le 11$）使得
$$\underset{x次}{\underbrace{2+2+\cdots +2}}\equiv 3\mathrm{m}\mathrm{o}\mathrm{d}11$$
即
$$x\cdot 2\equiv 3\mathrm{m}\mathrm{o}\mathrm{d}11.$$
虽然该群中的运算是模11加法，但是$\alpha$、$\beta$、$x$​之间的关系却可以被模11乘法表示，那么为了求解$x$，可以简单地对$\alpha$求逆元：
$$x\equiv 2^{-1}\cdot 3\mathrm{m}\mathrm{o}\mathrm{d}11$$
求逆元的算法并不复杂，可以根据扩展欧几里得算法（后续文章会提到）计算出$2^{-1}\equiv 6\mathrm{m}\mathrm{o}\mathrm{d}11$​，然后就能得到：
$$x\equiv 7\mathrm{m}\mathrm{o}\mathrm{d}11.$$
从上面的表格就能验证出这个结果是正确的。

上面示例3的结果可以被推广到$n$为任意值且元素$\alpha$、$\beta \in {\mathbb{Z}}_n$的任何群$({\mathbb{Z}}_n,+)$中，因此可以得到结论在${\mathbb{Z}}_n$中计算推广的DLP会非常简单。

介绍完反例以后，下面列举一些密码学中推荐使用的一些离散对数问题：

1. 素数域${\mathbb{Z}}_q$的乘法群或其子群，例如古典Diffie-Hellman密钥交换、ElGamal或数字签名算法（DSA）都用到了这个群；
2. 椭圆曲线构成的循环群，后续文章会介绍到，它们如今逐渐占据了密码学主流位置；
3. 伽罗瓦域$GF(2^m)$上的乘法群或其子群，和1的使用完全一致，但并不常用，因为针对其的攻击要比针对1的攻击更加强大，因此在提供相同安全等级的情况下基于$GF(2^m)$的DLP要求参数长度比1更长。

下面介绍一种非暴力搜索的解决离散对数问题的算法，名为Shanks’ Baby-Step Giant-Step方法，或简称为BSGS。BSGS是一个时间与内存平衡的方法，它通过额外的存储来减少蛮力搜索的时间。

BSGS算法的思想是将群$G$中离散对数$x={\log }_{\alpha }\beta$​重写为
$$x=x_{g}m+x_b,0\le x_g,x_b<m.$$
通常情况下$m$的大小选择为群的阶的平方根，即$m=\lceil \sqrt{|G|}\rceil$。下面可以将离散对数进行变形：
$$\begin{array}{rl}\beta & ={\alpha }^{x_{g}m+x_b}\\ \beta ({\alpha }^{-m}{)}^{x_g}& ={\alpha }^{x_b}\end{array}$$
算法的核心思想就是找到上面方程的解$(x_g,x_b)$，进而就能得到离散对数问题的解$x$。该算法分为两阶段，即baby-step和giant-step。

Baby-Step

在此阶段，要计算并存储所有${\alpha }^{x_b}$​的值，其中$0\le x_b<m$​。这一步需要$m$个群操作，并需要存储$m$个群元素。

Giant-Step

在此阶段，算法检查$0\le x_g<m$​范围内所有的$x_g$，并判断baby-step阶段计算的一些易存储的项${\alpha }^{x_b}$是否满足以下条件：
$$\beta ({\alpha }^{-m}{)}^{x_g}\stackrel{?}{=}{\alpha }^{x_b}$$
如果上面等式成立，那么就意味着找到了一个解$(x_{g0},x_{b0})$​​​​​满足上面的等式，这样离散对数问题的解$x$就可以表示为
$$x=x_{g0}m+x_{b0}.$$
BSGS算法需要$\mathcal{O}(\sqrt{|G|})$计算复杂度和相同大小的存储复杂度，因此一般为了追求$2^{80}$的攻击复杂度，群的阶至少为$|G|\ge 2^{160}$，因此在$G={\mathbb{Z}}_p^{\ast }$中，素数$p$的长度应该有160bit。

下面是用Python3对BSGS算法的代码实现，关键步骤在代码中都有注释：

from math import sqrt, ceil


def bsgs_alg(alpha: int, beta: int, p: int) -> int:
    # 求出m
    m = ceil(sqrt(p - 1))

    # 初始化一个baby数组，存放baby-step结果
    baby = []

    x_g, x_b = -1, -1

    # baby-step
    baby.append(1)
    for i in range(1, m):
        baby.append((baby[i - 1] * alpha) % p)

    # 对生成元求逆
    alpha_inv = (alpha ** (p - 2)) % p
    # 求alpha逆元的m次幂
    alpha_pow = (alpha_inv ** m) % p

    # giant-step
    product = beta % p
    for j in range(m):
        try:
            # 查询baby表中是否有匹配的
            x_b = baby.index(product)
            x_g = j
            break
        except ValueError:
            product *= alpha_pow
            product %= p

    if x_b == -1:
        return x_b
    else:
        return x_g * m + x_b

写在最后

欢迎大家关注我的微信公众号，本人会不定期发一些有关密码学、区块链技术、编程等相关文章，欢迎志同道合的朋友来一起交流呀！