密码学课设报告

目录

一．实验目的 (1)

二．实验内容及基本要求 (1)

2.1、分组密码SPN的编程实现 (1)

2.2、RSA的加/解密及快速加/解密 (1)

2.3、随机性检测 (1)

三．实验原理 (1)

3.1、分组密码SPN (1)

3.2、RSA的加/解密及快速加/解密 (6)

3.3、随机性检测 (6)

四．实验过程 (7)

5.1、分组密码SPN (7)

5.1.1 SPN加密 (7)

5.1.2 线性密码分析 (10)

5.1.3 差分密码分析 (12)

5.2、RSA的加/解密及快速加/解密 (15)

5.1.1 生成大素数 (15)

5.1.2 运用模重复平方的RSA加/解密 (18)

5.1.3 运用蒙哥马利的RSA快速加解密 (20)

5.1.4 运用中国剩余定理的RSA解密 (23)

5.3、随机性检测 (25)

五．实验结果 (25)

6.1、分组密码SPN (25)

6.2、RSA的加/解密及快速加/解密 (28)

6.3、随机性检测 (31)

六．实验心得总结 (33)

一．实验目的

通过课程设计，使学生进一步熟悉密码算法以及算法安全性的基本概念和原理；培养学生将密码理论和技术应用于实际的能力，使学生具备实施数据加/脱密和基本的密码分析的能力。

二．实验内容及基本要求

2.1、分组密码SPN的编程实现

①加密：输入初始加密密钥和一串有意义的字符串，显示相应的加密结果；

②线性分析：通过对明密文对的线性分析，破解出初始加密密钥；

③差分分析：通过对明密文对的差分分析，破解出初始加密密钥；

④设计用户界面，界面要有加密选择，线性与差分分析选择，输入密钥与明文栏以及密文显示栏；

2.2、RSA的加/解密及快速加/解密

①编制或网上下载大素数生成算法，产生二个大素数p和q；

②编写RSA的加/解密过程和快速加/解密过程；

③通过调用时钟对二种加/解密方法的时间开销进行测试；

④设计用户界面，界面要有加/解密方式选择，快速方式与一般方式的选择及时间开销显示。

2.3、随机性检测

密文的随机性反映了密码的强度，通过设计随机性测试算法或运用工具对SPN生成的密文进行随机性检测，来测试SPN的密码强度。

三．实验原理

3.1、分组密码SPN

（1）迭代密码

迭代密码的核心是一个密钥编排方案和一个轮函数

密钥编排方案对密钥k进行变换，生成Nr个子密钥(也叫轮密钥)，记为k1,k2,...,kNr

轮函数g是一个状态加密函数，以ki为密钥对当前状态w r-1进行变换，输出新的状态值w r，即g(w r-1,k i)=w r；轮函数是单射函数，存在一个逆变换g-1，有g-1(w r,k i)=w r-1

迭代密码的加密为将密钥k编排成Nr个轮密钥k1,k2,...,k Nr，将明文x定义为初始状态w0，经过Nr轮变换得到w Nr为密文y，即

w0=x, w1=g(w0,k1), w2=g(w1,k2), ...

w Nr-1=g(w Nr-2,k Nr-1), w Nr=g(w Nr-1,k Nr)

y=w Nr

迭代密码的解密为将密文y定义为初始状态w Nr，经过Nr轮逆变换得到w0为明文x，即

y=w Nr, w Nr-1=g-1(w Nr,k Nr)，w Nr-2=g-1(w Nr-1,k Nr-1)

...

w1=g-1(w2,k2), w0=g-1(w1,k1),

x=w0

（2）代替-置换网络(Substitution-Permutation Network)

代替-置换网络(Substitution-Permutation Network)是一种简单的迭代密码。处理的明文单元和状态值长度为l×m，轮函数g包括两个核心变换——代替和置换，分别记为πs和πp，有

πs : {0,1}l →{0,1}l

πp : {1,2,...,lm} →{1,2,...,lm}

在进行轮函数变换前，先用轮密钥和状态值进行异或(称为白化)

（3）SPN密码体制设计

设l,m,Nr是正整数,P=C={0,1}lm

K?({0,1}lm)Nr+1是由初始密钥k用密钥编排算法生成的所有可能的密钥编排方案集合，一个密钥编排方案记为(k1,k2,...,kNr+1)

状态值w长度为l×m，记为w1,w2,...,wlm；

w可以看成m个长度为l的子串连接而成，记为

w=w<1>,w<2>,...,w，其中

w=w(i-1)l+1,w(i-1)l+2,...,w(i-1)l+l

加密过程使用如下算法描述：

w0=x

for r=1 to N r-1{

u r=w r-1⊕k r // 白化

for i=1 to m {

v r=πs(u r) // 代替

}

w r=(v rπp(1),v rπp(2),...,v rπp(lm)) // 置换

}

u Nr=w Nr-1⊕k Nr

for i=1 to m {

v Nr=πs(u Nr) // 代替

}

y=v Nr⊕k Nr+1// 白化

return y

具体加密过程如图3.1所示：

图3.1 SPN加密过程示例

（4）线性密码分析

线性密码分析，是通过分析S盒的线性特性，从而发现明文比特、密文比特和密钥比特之间可能存在的线性关系，如果S盒设计不当，这种线性关系会以较大的概率存在，称为概率线性关系。线性密码分析一种已知明文攻击方法，已知x和y，确定k或k的部分比特。

其中，S盒的选择对SPN的安全性影响巨大，假设一个S盒按如下规则设计，见图3.2

图3.2 S盒示例

可以发现其实是将输入进行了循环左移，如图3.3

图3.3 输入输出线性关系示例

这种输入输出关系是一种”线性关系”。

采用已知明文攻击方法，如果掌握了足够多的明-密文对，即可求出轮密钥ki，进而根据轮密钥编排方案反向推导出加密密钥k。线性密码分析思路为找到足够多的明文-密文对，对可能的密钥进行穷举，计算相关随机变量的偏差，正确的密钥作用下，偏差的绝对值最大

不需要对全部密钥空间进行穷举，只需要对随机变量有影响的密钥比特进行穷举，这些密钥比特称为候选子密钥

具体算法如下：

线性攻击(T, T, πs-1)

for (L1,L2)=(0,0) to (F,F) { // L1,L2表示候选子密钥k5<2>和k5<4>

Count[L1,L2]=0 // 每个候选子密钥分配一个计数器并初始化为0

}

for each (x,y) ∈T {

for (L1,L2)=(0,0) to (F,F) {

v4<2> = L1⊕y<2>

v4<4> = L2⊕y<4>

u4<2> = πs-1(v4<2>)

u4<4>= πs-1(v4<4>)

z = x5⊕x7⊕x8⊕u46⊕u48⊕u414⊕u416// 计算随机变量值

if z=0 {

Count[L1,L2] ++;

}

}

max = -1

for (L1,L2)=(0,0) to (F,F) {

Count[L1,L2] = | Count[L1,L2] - T/2 |

if Count[L1,L2] > max {

max = Count[L1,L2]

maxkey = (L1,L2)

}

// maxkey即为所求子密钥

（4）差分密码分析

通过分析明文对的差值对密文对差值的影响来恢复某些密钥比特的分析方法，分析两个输入的异或和两个输出的异或之间的线性关系。构造若干个明文串对，每对明文的异或结果相同，观察相应的密文异或结果。

差分分析是一种选择明文攻击方法，比线性分析更早提出，分析效果略差于线性分析。

仍以“循环左移”S盒为例

假设两个输入分别是x=1010和x*=1101

则相应的输出是y=0101和y*=1011

输入的异或为x’=x⊕x*=0111

输出的异或为y’=y⊕y*=1110

可以发现不论x和x*如何变化，只要它们的异或是0111，相应输出的异或都是1110，(x’,y’)被称为一个差分

如果S盒是线性的，整个SPN也会是线性的，明文和密文的差分也会是线性的

差分分析的优势在于，分析过程基本可以忽略密钥的干扰作用。

差分密码分析思路

找到足够多的四元组(x,x*,y,y*)，其中x’=x⊕x*固定不变。对可能的密钥进行穷举，计算相关差分的扩散率，正确的密钥作用下，扩散率应最大和线性分析一样，不需要对全部密钥空间进行穷举，只需要对候选子密钥进行穷举即可。具体算法如下：

差分攻击(T, T, πs-1)

for (L1,L2)=(0,0) to (F,F) // L1,L2表示候选子密钥k5<2>和k5<4>

{

Count[L1,L2]=0 // 每个候选子密钥分配一个计数器并初始化为0 }

for each (x,x*,y,y*) ∈T

{

if (y<1>=y*<1> and y<3>=y*<3>)

{ // 只考虑y’<1>和y’<3>=0 for (L1,L2)=(0,0) to (F,F) {

v4<2> = L1⊕y<2>

v4<4> = L2⊕y<4>

u4<2>= πs-1(v4<2>)

u4<4>= πs-1(v4<4>)

(v4<2>)*= L1⊕(y<2>)*

(v4<4>)* = L2⊕(y<4>)*

(u4<2>)* = πs-1((v4<2>) *)

(u4<4>)* = πs-1((v4<4>)*)

(u4<2>)’=u4<2>⊕(u4<2>)*

(u4<4>)’=u4<4>⊕(u4<4>)*

if (u4<2>)’=0110 and (u4<4>)’ = 0110 {

Count[L1,L2] ++;

}

}

}

}

max = -1

for (L1,L2)=(0,0) to (F,F) {

if Count[L1,L2] > max {

max = Count[L1,L2]

maxkey = (L1,L2) }

}

// maxkey即为所求子密钥

3.2、RSA的加/解密及快速加/解密

非对称密码算法是指一个加密系统的加密密钥和解密密钥是不同的，或者说不能用其中一个推导出另一个。在非对称密码算法的两个密钥中，一个是用于加密的密钥，它是可以公开的，称为公钥；另一个是用于解密的密钥，是保密的，称为私钥。非对称密码算法解决了对称密码体制中密钥管理的难题，并提供了对信息发送人的身份进行验证手段，是现代密码学最重要的发明。

RSA密码体制是目前为止最成功的非对称密码算法，它是在1977年由Rivest、Shamir和Adleman提出的第一个比较完善的非对称密码算法。它的安全性是建立在“大数分解和素性检测”这个数论难题的基础上，即将两个大素数相乘在计算上容易实现，而将该乘积分解为两个大素数因子的计算量相当大。虽然它的安全性还未能得到理论证明，但经过20多年的密码分析和攻击，迄今仍然被实践证明是安全的。

RSA算法描述如下：

（1）公钥

选择两个互异的大素数p和q，n是二者的乘积，即n=pq，使Φ(n)=(p-1)(q-1)为欧拉函数。随机选取正整数e，使其满足gcd(e, Φ(n)) =1，即e和Φ(n) 互质，则将(n,e)作为公钥。

（2）私钥

求出正数d，使其满足e×d=1(modΦ(n))，则将(n,d)作为私钥。

（3）加密算法

对于明文M，由C=M e(mod n)，得到密文C。

（4）解密算法

对于密文C，由M=C d(mod n)，得到明文M。

如果窃密者获得了n、e和密文C，为了破解密文必须计算出私钥d，为此需要先分解n。为了提高破解难度，达到更高的安全性，一般商业应用要求n的长度不小于1024位，更重要的场合不小于2048位。

3.3、随机性检测

随机性测试方法

对于一个用DES加密产生的密文序列，分别以下面三种情况设计测试随机性工具

（1）0和1在密文中所占比例

（2）00、01、10、11在密文中所占比例

（3）000、001、010、011、100、101、110、111在密文中所占比例

四．实验过程

5.1、分组密码SPN

5.1.1 SPN加密

（一）数据结构选用

该部分首先确定选用数据结构，我选用C#中的List类型来存储切分后的明文单元与加密后的密文单元以及用于显示的string单元，因为List这种数据结构在添加元素的时候类似于C语言中的链表，动态存储，这样就适应了明文大小不确定的特点，避免了申请固定存储空间大小带来的麻烦。对于S盒与P盒，我采用一维数组的数据结构来存储相关信息。具体声明如下：

static public UInt16[] S = new UInt16[16]{14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7}; //S盒

static public UInt16[] S_ni = new UInt16[16] { 14, 3, 4, 8, 1, 12, 10, 15, 7, 13, 9, 6, 11, 2, 0, 5 }; //S盒逆置换

static public int[] P = new int[16]{ 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16 }; //P盒

static public UInt32 K ;

static public UInt32 ceshi;

static public List X = new List(); //放明文

static public List code = new List(); //放密文

static public List miwen = new List();

（二）具体代码实施

该部分主要依照SPN加密的原理来进行对明文的加密，并将密文转码之后转成字符串显示出来。主要按照以下几个步骤完成：

（1）根据初始密钥，生成轮密钥。

由于该设计中初始密钥设置为手动输入，以string的形式显示，所以生

成轮密钥之前，首先要将初始密钥string转成二进制，再根据其二进制

表现形式，采用位操作生成轮密钥。本实验中选用的密钥编排算法为：

从一个32比特的密钥开始，对轮数1=

16个连续的比特组成。具体实现代码如下：

将初始密钥字符串转成二进制：

string str = key.Text;

byte[] kk = Encoding.Default.GetBytes(str);

for (i = 0; i < kk.Length; i++) kk[i] = (byte)((uint)kk[i] - 48);

for (i = kk.Length-1; i >=0; i--)

{

p = (UInt32)(kk[i]<<(kk.Length-i-1));

number =(UInt32) (number | p);

}

生成轮密钥：

//获取轮函数

public static List Cycle(UInt32 K)

{

List mylist=new List();

UInt32 T;

int i;

for(i=0;i<5;i++)

{

T = K & 0XFFFF0000;

T = T >> 16;

mylist.Add((UInt16)T);

K=K<<4;

}

return mylist;

}

（2）切分明文，并进行加密

同样地，明文也是以string的形式输入的，所以在加密之前，需要将明文切分。

我的切分思路是，现将string转成byte数组，再将两个数组单元拼接成一个16比特位的单元，若byte数组元素个数为基数，则在最后一个单元补上8个0，凑成一个16比特位的单元。具体代码如下：

整体函数（包括切分）

string s = T1.Text;

byte[] b=Encoding.Default.GetBytes(s);

UInt16 current_x=0,current_y=0;

for(i=0;i

{

//拼接成16bit数进行加密

current_x = (UInt16)((b[i] << 8) | (b[i + 1]));

Class1.X.Add(current_x);

current_y = current_x;

current_y = decipher(current_y,Class1.K);

Class1.code.Add(current_y);

rr[0]=(byte)(((((current_y & 0xff00)) >> 8)%48)+48);

string r = Encoding.Default.GetString(rr);

Class1.miwen.Add(r);

rr[0] = (byte)(((((current_y & 0x00ff)) >> 8)%48)+48);

r = Encoding.Default.GetString(rr);

Class1.miwen.Add(r);

}

if(i==b.Length-1)

{

current_x=(UInt16)b[i];

Class1.X.Add(current_x);

current_y = current_x;

current_y = decipher(current_y,Class1.K);

Class1.code.Add(current_y);

rr[0] = (byte)((((current_y & 0x00ff))%48)+48);

string r = Encoding.Default.GetString(rr);

Class1.miwen.Add(r);

}

置换函数：

//置换函数

public static UInt16 Substitute(UInt16 u)

{

int n,i;

UInt16 m,v=0;

for (i = 0; i < 4;i++ )

{

m = (UInt16)(u & 0X000F);

n = Class1.S[m];

n = (UInt16)(n << 4 * i);

v =(UInt16) (v | n);

u = (UInt16)(u >> 4);

}

return v;

}

代换函数：

public static UInt16 Pjiami(UInt16 v)

{

BitArray array1 = UInt16toBitArray(v);

BitArray array2 = UInt16toBitArray(v);

int i;

for (i = 0; i < 16;i++ )

{

array2[(Class1.P[i])-1] = array1[15-i];

}

return BitArraytoUInt16(array2);

}

加密函数：

public static UInt16 decipher(UInt16 current_y,UInt32 K)

{

int r;

List mylist = new List();

mylist = Cycle(K); //生成轮函数

for (r = 0; r < 3; r++)

{

current_y = (UInt16)(current_y ^ mylist[r]); //异或

current_y = Substitute(current_y); //置换

current_y = Pjiami(current_y); //代换

}

current_y = (UInt16)(current_y ^ mylist[3]); //异或

current_y = Substitute(current_y); //置换

current_y = (UInt16)(current_y ^ mylist[4]); //异或

return current_y;

}

（3）将密文转成字符串显示出来

foreach (string c in Class1.miwen)

{

MI.Text += c;

}

5.1.2 线性密码分析

依据线性密码分析的原理与算法，我主要采用位操作来实现该算法，具体代码如下：

private void Button_Click_1(object sender, RoutedEventArgs e)

{

UInt16 L=0,L1=0,L2=0,V2,V4,U2,U4,Z,max_key=0,r_i;

int i,max;

int[] count = new int[256];

Class1.X.Clear();

Class1.code.Clear();

Random r = new Random();

for (i = 0; i < 20000;i++ )

{

r_i = (UInt16)(r.Next(0,65535));

Class1.X.Add(r_i);

r_i = decipher(r_i,Class1.K);

Class1.code.Add(r_i);

}

for (L = 0; L < 256; L++) count[L] = 0; //为256个计数器赋初值

for(i=0;i

{

for(L=0;L<256;L++)

{

L1 = (UInt16)(L >> 4);

L2 = (UInt16)(L & 0x000f);

V2 = (UInt16)(((Class1.code[i] & 0x0f00) >> 8) ^ L1);

V4=(UInt16)((Class1.code[i]&0x000f)^L2);

U2 = Class1.S_ni[V2];

U4 = Class1.S_ni[V4]; //S的逆置换

Z = (UInt16)(((Class1.X[i] >> 11) & 0x0001) ^

((Class1.X[i] >> 9) & 0x0001) ^ ((Class1.X[i] >> 8) & 0x0001) ^ ((U2 >> 2) & 0x0001) ^ (U2 & 0x0001) ^ ((U4 >> 2) & 0x0001) ^ (U4 & 0x0001));

if (Z == 0) count[L]++;

}

}

max = -1;

for(L=0;L<256;L++)

{

count[L] = Math.Abs(count[L] - 10000);

if(count[L]>max)

{

max = count[L];

max_key = L; //得出L1,L2

}

}

//暴力破解

UInt32 M, N = 0;

UInt32 M1, M2, M3, M4, M5, M6, M7, M8, M9,gg;

List hhh = new List();

for (M = 0; M < 16777215; M++)

{

if (M == 16777214)

gg = 0;

M1 = (UInt32)((M & 0x00f00000)>>20 );

M2 = (UInt32)((M & 0x00f0000)>>16);

M3 = (UInt32)((M & 0x000f000)>>12 );

M4 = (UInt32)((M & 0x0000f00)>>8);

M5 = (UInt32)((M & 0x00000f0) >>4);

M6 = (UInt32)((max_key & 0xf0) >>4);

M7 = (UInt32)((M & 0x00000f) );

M8 = (UInt32)(max_key & 0xf);

N = (UInt32)((M1<<28) | (M2<<24) | (M3<<20) | (M4<<16) |( M5<<12) | (M6<<8) | (M7<<4) | M8);

Class1.ceshi = N;

bool result = true;

for (i = 0; i < Class1.X.Count; i++)

{

if (result == true)

{

if (decipher(Class1.X[i], Class1.ceshi) != Class1.code[i])

{

result = false;

break;

}

}

if (result == false) break;

}

if (result == true) break;

}

while (N != 0)

{

M9 = (UInt16)((N & 0x80000000) >> 31);

hhh.Add(M9.ToString());

N = N << 1;

}

jieguo.Text = string.Empty;

foreach (string c in hhh)

{

jieguo.Text += c;

}

}

5.1.3 差分密码分析

依据差分密码分析的原理与算法，我主要采用位操作来实现该算法，具体代码如下：

差分分析代码

private void Button_Click_2(object sender, RoutedEventArgs e)

{

int i, max;

UInt16 r_i, L, L1, L2, V2, V4, U2, U4, V2_B;

UInt16 U2_B, V4_B, U4_B, U2_L, U4_L, max_key = 0;

//随机数生成

Class1.X.Clear();

Class1.code.Clear();

Class1.X_b.Clear();

Class1.code_b.Clear();

int[] count = new int[256];

Random r = new Random();

for (i = 0; i < 400; i++)

{

r_i = (UInt16)(r.Next(0, 65535));

Class1.X.Add(r_i); //r_i=x

Class1.X_b.Add(company(r_i)); //r_i=x

UInt16 xx = company(r_i);

Class1.code_b.Add(decipher(xx, Class1.K));

r_i = decipher(r_i, Class1.K);

Class1.code.Add(r_i);

}

//计数器初始化

for (L = 0; L < 256; L++) count[L] = 0;

for (i = 0; i < Class1.X.Count; i++)

{

if (((Class1.code[i] & 0xf000) == (Class1.code_b[i] & 0xf000)) && ((Class1.code[i] & 0x00f0) == (Class1.code_b[i] & 0x00f0)))

{

for (L = 0; L < 256; L++)

{

L1 = (UInt16)(L >> 4);

L2 = (UInt16)(L & 0x000f);

V2 = (UInt16)(L1 ^ ((Class1.code[i] & 0x0f00) >> 8));

V4 = (UInt16)(L2 ^ (Class1.code[i] & 0x000f));

U2 = Class1.S_ni[V2];

U4 = Class1.S_ni[V4];

V2_B = (UInt16)(L1 ^ (((Class1.code_b[i]) & 0x0f00) >> 8));

V4_B = (UInt16)(L2 ^ ((Class1.code_b[i]) & 0x000f));

U2_B = Class1.S_ni[V2_B];

U4_B = Class1.S_ni[V4_B];

U2_L = (UInt16)(U2 ^ U2_B);

U4_L = (UInt16)(U4 ^ U4_B);

if ((U2_L == 0x6) && (U4_L == 0x6)) count[L]++;

}

}

}

max = -1;

for (L = 0; L < 256; L++)

{

if (count[L] > max)

{

max = count[L];

max_key = L;

}

}

//暴力破解

UInt32 M, N = 0;

UInt32 M1, M2, M3, M4, M5, M6, M7, M8, M9,gg;

List hhh = new List();

for (M = 0; M < 16777215; M++)

{

if (M == 16777214)

gg = 0;

M1 = (UInt32)((M & 0x00f00000)>>20 );

M2 = (UInt32)((M & 0x00f0000)>>16);

M3 = (UInt32)((M & 0x000f000)>>12 );

M4 = (UInt32)((M & 0x0000f00)>>8);

M5 = (UInt32)((M & 0x00000f0) >>4);

M6 = (UInt32)((max_key & 0xf0) >>4);

M7 = (UInt32)((M & 0x00000f) );

M8 = (UInt32)(max_key & 0xf);

N = (UInt32)((M1<<28) | (M2<<24) | (M3<<20) | (M4<<16) |( M5<<12) | (M6<<8) | (M7<<4) | M8);

Class1.ceshi = N;

bool result = true;

for (i = 0; i < Class1.X.Count; i++)

{

if (result == true)

{

if (decipher(Class1.X[i], Class1.ceshi) != Class1.code[i])

{

result = false;

break;

}

}

if (result == false) break;

}

if (result == true) break;

}

while (N != 0)

{

M9 = (UInt16)((N & 0x80000000) >> 31);

hhh.Add(M9.ToString());

N = N << 1;

}

jieguo.Text = string.Empty;

foreach (string c in hhh)

{

jieguo.Text += c;

}

}

static public UInt16 company(UInt16 X) //求伴随

{

UInt16 c = 0x0B00;

UInt16 D;

D = (UInt16)(X ^ c);

return D;

}

5.2、RSA的加/解密及快速加/解密

该部分RSA的加解密原理比较容易理解，难点在于大数的模幂运算，若采用普通算法，时间消耗非常大，故在此选用了以下三种方式来解决大数模幂运算的问题：

5.1.1 生成大素数

该实验中我生成大素数的思路是，首先生成一个大数，接着比这个大数大的最近的一个素数，其中涉及到了大数的生成，素数的判断等算法，具体步骤如下：（1）随机生成大数：由于此次课设我没有连接大数库，只有一个大数类，故无法直接调用随机生成大数的库函数。我的思路是先随机生成一个规定长度的字符串，然后将该字符串转成大数，具体代码实现如下：

随机生成字符串

private string Randomstring(int a)

{

string PASSWORD_CHARS_LCASE = "1234567890";

int length = PASSWORD_CHARS_LCASE.Length;

int passwordlen = a;

StringBuilder sb = new StringBuilder(passwordlen);

for (int i = 0; i < passwordlen; i++)

{

int n = RandomNumber(0, length);

sb.Append(PASSWORD_CHARS_LCASE[n]);

}

return sb.ToString();

}

字符串转成大数

string sr = Randomstring(len); //随机生成字符串

BigInteger a = BigInteger.Parse(sr);

（2）寻找比n大的最近的素数，其中涉及miller-rabin算法来进行素性检测，具体代码如下：

NextPrime：生成比n大的素数,len 指定长度

private BigInteger NextPrime(int len)

{

BigInteger[] primegap =new BigInteger[167]

{

2,2,4,2,4,2,4,6,2,6,4,2,4,6,6,2,6,4,2,6,4,6,8,4,2,4,2,4,14,4,6,

2,10,2,6,6,4,6,6,2,10,2,4,2,12,12,4,2,4,6,2,10,6,6,6,2,6,4,2,10,14,4,2,

4,14,6,10,2,4,6,8,6,6,4,6,8,4,8,10,2,10,2,6,4,6,8,4,2,4,12,8,4,8,4,6, 12,2,18,6,10,6,6,2,6,10,6,6,2,6,6,4,2,12,10,2,4,6,6,2,12,4,6,8,10,8,10,8, 6,6,4,8,6,4,8,4,14,10,12,2,10,2,4,2,10,14,4,2,4,14,4,2,4,20,4,8,10,8,4,6, 6,14,4,6,6,8,6,12

};

L: BigInteger n = BigInteger.Parse(Randomstring(len));

if (n < 2) return 2;

BigInteger p = n + 1;

if (p.IsEven) p++;

if (p <= 7) return 7;

BigInteger prime_limit = 167;

BigInteger prime;

BigInteger[] moduli = new BigInteger[167];

int i;

for(;;)

{

prime = 3;

for (i = 0; i < 167; i++)

{

moduli[i] = prime % p;

prime += primegap[i];

}

BigInteger difference=0,incr=0;

for(;incr<0x10000;difference+=2)

{

prime = 3;

for (i = 0; i < 167; i++)

{

BigInteger r;

r = (moduli[i] + incr) % prime;

prime += primegap[i];

if (r == 0)

goto next;

}

p=p+difference;

difference = 0;

if (p.ToString().Length > len)

goto L;

if (panduan (p, 25))

goto done;

next:;

incr += 2;

}

BigInteger mp = p + difference;

difference = 0;

}

done: ;

return p;

}

private void Button_Click_2(object sender, RoutedEventArgs e)

{

int i = int.Parse(T_enum.Text);

BigInteger n=0;

do

{

string s = Randomstring(i);

n = BigInteger.Parse(s);

} while ((BigInteger.GreatestCommonDivisor(n, BigInteger.Parse(n_1.Text)) != 1) || (n % BigInteger.Parse(n_1.Text)==1));

T_e.Text = (n % BigInteger.Parse(n_1.Text)).ToString();

BigInteger d = Ni(n % BigInteger.Parse(n_1.Text), BigInteger.Parse(n_1.Text),ref Class1.NX,ref Class1.NY);

while (Class1.NX < 0) Class1.NX +=

BigInteger.Parse(n_1.Text);

T_d.Text = Class1.NX.ToString();

}

Miller-Rabin算法素性检测

private bool panduan(BigInteger number1,int length)

{

BigInteger number2 = 1;

BigInteger result = number1 & number2;

int k = 0;

if ((number1 == 0) || (number1 == 1)) return false;

if (number1 == 2) return true;

if ((result == 0) && (number1 != 2)) return false;

//Miller-Rabin算法

//将（number1-1）写成m*2^k的形式,要求k，只要看n-1的二进制右边有多少个0就是q了

BigInteger n = number1 - 1;

while (n != 0)

{

result = n & number2;

if (result == 0) k++;

else break;

n = n >> 1;

}

BigInteger m = ((number1 - 1) / (BigInteger.Pow(2, k)));

Random r = new Random();

int len = r.Next(1, length);

string sr = Randomstring(len); //随机生成字符串

BigInteger a = BigInteger.Parse(sr);

BigInteger b = Montgomerie(a, m, number1);

if (b == 1) return true;

for (int i = 0; i < k; i++)

{

if ((b % number1) == (number1 - 1)) return true;

else b = (b * b) % number1;

}

return false;

}

5.1.2 运用模重复平方的RSA加/解密

模重复平方的思想是将指数n写成二进制形式n=n0+n1*2+…+n k-1*2k-1，令a=1 1）若n0=1，则计算a0=a*b(mod m),否则取a0=a，即计算a0=a*b n0(mod m)，再计算b1=b2(mod m).

2）若n1=1，则计算a1=a0*b1(mod m),否则取a1=a0，即计算a1= a0* b1n1(mod m)，再计算b2=b12(mod m)。

……

（k-1）若n k-2=1，则计算a k-2=a k-3*b k-2(mod m)，否则取a k-2=a k-3，即计算a k-2=a k-3*b k-2nk-2(mod m)，再计算b k-1=b k-22(mod m)。

（k）若n k-1=1，则计算a k-1=a k-2*b k-1(mod m)，否则取a k-1=a k-2，即计算a k-1=a k-2*b k-1nk-1(mod m)，最后，a k-1就是b n(mod m)

具体加密解密实现代码如下：

模重复平方算法

private BigInteger Mo(BigInteger b, BigInteger k, BigInteger n)

{

BigInteger bb = b;

BigInteger kk = k;

BigInteger nn = n;

int result;

BigInteger a = 1;

while (k != 0)

{

result = (int)(k & 1);

if (result == 1) a = (a * b) % n;

b = (b * b) % n;

k = k / 2;

}

}

模重复平方加密解密

private void Button_Click_4(object sender, RoutedEventArgs e)

{

BigInteger key_e = BigInteger.Parse(T_e.Text);

BigInteger key_d = BigInteger.Parse(T_d.Text);

BigInteger n = BigInteger.Parse(T_n.Text);

BigInteger y1;

int done;

UInt16 current_x;

byte[] b=null;

string s = string.Empty;

if ((T_plain.Text == string.Empty) && (T_decipher.Text == string.Empty)) { MessageBox.Show("请输入明文或密文！"); return; }

if (T_decipher.Text == string.Empty) { s = T_plain.Text; done = 1; } //加密done置1

else { s = T_decipher.Text; done = 2; } //解密done置2

int i=0;

if(done==1)

{

Class1.code.Clear();

b = Encoding.Default.GetBytes(s);

//计时开始

DateTime begin = new DateTime(1970, 1, 1);

DateTime now = DateTime.UtcNow;

for (i = 0; i < b.Length; i ++)

{

current_x = (UInt16)(b[i]-48);

Class1.X.Add(current_x);

y1 = Mo(current_x,key_e,n);

Class1.code.Add(y1);

}

//计时结束

DateTime now2 = DateTime.UtcNow;

long time2 = now2.Ticks - now.Ticks;

int time = (int)(time2 / 10000);

foreach (BigInteger c in Class1.code)

{

T_decipher.Text += c.ToString();

现代密码学实验报告

现代密码学 实验报告 学生姓名 学号 专业班级计算机科学与技术指导教师段桂华 学院信息科学与工程学院完成时间2016年4月

实验一密码算法实验 [实验目的] 1.掌握密码学中经典的对称密码算法AES、RC4的算法原理。 2.掌握AES、RC4的算法流程和实现方法。 [实验预备] 1.AES算法的基本原理和特点。 2.流密码RC4的密钥流生成以及S盒初始化过程。 [实验内容] 1. 分析AES、RC4的实现过程。 2. 用程序设计语言将算法过程编程实现。 3. 完成字符串数据的加密运算和解密运算 输入十六进制明文：11223344556677889900AABBCCDDEEFF 输入十六进制密钥：13579BDF02468ACE1234567890ABCDEF [实验步骤] 1. 预习AES、RC4算法。 2. 写出算法流程，用程序设计语言将算法过程编程实现。 3. 输入指定的明文、密钥进行实验，验证结果。 4. 自己选择不同的输入，记录输出结果。 写出所编写程序的流程图和运行界面、运行结果。 一、AES算法 1、AES算法简介 AES 是一种可用来保护电子数据的新型加密算法。特别是，AES 是可以使用128、192 和 256 位密钥的迭代式对称密钥块密码，并且可以对 128 位（16 个字节）的数据块进行加密和解密。与使用密钥对的公钥密码不同的是，对称密钥密码使用同一个密钥来对数据进行加密和解密。由块密码返回的加密数据与输入数据具有相同的位数。迭代式密码使用循环结构来针对输入数据反复执行排列和置换运算。 2、算法实现及流程 以加密函数为例，如下所示，首先对密钥进行预处理密钥扩展，然后明文进行Nr（Nr与密钥长度有关）次迭代运算，包括字节替换SubBytes、移位行运算ShiftRows、混合列运算MixColumns、以及轮秘钥加密AddRoundKey。

密码学答案2

《密码学原理与实践(第三版)》课后习题参考答案 (由华中科技大学信安09级提供) 第二章 2.1（何锐） 解：依题意有：x ∈{2,…,12}，y ∈{D ，N} 计算Pr[x ，y]： Pr[2，D]=1/36 Pr[3，D]=0 Pr[4，D]=1/36 Pr[5，D]=0 Pr[6，D]=1/36 Pr[7，D]=0 Pr[8，D]=1/36 Pr[9，D]=0 Pr[10，D]=1/36 Pr[11，D]=0 Pr[12，D]=1/36 Pr[2，N]=0 Pr[3，N]=1/18 Pr[4，N]=1/18 Pr[5，N]=1/9 Pr[6，N]=1/9 Pr[7，N]=1/6 Pr[8，N]=1/9 Pr[9，N]=1/9 Pr[10，N]=1/18 Pr[11，N]=1/18 Pr[12，N]=0 计算Pr[x | y]： 有Pr[D]=1/6 Pr[N]=5/6 Pr[2 | D]=1/6 Pr[3 | D]=0 Pr[4 | D]=1/6 Pr[5 | D]=0 Pr[6 | D]=1/6 Pr[7 | D]=0 Pr[8 | D]= 1/6 Pr[9 | D]=0 Pr[10 | D]= 1/6 Pr[11 | D]=0 Pr[12 | D]=1/6 Pr[2 | N]=0 Pr[3 | N]=1/15 Pr[4 | N]=1/15 Pr[5 | N]=2/15 Pr[6 | N]=2/15 Pr[7 | N]=1/5 Pr[8 | N]=2/15 Pr[9 | N]=2/15 Pr[10 | N]=1/15 Pr[11 | N]=1/15 Pr[12 | N]=0 计算Pr[y | x]： Pr[D | 2]=1 Pr[D | 3]=0 Pr[D | 4]=1/3 Pr[D | 5]=0 Pr[D | 6]=1/5 Pr[D | 7]=0 Pr[D | 8]=1/5 Pr[D | 9]=0 Pr[D | 10]=1/3 Pr[D | 11]=0 Pr[D | 12]=1 Pr[N | 2]=0 Pr[N | 3]=1 Pr[N | 4]=2/3 Pr[N | 5]=1 Pr[N | 6]=4/5 Pr[N | 7]=1 Pr[N | 8]=4/5 Pr[N | 9]=1 Pr[N | 10]=2/3 Pr[N | 11]=1 Pr[N | 12]=0 有上面的计算可得： Pr[D | x]Pr[x] = Pr[D]Pr[x | D] Pr[N | x]Pr[x] = Pr[N]Pr[x | N] 显然符合Bayes 定理。 2.2（王新宇） 证明： 由P=C=K=z n ，对于1≤i ≤n,加密规则e i (j)=L(i,j)（1≤j ≤n)， 且每行的加密规则不同。 首先，计算C 的概率分布。假设i ∈ z n ，则 )] (Pr[i ]Pr[]Pr[d K j Z k K y y n k ∑∈ === = )](Pr[i n 1 d K j Z n k ∑∈==

现代密码学知识点整理：.

第一章 基本概念 1. 密钥体制组成部分： 明文空间，密文空间，密钥空间，加密算法，解密算法 2、一个好密钥体制至少应满足的两个条件： （1）已知明文和加密密钥计算密文容易；在已知密文和解密密钥计算明文容易； （2）在不知解密密钥的情况下，不可能由密文c 推知明文 3、密码分析者攻击密码体制的主要方法： （1）穷举攻击 （解决方法:增大密钥量） （2）统计分析攻击（解决方法：使明文的统计特性与密文的统计特性不一样） （3）解密变换攻击（解决方法：选用足够复杂的加密算法） 4、四种常见攻击 （1）唯密文攻击：仅知道一些密文 （2）已知明文攻击：知道一些密文和相应的明文 （3）选择明文攻击：密码分析者可以选择一些明文并得到相应的密文 （4）选择密文攻击：密码分析者可以选择一些密文，并得到相应的明文 【注：①以上攻击都建立在已知算法的基础之上；②以上攻击器攻击强度依次增加；③密码体制的安全性取决于选用的密钥的安全性】 第二章 古典密码 （一）单表古典密码 1、定义：明文字母对应的密文字母在密文中保持不变 2、基本加密运算 设q 是一个正整数，}1),gcd(|{};1,...,2,1,0{* =∈=-=q k Z k Z q Z q q q （1）加法密码 ①加密算法： κκ∈∈===k X m Z Z Y X q q ;,;对任意，密文为：q k m m E c k m od )()(+== ②密钥量：q （2）乘法密码 ①加密算法： κκ∈∈===k X m Z Z Y X q q ;,;* 对任意，密文为：q km m E c k m od )(== ②解密算法：q c k c D m k mod )(1 -== ③密钥量：)(q ? （3）仿射密码 ①加密算法： κκ∈=∈∈∈===),(;},,|),{(;21* 2121k k k X m Z k Z k k k Z Y X q q q 对任意；密文

密码学基础课程设计指导书

《现代密码学基础》课程设计指导书 杨柳编 湖南科技大学计算机科学与工程学院 2014年12月

一、概述 本课程在简要复习数学基础知识之后，探讨了密码学研究的基本问题：通过不安全的通信媒介如何进行安全通信。也可以理解为关心任何希望限制不诚实者达到目的的问题，把度量和评价一个密码体制（协议）的安全性作为一个重点。就目前来说，密码学的研究领域已从消息加密扩大到了数字签名、消息认证、身份识别、抗欺骗协议等。无疑，在整个教学过程中非常重视密码学的基础，当然包括数学基础。并针对实际的密码体制（协议）强调设计与分析（攻击），对现代密码学的主要研究问题都进行了介绍。 对于密码学这样的课程，同学们一定要从理论、技术、应用三个方面进行学习与思考。密码体制（协议）无疑是我们的学习重点，密码体制（协议）也可以单纯地理解为计算机算法，从而有设计、分析、证明、实现的问题。实现密码体制（协议）就是我们经常讲的八个字：模型、算法、程序、测试。 二、课程设计步骤 课程设计步骤要求如下： 1.模型 从数学的角度看，解决任何问题都要建立一个数学模型，对于密码学来说更是如此。我们还可以认为，数据结构中的存储结构也是模型。于是这一部分的任务就是建立起问题的逻辑结构和存储结构，为算法设计和编码实现打下基础。 2.算法 这一部分对同学们的要求是能看懂书上的常用算法，并对其中的参数可以进行调整和设置，能实现和应用它们。 3.程序 编码实现得到程序。 4. 测试 5. 提交课程设计报告

三、课程设计报告编写要求 课程设计报告开头标明课程设计题目、设计者的班级、姓名、学号和完成日期，内容包括：模型、算法、程序、测试四个部分。 四、设计要求 可以只做第7题，不做第7题的要做第1题-第6题。 五、课程设计题目 大整数运算包的设计与实现 1．问题描述 大整数运算是现代密码学算法实现的基础，重要性不言而喻。大整数我们指的是二进制位512、1024和2048的数，一般的语言不支持。 2．基本要求 以类库头文件的形式实现。 3．实现提示 在选择了大整数的存储结构之后，主要实现以下运算： ①模加； ②模减； ③模乘； ④模整除； ⑤模取余。这五种运算模拟手算实现。 ⑥幂模：利用“平方-乘法”算法实现。 ⑦GCD：利用欧几里得算法实现。 ⑧乘法逆: 利用扩展的欧几里得算法实现。 ⑨素数判定与生成：概率性素数产生方法产生的数仅仅是伪素数，其缺点在于，

杭电密码学DES密码实验报告

课程实验报告 课程密码学实验 学院通信工程学院 专业信息安全 班级14083611 学号14084125 学生姓名刘博 实验名称DES密码实验 授课教师胡丽琴

DES密码实验 一、实验要求： 1、了解分组密码的起源与涵义。 2、掌握DES密码的加解密原理。 3、用Visual C++实现DES密码程序并输出结果。 二、实验内容： 1、1949年，Shannon发表了《保密系统的通信理论》，奠定了现代密码学的基础。他还指出混淆和扩散是设计密码体制的两种基本方法。扩散指的是让明文中的每一位影响密文中的许多位，混淆指的是将密文与密钥之间的统计关系变得尽可能复杂。而分组密码的设计基础正是扩散和混淆。在分组密码中，明文序列被分成长度为n的元组，每组分别在密钥的控制下经过一系列复杂的变换，生成长度也是n的密文元组，再通过一定的方式连接成密文序列。 2、DES是美国联邦信息处理标准(FIPS)于1977年公开的分组密码算法，它的设计基于Feistel对称网络以及精心设计的S盒，在提出前已经进行了大量的密码分析，足以保证在当时计算条件下的安全性。不过，随着计算能力的飞速发展，现如今DES已经能用密钥穷举方式破解。虽然现在主流的分组密码是AES，但DES的设计原理仍有重要参考价值。在本实验中，为简便起见，就限定DES 密码的明文、密文、密钥均为64bit，具体描述如下： 明文m是64bit序列。 初始密钥K是64 bit序列(含8个奇偶校验bit)。 子密钥K1, K2…K16均是48 bit序列。 轮变换函数f(A,J)：输入A(32 bit序列), J(48 bit序列)，输出32 bit序列。 密文c是64 bit序列。 1)子密钥生成： 输入初始密钥，生成16轮子密钥K1, K2 (16) 初始密钥(64bit)经过置换PC-1，去掉了8个奇偶校验位，留下56 bit，接着分成两个28 bit的分组C0与D0，再分别经过一个循环左移函数LS1，得到C1与D1，连成56 bit数据，然后经过置换PC-2，输出子密钥K1，以此类推产生K2至K16。

现代密码学课后答案第二版讲解

现代密码学教程第二版 谷利泽郑世慧杨义先 欢迎私信指正，共同奉献 第一章 1.判断题 2.选择题 3.填空题 1.信息安全的主要目标是指机密性、完整性、可用性、认证性和不可否认性。 2.经典的信息安全三要素--机密性，完整性和可用性，是信息安全的核心原则。 3.根据对信息流造成的影响，可以把攻击分为5类中断、截取、篡改、伪造和重放，进一 步可概括为两类主动攻击和被动攻击。

4.1949年，香农发表《保密系统的通信理论》，为密码系统建立了理论基础，从此密码学 成为了一门学科。 5.密码学的发展大致经历了两个阶段：传统密码学和现代密码学。 6.1976年，W.Diffie和M.Hellman在《密码学的新方向》一文中提出了公开密钥密码的 思想，从而开创了现代密码学的新领域。 7.密码学的发展过程中，两个质的飞跃分别指 1949年香农发表的《保密系统的通信理 论》和 1978年，Rivest，Shamir和Adleman提出RSA公钥密码体制。 8.密码法规是社会信息化密码管理的依据。 第二章 1.判断题 答案×√×√√√√××

2.选择题 答案：DCAAC ADA

3.填空题 1.密码学是研究信息寄信息系统安全的科学，密码学又分为密码编码学和密码分 析学。 2.8、一个保密系统一般是明文、密文、密钥、加密算法、解密算法 5部分组成的。 3.9、密码体制是指实现加密和解密功能的密码方案，从使用密钥策略上，可分为对称和 非对称。 4.10、对称密码体制又称为秘密密钥密码体制，它包括分组密码和序列 密码。

第三章5.判断 6.选择题

AES密码学课程设计(C语言实现)

成都信息工程学院课程设计报告 AES加密解密软件的实现 课程名称：应用密码算法程序设计 学生姓名：樊培 学生学号：2010121058 专业班级：信息对抗技术101 任课教师：陈俊 2012 年6月7日

课程设计成绩评价表

目录 1、选题背景 (4) 2、设计的目标 (4) 2.1基本目标： (4) 2.2较高目标： (5) 3、功能需求分析 (5) 4、模块划分 (6) 4.1、密钥调度 (6) 4.2、加密 (8) 4.2.1、字节代替（SubBytes） (8) 4.2.2、行移位（ShiftRows） (10) 4.2.3、列混合（MixColumn） (11) 4.2.4、轮密钥加（AddRoundKey） (13) 4.2.5、加密主函数 (14) 4.3、解密 (16) 4.3.1、逆字节替代（InvSubBytes） (16) 4.3.2、逆行移位（InvShiftRows） (17) 4.3.3、逆列混合（InvMixCloumns） (17) 4.3.4、轮密钥加（AddRoundKey） (18) 4.3.5、解密主函数 (18) 5.测试报告 (20) 5.1主界面 (20) 5.2测试键盘输入明文和密钥加密 (20) 5.3测试键盘输入密文和密钥加密 (21) 5.3测试文件输入明文和密钥加密 (22) 5.4测试文件输入密文和密钥加密 (22) 5.5软件说明 (23) 6.课程设计报告总结 (23) 7.参考文献 (24)

1、选题背景 高级加密标准（Advanced Encryption Standard，AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。该算法为比利时密码学家Joan Daemen和Vincent Rijmen所设计，结合两位作者的名字，以Rijndael 之命名之，投稿高级加密标准的甄选流程。（Rijndael的发音近于 "Rhine doll"） 严格地说，AES和Rijndael加密法并不完全一样（虽然在实际应用中二者可以互换），因为Rijndael加密法可以支援更大范围的区块和密钥长度：AES的区块长度固定为128 位元，密钥长度则可以是128，192或256位元；而Rijndael使用的密钥和区块长度可以是32位元的整数倍，以128位元为下限，256位元为上限。加密过程中使用的密钥是由Rijndael 密钥生成方案产生。大多数AES计算是在一个特别的有限域完成的。 截至2006年，针对AES唯一的成功攻击是旁道攻击 旁道攻击不攻击密码本身，而是攻击那些实作于不安全系统（会在不经意间泄漏资讯）上的加密系统。2005年4月，D.J. Bernstein公布了一种缓存时序攻击法，他以此破解了一个装载OpenSSL AES加密系统的客户服务器[6]。为了设计使该服务器公布所有的时序资讯，攻击算法使用了2亿多条筛选过的明码。有人认为[谁？]，对于需要多个跳跃的国际互联网而言，这样的攻击方法并不实用[7]。 Bruce Schneier称此攻击为“好的时序攻击法”[8]。2005年10月，Eran Tromer和另外两个研究员发表了一篇论文，展示了数种针对AES的缓存时序攻击法。其中一种攻击法只需要800个写入动作，费时65毫秒，就能得到一把完整的AES密钥。但攻击者必须在执行加密的系统上拥有执行程式的权限，方能以此法破解该密码系统。 虽然高级加密标准也有不足的一面，但是，它仍是一个相对新的协议。因此，安全研究人员还没有那么多的时间对这种加密方法进行破解试验。我们可能会随时发现一种全新的攻击手段会攻破这种高级加密标准。至少在理论上存在这种可能性。 2、设计的目标 2.1基本目标： （1）在深入理解AES加密/解密算法理论的基础上，能够设计一个AES加密/解密软件系统，采用控制台模式，使用VS2010进行开发，所用语言为C语言进行编程，实现加密解密； （2）能够完成只有一个明文分组的加解密，明文和密钥是ASCII码，长度都为16个字符(也就是固定明文和密钥为128比特)，输入明文和密钥，输出密文，进行加密后，能够进

现代密码学期终考试试卷和答案

一．选择题 1、关于密码学的讨论中，下列（D ）观点是不正确的。 A、密码学是研究与信息安全相关的方面如机密性、完整性、实体鉴别、抗否认等的综 合技术 B、密码学的两大分支是密码编码学和密码分析学 C、密码并不是提供安全的单一的手段，而是一组技术 D、密码学中存在一次一密的密码体制，它是绝对安全的 2、在以下古典密码体制中，属于置换密码的是（B）。 A、移位密码 B、倒序密码 C、仿射密码 D、PlayFair密码 3、一个完整的密码体制，不包括以下（?C?? ）要素。 A、明文空间 B、密文空间 C、数字签名 D、密钥空间 4、关于DES算法，除了（C ）以外，下列描述DES算法子密钥产生过程是正确的。 A、首先将DES 算法所接受的输入密钥K（64 位），去除奇偶校验位，得到56位密钥（即经过PC-1置换，得到56位密钥） B、在计算第i轮迭代所需的子密钥时，首先进行循环左移，循环左移的位数取决于i的值，这些经过循环移位的值作为下一次 循环左移的输入 C、在计算第i轮迭代所需的子密钥时，首先进行循环左移，每轮循环左移的位数都相同，这些经过循环移位的值作为下一次循 环左移的输入 D、然后将每轮循环移位后的值经PC-2置换，所得到的置换结果即为第i轮所需的子密钥Ki 5、2000年10月2日，NIST正式宣布将（B ）候选算法作为高级数据加密标准，该算法是由两位比利时密码学者提出的。 A、MARS B、Rijndael C、Twofish D、Bluefish *6、根据所依据的数学难题，除了（A ）以外，公钥密码体制可以分为以下几类。 A、模幂运算问题 B、大整数因子分解问题 C、离散对数问题 D、椭圆曲线离散对数问题 7、密码学中的杂凑函数（Hash函数）按照是否使用密钥分为两大类：带密钥的杂凑函数和不带密钥的杂凑函数，下面（C ）是带密钥的杂凑函数。 A、MD4 B、SHA-1

现代密码学 学习心得

混合离散对数及安全认证 摘要：近二十年来，电子认证成为一个重要的研究领域。其第一个应用就是对数字文档进行数字签名，其后Chaum希望利用银行认证和用户的匿名性这一性质产生电子货币，于是他提出盲签名的概念。 对于所有的这些问题以及其他的在线认证，零知识证明理论成为一个非常强有力的工具。虽然其具有很高的安全性，却导致高负荷运算。最近发现信息不可分辨性是一个可以兼顾安全和效率的性质。 本文研究混合系数的离散对数问题，也即信息不可识别性。我们提供一种新的认证，这种认证比因式分解有更好的安全性，而且从证明者角度看来有更高的效率。我们也降低了对Schnorr方案变形的实际安全参数的Girault的证明的花销。最后，基于信息不可识别性，我们得到一个安全性与因式分解相同的盲签名。 1．概述 在密码学中，可证明为安全的方案是一直以来都在追求的一个重要目标。然而，效率一直就是一个难以实现的属性。即使在现在对于认证已经进行了广泛的研究，还是很少有方案能兼顾效率和安全性。其原因就是零知识协议的广泛应用。 身份识别：关于识别方案的第一篇理论性的论文就是关于零知识的，零知识理论使得不用泄漏关于消息的任何信息，就可以证明自己知道这个消息。然而这样一种能够抵抗主动攻击的属性，通常需要许多次迭代来得到较高的安全性，从而使得协议或者在计算方面，或者在通信量方面或者在两个方面效率都十分低下。最近，poupard和stern提出了一个比较高效的方案，其安全性等价于离散对数问题。然而，其约减的代价太高，使得其不适用于现实中的问题。 几年以前，fiege和shamir就定义了比零知识更弱的属性，即“信息隐藏”和“信息不可分辨”属性，它们对于安全的识别协议来说已经够用了。说它们比零知识更弱是指它们可能会泄漏秘密消息的某些信息，但是还不足以找到消息。具体一点来说，对于“信息隐藏”属性，如果一个攻击者能够通过一个一次主动攻击发现秘密消息，她不是通过与证明者的交互来发现它的。而对于“信息不可分辨”属性，则意味着在攻击者方面看来，证据所用的私钥是不受约束的。也就是说有许多的私钥对应于一个公钥，证据仅仅传递了有这样一个私钥被使用了这样一个信息，但是用的是哪个私钥，并没有在证据传递的信息中出现。下面，我们集中考虑后一种属性，它能够提供一种三次传递识别方案并且对抗主动攻击。Okamoto 描述了一些schnorr和guillou-quisquater识别方案的变种，是基于RSA假设和离散对数子群中的素数阶的。 随机oracle模型：最近几年，随机oracle模型极大的推动了研究的发展，它能够用来证明高效方案的安全性，为设计者提供了一个有价值的工具。这个模型中理想化了一些具体的密码学模型，例如哈希函数被假设为真正的随机函数，有助于给某些加密方案和数字签名等提供安全性的证据。尽管在最近的报告中对于随机oracle模型采取了谨慎的态度，但是它仍然被普遍认为非常的有效被广泛的应用着。例如，在这个模型中被证明安全的OAPE加密

华科大密码学课程设计实验报告

密码学课程设计实验报告 专业：信息安全 班级：0903 姓名：付晓帆 学号：U200915328

一、 DES 的编程实现 1.实验目的 通过实际编程掌握DES 的加、脱密及密钥生成过程，加深对DES 算法的认识。 2.实验原理 a.加密过程 DES 是一个分组密码，使用长度为56比特的密钥加密长度为64比特的明文，获得长度为64比特的密文，其加密过程： (1) 给定一个明文X ，通过一个固定的初始置换IP 置换X 的比特，获得X0，X0=IP(X)=L0R0，L0R0分别是X0的前32比特和后32比特。 (2) 然后进行16轮完全相同的运算，有如下规则，其中0

密码学作业参考答案

第1章绪论 1．1为什么会有信息安全问题的出现？ 答题要点： （1）网络自身的安全缺陷。主要指协议不安全和业务不安全。协议不安全的主要原因 一是 Internet 从建立开始就缺乏安全的总体构想和设计；二是协议本身可能会泄漏口令等。业务不安全的主要表现为业务内部可能隐藏着一些错误的信息；有些业务本，难以区分出错原因；有些业务设置复杂，一般非专业人士很难完善地设置。 （2）网络的开放性。网络协议是公开的协议，连接基于彼此的信任，远程访问等，使 得各种攻击无需到现场就能成功。 （3）人的因素，包括人的无意失误、黑客攻击、管理不善等。 1．2简述密码学与信息安全的关系。 答题要点： 密码技术是实现网络信息安全的核心技术，是保护数据最重要的工具之一。 密码学尽管在网络信息安全中具有举足轻重的作用，但密码学绝不是确保网络信息安全的唯一工具，它也不能解决所有的安全问题。 1．3简述密码学发展的三个阶段及其主要特点。 答题要点：密码学的发展大致经历了三个阶段： （1）古代加密方法（手工阶段）。特点：基于手工的方式实现，通常原理简单，变化量小，时效性较差等。 （2）古典密码（机械阶段）。特点：加密方法一般是文字置换，使用手工或机械变换的 方式实现。它比古代加密方法更复杂，但其变化量仍然比较小。转轮机的出现是这一阶段的重要标志，利用机械转轮可以开发出极其复杂的加密系统，缺点是密码周期有限、制造费用高等。 （3）近代密码（计算机阶段）。特点：这一阶段密码技术开始形成一门科学，利用电子 计算机可以设计出更为复杂的密码系统，密码理论蓬勃发展，出现了以 DES 为代表的对称 密码体制和 RSA 为代表的非对称密码体制，制定了许多通用的加密标准，促进和加快了密 码技术的发展。 1．4近代密码学的标志是什么？ 答：1949 年 Claude Shannon 发表论文 The communication theory of secrecy systems，1976 年 W.Diffie 和 M.Hellman 发表论文 New directions in cryptography，以及美国数据加密标准 DES 的实施，标志着近代密码学的开始。 1．5安全机制是什么？主要的安全机制有哪些？ 答题要点： 安全机制是指用来保护网络信息传输和信息处理安全的机制。 安全机制可分为两类：特定的安全机制和通用的安全机制。 特定的安全机制包含：加密、数字签名、访问控制、数据完整性、认证交换、流量填充、路由控制和公证。 通用的安全机制包含：可信功能、安全标签、事件检测、安全审计跟踪和安全恢复。1．6什么是安全服务？主要的安全服务有哪些？ 答题要点： 安全服务就是指在信息传输和处理过程中为保证信息安全的一类服务。 主要的安全服务包括：机密性、完整性、鉴别、非否认性、访问控制、可用性。 1．7简述安全性攻击的主要形式及其含义。 答题要点：

密码学课程设计

一、设计题目 随机数产生器应用系统 二、课题要求 系统功能要求： 1）模拟线性移位寄存器、线性同余发生器等产生伪随机数，并比较算法性能以及伪随机数的随机性； 2）利用该模拟随机数，应用到口令认证系统中，完成口令的生产、口令的加密保护、登陆验证等功能； 3）利用该模拟随机数，应用到密钥生成系统中，可以利用该密钥完成对称密钥的加密和解密功能。 三、系统设计和模块设计 1.总体设计思路 利用线性同余发生器(LCG)和线性反馈移位寄存器（LFSR)生成伪随机数M序列，并通过口令认证系统完成口令生成加密工作，同时完成对随机数的加密和解密功能。 2.模块设计思路 2.1原理 通过一定的算法对事先选定的随机种子(seed)做一定的运算可以得到一组人工生成的周期序列，在这组序列中以相同的概率选取其中一个数字，该数字称作伪随机数，由于所选数字并不具有完全的随机性，但是从实用的角度而言，其随机程度已足够了。这里的“伪”的含义是，由于该随机数是按照一定算法模拟产生的，

其结果是确定的，是可见的，因此并不是真正的随机数。伪随机数的选择是从随机种子开始的，所以为了保证每次得到的伪随机数都足够地“随机”，随机种子的选择就显得非常重要，如果随机种子一样，那么同一个随机数发生器产生的随机数也会一样。 2.2线性同余算法生成随机数 到目前为止，使用最为广泛的随机数产生技术是由Lehmer首先提出的称为线性同余算法，即使用下面的线性递推关系产生一个伪随机数列x1，x2，x3，… 这个算法有四个参数，分别是： a 乘数 0 ≤ a < m c 增量 0 ≤ c< m m 模数 m > 0 ≤ x0 < m x0 初始种子（秘密） 0 伪随机数序列{ xn}通过下列迭代方程得到： xn+1=(axn+c)modm 如果m、a、c和x0都是整数，那么通过这个迭代方程将产生一系列的整数，其中每个数都在0 ≤ xn < m的范围内。数值m、a和c的选择对于建立一个好的伪随机数产生器十分关键。为了形成一个很长的伪随机数序列，需要将m设置为一个很大的数。一个常用准则是将m选为几乎等于一个给定计算机所能表示的最大非负整数。因而，在一个32位计算机上，通常选择的m值是一个接近或等于231的整数。此外，为了使得随机数列不易被重现，可以使用当前时间的毫秒数作为初始种子的位置。 2.2 线性反馈移位寄存器生成随机数 LFSR是指给定前一状态的输出，将该输出的线性函数再用作输入的线性寄存器。异或运算是最常见的单比特线性函数：对寄存器的某些位进行异或操作后作为输入，再对寄存器中的各比特进行整体移位。赋给寄存器的初始值叫做“种子”，因为线性反馈移位寄存器的运算是确定性的，所以，由寄存器所生成的数据流完全决定于寄存器当时或者之前的状态。而且，由于寄存器的状态是有

(完整版)北邮版《现代密码学》习题答案

《现代密码学习题》答案 第一章 1、1949年，（ A ）发表题为《保密系统的通信理论》的文章，为密码系统建立了理论基础，从此密码学成了一门科学。 A、Shannon B、Diffie C、Hellman D、Shamir 2、一个密码系统至少由明文、密文、加密算法、解密算法和密钥5部分组成，而其安全性是由（ D）决定的。 A、加密算法 B、解密算法 C、加解密算法 D、密钥 3、计算和估计出破译密码系统的计算量下限，利用已有的最好方法破译它的所需要的代价超出了破译者的破译能力（如时间、空间、资金等资源），那么该密码系统的安全性是（ B ）。 A无条件安全B计算安全C可证明安全D实际安全 4、根据密码分析者所掌握的分析资料的不通，密码分析一般可分为4类：唯密文攻击、已知明文攻击、选择明文攻击、选择密文攻击，其中破译难度最大的是（ D ）。 A、唯密文攻击 B、已知明文攻击 C、选择明文攻击 D、选择密文攻击 5、1976年，和在密码学的新方向一文中提出了公开密钥密码的思想，从而开创了现代密码学的新领域。 6、密码学的发展过程中，两个质的飞跃分别指 1949年香农发表的保密系统的通信理论和公钥密码思想。 7、密码学是研究信息寄信息系统安全的科学，密码学又分为密码编码学和密码分析学。 8、一个保密系统一般是明文、密文、密钥、加密算法、解密算法 5部分组成的。 9、密码体制是指实现加密和解密功能的密码方案，从使用密钥策略上，可分为对称和非对称。 10、对称密码体制又称为秘密密钥密码体制，它包括分组密码和序列密码。 第二章 1、字母频率分析法对（B ）算法最有效。 A、置换密码 B、单表代换密码 C、多表代换密码 D、序列密码 2、（D）算法抵抗频率分析攻击能力最强，而对已知明文攻击最弱。

密码学实验报告(AES,RSA)

华北电力大学 实验报告| | 实验名称现代密码学课程设计 课程名称现代密码学 | | 专业班级：学生姓名： 学号：成绩： 指导教师：实验日期：

[综合实验一] AES-128加密算法实现 一、实验目的及要求 （1）用C++实现； （2）具有16字节的加密演示； （3）完成4种工作模式下的文件加密与解密：ECB, CBC, CFB,OFB. 二、所用仪器、设备 计算机、Visual C++软件。 三. 实验原理 3.1、设计综述 AES 中的操作均是以字节作为基础的，用到的变量也都是以字节为基础。State 可以用4×4的矩阵表示。AES 算法结构对加密和解密的操作，算法由轮密钥开始，并用Nr 表示对一个数据分组加密的轮数(加密轮数与密钥长度的关系如表2所示)。AES 算法的主循环State 矩阵执行1 r N 轮迭代运算，每轮都包括所有 4个阶段的代换，分别是在规范中被称为 SubBytes(字节替换)、ShiftRows(行位移变换)、MixColumns(列混合变换) 和AddRoundKey ，(由于外部输入的加密密钥K 长度有限，所以在算法中要用一个密钥扩展程序(Keyexpansion)把外部密钥 K 扩展成更长的比特串，以生成各轮的加密和解密密钥。最后执行只包括 3个阶段 (省略 MixColumns 变换)的最后一轮运算。 表2 AES 参数 比特。

3.2、字节代替（SubBytes ） AES 定义了一个S 盒，State 中每个字节按照如下方式映射为一个新的字节：把该字节的高4位作为行值，低4位作为列值，然后取出S 盒中对应行和列的元素作为输出。例如，十六进制数{84}。对应S 盒的行是8列是4，S 盒中该位置对应的值是{5F}。 S 盒是一个由16x16字节组成的矩阵，包含了8位值所能表达的256种可能的变换。S 盒按照以下方式构造： (1) 逐行按照升序排列的字节值初始化S 盒。第一行是{00}，{01}，{02}，…，{OF}； 第二行是{10}，{l1}，…，{1F}等。在行X 和列Y 的字节值是{xy}。 (2) 把S 盒中的每个字节映射为它在有限域GF(k 2)中的逆。GF 代表伽罗瓦域，GF(82) 由一组从0x00到0xff 的256个值组成，加上加法和乘法。 ) 1(] [2)2(3488++++= x x x x X Z GF 。{00}被映射为它自身{00}。 (3) 把S 盒中的每个字节记成),,,,,,,,(012345678b b b b b b b b b 。对S 盒中每个字节的每位 做如下变换： i i i i i i c b b b b b i b ⊕⊕⊕⊕⊕='++++8mod )7(8mod )6(8mod )5(8mod )4( 上式中i c 是指值为{63}字节C 第i 位，即)01100011(),,,,,,,,(012345678=c c c c c c c c c 。符号(')表示更新后的变量的值。AES 用以下的矩阵方式描述了这个变换： ?? ? ?? ? ? ? ? ? ??? ? ????????????+???????????????????????????????????????? ????????????=??????????????????????????0110001111111000011111000011111000011111100011111100011111100011111100017654321076543210b b b b b b b b b b b b b b b b 最后完成的效果如图：

现代密码学-RC4校验 实验报告

现代密码学 实 验 报 告 院系：理学院 班级：信安二班 姓名： 学号：

前言 密码学（Cryptology）是研究秘密通信的原理和破译秘密信息的方法的一门学科。密码学的基本技术就是对数据进行一组可逆的数学变换，使未授权者不能理解它的真实含义。密码学包括密码编码学（Cryptography）和密码分析学（Cryptanalyst）两个既对立又统一的主要分支学科。研究密码变化的规律并用之于编制密码以保护信息安全的科学，称为密码编码学。研究密码变化的规律并用之于密码以获取信息情报的科学，称为密码分析学，也叫密码破译学。 密码学在信息安全中占有非常重要的地位，能够为信息安全提供关键理论与技术。密码学是一门古老而深奥的学问，按其发展进程，经历了古典密码和现代密码学两个阶段。现代密码学（Modern Cryptology）通常被归类为理论数学的一个分支学科，主要以可靠的数学方法和理论为基础，为保证信息的机密性、完整性、可认证性、可控性、不可抵赖性等提供关键理论与技术。

RC4密码算法算法实现 实验目的： 理解流密码的概念及相关结构； 理解并能够编写基本的流密码体制； 熟练应用C/C++编程实现RC4密码算法体制。 实验内容： 编程实现RC4加/解密算法。 实验原理： RC4算法是一种序列密码体制或称流密码体制，其加密密钥和解密密钥相同RC4的 密钥长度可变，但为了确保哪去安全强度，目前RC4至少使用128位的密钥。 用1~256个字节（8~2048位）的可变长度密钥初始化一个256个字节的状态向量S，S的元素记为S[0]，S[1],…,S[255]，从始至终置换后的S包含从0到255的所有8位数。对于加密和解密，字节K是从S的255个元素中按一种系统化的方式选出的一个元素生成的。每生成一个K的值，S中的元素个体就被重新置换一次。 实验代码： Encrypt.h文件： #ifndef _ENCRYPT_RC4_ #define _ENCRYPT_RC4_ #include

密码学级考卷A卷 答案

试题 2015 年~ 2016 年第1 学期 课程名称：密码学专业年级： 2013级信息安全 考生学号：考生姓名： 试卷类型： A卷■ B卷□考试方式: 开卷□闭卷■……………………………………………………………………………………………………… 一. 选择题（每题2分，共20分） 1.凯撒密码是有记录以来最为古老的一种对称加密体制，其加密算法的定义为， 任意，，那么使用凯撒密码加密SECRET的结果是什么（）。 A. UGETGV B. WIGVIX C. VHFUHW D. XIVGIW 2.在一下密码系统的攻击方法中，哪一种方法的实施难度最高的（）。 A. 唯密文攻击 B. 已知明文攻击 C. 选择明文攻击 D. 选择文本攻击 3.仿射密码顺利进行加解密的关键在于保证仿射函数是一个单射函数，即对于 任意的同余方程有唯一解，那么仿射密码的密钥空间大小是（）。（表示中所有与m互素的数的个数） A. B. C. D. 4.为了保证分组密码算法的安全性，以下哪一点不是对密码算法的安全性要求

（）。 A. 分组长度足够长 B. 由密钥确定置换的算法要足够复杂 C. 差错传播尽可能地小 D. 密钥量足够大 5.以下哪一种分组密码工作模式等价于同步序列密码（）。 A. 电码本模式（ECB模式） B. 密码分组链接模式（CBC模式） C. 输出反馈模式（OFB模式） D. 密码反馈模式（CFB模式） 6.以下对自同步序列密码特性的描述，哪一点不正确（）。 A．自同步性 B．无错误传播性 C．抗主动攻击性 D．明文统计扩散性 7.如下图所示的线性移位寄存器，初始值为，请问以下哪 一个选项是正确的输出序列（）。 A． B． C． D． 8.以下关于消息认证码的描述，哪一点不正确（）。 A．在不知道密钥的情况下，难以找到两个不同的消息具有相同的输出 B．消息认证码可以用于验证消息的发送者的身份 C．消息认证码可以用于验证信息的完整性 D．消息认证码可以用于加密消息 9.以下哪些攻击行为不属于主动攻击（）。 A．偷听信道上传输的消息

密码学-RSA加密解密算法的实现课程设计报告

密码学课程报告《RSA加密解密算法》 专业：信息工程（信息安全） 班级：1132102 学号：201130210214 姓名：周林 指导老师：阳红星 时间：2014年1月10号

一、课程设计的目的 当前最著名、应用最广泛的公钥系统RSA是在1978年，由美国麻省理工学院(MIT)的Rivest、Shamir和Adleman在题为《获得数字签名和公开钥密码系统的方法》的论文中提出的。 RSA算法是第一个既能用于数据加密也能用于数字签名的算法，因此它为公用网络上信息的加密和鉴别提供了一种基本的方法。它通常是先生成一对RSA 密钥，其中之一是保密密钥，由用户保存；另一个为公开密钥，可对外公开，甚至可在网络服务器中注册，人们用公钥加密文件发送给个人，个人就可以用私钥解密接受。为提高保密强度，RSA密钥至少为500位长，一般推荐使用1024位。 公钥加密算法中使用最广的是RSA。RSA算法研制的最初理念与目标是努力使互联网安全可靠，旨在解决DES算法秘密密钥的利用公开信道传输分发的难题。而实际结果不但很好地解决了这个难题；还可利用RSA来完成对电文的数字签名以抗对电文的否认与抵赖；同时还可以利用数字签名较容易地发现攻击者对电文的非法篡改，以保护数据信息的完整性。此外，RSA加密系统还可应用于智能IC卡和网络安全产品。 二、RSA算法的编程思路 1.确定密钥的宽度。 2.随机选择两个不同的素数p与q，它们的宽度是密钥宽度的1/2。 3.计算出p和q的乘积n 。 4.在2和Φ(n)之间随机选择一个数e , e 必须和Φ(n)互素，整数e 用做加密密钥（其中Φ(n)=(p-1)*(q-1)）。 5.从公式ed ≡ 1 mod Φ(n)中求出解密密钥d 。 6.得公钥（e ，n ）, 私钥 (d , n) 。 7.公开公钥，但不公开私钥。 8.将明文P (假设P是一个小于n的整数)加密为密文C，计算方法为： C = Pe mod n 9.将密文C解密为明文P，计算方法为：P = Cd mod n 然而只根据n和e（不是p和q）要计算出d是不可能的。因此，任何人都可对明文进行加密，但只有授权用户（知道d）才可对密文解密 三、程序实现流程图： 1、密钥产生模块：

密码学课程设计

信息安全技术应用实践 课程设计报告 设计题目信息的安全传递 专业名称： 班级： 学号： 姓名： 指导教师： 2014年7月

目录 一、引言 (3) 二、设计方案 (3) 1.安全需求 (3) 2.概要设计 (3) 3.详细设计 (5) 三、安全性分析........................................................................................................... 错误！未定义书签。 四、运行结果 (8) 五、总结 (8) 参考文献 (11)

一、引言 对于信息安全问题，经常出现QQ被盗号骗取财物等案件的出现。信息的安全性十分重要，尤其是一些个人的隐私。 人们也越来越重视信息的安全传递，所以设计出一个安全传递信息的系统刻不容缓。所以在此次课程设计我设计了一个信息传递系统，此系统是基于JAVA应用程序开发的，结合密码学的加密算法实现。其主要特性是安全的完成信息的传递。 二、设计方案 1.安全需求 1）.服务器端每一客户口令安全存储（口令保护） 2）.对所有通信内容用分组密码以计数器模式进行加密 3）.对所有的通信内容用认证码（MAC）进行完整性检验 4）.服务器对每个客户进行身份认证 5）.服务器端抗重放攻击 2概要设计 1. (BrokerGUI) 发送代理端代替发送者进行内部操作，它设置了与服务端的共享密钥、实现共享口令的加密密钥的加密、随机密钥的加密，、文件的加密、消息的验证。 工作进程：

假设口令“sharedPwd”为代理与授权服务器共享口令 1）用“sharedPwd”生成加密密钥“K-BC”，以及MAC密钥“K-MAC” 2）随机生成一个密钥“K”；并且用“K”生成一个新的加密密钥“K-temp” 和一个新的MAC密钥“K-MAC-temp”。 3）对输入文件内容进行加密和计算MAC E[ K-temp, file contents ] || MAC[ K-MAC-temp, E[ K-temp, file contents ] ] 4）对新的密钥“K”进行加密和计算MAC E[ K-BC, K ] || MAC[ K-MAC, E[ K-BC, K ] ] 5）输出所有上述信息 2.（BrokerClient） 接收代理端应该设置自己的用户名和密码，且要发防重放的随机数。与服务器端建立通信通道，向服务器端发送加密后的信息。对方接收来自服务器的信息。 相对服务器而言，接收端的任务主要就是保证消息的安全性、保密性、完整性等。 1)用“用户口令”生成加密密钥“K-BC-user”，以及MAC密钥“K-MAC-user1”； 2）接收端提供给服务器 R ||user1 || MAC[ K-MAC-user1, R || user1 ] 这里R是一个随机数，user1为用户名 3）接收端从服务器获得 E[ K-BC-user1, K ] || MAC[ K-MAC-user1, E[ K-BC-user1, K ] ] 解密得“K”，并计算出加密密钥“K-temp”和 一个新的MAC密钥“K-MAC-temp”。 解密和验证“file contents”。 3.AuthorityServer） 服务端实现发送代理端和接收代理端之间的连接，是一个中转站。服务器接受和发送的信息都是加密的，保证了消息的安全性。 服务端实现对了发送代理端的消息认证，实现接收代理端的用户身份认证，对密钥的解密和加密，实现了防重放攻击。 工作进程：