电子商务信息安全实验报告.docx
《电子商务信息安全实验报告.docx》由会员分享，可在线阅读，更多相关《电子商务信息安全实验报告.docx（19页珍藏版）》请在冰豆网上搜索。
电子商务信息安全实验报告
电子商务中的信息安全
实验报告
实验一
实验要求：
用VisualC++或者JAVA实现下述电子支付安全的一些原理，对电子支付的加密过程、解密过程、防火墙等基本原理做出仿真。
实验内容：
一、编程实现棋盘密码的加密和解密过程，实现如下功能：
（1）从键盘输入明文，要求在屏幕上显示对应的密文；
由于程序中i，j在同一个位置上，而我是采用英文的明文输入，经查证英文中字母z不经常使用，故将字母中z省去
程序如下：
importjava.util.*;
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
publicclasspassword{
publicstaticvoidmain（Stringargs[]）{
char[][]a=
{
{'A','B','C','D','E'},
{'F','G','H','I','J'},
{'K','L','M','N','O'},
{'P','Q','R','S','T'},
{'U','V','W','X','Y'}
};//定义一个字符数组存储所需字母
Stringdd="";
BufferedReaderin=newBufferedReader（newInputStreamReader（System.in））;
try{
System.out.print（"请输入明文：
"）;
Stringdata=in.readLine（）;//读取明文
intu=data.length（）;//获得明文的长度
Stringdata1=data.toUpperCase（）;//将明文无论大小写一律转化成大写
System.out.print（"对应的密文是：
"）;
for（intk=0;kcharc=data1.charAt（k）;//获取明文对应的各位字母
for（inti=0;i<5;i++）{
for（intj=0;j<5;j++）{
if（c==a[i][j]）{
Stringg=Integer.toString（i+1）;
Stringh=Integer.toString（j+1）;
dd+=（g+h）;//将明文字母所对应的数组下标分别加一，在将两个下标加到一块组成字符串
}
}
}
}
System.out.print（dd）;//输出对应的密文
}
catch（IOExceptione）{
e.printStackTrace（）;
}
}
}
程序运行结果如下：
（2）从键盘输入密文，要求在屏幕上显示对应的明文；
程序将密文分成两个字符一组的字符串，并找到其对应的数组下标，进而求得明文，程序代码如下：
importjava.util.*;
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
publicclasspassword2{
publicstaticvoidmain（Stringargs[]）{
char[][]a=
{
{'A','B','C','D','E'},
{'F','G','H','I','J'},
{'K','L','M','N','O'},
{'P','Q','R','S','T'},
{'U','V','W','X','Y'}
};
BufferedReaderin=newBufferedReader（newInputStreamReader（System.in））;
try{
System.out.print（"输入密文：
"）;
Stringdata=in.readLine（）;//获取键盘输入的密文
intu=data.length（）;//获取密文的长度
Strings="";//定义空字符串
for（intk=0;kStringdata1=data.substring（k,k+2）;//循环获取两个密文字符并赋值给data1
k++;
intdata3=Integer.parseInt（data1）;
intdata4=data3%10-1;//获取数组下标
intdata5=data3/10-1;//获取数组下标
s=s+a[data5][data4];//将数组对应的字符加到s中
s=s.toLowerCase（）;//将s转化成小写形式
}
System.out.println（"对应的明文是:
"+s）;
}
catch（IOExceptione）{
e.printStackTrace（）;
}
}
}
程序运行结果如下：
明文是：
attackattwopm
二、编程实现置换密码的加密过程，实现如下功能：
（1）.键盘输入明文和密钥，要求在屏幕上输出密文；
程序先将明文和密钥存储在一个n行七列的数组中，n的数值由明文加密钥的字符串长度决定，程序中的密钥是1,2,3,4,5,6,7这七个数的任意排序，程序中若明文加密钥的长度不能被7整除，则将用z补充剩余的字符，使其可被整除
程序代码如下：
importjava.util.*;
importjava.io.*;
publicclasschange1{
publicstaticvoidmain（Stringargs[]）throwsIOException{
BufferedReaderin=newBufferedReader（newInputStreamReader（System.in））;
try
{
System.out.print（"请输入明文:
"）;
Stringdata=in.readLine（）;
introws1=0;//明文的行数
System.out.print（"请输入七位密钥:
"）;
Stringdata1=in.readLine（）;
intlength1=data1.length（）;
Stringdata3=data1+data;//将明文与密钥合并，且密钥在前
intlength=data3.length（）;
introws=length%7;//判断最后一行是否满行
if（rows!
=0）{
rows1=length/7+1;
for（inti=0;i<7-rows;i++）
{
data3=data3+"z";//若字符串长度不是7的倍数则补充z使其是7的倍数
}
}
else{
rows1=length/7;
}
String[][]data2=newString[rows1][7];//创建一个字符串数组，用来存储明文和密钥
for（inti=0;i{
for（intj=0;j<7;j++）
{
data2[i][j]=String.valueOf（data3.charAt（j+i*7））;//将合并后的字符串赋给数组
}
}
Strings1="";
Strings2="";
Strings3="";
Strings4="";
Strings5="";
Strings6="";
Strings7="";
Strings="";
for（inti=0;i<7;i++）
{
if（data2[0][i].equals（"1"））
{
for（intj=1;js1=s1+data2[j][i];
}
elseif（data2[0][i].equals（"2"））
{
for（intj=1;js2=s2+data2[j][i];
}
elseif（data2[0][i].equals（"3"））
{
for（intj=1;js3=s3+data2[j][i];
}
elseif（data2[0][i].equals（"4"））
{
for（intj=1;js4=s4+data2[j][i];
}
elseif（data2[0][i].equals（"5"））
{
for（intj=1;js5=s5+data2[j][i];
}
elseif（data2[0][i].equals（"6"））
{
for（intj=1;js6=s6+data2[j][i];
}
elseif（data2[0][i].equals（"7"））
{
for（intj=1;js7=s7+data2[j][i];
}
}
s=s1+s2+s3+s4+s5+s6+s7;//将对应列所得的字符串连接起来
System.out.println（"密文是：
"+s）;//输出加密后的密文
}
catch（IOExceptione）{
e.printStackTrace（）;
}
}
}
程序运行结果如下：
（2）.键盘输入明文和密文，要求在屏幕上输出密钥；
程序就是上面的程序的逆过程，只是若程序中密文字符串不能被7整除，缺少的部分一定要加z作为补充，程序代码如下：
importjava.util.*;
importjava.io.*;
publicclasschange2{
publicstaticvoidmain（Stringargs[]）throwsIOException{
BufferedReaderin=newBufferedReader（newInputStreamReader（System.in））;
try
{
System.out.print（"请输入明文:
"）;//明文长度是七的倍数，若不是补充z代替
Stringdata=in.readLine（）;
intlength1=data.length（）;//明文长度
introws=length1/7;//明文所需要的行数
System.out.print（"请输入密文:
"）;
Stringdata1=in.readLine（）;//输入密文
intlength2=data1.length（）;
Strings[]=newString[7];
Stringb[]=newString[7];
Stringa[]=newString[7];
for（inti=0;i<7;i++）
{
b[i]="";
}
for（inti=0,j=0;i<7;i++,j++）
{
s[i]=data1.substring（j,j+rows）;//将密文按rows个数存放进s数组中，刚好有七个元素
j++;
}
for（inti=0;i{
for（intj=0;j<7;j++）
{
b[j]+=String.valueOf（data.charAt（j+i*7））;//将明文按密钥的法则变成七个元素放进b数组中
}
}
for（inti=0;i<7;i++）
{
for（intj=0;j<7;j++）
{
if（s[i].equals（b[j]））
{
a[j]=Integer.toString（i+1）;//将密钥转换成字符串，并按照相应的顺序放入a数组中，j表示的就是相应的密钥所在的位置
}
}
}
Stringh="";
for（inti=0;i<7;i++）
{
h+=a[i];
}
System.out.println（"加密的密钥是:
"+h）;//将密钥按照从零到七的顺序相加便得到所要的密钥
}
catch（IOExceptione）{
e.printStackTrace（）;
}
}
}
程序运行结果如下：
（3）.键盘输入密文和密钥，要求在屏幕上输出明文；
程序跟上面两个程序类似，程序代码如下：
importjava.util.*;
importjava.io.*;
publicclasschange3{
publicstaticvoidmain（Stringargs[]）throwsIOException{
BufferedReaderin=newBufferedReader（newInputStreamReader（System.in））;
try
{
System.out.print（"请输入密文:
"）;//密文长度是七的倍数
Stringdata=in.readLine（）;
intlength1=data.length（）;//密文
introws=length1/7;//明文所需要的行数
System.out.print（"请输入密钥:
"）;
Stringdata1=in.readLine（）;//输入密钥
intlength2=data1.length（）;
ints[]=newint[7];
for（inti=0;i<7;i++）
{
s[i]=Integer.parseInt（String.valueOf（data1.charAt（i）））;//将密钥转化成数字形式，并存入s数组中
}
Stringb[]=newString[7];
for（inti=0,j=0;i<7;i++,j++）
{
b[i]=data.substring（j,j+rows）;//将密文按rows个数存放进b数组中，刚好有七个元素
j++;}
Stringh="";
for（intk=0;k{
for（inti=0;i<7;i++）
{
intj=s[i];
h+=String.valueOf（b[j-1].charAt（k））;//b数组中七个元素的对应位的字符相加，并转化为相应的字符串再相加，即得明文
}
}
System.out.println（"对应的明文是:
"+h）;}
catch（IOExceptione）{
e.printStackTrace（）;
}
}
}
运行结果如下：
三、编程模拟密码攻击的过程，实现下述功能：
（1）.键盘输入12位密码，包括字母和数字；
（2）.采用穷举法进行攻击，直到破解密码为止，记录破解的时间；
（3）.将12位密码改为13位，14位，15位，分别进行破解实验，记录并比较破解时间，总结其中的规律。
此程序若采用穷举法，即将所有的十二位密码输出再比较效率太低，且运行时间太久，我采用的是将密码各位与组成密码的字符逐个比较，进而得到相应的密码，程序代码如下：
importjava.util.*;
importjava.io.*;
publicclassattack1{
publicstaticvoidmain（Stringargs[]）throwsIOException{
Calendarcalendar=newGregorianCalendar（）;
longstart=calendar.getTimeInMillis（）;
System.out.println（"MILLISECONDStart:
"+start）;
BufferedReaderin=newBufferedReader（newInputStreamReader（System.in））;
try
{
System.out.print（"请输入密码：
"）;
Stringdata=in.readLine（）;
Stringgg="";
Strings[]={"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","0","1","2","3","4","5","6","7","8","9"};
for（intj=0;j<12;j++）
{
for（inti=0;i<62;i++）
{
if（String.valueOf（data.charAt（j））.equals（s[i]））
gg=gg+s[i];}}
System.out.println（"密码是：
"+gg）;}
catch（IOExceptione）{
e.printStackTrace（）;}
Calendarcalendar1=newGregorianCalendar（）;
longend=calendar1.getTimeInMillis（）;
longc=end-start;
System.out.println（"MILLISECOND:
"+end）;
System.out.println（"运行时间:
"+c+"ms"）;}}
若是十二位密码时运行时间如下：
若是十三位密码时运行时间如下：
若是十四位密码时运行时间如下：
若是十五位密码时运行时间如下：
从时间上看随着密码的位数增加，检测所用的时间总体上是增加的，但也会根据密码组成字符所排列的顺序有关。
实验二
四、模拟查杀病毒的过程，实现下述功能：
（1）.产生一个1000维的数组作为“文件”，产生1-1000中的10个随机数，这十个随机数所对应的“文件”含有病毒；
（2）.每个文件的查毒时间和杀毒时间是[10-7s,10-5s]上的一个随机数；
（3）.查杀所有的病毒，直至全部的10个病毒均被发现未知，屏幕输出受感染的“文件”；
（4）.重复运行10次，记录每次的运行时间。
程序首先产生一个1000维的数组a，存储1-1000这一千个数，然后再产生1-1000中的十个随机数并将其存到数组b中，检查产生的十个数，要使他们各不相同，将查出的病毒文件存储到数组中，并将a数组中相应的病毒文件删除。
但由于操作系统时间只能精确到10ms，故10-5s这个数量级无法精确到，又由于每次产生的病毒都不一样，故无法采用多次循环得到精确时间的方法。
程序代码如下：
importjava.util.*;
publicclassff{
publicstaticvoidmain（Stringargs[]）{
Calendarcalendar=newGregorianCalendar（）;
longstart=calendar.getTimeInMillis（）;
System.out.println（"MILLISECONDStart:
"+start）;
inta[]=newint[1000];
intb[]=newint[10];
intc[]=newint[10];
intadd=0;//用于记录病毒数目
for（inti=0;i<1000;i++）
{
a[i]=i+1;
}
for（inti=0;i<10;i++）{
b[i]=（int）（Math.random（）*1000）;
for（intj=0;j{
while（b[i]==b[j]）{
b[i]=（int）（Math.random（）*1000）;//防止产生的随机数重复，若重复则重新产生，直至产生不重复的数
}
}
}
for（inti=0;i<10;i++）
{
for（intj=0;j<1000;j++）
{
if（b[i]==a[j]）
{
c[add]=b[i];
add++;
for（intk=j;k<1000-add;k++）
{
a[k]=a[k+1];//删除病毒，将数组整体前移一位
}
a[1000-add]='\0';//给数组最后一位赋值
}
}
}
System.out.println（"被感染的病毒文件是:
"）;
for（inti=0;i<10;i++）
{
System.out.print（c[i]+""）;
}
System.out.print（'\n'）;
Calendarcalendar1=newGregorianCalendar（）;
longend=calendar1.getTimeInMillis（）;
longg=（end-start）;
System.out.println（"MILLISECONDEnd:
"+end）;
System.out.println（"运行时间:
"+g+"ms"）;
}
}
十次运行结果如下：
其他结果就不详细列出了，因为程序运行时间过快，时间有时无法精确，很多显示的是0ms，就是因为其运行时间小于10ms的原因。
五、模拟RSA算法
（1）.寻找1010~1010+1010之间的所有素数，屏幕输出他们的个数；
程序如下：
publicclasssushu
升级会员 