信息计算2019级1班5号唐乐

唐乐 · 发表于 2022-6-1 22:15:03

本帖最后由唐乐于 2022-6-2 08:55 编辑

RSA加解密----大数加密

这里添加了外部依赖库boost库

一、源代码
1、RAS.h（结构体的定义和功能函数的声明）

#pragma once
#include <string>
#include <vector>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/random.hpp>
#include <boost/multiprecision/miller_rabin.hpp>
namespace bm = boost::multiprecision;
struct Key
{
bm::int1024_t pkey;
//公钥(ekey, pkey): (e,n)
bm::int1024_t ekey;
//私钥(dkey, pkey): (d, n)
bm::int1024_t dkey;
};
class RSA
{
public:
RSA();
Key getKey()
{
return _key;
}
void ecrept(const char* plain_file_in, const char* ecrept_file_out,
bm::int1024_t ekey, bm::int1024_t pkey);//加密
void decrept(const char* ecrept_file_in, const char* plain_file_out,
bm::int1024_t dkey, bm::int1024_t pkey);//解密
std::vector<bm::int1024_t> ecrept(std::string& str_in, bm::int1024_t ekey, bm::int1024_t pkey);//字符串加密
std::string decrept(std::vector<bm::int1024_t>& ecrept_str, bm::int1024_t dkey, bm::int1024_t pkey);//解密为字符串
void printInfo(std::vector<bm::int1024_t>& ecrept_str);//打印信息
private:
bm::int1024_t ecrept(bm::int1024_t msg, bm::int1024_t key, bm::int1024_t pkey);//加密单个信息
bm::int1024_t produce_prime();//产生素数
bool is_prime(bm::int1024_t prime);//是否为素数
bool is_prime_bigInt(bm::int1024_t prime);
void produce_keys();
bm::int1024_t produce_pkey(bm::int1024_t prime1, bm::int1024_t prime2);//计算pq乘积n
bm::int1024_t produce_orla(bm::int1024_t prime1, bm::int1024_t prime2);//计算欧拉函数φ(n)
bm::int1024_t produce_ekey(bm::int1024_t orla);//产生e
bm::int1024_t produce_gcd(bm::int1024_t ekey, bm::int1024_t orla);//产生最大公约数
bm::int1024_t produce_dkey(bm::int1024_t ekey, bm::int1024_t orla);//产生d
bm::int1024_t exgcd(bm::int1024_t ekey, bm::int1024_t orla,
bm::int1024_t& x, bm::int1024_t& y);
private:
Key _key;
};
// 1. 随机选择两个不相等的质数p和q(实际应用中，这两个质数越大，就越难破解)。
// 2. 计算p和q的乘积n，n = pq。
// 3. 计算n的欧拉函数φ(n)。
// 4. 随机选择一个整数e，条件是1 < e < φ(n)，且e与φ(n) 互质。
// 5. 计算e对于φ(n)的模反元素d，使得de≡1 mod φ(n)，即：
// (de)modφ(n) = 1
// 6. 产生公钥(e, n)，私钥(d, n)。

复制代码

唐乐 · 发表于 2022-6-1 22:17:03

2、RAS.cpp（功能函数的定义和实现）

#include"RSA.h"
#include<time.h>
#include<math.h>
#include<iostream>
#include<fstream>
RSA::RSA()
{
produce_keys();
}
void RSA::ecrept(const char* plain_file_in, const char* ecrept_file_out,
bm::int1024_t ekey, bm::int1024_t pkey)//加密
{
std::ifstream fin(plain_file_in, std::ifstream::binary);
std::ofstream fout(ecrept_file_out, std::ofstream::binary);
if (!fin.is_open())
{
std::cout << "open file failed" << std::endl;
return;
}
const int NUM = 128;
char buffer[NUM];
bm::int1024_t buffer_out[NUM];
int curNum;
while (!fin.eof())
{
fin.read(buffer, NUM);
curNum = fin.gcount();
for (int i = 0; i < curNum; ++i)
{
buffer_out[i] = ecrept(buffer[i], ekey, pkey);
}
fout.write((char*)buffer_out, curNum * sizeof(bm::int1024_t));
}
fin.close();
fout.close();
}
void RSA::decrept(const char* ecrept_file_in, const char* plain_file_out,
bm::int1024_t dkey, bm::int1024_t pkey)//解密
{
std::ifstream fin(ecrept_file_in, std::ifstream::binary);
std::ofstream fout(plain_file_out, std::ofstream::binary);
if (!fin.is_open())
{
std::cout << "open file failed" << std::endl;
return;
}
const int NUM = 256;
bm::int1024_t buffer[NUM];
char buffer_out[NUM];
int curNum;
while (!fin.eof())
{
fin.read((char*)buffer, NUM * sizeof(bm::int1024_t));
curNum = fin.gcount() / sizeof(bm::int1024_t);
for (int i = 0; i < curNum; ++i)
{
buffer_out[i] = (char)ecrept(buffer[i], dkey, pkey);
}
fout.write(buffer_out, curNum);
}
fin.close();
fout.close();
}
std::vector<bm::int1024_t> RSA::ecrept(std::string& str_in, bm::int1024_t ekey, bm::int1024_t pkey)//字符串加密
{
std::vector<bm::int1024_t> vecout;
size_t sz = str_in.size();
for (const auto& e : str_in)
{
vecout.push_back(ecrept(e, ekey, pkey));
}
return vecout;
}
std::string RSA::decrept(std::vector<bm::int1024_t>& ecrept_str, bm::int1024_t dkey, bm::int1024_t pkey)//解密为字符串
{
std::string strout;
for (const auto& e : ecrept_str)
{
strout.push_back((char)ecrept(e, dkey, pkey));
}
return strout;
}
void RSA::printInfo(std::vector<bm::int1024_t>& ecrept_str)//打印信息
{
for (const auto& e : ecrept_str)
{
std::cout << e << ' ';
}
std::cout << std::endl;
}
//模幂运算(a^b)%c
bm::int1024_t RSA::ecrept(bm::int1024_t msg, bm::int1024_t key, bm::int1024_t pkey)
{
bm::int1024_t msg_out = 1;
//A0:a^(2^0) = a^1 = a
bm::int1024_t a = msg;
bm::int1024_t b = key;
bm::int1024_t c = pkey;
while (b)
{
if (b & 1)
//msg_out = (A0 * A1 ...Ai ... An) % c
msg_out = (msg_out * a) % c;
b >>= 1;
//Ai = (A(i - 1) * A(i - 1)) % c
a = (a * a) % c;
}
return msg_out;
}
//随机产生一个素数
bm::int1024_t RSA::produce_prime()
{
//srand(time(nullptr));
bm::int1024_t prime = 0;
//mt19937:一种随机数产生器
boost::random::mt19937 gen(time(nullptr));
//指定随机数的范围 2 ~ (1<<128)
boost::random::uniform_int_distribution<bm::int1024_t> dist(2, bm::int1024_t(1) << 128);
while (1)
{
prime = dist(gen);
if (is_prime_bigInt(prime))
break;
}
return prime;
}
bool RSA::is_prime(bm::int1024_t prime)
{
if (prime < 2)
return false;
for (bm::int1024_t i = 2; i < sqrt(prime); ++i)
{
if (prime % i == 0)
return false;
}
return true;
}
bool RSA::is_prime_bigInt(const bm::int1024_t digit)
{
boost::random::mt11213b gen(time(nullptr));
if (miller_rabin_test(digit, 25, gen)) //素数测试算法miller_rabin_test（）
{
if (miller_rabin_test((digit - 1) / 2, 25, gen))
{
return true;
}
}
return false;
}
void RSA::produce_keys()
{
bm::int1024_t prime1 = produce_prime();
bm::int1024_t prime2 = produce_prime();
while (prime1 == prime2)
prime2 = produce_prime();
_key.pkey = produce_pkey(prime1, prime2);
bm::int1024_t orla = produce_orla(prime1, prime2);
_key.ekey = produce_ekey(orla);
_key.dkey = produce_dkey(_key.ekey, orla);
}
bm::int1024_t RSA::produce_pkey(bm::int1024_t prime1, bm::int1024_t prime2)
{
return prime1 * prime2;
}
bm::int1024_t RSA::produce_orla(bm::int1024_t prime1, bm::int1024_t prime2)
{
return (prime1 - 1) * (prime2 - 1);
}
//随机选择一个整数e，条件是1 < e < φ(n)，且e与φ(n) 互质
bm::int1024_t RSA::produce_ekey(bm::int1024_t orla)
{
bm::int1024_t ekey;
srand(time(nullptr));
while (1)
{
ekey = rand() % orla;
if (ekey > 1 && produce_gcd(ekey, orla) == 1)
break;
}
return ekey;
}
//求最大公约数
bm::int1024_t RSA::produce_gcd(bm::int1024_t ekey, bm::int1024_t orla)
{
//gcd(a, b)------gcd(b ,a%b)
bm::int1024_t ret;
while (ret = ekey % orla)
{
ekey = orla;
orla = ret;
}
return orla;
}
bm::int1024_t RSA::produce_dkey(bm::int1024_t ekey, bm::int1024_t orla)
{
bm::int1024_t x, y;
exgcd(ekey, orla, x, y);
return (x % orla + orla) % orla;
}
/*
扩展的欧几里得算法
x = y1; y = x1 - [a/b]*y1
*/
bm::int1024_t RSA::exgcd(bm::int1024_t ekey, bm::int1024_t orla,
bm::int1024_t& x, bm::int1024_t& y)
{
if (orla == 0)
{
x = 1;
y = 0;
return ekey;
}
bm::int1024_t ret = exgcd(orla, ekey % orla, x, y);
bm::int1024_t x1 = x, y1 = y;
x = y1;
y = x1 - (ekey / orla) * y1;
return ret;
}

复制代码

3、test.cpp（主函数及测试函数）

#include"RSA.h"
#include<iostream>
void teststring()
{
RSA rsa;
Key key = rsa.getKey();
std::string strin;
while (1)
{
std::cout << "输入要加密的信息：" << std::endl;
std::cin >> strin;
std::vector<bm::int1024_t>strecrept = rsa.ecrept(strin, key.ekey, key.pkey);
std::string strout = rsa.decrept(strecrept, key.dkey, key.pkey);
std::cout << "加密后的信息：" << std::endl;
rsa.printInfo(strecrept);
std::cout << "解密后的信息：" << std::endl;
std::cout << strout << std::endl;
std::cout << std::endl;
}
}
int main()
{
teststring();
system("pause");
return 0;
}

复制代码

二、运行截图

唐乐 · 发表于 2022-6-2 08:53:57

本帖最后由唐乐于 2022-6-2 08:56 编辑

(ECC)椭圆曲线加密

一、ECC加密原理：

1、用户A选定一条适合加密的椭圆曲线Ep(a,b)(如:y2=x3+ax+b)，并取椭圆曲线上一点，作为基点G。
　 2、用户A选择一个私有密钥k，并生成公开密钥K=kG。
　 3、用户A将Ep(a,b)和点K，G传给用户B。
　 4、用户B接到信息后，将待传输的明文编码到Ep(a,b)上一点M，并产生一个随机整数r（r<n）。
　 5、用户B计算点C1=M+rK；C2=rG。
　 6、用户B将C1、C2传给用户A。
　 7、用户A接到信息后，计算C1-kC2，结果就是点M。因为
      C1-kC2=M+rK-k(rG)=M+rK-r(kG)=M
　　　再对点M进行解码就可以得到明文。

密码学中，描述一条Fp上的椭圆曲线，常用到六个参量： T=(p,a,b,G,n,h)。
      （p 、a 、b 用来确定一条椭圆曲线，G为基点，n为点G的阶，h 是椭圆曲线上所有点的个数m与n相除的整数部分）

      这几个参量取值的选择，直接影响了加密的安全性。参量值一般要求满足以下几个条件：
      1、p 当然越大越安全，但越大，计算速度会变慢，200位左右可以满足一般安全要求；
　　  2、p≠n×h；
　　  3、pt≠1 (mod n)，1≤t<20；
　　  4、4a3+27b2≠0 (mod p)；
　　  5、n 为素数；
　　  6、h≤4。

二、源代码
1、头文件
（1）ECC.h

#pragma once
#include <vector>
#include "stdafx.h"
#include "Key.h"
class ECC
{
public:
ECC(int a, int b, int p);//设置椭圆曲线方程参数
virtual ~ECC(void);
//ECC加密
//待加密的消息已映射为曲线上的点Pm，密钥key，随机数k，加密结果result,通过引用方式传出该参数
//随机数为负数则自动生成随机数，否则使用固定数值k进行加密
void encrypt(const std::vector<Point>& Pm, Key& key, std::vector<Cipher>& result, int k = -1);
//ECC解密
//待解密的密文点ciphers，私钥x，解密后的离散点result,通过引用方式传出该参数
void decrypt(const std::vector<Cipher>& ciphers, int x, std::vector<Point>& result);
const std::vector<Generator> getGenerators()const;//获取生成元列表
//生成公私钥对
//生成元在mGenerators数组中的索引gIndex，私钥x
//如果传入参数不合法（例如生成元g的阶数不是素数，或者x是默认值-1），会重新生成合法的gIndex和x
//result是函数返回时生成的密钥，通过引用方式传出该参数
void genKey(Key& result, int gIndex = -1, int x = -1);
//将解密后得到的离散点解码为明文字符串
void decodePlainPoints(const std::vector<Point>& Pm, std::string& result);
//将明文M编码为椭圆曲线上的点
//编码方式：对输入的字符串去除重复字符后，构成set集合，然后把这些字符一一映射到椭圆曲线上的离散点集合里
void encodePlainText(const char* plainText, std::vector<Point>& result);
static bool isPrime(int n);//判断数n是否为素数
protected:
int mA, mB, mP;//椭圆曲线方程参数y^2=x^3+ax+b (mod p)
std::vector<Point> mPoints;//椭圆曲线上的离散点,不包含无穷远点
std::vector<Generator> mGenerators;//离散点作为生成元，及其阶数构成的集合
Dictionary mDictionary;//明文字符到曲线上点的映射
private:
void getAllPoints();//计算椭圆曲线上的离散点
void getAllOrders();//计算所有生成元的阶数
int getOrder(const Point& p);//计算点p的阶数
int ex_gcd(int a, int b, int& x, int& y);//递归扩展欧几里得
int getInverse(int a, int p);//计算数a在模p下的逆元
Point getMultiplePoint(int k, const Point& p);//递归计算点p的k倍点
Point add(const Point& p1, const Point& p2);//计算两个点的加法
int mod(int a, int p);//计算有符号数a在模p下的最小正数(或0)
};

复制代码

（2）Key.h

#pragma once
#include "StdAfx.h"
class Key
{
public:
Key(void);
Key(const Generator& g, int x, const Point& Q);//生成元g,私钥x，公钥Q
virtual ~Key(void);
const Point& getPublicKey()const;
const int getPrivateKey()const;
const Generator& getGenerator()const;
protected:
Generator m_g;//生成元
Point m_Q;//公钥
int m_x;//私钥
};

复制代码

（3）stdafx.h

// stdafx.h : 标准系统包含文件的包含文件，
// 或是经常使用但不常更改的
// 特定于项目的包含文件
//
#pragma once
//#include "targetver.h"
#include <SDKDDKVer.h>
#include <stdio.h>
#include <tchar.h>
#include <memory>
#include <iostream>
#include <algorithm>
// TODO: 在此处引用程序需要的其他头文件
struct Point {//表示平面上的一个点
int X;
int Y;
Point(int x = 0, int y = 0)//构造函数
{
this->X = x;
this->Y = y;
}
Point(const Point& p)//拷贝构造函数
{
this->X = p.X;
this->Y = p.Y;
}
bool operator==(const Point& p)const//判断两点是否相等
{
return this->X == p.X && this->Y == p.Y;
}
bool operator!=(const Point& p)const//判断两点是否不等
{
return this->X != p.X || this->Y != p.Y;
}
friend std::ostream& operator<<(std::ostream& out, const Point& p)//重载流输出运算符
{
if (p.isInfinity())
{
out << "(∞,∞)";
}
else
{
out << '(' << p.X << ',' << p.Y << ')';
}
return out;
}
bool isZero()const//判断是否是原点
{
return this->X == 0 && this->Y == 0;
}
bool isInfinity()const//判断是无穷远点
{
return this->X == INT_MAX || this->Y == INT_MAX;
}
static const Point Infinity()//无穷远点
{
static const Point p(INT_MAX, INT_MAX);
return p;
}
};
struct Generator {//表示一个生成元
Point Value;//生成元,点P
int Order;//点P的阶，即满足nP=O的最小正整数n
Generator() {}
Generator(const Point& p, int o)
{
this->Value.X = p.X;
this->Value.Y = p.Y;
this->Order = o;
}
bool operator==(const Generator& g)const//判断两个生成元是否相等
{
return this->Value == g.Value && this->Order == g.Order;
}
bool operator!=(const Generator& g)const//判断两个生成元是否不相等
{
return !(*this == g);
}
friend std::ostream& operator<<(std::ostream& out, const Generator& g)
{
out << g.Value << "=>" << g.Order;
return out;
}
};
struct Cipher {//表示一个字符经过ECC加密后所对应的密文
Point C1;//C1=kP
Point C2;//C2=Pm+kQ
Cipher(const Point& c1, const Point& c2)
{
this->C1.X = c1.X;
this->C1.Y = c1.Y;
this->C2.X = c2.X;
this->C2.Y = c2.Y;
}
friend std::ostream& operator<<(std::ostream& out, const Cipher& c)
{
out << '[' << c.C1 << ' ' << c.C2 << ']';
return out;
}
};
struct Dictionary {//表示由字符串构成的字符集
private:
unsigned char mCharValueSet[256];
int mHash[256];
int Count;
public:
Dictionary(void)//初始化一个空字典
{
memset(mCharValueSet, 0, sizeof(mCharValueSet));
memset(mHash, 0, sizeof(mHash));
this->Count = 0;
}
Dictionary(const char* str)//由给定的字符串初始化一个字典
{
memset(mCharValueSet, 0, sizeof(mCharValueSet));
memset(mHash, 0, sizeof(mHash));
this->Count = 0;
unsigned char i = 0;
while (*str != '\0')
{
i = *str;
mHash[i]++;
str++;
}
for (int i = 0; i < 256; i++)
{
if (mHash[i] != 0)
{
mCharValueSet[this->Count] = i;
mHash[i] = this->Count;
this->Count++;
}
}
}
int getIndex(unsigned char ch)const//获取某个字符在字典中的下标
{
//return std::lower_bound(mCharValueSet,mCharValueSet+Count,ch)-mCharValueSet;//二分查找
return mHash[ch];//哈希查找
}
unsigned char getChar(int i)const//获取指定索引处的字符
{
return mCharValueSet[i];
}
};

复制代码

唐乐 · 发表于 2022-6-2 08:59:15

2.源文件
（1）ECC.cpp

#include "StdAfx.h"
#include "ECC.h"
#include <math.h>
#include <sstream>
//E29(4,20) G(13,23) ord(G)=37 x=25,Q(14,6)
//k=6
ECC::ECC(int a = 4, int b = 20, int p = 29)
{
this->mA = a;
this->mB = b;
this->mP = p;
this->getAllPoints();
this->getAllOrders();
}
ECC::~ECC(void)
{
}
//计算曲线上的点
void ECC::getAllPoints()
{
int left, right = 0;
for (int x = 0; x < mP; x++)
{
right = x * x * x + mA * x + mB;//先计算式子右边的值
for (int y = 0; y < mP; y++)//判断右边是不是左边的平方剩余
{
left = y * y;
if (mod(left, mP) == mod(right, mP))//如果两边相等
{
mPoints.push_back(Point(x, y));//则该点在曲线上
}
}
}
}
//计算所有生成元的阶
void ECC::getAllOrders()
{
for (std::vector<Point>::const_iterator it = mPoints.begin(); it != mPoints.end(); it++)
{
mGenerators.push_back(Generator(*it, getOrder(*it)));
}
}
int ECC::getOrder(const Point& p)
{
int i = 1;
Point q = add(p, p);
while (q != p && q.isInfinity() == false)
{
i++;
q = add(p, q);
}
return ++i;
}
int ECC::ex_gcd(int a, int b, int& x, int& y)
{
if (b == 0)
{
x = 1;
y = 0;
return a;
}
int ans = this->ex_gcd(b, a % b, x, y);
int tmp = x;
x = y;
y = tmp - a / b * y;
return ans;
}
int ECC::getInverse(int a, int p)
{
int x, y;
int n = ex_gcd(a, p, x, y);
if (1 % n != 0) return -1;
x *= 1 / n;
p = abs(p);
int ans = x % p;
if (ans <= 0) ans += p;
return ans;
}
Point ECC::getMultiplePoint(int k, const Point& p)
{
Point q(p);
for (int i = 1; i < k; i++)
{
q = add(p, q);
}
return q;
}
Point ECC::add(const Point& p, const Point& q)
{
int lambda, m, n;//斜率lambda=m/n
int x, y;
if (p.isInfinity())//p是无穷远点P+Q=O+Q=Q
{
return q;
}
if (q.isInfinity())//q是无穷远点P+Q=P+O=P
{
return p;
}
if (p == q)//P=Q
{
m = mod(3 * p.X * p.X + mA, mP);
n = mod(2 * p.Y, mP);
//n不能为0，0没有乘法逆元
}
else//P≠Q
{
m = mod(q.Y - p.Y, mP);
n = mod(q.X - p.X, mP);
//n不能为0
//如果n=0,P、Q横坐标相同，即P、Q互逆P+Q=P+(-P)=O
}
if (n == 0)
{
return Point::Infinity();
}
lambda = mod(m * getInverse(n, mP), mP);
x = mod(lambda * lambda - p.X - q.X, mP);
y = mod(lambda * (p.X - x) - p.Y, mP);
return Point(x, y);
}
int ECC::mod(int a, int p)
{
if (a >= 0)
{
return a % p;
}
else
{
return ((a % p) + p) % p;
}
}
void ECC::encrypt(const std::vector<Point>& Pm, Key& key, std::vector<Cipher>& result, int k)
{
bool flag = k <= 1 || k > key.getGenerator().Order;
//开始加密
for (std::vector<Point>::const_iterator it = Pm.begin(); it != Pm.end(); it++)
{
if (flag)//如果k不符合条件
{
k = rand() % (key.getGenerator().Order - 1) + 1;//随机选取整数k,满足1<k<n
}
Point C1 = getMultiplePoint(k, key.getGenerator().Value);//C1=kP
Point C2 = add(*it, getMultiplePoint(k, key.getPublicKey()));//C2=Pm+kQ
result.push_back(Cipher(C1, C2));//密文c=(C1,C2)
}
}
void ECC::encodePlainText(const char* plainText, std::vector<Point>& result)
{
mDictionary = Dictionary(plainText);
while (*plainText != '\0')
{
int index = mDictionary.getIndex(*plainText);//获取该字符在字典中的索引
//把该字符映射到曲线上的一个点,如果字典中元素个数多于曲线上点的个数，会发生数组越界
result.push_back(mPoints[index]);
plainText++;
}
}
void ECC::decodePlainPoints(const std::vector<Point>& Pm, std::string& result)
{
std::stringstream ss;
for (std::vector<Point>::const_iterator it = Pm.begin(); it != Pm.end(); it++)
{
for (unsigned int i = 0; i < mPoints.size(); i++)
{
if (mPoints[i] == *it)
{
unsigned char ch = mDictionary.getChar(i);
ss << ch;
break;
}
}
}
ss >> result;
}
void ECC::decrypt(const std::vector<Cipher>& ciphers, int x, std::vector<Point>& result)
{
for (std::vector<Cipher>::const_iterator it = ciphers.begin(); it != ciphers.end(); it++)
{
Point C1R = Point(it->C1.X, -it->C1.Y);//求C1的加法逆元P+(-P)=(x,y)+(x,-y)=O
Point Pm = add(it->C2, getMultiplePoint(x, C1R));
result.push_back(Pm);
}
}
bool ECC::isPrime(int n)
{
if (n < 2)
return false;
if (n == 2 || n == 3)
return true;
if (n % 6 != 1 && n % 6 != 5)
return false;
float n_sqrt = floor(sqrt((float)n));
for (int i = 5; i <= n_sqrt; i += 6)
{
if (n % i == 0 || n % (i + 2) == 0)
return false;
}
return true;
}
//g是生成元,x是私钥
void ECC::genKey(Key& result, int gIndex, int x)
{
int n;
Generator G;
if (gIndex < 0 || isPrime(mGenerators[gIndex].Order) == false)
{
do
{
gIndex = rand() % mGenerators.size();//随机选取一个阶为n的生成元,在数组中的下标为index
n = mGenerators[gIndex].Order;
} while (isPrime(n) == false);//如果选取的生成元的阶数不是素数，就重新选取
}
else
{
n = mGenerators[gIndex].Order;
}
G = mGenerators[gIndex];//最终选择的生成元
if (x >= n || x <= 1)//传入的私钥不对
{
x = rand() % (n - 1) + 1;//随机选取整数x,满足1<x<n
}
Point Q = getMultiplePoint(x, G.Value);//计算Q=xG
result = Key(G, x, Q);//生成元为mGenerators[index]，公钥为Q，私钥为x
}
const std::vector<Generator> ECC::getGenerators()const
{
return mGenerators;
}

复制代码

（2）Key.cpp

#include "StdAfx.h"
#include "Key.h"
Key::Key(const Generator& g, int x, const Point& Q)
{
this->m_g = g;
this->m_Q = Q;
this->m_x = x;
}
Key::Key(void)
{
}
Key::~Key(void)
{
}
const Point& Key::getPublicKey()const
{
return m_Q;
}
const int Key::getPrivateKey()const
{
return m_x;
}
const Generator& Key::getGenerator()const
{
return m_g;
}

复制代码

（3）Test.cpp

#include "stdafx.h"
#include "ECC.h"
#include <stdlib.h>
#include <string>
#include <iomanip>
#include <vector>
using namespace std;
template <typename T>
void print(const vector<T>& list)//打印数组内容
{
for (unsigned int i = 0; i < list.size(); i++)
{
if (i % 4 == 0)
{
cout << endl;
}
cout << setw(3) << setfill(' ') << i << "、" << list[i] << "\t\t";
}
cout << endl;
cout << "-------------------------------------------------------" << endl;
}
int main()
{
int a, b, p, x, k;
Key key;
cout << "椭圆曲线方程为：" << "y^2 = x^3 + ax + b (mod p)" << endl;
//选取方程参数
input: cout << "请输入a的值（a是整数，a>0）：";
cin >> a;
cout << "请输入b的值（b是整数，b>0）：";
cin >> b;
cout << "请输入p的值（p是大素数，但目前用Int32表示）：";
cin >> p;
if (ECC::isPrime(p) == false)
{
cout << "p不是素数，请重新输入！" << endl;
goto input;
}
if ((4 * (a * a * a) + 27 * (b * b)) % p == 0)
{//当4a^3+27b^2≠0时，是一条非奇异椭圆曲线，此时可以在E(a,b)定义一个阿贝尔群
cout << "输入的参数有误，请重新输入！" << endl;
goto input;
}
//初始化椭圆曲线方程
ECC ecc(a, b, p);
//获取所有生成元以及对应的阶
vector<Generator> generators = ecc.getGenerators();
cout << "下面是生成元及对应的阶数：" << endl;
print(generators);
//选择基点G
cout << "请选择基点G（x,y）的序号：";//G=P
cin >> k;
//输入私钥
cout << "请输入私钥（x<" << generators[k].Order << "）：x = ";
cin >> x;
//产生公私钥对
ecc.genKey(key, k, x);
if (generators[k] != key.getGenerator())
{
cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl;
cout << "你选择的生成元为：G = " << generators[k] << endl;
cout << "该生成元的阶数为：ord(G) = " << generators[k].Order << ",不是素数" << endl;
cout << "生成元已自动变更为：G = " << key.getGenerator() << endl;
cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl;
}
cout << "生成的公钥为：Q = " << key.getPublicKey() << endl;
cout << "目前的私钥为：x = " << key.getPrivateKey() << endl;
//输入随机数k
cout << "请输入k的值来计算 kG,kQ+Pm，输入负数使用随机值（1<k<" << key.getGenerator().Order << "）：k = ";
cin >> k;
vector<Point> encodedPoints;
vector<Cipher> cipheredPoints;
//将明文m编码为椭圆曲线上的点
char text[]="";
cout << "请输入需要加密的字符串：";
cin >> text;
char* plainText = text;
ecc.encodePlainText(plainText, encodedPoints);
cout << "编码后的明文点集为：Pme = " << endl;
print(encodedPoints);
//加密
ecc.encrypt(encodedPoints, key, cipheredPoints, k);
cout << "加密后的密文点集为：Pc = " << endl;
print(cipheredPoints);
vector<Point> decryptedPoints;
string decodedText;
//解密
ecc.decrypt(cipheredPoints, key.getPrivateKey(), decryptedPoints);
cout << "解密后的明文点集为：Pm = " << endl;
print(decryptedPoints);
//解码明文点集，得到明文字符串
ecc.decodePlainPoints(decryptedPoints, decodedText);
cout << "解码后的字符串明文为：" << endl;
cout << decodedText << endl;
system("Pause");
return 0;
}

复制代码

三、运行截图

		自动登录	找回密码
密码			立即注册

信息计算2019级1班5号唐乐

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

浏览过的版块