信息计算2019级2班23号唐天玮

唐天玮 · 发表于 2022-5-30 22:00:51

本帖最后由唐天玮于 2022-5-30 22:03 编辑

RSA加密及签名的实现

一、加解密过程简述

A和B进行通信加密,B要先生成一对RSA密钥,B自己持有私钥,给A公钥 —>A使用B的公钥加密要发送的内容,然后B接收到密文后通过自己的私钥解密内容。

二、签名验签过程简述

A给B发送消息,A先计算出消息的消息摘要,然后使用自己的私钥加密消息摘要,被加密的消息摘要就是签名.(A用自己的私钥给消息摘要加密成为签名)。

B收到消息后,也会使用和A相同的方法提取消息摘要,然后用A的公钥解密签名,并与自己计算出来的消息摘要进行比较–>如果相同则说明消息是A发送给B的,同时,A也无法否认自己发送消息给B的事实.(B使用A的公钥解密签名文件的过程,叫做"验签")。

三、签名和验签过程详细理解

签名过程：

（1）. A计算消息m的消息摘要,记为 h(m)

（2）. A使用私钥(n,d)对h(m)加密,生成签名s, s满足:s=(h(m))^d mod n;

由于A是用自己的私钥对消息摘要加密,所以只用使用s的公钥才能解密该消息摘要,这样A就不可否认自己发送了该消息给B

（3）. A发送消息和签名(m,s)给B

验签过程:

（1）. B计算消息m的消息摘要(计算方式和A相同),记为h(m)

（2）. B使用A的公钥(n,e)解密s,得到 H(m), H(m) = s^e mod n

（3）. B比较H(m)与h(m),相同才能证明验签成功

四、代码部分

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import javax.crypto.Cipher;
public class RSAUtil{
public static final String SIGN_ALGORITHMS = "SHA1WithRSA";
/**加密算法RSA*/
public static final String KEY_ALGORITHM = "RSA";
/**RSA最大加密明文大小*/
private static final int MAX_ENCRYPT_BLOCK = 117;
/**RSA最大解密密文大小*/
private static final int MAX_DECRYPT_BLOCK = 128;
/**
* RSA签名
* @param content 待签名数据
* @param privateKey 商户私钥
* @param input_charset 编码格式
*/
public static String sign(String content, String privateKey, String input_charset){
try {
PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Base64_.decode(privateKey) );
KeyFactory keyf = KeyFactory.getInstance(KEY_ALGORITHM);
PrivateKey priKey = keyf.generatePrivate(priPKCS8);
java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
signature.initSign(priKey);
signature.update(content.getBytes(input_charset));
byte[] signed = signature.sign();
return Base64_.encode(signed);
}catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* RSA验签名检查
* @param content 待签名数据
* @param sign 签名值
* @param ali_public_key 支付宝公钥
* @param input_charset 编码格式
*/
public static boolean verify(String content, String sign, String ali_public_key, String input_charset){
try {
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
byte[] encodedKey = Base64_.decode(ali_public_key);
PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
signature.initVerify(pubKey);
signature.update(content.getBytes(input_charset) );
boolean bverify = signature.verify( Base64_.decode(sign) );
return bverify;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/**
* 私钥解密
* @param content 密文
* @param private_key 商户私钥
* @param input_charset 编码格式
*/
public static String decrypt(String content, String private_key, String input_charset) throws Exception {
PrivateKey prikey = getPrivateKey(private_key);
Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, prikey);
InputStream ins = new ByteArrayInputStream(Base64_.decode(content));
ByteArrayOutputStream writer = new ByteArrayOutputStream();
//rsa解密的字节大小最多是128，将需要解密的内容，按128位拆开解密
byte[] buf = new byte[128];
int bufl;
while ((bufl = ins.read(buf)) != -1) {
byte[] block = null;
if (buf.length == bufl) {
block = buf;
} else {
block = new byte[bufl];
for (int i = 0; i < bufl; i++) {
block[i] = buf[i];
}
}
writer.write(cipher.doFinal(block));
}
return new String(writer.toByteArray(), input_charset);
}
/**
* 公钥加密
* @param data 源数据
* @param publicKey 公钥(BASE64编码)
*/

复制代码

唐天玮 · 发表于 2022-5-30 22:04:20

本帖最后由唐天玮于 2022-5-30 22:05 编辑

public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
byte[] keyBytes = Base64_.decode(publicKey);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
Key publicK = keyFactory.generatePublic(x509KeySpec);
// 对数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, publicK);
int inputLen = data.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段加密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
} else {
cache = cipher.doFinal(data, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_ENCRYPT_BLOCK;
}
byte[] encryptedData = out.toByteArray();
out.close();
return encryptedData;
}
public static String encryptByPublicKeyToStr(byte[] data, String publicKey) throws Exception {
byte[] bytes = encryptByPublicKey(data, publicKey);
String result = Base64_.encode(bytes);
return result;
}
/**
* 得到私钥
* @param key 密钥字符串（经过base64编码）
* @throws Exception
*/
public static PrivateKey getPrivateKey(String key) throws Exception {
byte[] keyBytes;
keyBytes = Base64_.decode(key);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
return privateKey;
}
public static class Base64_ {
private static final Base64.Decoder decoder = Base64.getDecoder();
private static final Base64.Encoder encoder = Base64.getEncoder();
public static byte[] decode(String key) {
if (key == null) { return null;}
byte[] decode = decoder.decode(key);
return decode;
}
public static String encode(byte[] content) {
if (content == null) {return null;}
String encode = encoder.encodeToString(content);
return encode;
}
}
/**
* 测试
*/
public static void main(String args[]) throws Exception{
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
keyPairGen.initialize(1024);
KeyPair keyPair = keyPairGen.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
String pubKey = Base64_.encode(publicKey.getEncoded()); //公钥
String priKey = Base64_.encode(privateKey.getEncoded()); //私钥
// System.out.println(pubKey);
// System.out.println(priKey);
//....公钥加密，私钥解密！
String sourceStr = "密码学";
//公钥加密
byte[] ens = RSAUtil.encryptByPublicKey(sourceStr.getBytes(),pubKey);
String encodes = Base64_.encode(ens);
System.out.println(encodes);
//私钥解密
String res2 = RSAUtil.decrypt(encodes, priKey, "UTF-8");
System.out.println(res2);
//....签名验证，私钥签名，公钥验证是否正确!
String source = "id=shoig&name=shoer&age=23dnjlegj;reg"; //模拟请求参数,然后对此请求参数进行签名。
String sign = RSAUtil.sign(source, priKey, "UTF-8");
System.out.println("签名是："+sign);
// 公钥验证签名是否正确.
// 具体流程是，请求参数+sign发送给公钥方，然后公钥方过滤掉sign，用公钥验证其他参数是否通过。
boolean result = RSAUtil.verify(source, sign, pubKey, "UTF-8");
System.out.println(result);
}
}

复制代码

唐天玮 · 发表于 2022-5-30 22:15:19

本帖最后由唐天玮于 2022-5-30 22:23 编辑

唐天玮发表于 2022-5-30 22:04

ECC椭圆曲线上公钥密码
一、定义
椭圆曲线加密（ECC，Elliptic Curves Cryptography）也属于非对称加密公钥算法，与主流的RSA算法相比，ECC算法可以使用较短的密钥达到相同的安全程度。ECC是建立在基于椭圆曲线的离散对数问题上的密码体制，给定椭圆曲线上的一个点G，并选取一个整数k，求解K=kG很容易(注意根据kG求解出来的K也是椭圆曲线上的一个点)；反过来，在椭圆曲线上给定两个点K和G，若使K=kG，求整数k是一个难题。ECC就是建立在此数学难题之上,这一数学难题称为椭圆曲线离散对数问题。近年来，ECC逐步进入实际应用，如国家密码管理局颁布的SM2算法就是基于ECC算法的。

二、ECC安全性原理
K=kG，其中K,G为Ep（a,b）上的点，k为小于n的整数，n是点G的阶。
因此：K为公钥，k为私钥，G为基点。

三、源代码

#include<iostream>
#include<math.h>
#include<time.h>
using namespace std;
class point
{
public:
int x;
int y;
};
point P[100];
int num = 0;
//取模
int my_mod(int a, int p)
{
int i;
i = a / p;
int re = a - i * p;
if (re >= 0)
{
return re;
}
else
{
return re + p;
}
}
int my_pow(int a, int m, int p)
{
int result = 1;
for (int i = 0; i < m; i++)
{
result = (result * a) % p;
}
return result;
}
int my_sqrt(int s)
{
int t;
t = (int)sqrt(s);
if (t * t == s)
{
return t;
}
else {
return -1;
}
}
void all_points(int a, int b, int p)
{
for (int i = 0; i < p; i++)
{
int s = i * i * i + a * i + b;
while (s < 0)
{
s += p;
}
s = my_mod(s, p);
int re = my_pow(s, (p - 1) / 2, p);
if (re == 1)
{
//求y
int n = 1, y;
int f = my_sqrt(s);
if (f != -1)
{
y = f;
}
else
{
for (; n <= p - 1;)
{
s = s + n * p;
f = my_sqrt(s);
if (f != -1)
{
y = f;
break;
}
n++;
}
}

复制代码

唐天玮 · 发表于 2022-5-30 22:24:35

唐天玮发表于 2022-5-30 22:15
...

y = my_mod(y, p);
P[num].x = i;
P[num].y = y;
num++;
if (y != 0)
{
P[num].x = i;
P[num].y = (p - y) % p;
num++;
}
}
}
}
void show()
{
for (int i = 0; i < num; i++)
{
cout << P[i].x << " " << P[i].y << endl;
}
}
int extend(int a, int b, int& x, int& y)
{
if (b == 0)
{
x = 1;
y = 0;
return a;
}
int r = extend(b, a % b, x, y);
int t = x;
x = y;
y = t - a / b * y;
return r;
}
//递归扩展欧几里得求逆
int inv(int a, int b)
{
int x, y;
int r = extend(a, b, x, y);
if (r != 1)
{
return 0;
}
x = x % b;
if (x < 0)
{
x = x + b;
}
return x;
}
//加法运算
point add(point p1, point p2, int a, int p)
{
long t; int flag = 0;
int x1 = p1.x; int y1 = p1.y;
int x2 = p2.x; int y2 = p2.y;
int tx, ty; int x3, y3;
if ((x2 == x1) && (y2 == y1))
{
//相同点
if (y1 == 0)
{
flag = 1;
}
else
{
t = (3 * x1 * x1 + a) * inv(2 * y1, p) % p;
}
}
else
{
//不同点
ty = y2 - y1;
tx = x2 - x1;
while (tx < 0)
{
tx = tx + p;
}
while (ty < 0)
{
ty = ty + p;
}
if (tx == 0 && ty != 0)
{
flag = 1;
}
else
{
//点不相等
t = ty * inv(tx, p) % p;
}
}
if (flag == 1)
{
//无限点
p2.x = -1;
p2.y = -1;
}
else
{
x3 = (t * t - x1 - x2) % p;
y3 = (t * (x1 - x3) - y1) % p;
while (x3 < 0)
{
x3 += p;
}
while (y3 < 0)
{
y3 += p;
}
p2.x = x3;
p2.y = y3;
}
return p2;
}
//随机选取一个生成元并计算阶
int jie(point& pp, int a, int p)
{
int ii = rand() % num;
point P0 = P[ii];
point p1, p2;
int number = 1;

复制代码

唐天玮 · 发表于 2022-5-30 22:24:57

唐天玮发表于 2022-5-30 22:24

p1.x = P0.x; p2.x = P0.x;
p1.y = P0.y; p2.y = P0.y;
while (true)
{
p2 = add(p1, p2, a, p);
if (p2.x == -1 && p2.y == -1)
{
break;
}
number++;
if (p2.x == p1.x)
{
break;
}
}
pp.x = p1.x;
pp.y = p1.y;
int n = ++number;
return n;
}
//素数判断
bool judge(int num)
{
bool ret = true;
int ubound = sqrt(num) + 1;
for (int i = 2; i < ubound; i++)
{
if (num % i == 0)
{
ret = false;
break;
}
}
return ret;
}
//计算kG
point cal(point G, int k, int a, int p)
{
point temp = G;
for (int i = 0; i < k - 1; i++)
{
temp = add(temp, G, a, p);
}
return temp;
}
int main()
{
srand(time(NULL));
int a, b, p;
point generator; int n;
char SE[10];
char CR[10];
cout << "请输入椭圆曲线群（a,b,p）：";
cin >> a >> b >> p;
cout << "请输入明文：";
cin >> SE;
cout << "请输入密钥：";
cin >> CR;
//计算所有点
all_points(a, b, p);
//选取生成元，直到阶为素数
do
{
n = jie(generator, a, p);
} while (judge(n) == false);
cout << endl << "选取生成元（" << generator.x << "," << generator.y << "）,阶为：" << n << endl;
//选取私钥
int ka = int(CR[0]) % (n - 1) + 1;//选取使用的密钥
point pa = cal(generator, ka, a, p);//计算公钥
cout << "私钥：" << ka << endl;
cout << "公钥：（" << pa.x << "," << pa.y << "）" << endl;
//加密
int k = 0;//随机数k
k = rand() % (n - 2) + 1;
point C1 = cal(generator, k, a, p);//计算C1
//m嵌入到椭圆曲线
int t = rand() % num; //选择映射点
point Pt = P[t];
point P2 = cal(pa, k, a, p);
point Pm = add(Pt, P2, a, p);
cout << endl << "要发送的密文：" << endl;
cout << "kG=(" << C1.x << "," << C1.y << "),pt+kPa=(" << Pm.x << "," << Pm.y << ")";
int C[100];
cout << ",C = { ";
for (int i = 0; i < strlen(SE); i++)
{
C[i] = int(SE[i]) * Pt.x + Pt.y;//选取要加密的明文
cout << C[i] << " ";
}
cout << "}" << endl;
//解密
point temp, temp1;
int m;
temp = cal(C1, ka, a, p);
temp.y = 0 - temp.y;
temp1 = add(Pm, temp, a, p);//求解Pt
printf("\n解密结果：\n");
for (int i = 0; i < strlen(SE); i++)
{
m = (C[i] - temp1.y) / temp1.x;
printf("%c", char(m));//输出密文
}
printf("\n");
return 0;
}

复制代码

唐天玮 · 发表于 2022-5-30 22:26:12

唐天玮发表于 2022-5-30 22:24

如图所示：

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

信息计算2019级2班23号唐天玮

本帖子中包含更多资源

浏览过的版块