CN103825699A - 云计算环境中对存储文件的并行混沌加密方法 - Google Patents

Abstract

云计算环境中对存储文件的并行混沌加密方法为数据文件的加密提供一种可并行的轻量级加密，属于信息安全领域。利用云计算环境的可并行计算机制，如MapReduce并行计算技术，结合混沌加密方法，通过对明文数据进行分组加密，最终实现对整个文件的加密，并上载到云计算环境的存储系统中。方法包含了加密系统初值计算、加密密钥序列计算和数据加密三个步骤。在加密系统初始化中，方法采用三维Lorenz混沌系统和Chen混沌系统生成用于加密的初值和干扰值；在计算加密密钥序列过程中，基于计算出的初始值和干扰值，通过Henon混沌映射和2维Logistic混沌映射的迭代运算，生成用于数据加密的密钥序列；在数据加密过程中，通过密钥序列与明文进行运算，最终实现对明文数据的加密。

Description

云计算环境中对存储文件的并行混沌加密方法

技术领域

本发明针对云计算环境中需要存储的数据文件安全问题，提出了一种适用于云计算环境的并行混合混沌加密方案，其思路是：数据文件的所有者将要存储于云环境中的文件先进行加密，再上载到租用的存储空间中，供使用者使用，实现对数据的保密性要求。本发明涉及混沌计算、并行计算技术和云计算技术，属于信息安全领域。

背景技术

大数据安全领域是近几年备受关注的一个热点问题。一方面，数据所有者将大量的数据存储于云计算环境中，供使用者访问使用。但这些大量数据中有很多敏感数据需要保障其机密性，如位置信息、个人身份等隐私信息等，如何实现对这类存储模式中数据文件的信息加密，实现安全、有效、简单的数据访问控制是云计算走向实际应用需要解决的问题。另一方面，由于文件数据数量大，需要构建一种针对大数据的快速加密算法，而在云计算环境中，就要解决如何能够利用云计算环境可并行计算的特点，实现大数据的快速并行加密。本发明就是针对文件数据的机密性和可并行性，提出了一种可应用于云计算环境的并行混合混沌加密技术，该方案能够有效提高大数据量的加密速度。

方法包含了加密系统初值计算、加密密钥序列计算和数据加密三个步骤。在加密系统初始化中，方法采用三维Lorenz混沌系统和Chen混沌系统生成用于加密的初值和干扰值；在计算加密密钥序列过程中，基于计算出的初始值和干扰值，通过Henon混沌映射和2维Logistic混沌映射的迭代运算，生成用于数据加密的密钥序列；在数据加密过程中，通过密钥序列与明文进行运算，最终实现对明文数据的加密。

由于采用分组加密等运算，使提出的方法可以利用云计算环境中的并行技术，实现加密方法的可并行计算化。

发明内容

发明目的：本发明的目的是提供一种云计算环境中对存储文件的并行混沌加密方法，通

过结合云计算环境的并行技术和混沌加密技术实现一种并行的混沌加密方案，以提高大数据量的加解密速度。

技术方案：本发明为实现上述发明目的，采用如下技术方案：

步骤一：数据文件分块

记数据文件即明文的长度为L，将明文分成n块，每一块的大小为l_i，i≤n，且要求l_i为4字节的整倍数，记为l_i=4N；这样前n-1块为等长的数据块，第n块为剩余部分数据，即：

l_i＝4N  (i＜n)

              （1）

l_i＝L-(n-1)·4N  (i＝n)

步骤二：应用非线性混沌系统生成初始序列和干扰序列

对于每一个分块，通过三维连续混沌系统Lorenz混沌映射和Chen混沌映射产生初值序列和干扰值序列，方法如下：

Lorenz混沌映射方程为：

$\left\{\begin{array}{c}\frac{{\mathrm{dx}}_1}{\mathrm{dt}}=p(x_2-x_1)\\ \frac{{\mathrm{dx}}_2}{\mathrm{dt}}=-x_1{x}_3+r{x}_1-x_2\\ \frac{{\mathrm{dx}}_3}{\mathrm{dt}}=x_2{x}_1-t{x}_3\end{array}\right.---\left(2\right)$

Chen混沌系统方程为：

$\left\{\begin{array}{c}\frac{{\mathrm{dx}}_4}{\mathrm{dt}}=a(x_5-x_4)\\ \frac{{\mathrm{dx}}_5}{\mathrm{dt}}=(c-a)x_4-x_4{x}_6+{\mathrm{cx}}_5\\ \frac{{\mathrm{dx}}_6}{\mathrm{dt}}=x_4{x}_5-b{x}_6\end{array}\right.---\left(3\right)$

其中χ=(x₁,x₂,x₃,x₄,x₅,x₆)为要生成的混沌序列,p,r,t和a,b,c为系统要给定的参数，利用4阶龙格库塔法求解混沌系统方程（2）和（3），每次迭代分别生成三个随机序列值，即6个混沌序列值χ=(x₁,x₂,x₃,x₄,x₅,x₆)；为了计算得到这个混沌序列值，首先获取明文块第一个字节的偏移量θ_i，取Lorenz系统的初始迭代次数为N₀，Chen系统的初始迭代次数为M₀，记Lorenz系统的迭代次数为ρ_L，Chen系统的迭代次数为ρ_C，则有：

${\mathrm{\ρ}}_L=\frac{{\mathrm{\θ}}_i}{N}+N_0,{\mathrm{\ρ}}_C=\frac{{\mathrm{\θ}}_i}{N}+M_0---\left(4\right)$

则每个分块的对应的混沌序列为

χ_ρ=(x₁(ρ_L),x₂(ρ_L),x₃(ρ_L),x₄(ρ_C),x₅(ρ_C),x₆(ρ_C))  (5)

为了使两个系统产生的序列具有耦合性，将得到的Lorenz系统产生的随机序列对和Chen系统产生的随机序列对进行异或运算：

$\begin{array}{c}{x}_4\left({\mathrm{\ρ}}_C\right)=x_4\left({\mathrm{\ρ}}_C\right)\⊕x_1\left({\mathrm{\ρ}}_L\right)\\ x_5\left({\mathrm{\ρ}}_C\right)=x_5\left({\mathrm{\ρ}}_C\right)\⊕x_2\left({\mathrm{\ρ}}_L\right)\\ x_6\left({\mathrm{\ρ}}_C\right)=x_6\left({\mathrm{\ρ}}_C\right)\⊕x_3\left({\mathrm{\ρ}}_L\right)\end{array}---\left(6\right)$

计混沌序列χ_ρ为初值序列 ${\mathrm{\χ}}_p^I=(x_1\left({\mathrm{\ρ}}_L\right),x_2\left({\mathrm{\ρ}}_L\right),x_3\left({\mathrm{\ρ}}_L\right),x_4\left({\mathrm{\ρ}}_C\right))$ 和干扰序列 ${\mathrm{\χ}}_{\mathrm{\ρ}}^d=(x_5\left({\mathrm{\ρ}}_C\right),x_6\left({\mathrm{\ρ}}_C\right));$

步骤三：用初值序列计算加密密钥的混沌序列

将初值序列

中的(x₁(ρ_L),x₂(ρ_L))小数部分作为Hénon混沌映射迭代的初始值、(x₃(ρ_L),x₄(ρ_L))小数部分作为二维Logistic映射迭代的初始值，递归产生加密的密钥序列ω_ρ=(ω₁(ρ),ω₂(ρ),ω₃(ρ),ω₄(ρ))，其中(ω₁(ρ),ω₂(ρ))由式（7）的Hénon系统方程迭代产生：

$\left\{\begin{array}{c}{x}_{n+1}=y_n+1-a{x}_n^2\\ y_{n+1}={\mathrm{bx}}_n\end{array}\right.---\left(7\right)$

(ω₃(ρ),ω₄(ρ))由式（8）的二维Logistic混沌映射系统方程迭代产生：

$\left\{\begin{array}{c}{x}_{n+1}={\mathrm{\μ}}_1{x}_n(1-x_n)+{\mathrm{\γ}}_1{y}_n^2\\ y_{n+1}={\mathrm{\μ}}_2{y}_n(1-y_n)+{\mathrm{\γ}}_2(x_n^2+x_n{y}_n)\end{array}\right.---\left(8\right)$

映射中的参数取值为：2.75＜μ₁＜3.4,2.7＜μ₂＜3.45和0.15＜γ₁＜0.21,0.13＜γ₂＜0.15。

步骤四：重构加密密钥序列

得到加密密钥序列后，由于其产生的值并不能和明文进行异或操作，所以需要将加密密钥序列根据下式进行转换：

为了使两个系统产生的序列具有耦合性，进行如下计算：

$\begin{array}{c}{\mathrm{\ω}}_3\left(\mathrm{\ρ}\right)={\mathrm{\ω}}_1\left(\mathrm{\ρ}\right)\⊕{\mathrm{\ω}}_3\left(\mathrm{\ρ}\right)\\ {\mathrm{\ω}}_4\left(\mathrm{\ρ}\right)={\mathrm{\ω}}_2\left(\mathrm{\ρ}\right)\⊕{\mathrm{\ω}}_4\left(\mathrm{\ρ}\right)\end{array}---\left(10\right)$

步骤五：数据加密

在生成了加密密钥序列后，将进行明文文件的加密，加密操作是依次在明文中取4个字节长度数据块对应的ASCII码M，同加密密钥序列进行异或(XOR)操作得到中间结果，然后再同干扰序列进行二次异或操作得到最终的密文C：

$\left\{\begin{array}{c}{C}_{4k+1}=(M_{4k+1}\⊕{\mathrm{\ω}}_1(k+1))\⊕x_5(k+1)\\ C_{4k+2}=(M_{4k+2}\⊕{\mathrm{\ω}}_2(k+1))\⊕x_6(k+1)\\ C_{4k+3}=(M_{4k+3}\⊕{\mathrm{\ω}}_3(k+1))\⊕x_5(k+1)\\ C_{4k+4}=(M_{4k+4}\⊕{\mathrm{\ω}}_4(k+1))\⊕x_6(k+1)\end{array}\right.---\left(11\right)$

其中k代表数据块的序号，C_4k+1，C_4k+2，C_4k+3，C_4k+4分别为数据块中对应于第1、2、3和4个字节的加密密文。在方法提出的加密方法中，密钥空间包括密钥序列的初始值χ(0)=(x₁(0),x₂(0),x₃(0),x₄(0),x₅(0),x₆(0))、Lorenz和Chen系统的初始迭代次数N₀和M₀，以及两个混沌系统的参数p,r,t和a,b,c。

有益效果：本发明设计出的并行混合混沌加密方案解决了云计算实际应用过程中要解决的两个问题，一是数据所有者对数据文件的机密性要求，通过对明文文件的分组加密，上载存储于云环境中，保证数据所有者的敏感信息受到保护；二是针对大数据高速计算要求，采用分组加密等看并行的计算技术，使数据文件的加密过程可利用云计算环境中的并行计算技术，实现对大数据文件加密的高速并行计算，最终满足云计算环境中大数据的安全高速访问。

附图说明

图1是加密方案的流程。

具体实施方式

下面对技术方案的实施作进一步的详细描述：

步骤一：数据文件分块

设明文长度为15个字节的文件，即L=15。分成4块，每一块的最大长度为4个字节，则有N=1。前3块为等长的4个字节数据块，第4块为剩余部分数据3个字节，即：

l_i＝4N＝4  (i＝1,2,3)

            (12)

l_i＝L-(n-1)·4N＝15-(4-1)·4＝3  (i＝4)

步骤二：应用非线性混沌系统生成初始序列和干扰序列

对于每一个分块，通过三维连续混沌系统Lorenz混沌映射和Chen混沌映射产生初值序列和干扰值序列。方法如下：

Lorenz混沌映射方程为：

$\left\{\begin{array}{c}\frac{{\mathrm{dx}}_1}{\mathrm{dt}}=p(x_2-x_1)\\ \frac{{\mathrm{dx}}_2}{\mathrm{dt}}=-x_1{x}_3+r{x}_1-x_2\\ \frac{{\mathrm{dx}}_3}{\mathrm{dt}}=x_2{x}_1-t{x}_3\end{array}\right.---\left(13\right)$

其中p＝10,r＝28,t＝8/3。Chen混沌系统方程为：

$\left\{\begin{array}{c}\frac{{\mathrm{dx}}_4}{\mathrm{dt}}=a(x_5-x_4)\\ \frac{{\mathrm{dx}}_5}{\mathrm{dt}}=(c-a)x_4-x_4{x}_6+{\mathrm{cx}}_5\\ \frac{{\mathrm{dx}}_6}{\mathrm{dt}}=x_4{x}_5-b{x}_6\end{array}\right.---\left(14\right)$

其中χ=(x₁,x₂,x₃,x₄,x₅,x₆)为要生成的混沌序列,a＝35,b＝3,c＝28。利用4阶龙格库塔法求解混沌系统方程（13）和（14），每次迭代分别生成三个随机序列值，即6个混沌序列值χ=(x₁,x₂,x₃,x₄,x₅,x₆)。为了计算得到这个混沌序列值，根据数据块的划分，可以计算出每个明文块第一个字节的偏移量θ₁,θ₂,θ₃,θ₄，根据数据块划分有θ₁＝0,θ₂＝4,θ₃＝8,θ₄＝12。取Lorenz系统的初始迭代次数为N₀=2000，Chen系统的初始迭代次数为M₀=3000。则两个系统的迭代次数分别为：

$\begin{array}{cc}{\mathrm{\ρ}}_L\left(1\right)=\frac{0}{4}+2000=2000& {\mathrm{\ρ}}_C\left(1\right)=\frac{0}{4}+3000=3000\\ {\mathrm{\ρ}}_L\left(2\right)=\frac{4}{4}+2000=2001& {\mathrm{\ρ}}_C\left(2\right)=\frac{4}{4}+3000=3001\\ {\mathrm{\ρ}}_L\left(3\right)=\frac{8}{4}+2000=2002& {\mathrm{\ρ}}_C\left(3\right)=\frac{8}{4}+3000=3002\\ {\mathrm{\ρ}}_L\left(4\right)=\frac{12}{4}+2000=2003& {\mathrm{\ρ}}_C\left(4\right)=\frac{12}{4}+3000=3003\end{array}---\left(15\right)$

取初值为x₁(0)=1,x₂(0)=2,x₃(0)=3,x₄(0)=4,x₅(0)=5,x₆(0)=6，则计算得到每个分块的对应的混沌序列为：

χ_ρ=(x₁(ρ_L),x₂(ρ_L),x₃(ρ_L),x₄(ρ_C),x₅(ρ_C),x₆(ρ_C))

χ_ρ(1)=(x₁(2000),x₂(2000),x₃(2000),x₄(3000),x₅(3000),x₆(3000))

=(17.875805137193584,23.577775139444757,35.317757483789414,

6.717742409639023,7.835244360075882,10.201089575432276)

χ_ρ(2)=(x₁(2001),x₂(2001),x₃(2001),x₄(3001),x₅(3001),x₆(3001))

=(18.17831668337063,22.534873609894326,37.37817682181235,

6.782891166690998,7.8362000710961714,10.394920549118666)

χ_ρ(3)=(x₁(2002),x₂(2002),x₃(2002),x₄(3002),x₅(3002),x₆(3002))

=(18.395763937117206,21.26573786112585,39.3236292734919,

6.844042435179011,7.828307249610151,10.589251029269274)

χ_ρ(4)=(x₁(2003),x₂(2003),x₃(2003),x₄(3003),x₅(3003),x₆(3003))

=(18.546007636272776,18.12250541456983,42.723826295121185,

6.953205127666364,7.785230347792439,10.977112780831336)

步骤三：用初值序列计算加密密钥的混沌序列

将混沌序列χ_ρ分为初值序列 ${\mathrm{\χ}}_p^I=(x_1\left({\mathrm{\ρ}}_L\right),x_2\left({\mathrm{\ρ}}_L\right),x_3\left({\mathrm{\ρ}}_L\right),x_4\left({\mathrm{\ρ}}_C\right)),$ 和干扰序列将初值序列

的小数部分将作为Hénon混沌映射和2D-Logistic映射的初始值，进行递归产生加密序列ω_ρ=(ω₁(ρ),ω₂(ρ),ω₃(ρ),ω₄(ρ))，其中(ω₁(ρ),ω₂(ρ))由式（16）的Hénon系统迭代方程产生：

$\left\{\begin{array}{c}{x}_{n+1}=y_n+1-a{x}_n^2\\ y_{n+1}={\mathrm{bx}}_n\end{array}\right.---\left(16\right)$

式（16）中的参数为a＝1.4,b＝0.3。序列值(ω₃(ρ),ω₄(ρ))由式（17）的二维Logistic混沌映射系统迭代方程产生：

$\left\{\begin{array}{c}{x}_{n+1}={\mathrm{\μ}}_1{x}_n(1-x_n)+{\mathrm{\γ}}_1{y}_n^2\\ y_{n+1}={\mathrm{\μ}}_2{y}_n(1-y_n)+{\mathrm{\γ}}_2(x_n^2+x_n{y}_n)\end{array}\right.---\left(17\right)$

其中参数为μ₁=2.93，μ₂=3.17，γ₁=0.197，γ₂=0.139。产生对应与4个分块的加密密钥序列ω_ρ=(ω₁(ρ),ω₂(ρ),ω₃(ρ),ω₄(ρ))：

ω(1)＝(0.503926645776215,0.26274154115807524,0.7310172809052533,0.5911631451546245)

ω(2)=(1.490358034498705,0.053495005011188465,0.635768102381588,0.610385893368047)

ω(3)=(1.0464571296343332,0.1187291811351617,0.5208502734446377,0.6470227289937563)

ω(4)=(1.407740930215608,0.15611128793982337,0.39125888333654657,0.6995879558829032)

步骤四：重构加密密钥序列

得到加密密钥序列后，由于其产生的值并不能和明文进行异或操作，所以需要将加密密钥序列根据式（18）进行转换：

为了使两个系统产生的序列具有耦合性，计算：

$\begin{array}{c}{\mathrm{\ω}}_3\left(\mathrm{\ρ}\right)={\mathrm{\ω}}_1\left(\mathrm{\ρ}\right)\⊕{\mathrm{\ω}}_3\left(\mathrm{\ρ}\right)\\ {\mathrm{\ω}}_4\left(\mathrm{\ρ}\right)={\mathrm{\ω}}_2\left(\mathrm{\ρ}\right)\⊕{\mathrm{\ω}}_4\left(\mathrm{\ρ}\right)\end{array}---\left(19\right)$

经过变换得到的混沌加密序列为：

ω_i(1)=(56,114,83,76)x_i(1)＝(54,39)

ω_i(2)=(7,100,101,63)x_i(2)＝(31,100)

ω_i(3)=(54,123,25,47)x_i(3)＝(126,70)

ω_i(4)=(7,35,39,18)x_i(4)＝(13,124)

步骤五：数据加密

在生成了加密密钥序列后，将进行明文文件的加密。设15个字节的明文的ASCⅡ码M分别为(97,98,99,100,101,102,103,104,105,106,107,108,109,110,111)，加密操作是依次在明文中取4个字节长度数据块对应的ASCII码M，同加密密钥序列进行异或(XOR)操作得到中间结果，然后再同干扰序列进行二次异或操作得到最终的密文C：

$\left\{\begin{array}{c}{C}_{4k+1}=(M_{4k+1}\⊕{\mathrm{\ω}}_1(k+1))\⊕x_5(k+1)\\ C_{4k+2}=(M_{4k+2}\⊕{\mathrm{\ω}}_2(k+1))\⊕x_6(k+1)\\ C_{4k+3}=(M_{4k+3}\⊕{\mathrm{\ω}}_3(k+1))\⊕x_5(k+1)\\ C_{4k+4}=(M_{4k+4}\⊕{\mathrm{\ω}}_4(k+1))\⊕x_6(k+1)\end{array}\right.---\left(20\right)$

其中k代表数据块的序号，C_4k+1，C_4k+2，C_4k+3，C_4k+4分别为数据块中对应于第1、2、3和4个字节的加密密文。具体加密结果为：

$\left\{\begin{array}{c}{C}_1=(M_1\⊕{\mathrm{\ω}}_1\left(1\right))\⊕x_5\left(1\right)=97\⊕56\⊕54=111\\ C_2=(M_2\⊕{\mathrm{\ω}}_2\left(1\right))\⊕x_6\left(1\right)=98\⊕114\⊕54=38\\ C_3=(M_3\⊕{\mathrm{\ω}}_3\left(1\right))\⊕x_5\left(1\right)=99\⊕83\⊕39=23\\ C_4=(M_4\⊕{\mathrm{\ω}}_4\left(1\right))\⊕x_6\left(1\right)=100\⊕76\⊕39=15\end{array}\right.$

$\left\{\begin{array}{c}{C}_5=(M_5\⊕{\mathrm{\ω}}_1\left(2\right))\⊕x_5\left(2\right)=101\⊕7\⊕31=125\\ C_6=(M_6\⊕{\mathrm{\ω}}_2\left(2\right))\⊕x_6\left(2\right)=102\⊕100\⊕31=29\\ C_7=(M_7\⊕{\mathrm{\ω}}_3\left(2\right))\⊕x_5\left(2\right)2=103\⊕101\⊕100=102\\ C_8=(M_8\⊕{\mathrm{\ω}}_4\left(2\right))\⊕x_6\left(2\right)=104\⊕63\⊕100=51\end{array}\right.$

$\left\{\begin{array}{c}{C}_9=(M_9\⊕{\mathrm{\ω}}_1\left(3\right))\⊕x_5\left(3\right)=105\⊕54\⊕126=33\\ C_{10}=(M_{10}\⊕{\mathrm{\ω}}_2\left(3\right))\⊕x_6\left(3\right)=106\⊕123\⊕126=111\\ C_{11}=(M_{11}\⊕{\mathrm{\ω}}_3\left(3\right))\⊕x_5\left(3\right)=107\⊕25\⊕70=52\\ C_{12}=(M_{12}\⊕{\mathrm{\ω}}_4\left(3\right))\⊕x_6\left(3\right)=108\⊕47\⊕70=5\end{array}\right.$

$\left\{\begin{array}{c}{C}_{13}=(M_{13}\⊕{\mathrm{\ω}}_1\left(4\right))\⊕x_5\left(4\right)=109\⊕7\⊕13=103\\ C_{14}=(M_{14}\⊕{\mathrm{\ω}}_2\left(4\right))\⊕x_6\left(4\right)=110\⊕35\⊕13=64\\ C_{15}=(M_{15}\⊕{\mathrm{\ω}}_3\left(4\right))\⊕x_5\left(4\right)=111\⊕39\⊕124=52\end{array}\right.$

即明文为M=(97,98,99,100,101,102,103,104,105,106,107,108,109,110,111)，密文为C=（111,38,23,15,125,29,102,51,33,111,52,5,103,64,52）。

Claims (1)

1.一种云计算环境中对存储文件的并行混沌加密方法，其特征在于该方法包括以下步骤：

步骤一：数据文件分块

记数据文件即明文的长度为L，将明文分成n块，每一块的大小为l_i，i≤n，且要求l_i为4字节的整倍数，记为l_i=4N；这样前n-1块为等长的数据块，第n块为剩余部分数据，即：

l_i＝4N  (i＜n)

               （1）

l_i＝L-(n-1)·4N  (i＝n)

步骤二：应用非线性混沌系统生成初始序列和干扰序列

对于每一个分块，通过三维连续混沌系统Lorenz混沌映射和Chen混沌映射产生初值序列和干扰值序列，方法如下：

Lorenz混沌映射方程为：

$\left\{\begin{array}{c}\frac{{\mathrm{dx}}_1}{\mathrm{dt}}=p(x_2-x_1)\\ \frac{{\mathrm{dx}}_2}{\mathrm{dt}}=-x_1{x}_3+r{x}_1-x_2\\ \frac{{\mathrm{dx}}_3}{\mathrm{dt}}=x_2{x}_1-t{x}_3\end{array}\right.---\left(2\right)$

Chen混沌系统方程为：

$\left\{\begin{array}{c}\frac{{\mathrm{dx}}_4}{\mathrm{dt}}=a(x_5-x_4)\\ \frac{{\mathrm{dx}}_5}{\mathrm{dt}}=(c-a)x_4-x_4{x}_6+{\mathrm{cx}}_5\\ \frac{{\mathrm{dx}}_6}{\mathrm{dt}}=x_4{x}_5-b{x}_6\end{array}\right.---\left(3\right)$

其中χ=(x₁,x₂,x₃,x₄,x₅,x₆)为要生成的混沌序列,p,r,t和a,b,c为系统要给定的参数，利用4阶龙格库塔法求解混沌系统方程（2）和（3），每次迭代分别生成三个随机序列值，即6个混沌序列值χ=(x₁,x₂,x₃,x₄,x₅,x₆)；为了计算得到这个混沌序列值，首先获取明文块第一个字节的偏移量θ_i，取Lorenz系统的初始迭代次数为N₀，Chen系统的初始迭代次数为M₀，记Lorenz系统的迭代次数为ρ_L，Chen系统的迭代次数为ρ_C，则有：

${\mathrm{\ρ}}_L=\frac{{\mathrm{\θ}}_i}{N}+N_0,{\mathrm{\ρ}}_C=\frac{{\mathrm{\θ}}_i}{N}+M_0---\left(4\right)$

则每个分块的对应的混沌序列为

χ_ρ=(x₁(ρ_L),x₂(ρ_L),x₃(ρ_L),x₄(ρ_C),x₅(ρ_C),x₆(ρ_C))  (5)

为了使两个系统产生的序列具有耦合性，将得到的Lorenz系统产生的随机序列对和Chen系统产生的随机序列对进行异或运算：

$\begin{array}{c}{x}_4\left({\mathrm{\ρ}}_C\right)=x_4\left({\mathrm{\ρ}}_C\right)\⊕x_1\left({\mathrm{\ρ}}_L\right)\\ x_5\left({\mathrm{\ρ}}_C\right)=x_5\left({\mathrm{\ρ}}_C\right)\⊕x_2\left({\mathrm{\ρ}}_L\right)\\ x_6\left({\mathrm{\ρ}}_C\right)=x_6\left({\mathrm{\ρ}}_C\right)\⊕x_3\left({\mathrm{\ρ}}_L\right)\end{array}---\left(6\right)$

计混沌序列χ_ρ为初值序列 ${\mathrm{\χ}}_p^I=(x_1\left({\mathrm{\ρ}}_L\right),x_2\left({\mathrm{\ρ}}_L\right),x_3\left({\mathrm{\ρ}}_L\right),x_4\left({\mathrm{\ρ}}_C\right))$ 和干扰序列 ${\mathrm{\χ}}_{\mathrm{\ρ}}^d=(x_5\left({\mathrm{\ρ}}_C\right),x_6\left({\mathrm{\ρ}}_C\right));$

步骤三：用初值序列计算加密密钥的混沌序列

将初值序列

中的(x₁(ρ_L),x₂(ρ_L))小数部分作为Hénon混沌映射迭代的初始值、(x₃(ρ_L),x₄(ρ_L))小数部分作为二维Logistic混沌映射迭代的初始值，递归产生加密的密钥序列ω_ρ=(ω₁(ρ),ω₂(ρ),ω₃(ρ),ω₄(ρ))，其中(ω₁(ρ),ω₂(ρ))由式（7）的Hénon系统方程迭代产生：

$\left\{\begin{array}{c}{x}_{n+1}=y_n+1-a{x}_n^2\\ y_{n+1}={\mathrm{bx}}_n\end{array}\right.---\left(7\right)$

(ω₃(ρ),ω₄(ρ))由式（8）的二维Logistic混沌映射系统方程迭代产生：

$\left\{\begin{array}{c}{x}_{n+1}={\mathrm{\μ}}_1{x}_n(1-x_n)+{\mathrm{\γ}}_1{y}_n^2\\ y_{n+1}={\mathrm{\μ}}_2{y}_n(1-y_n)+{\mathrm{\γ}}_2(x_n^2+x_n{y}_n)\end{array}\right.---\left(8\right)$

映射中的参数取值为：2.75＜μ₁＜3.4,2.7＜μ₂＜3.45和0.15＜γ₁＜0.21,0.13＜γ₂＜0.15。

步骤四：重构加密密钥序列

得到加密密钥序列后，由于其产生的值并不能和明文进行异或操作，所以需要将加密密钥序列根据下式进行转换：

为了使两个系统产生的序列具有耦合性，进行如下计算：

$\begin{array}{c}{\mathrm{\ω}}_3\left(\mathrm{\ρ}\right)={\mathrm{\ω}}_1\left(\mathrm{\ρ}\right)\⊕{\mathrm{\ω}}_3\left(\mathrm{\ρ}\right)\\ {\mathrm{\ω}}_4\left(\mathrm{\ρ}\right)={\mathrm{\ω}}_2\left(\mathrm{\ρ}\right)\⊕{\mathrm{\ω}}_4\left(\mathrm{\ρ}\right)\end{array}---\left(10\right)$

步骤五：数据加密

在生成了加密密钥序列后，将进行明文文件的加密，加密操作是依次在明文中取4个字节长度数据块对应的ASCII码M，同加密密钥序列进行异或(XOR)操作得到中间结果，然后再同干扰序列进行二次异或操作得到最终的密文C：

$\left\{\begin{array}{c}{C}_{4k+1}=(M_{4k+1}\⊕{\mathrm{\ω}}_1(k+1))\⊕x_5(k+1)\\ C_{4k+2}=(M_{4k+2}\⊕{\mathrm{\ω}}_2(k+1))\⊕x_6(k+1)\\ C_{4k+3}=(M_{4k+3}\⊕{\mathrm{\ω}}_3(k+1))\⊕x_5(k+1)\\ C_{4k+4}=(M_{4k+4}\⊕{\mathrm{\ω}}_4(k+1))\⊕x_6(k+1)\end{array}\right.---\left(11\right)$

其中k代表数据块的序号，C_4k+1，C_4k+2，C_4k+3，C_4k+4分别为数据块中对应于第1、2、3和4个字节的加密密文。在方法提出的加密方法中，密钥空间包括密钥序列的初始值χ(0)=(x₁(0),x₂(0),x₃(0),x₄(0),x₅(0),x₆(0))、Lorenz和Chen系统的初始迭代次数N₀和M₀，以及两个混沌系统的参数p,r,t和a,b,c。