CN101567781A - 利用排序产生的序号码加密的方法及密码机 - Google Patents

利用排序产生的序号码加密的方法及密码机 Download PDF

Info

Publication number
CN101567781A
CN101567781A CNA2009101474540A CN200910147454A CN101567781A CN 101567781 A CN101567781 A CN 101567781A CN A2009101474540 A CNA2009101474540 A CN A2009101474540A CN 200910147454 A CN200910147454 A CN 200910147454A CN 101567781 A CN101567781 A CN 101567781A
Authority
CN
China
Prior art keywords
numbers
ordered series
circulation
data
registers group
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Pending
Application number
CNA2009101474540A
Other languages
English (en)
Inventor
刘海云
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Individual
Original Assignee
Individual
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Individual filed Critical Individual
Priority to CNA2009101474540A priority Critical patent/CN101567781A/zh
Publication of CN101567781A publication Critical patent/CN101567781A/zh
Pending legal-status Critical Current

Links

Landscapes

  • Computer And Data Communications (AREA)
  • Storage Device Security (AREA)
  • Facsimile Transmission Control (AREA)

Abstract

本发明涉及一种利用序号码加密的方法及密码机，本发明的基本特征是：用某种算法计算整数数列P的序号码，并以序号码为密钥对明文加密。所述序号码是指按照某种规则对一个数列重新排序得到新数列后，原数列中数据在新数列中的位置序号代码。用序号码来加密信息时，具有其他任何加密方法不具有的特性：第一由于序号码是通过数学中的大小关系产生的，任何破解者无法根据数列P的序号码推出数列P，第二用数列P的序号码中的数据直接与明文进行异或、加、减等运算时具有高效地破坏频率特征的功能，第三可根据序号码的位置序号重排明文中各代码的位置。

Description

利用排序产生的序号码加密的方法及密码机
技术领域
本发明涉及一种利用排序产生的序号码对数字信息加密的方法。
背景技术
随着计算机速度的不断提高，当前分组加密算法不断受到挑战，甚至已被破解如DES加密，这需要加密强度更高的方法来取代现有的加密方法。
发明内容
本发明正是针对以上问题而产生。
根据本发明的一个方面，提供一种加密方法，其加密流程如下：
【1】用预定算法计算数列P的序号码，
【2】以序号码为密钥对明文分组加密，其中，
所述预定算法是指用于排序的方法，并且是下列其中一种：计数排序法、快速排序算法、选择排序算法、冒泡排序算法、堆排序算法、归并排序算法、希尔排序算法、插入排序算法、二叉树排序算法、桶排序算法、基数排序算法，
所述序号码是指按照某种规则对一个数列重新排序得到新数列后，原数列中数据在新数列中的位置序号代码，并且，所述按照某种规则对一个数列重新排序指以下四者之一：①按照从大到小的顺序对一个数列重新排序，②按照从小到大的顺序对一个数列重新排序，③按照从大到小的顺序对一个数列重新排序，然后在此基础上再调整数列中数据的位置，④按照从小到大的顺序对一个数列重新排序，然后在此基础上再调整数列中数据的位置，
所述以序号码为密钥对明文分组加密，是指采用以下算法中一种或多种：根据序号码重新排列明文分组各代码的位置，直接利用序号码与明文分组的数据做异或、同或、加、减、乘、除、取模等运算来加密。
根据本发明的一个方面，提供一种加密方法，其加密流程如下：
【1】用计数排序法计算数列P的序号码，
【2】以序号码为密钥对明文分组加密，其中，
所述序号码是指按照某种规则对一个数列重新排序得到新数列后，原数列中数据在新数列中的位置序号代码，并且，所述按照某种规则对一个数列重新排序指以下四者之一：①按照从大到小的顺序对一个数列重新排序，②按照从小到大的顺序对一个数列重新排序，③按照从大到小的顺序对一个数列重新排序，然后在此基础上再调整数列中数据的位置，④按照从小到大的顺序对一个数列重新排序，然后在此基础上再调整数列中数据的位置，
所述以序号码为密钥对明文分组加密，是指采用以下算法中一种或多种：根据序号码重新排列明文分组中各代码的位置，直接以序号码为密钥对明文分组的数据做异或、同或、加、减、乘、除、取模等运算来加密，
所述用计数排序法计算数列P的序号码，包括四步：(a)对计数数列清0，(b)用计数数列记录数列P中各种数值的出现次数，(c)对计数数列中的数据累加，(d)利用累加结果和数列P中的数据计算序号码，并且，所述数列P能以下列三种形式之一出现：(1)数列P在步骤(b)之前就已产生，(2)数列P在步骤(b)中产生，并且每产生一个数列P的数据p[i]，就将计数数列中与数据p[i]的值对应的数据加1，(3)数列P在步骤(b)中产生，并且在数列P中数据都产生之后，再用计数数列记录数列P中各种数值的出现次数，
在数列P以(1)这种形式出现的条件下，步骤【1】可采用以下八种方法之一或指以下八种方法的变异方法：
第一种计数排序法计算序号码的方法如下：
①i＝0                    /*...给i赋初始值...*/
针对i循环执行以下指令：             /*...执行2n遍...*/
{
r[i]＝0
/*...将数列R清0，r[i]表示数列R中第i+1个整数...*/
i＝i+1
}
②i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：            /*...执行2n遍...*/
{
r[p[i]]＝r[p[i]]+1
/*...计数，p[i]表示数列P中第i+1个整数，r[p[i]]表示数列R中第p[i]+1个整数...*/
i＝i+1
}
③i＝1                      /*...给i赋初始值...*/
针对i循环执行以下指令：            /*...执行2n-1遍...*/
{
r[i]＝r[i]+r[i-1]       /*...累加...*/
i＝i+1
}
④i＝0                      /*...给i赋初始值...*/
针对i循环执行以下指令：            /*...执行2n遍...*/
{
r[p[i]]＝r[p[i]]-1
k[i]＝r[p[i]]
/*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数，当然前面两条指令也可修改为：k[i]＝r[p[i]]-1  r[p[i]]＝k[i]...*/
i＝i+1
}
第二种计数排序法计算序号码的方法如下：
①i＝0                      /*...给i赋初始值...*/
针对i循环执行以下指令：                 /*...执行2n遍...*/
{
r[i]＝0
/*...将数列R清0，r[i]表示数列R中第i+1个整数...*/
i＝i+1
}
②i＝0                     /*...给i赋初始值...*/
针对i循环执行以下指令：            /*...执行2n遍...*/
{
r[p[i]]＝r[p[i]]+1
/*...计数，p[i]表示数列P中第i+1个整数，r[p[i]]表示数列R中第p[i]+1个整数...*/
i＝i+1
}
③i＝1  a＝r[0]  r[0]＝0       /*...赋初始值...*/
针对i循环执行以下指令：      /*...执行2n-1遍...*/
{
b＝r[i]
r[i]＝a+r[i-1]         /*...累加...*/
i＝i+1  a＝b
}
④i＝0                        /*...给i赋初始值...*/
针对i循环执行以下指令：          /*...执行2n遍...*/
{
k[i]＝r[p[i]]
r[p[i]]＝r[p[i]]+1
/*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数...*/
i＝i+1
}
第三种计数排序法计算序号码的方法如下：
①i＝0                       /*...给i赋初始值...*/
针对i循环执行以下指令：         /*...执行2n遍...*/
{
r[i]＝0
/*...将数列R清0，r[i]表示数列R中第i+1个整数...*/
i＝i+1
}
②i＝0                       /*...给i赋初始值...*/
针对i循环执行以下指令：         /*...执行2n遍...*/
{
r[p[i]]＝r[p[i]]+1
/*...计数，p[i]表示数列P中第i+1个整数，r[p[i]]表示数列R中第p[i]+1个整数...*/
i＝i+1
}
③i＝2n-2                  /*...给i赋初始值...*/
针对i循环执行以下指令：       /*...执行2n-1遍...*/
{
r[i]＝r[i]+r[i+1]     /*...累加...*/
i＝i-1
}
④i＝0                     /*...给i赋初始值...*/
针对i循环执行以下指令：        /*...执行2n遍...*/
{
r[p[i]]＝r[p[i]]-1
k[i]＝r[p[i]]
/*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数，当然前面两条指令也可修改为：k[i]＝r[p[i]]-1  r[p[i]]＝k[i]...*/
i＝i+1
}
第四种计数排序法计算序号码的方法如下：
①i＝0                     /*...给i赋初始值...*/
针对i循环执行以下指令：                    /*...执行2n遍...*/
{
r[i]＝0
/*...将数列R清0，r[i]表示数列R中第i+1个整数...*/
i＝i+1
}
②i＝0                 /*...给i赋初始值...*/
针对i循环执行以下指令：                /*...执行2n遍...*/
{
r[p[i]]＝r[p[i]]+1
/*...计数，p[i]表示数列P中第i+1个整数，r[p[i]]表示数列R中第p[i]+1个整数...*/
i＝i+1
}
③i＝2n-2  a＝r[2n-1]  r[2n-1]＝0    /*...赋初始值...*/
针对i循环执行以下指令：           /*...执行2n-1遍...*/
{
b＝r[i]
r[i]＝a+r[i+1]        /*...累加...*/
i＝i-1  a＝b
}
④i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：             /*...执行2n遍...*/
{
k[i]＝r[p[i]]
r[p[i]]＝r[p[i]]+1
/*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数...*/
i＝i+1
}
第五种计数排序法计算序号码的方法如下：
①i＝0                      /*...给i赋初始值...*/
针对i循环执行以下指令：                   /*...执行2n遍...*/
{
k[i]＝0
/*...将数列K清0，k[i]表示数列K中第i+1个整数...*/
i＝i+1
}
②i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：             /*...执行2n遍...*/
{
k[p[i]]＝k[p[i]]+1
/*...计数，p[i]表示数列P中第i+1个整数，k[p[i]]表示数列K中第p[i]+1个整数...*/
i＝i+1
}
③i＝1  r[0]＝k[0]                 /*...给i赋初始值...*/
针对i循环执行以下指令：             /*...执行2n-1遍...*/
{
r[i]＝k[i]+r[i-1]     /*...累加...*/
i＝i+1
}
④i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：            /*...执行2n遍...*/
{
r[p[i]]＝r[p[i]]-1
k[i]＝r[p[i]]
/*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数...*/
i＝i+1
}
第六种计数排序法计算序号码的方法如下：
①i＝0                     /*...给i赋初始值...*/
针对i循环执行以下指令：                  /*...执行2n遍...*/
{
k[i]＝0
/*...将数列K清0，k[i]表示数列K中第i+1个整数...*/
i＝i+1
}
②i＝0                    /*...给i赋初始值...*/
针对i循环执行以下指令：             /*...执行2n遍...*/
{
k[p[i]]＝k[p[i]]+1
/*...计数，p[i]表示数列P中第i+1个整数，k[p[i]]表示数列K中第p[i]+1个整数...*/
i＝i+1
}
③i＝1  r[0]＝0               /*...赋初始值...*/
针对i循环执行以下指令：           /*...执行2n-1遍...*/
{
r[i]＝k[i-1]+r[i-1]     /*...累加...*/
i＝i+1
}
④i＝0                        /*...给i赋初始值...*/
针对i循环执行以下指令：            /*...执行2n遍...*/
{
k[i]＝r[p[i]]
r[p[i]]＝r[p[i]]+1
/*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数...*/
i＝i+1
}
第七种计数排序法计算序号码的方法如下：
①i＝0                      /*...给i赋初始值...*/
针对i循环执行以下指令：                  /*...执行2n遍...*/
{
k[i]＝0
/*...将数列K清0，k[i]表示数列K中第i+1个整数...*/
i＝i+1
}
②i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：             /*...执行2n遍...*/
{
k[p[i]]＝k[p[i]]+1
/*...计数，p[i]表示数列P中第i+1个整数，k[p[i]]表示数列K中第p[i]+1个整数...*/
i＝i+1
}
③i＝2n-2  r[2n-1]＝k[2n-1]          /*...给i赋初始值...*/
针对i循环执行以下指令：           /*...执行2n-1遍...*/
{
r[i]＝k[i]+r[i+1]    /*...累加...*/
i＝i-1
}
④i＝0                            /*...给i赋初始值...*/
针对i循环执行以下指令：              /*...执行2n遍...*/
{
r[p[i]]＝r[p[i]]-1
k[i]＝r[p[i]]
/*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数...*/
i＝i+1
}
第八种计数排序法计算序号码的方法如下：
①i＝0                      /*...给i赋初始值...*/
针对i循环执行以下指令：                  /*...执行2n遍...*/
{
k[i]＝0
/*...将数列K清0，k[i]表示数列K中第i+1个整数...*/
i＝i+1
}
②i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：            /*...执行2n遍...*/
{
k[p[i]]＝k[p[i]]+1
/*...计数，p[i]表示数列P中第i+1个整数，k[p[i]]表示数列K中第p[i]+1个整数...*/
i＝i+1
}
③i＝2n-2  r[2n-1]＝0      /*...赋初始值...*/
针对i循环执行以下指令：                  /*...执行2n-1遍...*/
{
r[i]＝k[i+1]+r[i+1]      /*...累加...*/
i＝i-1
}
④i＝0                /*...给i赋初始值...*/
针对i循环执行以下指令：          /*...执行2n遍...*/
{
k[i]＝r[p[i]]
r[p[i]]＝r[p[i]]+1
/*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数...*/
i＝i+1
}
在数列P以(2)这种形式出现的条件下，对于前四种计数排序法计算序号码的方法，只要修改方法中的②即可，如将②修改为如下：
②i＝0                      /*...给i赋初始值...*/
针对i循环执行以下指令：               /*...执行2n遍...*/
{
p[i]＝f(...)      /*...f(...)用来表示产生数列P的程序段...*/
r[p[i]]＝r[p[i]]+1
/*...计数，p[i]表示数列P中第i+1个整数，r[p[i]]表示数列R中第p[i]+1个整数...*/
i＝i+1
}
在数列P以(3)这种形式出现的条件下，对于前四种计数排序法计算序号码的方法，只要修改方法中的②即可，如将②修改为如下：
②
i＝0                     /*...给i赋初始值...*/
针对i循环执行以下指令：                /*...执行2n遍...*/
{
p[i]＝f(...)      /*...f(...)用来表示产生数列P的程序段...*/
i＝i+1
}
i＝0                         /*...给i赋初始值...*/
针对i循环执行以下指令：                    /*...执行2n遍...*/
{
r[p[i]]＝r[p[i]]+1
/*...计数，p[i]表示数列P中第i+1个整数，r[p[i]]表示数列R中第p[i]+1个整数...*/
i＝i+1
}
在数列P以(2)这种形式出现的条件下，对于后四种计数排序法计算序号码的方法，只要修改方法中的②即可，如将②修改为如下：
②i＝0                       /*...给i赋初始值...*/
针对i循环执行以下指令：                /*...执行2n遍...*/
{
p[i]＝f(...)       /*...f(...)用来表示产生数列P的程序段...*/
k[p[i]]＝k[p[i]]+1
/*...计数，p[i]表示数列P中第i+1个整数，k[p[i]]表示数列K中第p[i]+1个整数...*/
i＝i+1
}
在数列P以(3)这种形式出现的条件下，对于后四种计数排序法计算序号码的方法，只要修改方法中的②即可，如将②修改为如下：
②
i＝0                    /*...给i赋初始值...*/
针对i循环执行以下指令：               /*...执行2n遍...*/
{
p[i]＝f(...)    /*...f(...)用来表示产生数列P的程序段...*/
i＝i+1
}
i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：              /*...执行2n遍...*/
{
k[p[i]]＝k[p[i]]+1
/*...计数，p[i]表示数列P中第i+1个整数，k[p[i]]表示数列K中第p[i]+1个整数...*/
i＝i+1
}
上述计数排序法计算序号码的方法中：如果将所有出现的“k[i]＝r[p[i]]”修改为：“k[(i+u)％(2n)]＝(r[p[i]]+w)％(2n)”则可产生变异的计算序号码的方法，如果将所有出现的“k[i]＝r[p[i]]”修改为：“k[(i+u)％(2n)]＝((r[p[i]]*r[p[i]]+r[p[i]]+v)/2+w)％(2n)”则又可产生变异的计算序号码的方法，如果将所有出现的“k[i]＝r[p[i]]”修改为：“k[(i+u)％(2n)]＝f(r[p[i]])”则又可产生变异的计算序号码的方法，其中f(r[p[i]])表示以r[p[i]]为变元的函数，即以序号码为变元，如果将所有出现的“r[p[i]]”修改为：“r[(p[i]+z)％(2n)]”，并将所有出现的“k[p[i]]”修改为：“k[(p[i]+z)％(2n)]”则也可产生变异的计算序号码的方法，如果将计数器i的初始值修改为其他大于-1的数值，并将受该参数影响的命令参数适当修改就可产生变异的计算序号码的方法，上面计算序号码的方法中计数器i的计数操作(如加1或减1)都放在循环体的尾部，如果将计数器i的计数操作放在循环体的首部，并调整受影响的命令参数适当修改也可产生变异的计算序号码的方法，注意前面所出现的z、u、v、w在计算序号码的过程中是不变的整数。
根据本发明的一个方面，提供一种加密方法，其加密流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数的数列P，设置j＝0
【2】将明文分组逐组输入明文数列T中，并且每输入一组明文后做下列运算：
{/*...第一层循环，当最后一个明文分组加密完毕时跳出循环，明文分组长为2n个单元，每个单元为n个比特，n为正整数...*/
①用计数排序法计算将数列P按照大小关系进行排序的序号码，并将序号码记录到数列K中，
②i＝0
针对整数i做下列循环运算：
{                     /*...第二层循环，i等于2n时跳出循环...*/
c[j]＝(t[i]+k[i])％(2n)
i＝i+1
j＝j+1
/*...即用序号码对明文数列T加密，其中t[i]表示数列T中第i+1个整数，k[i]表示数列K中第i+1个整数，c[j]表示密文数列C中第j+1个密文，“％”表示mod，...*/
}
③i＝0
针对整数i做下列循环运算：
{                     /*...第二层循环，i等于2n时跳出循环...*/
p[i]＝(p[i]+(t[i]*t[i]+t[i])/2)％(2n)
/*...即用明文数列T中的数据对数列P更新，其中t[i]，p[i]分别表示数列T、数列P中第i+1个整数，*表示乘，/表示整除，上式应用函数：f(x)＝((x2+x)/2)％(2n)对数列P加密，函数f(x)在x和n都为正整数的条件下，具有最佳的离散性能...*/
i＝i+1
}
}
根据本发明的一个方面，提供一种加密方法，其加密流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数的数列P，设置j＝0
【2】将明文分组逐组输入明文数列T中，并且每输入一组明文后做下列运算：
{/*...第一层循环，当最后一个明文分组加密完毕时跳出循环，明文分组长为2n个单元，每个单元为n个比特，n为正整数...*/
①用计数排序法计算将数列P按照大小关系进行排序的序号码，并将序号码记录到数列K中，
②i＝0
针对整数i做下列循环运算：
{                    /*...第二层循环，i等于2n时跳出循环...*/
s[i]＝t[k[i]]
i＝i+1
/*...即用数列K中的序号码重新排列数列T中各整数的位置，并将结果保存在数列S中，其中k[i]分别表示数列K中第i+1个整数，t[k[i]]表示数列T中第k[i]+1个整数，s[i]表示数列S中第i+1个密文...*/
}
③i＝0
针对整数i做下列循环运算：
{                      /*...第二层循环，i等于2n时跳出循环...*/
c[j]＝(s[i]+k[i])％(2)
i＝i+1
j＝j+1
/*...即用序号码对数列S继续加密，其中s[i]表示数列S中第i+1个整数，k[i]表示数列K中第i+1个整数，c[j]表示密文数列C中第j+1个密文，“％”表示mod，...*/
}
④i＝0
针对整数i做下列循环运算：
{                      /*...第二层循环，i等于2n时跳出循环...*/
p[i]＝(p[i]+(t[i]*t[i]+t[i])/2)％(2n)
/*...即用明文数列T中的数据对数列P更新，其中t[i]，p[i]分别表示数列T、数列P中第i+1个整数，*表示乘，/表示整除    ...*/
i＝i+1
}
}
根据本发明的一个方面，提供一种加密方法，其加密流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数的数列P，并且数列P中每个整数可用n比特表示，设置j＝0，
【2】将明文分组逐组输入明文数列T中，并且每输入一组明文后做下列运算：
{    /*...第一层循环，当最后一个明文分组加密完毕时跳出循环...*/
①用计数排序法计算将数列P按照大小关系进行排序的序号码，并将序号码记录到数列K中，
②i＝0
针对整数i做下列循环运算：
{                      /*...第二层循环，i等于2n时跳出循环...*/
s[i]＝t[i]^k[i]
i＝i+1
/*...即用序号码对明文数列T加密，其中t[i]表示数列T中第i+1个整数，k[i]表示数列K中第i+1个整数，s[i]表示整数数列s中第i+1个密文，“^”表示异或...*/
}
③i＝0
针对整数i做下列循环运算：
{                    /*...第二层循环，i等于2n时跳出循环...*/
q[i]＝p[k[i]]
i＝i+1
/*...依据数列K中记录的序号码，将用数列P中的数据逆向复制到数列Q中，其中q[i]、k[i]分别表示数列Q、数列K中第i+1个整数，p[k[i]]表示数列P中第k[i]+1个整数...*/
}
④用计数排序法计算将数列Q按照大小关系进行排序的序号码，并将序号码记录到数列K中，
⑤i＝0
针对整数i做下列循环运算：
{                      /*...第二层循环，i等于2n时跳出循环...*/
c[j+i]＝s[k[i]]
i＝i+1
/*...即用数列K中的序号码重新排列数列S中各整数的位置，并将结果作为密文输出，其中k[i]分别表示数列K中第i+1个整数，s[k[i]]表示数列s中第k[i]+1个整数，c[j+i]表示密文数列C中第j+i+1个密文，...*/
}
⑥i＝0
针对整数i做下列循环运算：
{                      /*...第二层循环，i等于2n时跳出循环...*/
p[i]＝(q[i]+(t[i]*t[i]+t[i])/2)％(2n)
i＝i+1
/*...即用明文数列T中的数据对数列Q更新，并将更新结果保存在数列P中，其中t[i]、p[i]、q[i]分别表示数列T、数列P、数列Q中第i+1个整数，...*/
}
⑦j＝j+2n        /*...这里为下一个分组的加密做准备...*/
}
根据本发明的一个方面，提供一种加密方法，其加密流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数的数列P，并且数列P中每个整数可用n比特表示，设置j＝0
【2】将明文分组逐组输入明文数列T中，并且每输入一组明文后做下列运算：
{    /*...第一层循环，当最后一个明文分组加密完毕时跳出循环...*/
①用计数排序法计算将数列P按照大小关系排序的序号码，并将序号码记录到数列K中，
②i＝0
针对i进行循环计算：
{                      /*...第二层循环，i等于2n时跳出循环...*/
s[k[i]]＝t[i]
/*...s[k[i]]表示数列S中第k[i]+1个整数，这里将明文分组重排位置并将结果保存在数列S中...*/
i＝i+1
}
③i＝0
针对i进行循环计算：
{                    /*...第二层循环，i等于2n时跳出循环...*/
q[i]＝p[k[i]]
i＝i+1
}
④i＝0
针对i进行循环计算：
{                   /*...第二层循环，i等于2n时跳出循环...*/
r[i]＝((q[i]*q[i]+q[i])/2+p[i])％2n
i＝i+1
}
⑤用计数排序法计算将数列Q按照大小关系排序的序号码，并将序号码记录到数列K中，
⑥i＝0
针对i进行循环计算：
{                         /*...第二层循环，i等于2n时跳出循环...*/
c[j]＝(k[i]+r[i]+s[i])％2n       /*...加密...*/
i＝i+1
j＝j+1
}
⑦i＝0
针对i进行循环计算：
{                           /*...第二层循环，i等于2n时跳出循环...*/
p[i]＝(q[i]+t[i])％2n
/*...用明文数列T对数列Q更新，并将结果保存在数列P中...*/
i＝i+1
}
}
根据本发明的一个方面，提供一种加密方法，其加密流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数的数列P，并且数列P中每个整数可用n比特表示，
【2】将明文分组逐组输入数列C中，并且每输入一组明文后做下列运算：
{    /*...第一层循环，当最后一个明文分组加密完毕时跳出循环...*/
①用计数排序法计算将数列P按照大小关系排序的序号码，并将序号码记录到数列K中，
②R＝g(P)
/*...这里表示R是数列P中数据作函数g运算后得到的结果...*/
d＝2n-1
{    /*...第二层循环，当d等于-1时，结束本循环，...*/
t[d]＝c[d]^(((R*R+R)/2)％(2n))
R＝((c[d]*c[d]+c[d]*3)/2+R)％2n
/*...t[d]、c[d]分别表示数列T、数列C中第d+1个整数...*/
d＝d-1
}
③R＝h(P)
/*...这里表示R是数列P中数据作函数h运算后得到的结果...*/
a＝0
{    /*...第二层循环，当a等于2n时，结束本循环，...*/
c[k[a]]＝t[a]^(((R*R+R)/2)％(2n))
/*...c[k[a]]表示密文分组数列C中第k[a]+1个整数，k[a]、t[a]分别表示数列K、数列T中第a+1个整数，这里将数列T重排位置并将结果保存在密文分组数列C中...*/
R＝((t[a]*t[a]+t[a]*3)/2+R)％(2n)
a＝a+1
}
④i＝0
针对i进行循环计算：
{                     /*...第二层循环，i等于2n时跳出循环...*/
q[i]＝f(p[k[i]])   /*...f(p[k[i]])表示以为p[k[i]]变量，作某种函数运算...*/
i＝i+1
}
⑤i＝0
针对i进行循环计算：
{                   /*...第二层循环，i等于2n时跳出循环...*/
r[i]＝((q[i]*q[i]+q[i])/2+p[i])％2n
i＝i+1
}
⑥用计数排序法计算将数列Q按照大小关系排序的序号码，并将序号码记录到数列K中，
⑦i＝0
针对i进行循环计算：
{                          /*...第二层循环，i等于2n时跳出循环...*/
c[i]＝(k[i]+r[i]+c[i])％2n        /*...加密...*/
i＝i+1
}
输出分组密文数列C
⑧i＝0
针对i进行循环计算：
{                         /*...第二层循环，i等于2n时跳出循环...*/
p[i]＝(q[i]+t[i])％2n
/*...对数列Q更新，并将结果保存在数列P中...*/
i＝i+1
}
}
根据本发明的一个方面，提供一种密码机，该密码机的结构如下：
有一个处理器CPU，该处理器CPU集成有运算寄存器R、递增计数器A、递减计数器D和四组运算寄存器。并且，所述四组运算寄存器分别为：寄存器组S、寄存器组K、寄存器组T、寄存器组C，每个寄存器组都有2n个单元，每个单元为可保存n比特信息，每个寄存器组不仅可寄存数据，还可作为寄存器组中单元的相对地址控制寄存器，处理器CPU通过数据总线接收和输出信息，处理器CPU每执行一个跳转指令递增计数器A加1，递减计数器D减1，当这些计数器与地址控制线路接通时，计数器中的数值就决定该地址控制线路接通的运算寄存器组中哪个单元能接通使用，并且接通的单元序号就等于计数器中的数值，即计数器可作为前述四组运算寄存器的相对地址控制寄存器，计数器还用于控制循环次数，所述寄存器R只有一个单元且能容纳n比特的信息，并且密码机的工作流程分为加密工作流程和解密工作流程这两部分，其中，
密码机加密工作流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数(每个整数为n比特)的数列，并将该数列保存在寄存器组S中，
【2】将明文分组逐组输入寄存器组C中，并且每输入一组明文后做下列运算：
{    /*...第一层循环，明文分组长为2n×n比特，当最后一组明文加密完毕时跳出循环...*/
(1)将递增计数器A作为寄存器组S的相对地址控制寄存器接通，寄存器组S作为寄存器组K的相对地址控制寄存器接通，并将寄存器组K中各单元都设为0，将计数器A设为0，然后，循环执行以下指令：
{                  /*...当a等于2n时，结束本循环，...*/
执行K[S[a]]←K[S[a]]+1的指令
/*...a表示递增计数器A中的数值，S[a]表示寄存器组S中序号为a的单元，K[S[a]]表示寄存器组K中由S[a]接通的单元，即表示寄存器组K中序号等于S[a]中数据的单元，这条指令是将K[s[a]]中数据与1相加，并将结果传送到K[S[a]]，...*/
}
(2)将递减计数器D作为寄存器组K、寄存器组T的相对地址控制寄存器接通，将寄存器R设为0，将递减计数器D设为2n-1，然后，循环执行以下指令：
{             /*...当d等于-1时，结束本循环，...*/
执行T[d]←(K[d]+R)→R的指令
/*...d表示递减计数器D中的数据，K[d]表示寄存器组K中序号为d的单元，T[d]表示寄存器组T中序号为d的单元，这条指令是将K[d]中数据和寄存器R中数据相加，并将运算结果传送给寄存器组T中序号为d的单元，同时还将运算结果传送给寄存器R，这里实现对寄存器组K中整数的累加，本循环结束时，T[0]中的数据应为2n，但由于四组寄存器中各单元的长度都为n比特，因此只能表示2n个数据，又因序号从0开始，所以实际上本循环结束时T[0]中的数据为0，但只要能实现四组寄存器中各单元在单元中的数据为0的情况下作减1运算后，该单元中代码与表示2n-1的代码相同，就不会影响本密码机的实施，...*/
}
(3)将递增计数器A作为寄存器组S和寄存器组K的相对地址控制寄存器接通，将寄存器组S作为寄存器组T的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{         /*...当a等于2n时，结束本循环，...*/
执行K[a]←(T[S[a]]-1)→T[S[a]]的指令
/*...a为递增计数器A中的数据，S[a]、K[a]分别表示寄存器组S、寄存器组K中序号为a的单元，T[S[a]]表示寄存器组T中序号等于S[a]中内容的单元，这条指令表示将T[S[a]]中数据减1，然后将结果传送到K[a]，同时也传送到T[S[a]]，以实现算出序号码，...*/
}
(4)执行R←(K[2n-1]+S[K[2n-2]])％2n的命令
/*...这条指令是将寄存器组S中序号等于K[2n-2]中数据的单元数据与寄存器组K中第2n个单元中的数据相加，然后模2n，并将结果传送到寄存器R中...*/
递减计数器D作为寄存器组C和寄存器组T的相对地址控制寄存器接通，并将计数器D设为2n-1，然后，循环执行以下指令：
{          /*...当d等于-1时，结束本循环，...*/
执行T[d]←(C[d])^(((R*R+R)/2)％(2n))的指令
/*...d为递减计数器D中的数据，T[d]、C[d]分别表示寄存器组T、寄存器组C中序号为d的单元，这条指令表示将寄存器R中数据的平方与寄存器R中数据相加后，以2整除，然后模2n，再与C[d]中数据作异或运算，并将结果传送到T[d]，即对分组信息进行第一次加密...*/
执行R←((C[d]*C[d]+C[d]*3)/2+R)％2n的指令
/*...将寄存器组C中第d+1个单元中的数据乘以3的结果与寄存器组C第d+1个单元中的数据平方相加，接着以2整除，然后与寄存器R中数据相加，再模2n，并将运算结果传送到寄存器R中...*/
}
(5)执行R←(K[1]+S[K[0]])％2n的指令
/*...即将寄存器组K中第2个单元中的数据和寄存器组S中第K[0]+1个单元中的数据相加，并将结果传送到寄存器R，...*/
将递增计数器A作为寄存器组T和寄存器组K的相对地址控制寄存器接通，将寄存器组K作为寄存器组C的相对地址控制寄存器接通，接着将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行C[K[a]]←T[a]^(((R*R+R)/2)％(2n))的指令
/*...这条指令表示将寄存器R中数据的平方与寄存器R中数据相加，接着以2整除，然后模2n，再与寄存器组T中第a个单元中数据互异，并将运算结果传送到存器组C的第K[a]+1个单元，即对分组信息进行第二次加密，...*/
执行R←((T[a]*T[a]+T[a]*3)/2+R)％(2n)的指令
/*...这条指令表示将T[a]中数据与3相乘后的积与T[a]中数据的平方相加，接着以2整除，然后加上寄存器R中的数据，再模2n，并将运算结果传送到存器R，为加密下一单元做准备，...*/
}
(6)将递增计数器A作为寄存器组K的相对地址控制寄存器接通，将寄存器组K作为寄存器组S的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行K[a]←S[K[a]]^m的指令
/*...S[K[a]]表示寄存器组S中序号等于K[a]中数据的单元，这条指令表示将S[K[a]]中数据与m作互异运算，并将结果保存在寄存器组K中序号等于a的单元，m为常数，
}
(7)将递增计数器A作为寄存器组K、S这两者的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{       /*...当a等于2n时，结束本循环，...*/
执行S[a]←((K[a]*K[a]+K[a])/2+S[a])％(2n)的指令
/*...这务指令表示将K[a]中整数的平方与K[a]中整数相加，接着以2整除，然后与S[a]中数据相加，再模2n，并将结果传送到寄存器组S中序号为a的单元中，以便后面实施第三次加密，...*/
}
(8)将递增计数器A作为寄存器组C、S这两者的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{     /*...当a等于2n时，结束本循环，...*/
执行C[a]←(C[a]+S[a])％2n的指令
/*...这条指令表示将C[a]和S[a]相加后，再模2n，并将结果传送到寄存器组C中序号为a的单元中，以实现第三次加密，...*/
}
(9)将递增计数器A作为寄存器组K的相对地址控制寄存器接通，寄存器组K作为寄存器组S的相对地址控制寄存器接通，将寄存器组S中各单元都设为0，并将计数器A设为0，然后，循环执行以下指令：
{                  /*...当a等于2n时，结束本循环，...*/
执行S[K[a]]←S[K[a]]+1的指令
/*...a表示递增计数器A中的数值，K[a]表示寄存器组K中序号为a的单元，S[K[a]]表示寄存器组S中由K[a]接通的单元，即表示寄存器组S中序号等于K[a]中数据的单元，这条指令是将S[K[a]]中数据与1相加，并将结果传送到S[K[a]]，...*/
}
(10)将计数器A作为寄存器组S的相对地址控制寄存器接通，将寄存器R设为0，将递增计数器A设为0，然后，循环执行以下指令：
{             /*...当a等于2n时，结束本循环，...*/
执行S[a]←(S[a]+R)→R的指令
/*...这条指令是将S[a]中数据和寄存器R中数据相加，并将运算结果传送给S[a]，同时还将运算结果传送给寄存器R，这里实现对寄存器组S中整数的累加，本循环结束时，S[2n-1]中的数据应为2n，但由于四组寄存器中各单元的长度都为n比特，因此只能表示2n个数据，又因序号从0开始，实际上本循环结束时S[2n-1]中的数据为0，但只要能实现四个寄存器组中各单元在单元中的数据为0的情况下作减1运算后，该单元中代码与表示2n-1的代码相同，就不会影响本密码机的实施，...*/
}
(11)将递增计数器A作为寄存器组K和寄存器组C的相对地址控制寄存器接通，将寄存器组K作为寄存器组S的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{        /*...当a等于2n时，结束本循环，...*/
执行R←S[K[a]]-1→S[K[a]]的指令
/*...这条指令表示将S[K[a]]中数据减1，然后将结果传送到寄存器R，同时也传送到S[K[a]]，以实现将寄存器组K中序号为a单元中数据按照从小到大在排序后新数列中的位置序号算出，...*/
执行Port←(R+C[a])％2n的指令
/*...port，表示输出端口或输出线路，这条指令表示将寄存器R中的数据与C[a]中的数据相加，并模2n，然后输出，这一步功能是利用序号码加密，这是第四次加密，并向外传送，...*/
}
(12)将递增计数器A作为寄存器组K、S、T的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{             /*...当a等于2n时，结束本循环，...*/
执行S[a]←(K[a]+T[a])％2n的指令
/*...这条指令表示将K[a]和T[a]相加后，再模2n，并将结果传送S[a]到中，以实现更新用来产生密钥的参数，为加密下一组明文做准备，...*/
}
}
密码机解密工作流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数(每个整数为n比特)的数列，并将该数列保存在寄存器组S中，
【2】将密文分组逐组输入寄存器组C中，并且每输入一组密文后做下列运算：
{    /*...第一层循环，密文分组长为2n×n比特，当最后一组密文解密完毕时跳出循环...*/
(1)将递增计数器A作为寄存器组S的相对地址控制寄存器接通，寄存器组S作为寄存器组K的相对地址控制寄存器接通，并将寄存器组K中各单元都设为0，将计数器A设为0，然后，循环执行以下指令：
{                    /*...当a等于2n时，结束本循环，...*/
执行K[S[a]]←K[S[a]]+1的指令
/*...a表示递增计数器A中的数值，S[a]表示寄存器组S中序号为a的单元，K[S[a]]表示寄存器组K中由S[a]接通的单元，即表示寄存器组K中序号等于S[a]中数据的单元，这条指令是将K[S[a]]中数据与1相加，并将结果传送到K[S[a]]，...*/
}
(2)将递减计数器D作为寄存器组T、寄存器组K的相对地址控制寄存器接通，将寄存器R设为0，将递减计数器D设为2n-1，然后，循环执行以下指令：
{           /*...当d等于-1时，结束本循环，...*/
执行T[d]←(K[d]+R)→R的指令
/*...d表示递减计数器D中的数据，K[d]表示寄存器组K中序号为d的单元，T[d]表示寄存器组T中序号为d的单元，这条指令是将K[d]中数据和寄存器R中数据相加，并将运算结果传送给寄存器组T中序号为d的单元，同时还将运算结果传送给寄存器R，这里实现对寄存器组K中整数的累加，本循环结束时，T[0]中的数据应为2n，但由于四组寄存器中各单元的长度都为n比特，因此只能表示2n个数据，又因序号从0开始，所以实际上本循环结束时T[0]中的数据为0，但只要能实现四组寄存器中各单元在单元中的数据为0的情况下作减1运算后，该单元中代码与表示2n-1的代码相同，就不会影响本密码机的实施，当d等于-1时，自动结束本循环，往下执行...*/
}
(3)将递增计数器A作为寄存器组S和寄存器组K的相对地址控制寄存器接通，将寄存器组S作为寄存器组T的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{         /*...当a等于2n时，结束本循环，...*/
执行K[a]←(T[S[a]]-1)→T[S[a]]的指令
/*...a为递增计数器A中的数据，S[a]、K[a]分别表示寄存器组S、寄存器组K中序号为a的单元，T[S[a]]表示寄存器组T中序号等于S[a]中内容的单元，这条指令表示将T[S[a]]中数据减1，然后将结果传送到K[a]，同时也传送到T[S[a]]，以实现算出序号码，...*/
}
(4)将递增计数器A作为寄存器组K、T的相对地址控制寄存器接通，将寄存器组K作为寄存器组S的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{          /*...当a等于2n时，结束本循环，...*/
执行T[a]←S[K[a]]^m的指令
/*...S[K[a]]表示寄存器组S中序号等于K[a]中数据的单元，这条指令表示将S[K[a]]中数据与m作互异运算，并将结果保存在寄存器组T中序号等于a的单元，m为常数，...*/
}
(5)将递增计数器A作为寄存器组T、S、C这三者的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{            /*...当a等于2n时，结束本循环往下执行，...*/
执行R←2n-((T[a]*T[a]+T[a])/2+S[a])％(2n)的指令
/*...这条指令表示将T[a]中整数的平方与T[a]中整数相加后，以2整除，接着与S[a]相加，再模2n，然后用2n减去前述模2n之后的结果，并将结果传送寄存器R，...*/
执行C[a]←(R+C[a])％(2n)的指令
/*...这条指令表示将C[a]中数据与R中数据相加，再模2n，并将结果传送C[a]，以实现解除第三次加密，...*/
}
(6)将递增计数器A作为寄存器组T的相对地址控制寄存器接通，寄存器组T作为寄存器组S的相对地址控制寄存器接通，将寄存器组S中各单元都设为0，并将计数器A设为0，然后，循环执行以下指令：
{         /*...当a等于2n时，结束本循环，...*/
执行S[T[a]]←S[T[a]]+1的指令
/*...a表示递增计数器A中的数值，T[a]表示寄存器组T中序号为a的单元，S[T[a]]表示寄存器组S中由T[a]接通的单元，即表示寄存器组S中序号等于T[a]中数据的单元，这条指令是将S[T[a]]中数据与1相加，并将结果传送到S[T[a]]，...*/
}
(7)将计数器A作为寄存器组S的相对地址控制寄存器接通，将寄存器R设为0，将递增计数器A设为0，然后，循环执行以下指令：
{             /*...当a等于2n时，结束本循环，...*/
执行S[a]←(S[a]+R)→R的指令
/*...这条指令是将S[a]中数据和寄存器R中数据相加，并将运算结果传送给S[a]，同时还将运算结果传送给寄存器R，这里实现对寄存器组S中整数的累加，本循环结束时，S[2n-1]中的数据应为2n，但由于四组寄存器中各单元的长度都为n比特，因此只能表示2n个数据，又因序号从0开始，实际上本循环结束时S[2n-1]中的数据为0，但只要能实现四组寄存器中各单元在单元中的数据为0的情况下作减1运算后，该单元中代码与表示2n-1的代码相同，就不会影响本密码机的实施，...*/
}
(8)将递增计数器A作为寄存器组C和寄存器组T的相对地址控制寄存器接通，将寄存器组T作为寄存器组S的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{             /*...当a等于2n时，结束本循环，...*/
执行R←S[T[a]]-1→S[T[a]]的指令
/*...这条指令表示将S[T[a]]中数据减1，然后将结果传送到寄存器R，同时也传送到S[T[a]]，以实现算出序号码，...*/
执行C[a]←(2n-R+C[a])％2n的指令
/*...这条指令表示用2n减去寄存器R中的数据再与C[a]中的数据相加，并模2n，并将结果传送到C[a]，以实现解除第四次加密，...*/
}
(9)执行R←(K[1]+(T[0]^m))％2n的指令
/*...即将寄存器组T中第1个单元中的数据与m作互异运算，将互异结果与寄存器组K中第2个单元中的数据相加，再模2n，并将结果传送到寄存器R，...*/
将递增计数器A作为寄存器组S、寄存器组K的相对地址控制寄存器接通，将寄存器组K作为寄存器组C的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{               /*...当a等于2n时，结束本循环，...*/
执行S[a]←C[K[a]]^(((R*R+R)/2)％(2n))的指令
/*...这条指令表示将寄存器R中数据的平方与寄存器R中数据相加，接着以2整除，然后模2n，再与寄存器组C中第K[a]+1个单元中数据互异，并将运算结果传送到存器组S的第a+1个单元，以实现解除第二次加密，...*/
执行R←((S[a]*S[a]+S[a]*3)/2+R)％(2n)的指令
/*...这条指令表示将S[a]中数据与3相乘后的数据与S[a]中数据的平方相加，接着以2整除，然后加上寄存器R中的数据，再模2n，并将运算结果传送到存器R，为解密下一单元做准备，...*/
}
(10)执行R←(K[2n-1]+(T[2n-2]^m))％2n的指令
/*...即将寄存器组T中第2n-1个单元中的数据与m作互异运算，将互异结果与寄存器组K中第2n个单元中的数据相加，再模2n，并将结果传送到寄存器R，...*/
将递减计数器D作为寄存器组C和寄存器组S的相对地址控制寄存器接通，并将计数器D设为2n-1，然后，循环执行以下指令：
{           /*...当d等于-1时，结束本循环，...*/
执行C[d]←(S[d])^(((R*R+R)/2)％(2n))→Port的指令
/*...d为递减计数器D中的数据，S[d]、C[d]分别表示寄存器组S、寄存器组C中序号为d的单元，这条指令表示将寄存器R中数据的平方与寄存器R中数据相加后，以2整除，然后模2n，再与S[d]中数据作异或运算，以实现解除第一次加密，并将结果传送到C[d]，同时输出明文...*/
执行R←((C[d]*C[d]+C[d]*3)/2+R)％2n的指令
/*...将寄存器组C中第d+1个单元中的数据乘以3的结果与寄存器组C第d+1个单元中的数据平方相加，接着以2整除，然后与寄存器R中数据相加，再模2n，并将运算结果传送到寄存器R中...*/
}
(11)将递增计数器A作为寄存器组S、T的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{             /*...当a等于2n时，结束本循环，...*/
执行S[a]←(S[a]+T[a])％2n的指令
/*...这条指令表示将S[a]和T[a]相加后，再模2n，并将结果传送S[a]到中，以实现更新用来产生密钥的参数，为解密下一组密文做准备，...*/
}
}
具体实施方式
本发明的基本特征是：用某种算法计算整数数列P的序号码，并以序号码为密钥对明文加密。所述序号码是指按照某种规则对一个数列重新排序得到新数列后，原数列中数据在新数列中的位置序号代码。所述按照某种规则对一个数列重新排序指以下四者之一：①按照从大到小的顺序对一个数列重新排序，②按照从小到大的顺序对一个数列重新排序，③按照从大到小的顺序对一个数列重新排序，然后在此基础上再调整数列中数据的位置，④按照从小到大的顺序对一个数列重新排序，然后在此基础上再调整数列中数据的位置。由于序号码记录的是位置序号，序号码中的整数总是互不相同的，因此序号码来加密信息时，具有其他任何加密方法不具有的特性：第一由于序号码是通过数学中的大小关系产生的，任何破解者无法根据数列P的序号码推出数列P，第二用序号码中的数据直接与明文进行异或、加、减等运算时具有高效地破坏频率特征的功能，第三可根据序号码的位置序号重排明文中各代码的位置。
在计算机上实验发现，当数列P中的整数都是n比特，数列P的个数为2n的条件下：当n≥3时，用计数排序法计算序号码比用快速排序法计算序号码快，当n＜3时，用计数排序法计算序号码比用快速排序法计算排序码慢，因此本发明主张：当n≥3时，用计数排序法计算序号码，当n＜3时，用快速排序法计算序号码。对计算序号码而言，在大多数情况下，计数排序法不仅速度快，而且不用对数列P进行排序也可计算序号码，这是其他排序法难以做到的，尤其是采用硬件实现本发明时，采用计数排序法来计算序号码的电路设计更简单。
本发明在利用序号码对数字信息的加密运算中，既可根据序号码重新排列明文中各代码的位置，可直接利用序号码与明文作异或、同或、加、减、乘、除、取模等运算，以生成密文实现对明文的加密。
本发明第一个实施例提供一种加密方法，其加密流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数的数列P，并且数列P中每个整数可用n比特表示，
【2】将明文分组逐组输入数列C中，并且每输入一组明文后做下列运算：
{    /*...第一层循环，当最后一个明文分组加密完毕时跳出循环...*/
①用计数排序法计算将数列P按照大小关系排序的序号码，并将序号码记录到数列K中，
②R＝g(P)
/*...这里表示R是数列P中数据作函数g运算后得到的结果...*/
d＝2n-1
{    /*...第二层循环，当d等于-1时，结束本循环，...*/
t[d]＝c[d]^(((R*R+R)/2)％(2))
R＝((c[d]*c[d]+c[d]*3)/2+R)％2
/*...t[d]、c[d]分别表示数列T、数列C中第d+1个整数...*/
d＝d-1
}
③R＝h(P)
/*...这里表示R是数列P中数据作函数h运算后得到的结果...*/
a＝0
{    /*...第二层循环，当a等于2n时，结束本循环，...*/
c[k[a]]＝t[a]^(((R*R+R)/2)％(2n))
/*...c[k[a]]表示密文分组数列C中第k[a]+1个整数，k[a]、t[a]分别表示数列K、数列T中第a+1个整数，这里将数列T重排位置并将结果保存在密文分组数列C中...*/
R＝((t[a]*t[a]+t[a]*3)/2+R)％(2n)
a＝a+1
}
④i＝0
针对i进行循环计算：
{                      /*...第二层循环，i等于2n时跳出循环...*/
q[i]＝f(p[k[i]])    /*...f(p[k[i]])表示以为p[k[i]]变量，作某种函数运算...*/
i＝i+1
}
⑤i＝0
针对i进行循环计算：
{                             /*...第二层循环，i等于2n时跳出循环...*/
r[i]＝((q[i]*q[i]+q[i])/2+p[i])％2n
i＝i+1
}
⑥用计数排序法计算将数列Q按照大小关系排序的序号码，并将序号码记录到数列K中，
⑦i＝0
针对i进行循环计算：
{                          /*...第二层循环，i等于2n时跳出循环...*/
c[i]＝(k[i]+r[i]+c[i])％2n        /*...加密...*/
i＝i+1
}
输出分组密文数列C
⑧i＝0
针对i进行循环计算：
{                         /*...第二层循环，i等于2n时跳出循环...*/
p[i]＝(q[i]+t[i])％2n
/*...对数列Q更新，并将结果保存在数列P中...*/
i＝i+1
}
}
本发明第二个实施例提供一种密码机，该密码机的结构如下：
有一个处理器CPU，该处理器CPU集成有运算寄存器R、递增计数器A、递减计数器D和四组运算寄存器。并且，所述四组运算寄存器分别为：寄存器组S、寄存器组K、寄存器组T、寄存器组C，每个寄存器组都有2n个单元，每个单元为可保存n比特信息，每个寄存器组不仅可寄存数据，还可作为寄存器组中单元的相对地址控制寄存器，处理器CPU通过数据总线接收和输出信息，处理器CPU每执行一个跳转指令递增计数器A加1，递减计数器D减1，当这些计数器与地址控制线路接通时，计数器中的数值就决定该地址控制线路接通的运算寄存器组中哪个单元能接通使用，并且接通的单元序号就等于计数器中的数值，即计数器可作为前述四组运算寄存器的相对地址控制寄存器，计数器还用于控制循环次数，所述寄存器R只有一个单元且能容纳n比特的信息，并且密码机的工作流程分为加密工作流程和解密工作流程这两部分，其中，
密码机加密工作流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数(每个整数为n比特)的数列，并将该数列保存在寄存器组S中，
【2】将明文分组逐组输入寄存器组C中，并且每输入一组明文后做下列运算：
{    /*...第一层循环，明文分组长为2n×n比特，当最后一组明文加密完毕时跳出循环...*/
(1)将递增计数器A作为寄存器组S的相对地址控制寄存器接通，寄存器组S作为寄存器组K的相对地址控制寄存器接通，并将寄存器组K中各单元都设为0，将计数器A设为0，然后，循环执行以下指令：
{                  /*...当a等于2n时，结束本循环，...*/
执行K[S[a]]←K[S[a]]+1的指令
/*...a表示递增计数器A中的数值，S[a]表示寄存器组S中序号为a的单元，K[S[a]]表示寄存器组K中由S[a]接通的单元，即表示寄存器组K中序号等于S[a]中数据的单元，这条指令是将K[S[a]]中数据与1相加，并将结果传送到K[S[a]]，...*/
}
(2)将递减计数器D作为寄存器组K、寄存器组T的相对地址控制寄存器接通，将寄存器R设为0，将递减计数器D设为2n-1，然后，循环执行以下指令：
{             /*...当d等于-1时，结束本循环，...*/
执行T[d]←(K[d]+R)→R的指令
/*...d表示递减计数器D中的数据，K[d]表示寄存器组K中序号为d的单元，T[d]表示寄存器组T中序号为d的单元，这条指令是将K[d]中数据和寄存器R中数据相加，并将运算结果传送给寄存器组T中序号为d的单元，同时还将运算结果传送给寄存器R，这里实现对寄存器组K中整数的累加，本循环结束时，T[0]中的数据应为2n，但由于四组寄存器中各单元的长度都为n比特，因此只能表示2n个数据，又因序号从0开始，所以实际上本循环结束时T[0]中的数据为0，但只要能实现四组寄存器中各单元在单元中的数据为0的情况下作减1运算后，该单元中代码与表示2n-1的代码相同，就不会影响本密码机的实施，...*/
}
(3)将递增计数器A作为寄存器组S和寄存器组K的相对地址控制寄存器接通，将寄存器组S作为寄存器组T的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{         /*...当a等于2n时，结束本循环，...*/
执行K[a]←(T[S[a]]-1)→T[S[a]]的指令
/*...a为递增计数器A中的数据，S[a]、K[a]分别表示寄存器组S、寄存器组K中序号为a的单元，T[S[a]]表示寄存器组T中序号等于S[a]中内容的单元，这条指令表示将T[S[a]]中数据减1，然后将结果传送到K[a]，同时也传送到T[S[a]]，以实现算出序号码，...*/
}
(4)执行R←(K[2n-1]+S[K[2n-2]])％2n的命令
/*...这条指令是将寄存器组S中序号等于K[2n-2]中数据的单元数据与寄存器组K中第2n个单元中的数据相加，然后模2n，并将结果传送到寄存器R中...*/
递减计数器D作为寄存器组C和寄存器组T的相对地址控制寄存器接通，并将计数器D设为2n-1，然后，循环执行以下指令：
{          /*...当d等于-1时，结束本循环，...*/
执行T[d]←(C[d])^(((R*R+R)/2)％(2n))的指令
/*...d为递减计数器D中的数据，T[d]、C[d]分别表示寄存器组T、寄存器组C中序号为d的单元，这条指令表示将寄存器R中数据的平方与寄存器R中数据相加后，以2整除，然后模2n，再与C[d]中数据作异或运算，并将结果传送到T[d]，即对分组信息进行第一次加密...*/
执行R←((C[d]*C[d]+C[d]*3)/2+R)％2n的指令
/*...将寄存器组C中第d+1个单元中的数据乘以3的结果与寄存器组C第d+1个单元中的数据平方相加，接着以2整除，然后与寄存器R中数据相加，再模2n，并将运算结果传送到寄存器R中...*/
}
(5)执行R←(K[1]+S[K[0]])％2n的指令
/*...即将寄存器组K中第2个单元中的数据和寄存器组S中第K[0]+1个单元中的数据相加，并将结果传送到寄存器R，...*/
将递增计数器A作为寄存器组T和寄存器组K的相对地址控制寄存器接通，将寄存器组K作为寄存器组C的相对地址控制寄存器接通，接着将计数器A设为0，然后，循环执行以下指令：
{     /*...当a等于2n时，结束本循环，...*/
执行C[K[a]]←T[a]^(((R*R+R)/2)％(2n))的指令
/*...这条指令表示将寄存器R中数据的平方与寄存器R中数据相加，接着以2整除，然后模2n，再与寄存器组T中第a个单元中数据互异，并将运算结果传送到存器组C的第K[a]+1个单元，即对分组信息进行第二次加密，...*/
执行R←((T[a]*T[a]+T[a]*3)/2+R)％(2n)的指令
/*...这条指令表示将T[a]中数据与3相乘后的积与T[a]中数据的平方相加，接着以2整除，然后加上寄存器R中的数据，再模2n，并将运算结果传送到存器R，为加密下一单元做准备，...*/
}
(6)将递增计数器A作为寄存器组K的相对地址控制寄存器接通，将寄存器组K作为寄存器组S的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行K[a]←S[K[a]]^m的指令
/*...S[K[a]]表示寄存器组S中序号等于K[a]中数据的单元，这条指令表示将S[K[a]]中数据与m作互异运算，并将结果保存在寄存器组K中序号等于a的单元，m为常数，
}
(7)将递增计数器A作为寄存器组K、S这两者的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{      /*...当a等于2n时，结束本循环，...*/
执行S[a]←((K[a]*K[a]+K[a])/2+S[a])％(2n)的指令
/*...这条指令表示将K[a]中整数的平方与K[a]中整数相加，接着以2整除，然后与S[a]中数据相加，再模2n，并将结果传送到寄存器组S中序号为a的单元中，以便后面实施第三次加密，...*/
}
(8)将递增计数器A作为寄存器组C、S这两者的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{     /*...当a等于2n时，结束本循环，...*/
执行C[a]←(C[a]+S[a])％2n的指令
/*...这条指令表示将C[a]和S[a]相加后，再模2n，并将结果传送到寄存器组C中序号为a的单元中，以实现第三次加密，...*/
}
(9)将递增计数器A作为寄存器组K的相对地址控制寄存器接通，寄存器组K作为寄存器组S的相对地址控制寄存器接通，将寄存器组S中各单元都设为0，并将计数器A设为0，然后，循环执行以下指令：
{                 /*...当a等于2n时，结束本循环，...*/
执行S[K[a]]←S[K[a]]+1的指令
/*...a表示递增计数器A中的数值，K[a]表示寄存器组K中序号为a的单元，S[K[a]]表示寄存器组S中由K[a]接通的单元，即表示寄存器组S中序号等于K[a]中数据的单元，这条指令是将S[K[a]]中数据与1相加，并将结果传送到S[K[a]]，...*/
}
(10)将计数器A作为寄存器组S的相对地址控制寄存器接通，将寄存器R设为0，将递增计数器A设为0，然后，循环执行以下指令：
{            /*...当a等于2n时，结束本循环，...*/
执行S[a]←(S[a]+R)→R的指令
/*...这条指令是将S[a]中数据和寄存器R中数据相加，并将运算结果传送给S[a]，同时还将运算结果传送给寄存器R，这里实现对寄存器组S中整数的累加，本循环结束时，S[2n-1]中的数据应为2n，但由于四组寄存器中各单元的长度都为n比特，因此只能表示2n个数据，又因序号从0开始，实际上本循环结束时S[2n-1]中的数据为0，但只要能实现四个寄存器组中各单元在单元中的数据为0的情况下作减1运算后，该单元中代码与表示2n-1的代码相同，就不会影响本密码机的实施，...*/
}
(11)将递增计数器A作为寄存器组K和寄存器组C的相对地址控制寄存器接通，将寄存器组K作为寄存器组S的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{       /*...当a等于2n时，结束本循环，...*/
执行R←S[K[a]]-1→S[K[a]]的指令
/*...这条指令表示将S[K[a]]中数据减1，然后将结果传送到寄存器R，同时也传送到S[K[a]]，以实现将寄存器组K中序号为a单元中数据按照从小到大在排序后新数列中的位置序号算出，...*/
执行Port←(R+C[a])％2n的指令
/*...port，表示输出端口或输出线路，这条指令表示将寄存器R中的数据与C[a]中的数据相加，并模2n，然后输出，这一步功能是利用序号码加密，这是第四次加密，并向外传送，...*/
}
(12)将递增计数器A作为寄存器组K、S、T的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{             /*...当a等于2n时，结束本循环，...*/
执行S[a]←(K[a]+T[a])％2n的指令
/*...这条指令表示将K[a]和T[a]相加后，再模2n，并将结果传送S[a]到中，以实现更新用来产生密钥的参数，为加密下一组明文做准备，...*/
}
}
密码机解密工作流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数(每个整数为n比特)的数列，并将该数列保存在寄存器组S中，
【2】将密文分组逐组输入寄存器组C中，并且每输入一组密文后做下列运算：
{    /*...第一层循环，密文分组长为2n×n比特，当最后一组密文解密完毕时跳出循环...*/
(1)将递增计数器A作为寄存器组S的相对地址控制寄存器接通，寄存器组S作为寄存器组K的相对地址控制寄存器接通，并将寄存器组K中各单元都设为0，将计数器A设为0，然后，循环执行以下指令：
{                   /*...当a等于2n时，结束本循环，...*/
执行K[S[a]]←K[S[a]]+1的指令
/*...a表示递增计数器A中的数值，S[a]表示寄存器组S中序号为a的单元，K[S[a]]表示寄存器组K中由S[a]接通的单元，即表示寄存器组K中序号等于S[a]中数据的单元，这条指令是将K[S[a]]中数据与1相加，并将结果传送到K[S[a]]，...*/
}
(2)将递减计数器D作为寄存器组T、寄存器组K的相对地址控制寄存器接通，将寄存器R设为0，将递减计数器D设为2n-1，然后，循环执行以下指令：
{            /*...当d等于-1时，结束本循环，...*/
执行T[d]←(K[d]+R)→R的指令
/*...d表示递减计数器D中的数据，K[d]表示寄存器组K中序号为d的单元，T[d]表示寄存器组T中序号为d的单元，这条指令是将K[d]中数据和寄存器R中数据相加，并将运算结果传送给寄存器组T中序号为d的单元，同时还将运算结果传送给寄存器R，这里实现对寄存器组K中整数的累加，本循环结束时，T[0]中的数据应为2n，但由于四组寄存器中各单元的长度都为n比特，因此只能表示2n个数据，又因序号从0开始，所以实际上本循环结束时T[0]中的数据为0，但只要能实现四组寄存器中各单元在单元中的数据为0的情况下作减1运算后，该单元中代码与表示2n-1的代码相同，就不会影响本密码机的实施，当d等于-1时，自动结束本循环，往下执行...*/
}
(3)将递增计数器A作为寄存器组S和寄存器组K的相对地址控制寄存器接通，将寄存器组S作为寄存器组T的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{         /*...当a等于2n时，结束本循环，...*/
执行K[a]←(T[S[a]]-1)→T[S[a]]的指令
/*...a为递增计数器A中的数据，S[a]、K[a]分别表示寄存器组S、寄存器组K中序号为a的单元，T[S[a]]表示寄存器组T中序号等于S[a]中内容的单元，这条指令表示将T[S[a]]中数据减1，然后将结果传送到K[a]，同时也传送到T[S[a]]，以实现算出序号码，...*/
}
(4)将递增计数器A作为寄存器组K、T的相对地址控制寄存器接通，将寄存器组K作为寄存器组S的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{          /*...当a等于2n时，结束本循环，...*/
执行T[a]←S[K[a]]^m的指令
/*...S[K[a]]表示寄存器组S中序号等于K[a]中数据的单元，这条指令表示将S[K[a]]中数据与m作互异运算，并将结果保存在寄存器组T中序号等于a的单元，m为常数，...*/
}
(5)将递增计数器A作为寄存器组T、S、C这三者的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{            /*...当a等于2n时，结束本循环往下执行，...*/
执行R←2n-((T[a]*T[a]+T[a])/2+S[a])％(2n)的指令
/*...这条指令表示将T[a]中整数的平方与T[a]中整数相加后，以2整除，接着与S[a]相加，再模2n，然后用2n减去前述模2n之后的结果，并将结果传送寄存器R，...*/
执行C[a]←(R+C[a])％(2n)的指令
/*...这条指令表示将C[a]中数据与R中数据相加，再模2n，并将结果传送C[a]，以实现解除第三次加密，...*/
}
(6)将递增计数器A作为寄存器组T的相对地址控制寄存器接通，寄存器组T作为寄存器组S的相对地址控制寄存器接通，将寄存器组S中各单元都设为0，并将计数器A设为0，然后，循环执行以下指令：
{        /*...当a等于2n时，结束本循环，...*/
执行S[T[a]]←S[T[a]]+1的指令
/*...a表示递增计数器A中的数值，T[a]表示寄存器组T中序号为a的单元，S[T[a]]表示寄存器组S中由T[a]接通的单元，即表示寄存器组S中序号等于T[a]中数据的单元，这条指令是将S[T[a]]中数据与1相加，并将结果传送到S[T[a]]，...*/
}
(7)将计数器A作为寄存器组S的相对地址控制寄存器接通，将寄存器R设为0，将递增计数器A设为0，然后，循环执行以下指令：
{            /*...当a等于2n时，结束本循环，...*/
执行S[a]←(S[a]+R)→R的指令
/*...这条指令是将S[a]中数据和寄存器R中数据相加，并将运算结果传送给S[a]，同时还将运算结果传送给寄存器R，这里实现对寄存器组S中整数的累加，本循环结束时，S[2n-1]中的数据应为2n，但由于四组寄存器中各单元的长度都为n比特，因此只能表示2n个数据，又因序号从0开始，实际上本循环结束时S[2n-1]中的数据为0，但只要能实现四组寄存器中各单元在单元中的数据为0的情况下作减1运算后，该单元中代码与表示2n-1的代码相同，就不会影响本密码机的实施，...*/
}
(8)将递增计数器A作为寄存器组C和寄存器组T的相对地址控制寄存器接通，将寄存器组T作为寄存器组S的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{             /*...当a等于2n时，结束本循环，...*/
执行R←S[T[a]]-1→S[T[a]]的指令
/*...这条指令表示将S[T[a]]中数据减1，然后将结果传送到寄存器R，同时也传送到S[T[a]]，以实现算出序号码，...*/
执行C[a]←(2n-R+C[a])％2n的指令
/*...这条指令表示用2n减去寄存器R中的数据再与C[a]中的数据相加，并模2n，并将结果传送到C[a]，以实现解除第四次加密，...*/
}
(9)执行R←(K[1]+(T[0]^m))％2n的指令
/*...即将寄存器组T中第1个单元中的数据与m作互异运算，将互异结果与寄存器组K中第2个单元中的数据相加，再模2n，并将结果传送到寄存器R，...*/
将递增计数器A作为寄存器组S、寄存器组K的相对地址控制寄存器接通，将寄存器组K作为寄存器组C的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{               /*...当a等于2n时，结束本循环，...*/
执行S[a]←C[K[a]]^(((R*R+R)/2)％(2n))的指令
/*...这条指令表示将寄存器R中数据的平方与寄存器R中数据相加，接着以2整除，然后模2n，再与寄存器组C中第K[a]+1个单元中数据互异，并将运算结果传送到存器组S的第a+1个单元，以实现解除第二次加密，...*/
执行R←((S[a]*S[a]+S[a]*3)/2+R)％(2n)的指令
/*...这条指令表示将S[a]中数据与3相乘后的数据与S[a]中数据的平方相加，接着以2整除，然后加上寄存器R中的数据，再模2n，并将运算结果传送到存器R，为解密下一单元做准备，...*/
}
(10)执行R←(K[2n-1]+(T[2n-2]^m))％2n的指令
/*...即将寄存器组T中第2n-1个单元中的数据与m作互异运算，将互异结果与寄存器组K中第2n个单元中的数据相加，再模2n，并将结果传送到寄存器R，...*/
将递减计数器D作为寄存器组C和寄存器组S的相对地址控制寄存器接通，并将计数器D设为2n-1，然后，循环执行以下指令：
{           /*...当d等于-1时，结束本循环，...*/
执行C[d]←(S[d])^(((R*R+R)/2)％(2n))→Port的指令
/*...d为递减计数器D中的数据，S[d]、C[d]分别表示寄存器组S、寄存器组C中序号为d的单元，这条指令表示将寄存器R中数据的平方与寄存器R中数据相加后，以2整除，然后模2n，再与S[d]中数据作异或运算，以实现解除第一次加密，并将结果传送到C[d]，同时输出明文...*/
执行R←((C[d]*C[d]+C[d]*3)/2+R)％2n的指令
/*...将寄存器组C中第d+1个单元中的数据乘以3的结果与寄存器组C第d+1个单元中的数据平方相加，接着以2整除，然后与寄存器R中数据相加，再模2n，并将运算结果传送到寄存器R中...*/
}
(11)将递增计数器A作为寄存器组S、T的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{             /*...当a等于2n时，结束本循环，...*/
执行S[a]←(S[a]+T[a])％2n的指令
/*...这条指令表示将S[a]和T[a]相加后，再模2n，并将结果传送S[a]到中，以实现更新用来产生密钥的参数，为解密下一组密文做准备，...*/
}
}
可以以多种方法来实现本发明的实施例，本发明不仅可用软件实现也可用硬件实现。当用软件实现时，包括写在计算机可读记录介质上的计算机可读代码。计算机可读记录介质可以是任意类型的记录设备，在其中数据以计算机可读形式存储。计算机可读记录介质包括、但不局限于ROM、RAM、CD-ROM、磁带、软盘、硬盘、移动存储盘、光数据存储、和载波(例如，通过因特网的数据传输)。计算机可读记录介质可以分布在多个连接到网络的计算机系统上，以使得计算机可读代码能够以分布方式写到其上以及从其上执行。另外，实现本发明的实施例所需要的功能程序、代码或代码段可以被本领域的普通技术人员解释。
尽管已经参照本发明的给定优选实施例示出并描述了本发明，但是本领域的技术人员应当理解，在不脱离如所附权利要求所限定的本发明的精神和范围的条件下，可以在这里进行形式和细节上的各种变化。
产业上的可利用性
根据本发明的加密方法可以用于加密各种数字信息和文件，并且生成的密文无有效方法进行破解。

Claims (16)

1.一种加密方法，其加密流程如下：
【1】用预定算法计算数列P的序号码，
【2】以序号码为密钥对明文分组加密，其中，
所述预定算法是指用于排序的方法，并且是下列其中一种：计数排序法、快速排序算法、选择排序算法、冒泡排序算法、堆排序算法、归并排序算法、希尔排序算法、插入排序算法、二叉树排序算法、桶排序算法、基数排序算法，
所述序号码是指按照某种规则对一个数列重新排序得到新数列后，原数列中数据在新数列中的位置序号代码，并且，所述按照某种规则对一个数列重新排序指以下四者之一：①按照从大到小的顺序对一个数列重新排序，②按照从小到大的顺序对一个数列重新排序，③按照从大到小的顺序对一个数列重新排序，然后在此基础上再调整数列中数据的位置，④按照从小到大的顺序对一个数列重新排序，然后在此基础上再调整数列中数据的位置，
所述以序号码为密钥对明文分组加密，是指采用以下算法中一种或多种：根据序号码重新排列明文分组各代码的位置，直接利用序号码与明文分组的数据做异或、同或、加、减、乘、除、取模等运算来加密。
2.一种加密方法，其加密流程如下：
【1】用计数排序法计算数列P的序号码，
【2】以序号码为密钥对明文分组加密，其中，
所述序号码是指按照某种规则对一个数列重新排序得到新数列后，原数列中数据在新数列中的位置序号代码，并且，所述按照某种规则对一个数列重新排序指以下四者之一：①按照从大到小的顺序对一个数列重新排序，②按照从小到大的顺序对一个数列重新排序，③按照从大到小的顺序对一个数列重新排序，然后在此基础上再调整数列中数据的位置，④按照从小到大的顺序对一个数列重新排序，然后在此基础上再调整数列中数据的位置，
所述以序号码为密钥对明文分组加密，是指采用以下算法中一种或多种：根据序号码重新排列明文分组中各代码的位置，直接以序号码为密钥对明文分组的数据做异或、同或、加、减、乘、除、取模等运算来加密，
所述用计数排序法计算数列P的序号码，包括四步：(a)对计数数列清0，(b)用计数数列记录数列P中各种数值的出现次数，(c)对计数数列中的数据累加，(d)利用累加结果和数列P中的数据计算序号码，并且，所述数列P能以下列三种形式之一出现：(1)数列P在步骤(b)之前就已产生，(2)数列P在步骤(b)中产生，并且每产生一个数列P的数据p[i]，就将计数数列中与数据p[i]的值对应的数据加1，(3)数列P在步骤(b)中产生，并且在数列P中数据都产生之后，再用计数数列记录数列P中各种数值的出现次数。
3.一种加密方法，其加密流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数的数列P，设置j＝0
【2】将明文分组逐组输入明文数列T中，并且每输入一组明文后做下列运算：
{/*...第一层循环，当最后一个明文分组加密完毕时跳出循环，明文分组长为2n个单元，每个单元为n个比特，n为正整数...*/
①用计数排序法计算将数列P按照大小关系进行排序的序号码，并将序号码记录到数列K中，
②i＝0
针对整数i做下列循环运算：
{                  /*...第二层循环，i等于2n时跳出循环...*/
 c[j]＝(t[i]+k[i])％(2n)
 i＝i+1
 j＝j+1
 /*...即用序号码对明文数列T加密，其中t[i]表示数列T中第i+1个整数，k[i]表示数列K中第i+1个整数，c[j]表示密文数列C中第j+1个密文，“％”表示mod，...*/
}
③i＝0
针对整数i做下列循环运算：
{                     /*...第二层循环，i等于2n时跳出循环...*/
 p[i]＝(p[i]+(t[i]*t[i]+t[i])/2)％(2n)
/*...即用明文数列T中的数据对数列P更新，其中t[i]，p[i]分别表示数列T、数列P中第i+1个整数，*表示乘，/表示整除，上式应用函数：f(χ)＝((χ2+χ)/2)％(2n)对数列P加密，函数f(χ)在χ和n都为正整数的条件下，具有最佳的离散性能    ...*/
       i＝i+1
   }
}。
4.一种加密方法，其加密流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数的数列P，设置j＝0
【2】将明文分组逐组输入明文数列T中，并且每输入一组明文后做下列运算：
{/*...第一层循环，当最后一个明文分组加密完毕时跳出循环，明文分组长为2n个单元，每个单元为n个比特，n为正整数...*/
①用计数排序法计算将数列P按照大小关系进行排序的序号码，并将序号码记录到数列K中，
②i＝0
针对整数i做下列循环运算：
{                    /*...第二层循环，i等于2n时跳出循环...*/
 s[i]＝t[k[i]]
 i＝i+1
 /*...即用数列K中的序号码重新排列数列T中各整数的位置，并将结果保存在数列S中，其中k[i]分别表示数列K中第i+1个整数，t[k[i]]表示数列T中第k[i]+1个整数，s[i]表示数列S中第i+1个密文，...
 */
 }
③i＝0
针对整数i做下列循环运算：
{                      /*...第二层循环，i等于2n时跳出循环...*/
 c[j]＝(s[i]+k[i])％(2n)
 i＝i+1
 j＝j+1
 /*...即用序号码对数列S继续加密，其中s[i]表示数列S中第i+1个整数，k[i]表示数列K中第i+1个整数，c[j]表示密文数列C中第j+1个密文，“％”表示mod，...*/
 }
④i＝0
针对整数i做下列循环运算：
{                   /*...第二层循环，i等于2n时跳出循环...*/
p[i]＝(p[i]+(t[i]*t[i]+t[i])/2)％(2n)
/*...即用明文数列T中的数据对数列P更新，其中t[i]，p[i]分别表示数列T、数列P中第i+1个整数，*表示乘，/表示整除    ...*/
 i＝i+1
 }
}。
5.一种加密方法，其加密流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数的数列P，并且数列P中每个整数可用n比特表示，设置j＝0，
【2】将明文分组逐组输入明文数列T中，并且每输入一组明文后做下列运算：
{     /*...第一层循环，当最后一个明文分组加密完毕时跳出循环...*/
①用计数排序法计算将数列P按照大小关系进行排序的序号码，并将序号码记录到数列K中，
②i＝0
针对整数i做下列循环运算：
{                   /*...第二层循环，i等于2n时跳出循环...*/
 s[i]＝t[i]^k[i]
 i＝i+1
 /*...即用序号码对明文数列T加密，其中t[i]表示数列T中第i+1个整数，k[i]表示数列K中第i+1个整数，s[i]表示整数数列s中第i+1个密文，“^”表示异或...*/
}
③i＝0
针对整数i做下列循环运算：
{                    /*...第二层循环，i等于2n时跳出循环...*/
q[i]＝p[k[i]]
i＝i+1
/*...依据数列K中记录的序号码，将用数列P中的数据逆向复制到数列Q中，其中q[i]、k[i]分别表示数列Q、数列K中第i+1个整数，p[k[i]]表示数列P中第k[i]+1个整数...*/
}
④用计数排序法计算将数列Q按照大小关系进行排序的序号码，并将序号码记录到数列K中，
⑤i＝0
针对整数i做下列循环运算：
{                    /*...第二层循环，i等于2n时跳出循环...*/
 c[j+i]＝s[k[i]]
 i＝i+1
 /*...即用数列K中的序号码重新排列数列S中各整数的位置，并将结果作为密文输出，其中k[i]分别表示数列K中第i+1个整数，s[k[i]]表示数列s中第k[i]+1个整数，c[j+i]表示密文数列C中第j+i+1个密文，...*/
}
⑥i＝0
针对整数i做下列循环运算：
{                     /*...第二层循环，i等于2n时跳出循环...*/
 p[i]＝(q[i]+(t[i]*t[i]+t[i])/2)％(2n)
 i＝i+1
 /*...即用明文数列T中的数据对数列Q更新，并将更新结果保存在数列P中，其中t[i]、p[i]、q[i]分别表示数列T、数列P、数列Q中第i+1个整数，...*/
 }
⑦j＝j+2n            /*...这里为下一个分组的加密做准备...*/
}。
6.一种加密方法，其加密流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数的数列P，并且数列P中每个整数可用n比特表示，设置j＝0
【2】将明文分组逐组输入明文数列T中，并且每输入一组明文后做下列运算：
{     /*...第一层循环，当最后一个明文分组加密完毕时跳出循环...*/
①用计数排序法计算将数列P按照大小关系排序的序号码，并将序号码记录到数列K中，
②i＝0
针对i进行循环计算：
{                    /*...第二层循环，i等于2n时跳出循环...*/
 s[k[i]]＝t[i]
 /*...s[k[i]]表示数列S中第k[i]+1个整数，这里将明文分组重排位置并将结果保存在数列S中...*/
 i＝i+1
}
③i＝0
针对i进行循环计算：
{                  /*...第二层循环，i等于2n时跳出循环...*/
 q[i]＝p[k[i]]
 i＝i+1
}
④i＝0
针对i进行循环计算：
{                      /*...第二层循环，i等于2n时跳出循环...*/
 r[i]＝((q[i]*q[i]+q[i])/2+p[i])％2n
 i＝i+1
}
⑤用计数排序法计算将数列Q按照大小关系排序的序号码，并将序号码记录到数列K中，
⑥i＝0
针对i进行循环计算：
{                      /*...第二层循环，i等于2n时跳出循环...*/
 c[j]＝(k[i]+r[i]+s[i])％2n    /*...加密...*/
  i＝i+1
  j＝j+1
}
⑦i＝0
针对i进行循环计算：
{                          /*...第二层循环，i等于2n时跳出循环...*/
  p[i]＝(q[i]+t[i])％2n
  /*...用明文数列T对数列Q更新，并将结果保存在数列P中...*/
  i＝i+1
 }
}。
7.一种加密方法，其加密流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数的数列P，并且数列P中每个整数可用n比特表示，
【2】将明文分组逐组输入数列C中，并且每输入一组明文后做下列运算：
{/*...第一层循环，当最后一个明文分组加密完毕时跳出循环...*/
①用计数排序法计算将数列P按照大小关系排序的序号码，并将序号码记录到数列K中，
②R＝g(P)
  /*...这里表示R是数列P中数据作函数g运算后得到的结果...*/
  d＝2n-1
  {    /*...第二层循环，当d等于-1时，结束本循环，...*/
    t[d]＝c[d]^(((R*R+R)/2)％(2n))
    R＝((c[d]*c[d]+c[d]*3)/2+R)％2n
    /*...t[d]、c[d]分别表示数列T、数列C中第d+1个整数...*/
   d＝d-1
  }
③R＝h(P)
  /*...这里表示R是数列P中数据作函数h运算后得到的结果...*/
  a＝0
  {    /*...第二层循环，当a等于2n时，结束本循环，...*/
   c[k[a]]＝t[a]^(((R*R+R)/2)％(2n))
   /*...c[k[a]]表示密文分组数列C中第k[a]+1个整数，k[a]、t[a]分别表示数列K、数列T中第a+1个整数，这里将数列T重排位置并将结果保存在密文分组数列C中...*/
   R＝((t[a]*t[a]+t[a]*3)/2+R)％(2n)
   a＝a+1
  }
④i＝0
针对i进行循环计算：
 {                       /*...第二层循环，i等于2n时跳出循环...*/
   q[i]＝f(p[k[i]])    /*...f(p[k[i]])表示以为p[k[i]]变量，作某种函数运算...*/
   i＝i+1
 }
⑤i＝0
针对i进行循环计算：
{                /*...第二层循环，i等于2n时跳出循环...*/
   r[i]＝((q[i]*q[i]+q[i])/2+p[i])％2n
   i＝i+1
}
⑥用计数排序法计算将数列Q按照大小关系排序的序号码，并将序号码记录到数列K中，
⑦i＝0
针对i进行循环计算：
{                        /*...第二层循环，i等于2n时跳出循环...*/
  c[i]＝(k[i]+r[i]+c[i])％2n    /*...加密...*/
  i＝i+1
}
输出分组密文数列C
⑧i＝0
针对i进行循环计算：
{                    /*...第二层循环，i等于2n时跳出循环...*/
   p[i]＝(q[i]+t[i])％2n
   /*...对数列Q更新，并将结果保存在数列P中...*/
   i＝i+1
 }
}。
8、一种密码机，该密码机的结构工作原理如下：
有一个处理器CPU，该处理器CPU集成有运算寄存器R、递增计数器A、递减计数器D和四组运算寄存器。并且，所述四组运算寄存器分别为：寄存器组S、寄存器组K、寄存器组T、寄存器组C，每个寄存器组都有2n个单元，每个单元为可保存n比特信息，每个寄存器组不仅可寄存数据，还可作为寄存器组中单元的相对地址控制寄存器，处理器CPU通过数据总线接收和输出信息，处理器CPU每执行一个跳转指令递增计数器A加1，递减计数器D减1，当这些计数器与地址控制线路接通时，计数器中的数值就决定该地址控制线路接通的运算寄存器组中哪个单元能接通使用，并且接通的单元序号就等于计数器中的数值，即计数器可作为前述四组运算寄存器的相对地址控制寄存器，计数器还用于控制循环次数，所述寄存器R只有一个单元且能容纳n比特的信息，并且密码机的工作流程分为加密工作流程和解密工作流程这两部分，其中，
密码机加密工作流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数(每个整数为n比特)的数列，并将该数列保存在寄存器组S中，
【2】将明文分组逐组输入寄存器组C中，并且每输入一组明文后做下列运算：
{    /*...第一层循环，明文分组长为2n×n比特，当最后一组明文加密完毕时跳出循环...*/
(1)将递增计数器A作为寄存器组S的相对地址控制寄存器接通，寄存器组S作为寄存器组K的相对地址控制寄存器接通，并将寄存器组K中各单元都设为0，将计数器A设为0，然后，循环执行以下指令：
{    /*....当a等于2n时，结束本循环，...*/
执行K[S[a]]←K[S[a]]+1    的指令
/*...a表示递增计数器A中的数值，S[a]表示寄存器组S中序号为a的单元，K[S[a]]表示寄存器组K中由S[a]接通的单元，即表示寄存器组K中序号等于S[a]中数据的单元，这条指令是将K[S[a]]中数据与1相加，并将结果传送到K[S[a]]，...*/
}
(2)将递减计数器D作为寄存器组K、寄存器组T的相对地址控制寄存器接通，将寄存器R设为0，将递减计数器D设为2n-1，然后，循环执行以下指令：
{    /*...当d等于-1时，结束本循环，...*/
执行    T[d]←(K[d]+R)→R    的指令
/*...d表示递减计数器D中的数据，K[d]表示寄存器组K中序号为d的单元，T[d]表示寄存器组T中序号为d的单元，这条指令是将K[d]中数据和寄存器R中数据相加，并将运算结果传送给寄存器组T中序号为d的单元，同时还将运算结果传送给寄存器R，这里实现对寄存器组K中整数的累加，本循环结束时，T[0]中的数据应为2n，但由于四组寄存器中各单元的长度都为n比特，因此只能表示2n个数据，又因序号从0开始，所以实际上本循环结束时T[0]中的数据为0，但只要能实现四组寄存器中各单元在单元中的数据为0的情况下作减1运算后，该单元中代码与表示2n-1的代码相同，就不会影响本密码机的实施，...*/
}
(3)将递增计数器A作为寄存器组S和寄存器组K的相对地址控制寄存器接通，将寄存器组S作为寄存器组T的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行K[a]←(T[S[a]]-1)→T[S[a]]的指令
/*...a为递增计数器A中的数据，S[a]、K[a]分别表示寄存器组S、寄存器组K中序号为a的单元，T[S[a]]表示寄存器组T中序号等于S[a]中内容的单元，这条指令表示将T[S[a]]中数据减1，然后将结果传送到K[a]，同时也传送到T[S[a]]，以实现算出序号码，...*/
}
(4)执行  R←(K[2n-1]+S[K[2n-2]])％2n  的命令
/*...这条指令是将寄存器组S中序号等于K[2n-2]中数据的单元数据与寄存器组K中第2n个单元中的数据相加，然后模2n，并将结果传送到寄存器R中...*/
递减计数器D作为寄存器组C和寄存器组T的相对地址控制寄存器接通，并将计数器D设为2n-1，然后，循环执行以下指令：
{    /*...当d等于-1时，结束本循环，...*/
执行  T[d]←(C[d])^(((R*R+R)/2)％(2n))  的指令
/*...d为递减计数器D中的数据，T[d]、C[d]分别表示寄存器组T、寄存器组C中序号为d的单元，这条指令表示将寄存器R中数据的平方与寄存器R中数据相加后，以2整除，然后模2n，再与C[d]中数据作异或运算，并将结果传送到T[d]，即对分组信息进行第一次加密...*/
执行  R←((C[d]*C[d]+C[d]*3)/2+R)％2n  的指令
/*...将寄存器组C中第d+1个单元中的数据乘以3的结果与寄存器组C第d+1个单元中的数据平方相加，接着以2整除，然后与寄存器R中数据相加，再模2n，并将运算结果传送到寄存器R中...*/
}
(5)执行  R←(K[1]+S[K[0]])％2n  的指令
/*...即将寄存器组K中第2个单元中的数据和寄存器组S中第K[0]+1个单元中的数据相加，并将结果传送到寄存器R，...*/
将递增计数器A作为寄存器组T和寄存器组K的相对地址控制寄存器接通，将寄存器组K作为寄存器组C的相对地址控制寄存器接通，接着将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行C[K[a]]←T[a]^(((R*R+R)/2)％(2n))  的指令
/*...这条指令表示将寄存器R中数据的平方与寄存器R中数据相加，接着以2整除，然后模2n，再与寄存器组T中第a个单元中数据互异，并将运算结果传送到存器组C的第K[a]+1个单元，即对分组信息进行第二次加密，...*/
执行R←((T[a]*T[a]+T[a]*3)/2+R)％(2n)  的指令
/*...这条指令表示将T[a]中数据与3相乘后的积与T[a]中数据的平方相加，接着以2整除，然后加上寄存器R中的数据，再模2n，并将运算结果传送到存器R，为加密下一单元做准备，...*/
}
(6)将递增计数器A作为寄存器组K的相对地址控制寄存器接通，将寄存器组K作为寄存器组S的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行K[a]←S[K[a]]^m    的指令
/*...S[K[a]]表示寄存器组S中序号等于K[a]中数据的单元，这条指令表示将S[K[a]]中数据与m作互异运算，并将结果保存在寄存器组K中序号等于a的单元，m为常数，
}
(7)将递增计数器A作为寄存器组K、S这两者的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行S[a]←((K[a]*K[a]+K[a])/2+S[a])％(2n)  的指令
/*...这条指令表示将K[a]中整数的平方与K[a]中整数相加，接着以2整除，然后与S[a]中数据相加，再模2n，并将结果传送到寄存器组S中序号为a的单元中，以便后面实施第三次加密，...*/
}
(8)将递增计数器A作为寄存器组C、S这两者的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行C[a]←(C[a]+S[a])％2n  的指令
/*...这条指令表示将C[a]和S[a]相加后，再模2n，并将结果传送到寄存器组C中序号为a的单元中，以实现第三次加密，...*/
}
(9)将递增计数器A作为寄存器组K的相对地址控制寄存器接通，寄存器组K作为寄存器组S的相对地址控制寄存器接通，将寄存器组S中各单元都设为0，并将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行S[K[a]]←S[K[a]]+1  的指令
/*...a表示递增计数器A中的数值，K[a]表示寄存器组K中序号为a的单元，S[K[a]]表示寄存器组S中由K[a]接通的单元，即表示寄存器组S中序号等于K[a]中数据的单元，这条指令是将S[K[a]]中数据与1相加，并将结果传送到S[K[a]]，...*/
}
(10)将计数器A作为寄存器组S的相对地址控制寄存器接通，将寄存器R设为0，将递增计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行S[a]←(S[a]+R)→R  的指令
/*...这条指令是将S[a]中数据和寄存器R中数据相加，并将运算结果传送给S[a]，同时还将运算结果传送给寄存器R，这里实现对寄存器组S中整数的累加，本循环结束时，S[2n-1]中的数据应为2n，但由于四组寄存器中各单元的长度都为n比特，因此只能表示2n个数据，又因序号从0开始，实际上本循环结束时S[2n-1]中的数据为0，但只要能实现四个寄存器组中各单元在单元中的数据为0的情况下作减1运算后，该单元中代码与表示2n-1的代码相同，就不会影响本密码机的实施，...*/
}
(11)将递增计数器A作为寄存器组K和寄存器组C的相对地址控制寄存器接通，将寄存器组K作为寄存器组S的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行  R←S[K[a]]-1→S[K[a]]  的指令
/*...这条指令表示将S[K[a]]中数据减1，然后将结果传送到寄存器R，同时也传送到S[K[a]]，以实现将寄存器组K中序号为a单元中数据按照从小到大在排序后新数列中的位置序号算出，...*/
执行  Port←(R+C[a])％2n  的指令
/*...port，表示输出端口或输出线路，这条指令表示将寄存器R中的数据与C[a]中的数据相加，并模2n，然后输出，这一步功能是利用序号码加密，这是第四次加密，并向外传送，...*/
}
(12)将递增计数器A作为寄存器组K、S、T的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行S[a]←(K[a]+T[a])％2n  的指令
/*...这条指令表示将K[a]和T[a]相加后，再模2n，并将结果传送S[a]到中，以实现更新用来产生密钥的参数，为加密下一组明文做准备，...
    */
  }
}
密码机解密工作流程如下：
【1】初始化：输入初始密钥Key，并利用初始密钥Key产生一个具有2n个整数(每个整数为n比特)的数列，并将该数列保存在寄存器组S中，
【2】将密文分组逐组输入寄存器组C中，并且每输入一组密文后做下列运算：
{    /*...第一层循环，密文分组长为2n×n比特，当最后一组密文解密完毕时跳出循环...*/
(1)将递增计数器A作为寄存器组S的相对地址控制寄存器接通，寄存器组S作为寄存器组K的相对地址控制寄存器接通，并将寄存器组K中各单元都设为0，将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行  K[S[a]]←K[S[a]]+1  的指令
/*...a表示递增计数器A中的数值，S[a]表示寄存器组S中序号为a的单元，K[S[a]]表示寄存器组K中由S[a]接通的单元，即表示寄存器组K中序号等于S[a]中数据的单元，这条指令是将K[S[a]]中数据与1相加，并将结果传送到K[S[a]]，...*/
}
(2)将递减计数器D作为寄存器组T、寄存器组K的相对地址控制寄存器接通，将寄存器R设为0，将递减计数器D设为2n-1，然后，循环执行以下指令：
{    /*...当d等于-1时，结束本循环，...*/
执行  T[d]←(K[d]+R)→R  的指令
/*...d表示递减计数器D中的数据，K[d]表示寄存器组K中序号为d的单元，T[d]表示寄存器组T中序号为d的单元，这条指令是将K[d]中数据和寄存器R中数据相加，并将运算结果传送给寄存器组T中序号为d的单元，同时还将运算结果传送给寄存器R，这里实现对寄存器组K中整数的累加，本循环结束时，T[0]中的数据应为2n，但由于四组寄存器中各单元的长度都为n比特，因此只能表示2n个数据，又因序号从0开始，所以实际上本循环结束时T[0]中的数据为0，但只要能实现四组寄存器中各单元在单元中的数据为0的情况下作减1运算后，该单元中代码与表示2n-1的代码相同，就不会影响本密码机的实施，当d等于-1时，自动结束本循环，往下执行...*/
}
(3)将递增计数器A作为寄存器组S和寄存器组K的相对地址控制寄存器接通，将寄存器组S作为寄存器组T的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行K[a]←(T[S[a]]-1)→T[S[a]]的指令
/*...a为递增计数器A中的数据，S[a]、K[a]分别表示寄存器组S、寄存器组K中序号为a的单元，T[S[a]]表示寄存器组T中序号等于S[a]中内容的单元，这条指令表示将T[S[a]]中数据减1，然后将结果传送到K[a]，同时也传送到T[S[a]]，以实现算出序号码，...*/
}
(4)将递增计数器A作为寄存器组K、T的相对地址控制寄存器接通，将寄存器组K作为寄存器组S的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行T[a]←S[K[a]]^m    的指令
/*...S[K[a]]表示寄存器组S中序号等于K[a]中数据的单元，这条指令表示将S[K[a]]中数据与m作互异运算，并将结果保存在寄存器组T中序号等于a的单元，m为常数，...*/
}
(5)将递增计数器A作为寄存器组T、S、C这三者的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{              /*...当a等于2n时，结束本循环往下执行，...*/
执行    R←2n-((T[a]*T[a]+T[a])/2+S[a])％(2n)    的指令
/*...这条指令表示将T[a]中整数的平方与T[a]中整数相加后，以2整除，接着与S[a]相加，再模2n，然后用2n减去前述模2n之后的结果，并将结果传送寄存器R，...*/
执行    C[a]←(R+C[a])％(2n)    的指令
/*...这条指令表示将C[a]中数据与R中数据相加，再模2n，并将结果传送C[a]，以实现解除第三次加密，...*/
}
(6)将递增计数器A作为寄存器组T的相对地址控制寄存器接通，寄存器组T作为寄存器组S的相对地址控制寄存器接通，将寄存器组S中各单元都设为0，并将计数器A设为0，然后，循环执行以下指令：
{           /*...当a等于2n时，结束本循环，...*/
执行    S[T[a]]←S[T[a]]+1    的指令
/*...a表示递增计数器A中的数值，T[a]表示寄存器组T中序号为a的单元，S[T[a]]表示寄存器组S中由T[a]接通的单元，即表示寄存器组S中序号等于T[a]中数据的单元，这条指令是将S[T[a]]中数据与1相加，并将结果传送到S[T[a]]，...*/
}
(7)将计数器A作为寄存器组S的相对地址控制寄存器接通，将寄存器R设为0，将递增计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行S[a]←(S[a]+R)→R的指令
/*...这条指令是将S[a]中数据和寄存器R中数据相加，并将运算结果传送给S[a]，同时还将运算结果传送给寄存器R，这里实现对寄存器组S中整数的累加，本循环结束时，S[2n-1]中的数据应为2n，但由于四组寄存器中各单元的长度都为n比特，因此只能表示2n个数据，又因序号从0开始，实际上本循环结束时S[2n-1]中的数据为0，但只要能实现四组寄存器中各单元在单元中的数据为0的情况下作减1运算后，该单元中代码与表示2n-1的代码相同，就不会影响本密码机的实施，...*/
}
(8)将递增计数器A作为寄存器组C和寄存器组T的相对地址控制寄存器接通，将寄存器组T作为寄存器组S的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{              /*...当a等于2n时，结束本循环，...*/
执行    R←S[T[a]]-1→S[T[a]]    的指令
/*...这条指令表示将S[T[a]]中数据减1，然后将结果传送到寄存器R，同时也传送到S[T[a]]，以实现算出序号码，...*/
执行    C[a]←(2n-R+C[a])％2n    的指令
/*...这条指令表示用2n减去寄存器R中的数据再与C[a]中的数据相加，并模2n，并将结果传送到C[a]，以实现解除第四次加密，...*/
}
(9)执行    R←  (K[1]+(T[0]^m))％2n    的指令
/*...即将寄存器组T中第1个单元中的数据与m作互异运算，将互异结果与寄存器组K中第2个单元中的数据相加，再模2n，并将结果传送到寄存器R，...*/
将递增计数器A作为寄存器组S、寄存器组K的相对地址控制寄存器接通，将寄存器组K作为寄存器组C的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{                    /*...当a等于2n时，结束本循环，...*/
执行    S[a]←C[K[a]]^(((R*R+R)/2)％(2n))    的指令
/*...这条指令表示将寄存器R中数据的平方与寄存器R中数据相加，接着以2整除，然后模2n，再与寄存器组C中第K[a]+1个单元中数据互异，并将运算结果传送到存器组S的第a+1个单元，以实现解除第二次加密，...*/
执行R←((S[a]*S[a]+S[a]*3)/2+R)％(2n)    的指令
/*...这条指令表示将S[a]中数据与3相乘后的数据与S[a]中数据的平方相加，接着以2整除，然后加上寄存器R中的数据，再模2n，并将运算结果传送到存器R，为解密下一单元做准备，...*/
}
(10)执行  R←(K[2n-1]+(T[2n-2]^m))％2n    的指令
/*...即将寄存器组T中第2n-1个单元中的数据与m作互异运算，将互异结果与寄存器组K中第2n个单元中的数据相加，再模2n，并将结果传送到寄存器R，...*/
将递减计数器D作为寄存器组C和寄存器组S的相对地址控制寄存器接通，并将计数器D设为2n-1，然后，循环执行以下指令：
{             /*...当d等于-1时，结束本循环，...*/
执行      C[d]←(S[d])^(((R*R+R)/2)％(2n))→Port    的指令
/*...d为递减计数器D中的数据，S[d]、C[d]分别表示寄存器组S、寄存器组C中序号为d的单元，这条指令表示将寄存器R中数据的平方与寄存器R中数据相加后，以2整除，然后模2n，再与S[d]中数据作异或运算，以实现解除第一次加密，并将结果传送到C[d]，同时输出明文...*/
执行    R←((C[d]*C[d]+C[d]*3)/2+R)％2n    的指令
/*...将寄存器组C中第d+1个单元中的数据乘以3的结果与寄存器组C第d+1个单元中的数据平方相加，接着以2整除，然后与寄存器R中数据相加，再模2n，并将运算结果传送到寄存器R中...*/
}
(11)将递增计数器A作为寄存器组S、T的相对地址控制寄存器接通，并将计数器A设为0，然后，循环执行以下指令：
{    /*...当a等于2n时，结束本循环，...*/
执行    S[a]←(S[a]+T[a])％2n    的指令
/*...这条指令表示将S[a]和T[a]相加后，再模2n，并将结果传送S[a]到中，以实现更新用来产生密钥的参数，为解密下一组密文做准备，...
     */
   }
}。
9.根据权利要求2所述加密方法，其特征是：其中，步骤【1】采用以下八种方法之一：
第一种计数排序法计算序号码的方法如下：
①i＝0               /*...给i赋初始值...*/
针对i循环执行以下指令：       /*...执行2n遍...*/
{
 r[i]＝0
 /*...将数列R清0，r[i]表示数列R中第i+1个整数...*/
 i＝i+1
}
②i＝0                  /*...给i赋初始值...*/
针对i循环执行以下指令：            /*...执行2n遍...*/
{
 r[p[i]]＝r[p[i]]+1
 /*...计数，p[i]表示数列P中第i+1个整数，r[p[i]]表示数列R中第p[i]+1个整数...*/
 i＝i+1
}
③i＝1                        /*...给i赋初始值...*/
针对i循环执行以下指令：                /*...执行2n-1遍...*/
 {
 r[i]＝r[i]+r[i-1]    /*...累加...*/
 i＝i+1
 }
④i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：           /*...执行2n遍...*/
{
 r[p[i]]＝r[p[i]]-1
 k[i]＝r[p[i]]
/*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数，当然前面两条指令也可修改为：k[i]＝r[p[i]]-1    r[p[i]]＝k[i]  ...*/
 i＝i+1
}
第二种计数排序法计算序号码的方法如下：
①i＝0            /*...给i赋初始值...*/
针对i循环执行以下指令：    /*...执行2n遍...*/
{
 r[i]＝0
 /*...将数列R清0，r[i]表示数列R中第i+1个整数...*/
 i＝i+1
}
②i＝0                 /*...给i赋初始值...*/
针对i循环执行以下指令：          /*...执行2n遍...*/
{
 r[p[i]]＝r[p[i]]+1
 /*...计数，p[i]表示数列P中第i+1个整数，r[p[i]]表示数列R中第p[i]+1个整数...*/
 i＝i+1
}
③i＝1    a＝r[0]    r[0]＝0    /*...赋初始值...*/
针对i循环执行以下指令：       /*...执行2n-1遍...*/
{
 b＝r[i]
 r[i]＝a+r[i-1]    /*...累加...*/
 i＝i+1    a＝b
}
④i＝0                       /*...给i赋初始值...*/
针对i循环执行以下指令：         /*...执行2n遍...*/
{
 k[i]＝r[p[i]]
 r[p[i]]＝r[p[i]]+1
/*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数...*/
 i＝i+1
}
第三种计数排序法计算序号码的方法如下：
①i＝0                       /*...给i赋初始值...*/
针对i循环执行以下指令：         /*...执行2n遍...*/
{
 r[i]＝0
 /*...将数列R清0，r[i]表示数列R中第i+1个整数...*/
 i＝i+1
}
②i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：    /*...执行2n遍...*/
{
 r[p[i]]＝r[p[i]]+1
 /*...计数，p[i]表示数列P中第i+1个整数，r[p[i]]表示数列R中第p[i]+1个整数...*/
 i＝i+1
}
③i＝2n-2                /*...给i赋初始值...*/
针对i循环执行以下指令：     /*...执行2n-1遍...*/
{
 r[i]＝r[i]+r[i+1]    /*...累加...*/
 i＝i-1
}
④i＝0                      /*...给i赋初始值...*/
针对i循环执行以下指令：        /*...执行2n遍...*/
{
 r[p[i]]＝r[p[i]]-1
 k[i]＝r[p[i]]
/*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数，当然前面两条指令也可修改为：k[i]＝r[p[i]]-1    r[p[i]]＝k[i]  ...*/
 i＝i+1
}
第四种计数排序法计算序号码的方法如下：
①i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：                   /*...执行2n遍...*/
{
 r[i]＝0
 /*...将数列R清0，r[i]表示数列R中第i+1个整数...*/
 i＝i+1
}
②i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：         /*...执行2n遍...*/
{
 r[p[i]]＝r[p[i]]+1
 /*...计数，p[i]表示数列P中第i+1个整数，r[p[i]]表示数列R中第p[i]+1个整数...*/
 i＝i+1
}
③i＝2n-2    a＝r[2n-1]  r[2n-1]＝0          /*...赋初始值...*/
针对i循环执行以下指令：                 /*...执行2n-1遍...*/
{
 b＝r[i]
 r[i]＝a+r[i+1]           /*...累加...*/
 i＝i-1    a＝b
}
④i＝0                    /*...给i赋初始值...*/
针对i循环执行以下指令：              /*...执行2n遍...*/
{
 k[i]＝r[p[i]]
 r[p[i]]＝r[p[i]]+1
 /*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数...*/
 i＝i+1
}
第五种计数排序法计算序号码的方法如下：
①i＝0                       /*...给i赋初始值...*/
针对i循环执行以下指令：                   /*...执行2n遍...*/
{
 k[i]＝0
 /*...将数列K清0，k[i]表示数列K中第i+1个整数...*/
 i＝i+1
}
②i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：            /*...执行2n遍...*/
{
 k[p[i]]＝k[p[i]]+1
 /*...计数，p[i]表示数列P中第i+1个整数，k[p[i]]表示数列K中第p[i]+1个整数...*/
 i＝i+1
}
③i＝1  r[0]＝k[0]                 /*...给i赋初始值...*/
针对i循环执行以下指令：            /*...执行2n-1遍...*/
{
 r[i]＝k[i]+r[i-1]    /*...累加...*/
 i＝i+1
}
④i＝0                  /*...给i赋初始值...*/
针对i循环执行以下指令：         /*...执行2n遍...*/
{
 r[p[i]]＝r[p[i]]-1
 k[i]＝r[p[i]]
 /*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数...*/
 i＝i+1
}
第六种计数排序法计算序号码的方法如下：
①i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：              /*...执行2n遍...*/
{
k[i]＝0
 /*...将数列K清0，k[i]表示数列K中第i+1个整数...*/
 i＝i+1
}
②i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：            /*...执行2n遍...*/
{
 k[p[i]]＝k[p[i]]+1
/*...计数，p[i]表示数列P中第i+1个整数，k[p[i]]表示数列K中第p[i]+1个整数...*/
 i＝i+1
}
③i＝1    r[0]＝0            /*...赋初始值...*/
针对i循环执行以下指令：           /*...执行2n-1遍...*/
{
 r[i]＝k[i-1]+r[i-1]        /*...累加...*/
 i＝i+1
}
④i＝0                     /*...给i赋初始值...*/
针对i循环执行以下指令：    /*...执行2n遍...*/
{
 k[i]＝r[p[i]]
 r[p[i]]＝r[p[i]]+1
/*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数...*/
 i＝i+1
}
第七种计数排序法计算序号码的方法如下：
①i＝0                  /*...给i赋初始值...*/
针对i循环执行以下指令：             /*...执行2n遍...*/
{
k[i]＝0
 /*...将数列K清0，k[i]表示数列K中第i+1个整数...*/
 i＝i+1
}
②i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：            /*...执行2n遍...*/
{
 k[p[i]]＝k[p[i]]+1
 /*...计数，p[i]表示数列P中第i+1个整数，k[p[i]]表示数列K中第p[i]+1个整数...*/
 i＝i+1
}
③i＝2n-2    r[2n-1]＝k[2n-1]         /*...给i赋初始值...*/
针对i循环执行以下指令：         /*...执行2n-1遍...*/
{
 r[i]＝k[i]+r[i+1]           /*...累加...*/
 i＝i-1
}
④i＝0                      /*...给i赋初始值...*/
针对i循环执行以下指令：        /*...执行2n遍...*/
{
 r[p[i]]＝r[p[i]]-1
 k[i]＝r[p[i]]
 /*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数...
*/
 i＝i+1
}
第八种计数排序法计算序号码的方法如下：
①i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：               /*...执行2n遍...*/
{
 k[i]＝0
 /*...将数列K清0，k[i]表示数列K中第i+1个整数...*/
 i＝i+1
}
②i＝0                 /*...给i赋初始值...*/
针对i循环执行以下指令：       /*...执行2n遍...*/
{
 k[p[i]]＝k[p[i]]+1
 /*...计数，p[i]表示数列P中第i+1个整数，k[p[i]]表示数列K中第p[i]+1个整数...*/
 i＝i+1
}
③i＝2n-2    r[2n-1]＝0      /*...赋初始值...*/
针对i循环执行以下指令：             /*...执行2n-1遍...*/
{
r[i]＝k[i+1]+r[i+1]         /*...累加...*/
i＝i-1
}
④i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：           /*...执行2n遍...*/
{
 k[i]＝r[p[i]]
 r[p[i]]＝r[p[i]]+1
 /*...在数列K中，记录序号码，k[i]表示数列K中第i+1个整数...
*/
 i＝i+1
}。
10.根据权利要求9所述加密方法，其特征是：其中，步骤②被修改为：
②i＝0                   /*...给i赋初始值...*/
针对i循环执行以下指令：          /*...执行2n遍...*/
{
 p[i]＝f(...)    /*...f(...)用来表示产生数列P的程序段...*/
 r[p[i]]＝r[p[i]]+1
 /*...计数，p[i]表示数列P中第i+1个整数，r[p[i]]表示数列R中第p[i]+1个整数...*/
 i＝i+1
}。
11.根据权利要求9所述加密方法，其特征是：其中，步骤②被修改为：
②
 i＝0                      /*...给i赋初始值...*/
 针对i循环执行以下指令：              /*...执行2n遍...*/
{
 p[i]＝f(...)    /*...f(...)用来表示产生数列P的程序段...*/
 i＝i+1
}
 i＝0                        /*...给i赋初始值...*/
针对i循环执行以下指令：               /*...执行2n遍...*/
{
 r[p[i]]＝r[p[i]]+1
 /*...计数，p[i]表示数列P中第i+1个整数，r[p[i]]表示数列R中第p[i]+1个整数...*/
i＝i+1
}。
12.根据权利要求9、或9和10、或9和11所述加密方法，其特征是：其中，“k[i]＝r[p[i]]”被修改为：“k[(i+u)％(2n)]＝(r[p[i]]+w)％(2n)”
13.根据权利要求9、或9和10、或9和11所述加密方法，其特征是：其中，“k[i]＝r[p[i]]”被修改为：“k[(i+u)％(2n)]＝((r[p[i]]*r[p[i]]+r[p[i]]+v)/2+w)％(2n)”。
14.根据权利要求9、或9和10、或9和11所述加密方法，其特征是：其中，“k[i]＝r[p[i]]”被修改为：“k[(i+u)％(2n)]＝f(r[p[i]])”。
15.根据权利要求9、或9和10、或9和11、或12、或13、或14所述加密方法，其特征是：其中，“r[p[i]]”被修改为：“r[(p[i]+z)％(2n)]”。
16.根据权利要求9、或9和10、或9和11、或12、或13、或14、或15所述加密方法，其特征是：其中，“k[p[i]]”被修改为：“k[(p[i]+z)％(2n)]”。
CNA2009101474540A 2009-06-09 2009-06-09 利用排序产生的序号码加密的方法及密码机 Pending CN101567781A (zh)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CNA2009101474540A CN101567781A (zh) 2009-06-09 2009-06-09 利用排序产生的序号码加密的方法及密码机

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CNA2009101474540A CN101567781A (zh) 2009-06-09 2009-06-09 利用排序产生的序号码加密的方法及密码机

Publications (1)

Publication Number Publication Date
CN101567781A true CN101567781A (zh) 2009-10-28

Family

ID=41283751

Family Applications (1)

Application Number Title Priority Date Filing Date
CNA2009101474540A Pending CN101567781A (zh) 2009-06-09 2009-06-09 利用排序产生的序号码加密的方法及密码机

Country Status (1)

Country Link
CN (1) CN101567781A (zh)

Cited By (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN102347835A (zh) * 2010-07-30 2012-02-08 索尼公司 更新私钥的方法及设备、获得会话密钥的方法和通信设备
CN103199998A (zh) * 2013-04-17 2013-07-10 天津大学 五种数字信息的无逻辑硬加密方法组合
CN103312709A (zh) * 2013-03-16 2013-09-18 方秀琴 一种登陆加密方法
US9171032B2 (en) 2012-12-29 2015-10-27 International Business Machines Corporation Radix sort with read-only key
CN106549752A (zh) * 2016-10-10 2017-03-29 佛山职业技术学院 一种用于电子标签的数据信息加密方法
CN109412609A (zh) * 2018-12-20 2019-03-01 中国地质大学（武汉） 一种极化码译码中路径分裂的硬件排序器系统及设计方法
CN112685761A (zh) * 2021-01-08 2021-04-20 浙江省国土勘测规划有限公司 一种用于农房测绘一体化的软件系统

Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN201156248Y (zh) * 2008-02-03 2008-11-26 深圳艾科创新微电子有限公司 一种计算多数据排序序号的硬件结构
US20090034741A1 (en) * 2007-07-31 2009-02-05 Sabev Anton I Asymmetric key wrapping using a symmetric cipher
CN101378314A (zh) * 2008-09-26 2009-03-04 北京数字太和科技有限责任公司 一种密钥序列的生成方法和密钥产生装置
CN101496342A (zh) * 2006-07-21 2009-07-29 日本电气株式会社 加密装置、程序及方法

Patent Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101496342A (zh) * 2006-07-21 2009-07-29 日本电气株式会社 加密装置、程序及方法
US20090034741A1 (en) * 2007-07-31 2009-02-05 Sabev Anton I Asymmetric key wrapping using a symmetric cipher
CN201156248Y (zh) * 2008-02-03 2008-11-26 深圳艾科创新微电子有限公司 一种计算多数据排序序号的硬件结构
CN101378314A (zh) * 2008-09-26 2009-03-04 北京数字太和科技有限责任公司 一种密钥序列的生成方法和密钥产生装置

Cited By (10)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN102347835A (zh) * 2010-07-30 2012-02-08 索尼公司 更新私钥的方法及设备、获得会话密钥的方法和通信设备
US9171032B2 (en) 2012-12-29 2015-10-27 International Business Machines Corporation Radix sort with read-only key
US9177006B2 (en) 2012-12-29 2015-11-03 International Business Machines Corporation Radix sort with read-only key
CN103312709A (zh) * 2013-03-16 2013-09-18 方秀琴 一种登陆加密方法
CN103312709B (zh) * 2013-03-16 2016-04-13 郑州航空工业管理学院 一种登陆加密方法
CN103199998A (zh) * 2013-04-17 2013-07-10 天津大学 五种数字信息的无逻辑硬加密方法组合
CN106549752A (zh) * 2016-10-10 2017-03-29 佛山职业技术学院 一种用于电子标签的数据信息加密方法
CN109412609A (zh) * 2018-12-20 2019-03-01 中国地质大学（武汉） 一种极化码译码中路径分裂的硬件排序器系统及设计方法
CN109412609B (zh) * 2018-12-20 2020-10-30 中国地质大学（武汉） 一种极化码译码中路径分裂的硬件排序器系统及设计方法
CN112685761A (zh) * 2021-01-08 2021-04-20 浙江省国土勘测规划有限公司 一种用于农房测绘一体化的软件系统

Similar Documents

Publication Publication Date Title
CN101567781A (zh) 利用排序产生的序号码加密的方法及密码机
CA2723405C (en) Cryptographic system including a random number generator using finite field arithmetics
CN112865954B (zh) 用于Paillier解密的加速器、芯片及系统
JP6880017B2 (ja) 信頼できないコンピュータ上でプライベートプログラムを実行するためのシステム及びプロセス
CN104298937B (zh) 用于存储器地址加密的装置和方法
CN108702286A (zh) 抗功率侧信道攻击的高级加密标准加速器处理器
CN106850221A (zh) 信息加密、解密方法及装置
US20070198824A1 (en) Cryptography system and elliptic curve operation method
US20130279692A1 (en) Protecting modular exponentiation in cryptographic operations
US20150195089A1 (en) Data scramble device, security device, security system, and data scramble method
CN110661618B (zh) 数据传输方法、装置和电子设备
KR20070008012A (ko) 멱지수를 숨기는 ｄｐａ 대책의 고속 계산을 위한 암호화장치 및 방법
CN112070222A (zh) 用于联邦学习的处理架构、加速器及方法
JP6552184B2 (ja) 情報処理装置およびその方法
CN114491613B (zh) 高效可搜索的代理隐私集合求交方法及装置
CN102306262A (zh) 数据加密方法及数据加密系统
WO2021129470A1 (zh) 基于多项式完全同态的二进制数据加密系统及方法
CN102122241A (zh) 一种适用于素域和多项式域的模乘模除器
CN113904808A (zh) 一种私钥分发、解密方法、装置、设备及介质
EP3127271B1 (en) Obfuscated performance of a predetermined function
KR20020063793A (ko) 몽고메리의 알고리즘을 이용한 멱승 잉여 연산기
Hossain et al. Efficient fpga implementation of modular arithmetic for elliptic curve cryptography
JP6844897B2 (ja) ビット分解秘密計算装置、ビット結合秘密計算装置、方法およびプログラム
CN104572012A (zh) 一种基于aop的多项式基gf(2227)高速模乘法器
CN110034918A (zh) 一种sm4加速方法和装置

Legal Events

Date Code Title Description
C06 Publication
PB01 Publication
C10 Entry into substantive examination
SE01 Entry into force of request for substantive examination
C02 Deemed withdrawal of patent application after publication (patent law 2001)
WD01 Invention patent application deemed withdrawn after publication

Application publication date: 20091028