CN101814985A - 应用多混沌映射多动态s盒的分组密码系统 - Google Patents

Abstract

本发明涉及一种应用多混沌映射多动态S盒的分组密码系统，包括子密钥产生模块、动态S盒生成模块、加密模块和解密模块，首先利用多个混沌系统产生轮循环子密钥，利用多个混沌系统生成多个动态S盒；利用加密模块对明文件进行加密，明文文件被加密后，若需要解密时利用解密模块按照与加密过程相逆的顺序对密文件解密。本发明应用多混沌映射多动态S盒的分组密码系统，使用模块化程序设计方法，大大提高了加/解密运算速度，同时便于硬件实现，可广泛应用于政府、电子商务、军事、数字银行等众多领域。

Description

应用多混沌映射多动态S盒的分组密码系统

一、技术领域：

本发明属于信息安全领域中的混沌数字密码设计技术，是一种应用多个离散混沌映射多动态S盒的混沌分组密码系统，具体涉及一种应用多混沌映射多动态S盒的分组密码系统。

二、背景技术：

随着Internet技术的飞速发展，计算机网络技术正日益广泛的应用到社会各个领域，信息的安全与保密显得尤其重要。为了保证网络信息安全，国内外研究人员设计并公布了众多密码算法，现行的密码算法主要包括序列密码、分组密码、公钥密码、散列函数等。其中，分组密码，也称为块密码，它是现代密码学中的一个重要研究分支，主要由加密算法、解密算法和密钥编排算法三部分组成。分组密码因具有速度快、易于标准化和便于软硬件实现等特点而在计算机通信和信息系统安全领域中有着极其广泛的应用。

混沌是非线性确定系统中由于内禀随机性而产生的外在复杂表现，是一种貌似随机的非随机运动。混沌由于其对初值敏感性、对参数敏感性、遍历性、类随机性、弱相关性等特点，非线性科学界和信息工程界普遍关注混沌理论在信息安全和保密通信等领域中的应用。近年来，研究人员提出了许多基于混沌系统的加密算法。但从密码分析角度看，大多数混沌数字密码存在着安全性不高、运算速度慢、难以在实际中应用等缺陷。本发明提供了一种利用多个混沌映射多个动态S盒的分组加(解)密方法和系统，该密码系统安全性高，运算速度快，便于硬件实现。

三、发明内容：

本发明目的在于克服目前技术中混沌数字密码系统安全度低、运算速度慢、难以硬件实现等缺陷，提供一种能提高混沌数字密码性能的应用多混沌映射多动态S盒的分组密码系统。

技术方案：

一种应用多混沌映射多动态S盒的分组密码系统，利用计算机技术、信息编码理论及数字混沌技术实现，包括子密钥产生模块、动态S盒生成模块、加密模块和解密模块，具体运行步骤如下：

(1)在子密钥产生模块中，利用t个混沌系统产生轮循环子密钥，t≥2，t为整数；

(2)在动态S盒生成模块中，利用q个混沌系统生成z个动态S盒，q≥2，z≥2，q、z均为整数；

(3)利用加密模块对明文件进行加密，将明文文件按64位分成多个分组，从第一个分组开始，利用立方映射产生一个随机数h，根据该随机数h选择第h个S盒并利用第(1)步中子密钥模块产生的子密钥，进行轮循环加密运算；在当前的明文分组加密完成后，即可对下一个明文分组进行加密；重复这一过程，直至处理完所有明文数据分组，h≥0，h为整数；

(4)在需要解密时利用解密模块对密文件解密，按照与加密过程相逆的顺序进行运算获得解密密文，即：从密文文件的第一个数据块开始，利用立方映射产生一个随机数h’，根据该随机数h’选择第h’个S盒并利用第(1)步中子密钥模块产生的子密钥，进行轮循环解密运算；在当前的密文块解密完成后，即可对下一个密文块进行解密；重复这一过程，直至处理完所有密文块，h’≥0，h’为整数。

步骤(1)的子密钥产生模块中使用的混沌系统为四个系统参数和初始值均不相同的一维Logistic映射，利用这四个混沌映射生成两个128(16字节)位的序列ρ和η，利用序列ρ和η生成每轮循环的64位(8字节)子密钥。

步骤(2)中动态S盒生成模块，设计生成z个动态S盒所使用的混沌系统分别为二维Logistic映射、Standard映射、二维超混沌映射、Henón映射，生成第m个S盒的算法步骤如下，其中1≤m≤p，1＜p≤90，z≥2，m、p、z均为整数，0≤i≤749，n、k、i为自然数：

ST1.将相空间划分为等长的n+1＝750个区间，令0，…，n与每个区间一一对应；若某点位于区间k中，则该点的量值记为(k+1)mod 750；

ST2.选取750个初始点，用(x_i0，y_i0)表示第i个初始点的坐标值；所有的纵坐标值y_i0组成初始点集合U；利用Chebyshev映射产生一个随机数，根据该随机数选取一个二维离散混沌映射，对于任意的初始点(x_i0，y_i0)，迭代N_i次后得到y_i0的像y_i′；所有初始点y_i0对应的像组成像集合V；

ST3.从集合U中找出具有唯一像的初始点集合Φ；选择包含Φ中256个元素的子集A，从集合V中找出A中元素对应的像的集合B；

ST4.对集合A、B中的元素分别分配新的量值即[0，255]之间的整数，但集合A或B中各元素新的量值不能重复；若A中某个初始点的新量值是a，对应像的新量值是b，则记f(a)＝b；据此求得的映射f一一对应，f就是S盒。

步骤ST2中利用Chebyshev映射产生一个随机数，然后根据该随机数选取二维离散混沌映射。并且，选取的混沌映射不同，进行迭代的次数也不同。

模块(3)负责对明文文件进行加密，首先将明文M划分成一系列长度为64位(8字节)的块，从第一个数据块开始，利用立方映射产生一个随机数，根据该随机数选择一个S盒进行加密运算。假设对每个数据块进行加密时循环轮数为r轮，加密过程为：使用轮变换函数f和第i轮循环的子密钥p_i对数据块的各个字节进行异或运算，第i轮输出块是第(i+1)轮的输入(最后一轮除外)。第r轮的输出B_r＝x_r，0，x_r，1，…，x_r，7即为密文块。密文块的长度也是64位，和明文块的长度相同，这一结果在网络保密通信中是非常有意义的。这里的轮变换函数f实质上就是模块(2)生成的动态S盒。当一个明文块加密完成后，即可对下一个明文块进行加密。重复上述加密过程，直至把所有的明文数据块全部处理完毕。

模块(4)负责对密文文件进行解密，解密运算是加密的逆运算，只须按照与加密过程相逆的顺序进行运算即可解密密文。

Jakimoski和Kocarev在文献“Differential and linear probabilities of ablock-encryption cipher”[IEEE Transactions on Circuits and Systems-I，vol.50，no.1，pp.121-123，2003]中给出了分组加密算法中函数f的微分近似概率为2^-5＜DP_f＝12/256＜2^-4，线性近似概率为LP_f≈2^-3.825。同时，该文献证明了分组加密算法循环轮数为11轮时，差分(线性)轨迹至少包含17个动态S盒。本发明选取适当的循环轮数，例如取循环轮数r＝500，对于500轮循环差分轨迹至少包含(500×17)/11≈773个动态S盒，则DP≤(2^-4.678)⁷⁷³≈2^-3615，LP≤(2^-3.825)⁷⁷³≈2^-2957。据此可知，攻击者不可能构建分组加密算法的差分(线性)特征，即微分或线性分析不能够破译密文信息。此外，本文算法的密钥长度是128位，加密强度是2¹²⁸，如果将该密码系统所使用的混沌系统的参数、初始值、迭代次数、S盒数目、轮循环次数r也计入密钥，则密钥空间将是十分巨大的，足以应付穷举攻击。

本发明应用多混沌映射多动态S盒的分组密码系统，使用模块化程序设计方法，大大提高了加/解密运算速度，同时便于硬件实现，可广泛应用于政府、电子商务、军事、数字银行等众多领域。

四、附图说明：

图1为本发明的子密钥产生流程图。

图2为本发明的加密流程图。

五、具体实施方式：

实施例一：参见图1、图2，图1中，四个混沌映射分别迭代1600次后产生两个128位的初始序列ρ和η，根据式(2)生成第i轮子密钥p_i。图中，T_i，k表示密钥T_i的第k个字节，T₀＝ρ，T_i，16≡T_i，0，T_i，17≡T_i，1，f₀＝η₀，η₀为128位初始序列η的第一个字节(令η＝η₀η₁η₂…η₁₆)，⊕表示异或运算，函数

表示将密钥T_i的右边64位分配给轮子密钥p_i。

图2中，明文块B_i＝x_i-1，0，x_i-1，1，…，x_i-1，7，p_i-1，0，p_i-1，1，…，p_i-1，7是第i轮循环的子密钥p_i-1的8个字节，第i轮输出块B_i′＝x_i，0，x_i，1，…，x_i，7(它为第(i+1)轮的输入)。

本实施例提供了一种应用多个离散混沌映射多动态S盒的混沌分组密码系统，该密码系统共包括四个模块，下面对每一模块的实施方式作进一步的详细说明。

子密钥产生模块方式：

本模块中使用的混沌系统为下列四个一维离散Logistic映射：

$\left\{\begin{array}{cc}{x}_{n+1}^1={\mathrm{\λ}}_1{x}_n^1(1-x_n^1),& {\mathrm{\λ}}_1=3.6\\ x_{n+1}^2={\mathrm{\λ}}_2{x}_n^2(1-x_n^2),& {\mathrm{\λ}}_2=3.75\\ x_{n+1}^3={\mathrm{\λ}}_3{x}_n^3(1-x_n^3),& {\mathrm{\λ}}_3=3.9\\ x_{n+1}^4={\mathrm{\λ}}_4{x}_n^4(1-x_n^4),& {\mathrm{\λ}}_4=4\end{array}\right.,---\left(1\right)$

式(1)中，x_n ⁱ(i＝1，2，3，4)表示第i个Logistic映射迭代n次后的值， $x_0^i\∈\left(\mathrm{0,1}\right).$ 为消除初始值的影响，将上述各映射分别迭代200次，得到x₂₀₀ ⁱ。以x₂₀₀ ⁱ作为初始值，将上述各映射分别迭代1600次。设第i个映射的第j次迭代值为x_j ⁱ，用二进制形式表示为 $x_j^i=0.b_{j1}^i{b}_{j2}^i\·\·\·b_{\mathrm{jn}}^i\·\·\·,$ b_jn ⁱ表示x_j ⁱ的第n个二进制位。从x_j ⁱ(i＝1，2，3，4)中抽取第4、第5二进制位上的数值，得到一个8位的序列b_j4 ¹b_j4 ²b_j4 ³b_j4 ⁴b_j5 ¹b_j5 ²b_j5 ³b_j5 ⁴，以类似的方式总共抽取16次得到两个128位的序列：

ρ＝B_100，4B_100，5B_200，4B_200，5B_300，4B_300，5…B_1600，4B_1600，5，

η＝B_50，4B_50，5B_150，4B_150，5B_250，4B_250，5…B_1550，4B_1550，5，

这里， $B_{j,4}=b_{j4}^1{b}_{j4}^2{b}_{j4}^3{b}_{j4}^4,$ $B_{j,5}=b_{j5}^1{b}_{j5}^2{b}_{j5}^3{b}_{j5}^4.$

本分组密码系统中，假设轮循环次数为r，执行第i轮循环的函数f依赖于第i轮子密钥p_i的值，子密钥长度是64位。第i轮循环子密钥p_i的产生方法为：

式(2)中，i＝1，…，r，k＝1，…，16，T_i，k表示密钥T_i的第k个字节，T₀＝ρ，T_i，16≡T_i，0，T_i，17≡T_i，1，f₀＝η₀，η₀为128位序列η的第一个字节(令η＝η₀η₁η₂…η₁₆)。这里，函数

表示将密钥T_i的右边64位分配给轮子密钥p_i。

动态S盒生成模块方式：

模块(2)中设计生成多个动态S盒所选用的混沌映射如下：

二维Logistic映射： $\left\{\begin{array}{c}{x}_{n+1}=x_n+h(x_n-x_n^2+y_n)\\ y_{n+1}=y_n+h(y_n-y_n^2+x_n)\end{array}\right.,(h=0.65);$

Standard映射： $\left\{\begin{array}{c}{x}_{n+1}=x_n+k\sin y_n\\ y_{n+1}=y_n+x_{n+1}\end{array}\right.,(k=3);$

二维超混沌映射： $\left\{\begin{array}{c}{x}_{n+1}={\mathrm{ay}}_n^2\\ y_{n+1}=b+{\mathrm{cx}}_n+{\mathrm{dy}}_n\end{array}\right.,(a=1.3,b=-1.05,c=1.15,d=-0.2);$

Henón映射： $\left\{\begin{array}{c}{x}_{n+1}=1-{\mathrm{gx}}_n^2+y_n\\ y_{n+1}={\mathrm{\σx}}_n\end{array}\right.,(g=1.4,\mathrm{\σ}=0.3).$

生成第m(1≤m≤t，1＜t≤90)个S盒的算法步骤如下：

ST1.将相空间划分为等长的750个区间，令0，1，2，…，749与每个区间一一对应。若某点位于区间k中，则记该点的量值为(k+1)mod 750。

ST2.选取750个初始点，用(x_i0，y_i0)表示第i(0≤i≤749)个初始点的坐标值，所有的纵坐标值y_i0(0≤i≤749)构成初始点集合U。根据Chebyshev映射产生一个随机数，Chebyshev映射定义如下：

x_n+1＝cos(σarccos(x_n))，σ＝2.5，x_n∈[-1，1]。

利用Chebyshev映射产生随机数的具体方法是：任意选取初始值x₀，将Chebyshev映射迭代N次后得到x_N，然后计算Floor(10*|x_N|)mod 4的结果即为所求，函数Floor(x^*)表示取不大于x^*的最大整数。然后根据该随机数按照如下规则选择混沌映射和迭代次数：若随机数为0，选择二维Logistic映射，迭代1500次；若随机数为1，选择Standard映射，迭代2000次；若随机数为2，选择二维超混沌映射，迭代2300次；若随机数为3，选择Henón映射，迭代2800次。对于任意的初始点(x_i0，y_i0)，经过迭代N_i次后得到y_i0的像y_i′，将所有初始点y_i0(0≤i≤749)对应的像组成像集合V。显然，集合U，V中的元素个数均为750。

ST3.从集合U中找出具有唯一像的初始点集合Φ，选择包含Φ中256个不同元素的子集A，从集合V中找出A中元素对应的像的集合B。

ST4.对集合A、B中的元素分别分配新的量值([0，255]之间的整数)，但集合A(B)中各元素新的量值不能出现相同值。若A中某个元素的新量值是a，对应像的新量值是b，则记f(a)＝b。据此求得的映射f一一对应，f就是S盒。

步骤ST1中选取区间个数的方法为：若设混沌映射具有均匀分布、各态遍历的不变测度，设步骤ST1中划分的区间个数为n+1，根据文献“Chaos andcryptography：block encryption ciphers based on chaotic maps”[IEEE Transactionson Circuits and Systems-I，vol.48，no.2，pp.163-168，2001]，则给定像I_j刚好是某个初始点的像的概率为：

$P\left(I_j\right)=\underset{i=1}{\overset{n}{\mathrm{\Σ}}}\frac{1}{n}{\left(\frac{n}{n+1}\right)}^n={\left(\frac{n}{n+1}\right)}^n,$

并有lim_n→∞P(I_j)＝1/e。因此当n较大时，对应于某初始点的像的概率为1/e。若要构造映射f：{0，…，j-1}→{0，…，j-1}，对于较大的n值，区间的数量应略大于je。当j＝256时，划分区间的数量应略大于256e≈696。在本分组密码系统中，选取区间个数为750。

按照以上算法，可以生成多个不同的动态S盒。生成多个动态S盒的算法源代码如下：

int func[50][256]；//动态S盒，这里假设生成50个S-box

double comp(double startpointx，double startpointy)//计算迭代N次后的值

{

    int rndNum；

    double xx，x，y，z；

    //利用Chebyshev映射产生随机数

    z＝startpointx；

    for(i＝0；i＜1200；i++)

    {

        z＝cos(2.5*arccos(z))；

    }

    rndNum＝floor(abs(z))％4；

    x＝startpointx；

    y＝startpointy；

    Switch(rndNum)

    {

        Case 0：

          for(i＝0；i＜1500；i++)//选择二维Logistic映射迭代

          {

            xx＝x；

            x＝x+0.65*(x-x*x+y)；

            y＝y+0.65*(y-y*y+xx)；

          }

          break；

        Case 1：

           for(i＝0；i＜2000；i++)//选择Standard映射迭代

          {

            x＝x+3*sin(y)；

            y＝y+x；

          }

          break；

        Case 2：

          for(i＝0；i＜2300；i++)//选择二维超混沌映射迭代

         {

            xx＝x；

            x＝1.3*y*y；

            y＝-1.05+1.15*xx-0.2*y；

         }

         break；

       Case 3：

          for(i＝0；i＜2800；i++)//选择Henón映射迭代

        {

            xx＝x；

            x＝1-1.4*x*x+y；

            y＝0.3*x；

        }

        break；

    }

    return y；

}

//生成多动态S盒函数Sbox()

void Sbox()

{

    int i，j，k，sno，min，num，s；

    int magnitude[750]，flag[750]，SetA[256]，SetB[256]，refunc[256]；

    double d，startpointx，startpointy，image；

    double startarray[750]，imagearray[750]；

    d＝2.56/750；

    for(sno＝0；sno＜50；sno++)

    {

        startpointx＝-(0.02+sno*0.02)*d；

        startpointy＝-(0.05+sno*0.05)*d；

        s＝0；

        for(i＝0；i＜750；i++)

        {

            flag[i]＝0；

            magnitude[i]＝0；

            startarray[i]＝0；

            imagearray[i]＝0；

        }

        for(i＝0；i＜256；i++)

        {

            SetA[i]＝0；

            SetB[i]＝0；

            refunc[i]＝0；

            func[sno][i]＝0；

        }

/*********选择初始点，并随机选择混沌映射计算其对应的像值************/

        for(i＝0；i＜750；i++)

        {

            Startpointx＝startpointx+d；

            Startpointy＝startpointy+2*d；

            startarray[i]＝startpointy；

            image＝comp(startpointx，startpointy)；

            imagearray[i]＝image；

        }

/************选择具有唯一像的初始点集合A，包含元素256个************/

        for(j＝0；j＜750；j++)

        {

            magnitude[j]＝floor(imagearray[j]/d)；

            if(flag[magnitude[j]]＝＝0)

            {

                if(s＜256)

                {

                    SetA[s]＝j；

                    s++；

                    flag[magnitude[j]]＝1；

                }

                else

                    goto OutputB；

            }

        }

/************生成与集合A相对应的像集合B，包含元素256个************/

OutputB：

        for(k＝0；k＜256；k++)

        {

            i＝SetA[k]；

            SetB[k]＝magnitude[i]；

        }

        for(i＝0；i＜256；i++)

        {

            min＝750；

            for(j＝0；j＜256；j++)

            {

                if(SetB[j]＜min)

                {

                    min＝SetB[j]；

                    num＝j；

                }

            }

            subsetb[num]＝750；

            refunc[i]＝num；

        }

/********对集合A、B中的元素重新分配量值，构造一一对应f，即S盒********/

        for(i＝0；i＜256；i++)

        {

            for(j＝0；j＜256；j++)

            {

                if(refunc[j]＝＝i)

                {

                    func[sno][i]＝j；

                    break；

                }

            }

        }

    }

}

加密模块实施方式：

将明文M划分成一系列长度为64位的块：

令x_i，0，x_i，1，…，x_i，7表示块B_i的8个字节，即B_i＝x_i，0，x_i，1，…，x_i，7。使用轮变换函数f对每一数据块依次进行加密，假设每个数据块加密时循环轮数为r轮，则对块B_i的加密过程可用下式描述：

$\left\{\begin{array}{c}{x}_{i,2}=x_{i-\mathrm{1,1}}\⊕f_0\\ x_{i,3}=x_{i-\mathrm{1,2}}\⊕f_1\\ \·\\ \·\\ \·\\ x_{i,0}=x_{i-\mathrm{1,7}}\⊕f_6\\ x_{i,1}=x_{i-\mathrm{1,0}}\⊕f_7\end{array}\right.,---\left(3\right)$

式(3)中，i＝1，…，r，f₀＝p_i，0，函数f_j(1≤j≤7)定义如下：

f_j＝f[x_i-1，1⊕…⊕x_i-1，j⊕p_i-1，j]，                    (4)

式(4)中，函数f：χ→χ(χ＝{0，1，2，…，255})就是模块(2)生成的动态S盒，p_i，0，p_i，1，…，p_i，7是第i轮循环的子密钥p_i的8个字节。从式(3)可知，第i轮输出块B_i＝x_i，0，x_i，1，…，x_i，7是第(i+1)轮的输入(最后一轮除外)。因此，第r轮(最后一轮)的输出B_r＝x_r，0，x_r，1，…，x_r，7即为密文块。密文块的长度也是64位(8个字节)，和明文块的长度相同。以往很多混沌密码算法的密文文件大小为明文文件大小的2倍，进行网络传输时将消耗大量的时间，这很不利于大文件的网络传输，而本发明刚好可克服这一缺点。使用上述加密算法从明文文件的第一个数据块开始，利用立方映射产生一个随机数，根据该随机数选择一个S盒进行加密运算。当一个明文块加密完成后，即可对下一个明文块进行加密。重复上述加密过程，直至把所有的明文数据块全部处理完毕。

立方映射定义如下：

$x_{n+1}={\mathrm{\θx}}_n(1-x_n^2),\mathrm{\θ}=2.59.$

假设共有N个S盒，利用立方映射产生随机数的具体方法是：任意选取初始值x₀，迭代k次后得到像x_k，然后计算Ceil(100*|x_k|)mod N就是所要求的随机数，函数Ceil(x^*)表示取大于x^*的最小整数。

解密模块实施方式：

解密过程与加密过程类似，只须按照与加密过程相逆的顺序进行运算即可。从密文文件的第一个数据块开始，利用立方映射产生一个随机数(随机数产生方式同上)，根据该随机数选择一个S盒进行解密运算。令密文块C_i＝z_i，0，z_i，1，…，z_i，7，z_i，0，z_i，1，…，z_i，7是块C_i的8个字节。对密文块C_i的解密过程可用下式描述：

z_i-1，k＝z_i，k+1⊕f_k-1[z_i，1，…，z_i，k-1，p_i，k-1]，                 (5)

式(5)中，k＝1，…，8，f₀＝p_i，0，z_i，8≡z_i，0，z_i，9≡z_i，1，函数f_k(1≤k≤7)定义同式(4)，p_i，0，p_i，1，…，p_i，7是第i轮循环的子密钥p_i的8个字节。与加密过程类似，第i轮输出块C_i＝z_i，0，z_i，1，…，z_i，7是第(i+1)轮的输入，第r轮(最后一轮)的输出C_r＝z_r，0，z_r，1，…，z_r，7即为明文块。当一个密文块解密完成后，即可对下一个密文块进行解密。重复上述解密过程，直至把所有的密文数据块全部处理完毕。

Claims (3)

1.一种应用多混沌映射多动态S盒的分组密码系统，利用计算机技术、信息编码理论及数字混沌技术实现，其特征在于，包括子密钥产生模块、动态S盒生成模块、加密模块和解密模块，具体运行步骤如下：

(1)在子密钥产生模块中，利用t个混沌系统产生轮循环子密钥，t≥2，t为整数；

(2)在动态S盒生成模块中，利用q个混沌系统生成z个动态S盒，q≥2，z≥2，q、z均为整数；

(3)利用加密模块对明文件进行加密，将明文文件按64位分成多个分组，从第一个分组开始，利用立方映射产生一个随机数h，根据该随机数h选择第h个S盒并利用第(1)步中子密钥模块产生的子密钥，进行轮循环加密运算；在当前的明文分组加密完成后，即可对下一个明文分组进行加密；重复这一过程，直至处理完所有明文数据分组，h≥0，h为整数；

(4)在需要解密时利用解密模块对密文文件解密，按照与加密过程相逆的顺序进行运算获得解密密文，即：从密文文件的第一个数据块开始，利用立方映射产生一个随机数h’，根据该随机数h’选择第h’个S盒并利用第(1)步中子密钥模块产生的子密钥，进行轮循环解密运算；在当前的密文块解密完成后，即可对下一个密文块进行解密；重复这一过程，直至处理完所有密文块，h’≥0，h’为整数。

2.根据权利要求1所述的分组密码系统，其特征在于，步骤(1)的子密钥产生模块中使用的混沌系统为四个系统参数和初始值均不相同的一维Logistic映射，利用这四个混沌映射生成两个128位的序列ρ和η，利用序列ρ和η生成每轮循环的64位子密钥。

3.根据权利要求1所述的分组密码系统，其特征在于，步骤(2)中动态S盒生成模块，设计生成z个动态S盒所使用的混沌系统分别为二维Logistic映射、Standard映射、二维超混沌映射、Henón映射，生成第m个S盒的算法步骤如下，其中1≤m≤p，1＜p≤90，z≥2，m、p、z均为整数，0≤i≤749，n、k、i为自然数：

ST1.将相空间划分为等长的n+1＝750个区间，令0，…，n与每个区间一一对应；若某点位于区间k中，则该点的量值记为(k+1)mod 750；

ST2.选取750个初始点，用(x_i0，y_i0)表示第i个初始点的坐标值；所有的纵坐标值y_i0组成初始点集合U；利用Chebyshev映射产生一个随机数，根据该随机数选取一个二维离散混沌映射，对于任意的初始点(x_i0，y_i0)，迭代N_i次后得到y_i0的像y_i′；所有初始点y_i0对应的像组成像集合V；

ST3.从集合U中找出具有唯一像的初始点集合Φ；选择包含Φ中256个元素的子集A，从集合V中找出A中元素对应的像的集合B；

ST4.对集合A、B中的元素分别分配新的量值即[0，255]之间的整数，但集合A或B中各元素新的量值不能重复；若A中某个初始点的新量值是a，对应像的新量值是b，则记f(a)＝b；据此求得的映射f一一对应，f就是S盒。

Images