信息加密——现代密码学

信息加密——现代密码学

文章目录

    • 信息加密——现代密码学
  • 前言
  • 一、DES加密
    • 二.3DES加密算法
  • 三.MD5算法:
    • 四.RSA算法:


前言

密码学技术的商业化转变发生在20世纪70年代,主要原因是计算机革命所引发的对大量的电子信息数据实施保护的需求。到20世纪70年代中期,甚至连美国政府也意识到对于安全加密技术存在着合法合理的商业诉求。


一、DES加密

DES加密是三大著名且经典的加密算法之一,为分组对称加密 算法。DES算法(或国产等效算法)在POS、ATM、磁卡及智能卡(IC卡)、加油站、高速公路收费站等领域被广泛应用,以此来实现关键数据的保密,如信用卡持卡人的PIN的加密传输,IC卡与POS间的双向认证、金融交易数据包的MAC(消息鉴别码Message Authentication Code)校验等。
DES采用了64位的分组长度和56位的密钥长度,它将64位的输入经过一系列变换得到64位的输出。解密则使用了相同的步骤和相同的密钥。参与加密的长度为56位,密钥空间含有2^56个密钥。
DES算法利用多次组合替代算法和换位算法,分散和错乱的相互作用,把明文编制成密码强度很高的密文,它的加密和解密用的是同一算法。
DES算法是一种分组加密机制,将明文分成N个组,然后对各个组进行加密,形成各自的密文,最后把所有的分组密文进行合并,形成最终的密文。
采用单钥密码系统的加密方法,同一个密钥可以同时用作信息的加密和解密,这种加密方法称为对称加密,也称为单密钥加密。
信息加密——现代密码学_第1张图片

利用DES Tool对文本信息进行加密和解密:
信息加密——现代密码学_第2张图片
对重复字符进行加密:
信息加密——现代密码学_第3张图片

代码如下:

#include 
using namespace std;
string k;
struct node
{
    int c[80];
    int d[80];
    int cd[80];
    int k_n[80];
    int l[80];
    int r[80];
    node()
    {
        memset(c,0,sizeof(c));
        memset(d,0,sizeof(d));
        memset(k_n,0,sizeof(k_n));
        memset(l,0,sizeof(l));
        memset(r,0,sizeof(r));
    }
};
 
char mikey[18]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
 
//IP初始置换表
int pc_ip[80]= {0,58,50,42,34,26,18,10,2,
                60,52,44,36,28,20,12,4,
                62,54,46,38,30,22,14,6,
                64,56,48,40,32,24,16,8,
                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};
 
//置换选择PC-1
int pc_1[60]= {0,57,49,41,33,25,17,
               9,1,58,50,42,34,26,
               18,10,2,59,51,43,35,
               27,19,11,3,60,52,44,
               36,63,55,47,39,31,23,
               15,7,62,54,46,38,30,
               22,14,6,61,53,45,37,
               29,21,13,5,28,20,12,4};
 
//置换选择PC-2
int pc_2[60]= {0,14,17,11,24,1,5,
               3,28,15,6,21,10,
               23,19,12,4,26,8,
               16,7,27,20,13,2,
               41,52,31,37,47,55,
               30,40,51,45,33,48,
               44,49,39,56,34,53,
               46,42,50,36,29,32};
 
//E盒扩展变换
int pc_e[80]= {0,32,1,2,3,4,5,
               4,5,6,7,8,9,
               8,9,10,11,12,13,
               12,13,14,15,16,17,
               16,17,18,19,20,21,
               20,21,22,23,24,25,
               24,25,26,27,28,29,
               28,29,30,31,32,1};
 
//P盒置换表
int pc_p[80]= {0,16,7,20,21,
               29,12,28,17,
               1,15,23,26,
               5,18,31,10,
               2,8,24,14,
               32,27,3,9,
               19,13,30,6,
               22,11,4,25};
 
//逆初始置换表
int pc_ip_1[80]= {0,40,8,48,16,56,24,64,32,
                  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};
 
//S盒
int s_box[8][4][16]={
	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,
 
	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,10,5,14,9,
 
	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,
 
	7,13,14,3,0,6,9,10,1,2,8,5,11,12,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,
 
	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,
 
	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,
 
	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,
 
	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,7,4,10,8,13,15,12,9,0,3,5,6,11};
 
///F函数实现E盒扩展
int f(int r[80],int kn[80])
{
    int x=0;
    int e[80]= {0};
    int h=0,l=0,idx=0;
    //E盒扩展得到e(Ri);
    for(int i=1; i<=48; i++)
        e[i]=r[pc_e[i]];
    //异或运算得到k^(Ri);
    for(int i=1; i<=48; i++)
        r[i]=e[i]^kn[i];
    //S盒压缩将48位分为8组,每组6位,得到S(k^(Ri));
    for(int i=1; i<=48; i+=6)
    {
        h=r[i]*2+r[i+5]*1;
        l=r[i+1]*8+r[i+2]*4+r[i+3]*2+r[i+4]*1;
        e[++idx]=(s_box[x][h][l]>>3)&1;
        e[++idx]=(s_box[x][h][l]>>2)&1;
        e[++idx]=(s_box[x][h][l]>>1)&1;
        e[++idx]=s_box[x][h][l]&1;
        x++;
    }
    //P盒置换
    for(int i=1; i<=32; i++)
        r[i]=e[pc_p[i]];
}
 
int jiami(string m,int choice)
{
/*
转二进制
功能:将16个16进制转换成16个二进制并存到two数组
      k秘钥转换成二进制并存到two_k数组
*/
    int two[66]= {0},num,idx=0,two_k[66]= {0},two_kup[66]= {0};
    for(int i=0; i<16; i++) //将16个16进制转换成16个二进制:变成64位
    {
        if(m[i]>='0'&& m[i]<='9')
            num=m[i]-'0';
        else num=m[i]-'A'+10;
        two[++idx]=(num>>3)&1;
        two[++idx]=(num>>2)&1;
        two[++idx]=(num>>1)&1;
        two[++idx]=num&1;
    }
    idx=0;
    for(int i=0; i<16; i++) //k秘钥转2进制
    {
        if(k[i]>='0'&&k[i]<='9')
            num=k[i]-'0';
        else num=k[i]-'A'+10;
        two_k[++idx]=(num>>3)&1;
        two_k[++idx]=(num>>2)&1;
        two_k[++idx]=(num>>1)&1;
        two_k[++idx]=num&1;
    }
 
 
///密钥加密///
/*
求16个子密钥
功能:由密钥生成16轮加密所用的子密钥
*/
    ///表4-5用pc_1得到k+(将密钥用pc_1置换)
    for(int i=1; i<=56; i++)
        two_kup[i]=two_k[pc_1[i]];
    //左右分组
    node c_and_d[20];
    for(int i=1; i<=28; i++) //得到c[0];
        c_and_d[0].c[i]=two_kup[i];
    for(int i=1,j=29; j<=56; i++,j++) //得到d[0];
        c_and_d[0].d[i]=two_kup[j];
 
    ///16轮生成每轮子密钥
    for(int i=1; i<=16; i++) //得到c[1]-c[15],d[1]-d[15],CnDn;
    {
        ///表4-6的把移一位和移两位的分开
 
        //如果为第1、2、9、16轮,则d循环左移1位
        if(i==1||i==2||i==9||i==16)
        {
            for(int j=1; j<=27; j++)
                c_and_d[i].c[j]=c_and_d[i-1].c[j+1];
            c_and_d[i].c[28]=c_and_d[i-1].c[1];
            for(int j=1; j<=27; j++)
                c_and_d[i].d[j]=c_and_d[i-1].d[j+1];
            c_and_d[i].d[28]=c_and_d[i-1].d[1];
        }
        //如果是其他轮次,则d循环左移2位
        else
        {
            for(int j=1; j<=26; j++)
                c_and_d[i].c[j]=c_and_d[i-1].c[j+2];
            c_and_d[i].c[27]=c_and_d[i-1].c[1];
            c_and_d[i].c[28]=c_and_d[i-1].c[2];
            for(int j=1; j<=26; j++)
                c_and_d[i].d[j]=c_and_d[i-1].d[j+2];
            c_and_d[i].d[27]=c_and_d[i-1].d[1];
            c_and_d[i].d[28]=c_and_d[i-1].d[2];
        }
        for(int j=1; j<=28; j++)
            c_and_d[i].cd[j]=c_and_d[i].c[j];
        for(int j=29,t=1; t<=28; j++,t++)
            c_and_d[i].cd[j]=c_and_d[i].d[t];
    }
 
    ///PC_2置换后打印16轮子密钥
    node k_16[20];
    for(int i=1; i<=16; i++) //得到k1-kn;
        for(int j=1; j<=48; j++)
            k_16[i].k_n[j]=c_and_d[i].cd[pc_2[j]];
 
 
///明文加密 71页图4-8明文加密过程///
/*
DES算法主函数
功能:实现DES算法的16轮加密
*/
    int ip[80]= {0};
    //初始变换ip
    for(int i=1; i<=64; i++)
        ip[i]=two[pc_ip[i]];
 
    //初始化得到 l[0],r[0]
    node l_r[20];
    for(int i=1; i<=32; i++) //得到l;
        l_r[0].l[i]=ip[i];
    for(int i=1,j=33; j<=64; i++,j++) //得到r;
        l_r[0].r[i]=ip[j];
 
    ///choice=0时是加密操作,choice=1时是解密操作
    //进行16轮运算
    if(choice==0)
    {
        for(int i=1; i<=16; i++) //计算L1-L16,R1-R16;
        {
            for(int j=1; j<=32; j++)
                //左右的左等于左右的右
                l_r[i].l[j]=l_r[i-1].r[j];
            ///F函数包含E盒扩展、异或、S盒压缩、P盒置换
            f(l_r[i-1].r,k_16[i].k_n);
            ///左右合在一起,两者进行最终按位异或得到r[i]
            for(int j=1; j<=32; j++)
                l_r[i].r[j]=l_r[i-1].l[j]^l_r[i-1].r[j];
        }
    }
    else
    {
        for(int i=1; i<=16; i++) //计算L1-L16,R1-R16;
        {
            for(int j=1; j<=32; j++)
                l_r[i].l[j]=l_r[i-1].r[j];
            f(l_r[i-1].r,k_16[16-i+1].k_n);
            //^异或运算符
            for(int j=1; j<=32; j++)
                l_r[i].r[j]=l_r[i-1].l[j]^l_r[i-1].r[j];
        }
    }
 
    int R16L16[80]= {0}; //得到R16L16;
    //F函数过后左右合在一起
    for(int i=1; i<=32; i++)
        R16L16[i]=l_r[16].r[i];
    for(int i=33,j=1; j<=32; j++,i++)
        R16L16[i]=l_r[16].l[j];
 
    int ans[80]= {0}; //得到最终变换;
    //进行ip逆置换
    for(int i=1; i<=64; i++)
        ans[i]=R16L16[pc_ip_1[i]];
 
    ///choice=0时是加密操作,choice=1时是解密操作
    int tem_num;
    if(choice==0)
    {
        //字节转换成字符输出密文
        for(int i=1; i<=64; i+=4)
        {
            tem_num=ans[i]*8+ans[i+1]*4+ans[i+2]*2+ans[i+3]*1;
            if(tem_num>=10)
                printf("%c",(tem_num-10)+'A');
            else printf("%c",tem_num+'0');
        }
    }
    else
    {
        int change[1000];
        int pos=0;
        for(int i=1; i<=64; i+=4)
        {
            tem_num=ans[i]*8+ans[i+1]*4+ans[i+2]*2+ans[i+3]*1;
            change[++pos]=tem_num;
        }
        int jieans=0;
        for(int i=1; i<=16; i+=2)
        {
            jieans+=change[i];
            jieans*=16;
            jieans+=change[i+1];
            //printf("%d %d\n",change[i],change[i+1]);
            printf("%c",jieans);
            jieans=0;
        }
    }
}
 
int main()
{
    while(1)
    {
        cout<<"请选择功能:1.加密 2.解密 3.退出"<<endl;
        int choice;
        cin>>choice;
        if(choice==1)
        {
            k="";
            getchar();
            srand((int)time(0));
            cout<<"请输入明文(英文文本):"<<endl;
            char say[1000];
            gets(say);
            /* 
			cout<<"正在产生随机密钥:"<
            k="CFC2D6DCB7B5D0A3";//16位16进制数 
            cout<<"使用的密钥(16进制表示)为:"<<k<<endl;
            printf("密文(16进制表示)为:");
            int len=strlen(say),idx=0;
            char tensix[2000],tem[1000];
			int now=0;
            for(int i=0; i<len; i++) //文本转16进制
            {
                while(say[i])
                {
                    if(say[i]%16>=10) tem[++idx]=((say[i]%16)-10)+'A';
                    else tem[++idx]=(say[i]%16)+'0';
                    say[i]/=16;
                }
                //倒序存入
                for(int j=idx; j>=1; j--)
                    tensix[++now]=tem[j];
                idx=0;
            }
            while(now%16)//不够16位补0;
            {
                ++now;
                tensix[now]='0';
            }
            int sum=0;
            string m="";
            for(int i=1; i<=now; i++) //每64位加密一次;
            {
                sum++;
                m+=tensix[i];
                //cout<
                if(sum==16)
                {
                    sum=0;
                    jiami(m,0);
                    m="";
                }
            }
            printf("\n");
        }
        else if(choice==2)
        {
            getchar();
            cout<<"请输入密文:"<<endl;
            char tensix[1000];
            gets(tensix);
            cout<<"请输入秘钥:"<<endl;
            cin>>k;
            printf("明文为:");
            int len=strlen(tensix);
            int sum=0;
            string m="";
            for(int i=0; i<len; i++) //每64位加密一次;
            {
                sum++;
                m+=tensix[i];
                if(sum==16)
                {
                    sum=0;
                    jiami(m,1);
                    m="";
                }
            }
            printf("\n");
        }
        else
            return 0;
    }
    return 0;
}

二.3DES加密算法

3DES即三重数据加密算法,相当于是对每个数据块应用三次DES加密。由于计算机运算能力的增强,原版DES密码的密钥长度变得容易被暴力破解;3DES即是设计用来提供一种相对简单的方法,即通过增加DES的密钥长度来避免类似的攻击。
3DES使用3个密钥,对明文先使用key1进行des加密形成密文1,接着使用key2对密文1进行解密形成密文2,最后使用key3对密文2进行加密形成密文3。即:密文=EK3(DK2(EK1(明文))),明文=DK1(EK2(DK3(密文)))。
3DES标准定义了三种密钥选项:
密钥选项1:三个密钥是独立的。
密钥选项2:K1和K2是独立的,而K3=K1密钥选项3:三个密钥均相等,即K1=K2=K3密钥选项1的强度最高,拥有3 x 56 = 168个独立的密钥位。
密钥选项2的安全性稍低,拥有2 x 56 = 112个独立的密钥位。该选项比简单的应用DES两次的强度较高,即使用K1和K2,因为它可以防御中途相遇攻击(英语:meet-in-the-middle attack)。
密钥选项3:等同于DES,只有56个密钥位。这个选项提供了与DES的兼容性,因为第1和第2次DES操作相互抵消了。该选项不再为国家标准科技协会(NIST)所建议,亦不为ISO/IEC 18033-3所支持。

信息加密——现代密码学_第4张图片

三.MD5算法:

算法的输入:任何长度的字节流。
算法的输出:16字节值(有时会以32位十六进制字符表示)。
算法特点:加密过程不需要密钥,加密后的数据无法被解密。只有输入相同的明文数据经过相同的消息摘要算法才能得到相同的密文。所以不存在密钥的管理与分发问题。
算法流程:相当复杂。
算法应用:文件一致性验证、数字证书、访问认证。

#include
#include
using namespace std;
#define shift(x, n) (((x) << (n)) | ((x) >> (32-(n))))//右移的时候,高位一定要补零,而不是补充符号位
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))    
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
#define A 0x67452301
#define B 0xefcdab89
#define C 0x98badcfe
#define D 0x10325476
//strBaye的长度
unsigned int strlength;
//A,B,C,D的临时变量
unsigned int atemp;
unsigned int btemp;
unsigned int ctemp;
unsigned int dtemp;
//常量ti unsigned int(abs(sin(i+1))*(2pow32))
const unsigned int k[]={
        0xd76aa478,0xe8c7b756,0x242070db,0xc1bdceee,
        0xf57c0faf,0x4787c62a,0xa8304613,0xfd469501,0x698098d8,
        0x8b44f7af,0xffff5bb1,0x895cd7be,0x6b901122,0xfd987193,
        0xa679438e,0x49b40821,0xf61e2562,0xc040b340,0x265e5a51,
        0xe9b6c7aa,0xd62f105d,0x02441453,0xd8a1e681,0xe7d3fbc8,
        0x21e1cde6,0xc33707d6,0xf4d50d87,0x455a14ed,0xa9e3e905,
        0xfcefa3f8,0x676f02d9,0x8d2a4c8a,0xfffa3942,0x8771f681,
        0x6d9d6122,0xfde5380c,0xa4beea44,0x4bdecfa9,0xf6bb4b60,
        0xbebfbc70,0x289b7ec6,0xeaa127fa,0xd4ef3085,0x04881d05,
        0xd9d4d039,0xe6db99e5,0x1fa27cf8,0xc4ac5665,0xf4292244,
        0x432aff97,0xab9423a7,0xfc93a039,0x655b59c3,0x8f0ccc92,
        0xffeff47d,0x85845dd1,0x6fa87e4f,0xfe2ce6e0,0xa3014314,
        0x4e0811a1,0xf7537e82,0xbd3af235,0x2ad7d2bb,0xeb86d391};
//向左位移数
const unsigned int s[]={7,12,17,22,7,12,17,22,7,12,17,22,7,
        12,17,22,5,9,14,20,5,9,14,20,5,9,14,20,5,9,14,20,
        4,11,16,23,4,11,16,23,4,11,16,23,4,11,16,23,6,10,
        15,21,6,10,15,21,6,10,15,21,6,10,15,21};
const char str16[]="0123456789abcdef";
void mainLoop(unsigned int M[])
{
    unsigned int f,g;
    unsigned int a=atemp;
    unsigned int b=btemp;
    unsigned int c=ctemp;
    unsigned int d=dtemp;
    for (unsigned int i = 0; i < 64; i++)
    {
        if(i<16){
            f=F(b,c,d);
            g=i;
        }else if (i<32)
        {
            f=G(b,c,d);
            g=(5*i+1)%16;
        }else if(i<48){
            f=H(b,c,d);
            g=(3*i+5)%16;
        }else{
            f=I(b,c,d);
            g=(7*i)%16;
        }
        unsigned int tmp=d;
        d=c;
        c=b;
        b=b+shift((a+f+k[i]+M[g]),s[i]);
        a=tmp;
    }
    atemp=a+atemp;
    btemp=b+btemp;
    ctemp=c+ctemp;
    dtemp=d+dtemp;
}
/*
*填充函数
*处理后应满足bits≡448(mod512),字节就是bytes≡56(mode64)
*填充方式为先加一个1,其它位补零
*最后加上64位的原来长度
*/
unsigned int* add(string str)
{
    unsigned int num=((str.length()+8)/64)+1;//以512位,64个字节为一组
    unsigned int *strByte=new unsigned int[num*16];    //64/4=16,所以有16个整数
    strlength=num*16;
    for (unsigned int i=0; i < num*16; i++)
        strByte[i]=0;
    for (int i=0; i <str.length(); i++)
    {
        strByte[i>>2]|=(str[i])<<((i%4)*8);//一个整数存储四个字节,i>>2表示i/4 一个unsigned int对应4个字节,保存4个字符信息
    }
    strByte[str.length()>>2]|=0x80<<(((str.length()%4))*8);//尾部添加1 一个unsigned int保存4个字符信息,所以用128左移
    /*
    *添加原长度,长度指位的长度,所以要乘8,然后是小端序,所以放在倒数第二个,这里长度只用了32位
    */
    strByte[num*16-2]=str.length()*8;
    return strByte;
}
string changeHex(int a)
{
    int b;
    string str1;
    string str="";
    for(int i=0;i<4;i++)
    {
        str1="";
        b=((a>>i*8)%(1<<8))&0xff;   //逆序处理每个字节
        for (int j = 0; j < 2; j++)
        {
            str1.insert((int)0,(int)1,(char)str16[b%16]);
            b=b/16;
        }
        str+=str1;
    }
    return str;
}
string getMD5(string source)
{
    atemp=A;    //初始化
    btemp=B;
    ctemp=C;
    dtemp=D;
    unsigned int *strByte=add(source);
    for(unsigned int i=0;i<strlength/16;i++)
    {
        unsigned int num[16];
        for(unsigned int j=0;j<16;j++)
            num[j]=strByte[i*16+j];
        mainLoop(num);
    }
    return changeHex(atemp).append(changeHex(btemp)).append(changeHex(ctemp)).append(changeHex(dtemp));
}
int main()
{
    string ss;
    cout<<"请输入字串:"<<endl;
    cin>>ss;
    string s=getMD5(ss);
    cout<<s<<endl; 
    return 0;
}

四.RSA算法:

RSA算法基于数论构造,具体难题是大素数乘积的因子分解。
将两个大素数相乘十分容易,但对其乘积进行因式分解却极其困难,因此可以将乘积作为加密密钥公开。

公钥和私钥的产生:
任意选择两个大的质数(素数)p和q,p不等于q,计算N=pq
根据欧拉函数,不大于N且与N互质的整数个数为(p-1)(q-1)
选择一个整数e与(p-1)(q-1)互质,并且e小于(p-1)(q-1)
用以下这个公式计算d:d×e ≡ 1 (mod (p-1)(q-1))
将p和q销毁后,(N,e)是公钥,(N,d)是私钥
例如:
选素数p=47和q=71,得N=3337,(n)=(47-1)×(71-1)=3220
选择e=79,求得私钥d=e-11019(mod 3220)公开N=3337和e=79

加密消息:
假设Bob想给Alice送一个消息,他知道Alice产生的公钥N和e
将原始信息分为多段,每一段(假定为n)分别用以下公式计算出c:
在这里插入图片描述
将多个n计算出的多个c串在一起,就是密文,发送即可。
例如:
公钥(N,e)=(3337,79),私钥(N,d)=(3337,1019)
现要发送明文688,计算:68879(mod 3337)=1570

解密消息
Alice得到Bob的消息c后就可以利用她的密钥(N,d)来解码。她可以用以下这个公式来将c转换为n:
在这里插入图片描述得到n后,她可以将原来的信息m重新复原。
例如:
公钥(N,e)=(3337,79),私钥(N,d)=(3337,1019)
收到密文1570后,用私钥d=1019进行解密:15701019(mod 3337)=688

#include
#include
#include
#include
#include
using namespace std;
int prime[1305];//存放素数

int p[10005];//用筛选法求素数 
void PRIME(){
	int i,i2,k;
    for(i=0;i<=10000;i+=2)
   		p[i]=0; 
    for(i=1;i<=10000;i+=2)
   		p[i]=1; 
    p[2]=1;p[1]=0;
    for(i=3;i<=100;i+=2){ 
    	if(p[i]==1){
     		i2=i+i; 
     		k=i2+i;
            while(k<=10000){
      		p[k]=0;
      		k+=i2;
     		}	
    	}
	}
	prime[0]=1;
	prime[1]=2;
	for(i=3;i<=10000;i+=2)
   		if(p[i])
    		prime[++prime[0]]=i;

}
// 计算逆元素
__int64 mod(__int64 a,__int64 n){
	return (a%n+n)%n;
}
void gcd(__int64 a,__int64 b,__int64 &d,__int64 &x,__int64 &y){
	if(b==0)
	{	
   		d=a;
   		x=1;
   		y=0;
   		return;
	}
    gcd(b,a%b,d,y,x);
    y-=x*(a/b);
}
//a-1 mod n
__int64 Inv(__int64 a,__int64 n){ // 计算逆元素
	__int64 d,x,y;
	gcd(a,n,d,x,y);
    if(d==1)
   		return mod(x,n);
	else 
   		return -1;
}
//求两个数的最大公约数
__int64 GCD(__int64 n,__int64 m){
	__int64 t,r;
	if(n<m){
   		t=n;
   		n=m;
   		m=t;
	}
	while((r=n%m)!=0){
   		n=m;
   		m=r;
	}
	return m;
}
//x=a^b(mod n)
__int64 ModPow(__int64 a,__int64 b,__int64 n){
	__int64 d=1,i=0;
	while(b>=(1<<i)) i++;
	for(--i;i>=0;--i){
   		d=d*d%n;
   		if(b&(1<<i))
    		d=d*a%n;
	}
	return d;
}
int main(){
	__int64 i,e,d,n,st,ed,eula;
	__int64 m,c,ans;
	PRIME();
	printf("素数的个数:%d\n",prime[0]);
	printf("选择两个不同的素数(输入编号,空格隔开):\n");//47和71分别是第15个和20个 
	while(scanf("%I64d%I64d",&st,&ed)!=EOF){
		printf("你选择的两个素数分别是:%d和%d\n",prime[st],prime[ed]);
   		n=prime[st]*prime[ed];
   		printf("计算得到N是%I64d\n",n);
   		//N的Eula数
   		eula=(prime[st]-1)*(prime[ed]-1);
   		//找一个与eula互质的数
   		for(i=2;i<eula;i++)
    		if(GCD(eula,i)==1){
     			e=i;
     			break;
    		}
    	//e=79; 
   		//上面找到了公开密钥n--e
   		d=Inv(e,eula);
		//上面找到了私密钥n--d
   		printf("生成公钥:(%I64d %I64d)\n",e,n);
   		//输出密钥
  		printf("生成私钥:(%I64d %I64d)\n",d,n);
   		//切忌加密的数要比n小
   		printf("请输入要加密的数();
   		scanf("%I64d",&m);
   		c=ModPow(m,e,n);
   		printf("通过计算%I64d^%I64d(mod %I64d)得到密文=%I64d\n",m,e,n,c);
   		ans=ModPow(c,d,n);
  		printf("通过计算%I64d^%I64d(mod %I64d)得到明文=%I64d\n",c,d,n,ans);
  		printf("素数的个数:%d\n",prime[0]);
		printf("选择两个不同的素数(输入编号,空格隔开):\n");//47和71分别是第15个和20个 
	}
	return 0;
}

你可能感兴趣的:(金融信息安全实训,算法)