基于有限域Chebyshev多项式的类ElGamal公钥密码算法

最新推荐文章于 2023-10-16 23:18:58 发布

冒险梦师

最新推荐文章于 2023-10-16 23:18:58 发布

阅读量528

点赞数 3

分类专栏：脚本/主题文章标签：算法人工智能机器学习 python

本文链接：https://blog.csdn.net/qq_46123866/article/details/127562685

版权

脚本/主题专栏收录该内容

3 篇文章 1 订阅

订阅专栏

概述

复现论文：《基于混沌理论的非对称加密算法研究》

复现算法：基于有限域Chebyshev多项式的类ElGamal公钥密码算法

编程语言：Python

采用论文中的方法：

矩阵特征值法赋值ChebyShev多项式
素数生成Miller-Rabin算法

库依赖：

需要下载第三方库gmpy2库
这个库实现了求e模p的逆元
求逆元操作直接导入库了

代码文件组成：

alogrithm.py公钥算法文件
Miller-Rabin.py素性检验算法
赋值ChebyShev多项式的方法
- common_method.py 普通递归法
- quick_method.py快速递归法
- charactor_method.py 矩阵特征值法
test.py：是分析三种方法的效率的程序

程序运行方式：根据命令行提示进行输入数据

不足或改进之处：命令行输入不方便，可以写一个GUI程序

论文介绍

论文中主要叙述的三种算法，

基于Chebyshev多项式的类ElGamal公钥密码算法
基于有限域Chebyshev多项式的类ElGamal公钥密码算法
改进的基于有限域Chebyshev多项式的类ElGamal公钥密码算法

Chebyshev多项式

$T_{p+1}=2xT_p(x)-T_{p-1}(x),p\geq2,T_1=x$

一个显著的星光值是其班群特性

$T_r(T_s(x))=T_{rs}(x), r,s \in Z$

满足复合律

$T_s(T_r(x))=T_r(T_s(x)),r,s\in Z$

有限域Chebyshev多项式

定义：令 $n\in Z^+$ ，变量 $x\in Z_p$ ,则多项式 $T_n(x):Z_p -> Z_p$ 的递推关系定义为：

$T_{p+1}=(2xT_p(x)-T_{p-1}(x))(mod\;P),n\geq2$ ,且有 $T_0(X)\equiv1(mod\;p)$ $T_1(X)\equiv x(mod\;p)$

算法描述

设N=P*Q，P和Q为两个大素数，则有（A mod N）(mod P)=A(mod P)。根据这一性质，本章提出了一种改进的基于有限域Chebyshev多项式的类ELGamal公钥密码算法。改进后的算法同样有密钥残生算法，加密算法和机密算法构成。

密钥产生算法：（Alice需要产生密钥）

产生一个大的随机数P和Q，计算N=P*Q;
随机残生一个大整数x，是的x<P;
随机残生一个随机数2<=s<P,并计算A=Ts(x)(mod P);
Alice的公开密钥为（x,N,A）,密钥为（S,P）

加密算法：（Bob需要将明文m加密）

获得Alice的公开密钥（x,N,A）;
将m看做一个整数并将m分段，使得m属于Z_p，0<m<x;
选择一个随机整数2<=r<x;
计算B=Tr(x)(mod N)和X=m*Tr(A)(mod N);
将密文消息（B,X）传给Alice。

解密算法：（Alice需要将密文c还原成m）

使用密钥P计算C=B(mod P)
使用密钥s计算D=Ts©(mod P)
计算m=X*D^-1(mod P)恢复明文m。

基于有限域Chebyshev多项式的类ElGamal公钥密码算法实现

大整数的实现

因为编程语言是python，所以不需要考虑大整数的存储和运算。

大素数的生成

论文中使用的是很容易实现并且广泛应用的简单算法——Miller-Rabin素性测试法。本身算法不难

代码如下：

import random
def quickPowMod(a,n,m):
    re = 1
    base = a % m
    while(n>0):
        temp = n&1
        if (temp):
            re = (re*base) % m
        base = (base*base) % m
        n >>= 1
    return re

def Miler_Rabin(P,m=15):
    flag = 0
    for _ in range(0, m):
        a = random.randint(2, P-1)
        temp = quickPowMod(a,P-1,P)
        if temp != 1:
            flag = 1
            break
    if flag == 0:
        print("{} 是素数".format(P))
    else:
        print("{} 不是素数".format(P))

有限域Chebyshev多项式运算的实现

普通递归法

根据Chebyshev多项式的性质和定义，可以得到：

$T_{2n}=T_2(T_n(x)) \\ T_{2n+1}=2T_{n+1}T_n(x)-x$

应用到Chebyshev多项式的赋值运算中，得到：

当n为偶数时：

$T_n=2T^2_{n/2}-1$

n为奇数时

$T_n=2T_{n+1/2}T_{n-1/2}-x$

import time
import doctest
def func(n,x,p):
    '''
    >>> func(155033642076,8909654478045,431084178421767)
    290588719813696
    '''
    if n==0:
        return 1
    elif n==1:
        return x
    elif n%2==0:
        temp=func(n//2,x,p)
        re=2*temp*temp-1
        return re%p
    else:
        re=2*func((n+1)//2,x,p)*func((n-1)//2,x,p)-x
        return re%p

测试数据：func(155033642076,8909654478045,431084178421767)

输出

290588719813696
耗时： 2.061542510986328

快速递归法

流程对整数n，有：

首先计算偶数部分，得到A
计算奇数部分的时候重复利用A

根据递归函数的思想，首先判断n的值是否为0，若为0，则满足递归程序的出口条件，返回值1，若n为1返回值x；否则判断n是否为偶数：若为偶数，则n/2递归。为奇数时还需要判断模4为1还是3，然后根据结果进行相应的递归。

def func(n,x,p):
    if n==0:
        return 1
    elif n==1:
        return x
    elif n%2==0:#偶数
        temp=func(n//2,x,p)
        return (2*temp*temp-1)%p
    else:
        if n%4==1:
            odd=(n+3)//4
            even=(n-1)//4#偶数
        else:
            odd=(n-3)//4
            even=(n+1)//4
        A=func(even,x,p)
        B=func(odd,x,p)
        C=(2*A*A-1)%p
        D=(2*A*B-x)%p
        return (2*C*D-x)%p

测试

测试数据

n=155033642076
x=8909654478045
p=431084178421767

调用函数

func(155033642076,8909654478045,431084178421767)

输出

290588719813696
耗时： 0.01200246810913086

与普通递归法相比快速递归法赋值ChebyShev多项式在速度上快了20几倍

矩阵特征值法

分析

将有限域Chebyshev多项式的表达式协程表达式：

$\begin{pmatrix}T_n\\T_{n+1}\end{pmatrix}=\begin{pmatrix}0&1\\-1&2x\end{pmatrix}.\begin{pmatrix}T_{n-1}\\T_{n}\end{pmatrix}(mod\;P)=\begin{pmatrix}0&1\\-1&2x\end{pmatrix}^n\begin{pmatrix}T_0\\T_1\end{pmatrix}(mod\;P)=A^n.\begin{pmatrix}T_0\\T_1\end{pmatrix}(mod\;P)$

设 $a=x^2-1$ , $\lambda_1=x-\sqrt{a}$ ， $\lambda——2=x+\sqrt{a}$ ，则有 $\lambda_1+\lambda_2=2x$ , $\lambda_1.\lambda_2=1$

则 $T_n(x)=\frac{(\lambda_1^{n-1}-\lambda_2^{n-1})+x.(\lambda_1^n-\lambda_2^n)}{\lambda_2-\lambda_1}(mod\;p)$

= $\frac{\lambda_1^n+\lambda_2^n}{2}(mod\;p)$

假如 $(x+\sqrt{a})^n=c+d\sqrt{a}$ ，则 $(x-\sqrt{a})^n=c-d\sqrt{a}$ ，那么 $T_n(X)=c(mod\;P)$

因此求 $(x+\sqrt{a})^n$ 是关键。

我们需要求解 $(x+\sqrt{a})^n$ ，然后取整数部分的结果就是 $T_n=c(mod\; p)$ 的结果

作者给出的求解方法，应该是模重复平方计算法。但是我按照作者给的算法和流程图的思路进行编程。发现结果是错误的（可能是我没看懂它的流程图）。所以我根据作者的思路（模重复平方计算法）自己设计程序实现了求解 $(x+\sqrt{a})^n$ 。

实现

我们知道带根号的乘法运算，计算机实现和手算是不一样的，计算机算会开根号取近似值，而我们在这个算法的过程中不需要开根号，开根号后结果是不正确的，所以我们需要自行编程实现带根号的乘法。

例如：
$(c+d\sqrt{a})^2=c_0+d_0\sqrt{a}$
其中

$c_0=c^2+d^2a$

$d_0=2cd$

整数部分： $c_0$

带根号部分： $d_0\sqrt{a}$
$(c+d\sqrt{a})(x+\sqrt{a})=g+h\sqrt{a}$

其中

$g = c x + d a$

$h = c + d x$

整数部分： $g$

带根号部分： $h\sqrt{a}$

我们不需要将根号拆开，让它保持原样。需要设计两个函数

带根号的平方 pow_2()
两个不同的根号数 mul()

代码

def pow_2(c,d,a,p):
    '''带根式的多项式的平方，不拆根号'''
    x=c*c+d*d*a
    y=2*c*d
    return (x%p,y%p)
def mul(x1,y1,x2,y2,a,p):
    '''带根式的乘法，保证不拆根号'''
    x=x1*x2+y1*y2*a
    y=x1*y2+x2*y1
    return (x%p,y%p)
def T(n,x,p):
    a=x*x-1
    c,d=x,1
    e,f=1,0#初始值
    j,k=1,0#初始j,k
    while n>0:
        ep=n&1
        n>>=1
        if ep:
            j,k=mul(e,f,c,d,a,p)
            e,f=j,k
        c,d=pow_2(c,d,a,p)
    return j

测试：

n=155033642076
x=8909654478045
p=431084178421767

调用函数

T(155033642076,8909654478045,431084178421767)

（注：以下耗时是乘以10²⁰后才统计到的结果，一般情况下都是 0.0）

290588719813696
耗时  1.0004043579101563e+17

将结果除以10^20次方后约等于0.001s

算法实现

求ChebyShev多项式的算法采用矩阵特征值法

密钥产生算法

产生一个大的随机数P和Q，计算N=P*Q;
随机产生一个大整数x，是的x<P;
随机产生一个随机数2<=s<P,并计算A=Ts(x)(mod P);
Alice的公开密钥为（x,N,A）,密钥为（S,P）

手工输入数据产生key的代码

def key():
    p=int(input('输入p: '))
    q=int(input('输入q: '))
    N=p*q
    x=int(input('输入x(x<p): '))
    s=int(input('输入s(2<s<p): '))
    A=T(s,x,p)
    print('公钥\nx: {}\nN: {}\nA: {}\n私钥\ns: {}\np: {}'.format(x,N,A,s,p))
    return (x,N,A),(s,p)

测试

输入p: 48487858671441677503
输入q: 34675575173844376547
输入x(x<p): 7646794539055646799
输入s(2<s<p): 179696390584392503
公钥
x: 7646794539055646799
N: 1681344388380317807216915364180870722141
A: 20082626683460709250
私钥
s: 179696390584392503
p: 48487858671441677503

随机生成p,q,s,r产生key的代码

def randomkey():
    num=2
    delta=0
    pq=[]
    for i in range(10**64,10**200):
        if num<1:
            break
        if not Miler_Rabin(i+delta):
            pq.append(delta+i)
            delta=10**5
            num-=1
    p=pq[0]
    q=pq[1]
    N=p*q
    x=random.randrange(10**5,p)
    s=random.randrange(2,p)
    A=T(s,x,p)
    print('公钥\nx: {}\nN: {}\nA: {}\n私钥\ns: {}\np: {}'.format(x,N,A,s,p))

测试

++++++++++ 操作 ++++++++++
1  密钥生成
2  加密
3  解密
其它  退出
+++++++++++++++++++++++++
操作数:1
y/n 手动输入p,q,x,s (随机生成): 
公钥
x: 3701067950663966601843104319385932777411511926725352977597168006
N:100000000000000000000000000000000000000000000000000000000001002040000000000000000000000000000000000000000000000000000000005708379
A: 8604473064581927969822581060545081655745948659068081426786271706
私钥
s: 6855826339596984719498579332803047617235671254685907621123392070
p: 10000000000000000000000000000000000000000000000000000000000000057

加密算法

获得Alice的公开密钥（x,N,A）;
将m看做一个整数并将m分段，使得m属于Z_p，0<m<x;
选择一个随机整数2<=r<x;
计算B=Tr(x)(mod N)和X=m*Tr(A)(mod N);
将密文消息（B,X）传给Alice。

代码

def encrypt():
    print('输入公钥','+'*20)
    x=int(input('x: '))
    N=int(input('N: '))
    A=int(input('A: '))
    print('输入待加密明文','+'*20)
    m=int(input('m: '))
    r=random.randrange(2,x)
    B=T(r,x,N)
    X=m*T(r,A,N)
    print('密文(B,X)','*'*20)
    print('B: {}\nX: {}'.format(B,X))

解密算法

使用密钥P计算C=B(mod P)
使用密钥s计算D=Ts©(mod P)
计算m=X*D^-1(mod P)恢复明文m。

代码

def decrypt():
    print('输入密钥')
    p=int(input('p: '))
    s=int(input('s: '))
    print('输入密文')
    B=int(input('B: '))
    X=int(input('X: '))
    C=B%p
    D=T(s,C,p)
    m=X*invert(D,p)%p
    print('解密出明文','+'*20)
    print('m:',m)

算法分析

三种求ChebyShev多项式的算法的比较

首先选取小的参数仿真举例，用计算机随机选取一组1组（n,x,P）。如n=155033642076，x=8909654478045，p=431084178421767，通过计算得到$T_n(x)(mod;p)=$290588719813696

在主频为3.00GHz,内存为16G的计算机下计算，

其中直接迭代法用时太长没有跑完程序就主动中断程序了，普通递归所用时间2.062秒，快速递归所用时间 0.012秒，矩阵特征值所用时间0.001秒。

通过上面的例子可以看出，直接迭代法不可用，普通递归法相对于其它两种方法慢的多。而矩阵特征值法所用时间最短。下面只对“普通递归法”，“快速递归法”和“矩阵特征值法”进行比较。固定p值和x值，改变n值，比较这三种方法求 $T_n(x)(mod\;p)$ 值所用的时间。固定p=431084178421767，x=8909654478045， $n\in [1500\;0000\;0000,1700\;0000\;0000]$ 之间随机取值，用着三种办法计算所得的时间通过matplotlib库进行做图，如下所示
在这里插入图片描述

从图上看普通递归法求值比其它两种方法慢得多

而快速递归法和矩阵特征值法时间相近。理论上是矩阵特征值法比快速递归法还要快。

之所以看着差不多。一方面是迭代次数不大，另一方面是硬件比较好，在迭代次数不大的情况下，体现不出来优势。且花费时间与N没有相关性，而是根据迭代次数（n的取值有关）n符合某个特征的话，执行的次数少，自然花费的时间就越少。

时间与迭代次数成正相关。

而迭代次数不仅与N有关，更与N的构成有关

N的构成简单： $N=e^x+c^y$ ，N为这种形式时，它的迭代次数相对较少。
N的构成越复杂，迭代次数越多。花费时间就越多。

但是不可否认的是：

普通递归法最慢，快速递归法相对较快。但是涉及到递归，递归次数上去后，会消耗大量内存。这也是递归的缺点，虽然代码量少，但是会消耗更多的内存。

而特征值法，时间和空间性都比较好。迭代次数与N的二进制位数有关。

改进算法的数值测试

选择不同长度的密钥，加密同一明文m=64784457424784，对改进算法进行测试。

密钥长度为64位

(1) 密钥产生：产生两个随机素数

P=34126644289158652207

Q=27101092457309781619

则N=924869342138211483322346774027542383133

选取大整数x=7646794539055646799，产生一个随机数s=179696390584392503,计算 $A=T_s(x)(mod\; P)$ =23618804596014579605 。所以公开密钥为（x,N,A）,私密密钥为（s,P）

(2) 加密运算:随机选取整数r=738494658218590538（需要修改encrypt函数中的r，将随机赋值，改为固定值）,计算 $B=T_r(x)(mod\;P)$ =64098056950971877262922909844434713538

$X=m*T_r(A)(mod\; N)$ =16047118512433490570593784159857162769332009033172672

密文信息为（B,X）

加密时间为：0.0秒

(3)解密运算：计算 $C=B(mod\;P)$ = , $D=T_s(C)(mod\;P)$ =

则 $m = X / D (m o d P)$ = 64784457424784 解出明文

解密时间为 0.0秒（时间太小，最靠近0.0）

操作截图
在这里插入图片描述

密钥长度为128位

(1) 密钥产生：产生两个随机素数

P=360177629990425915397846369319235726741
Q=348489608574776096131124912618883538129

则N=125518161292754063089694430577655273239105357331491849423235111455652698407589

选取大整数x=271167331022500318717370550282054321123，产生一个随机数s=15503364207326107811122827673464247187,计算 $A=T_s(x)(mod\; P)$ = 93092983419023208333494422472274875165。所以公开密钥为（x,N,A）,私密密钥为（s,P）