信息安全实验报告.docx

信息安全实验报告.docx

《信息安全实验报告.docx》由会员分享，可在线阅读，更多相关《信息安全实验报告.docx（24页珍藏版）》请在冰豆网上搜索。

信息安全实验报告

中国地质大学

信息安全实验报告

课程名称信息安全实验

教师姓名

学生姓名

学号

专业

所在院系

日期

目录

一、仿射密码3

1）题目分析3

2）算法设计3

3）程序运行截图3

4）程序运行分析5

二、Vigenere（维吉尼亚）密码5

1）题目分析5

2）算法设计5

3）程序运行截图6

4）程序运行分析6

三、Hill（希尔）密码7

1）题目分析7

2）算法设计7

3）程序运行截图8

4）程序运行分析8

四、RSA算法9

1）题目分析9

2）算法设计10

3）程序运行截图10

4）程序运行分析12

五、附件（c源程序代码）13

1）仿射密码13

2）Vigenere密码14

3）Hill密码15

4）RSA算法16

一、仿射密码

1）题目分析

令

，

，

，定义：

这里要求gcd（a,b）=1，否则，加密函数就不是一个单射函数，因此在设计函数时还要设计一个gcd（a,b）函数求a,b的最大公约数，如果求gcd（a,b）=1，说明a和26互素，否则要重新输入a，直到互素为止。

验证：

输入密钥（3,6），明文abc,如果经过仿射密码的加密后得到密文hkn，就可以验证此程序的正确性。

2）算法设计

见附件

3）程序运行截图

注：

如果a与26不互素，则重新输入a，直到与26互素为止

注：

输入明文进行加密验证；

4）程序运行分析

输入密钥（3,6）加密明文abc,经过仿射密码的加密后得到密文hkn，与实际运算的结果保持一致，因此程序运行完全正确。

并且通过此程序能够判断出a与26是否互素，较好地符合题目要求。

二、Vigenere（维吉尼亚）密码

1）题目分析

设

为某个固定的正整数，

分别为明文空间、密文空间、密钥空间，且

，对一个密钥

，定义：

。

这里

为一个明文分组中的

个字母。

所有运算在

中进行。

密钥长度为

，故密钥空间为

。

明文是按照长度为

的分组进行加密的。

在写此算法的时候需要注意的有两个：

（1）不要忘记密钥k和明文

都要进行ASCII码转化才能进行整型数字求和运算；

（2）在最后利用循环输出密文字符时，可以做一个i%m（m为密钥长度）的取余，从而实现密文的分组输出。

验证：

取m=5，密钥字为hello，加密“university”。

明文分组为：

unive,rsity，密文转化为

为：

20,13,8,21,4和17,18,8,19,24。

密钥字实际为k=（7,4,11,11,14），

表示的密文为：

1,17,24,6,18和24,22,19,4,12。

密文字母为brtgs.ywtem.。

如果运行此程序能够实现此明文加密，则可验证此程序的正确性。

2）算法设计

见附件

3）程序运行截图

注：

下截图显示程序实现了密文的分组输出；

4）程序运行分析

输入密钥字hello，以及明文“university”，经过Vigenere的加密后得到密文“brtgs.ywtem”与实际运算的结果保持一致，因此程序运行完全正确。

同时在程序中实现了密文的分组输出，较好地符合题目要求。

三、Hill（希尔）密码

1）题目分析

设

是某个固定的正整数，

分别为明文空间、密文空间、密钥空间，且

，设

是一个

可逆矩阵，（即行列式

，且

）。

对任意密钥

，定义：

在写此算法时要注意的有两点：

（1）如果只要实现加密算法，K可以不是可逆矩阵，但是如果要实现解密算法，则必须要判断K可逆在我的算法中只实现了加密，解密过程基本相似；

（2）输入密钥矩阵K时，此算法采取了按行输入，以免出现混淆；（3）因为要拿明文向量P分段与密钥矩阵K相乘，所以此算法用了一个三层嵌套for循环来实现此加密算法，这也是整个程序最精华的部分。

验证：

取m=2，密钥

，设明文为hill，相应的明文向量为

和

，于是相应的密文向量分别

，

，故密文为xiyj。

如果运行此程序能够实现此明文加密，则可验证此程序的正确性。

2）算法设计

见附件

3）程序运行截图

4）程序运行分析

输入密钥矩阵K[m][m]，以及明文hill，经过Hill密码的加密后得到密文“xiyj”，这与实际运算的结果保持一致，因此程序运行完全正确。

同时在程序中采用三层for循环，实现了明文向量P分段左乘密钥矩阵K[m][m]，并且得到正确的密文，较好地符合了题意。

四、RSA算法

1）题目分析

RSA方案分为密钥生成，加密过程，解密过程，签名生成和签名验证5个步骤。

首先我们要输入两个素数p,q.并通过n=p*q,以及fn=（p-1）*（q-1）,计算出n和n的欧拉函数fn。

再输入一个满足条件1

然后根据这些数据求出私钥d,使其满足（d*e）modfn=1modfn成立。

最后再用这些d,e,p,q,n这些数据，利用相应的模幂运算可进行加密、解密，以及签名生成和验证的所有过程。

在写这个大算法时，需要注意的有3点：

（1）在此算法中，我设计了一个求最大公约数的函数gcd（a,b）并利用while循环，用来判断e和fn是否互素，且可以连续输入直到互素为止；设计函数Judge（a）用来判断输入的p,q是否是素数，如果不是素数则退出程序；

（2）在此算法中，我利用switch,case语句进行RSA加密和解密的选择；（3）在此算法中，我设计了一个模幂函数mi_mod（a,b,h）,循环b次对h求模，可以得到a^bmodh，这个函数在加密、解密，以及签名生成和验证的函数中都是最重要的元素；

验证：

输入两个素数p,q，即可以利用程序求出公钥e,私钥d以及n。

在加密时输入明文m=24,经过加密后可以得到c=7，在解密时输入密文c=7，经过解密可以得到明文m=24。

在签名生成、验证时，输入签名消息m=36可以得到签名s=82，并且签名验证结果为m=（s^e）mod（n），则说明签名有效。

如果运行此程序能够实现上述所有的算法过程，则可验证此程序的正确性。

2）算法设计

见附件

3）程序运行截图

注：

下截图显示若输入的不是素数，则程序会自动终止；

注：

重新输入两个素数p,q为11,13；

注：

下截图显示当输入公钥e和fn不互素时，程序会提醒重新输入；

注：

正确输入e=17和fn互素；

注：

下截图显示当输入1时，可进入系统加密阶段；

注：

下截图显示当输入2时，可进入系统解密阶段；

注：

进入数字签名算法界面；

4）程序运行分析

正确输入p=11,q=13后，可以通过程序得到正确的d,e,fn,n。

并且可以准确的加密，解密，签名生成以及验证。

同时进行了e和fn是否互素的判断，以及p,q是否互素的判断，较好地符合了题意。

五、附件（c源程序代码）

1）仿射密码

#include

#include

voidmain（）

{

inta,b,i,L,m,s[100];

chart1[100],t2[100];//定义两个字符数组存储明文和密文

intgcd（inta,intb）;//声明求最大公约数的函数

printf（"*******欢迎进入石博同学设计的仿射密码算法界面********\n"）;

printf（"请输入仿射密钥：

a,b:

"）;

scanf（"%d%d",&a,&b）;

while

（1）//判别a和26是否互素

{

gcd（a,26）;//求a和26的最大公约数

if（gcd（a,26）==1）

{printf（"经判断a和26互素\n"）;break;}

else

printf（"a和26不互素，重新输入一次a:

"）;//如果不互素，则重新输入

scanf（"%d",&a）;

}

printf（"请输入要加密的明文：

"）;//输入明文

scanf（"%s",t1）;

for（i=0;t1[i]!

='\0';i++）//用整型数组存储明文所对应的ASCII代码

{

s[i]=t1[i]-96;

}

s[i]=0;

L=strlen（t1）;//求出明文长度

printf（"明文长度L为：

"）;

printf（"%d\n",L）;

printf（"加密密文为：

"）;

for（i=0;i

{

m=（s[i]*a+b）%26;

t2[i]=m+96;

}

t2[i]='\0';

puts（t2）;//输出加密后的密文

printf（"*********仿射密码算法到此结束，谢谢您的使用!

*********\n"）;

}

intgcd（inta,intb）//定义求最大公约数的函数

{

if（b==0）return（a==1）;

elsegcd（b,a%b）;

}

2）Vigenere密码

#include

#include

voidmain（）

{

intm,i,t[100];

charP[100],k[26],C[100];

printf（"******欢迎进入石博同学设计的Vigenere密码算法界面******\n"）;

printf（"输入密钥K为：

"）;//输入密钥k

scanf（"%s",k）;

printf（"请输入明文:

"）;//输入明文P

scanf（"%s",P）;

m=strlen（k）;//求出密钥长度

printf（"密钥长度为：

%d\n",m）;

for（i=0;P[i]!

='\0';i++）//对明文进行加密

{

t[i]=（P[i]+k[i%m]-97*2）%26;

C[i]=t[i]+97;

}

C[i]='\0';

printf（"请输出密文：

"）;//分段输出加密后的密文

for（i=0;P[i]!

='\0';）

{

printf（"%c",C[i]）;

i++;

if（（i%m）==0）printf（"—"）;

}

printf（"\n"）;

printf（"********Vigenere密码算法到此结束，谢谢您的使用!

*********\n"）;

}

3）Hill密码

#include

#include

voidmain（）

{

intm,n,s=0,i,j,k,x[100],t[100],K[100][100];

charP[100],C[100];

printf（"********欢迎进入石博同学设计的Hill密码算法界面*********\n"）;

printf（"\n"）;

printf（"请输入密钥矩阵的维度m：

"）;//输入密钥矩阵的维度m

scanf（"%d",&m）;

printf（"请输入密钥矩阵K[m][m]:

"）;//按行输入可逆的密钥矩阵K[m][m]

for（i=0;i

{

for（j=0;j

{

scanf（"%d",&K[i][j]）;

}

}

printf（"请输入明文:

"）;//输入要加密的明文

scanf（"%s",P）;

n=strlen（P）/m;//求出明文以维度m为单位的分段段数

for（i=0;P[i]!

='\0';i++）//把明文由字符数组转换为整型数组

{

t[i]=P[i]-97;

}

t[i]=0;

for（k=0;k

{

for（j=0;j

{

for（i=0;i

{

s=s+t[i+k*m]*K[i][j];//左乘后得到一段明文中单个字符的加密值

}

x[j+k*m]=s%26;//依次保存一段明文中单个字符的加密值

i=0;

s=0;

}

}

x[j+（k-1）*m]=0;//把密文数组的最后一个数字设置为0.

for（j=0;x[j]!

=0;j++）//把密文转换为字符型

{

C[j]=x[j]+97;

}

C[j]='\0';

printf（"输出密文：

"）;

puts（C）;

printf（"\n"）;

printf（"**********Hill密码算法到此结束，谢谢您的使用!

**********\n"）;

}

4）RSA算法

#include

#include

intm,n;//定义两个全局变量

voidmain（）

{

intp,q,d,e,fn,s,A;

intJudge（inta）;//声明素数判别函数

intgcd（inta,intb）;//声明求最大公约数的函数

intmi_mod（inta,intb,inth）;//声明模幂函数

intniyuan（intn,intu）;//求e的逆元d的函数

voidRSAEnc（inte1,intn1）;//声明加密算法

voidRSADec（intd1,intn1）;//声明解密算法

intRSASign（intm,intd）;//输入消息m，签名密钥d，输出签名s

intRSAVerify（ints,inte）;//输入签名s,验证签名是否有效

printf（"***********欢迎进入石博同学设计的RSA算法界面***********\n"）;

printf（"请分别输入两个素数p,q：

"）;

scanf（"%d%d",&p,&q）;

printf（"分别判断p,q是不是素数：

\n"）;//判断p,q是否为素数

if（Judge（p）==0）//如果不是素数，则退出程序

return;

if（Judge（q）==0）//如果不是素数，则退出程序

return;

n=p*q;

fn=（p-1）*（q-1）;//求出n的欧拉函数

printf（"随机输入一个大于1小于fn的整数e:

"）;

while

（1）//输入e直到e和fn互素

{

scanf（"%d",&e）;

gcd（e,fn）;//求e和fn的最大公约数

if（gcd（e,fn）==1）

{printf（"经判断e和fn互素\n"）;break;}

else

printf（"e和fn不互素，重新输入一次e:

"）;

}

d=niyuan（fn,e）;//求e的逆元

printf（"且公钥（e,n）为：

%d,%d;私钥d为：

%d\n\n",e,n,d）;

printf（"**************下面进入RSA加密、解密算法界面**************\n"）;

printf（"请输入1或者2,1代表加密，2代表解密:

"）;

while

（1）//选择进行RSA加密或者解密

{

scanf（"%d",&A）;

switch（A）

{

case1:

RSAEnc（e,n）;break;//使用公钥e,n加密

case2:

RSADec（d,n）;break;//使用私钥d,n解密

default:

printf（"输入错误，请重新选择:

"）;break;

}

if（A==1||A==2）

break;

elsecontinue;

}

printf（"\n"）;

printf（"**************下面进入RSA数字签名算法界面***************\n"）;

printf（"输入待签名的消息m:

"）;

scanf（"%d",&m）;

s=RSASign（m,d）;//得到签名s

RSAVerify（s,e）;//输入签名s,验证签名是否有效

printf（"*************RSA算法到此结束，谢谢您的使用!

**************\n"）;

}

intJudge（inta）//定义素数判别函数

{

intj,s;

for（j=2;j<=sqrt（a）;j++）

{

s=a%j;

if（s==0）{printf（"不是素数,输入错误!

\n"）;return0;}

}

printf（"是素数，输入正确!

\n"）;

return1;

}

intgcd（inta,intb）//定义求最大公约数的函数

{

if（b==0）return（a==1）;

elsegcd（b,a%b）;

}

intniyuan（intn,intu）//定义求逆元d的函数

{

intn1=n;

intn2=u;

intb1=0;

intb2=1;

intq=n1/n2;

intr=n1-q*n2;

while（r!

=0）

{

n1=n2;

n2=r;

intt=b2;

b2=b1-q*b2;

b1=t;

q=n1/n2;

r=n1-q*n2;

}

if（n2!

=1）return0;

elsereturn（b2+n）%n;

}

intmi_mod（inta,intb,inth）//定义模幂函数,r=（a^b）mod（h）

{

intr=1;

b=b+1;

while（b!

=1）//r对h进行b次循环的求模，

{

r=r*a;

r=r%h;

b--;

}

returnr;

}

voidRSAEnc（inte1,intn1）//定义加密算法

{

intm,c;

printf（"请输入要加密的明文m:

"）;//输入整型的明文

scanf（"%d",&m）;

c=mi_mod（m,e1,n1）;

printf（"加密得到密文c:

"）;

printf（"%d\n",c）;

}

voidRSADec（intd1,intn1）//定义解密算法

{

intm,c;

printf（"请输入要解密的密文c:

"）;//输入整型的密文

scanf（"%d",&c）;

m=mi_mod（c,d1,n1）;

printf（"解密得到明文m:

"）;

printf（"%d\n",m）;

}

intRSASign（intm,intd）//输入整数消息m，签名密钥d，输出签名s

{

ints;

s=mi_mod（m,d,n）;//对签名消息m进行求模运算得到签名s

printf（"由消息生成签名s:

"）;

printf（"%d\n",s）;

returns;

}

intRSAVerify（ints,inte）//验证签名是否有效

{

if（m==mi_mod（s,e,n））

printf（"m=（s^e）mod（n），故签名有效\n"）;

elseprintf（"m!

=（s^e）mod（n）签名无效"）;

return0;

}