C++RSA密码系统的实现

最新推荐文章于 2023-01-22 08:25:32 发布
最新推荐文章于 2023-01-22 08:25:32 发布
阅读量1.8k 收藏 13
点赞数 2
文章标签： c++  密码学 RSA密码系统

1．问题描述
RSA密码系统可具体描述为：取两个大素数p和q，令n=pq,N=(p-1)(q-1),随机选择整数d,满足gcd(d,N)=1,ed=1 modN。
公开密钥：k1=(n,e)
私有密钥：k2=(p,q,d)
加密算法：对于待加密消息m，其对应的密文为c=E(m)=me(modn)
解密算法：D©=cd(modn)
2．基本要求
p,q,d,e参数选取合理，程序要求界面友好，自动化程度高。
4． 实现提示
要实现一个真实的RSA密码系统，主要考虑对大整数的处理。P和q是1024位的，n取2048位。

BigInteger.h

#ifndef BIGINT_H_INCLUDED
#define BIGINT_H_INCLUDED
#include <iostream>
#include <string>
#include <cstdlib>
#include<map>
#include <algorithm>//reverse函数所需添加的头文件
using namespace std;
/*
大整数类
*/
class BigInt
{
private:
    inline int compare(string s1, string s2)
    {
        if(s1.size() < s2.size())
            return -1;
        else if(s1.size() > s2.size())
            return 1;
        else
            return s1.compare(s2);
    }
public:
    bool flag;//true表示正数，false表示负数，0默认为正数
    string values;//保存所有位上的数字
    BigInt():values("0"),flag(true){};//构造函数
    BigInt(string str)//类型转换构造函数(默认为正整数)
    {
        values = str;
        flag = true;
    }
public:
    friend ostream& operator << (ostream& os, const BigInt& bigInt);//重载输出操作符
    friend istream& operator>>(istream& is, BigInt& bigInt);//输入操作符重载
    BigInt operator+(const BigInt& rhs);//加法操作重载
    BigInt operator-(const BigInt& rhs);//减法操作重载
    BigInt operator*(const BigInt& rhs);//乘法操作重载
    BigInt operator/(const BigInt& rhs);//除法操作重载
    BigInt operator%(const BigInt& rhs);//求余操作重载
};
/*
重载流提取运算符'>>'，输出一个整数
*/
ostream& operator << (ostream& os, const BigInt& bigInt)
{
    if (!bigInt.flag)
    {
        os << '-';
    }
    os << bigInt.values;
    return os;
}
/*
重载流插入运算符'>>'，输入一个正整数
*/
istream& operator >> (istream& is, BigInt& bigInt)
{
    string str;
    is >> str;
    bigInt.values = str;
    bigInt.flag = true;
    return is;
}
/*
两个正整数相加
*/
BigInt BigInt::operator+(const BigInt& rhs)
{
    BigInt ret;
    ret.flag = true;//正整数相加恒为正数
    string lvalues(values), rvalues(rhs.values);
    //处理特殊情况
    if (lvalues == "0")
    {
        ret.values = rvalues;
        return ret;
    }
    if (rvalues == "0")
    {
        ret.values = lvalues;
        return ret;
    }
    //调整s1与s2的长度
    unsigned int i, lsize, rsize;
    lsize = lvalues.size();
    rsize = rvalues.size();
    if (lsize < rsize)
    {
        for (i = 0; i < rsize - lsize; i++)//在lvalues左边补零
        {
            lvalues = "0" + lvalues;
        }
    }
    else
    {
        for (i = 0; i < lsize - rsize; i++)//在rvalues左边补零
        {
            rvalues = "0" + rvalues;
        }
    }
    //处理本质情况
    int n1, n2;
    n2 = 0;
    lsize = lvalues.size();
    string res = "";
    reverse(lvalues.begin(), lvalues.end());//颠倒字符串，以方便从低位算起计算
    reverse(rvalues.begin(), rvalues.end());
    for (i = 0; i < lsize; i++)
    {
        n1 = (lvalues[i] - '0' + rvalues[i] - '0' + n2) % 10;//n1代表当前位的值
        n2 = (lvalues[i] - '0' + rvalues[i] - '0' + n2) / 10;//n2代表进位
        res = res + char(n1 + '0');
    }

    if (n2 == 1)
    {
        res = res + "1";
    }
    reverse(res.begin(), res.end());

    ret.values = res;
    return ret;
}
/*
两个整数相减
*/
BigInt BigInt::operator-(const BigInt& rhs)
{
    BigInt ret;
    string lvalues(values), rvalues(rhs.values);
    //负数减负数
    if(flag==false&&rhs.flag==false)
    {
        string tmp = lvalues;
        lvalues = rvalues;
        rvalues = tmp;
    }
    //负数减正数
    if(flag==false&&rhs.flag==true)
    {
        BigInt res(lvalues);
        ret=res+rhs;
        ret.flag = false;
        return ret;
    }
    if(flag==true&&rhs.flag==false)
    {
        BigInt rel(lvalues),res(rhs.values);
        ret=rel+res;
        ret.flag = true;
        return ret;
    }
        //处理特殊情况
    if (rvalues == "0")
    {
        ret.values = lvalues;
        ret.flag = true;
        return ret;
    }
    if (lvalues == "0")
    {
        ret.values = rvalues;
        ret.flag = false;
        return ret;
    }
    //调整s1与s2的长度
    unsigned int i, lsize, rsize;
    lsize = lvalues.size();
    rsize = rvalues.size();
    if (lsize < rsize)
    {
        for (i = 0; i < rsize - lsize; i++)//在lvalues左边补零
        {
            lvalues = "0" + lvalues;
        }
    }
    else
    {
        for (i = 0; i < lsize - rsize; i++)//在rvalues左边补零
        {
            rvalues = "0" + rvalues;
        }
    }
    //调整使‘-’号前边的数大于后边的数
    int t = lvalues.compare(rvalues);//相等返回0，str1<str2返回负数，str1>str2返回正数
    if (t < 0)
    {
        ret.flag = false;
        string tmp = lvalues;
        lvalues = rvalues;
        rvalues = tmp;
    }
    else if (t == 0)
    {
        ret.values = "0";
        ret.flag = true;
        return ret;
    }
    else
    {
        ret.flag = true;
    }
    //处理本质情况
    unsigned int j;
    lsize = lvalues.size();
    string res = "";
    reverse(lvalues.begin(), lvalues.end());//颠倒字符串，以方便从低位算起计算
    reverse(rvalues.begin(), rvalues.end());
    for (i = 0; i < lsize; i++)
    {
        if (lvalues[i] < rvalues[i])//不足，向前借一维
        {
            j = 1;
            while(lvalues[i+j] == '0')
            {
                lvalues[i+j] = '9';
                j++;
            }
            lvalues[i+j] -= 1;
            res = res + char(lvalues[i] + ':' - rvalues[i]);
        }
        else
        {
            res = res + char(lvalues[i] - rvalues[i] + '0');
        }
    }
    reverse(res.begin(), res.end());
    res.erase(0, res.find_first_not_of('0'));//去掉前导零

    ret.values = res;
    return ret;
}

/*
两个整数相乘
*/
BigInt BigInt::operator*(const BigInt& rhs)
{
    BigInt ret;
    string lvalues(values), rvalues(rhs.values);
    //处理0或结果正负
    if (lvalues == "0" || rvalues == "0")
    {
        ret.values = "0";
        ret.flag = true;
        return ret;
    }
    if(flag==false||rhs.flag==false)
    {
        ret.flag=false;
    }
    //处理特殊情况
    unsigned int lsize, rsize;
    lsize = lvalues.size();
    rsize = rvalues.size();
    string temp;
    BigInt res, itemp;
    //让lvalues的长度最长
    if (lvalues < rvalues)
    {
        temp = lvalues;
        lvalues = rvalues;
        rvalues = temp;
        lsize = lvalues.size();
        rsize = rvalues.size();
    }
    //处理本质情况
    int i, j, n1, n2, n3, t;
    reverse(lvalues.begin(), lvalues.end());//颠倒字符串
    reverse(rvalues.begin(), rvalues.end());

    for (i = 0; i < rsize; i++)
    {
        temp = "";
        n1 = n2 = n3 = 0;
        for (j = 0; j < i; j++)
        {
            temp = temp + "0";
        }
        n3 = rvalues[i] - '0';
        for (j = 0; j < lsize; j++)
        {
            t = (n3*(lvalues[j] - '0') + n2);
            n1 = t % 10;//n1记录当前位置的值
            n2 = t / 10;//n2记录进位的值
            temp = temp + char(n1 + '0');
        }
        if (n2)
        {
            temp = temp + char(n2 + '0');
        }
        reverse(temp.begin(), temp.end());
        itemp.values = temp;
        res = res + itemp;
    }

    ret.values = res.values;
    return ret;
}
/*
两个正整数相除
*/
BigInt BigInt::operator/(const BigInt& rhs)
{
    BigInt ret;
    string lvalues(values), rvalues(rhs.values);
    string quotient;
    string temp;
    //处理特殊情况
    if(rvalues == "0")
    {
        ret.values = "error";//输出错误
        ret.flag = true;
        return ret;
    }
    if(lvalues == "0")
    {
        ret.values = "0";
        ret.flag = true;
        return ret;
    }

    if(compare(lvalues, rvalues) < 0)
    {
        ret.values = "0";
        ret.flag = true;
        return ret;
    }
    else if(compare(lvalues, rvalues) == 0)
    {
        ret.values = "1";
        ret.flag = true;
        return ret;
    }
    else
    {
        //处理本质情况

        unsigned int lsize, rsize;
        lsize = lvalues.size();
        rsize = rvalues.size();
        int i;
        if(rsize > 1) temp.append(lvalues, 0, rsize-1);
        for(i = rsize - 1; i < lsize; i++)
        {
            temp = temp + lvalues[i];
            //试商
            for(char c = '9'; c >= '0'; c--)
            {
                BigInt t = (BigInt)rvalues * (BigInt)string(1, c);
                BigInt s = (BigInt)temp - t;

                if(s.flag == true)
                {
                    temp = s.values;
                    quotient = quotient + c;
                    break;
                }
            }
        }
    }
    //去除前导零
    quotient.erase(0, quotient.find_first_not_of('0'));
    ret.values = quotient;
    ret.flag = true;
    return ret;
}
/*
两个正整数取余
*/
BigInt BigInt::operator%(const BigInt& rhs)
{
    BigInt ret,kj(values),ki(rhs.values);
    string lvalues(values), rvalues(rhs.values);
    string quotient;
    string temp;
    //处理特殊情况
    if(rvalues == "0")
    {
        ret.values = "error";//输出错误
        ret.flag = true;
        return ret;
    }
    if(lvalues == "0")
    {
        ret.values = "0";
        ret.flag = true;
        return ret;
    }

    if(compare(lvalues, rvalues) < 0)
    {
        if(flag==false)
        {
            ret.values=(ki-kj).values;
            ret.flag = true;
            return ret;
        }else{
            ret.values = lvalues;
            ret.flag = true;
            return ret;
        }
    }
    else if(compare(lvalues, rvalues) == 0)
    {
        ret.values = "0";
        ret.flag = true;
        return ret;
    }
    else
    {
        //处理本质情况
        unsigned int lsize, rsize;
        lsize = lvalues.size();
        rsize = rvalues.size();
        int i;
        if(rsize > 1) temp.append(lvalues, 0, rsize-1);
        for(i = rsize - 1; i < lsize; i++)
        {
            if(temp=="0"){
                temp=lvalues[i];
            }else{
                temp = temp + lvalues[i];
            }
            //试商
            for(char c = '9'; c >= '0'; c--)
            {
                BigInt t = (BigInt)rvalues * (BigInt)string(1, c);
                BigInt s = (BigInt)temp - t;

                if(s.flag == true)
                {
                    //cout<<s.values<<endl;
                    temp = s.values;
                    quotient = quotient + c;
                    break;
                }
            }
        }
    }
    //去除前导零
    quotient.erase(0, quotient.find_first_not_of('0'));
    ret.values = temp;
    ret.flag = true;
    return ret;
}
/*
一个大整数和一个小整数的取余
int divMod(string ch,int num)
{
    int s=0;
    for(int i=0;ch[i]!='\0';i++)
    s=(s*10+ch[i]-'0')%num;
    return s;
}*/

/*
欧几里德求GCD
*/
BigInt gcd(BigInt a,BigInt b)
{
    BigInt stemp;
    //cout<<a<<endl;
    //cout<<b<<endl;
    if((a-b).flag==false)//判断大小
    {
        stemp.values=a.values;
        a.values=b.values;
        b.values=stemp.values;
    }
    if(b.values=="0") return a;
    else return gcd(b,a%b);
}
/*
快速幂
*/
BigInt fast(BigInt a,BigInt b)
{
    BigInt aa=a,t("1"),k("2");
 //   int b2=atoi(b1[lsize-1].c_str());
    while(b.values!="0")
    {
        if((b%k).values!="0")
        {
            t=t*aa;
        }
        aa=aa*aa;
        b=b/k;
    }
    return t;
}
/*
快速幂模
*/
BigInt mod_fast(BigInt a,BigInt b,BigInt p)
{
    BigInt aa=a,t("1"),k("2");
 //   int b2=atoi(b1[lsize-1].c_str());
    while(b.values!="0")
    {
        if((b%k).values!="0")
        {
            t=(t%p)*(aa%p)%p;
        }
        aa=(aa%p)*(aa%p)%p;
        b=b/k;
    }
    return t%p;
}

/*
扩展欧几里德实现乘法逆
*/
BigInt extgcd(BigInt a, BigInt b, BigInt& x, BigInt& y)
{
    BigInt d(a.values);

    if(b.values != "0"){
        d = extgcd(b, a % b, y, x);
        y = y-(a / b) * x;
 //   cout<<"a:"<<a<<endl;
  //  cout<<"b:"<<b<<endl;
  //  cout<<"x:"<<x<<endl;
  //  cout<<"y:"<<y<<endl<<endl<<endl;
    }else {
        x.values = "1";
        y.values = "0";
    }
    return d;
}
BigInt mod_inverse(BigInt a, BigInt m)
{


    BigInt x, y;
    extgcd(a, m, x, y);

    if(x.flag==false)
    {
        x.flag=true;
        x=m-x;
    }
    return (m + x % m) % m;
}
const int times = 20;
int number = 0;

map<long long, int>m;
long long Random( long long n )			//生成[ 0 , n ]的随机数
{
	return ((double)rand( ) / RAND_MAX*n + 0.5);
}
long long q_mul( long long a, long long b, long long mod ) //快速计算 (a*b) % mod
{
	long long ans = 0;
	while(b)
	{
		if(b & 1)
		{
			b--;
			ans =(ans+ a)%mod;
		}
		b /= 2;
		a = (a + a) % mod;

	}
	return ans;
}

long long q_pow( long long a, long long b, long long mod ) //快速计算 (a^b) % mod
{
	long long ans = 1;
	while(b)
	{
		if(b & 1)
		{
			ans = q_mul( ans, a, mod );
		}
		b /= 2;
		a = q_mul( a, a, mod );
	}
	return ans;
}

bool witness( long long a, long long n )
{//用检验算子a来检验n是不是素数
	long long tem = n - 1;
	int j = 0;
	while(tem % 2 == 0)
	{
		tem /= 2;
		j++;
	}
	//将n-1拆分为a^r * s

	long long x = q_pow( a, tem, n ); //得到a^r mod n
	if(x == 1 || x == n - 1) return true;	//余数为1则为素数
	while(j--) //否则试验条件2看是否有满足的 j
	{
		x = q_mul( x, x, n );
		if(x == n - 1) return true;
	}
	return false;
}

bool miller_rabin( long long n )  //检验n是否是素数
{

	if(n == 2)
		return true;
	if(n < 2 || n % 2 == 0)
		return false;				//如果是2则是素数，如果<2或者是>2的偶数则不是素数

	for(int i = 1; i <= times; i++)  //做times次随机检验
	{
		long long a = Random( n - 2 ) + 1; //得到随机检验算子 a
		if(!witness( a, n ))						//用a检验n是否是素数
			return false;
	}
	return true;
}

#endif // BIGINT_H_INCLUDED

main.cpp

#include"BigInteger.h"
#include <windows.h>
int main()
{
    DWORD star_time = GetTickCount();
    BigInt p("2305843009213693951"),q("415924872698612520126277439911"),N,n,a("1"),b("2");
    //BigInt p("11"),q("17"),N,n,a("1"),b("2");
    BigInt d,e;
    BigInt m,s;
    N=p*q;
    s=gcd(p-a,q-a);
    n=s*((p-a)/s)*((q-a)/s);
    //cout<<s<<endl;
    //cout<<(p-a)*(q-a)<<endl;
    cout<<"n: "<<n<<endl;
    cout<<"N: "<<N<<endl;
    while(1){
        cout<<"请输入整数e："<<endl;
        cin>>e;
        cout<<"gcd(e,n): "<<gcd(e,n)<<endl;
        if(gcd(e,n).values=="1"&&(n-e).flag==true){

            d=mod_inverse(e,n);
            cout<<"d："<<d<<endl;
            cout<<"请输入需要加密的字符："<<endl;
            cin>>m;
            BigInt t;
            cout<<"加密："<<mod_fast(m,e,N)<<endl;
           /* DWORD end_time = GetTickCount();
	cout << "这个程序运行时间为：" << (end_time - star_time) << "ms." << endl;*/
            cout<<"解密："<<mod_fast(mod_fast(m,e,N),d,N)<<endl;

        }else{
            cout<<"d和N非互素或者非1<e<n！"<<endl;

        }            DWORD end_time = GetTickCount();
	cout << "这个程序运行时间为：" << (end_time - star_time) << "ms." << endl;
	system("pause");
    }

    return 0;
    //10407932194664399081925240327364085538615262247266704805319112350403608059673360298012239441732324184842421613954281007791383566248323464908139906605677320762924129509389220345773183349661583550472959420547689811211693677147548478866962501384438260291732348885311160828538416585028255604666224831890918801847068222203140521026698435488732958028878050869736186900714720710555703168729087
    //415924872698612520126277439911
}
Te_amost
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
RSA算法C++实现源码
11-01
RSA算法C++实现源码
RSA的C++语言描述简单实现
夜悊的博客
11-09 1914
网络安全中RSA的C++语言描述简单实现。
C语言实现RSA
qq_44310495的博客
12-04 3397
1978年美国麻省理工学院的三名密码学者R.L.Rivest, A.Shamir和L.M.Adleman提出了一种基于大合数因子分解困难性的公开密钥密码，简称RSA密码。 RSA密码被誉为是一种风格幽雅的公开密钥密码。由于RSA密码即可用于加密，又可用于数字签名，安全、易懂。因此，RSA密码已成为目前应用最广泛的公开密钥密码。许多国家标准化组织，如ISO，ITU和SWIFT等都已接受RSA作为标准。Internet网的E-Mail保密系统CPG以及国际的VISA和MASTER组织的电子商务协议（SET协议
借助stl实现的简单且相对高性能的c++ rsa加密算法。1024位以内秘钥可以实现1s内生成，2048位5s内生成。
01-22 357
借助stl实现的简单且相对高性能的c++ rsa加密算法。1024位以内秘钥可以实现1s内生成，2048位5s内生成。
RSA算法C++实现--密码学实验
AEliauk的博客
11-03 802
#include<iostream> #include<algorithm> #include<math.h> #include<string.h> #include<time.h> using namespace std; typedef long long LL; LL p,q,n,n_Euler,e,d; LL Plaintext[100];//明文 LL Ciphertext[100];//密文 LL Plaintext_C[100];
RSA大数运算实现(1024位n) (1)
热门推荐
威化饼的一隅
12-08 1万+
RSA大数运算（1024位）综述数据结构和宏数据结构及宏bignum.h中的函数定义bignum.h中函数声明函数实现方法加法减法乘法乘法算法除法取模数论中的一些函数求最大公因子和求逆模幂运算费马素性检测中国剩余定理实现的数论函数位运算函数左移右移获得二进制位数实现的位运算函数特殊操作函数求前几十个素数的乘积，存在文件中产生指定二进制位数大随机数（利用SHA-1和rand()）寻找指定二进制位数素...
RSA 公钥加密算法C++模拟
Andy
12-27 1198
RSA密钥设置算法： 随机选择两个大素数p，q，计算其乘积n，n就是加密和解密时的模。 计算n的欧拉函数值 Ω(n)。 选择与n互素的加密密钥e，e满足1 < e < Ω(n) 且 gcd(e,Ω(n)) =1。 公钥：{e，n}。 计算e关于Ω(n)的乘法逆元d。 私钥：{d，n}。 公布公钥，保留私钥。 代码实现（不现实，只是体现思想） #include <iostrea...
公钥密码RSA算法C++实现
02-19
**公钥密码体制** 公钥密码体制是一种加密技术，它基于数学难题，使得加密和...以上就是关于公钥密码体制RSA算法以及C++实现的相关知识点。通过理解这些概念，开发者可以构建自己的RSA加密系统，保障数据的安全传输。
RSA.rar_简易密码锁c++
09-21
**标题：“RSA.rar_简易密码锁c++”** 本文将深入探讨如何使用C++语言实现一个简单的密码锁程序。密码锁是一种常见的安全机制，用于保护数据或资源免受未经授权的访问。在这个项目中，我们将利用基础的编程概念，如...
RSA密码_实验报告1
08-03
总的来说，RSA密码系统是现代密码学中的重要组成部分，它的理论基础和实现方法对于理解公钥密码体制至关重要。通过学习RSA，我们可以深入理解公钥密码的安全性，并掌握如何在实际中实现这种加密技术。
rsa算法的c语言源码
10-07
实现了蒙哥马利算法，rsa大数加密算法，适用于2048，1024，512bit加密
RSA:RSA-1024加密算法
05-23
RSA RSA encryption algorithm bigInt.h bigInt.cpp：大数运算库 gcd.h：最大公因子及模逆算法实现 mrTest.h：Miller-Rabin检测的实现 power.h：模幂运算的实现 random.h：随机整数的生成库 main.cpp：测试程序，输入一个字符串，生成一对秘钥并保存（公钥名为pubkey.txt，私钥名为prikey.txt），用这对秘钥对字符串进行加密和解密 keygen.cpp:生成秘钥对，无需输入，输出秘钥对保存为文件（公钥名为pubkey.txt，私钥名为prikey.txt） encryption.cpp:加密程序，输入明文，输出密文 decryption.cpp：解密程序，输入密文，输出明文
RSA加密算法C++实现
04-17
RSA加密算法是一种非对称加密技术，由Ron...总的来说，RSA加密算法是现代密码学的重要基石，其C++实现涉及大数运算、数论知识和安全编程实践。通过理解这些原理和实现细节，开发者可以更好地理解和应用非对称加密技术。
基于C++实现 RSA 大作业【100012184】
05-15
**基于C++实现RSA大作业解析** RSA是一种广泛使用的非对称加密算法，它基于数论中的两个核心概念：大素数分解困难性和欧拉函数的性质。在本项目中，我们关注的重点是如何使用C++语言来实现这些复杂的数学运算。 ...
C++ 实现RSA加密
nb1253587023的博客
06-26 5903
c++
C++ RSA加密解密签字通信系统源码
alicema1111的博客
06-05 938
C++ RSA加密解密签字通信系统源码 如需安装运行环境或远程调试，可加QQ905733049, 或QQ2945218359由专业技术人员远程协助！运行结果如下：主要代码：
RSA加密的简单实现【C++ Code】
ProboxDu的博客
11-20 4564
原理不再细述, 下面是简单的实现,没有使用比较大的质数, 主要是用C++不想写大数… 支持对中文的加密#include <bits/stdc++.h> using namespace std; typedef long long LL; const int MAX_N = 1000; wifstream wfin; wofstream wfout;//locale loc("zh_CN.UTF-8
编程实现RSA密码系统c++
最新发布
06-12
下面是一个简单的C++实现RSA密码系统的示例代码，包含了密钥生成、加密和解密过程。 ```cpp #include #include #include #include using namespace std; // 求最大公约数 int gcd(int a, int b) { if (b == ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值