C++：文件加密（凯撒加密、栅栏加密、异或加密四方加密、Base64加密）

可选加密解密：凯撒加密、栅栏加密、异或加密、四方加密、base64加密。

凯撒加密：秘钥自动根据随机数生成，并且每次加密时随机生成1和2，若是1则向后移位实现加密，若是2则向前移位实现加密，将秘钥和1或2存入文件密文中，解密时根据其进行解密，凯撒加密可对字母，数字，中文等进行加密。

栅栏加密：栅栏加密一般不超过30个字符，根据字符长短分为2栏和7栏加密方式，若是偶数则全部进行加密，若是奇数则最后一个字符不进行加密而是在前面的偶数加密完成后直接加到最后，栅栏加密可对对字母，数字，中文等进行加密。

异或加密：对字符进行异或操作实现加密，异或加密可对字母、数字、中文进行加密。

四方加密：对小写26个字母和0~9数字进行对称加密，四方加密只可对小写26个字母和0~9数字进行对称加密。

Base64加密：三个字符的各八位二进制转换成四位的六位二进制，找出转换表的对应位置，实现加密。

在加密后的密文最后加上一个大写字母代表加密的方式：C（凯撒加密）、B（栅栏加密）、X（异或加密）、S（四方加密），解密时可根据最后一个字母来进行解密操作。

具体加密操作详见百度。

对这个程序做一个简单的介绍：

个人将这个程序分为了三个部分来写：

1.界面。

界面就是采用了gotoxy函数。

这个函数的作用就是如下所示：

原型：extern void gotoxy(int x, int y);

用法：#include <system.h>

功能：将光标移动到指定位置说明：gotoxy（x，y）将光标移动到指定行y和列x。设置光标到文本屏幕的指定位置，其中参数x,y为文本屏幕的坐标。

gotoxy(0,0)将光标移动到屏幕左上角。

然后，根据计算得出屏幕上的各个坐标的位置，然后将光标定位到不同的坐标点上即可，而且根据用户输入的指令可以将坐标点进行变化。然后根据此时的坐标点的位置选择进入不同的界面。

这个类实现的内容核心就是这个，其余的内容经过简单计算即可。

2.加密和解密。

加密和解密无非就是整个程序的核心所在，前面已经对程序的加密解密大致思想进行了介绍，这里在简单介绍一下实现过程：

凯撒加密：

这个就比较简单了，就是简单的位移计算，没有一点技术含量。为了加强加密的安全，这里采用了随机位数加密和随机向后向前加密。也就是说如果一个字母是A的话，算法会先产生一个随机数和在1和2（1的话向右进行加密，2的话向左进行加密），然后将A的ascii减去或加上（也就是向左或者向右）这个随机数，产生的新的ascii对应的字符就是加密后的密文，由于每次进行加减的位数不定，所以加密强度会有所提升，并且需要将加密时的随机数和向左或者向右的标志（秘钥）进行记录，否则无法解开密文。解密的时候根据秘钥进行计算就好了。

栅栏加密：

栅栏加密法是一种比较简单快捷的加密方法。栅栏加密法就是把要被加密的文件按照一上一下的写法写出来，再把第二行的文字排列到第一行的后面。相应的，破译方法就是把文字从中间分开，分成2行，然后插入。栅栏加密法一般配合其他方法进行加密。

例：

加密information

分行

i f r a i n

n o m t o

合并

ifrainnomto

完成~

这种也比较简单，同样的比较容易破解，这个百度词条上的是2栏加密，程序中除了实现2栏加密外，还有7栏加密。7栏加密与2栏加密的思想一致，算法也大概相同（不过程序中的7栏加密有缺陷，只能加密字符为：17、21、28的，其余的还是使用2栏加密实现的）。

3.异或加密。

这个就是用来凑数的，算法简单明了，将字符的ascii记性异或运算就好了，同样进行异或运算时的字符也是随机产生的，所以需要将秘钥进行保存。

4.四方加密。

这里是对四方密码的一个详细介绍，可以查看这个。
http://baike.baidu.com/link?url=EW-hRWmLoQdAt0NMIf4wgW3Tbfk1WxffbnDPw5oMUNUfavOL9OqvW9LL3o0jWE4W
算法就是根据这里的思想进行编写的，而且这里使用的加密矩阵可以进行简单修改，所以可以说如果不知道加密矩阵的话，是无法解开密文的。

5.base64加密。

同样的，下面是关于base64的介绍：
http://baike.baidu.com/link?url=JN4tj8Su4fjZR6vLOHWDtP2-LcDaIz8W31-8GRO4d4cDbImQiF6NyjL2A-p4_BerDv4Ykxhs6JEn3X0Dc_QrK_
加密过程采用了二进制转换的方法，就是讲明文的ascii转换成八位的二进制，每三个字符一组，就是24位二进制数。再将这24个二进制数，每6个一组分割成4组，再转换成十进制。这样就将三个字符分割成四个字符了，然后根据转换表转换成对应的密文即可。

3.整体逻辑控制。

这个就是main函数中实现的内容，采用了多个while循环嵌套，然后使用esc返回到上层界面。使用起来相对灵活。

课程设计相对应的报告（需要两个下载积分，没有积分的可以私信我邮箱，我进行发送）：http://download.csdn.net/detail/leafage_m/9741417

#include <iostream>//凯撒 栅栏  异或 四方 Base64
#include <windows.h>
#include <conio.h>
#include <fstream>
#include <string>
#include <ctime>
using namespace std;

//空格键ASCII 32 回车 13 Esc 27
void hide_cursor()
{
CONSOLE_CURSOR_INFO cci = {1, 0};
SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
}

void gotoxy(int x,int y)
{
COORD loc={x,y};
HANDLE hOutput=GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleCursorPosition(hOutput,loc);
}

class Interface
{
public:
Interface()
{
x = 0;
y = 0;
}
int Choose();//选择开始说明结束
int Display_Choose();//选择加密或者解密
int Choose_Passwd();//选择密码
void Move(int &x,int &y);//移动图标
void Empty();//清空区域
void Explain();//密码说明
private:
int x,y,m,n;
};

int Interface::Choose()
{
Empty();
m = 6;
n = 14;
x = 39;
y = 6;
gotoxy(x,y);
cout << "开始";
gotoxy(x,y+4);
cout << "说明";
gotoxy(x,y+8);
cout << "结束";
Move(x,y);
Empty();
return y;
}

int Interface::Display_Choose()
{
Empty();
m = 6;
n = 10;
x = 39;
y = 6;
gotoxy(x,y);
cout << "加密";
gotoxy(x,y+4);
cout << "解密";
Move(x,y);
Empty();
return y;
}

int Interface::Choose_Passwd()
{
Empty();
m = 4;
n = 20;
x = 39;
y = 4;
gotoxy(x,y);
cout << "凯撒";
gotoxy(x,y+4);
cout << "栅栏";
gotoxy(x,y+8);
cout << "异或";
gotoxy(x,y+12);
cout << "四方";
gotoxy(x-1,y+16);
cout << "Base64";
Move(x,y);
Empty();
return y;
}

void Interface::Move(int &x,int &y)
{
char ch;
gotoxy(x-4,y);
cout << ">>";
gotoxy(x+6,y);
cout << "<<";
ch = getch();
while(ch!=27 && ch!=13)
{
switch(ch)
{
case 'W':
case 'w':
if(y != m)
{
gotoxy(x-4,y);
cout << "  ";
gotoxy(x+6,y);
cout << "  ";
y = y - 4;
gotoxy(x-4,y);
cout << ">>";
gotoxy(x+6,y);
cout << "<<";
}
else
{
gotoxy(x-4,y);
cout << "  ";
gotoxy(x+6,y);
cout << "  ";
y = n;
gotoxy(x-4,y);
cout << ">>";
gotoxy(x+6,y);
cout << "<<";
}
break;
case 'S':
case 's':
if(y != n)
{
gotoxy(x-4,y);
cout << "  ";
gotoxy(x+6,y);
cout << "  ";
y = y + 4;
gotoxy(x-4,y);
cout << ">>";
gotoxy(x+6,y);
cout << "<<";
}
else
{
gotoxy(x-4,y);
cout << "  ";
gotoxy(x+6,y);
cout << "  ";
y = m;
gotoxy(x-4,y);
cout << ">>";
gotoxy(x+6,y);
cout << "<<";
}
break;
default:
break;
}
ch = getch();
}
if(ch == 27)
y = 0;
}

void Interface::Empty()
{
system("cls");
}

void Interface::Explain()
{
gotoxy(20,2);
cout << "凯撒(C)：可用于数字、符号、字母、中文加密、解密操作";
gotoxy(20,6);
cout << "栅栏(Z)：可用于数字、符号、字母加密、解密操作";
gotoxy(20,10);
cout << "异或(X)：可用于数字、空格、字母、中文加密、解密操作";
gotoxy(20,14);
cout << "四方(S)：可用于数字、小写字母加密、解密操作";
gotoxy(20,18);
cout << "Base64(B)：可用于对数字、字符加密、解密操作";
gotoxy(20,20);
cout << "加密后密文最后一个大写字母代表加密方式：";
gotoxy(20,22);
cout << "凯撒(C)、栅栏(Z)、异或(X)、四方(S)、Base64(B)";
}

class File
{
public:
void Write_File(char c[]);//写入文件
void Read_File();//读取文件
char *Return();//返回文件内容
int Return_Long();//返回文件长度
private:
char ch[1000],name[100];//ch保存文件内容,name保存文件名字
fstream file;
};

void File::Write_File(char c[])
{
gotoxy(30,12);
cout << "请输入要存放密文的文件名:";
cin >> name;
strcat(name,".txt");
file.open(name,ios::out|ios::trunc);
if(!file)
{
cerr << "打开" << name << "失败！" << endl;
exit(1);
}
file << c;
gotoxy(35,16);
cout << "存放成功！";
file.close();
}

void File::Read_File()
{
gotoxy(40,10);
cin >> name;
strcat(name,".txt");
file.open(name,ios::out|ios::in);

if(!file)
{
file.open(name,ios::out|ios::in|ios::trunc);
if(!file)
{
cerr << "打开" << name << "失败！" << endl;
exit(1);
}
}

while(!file.eof())//读取文件
{
file.getline(ch,1000,'\0');
}

if(strlen(ch) == 0)//如果文件为空
{
file.close();//先关闭再打开，否则写不进去
file.open(name,ios::out);
gotoxy(30,12);
cout << "该文件内容为空，请输入内容:";
gotoxy(38,14);
cin.getline(ch,1000,'\n');
cin.getline(ch,1000,'\n');
file << ch;
}
gotoxy(32,16);
cout << "文件内容为:";
cout << ch << endl;
file.close();
}

char* File::Return()
{
char *p;
p = ch;
return p;
}

int File::Return_Long()
{
return strlen(ch);
}

class Encrypt//加密基类
{
public:
virtual void How_Encrypt(File &F){}//以什么方法虚函数
protected:
char ch[1000];//存放文件内容
char *p;//接收传来的指针
int n,m,i;//对指针进行操作，给ch赋值
};

class Caesar_Encrypt:public Encrypt//凯撒加密
{
public:
virtual void How_Encrypt(File &F)
{
p = F.Return();//接收文件传来的内容指针
n = F.Return_Long();//接收文件内容的长度
m = 0;//用m来控制循环赋值
while(n != 0)
{
ch[m] = *(p+m);
m++;
n--;
}
ch[m] = '\0';//最后给文件末尾结束
gotoxy(30,8);
cout << "加密前明文:" << ch << endl;//输出加密前原文
srand(unsigned(time(NULL)));
lr = 1 + rand() % + 2;//随机产生两个数字，来移位方向
key = 1 + rand() % + 26;//随机产生秘钥
if(lr == 1)//向右加密
{
for(i=0;i<strlen(ch);i++)
{
ch[i] = ch[i] + key;
}
ch[i] = lr;
ch[i+1] = key;
ch[i+2] = 'C';
ch[i+3] = '\0';
gotoxy(30,10);
cout << "加密后暗文:" << ch << endl;//输出加密后密文
}
if(lr == 2)//向左加密
{
for(i=0;i<strlen(ch);i++)
{
ch[i] = ch[i] - key;
}
ch[i] = lr;
ch[i+1] = key;
ch[i+2] = 'C';
ch [i+3] = '\0';
gotoxy(30,10);
cout << "加密后暗文:" << ch << endl;//输出加密后密文
}
F.Write_File(ch);
}
private:
int key;//随机产生的秘钥
int lr;//向左或者向右移动
};

class Barrier_Encrypt:public Encrypt//栅栏加密
{
virtual void How_Encrypt(File &F)
{
p = F.Return();//接收文件传来的内容指针
str = n = F.Return_Long();//接收文件内容的长度
m = 0;//用m来控制循环赋值
while(n != 0)
{
ch[m] = *(p+m);
m++;
n--;
}
ch[m] = '\0';//最后给文件末尾结束
gotoxy(30,8);
cout << "加密前明文:" << ch << endl;//输出加密前原文

if(str == 1)
{
ch[1] = ' ';
}
if(str == 2)//小于2直接交换
{
key = ch[0];
ch[0] = ch[1];
ch[1] = key;
ch[2] = 'Z';
ch[3] = '\0';
gotoxy(30,10);
cout << "加密后暗文:" << ch << endl;//输出加密后暗文
F.Write_File(ch);
}
if(str<29 && str>13 && str%7==0)//大于13比并且整数7  7栏
{
char temp[m+1];//temp用来交换
int j=0;
if(str == 14)
{
for(i=0;i<strlen(ch);i=i+2)//找到7栏的规律实现加密
{
temp[i] = ch[i/2];
temp[i+1] = ch[j+7];
j++;
}
}
if(str == 21)
{
for(i=0;i<strlen(ch);i=i+3 )//找到7栏的规律实现加密
{
temp[i] = ch[i/3];
temp[i+1] = ch[j+7];
temp[i+2] = ch[j+14];
j++;
}
}
if(str == 28)
{
for(i=0;i<strlen(ch);i=i+4)//找到7栏的规律实现加密
{
temp[i] = ch[i/4];
temp[i+1] = ch[j+7];
temp[i+2] = ch[j+14];
temp[i+3] = ch[j+21];
j++;
}
}
temp[m] = 'Z';
temp[m+1] = '\0';
gotoxy(30,10);
cout << "加密后暗文:" << temp << endl;//输出加密后暗文
F.Write_File(temp);
}
if(str!=2)//否则2栏
{
if(str%2 == 1)
{
key = ch[m-1];
}
char temp[m+1];
for(i=0;i<strlen(ch)/2;i++)//找到2栏规律实现加密
{
temp[i] = ch[2*i];
temp[(strlen(ch)/2)+i] = ch[2*i+1];
}
if(str%2 == 1)
{
temp[m-1] = key;
temp[m] = 'Z';
temp[m+1] = '\0';
}
else
{
temp[m] = 'Z';
temp[m+1] = '\0';
}
gotoxy(30,10);
cout << "加密后暗文:" << temp << endl;//输出加密后暗文
F.Write_File(temp);
}
}
private:
char key;//key只用来处理2栏奇数
int str;
};

class Xor_Encrypt:public Encrypt//异或加密
{
public:
virtual void How_Encrypt(File &F)
{
p = F.Return();//接收文件传来的内容指针
n = F.Return_Long();//接收文件内容的长度
m = 0;//用m来控制循环赋值
while(n != 0)
{
ch[m] = *(p+m);
m++;
n--;
}
ch[m] = '\0';//最后给文件末尾结束
gotoxy(30,8);
cout << "加密前明文:" << ch << endl;//输出加密前原文
srand(unsigned(time(NULL)));
key = 1 + rand() % 127;
int i;
for(i=0;i<strlen(ch);i++)
{
ch[i] = key^ch[i];
}
ch[i] = key;
ch[i+1] = 'X';
ch[i+2] = '\0';
gotoxy(30,10);
cout << "加密后暗文:" << ch << endl;//输出加密后暗文
F.Write_File(ch);
}
private:
char key;
};

class Square_Encrypt:public Encrypt//四方加密
{
public:
virtual void How_Encrypt(File &F)
{
char key1[6][6]={{'a','b','c','d','e','f'},{'g','h','i','j','k','l'},{'m','n','o','p','q','l'},{'s','t','u','v','w','x'},{'y','z','0','1','2','3'},{'4','5','6','7','8','9'}};
char key2[6][6]={{'1','9','7','0','5','3'},{'8','2','4','6','M','A'},{'J','I','L','O','N','G'},{'m','a','j','i','l','o'},{'n','g','H','K','M','S'},{'B','C','D','E','F','Z'}};
char key3[6][6]={{'2','0','1','6','7','4'},{'8','3','9','5','W','O'},{'S','H','I','M','A','J'},{'L','O','N','G','w','o'},{'s','h','i','m','a','j'},{'l','o','n','g','z','Z'}};
char key4[6][6]={{'s','t','u','v','w','x'},{'y','z','0','1','2','3'},{'4','5','6','7','8','9'},{'a','b','c','d','e','f'},{'g','h','i','j','k','l'},{'m','n','o','p','q','l'}};
p = F.Return();//接收文件传来的内容指针
n = F.Return_Long();//接收文件内容的长度
m = 0;//用m来控制循环赋值
while(n != 0)
{
ch[m] = *(p+m);
m++;
n--;
}
ch[m] = '\0';//最后给文件末尾结束
gotoxy(30,8);
cout << "加密前明文:" << ch << endl;//输出加密前原文
key = '.';
if(strlen(ch)%2 == 1)//处理奇数情况
{
key = ch[m-1];
ch[m-1] = '\0';
}
int i,j,k;
for(k=0;k<strlen(ch);k=k+2)//加密算法，每两个字母一组
{
for(i=0;i<6;i++)//找到第一个字母在key1的位置
{
for(j=0;j<6;j++)
{
if(ch[k] == key1[i][j])
{
Row1 = i;
List1 = j;
}
}
}
for(i=0;i<6;i++)//找到第二个字母在key4的位置
{
for(j=0;j<6;j++)
{
if(ch[k+1] == key4[i][j])
{
Row2 = i;
List2 = j;
}
}
}
ch[k] = key2[Row1][List2];//找到第一个字母同行第二个字母同列
ch[k+1] = key3[List1][Row2];//找到第一个字母同列第二个字母同行

}
if(key != '.')
{
k = strlen(ch);
ch[k] = key;
ch[k+1] = 'S';
ch[k+2] = '\0';
}
else
{
k = strlen(ch);
ch[k] = 'S';
ch[k+1] = '\0';
}
gotoxy(30,10);
cout << "加密后暗文:" << ch << endl;//输出加密后暗文
F.Write_File(ch);
}
private:
char key;//用来处理奇数时最后一个字符
int Row1,List1,Row2,List2;//记录行和列
};

class Base64_Encrypt:public Encrypt//Base64加密
{
public:
virtual void How_Encrypt(File &F)
{
p = F.Return();//接收文件传来的内容指针
n = F.Return_Long();//接收文件内容的长度
m = 0;//用m来控制循环赋值
while(n != 0)
{
ch[m] = *(p+m);
m++;
n--;
}
ch[m] = '\0';//最后给文件末尾结束
gotoxy(30,8);
cout << "加密前明文:" << ch << endl;//输出加密前原文
char ZHB[64] = {'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','l','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/'};

int i,j,t,l=0;//i,j用来控制循环,l用来控制A
if(strlen(ch)%3 == 1)//若不是3的倍数后面加上空格来处理
{
ch[m] = ' ';
ch[m+1] = ' ';
ch[m+2] = '\0';
}
if(strlen(ch)%3 == 2)
{
ch[m] = ' ';
ch[m+1] = '\0';
}
for(i=0;i<strlen(ch);i++)//将原文中的内容转换成二进制存入到A数组中
{
t = ch[i];
if(t == 0)
{
for(int o=0;o<8;o++)
{
A[l][o] = 0;
}
l++;
}
if(t == 1)
{
for(int o=0;o<8;o++)
{
if(o == 7)
{
A[l][o] = 1;
}
else
{
A[l][o] = 0;
}
}
l++;
}
if(t!=0 && t!=1)
{
k = 0;//k记录二进制的个数，用来补全八位二进制
for(int i=0;i<8;i++)
{
yushu = t%2;
t = t/2;
A[l][7-i] = yushu;
k++;
if(t == 0)
{
k++;
A[l][7-i-1] = 0;
//cout << A[l][7-i-1] << endl;
break;
}
if(t == 1)
{
k++;
A[l][7-i-1] = 1;
break;
}
}
if(k != 8)
{
for(int i=0;i<8-k;i++)
{
A[l][i] = 0;
}
}
l++;
}
}
int z=0;//用来统计B的个数
for(i=0;i<l;i++)//将A中的二进制转存到B中
{
for(j=0;j<8;j++)
{
B[z] = A[i][j];
z++;
}
}
z = 0;
int x=l*8/6+2;//计算新建数组的大小
char temp[x];
x = 0;
for(i=0;i<l*8;i=i+6)//将B中的二进制6个一分，然后转换成十进制
{
Count = 0;
for(j=0;j<6;j++)//6个一组转换成十进制
{
if(j == 0)
{
Count += B[z]*32;
}
if(j == 1)
{
Count += B[z]*16;
}
if(j == 2)
{
Count += B[z]*8;
}
if(j == 3)
{
Count += B[z]*4;
}
if(j == 4)
{
Count += B[z]*2;
}
if(j == 5)
{
Count += B[z]*1;
}
z++;
}
temp[x] = ZHB[Count];
x++;
}
temp[x] = 'B';
temp[x+1] = '\0';
gotoxy(30,10);
cout << "加密后暗文:" << temp << endl;//输出加密后暗文
F.Write_File(temp);
}
private:
//char ZHB[66];//转换表
int A[100][8],k,yushu,zhengshu;//用来转换成二进制,k,q,w分别用来中间值的作用
int Count;//用来记录字符在转换表中的位置
int B[1000];//用来将二进制重新组合
};
class Decode//解密基类
{
public:
virtual void How_Decode(File &F){}//以什么方法解密
protected:
char ch[1000];//存放文件内容
char *p;//接收传来的指针
int n,m,i;//对指针进行操作，给ch赋值
};

class Caesar_Decode:public Decode//凯撒解密
{
public:
virtual void How_Decode(File &F)
{
p = F.Return();//接收文件传来的内容指针
n = F.Return_Long();//接收文件内容的长度
m = 0;//用m来控制循环赋值
while(n != 3)
{
ch[m] = *(p+m);
m++;
n--;
}
lr = *(p+m);
key = *(p+m+1);
ch[m] = '\0';//最后给文件末尾结束
gotoxy(30,8);
cout << "解密前暗文:" << ch << (char)lr << (char)key << 'C' << endl;//输出加密前原文
//cout << "秘钥：" << key1;
if((int)lr == 1)//向左解密
{
for(i=0;i<strlen(ch);i++)
{
ch[i] = ch[i] - key;
}
gotoxy(30,10);
cout << "解密后明文:" << ch << endl;
}
if((int)lr == 2)//向右解密
{
for(i=0;i<strlen(ch);i++)
{
ch[i] = ch[i] + key;
}
gotoxy(30,10);
cout << "解密后明文:" << ch << endl;
}
F.Write_File(ch);
}
private:
int key;//随机产生的秘钥
int lr;//向左或者向右移动
};

class Barrier_Decode:public Decode//栅栏解密
{
public:
virtual void How_Decode(File &F)
{
p = F.Return();//接收文件传来的内容指针
str = n = F.Return_Long();//接收文件内容的长度
m = 0;//用m来控制循环赋值
while(n != 1)
{
ch[m] = *(p+m);
m++;
n--;
}
ch[m] = '\0';//最后给文件末尾结束
gotoxy(30,8);
cout << "解密前暗文:" << ch << 'Z' << endl;//输出加密前原文

if(str == 3)//小于2直接交换
{
key = ch[0];
ch[0] = ch[1];
ch[1] = key;
gotoxy(30,10);
cout << "解密后明文:" << ch << endl;//输出加密后暗文
F.Write_File(ch);
}
char temp[m+1];//temp用来交换
if(str<30 && str>14 && str%7==1)//大于13比并且整数7  7栏
{
int j=0;
if(str == 15)//因为str等于从文件中的传来的最初个数，所以比此时的长度大1
{
for(i=0;i<strlen(ch);i=i+2)//找规律重新组合解密
{
temp[j] = ch[i];
j++;
}
for(i=1;i<strlen(ch);i=i+2)
{
temp[j] = ch[i];
j++;
}
}
if(str == 22)
{
for(i=0;i<strlen(ch);i=i+3)//找规律重新组合解密
{
temp[j] = ch[i];
j++;
}
for(i=1;i<strlen(ch);i=i+3)
{
temp[j] = ch[i];
j++;
}
for(i=2;i<strlen(ch);i=i+3)
{
temp[j] = ch[i];
j++;
}
}
if(str == 29)
{
for(i=0;i<strlen(ch);i=i+4)//找规律重新组合解密
{
temp[j] = ch[i];
j++;
}
for(i=1;i<strlen(ch);i=i+4)
{
temp[j] = ch[i];
j++;
}
for(i=2;i<strlen(ch);i=i+4)
{
temp[j] = ch[i];
j++;
}
for(i=3;i<strlen(ch);i=i+4)
{
temp[j] = ch[i];
j++;
}
}
temp[m] = '\0';
gotoxy(30,10);
cout << "解密后明文:" << temp << endl;//输出解密后明文
F.Write_File(temp);
}
if(str!=3)//否则2栏
{
if(str%2 != 1)
{
key = ch[m-1];
}
char temp[m+1];

int j=0;//j来控制
for(i=0;i<strlen(ch)/2;i++)//找到2栏规律实现解密
{
temp[j] = ch[i];
j = j+2;
}
j = 1;
for(i=strlen(ch)/2;i<strlen(ch);i++)//找到2栏规律实现解密
{
temp[j] = ch[i];
j = j+2;
}
if(str%2 != 1)
{
temp[m-1] = key;
}
temp[m] = '\0';
gotoxy(30,10);
cout << "解密后明文:" << temp << endl;//输出解密后明文
F.Write_File(temp);
}
}
private:
char key;
int str;
};

class Xor_Decode:public Decode//异或解密
{
public:
virtual void How_Decode(File &F)
{
p = F.Return();//接收文件传来的内容指针
n = F.Return_Long();//接收文件内容的长度
m = 0;//用m来控制循环赋值
while(n != 1)
{
ch[m] = *(p+m);
m++;
n--;
}
ch[m] = '\0';//最后给文件末尾结束
gotoxy(30,8);
cout << "解密前暗文:" << ch << 'X' << endl;//输出解密前暗文
key = ch[m-1];
int i;
for(i=0;i<strlen(ch)-1;i++)
{
ch[i] = key^ch[i];
}
ch[i] = '\0';
gotoxy(30,10);
cout << "解密后明文:" << ch << endl;//输出解密后明文
F.Write_File(ch);
}
private:
char key;//解密的关键
};

class Square_Decode:public Decode//四方解密
{
public:
virtual void How_Decode(File &F)
{
char key1[6][6]={{'a','b','c','d','e','f'},{'g','h','i','j','k','l'},{'m','n','o','p','q','l'},{'s','t','u','v','w','x'},{'y','z','0','1','2','3'},{'4','5','6','7','8','9'}};
char key2[6][6]={{'1','9','7','0','5','3'},{'8','2','4','6','M','A'},{'J','I','L','O','N','G'},{'m','a','j','i','l','o'},{'n','g','H','K','M','S'},{'B','C','D','E','F','Z'}};
char key3[6][6]={{'2','0','1','6','7','4'},{'8','3','9','5','W','O'},{'S','H','I','M','A','J'},{'L','O','N','G','w','o'},{'s','h','i','m','a','j'},{'l','o','n','g','z','Z'}};
char key4[6][6]={{'s','t','u','v','w','x'},{'y','z','0','1','2','3'},{'4','5','6','7','8','9'},{'a','b','c','d','e','f'},{'g','h','i','j','k','l'},{'m','n','o','p','q','l'}};
p = F.Return();//接收文件传来的内容指针
n = F.Return_Long();//接收文件内容的长度
m = 0;//用m来控制循环赋值
while(n != 1)
{
ch[m] = *(p+m);
m++;
n--;
}
ch[m] = '\0';//最后给文件末尾结束
gotoxy(30,8);
cout << "解密前暗文:" << ch << 'S' << endl;//输出解密前暗文
key = '.';
if(strlen(ch)%2 == 1)//处理奇数情况
{
key = ch[m-1];
ch[m-1] = '\0';
}
int i,j,k;
for(k=0;k<strlen(ch);k=k+2)//加密算法，每两个字母一组
{
for(i=0;i<6;i++)//找到第一个字母在key2的位置
{
for(j=0;j<6;j++)
{
if(ch[k] == key2[i][j])
{
Row1 = i;
List1 = j;
}
}
}
for(i=0;i<6;i++)//找到第二个字母在key3的位置
{
for(j=0;j<6;j++)
{
if(ch[k+1] == key3[i][j])
{
Row2 = i;
List2 = j;
}

}
}
ch[k] = key1[Row1][Row2];//反向解密
ch[k+1] = key4[List2][List1];//反向解密

}
if(key != '.')
{
ch[strlen(ch)] = key;
ch[strlen(ch)+1] = '\0';
}
else
{
ch[strlen(ch)] = '\0';
}
gotoxy(30,10);
cout << "解密后明文:" << ch << endl;//输出加密后暗文
F.Write_File(ch);
}
private:
char key;//用来处理奇数时最后一个字符
int Row1,List1,Row2,List2;//记录行和列
};

class Base64_Decode:public Decode//Base64解密
{
public:
virtual void How_Decode(File &F)
{
p = F.Return();//接收文件传来的内容指针
n = F.Return_Long();//接收文件内容的长度
m = 0;//用m来控制循环赋值
while(n != 1)
{
ch[m] = *(p+m);
m++;
n--;
}
ch[m] = '\0';//最后给文件末尾结束
gotoxy(30,8);
cout << "解密前暗文:" << ch << 'B' << endl;//输出解密前暗文
char ZHB[64] = {'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','l','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/'};
int i,j,t,l=0;//i,j用来控制循环,l用来控制A
int Count;
for(i=0;i<strlen(ch);i++)
{
for(j=0;j<64;j++)//找到字符在转换表中的位置
{
if(ch[i] == ZHB[j])
{
t = j;
break;
}
}
if(t == 0)//转换成二进制
{
for(int o=0;o<8;o++)
{
A[l][o] = 0;
}
l++;
}
if(t == 1)
{
for(int o=0;o<8;o++)
{
if(o == 7)
{
A[l][o] = 1;
}
else
{
A[l][o] = 0;
}
}
l++;
}
if(t!=0 && t!=1)
{
k = 0;//k记录二进制的个数，用来补全六位二进制
for(int i=0;i<6;i++)
{
yushu = t%2;
t = t/2;
A[l][5-i] = yushu;
k++;
if(t == 0)
{
k++;
A[l][5-i-1] = 0;
cout << A[l][5-i-1] << endl;
break;
}
if(t == 1)
{
k++;
A[l][5-i-1] = 1;
break;
}
}
if(k != 6)
{
for(int i=0;i<6-k;i++)
{
A[l][i] = 0;
}
}
//cout << A[l][0] << A[l][1] << A[l][2] << A[l][3] << A[l][4] << A[l][5] << " ";
l++;
}
}
int z=0;//用来统计B的个数
for(i=0;i<l;i++)//将A中的二进制转存到B中
{
for(j=0;j<6;j++)
{
B[z] = A[i][j];
z++;
}
}
z = 0;
int x=l*6/8+1;//计算新建数组的大小
char temp[x];
x = 0;
for(i=0;i<l*6;i=i+8)//将B中的二进制6个一分，然后转换成十进制
{
Count = 0;
for(j=0;j<8;j++)//6个一组转换成十进制
{
if(j == 0)
{
Count += B[z]*128;
}
if(j == 1)
{
Count += B[z]*64;
}
if(j == 2)
{
Count += B[z]*32;
}
if(j == 3)
{
Count += B[z]*16;
}
if(j == 4)
{
Count += B[z]*8;
}
if(j == 5)
{
Count += B[z]*4;
}
if(j == 6)
{
Count += B[z]*2;
}
if(j == 7)
{
Count += B[z]*1;
}
z++;
}
temp[x] = (char)Count;
x++;
}
temp[x] = '\0';
gotoxy(30,10);
cout << "解密后明文:" << temp << endl;//输出加密后暗文
F.Write_File(temp);
}
private:
int A[100][6],k,yushu,zhengshu;//用来转换成二进制,k,q,w分别用来中间值的作用
int Count;//用来记录字符在转换表中的位置
int B[1000];//用来将二进制重新组合
};

int main()
{
int x,y;
char ch;
hide_cursor();
File F;
Interface I;
Encrypt *p1;
Decode *p2;

Caesar_Encrypt CE;
Caesar_Decode CD;

Barrier_Encrypt BE;
Barrier_Decode BD;

Xor_Encrypt XE;
Xor_Decode XD;

Square_Encrypt SE;
Square_Decode SD;

Base64_Encrypt B64E;
Base64_Decode B64D;
while(1)//一级界面
{
x = I.Choose();
if(x == 10)
{
while(1)
{
I.Explain();
ch = getch();
while(ch!=27)//使用户的输入只能是Esc或者Enter
{
ch = getch();
}
break;
}
}
if(x == 14)//若选择退出
break;
if(x == 6)//若选择开始
{
while(1)//二级界面
{
gotoxy(30,8);//按下Esc返回上级,按下Enter确认！提示操作
cout << "请输入要进行操作的文件名:";
ch = getch();
while(ch!=27 && ch!=13)//使用户的输入只能是Esc或者Enter
{
ch = getch();
}
if(ch == 27)//Esc返回一级界面
break;
if(ch == 13)//Enter进入文件输入
{
F.Read_File();//打开文件
ch = getch();
while(ch!=27 && ch!=13)//输入完成后确认操作
{
ch = getch();
}
if(ch == 27)//返回一级界面
break;
if(ch == 13)//确认进入三级界面
{
while(1)//三级界面
{
x = I.Display_Choose();//x的值用来确定加密或者解密
if(x == 6)//加密操作
{
while(1)//四级界面
{
int y;
y = I.Choose_Passwd();//选择如何加密
if(y == 0)//返回三级界面
{
break;
}
while(1)//五级界面
{
switch(y)
{
case 4:
p1 = &CE;
p1->How_Encrypt(F);
break;
case 8:
p1 = &BE;
p1->How_Encrypt(F);
break;
case 12:
p1 = &XE;
p1->How_Encrypt(F);
break;
case 16:
p1 = &SE;
p1->How_Encrypt(F);
break;
case 20:
p1 = &B64E;
p1->How_Encrypt(F);
break;
}
ch = getch();
while(ch!=27)//输入完成后确认操作
{
ch = getch();
}
if(ch == 27)
break;
}

}
}
if(x == 10)//解密操作
{
while(1)//四级界面
{
int y;
y = I.Choose_Passwd();//选择如何解密
if(y == 0)//返回三级界面
{
break;
}
while(1)//五级界面
{
switch(y)
{
case 4:
p2 = &CD;
p2->How_Decode(F);
break;
case 8:
p2 = &BD;
p2->How_Decode(F);
break;
case 12:
p2 = &XD;
p2->How_Decode(F);
break;
case 16:
p2 = &SD;
p2->How_Decode(F);
break;
case 20:
p2 = &B64D;
p2->How_Decode(F);
break;
}
ch = getch();
while(ch!=27)//输入完成后确认操作
{
ch = getch();
}
if(ch == 27)
break;
}
}
}
if(x == 0)//返回二级界面
break;
}
}
}
}
}
}
return 0;
}