数学基础与密码学部分实验重要内容.doc

数学基础与密码学部分实验内容

一、 信息安全数学基础实验部分

题目：定理：设n是一个正整数，如果对所有的素数p≤,都有płn,则n一定是素数。
注：古希腊数学家埃拉托斯散(Eratosthenes，公元前275—公元前194)发明了求
比某给定数小的素数的筛法技巧。
方法如下：
对于任意给定的正整数N，要求出所有不超过N的素数。我们列出N个整数，从中删除小于等于的所有素数p1,…,pk的倍数。然后依次删除，
p1的倍数：2p1,…, p1。。。。。。。。。。。。。。。。。。。。。。。。。。pk的倍数：2pk,…, pk
余下的整数（不包括1）就是所要求的不超过N的素数。
使用VC++编程语言编写一个可测定不超过1，000，000的素数判定程序。
1、 程序设计思想：
有题目所给定的定理我们可以采用：首先将整数N下对应的小于所有的素数尽，则通过的倍数比不为素数，并将此种类型的整数提出后，最终只剩下素数输出到屏幕上。
2、 程序流程图：
3、 程序源代码：
#include
int prime(int m)
{
int n,i;
n=m/2;
for(i=2;i<=n;i++)
if(m%i==0)
return 0
return 1;
}
int main(void)
{
int k;
for(k=2;k<=1000000;k++)
if(prime(k)) printf("%d ",k);
return 0;
}
程序运行截图：

题目二 ：
使用VC++编程语言设计实现一个算法程序库，要求包括以下部分：
1）欧几里德算法求a，b的最大公倍数；
2）扩展的欧几里德算法，求出gcd(a,b)和满足gcd(a,b)=ax+by的整数x和y；
3）求解模线性方程 ax ≡ b (mod n) 其中n>0；
4）求解模线性方程组(中国余数定理)；
5）模取幂运算，计算ab mod n （a,b>1032）；
6）Miller-Rabin随机性素数测试算法（要求判定n>1016）；
1）欧几里德算法求a，b的最小公倍数；
程序设计思想：
采用欧几里得思想的推论，两个整数的积相乘并除以他们的最大公约数可以求出这两个整数的最小公倍数。
程序流程图：
程序源代码：
#include"stdio.h"
int main()
{
int a,b,c;
printf("请依次输入两个数：\n");
scanf("%d %d",&a,&b);
int a_cup, b_cup, res; /*被除数, 除数, 余数*/
if (a > 0 && b >0)
{
a_cup = a;
b_cup = b;
res = a_cup % b_cup;
while (res != 0)
{
a_cup = b_cup;
b_cup = res;
res = a_cup % b_cup;
}
c=a*b/b_cup;
}
printf("%d\n",c);
return 0;
}
运行结果：

2）扩展的欧几里德算法，求出gcd(a,b)和满足gcd(a,b)=ax+by的整数x和y；
#include
int x,y,q;
void extend_Eulid(int a,int b)
{
if(b == 0)
{
x = 1;y = 0;q = a;
　　 }
　 else
　　 {
　　 extend_Eulid(b,a%b);
int temp = x;
　　 x = y;
　　 y temp - a/b*y;
}
}
int main()
{
int a,b;
printf("Please input two numbers:");
scanf("%d %d",&a,&b);
if(a0；
源代码：
#includetream>
#include
#include
using namespace std;
#include"BigNum.h"

BigNum gcd(BigNum x,BigNum y) //递归法求最大公约数
{
BigNum z;
z="0";
if (y==z)
return x; //递归出口
else
return gcd(y,x%y); //递归调用
}
BigNum QiuNi(BigNum a,BigNum m) //求逆
{
BigNum r0,r1,r2,s0,s1,s2,t0,t1,t2,q,x,y;
x="0";y="1";
r0=a,r1=m;
s0="1",t1="1",s1="0",t0="0";
while(r1!=x)
{
q=r0/r1;
r2=r0%r1;
s2=s0-q*s1;
t2=t0-q*t1;
s0=s1,s1=s2;
t0=t1,t1=t2;
r0=r1,r1=r2;
}
if(r0==y)
{
if(!a.s&&s0.s)
{
s0=m+s0;
return s0;
}
else if(!a.s&&!s0.s) return s0;
else if(a.s&&s0.s)
{
return s0;
}
else if(a.s&&!s0.s)
{
s0=s0-m;
return s0;
}
}
else return x;

}
void main()
{
BigNum a,b,m,p,q,s,t;
char x[100],y[100],z[100];
while(1) //控制多次输入
{
cout<<"input a,b,m:"<>x>>y>>z;
s="0";t="1";
a=x;b=y;m=z;
p=gcd(a,m); //求（a,m）
q=QiuNi(a/(p),m/(p)); //求（a/((a,m) )）的逆(a/((a,m) ))^(-1)
if(b%p==s) //判断是否有解，有解输出解的情况
{
cout<<"解得："< ((b/p*q)%(m/p)).CoutBigNum();
cout<<"+";
(m/p).CoutBigNum();
cout<<"t(mod";
m.CoutBigNum();
cout<<") t=0,...,";
(p-t).CoutBigNum();
cout<<"."<1032）；
源代码：
#include
#include
#include
using namespace std;
#include"BigNum.h"
#define MAX 100
main()
{
BigNum f,r,s,b2,c1,c2,b1[500],c3,c4;
char a[MAX]={'\0'},b[MAX]={'\0'},m[MAX]={'\0'};
int i=0,j=0,t=0;
while(1)
{
cout<<"input a,b:"<n>>a>>b;
cout<<"input n:"<>m;
b2=b;s=m;f="1";c1="2";c2="0";c4="1";r=a;
for(i=0;i<500;i++)b1[i]="0"; //十进制转换成二进制
i=0;
while(b2!=c2)
{
b1[i]=b2%c1;
b2=b2/c1;
i++;
}
t=i;
for(j=0;j<(t-1)/2;j++)
{
c3=b1[j];
b1[j]=b1[t-1-j];
b1[t-1-j]=c3;
}
for(i=0;irime
{
private:
public:
int Btest(int a,int n);
int MillRab(int n);
int RepeatMillRab(int n,int k);
};
int judge_prime:: Btest(int a,int n)
{
int s=0;
int t=n-1;
int i=1;
int x=1;
int y;
do
{
s++;
t=t/2;
}while((t%2)!=1);
while(i<=t)
{
x=(x*a)%n;
i++;
}
if((x==1)||(x==n-1))return 1;
for(int j=1;j<=s-1;j++)
{
y=1;
for(int k=1;k<=j;k++)
{
y=2*y;
}
i=1;
x=1;
while(i<=(y*t))
{
x=(x*a)%n;
i++;
}
if(x==n-1)return 1;
}
return 0;
}
int judge_prime::MillRab(int n)
{
int a;
srand((unsigned)time(0));
a=rand()%(n-3)+2;
return Btest(a,n);
}
int judge_prime::RepeatMillRab(int n,int k)
{
int i;
for(i=1;i<=k;i++)
{
if(MillRab(n)==0)return 0;
}
return 1;
}
int main()
{
int i;
int n=10000;
int result=0;
cout<<2<<" "<<3<<" ";
for(i=5;i<=n;)
{
judge_prime P;
if(P.RepeatMillRab(i,(int)log10(i)))
cout<o.h"
#include "memory.h"
#include "time.h"
#include "stdlib.h"

#define PLAIN_FILE_OPEN_ERROR -1
#define KEY_FILE_OPEN_ERROR -2
#define CIPHER_FILE_OPEN_ERROR -3
#define OK 1

typedef char ElemType;

//下面是变量的声明

//初始置换表IP
int IP_Table[64] = { 57,49,41,33,25,17,9,1,
59,51,43,35,27,19,11,3,
61,53,45,37,29,21,13,5,
63,55,47,39,31,23,15,7,
56,48,40,32,24,16,8,0,
58,50,42,34,26,18,10,2,
60,52,44,36,2820,12,4,
62,54,46,38,30,22,14,6};
//逆初始置换表IP^-1
int IP_1_Table[64] = {39,7,47,15,55,23,63,31,
38,6,46,14,54,22,62,30,
37,5,45,13,53,21,61,29,
36,4,44,12,52,20,60,28,
35,3,43,11,51,19,59,27,
34,2,42,10,50,18,58,26,
33,1,41,9,49,17,57,25,
32,0,40,8,48,16,56,24};

//扩充置换表E
int E_Table[48] = {31, 0, 1, 2, 3, 4,
3, 4, 5, 6, 7, 8,
7, 8,9,10,11,12,
11,12,13,14,15,16,
15,16,17,18,19,20
19,20,21,22,23,24,
23,24,25,26,27,28,
27,28,29,30,31, 0};

//置换函数P
int P_Table[32] = {15,6,19,20,28,11,27,16,
0,14,22,25,4,17,30,9,
1,7,23,13,31,26,2,8,
1812,29,5,21,10,3,24};

//S盒
int S[8][4][16] =//S1
{{{14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7},
{0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8},
{4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0},
{15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13}}
//S2
{{15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10},
{3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5},
{0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15},
{13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9}},
//S3
{{10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8},
{13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1},
{13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7},
{1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12}},
//S4
{{7,13,14,3,0,6,9,10,1,2,8,5,1112,4,15},
{13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9},
{10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4},
{3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14}},
//S5
{{2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9},
{14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6},
{4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14},
{11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3}},
//S6
{{12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11},
{10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8},
{9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6},
{4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13}},
//S7
{{4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1},
{13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6},
{1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2},
{6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12}},
//S8
{{13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7},
{1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2},
{7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8},
{2,1,14,74,10,8,13,15,12,9,0,3,5,6,11}}};
//置换选择1
int PC_1[56] = {56,48,40,32,24,16,8,
0,57,49,41,33,25,17,
9,1,58,50,42,34,26,
18,10,2,59,51,43,35,
62,54,46,38,30,22,14,
6,61,53,45,37,29,21,
13,5,60,52,44,36,28,
20,12,4,27,19,11,3};

//置换选择2
int PC_2[48] = {13,16,10,23,0,4,2,27,
14,5,20,9,22,18,11,3,
25,7,15,6,26,19,12,1,
40,51,30,36,46,54,29,39,
50,44,32,46,43,48,38,55,
33,52,45,41,49,35,28,31};

//对左移次数的规定
int MOVE_TIMES[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};

//下面是函数的声明：

int ByteToBit(ElemType ch,ElemType bit[8]);
int BitToByte(ElemType bit[8],ElemType *ch);
int Char8ToBit64(ElemType ch[8],ElemType bit[64]);
int Bit64ToChar8(ElemType bit[64],ElemType ch[8]);
int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]);
int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]);
int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]);
int DES_ROL(ElemType data[56], int time);
int DES_IP_Transform(ElemType data[64]);
int DES_IP_1_Transform(ElemType data[64]);
int DES_E_Transform(ElemType data[48]);
int DES_P_Transform(ElemType data[32]);
int DES_SBOX(ElemType data[48]);
int DES_XOR(ElemType R[48], ElemType L[48],int count);
int DES_Swap(ElemType left[32],ElemType right[32]);
int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]);
int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48], ElemType plainBlock[8]);
int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile);
int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile);

//字节转换成二进制
int ByteToBit(ElemType ch, ElemType bit[8]){
int cnt;
for(cnt = 0;cnt < 8; cnt++){
*(bit+cnt) = (ch>>cnt)&1;
}
return 0;
}

//二进制转换成字节
int BitToByte(ElemType bit[8],ElemType *ch){
int cnt;
for(cnt = 0;cnt < 8; cnt++){
*ch |= *(bit + cnt)<ToBit(*(ch+cnt),bit+(cnt<<3));
}
return 0;
}

//将二进制位串转为长度为8的字符串
int Bit64ToChar8(ElemType bit[64],ElemType ch[8]){
int cnt;
memset(ch,0,8);
for(cnt = 0; cnt < 8; cnt++){
BitToByte(bit+(cnt<<3),ch+cnt);
}
return 0;
}

//生成子密钥
int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]){
ElemType temp[56];
int cnt;
DES_PC1_Transform(key,temp);//PC1置换
for(cnt = 0; cnt < 16; cnt++){//16轮跌代，产生16个子密钥
DES_ROL(temp,MOVE_TIMES[cnt]);//循环左移
DES_PC2_Transform(temp,subKeys[cnt]);//PC2置换，产生子密钥
}
return 0;
}

//密钥置换1
int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]){
int cnt;
for(cnt = 0; cnt < 56; cnt++){
tempbts[cnt] = key[PC_1[cnt]];
}
return 0;
}

//密钥置换2
int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]){
int cnt;
for(cnt = 0; cnt < 48; cnt++){
tempbts[cnt] = key[PC_2[cnt]];
}
return 0;
}

//循环左移
int DES_ROL(ElemType data[56], int time){
ElemType temp[56];

//保存将要循环移动到右边的位
memcpy(temp,data,time);
memcpy(temp+time,data+28,time);

//前28位移动
memcpy(data,data+time,28-time);
memcpy(data+28-time,temp,time);

//后28位移动
memcpy(data+28,data+28+time,28-time);
memcpy(data+56-time,temp+time,time);

return 0;
}

//IP置换
int DES_IP_Transform(ElemType data[64]){
int cnt;
ElemType temp[64];
for(cnt = 0; cnt < 64; cnt++){
temp[cnt] = data[IP_Table[cnt]];
}
memcpy(data,temp,64);
return 0;
}

//IP逆置换
int DES_IP_1_Transform(ElemType data[64]){
int cnt;
ElemType temp[64];
for(cnt = 0; cnt < 64; cnt++){
temp[cnt] = data[IP_1_Table[cnt]];
}
memcpy(data,temp,64);
return 0;
}

//扩展置换
int DES_E_Transform(ElemType data[48]){
int cnt;
ElemType temp[48];
for(cnt = 0; cnt < 48; cnt++){
temp[cnt] = data[E_Table[cnt]];
}
memcpy(data,temp,48);
return 0;
}

//P置换
int DES_P_Transform(ElemType data[32]){
int cnt;
ElemType temp[32];
for(cnt = 0; cnt < 32; cnt++){
temp[cnt] = data[P_Table[cnt]];
}
memcpy(data,temp,32);
return 0;
}

//异或
int DES_XOR(ElemType R[48], ElemType L[48] ,int count){
int cnt;
for(cnt = 0; cnt < count; cnt++){
R[cnt] ^= L[cnt];
}
return 0;
}

//S盒置换
int DES_SBOX(ElemType data[48]){
int cnt;
int line,row,output;
int cur1,cur2;
for(cnt = 0; cnt < 8; cnt++){
cur1 = cnt*6;
cur2 = cnt<<2;

//计算在S盒中的行与列
line = (data[cur1]<<1) + data[cur1+5];
row = (data[cur1+1]<<3) + (data[cur1+2]<<2)
+ (data[cur1+3]<<1) + data[cur1+4];
output = S[cnt][line][row];

//化为2进制
data[cur2] = (output&0X08)>>3;
data[cur