信息计算2019级2班10号蔡冉平

信计2班蔡冉平 · 发表于 2022-6-2 13:48:29

本帖最后由信计2班蔡冉平于 2022-6-2 14:17 编辑

RSA加密、解密及签名

   RSA密码体制是一种公钥密码体制，公钥公开，私钥保密，它的加密解密算法是公开的。由公钥加密的内容可以并且只能由私钥进行解密，并且由私钥加密的内容可以并且只能由公钥进行解密。也就是说，RSA的这一对公钥、私钥都可以用来加密和解密，并且一方加密的内容可以由并且只能由对方进行解密。                                                                                                                                          加密，是指对某个内容加密，加密后的内容还可以通过解密进行还原。例如对信件进行加密，加密后的内容在网络上进行传输，接收者在收到后，通过解密可以还原信件的真实内容。
      RSA的加密过程如下：
　　（1）A生成一对密钥（公钥和私钥），私钥不公开，A自己保留。公钥为公开的，任何人可以获取。
　　（2）A传递自己的公钥给B，B用A的公钥对消息进行加密。
　　（3）A接收到B加密的消息，利用A自己的私钥对消息进行解密。
   签名，就是在信息的后面再加上一段内容，可以证明信息没有被修改过。一般是对信息做一个hash计算得到一个hash值，注意，这个过程是不可逆的，也就是说无法通过hash值得出原来的信息内容。在把信息发送出去时，把这个hash值加密后做为一个签名和信息一起发出去。接收方在收到信息后，会重新计算信息的hash值，并和信息所附带的hash值(解密后)进行对比，如果一致，就说明信息的内容没有被修改过，因为这里hash计算可以保证不同的内容一定会得到不同的hash值，所以只要内容一被修改，根据信息内容计算的hash值就会变化。
   RSA签名的过程如下：
　　（1）A生成一对密钥（公钥和私钥），私钥不公开，A自己保留。公钥为公开的，任何人可以获取。
　　（2）A用自己的私钥对消息加签，形成签名，并将加签的消息和消息本身一起传递给B。
　　（3）B收到消息后，在获取A的公钥进行验签，如果验签出来的内容与消息本身一致，证明消息是A回复的。

信计2班蔡冉平 · 发表于 2022-6-2 14:11:33

本帖最后由信计2班蔡冉平于 2022-6-2 14:13 编辑

package mm;
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 mmRSA{
public static final String SIGN_ALGORITHMS = "SHA1WithRSA";
public static final String KEY_ALGORITHM = "RSA";
private static final int MAX_ENCRYPT_BLOCK = 117;
private static final int MAX_DECRYPT_BLOCK = 128;
/**
* RSA签名
* content 待签名数据
* privateKey 商户私钥
* 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验签名检查
*content 待签名数据
* sign 签名值
*ali_public_key 支付宝公钥
* 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;
}
/**
* 私钥解密
* content 密文
* private_key 商户私钥
* 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();
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);
}
/**
* 公钥加密
* data 源数据
* publicKey 公钥(BASE64编码)
*/
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;
}
/**
* 得到私钥
* key 密钥字符串（经过base64编码）
* 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 = "treat the world well";
byte[] ens = mmRSA.encryptByPublicKey(sourceStr.getBytes(),pubKey);
String encodes = Base64_.encode(ens);
System.out.println("加密后密文:"+ encodes);
String res2 = mmRSA.decrypt(encodes, priKey, "UTF-8");
System.out.println("解密后密文:"+res2);
//签名验证，私钥签名，公钥验证是否正确!
String source = "id=shoig&name=shoer&age=23dnjlegj;reg";
String sign = mmRSA.sign(source, priKey, "UTF-8");
System.out.println("签名是："+sign);
// 公钥验证签名是否正确.
// 具体流程是，请求参数+sign发送给公钥方，然后公钥方过滤掉sign，用公钥验证其他参数是否通过。
boolean result = mmRSA.verify(source, sign, pubKey, "UTF-8");
System.out.println("签名验证结果:"+result);
}
}

复制代码

信计2班蔡冉平 · 发表于 2022-6-2 21:18:41

本帖最后由信计2班蔡冉平于 2022-6-2 21:40 编辑

ECC/椭圆曲线加密算法

RSA的解决分解整数问题需要亚指数时间复杂度的算法，而目前已知计算椭圆曲线离散对数问题(ECDLP)的最好方法都需要全指数时间复杂度。这意味着在椭圆曲线系统中我们只需要使用相对于RSA 短得多的密钥就可以达到与其相同的安全强度。

椭圆曲线加密算法于1985年提出，由于自身优点，它一出现便受到关注，现在密码学界普遍认为它将替代RSA加密算法成为通用的公钥加密算法。ECC是基于椭圆曲线数学理论实现的一种非对称加密算法。相比RSA，ECC优势是可以使用更短的密钥，来实现与RSA相当或更高的安全。椭圆曲线加密系统是迄今为止每比特具有最高安全强度的加密系统,它被认为最有希望成为下一代通用的公钥加密系统。

ECC算法中的关键变量

（1）基点：基点G，G为椭圆曲线Ep(a,b)上的点
（2）阶：如果椭圆曲线上一点P，存在最小的正整数n使得数乘n P = O ∞ ,则将n称为P的阶，若n不存在，则P是无限阶的.
（3）公钥K：则给定私钥k和基点G，根据加法法则，计算K很容易但反过来，给定K和G，求k就非常困难。因为实际使用中的ECC原则上把p取得相当大，n也相当大，要把n个解点逐一算出来列成上表是不可能的。
   下面是利用椭圆曲线进行加密通信的过程：
   1、用户A选定一条椭圆曲线Ep(a,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计算点C 1=M+rK和C 2=rG。
   6、用户B将C 1 、 C 2 传给用户A。
   7、用户A接到信息后，计算C 1 − k C 2结果就是点M。再对点M进行解码就可以得到明文。
   因为C 1−k C 2 = M+rK−k(rG)=M+rkG−krG=M
   代码会用到两个结构体，一个结构体用来装在有限域上的椭圆，里面的变量有他们的阶，x,y,序号，还有另外的一个结构体数组，这是来装这些点对应的mP的坐标，这里的m从-1到阶没有 0 ，这个数组的下标就是m ，m为0 对应-P，这样将他的所有mP 保存起来，用于计算阶，以及后面的加密需要用到mp 。
   选择一个椭圆上的点作为基点，然后选择一个私钥，私钥k小于这个基点的阶n，生成公开密钥K=kG。这里选择基点是靠输入基点的序号，根据序号找到基点，在调取基点结构体中的数组，找到下标为k的数组，里面的坐标就是kG,因为计算了阶，所以已经有kG的值了。

信计2班蔡冉平 · 发表于 2022-6-2 21:40:50

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<time.h>
#define MAX 100
typedef struct point{
int point_x;
int point_y;
}Point;
typedef struct ecc{
struct point p[MAX];
int len;
}ECCPoint;
typedef struct generator{
Point p;
int p_class;
}GENE_SET;
void get_all_points();
int int_sqrt(int s);
Point timesPiont(int k,Point p);
Point add_two_points(Point p1,Point p2);
int inverse(int n,int b);
void get_generetor_class();
void encrypt_ecc();
void decrypt_ecc();
int mod_p(int s);
void print();
int isPrime(int n);
char alphabet[26]="abcdefghijklmnopqrstuvwxyz";
int a=-1,b=0,p=89;//椭圆曲线为E89(-1,0)： y2=x3-x (mod 89)
ECCPoint eccPoint;
GENE_SET geneSet[MAX];
int geneLen;
char plain[]="plaintext";
int m[MAX];
int cipher[MAX];
int nB;//私钥
Point P1,P2,Pt,G,PB;
Point Pm;
int C[MAX];
//task4:加密
void encrypt_ecc()
{
int num,i,j;
int gene_class;
int num_t;
int k;
srand(time(NULL));
printf("\n\n\n明文为：\n");
for(i=0;i<strlen(plain);i++)
printf("%c",plain[i]);
for(i=0;i<strlen(plain);i++)//明文转换
{
for(j=0;j<26;j++)
{
if(plain[i]==alphabet[j])
{
m[i]=j;//将字符串明文换成数字，并存到整型数组m里面
}
}
} //选择生成元
num=rand()%geneLen;
gene_class=geneSet[num].p_class;
while(isPrime(gene_class)==-1)//不是素数
{
num=rand()%(geneLen-3)+3;
gene_class=geneSet[num].p_class;
}
G=geneSet[num].p;
nB=rand()%(gene_class-1)+1;//选择私钥
PB=timesPiont(nB,G);
printf("\n\n公钥：");
printf("{y^2=x^3%d*x+%d,%d,(%d,%d),(%d,%d)}\n",a,b,gene_class,G.point_x,G.point_y,PB.point_x,PB.point_y);
printf("私钥：");
printf("nB=%d\n",nB);
k=rand()%(gene_class-2)+1;
P1=timesPiont(k,G);
num_t=rand()%eccPoint.len; //选择映射点
Pt=eccPoint.p[num_t];
P2=timesPiont(k,PB);
Pm=add_two_points(Pt,P2);
printf("加密数据：\n");
printf("kG=(%d,%d),Pt+kPB=(%d,%d),C={",P1.point_x,P1.point_y,Pm.point_x,Pm.point_y);
for(i=0;i<strlen(plain);i++)
{
C[i]=m[i]*Pt.point_x+Pt.point_y;//选择映射点
printf("{%d}",C[i]);
}
printf("}\n\n");
}
//task5:解密
void decrypt_ecc()
{
Point temp,temp1;
int m,i;
temp=timesPiont(nB,P1);
temp.point_y=0-temp.point_y;
temp1=add_two_points(Pm,temp);//求解Pt
printf("\n解密：\n");
for(i=0;i<strlen(plain);i++)
{
m=(C[i]-temp1.point_y)/temp1.point_x;
printf("%c",alphabet[m]);//输出密文
}
printf("\n\n\n");
}
//判断是否为素数
int isPrime(int n)
{
int i,k;
k = sqrt(n);
for (i = 2; i <= k;i++)
{
if (n%i == 0)
break;
}
if (i <=k){
return -1;
}
else {
return 0;
}
}
//task3:求生成元以及阶
void get_generetor_class()
{
int i,j=0;
int count=1;
Point p1,p2;
get_all_points();
printf("\n**********************************输出生成元以及阶：*************************************\n");
for(i=0;i<eccPoint.len;i++)
{
count=1;
p1.point_x=p2.point_x=eccPoint.p[i].point_x;
p1.point_y=p2.point_y=eccPoint.p[i].point_y;
while(1)
{
p2=add_two_points(p1,p2);
if(p2.point_x==-1 && p2.point_y==-1)
{
break;
}
count++;
if(p2.point_x==p1.point_x)
{
break;
}
}
count++;
if(count<=eccPoint.len+1)
{
geneSet[j].p.point_x=p1.point_x;
geneSet[j].p.point_y=p1.point_y;
geneSet[j].p_class=count;
printf("(%d,%d)--->>%d\t",geneSet[j].p.point_x,geneSet[j].p.point_y,geneSet[j].p_class);
j++;
if(j % 6 ==0){
printf("\n");
}
}
geneLen=j;
}
}
//task2:倍点运算的递归算法
Point timesPiont(int k,Point p0)
{
if(k==1){
return p0;
}
else if(k==2){
return add_two_points(p0,p0);
}else{
return add_two_points(p0,timesPiont(k-1,p0));
}
}
//两点的加法运算
Point add_two_points(Point p1,Point p2)
{
long t;
int x1=p1.point_x;
int y1=p1.point_y;
int x2=p2.point_x;
int y2=p2.point_y;
int tx,ty;
int x3,y3;
int flag=0;
if((x2==x1)&& (y2==y1) )
{
if(y1==0)
{
flag=1;
}else{
t=(3*x1*x1+a)*inverse(p,2*y1) % p;
}
}else{
ty=y2-y1;
tx=x2-x1;
while(ty<0)
{
ty+=p;
}
while(tx<0)
{
tx+=p;
}
if(tx==0 && ty !=0)
{
flag=1;
}else{
t=ty*inverse(p,tx) % p;
}
}
if(flag==1)
{
p2.point_x=-1;
p2.point_y=-1;
}else{
x3=(t*t-x1-x2) % p;
y3=(t*(x1-x3)-y1) % p;
while(x3<0) //使结果在有限域GF(P)上
{
x3+=p;
}
while(y3<0)
{
y3+=p;
}
p2.point_x=x3;
p2.point_y=y3;
}
return p2;
}
int inverse(int n,int b) //求b关于n的逆元
{
int q,r,r1=n,r2=b,t,t1=0,t2=1,i=1;
while(r2>0)
{
q=r1/r2;
r=r1%r2;
r1=r2;
r2=r;
t=t1-q*t2;
t1=t2;
t2=t;
}
if(t1>=0)
return t1%n;
else{
while((t1+i*n)<0)
i++;
return t1+i*n;
}
}
void get_all_points()//求出椭圆曲线上所有点
{
int i=0;
int j=0;
int s,y=0;
int n=0,q=0;
int modsqrt=0;
int flag=0;
if (4 * a * a * a + 27 * b * b != 0)
{
for(i=0;i<=p-1;i++)
{
flag=0;
n=1;
y=0;
s= i * i * i + a * i + b;
while(s<0)
{
s+=p;
}
s=mod_p(s);
modsqrt=int_sqrt(s);
if(modsqrt!=-1)
{
flag=1;
y=modsqrt;
}else{
while(n<=p-1)
{
q=s+n*p;
modsqrt=int_sqrt(q);
if(modsqrt!=-1)
{
y=modsqrt;
flag=1;
break;
}
flag=0;
n++;
}
}
if(flag==1)
{
eccPoint.p[j].point_x=i;
eccPoint.p[j].point_y=y;
j++;
if(y!=0)
{
eccPoint.p[j].point_x=i;
eccPoint.p[j].point_y=(p-y) % p;
j++;
}
}
}
eccPoint.len=j;//点集个数
print(); //打印点集
}
}
int mod_p(int s)//取模函数
{
int i; //保存s/p的倍数
int result; //模运算的结果
i = s / p;
result = s - i * p;
if (result >= 0)
{
return result;
}
else
{
return result + p;
}
}
int int_sqrt(int s)//判断平方根是否为整数
{
int temp;
temp=(int)sqrt(s);//转为整型
if(temp*temp==s)
{
return temp;
}else{
return -1;
}
}
void print() //打印点集
{
int i;
int len=eccPoint.len;
printf("\n该椭圆曲线上共有%d个点(包括无穷远点)\n",len+1);
for(i=0;i<len;i++)
{
if(i % 8==0)
{
printf("\n");
}
printf("(%2d,%2d)\t",eccPoint.p[i].point_x,eccPoint.p[i].point_y);
}
printf("\n");
}
int main()
{
get_generetor_class();
encrypt_ecc();
decrypt_ecc();
return 0;
}

复制代码

信计2班蔡冉平 · 发表于 2022-6-2 21:42:34

运行结果为：

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

信息计算2019级2班10号蔡冉平

本帖子中包含更多资源

本帖子中包含更多资源

浏览过的版块