2. 首页 > 文章分类 > 生活百态

rsa在线加解密(rsa加密和解密c语言实现)

作者：小编 • 更新时间：2023-08-17 16:48:00 •阅读

今天给各位分享rsa在线加解密的知识，其中也会对rsa加密和解密c语言实现进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

如何实现用javascript实现rsa加解密

具体实现思路如下：

1。服务端生成公钥与私钥，保存。

2。客户端在请求到登录页面后，随机生成一字符串。

3。后此随机字符串作为密钥加密密码，再用从服务端获取到的公钥加密生成的随机字符串。

4。将此两段密文传入服务并清端，服务端用私钥解出随机字符串，再用此私钥解出加密的密文。

这其中有一个关键是解决服务端的公钥，传入客户端，客户端用此公钥加密字符串后，后又能在服务端用私钥解出。

此文即为实现此步而作。

加密算法为RSA：洞游

1。服务端的RSA java实现。

/**

*

*/

packagecom.sunsoft.struts.util;

importjava.io.ByteArrayOutputStream;

importjava.io.FileInputStream;

importjava.io.FileOutputStream;

importjava.io.ObjectInputStream;

importjava.io.ObjectOutputStream;

importjava.math.BigInteger;

importjava.security.KeyFactory;

importjava.security.KeyPair;

importjava.security.KeyPairGenerator;

importjava.security.NoSuchAlgorithmException;

importjava.security.PrivateKey;

importjava.security.PublicKey;

importjava.security.SecureRandom;

importjava.security.interfaces.RSAPrivateKey;

importjava.security.interfaces.RSAPublicKey;

importjava.security.spec.InvalidKeySpecException;

importjava.security.spec.RSAPrivateKeySpec;

importjava.security.spec.RSAPublicKeySpec;

importjavax.crypto.Cipher;

纳蔽销

/**

*RSA工具类。提供加密，解密，生成密钥对等方法。

*需要到http://www.bouncycastle.org下载bcprov-jdk14-123.jar。

*

*/

publicclassRSAUtil{

/**

**生成密钥对*

*

*@returnKeyPair*

*@throwsEncryptException

*/

publicstaticKeyPairgenerateKeyPair()throwsException{

try{

KeyPairGeneratorkeyPairGen=KeyPairGenerator.getInstance("RSA",

neworg.bouncycastle.jce.provider.BouncyCastleProvider());

finalintKEY_SIZE=1024;//没什么好说的了，这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低

keyPairGen.initialize(KEY_SIZE,newSecureRandom());

KeyPairkeyPair=keyPairGen.generateKeyPair();

saveKeyPair(keyPair);

returnkeyPair;

}catch(Exceptione){

thrownewException(e.getMessage());

}

}

publicstaticKeyPairgetKeyPair()throwsException{

FileInputStreamfis=newFileInputStream("C:/RSAKey.txt");

ObjectInputStreamoos=newObjectInputStream(fis);

KeyPairkp=(KeyPair)oos.readObject();

oos.close();

fis.close();

returnkp;

}

publicstaticvoidsaveKeyPair(KeyPairkp)throwsException{

FileOutputStreamfos=newFileOutputStream("C:/RSAKey.txt");

ObjectOutputStreamoos=newObjectOutputStream(fos);

//生成密钥

oos.writeObject(kp);

oos.close();

fos.close();

}

/**

**生成公钥*

*

*@parammodulus*

*@parampublicExponent*

*@returnRSAPublicKey*

*@throwsException

*/

publicstaticRSAPublicKeygenerateRSAPublicKey(byte[]modulus,

byte[]publicExponent)throwsException{

KeyFactorykeyFac=null;

try{

keyFac=KeyFactory.getInstance("RSA",

neworg.bouncycastle.jce.provider.BouncyCastleProvider());

}catch(NoSuchAlgorithmExceptionex){

thrownewException(ex.getMessage());

}

RSAPublicKeySpecpubKeySpec=newRSAPublicKeySpec(newBigInteger(

modulus),newBigInteger(publicExponent));

try{

return(RSAPublicKey)keyFac.generatePublic(pubKeySpec);

}catch(InvalidKeySpecExceptionex){

thrownewException(ex.getMessage());

}

}

/**

**生成私钥*

*

*@parammodulus*

*@paramprivateExponent*

*@returnRSAPrivateKey*

*@throwsException

*/

publicstaticRSAPrivateKeygenerateRSAPrivateKey(byte[]modulus,

byte[]privateExponent)throwsException{

KeyFactorykeyFac=null;

try{

keyFac=KeyFactory.getInstance("RSA",

neworg.bouncycastle.jce.provider.BouncyCastleProvider());

}catch(NoSuchAlgorithmExceptionex){

thrownewException(ex.getMessage());

}

RSAPrivateKeySpecpriKeySpec=newRSAPrivateKeySpec(newBigInteger(

modulus),newBigInteger(privateExponent));

try{

return(RSAPrivateKey)keyFac.generatePrivate(priKeySpec);

}catch(InvalidKeySpecExceptionex){

thrownewException(ex.getMessage());

}

}

/**

**加密*

*

*@paramkey

*加密的密钥*

*@paramdata

*待加密的明文数据*

*@return加密后的数据*

*@throwsException

*/

publicstaticbyte[]encrypt(PublicKeypk,byte[]data)throwsException{

try{

Ciphercipher=Cipher.getInstance("RSA",

neworg.bouncycastle.jce.provider.BouncyCastleProvider());

cipher.init(Cipher.ENCRYPT_MODE,pk);

intblockSize=cipher.getBlockSize();//获得加密块大小，如：加密前数据为128个byte，而key_size=1024

//加密块大小为127

//byte,加密后为128个byte;因此共有2个加密块，第一个127

//byte第二个为1个byte

intoutputSize=cipher.getOutputSize(data.length);//获得加密块加密后块大小

intleavedSize=data.length%blockSize;

intblocksSize=leavedSize!=0?data.length/blockSize+1

:data.length/blockSize;

byte[]raw=newbyte[outputSize*blocksSize];

inti=0;

while(data.length-i*blockSize>0){

if(data.length-i*blockSize>blockSize)

cipher.doFinal(data,i*blockSize,blockSize,raw,i

*outputSize);

else

cipher.doFinal(data,i*blockSize,data.length-i

*blockSize,raw,i*outputSize);

//这里面doUpdate方法不可用，查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到

//ByteArrayOutputStream中，而最后doFinal的时候才将所有的byte[]进行加密，可是到了此时加密块大小很可能已经超出了

//OutputSize所以只好用dofinal方法。

i++;

}

returnraw;

}catch(Exceptione){

thrownewException(e.getMessage());

}

}

/**

**解密*

*

*@paramkey

*解密的密钥*

*@paramraw

*已经加密的数据*

*@return解密后的明文*

*@throwsException

*/

publicstaticbyte[]decrypt(PrivateKeypk,byte[]raw)throwsException{

try{

Ciphercipher=Cipher.getInstance("RSA",

neworg.bouncycastle.jce.provider.BouncyCastleProvider());

cipher.init(cipher.DECRYPT_MODE,pk);

intblockSize=cipher.getBlockSize();

ByteArrayOutputStreambout=newByteArrayOutputStream(64);

intj=0;

while(raw.length-j*blockSize>0){

bout.write(cipher.doFinal(raw,j*blockSize,blockSize));

j++;

}

returnbout.toByteArray();

}catch(Exceptione){

thrownewException(e.getMessage());

}

}

/**

***

*

*@paramargs*

*@throwsException

*/

publicstaticvoidmain(String[]args)throwsException{

RSAPublicKeyrsap=(RSAPublicKey)RSAUtil.generateKeyPair().getPublic();

Stringtest="helloworld";

byte[]en_test=encrypt(getKeyPair().getPublic(),test.getBytes());

byte[]de_test=decrypt(getKeyPair().getPrivate(),en_test);

System.out.println(newString(de_test));

}

}

2.测试页面：

IndexAction.java

RSA加密解密算法的证明

1.选择两个质数 p, q

2.设 n=p* q

3.求出n的欧拉函数 f=(p-1)*(q-1)

4.在[2, f)的范誉握围内随机找一个与f互质的数 e作为公钥的指数

5.算出私钥指数d，d为公钥指数e对 f的一个模反元素，即 ed= kf+1(k为正整数)

6.将(n, e)封装成公钥，将(n, d)封装成私钥

1.设被加密的数为m, m为小于n的非庆扮庆负整数

2.算出 c=(m^e)% n，则 c即为密文

算出(c^d)%n,即为被加密的数m，证明如下。

因为  c=m^e- n*g，其中g为非负整数，

所以  (c^d)%n = [ (m^e- n*g) ^ d ] % n

展开多项式后将n的整数倍的项去除，得到

[( m^e)^d]% n

=[ m^(e*d) ]% n

=[ m^(k*f+1) ]% n

=[ m* m^(k*f) ]% n

={ m* [(m^f) ^ k]}% n

接下来分三种情况讨论：

第一种情况：m=0或者m=1

则 { m* [(m^f) ^ k]}% n= m

第二种情况：m>1，且m与n互质

根据 欧拉定理 ，m^f= h*n+1，其中h为正整数

则{ m* [(m^f) ^ k]}% n

={ m* [( h*n+1) ^ k]}% n

={ m* [ i*n+ 1 ]}% n  (其中i为展开指数多项式后合并n的同类项得到的正整数)

=m%n 

=m (因为m<n)

第三种情况：m>1，且m与n不互质

因为n=p*q,且p, q均为质数，则 m=j*p或者j*q,其中j为正整数

当m=j*p时,因为m<n,所以m与q互质

（证明：如果m, q不互质，则m含有质缺袜因数q，因为p与q互质,所以 j含有质因数p,这与m<n矛盾）

根据欧拉定理 m^(q-1)=x*q+1，其中x为正整数

则{ m* [(m^f) ^ k]}% n

={ m* [( m^[(p-1)*(q-1)]) ^ k]}% n

={ m* [ m^(q-1)^(p-1)^k ]}% n

={ j* p* [( x*q+1)^(p-1)^k ]}% n

={ j* p* [ y*q+ 1 ]}% n  (其中y为展开指数多项式后合并q的同类项得到的正整数)

=(j*p*y*q+ m)%n

=(j*y*n+m)% n

=m

同理，当m=j*q时也成立。

rsa在线加解密(rsa加密和解密c语言实现)(图1)

证明完毕。

RSA解密正确性证明_国科大网安二班的博客-CSDN博客

https://blog.csdn.net/weixin_46395886/article/details/114700012#:~:text=RSA%E8%A7%A3%E5%AF%86%E6%AD%A3%E7%A1%AE%E6%80%A7%E8%AF%81%E6%98%8E%20%E5%85%88%E6%8F%8F%E8%BF%B0%E4%B8%80%E4%B8%8BRSA%E5%AF%86%E7%A0%81%E4%BD%93%E5%88%B6%EF%BC%9A%20RSA%E5%AF%86%E7%A0%81%E4%BD%93%E5%88%B6%EF%BC%9A%20%E5%A4%A7%E7%B4%A0%E6%95%B0%20p%2Cq%20%EF%BC%8C%E6%A8%A1%E6%95%B0,n%20%3D%20pq%20%EF%BC%8C%E5%8A%A0%E5%AF%86%E6%8C%87%E6%95%B0%20b%20%EF%BC%8C%E8%A7%A3%E5%AF%86%E6%8C%87%E6%95%B0

RSA算法原理-知乎(zhihu.com)

https://zhuanlan.zhihu.com/p/48249182#:~:text=RSA%E7%AE%97%E6%B3%95%E5%8E%9F%E7%90%86%201%20%EF%BC%881%EF%BC%89%E4%B9%99%E6%96%B9%E7%94%9F%E6%88%90%E4%B8%A4%E6%8A%8A%E5%AF%86%E9%92%A5%20%28%E5%85%AC%E9%92%A5%E5%92%8C%E7%A7%81%E9%92%A5%29%E3%80%82...,2%20%EF%BC%882%EF%BC%89%E7%94%B2%E6%96%B9%E8%8E%B7%E5%8F%96%E4%B9%99%E6%96%B9%E7%9A%84%E5%85%AC%E9%92%A5%EF%BC%8C%E7%84%B6%E5%90%8E%E7%94%A8%E5%AE%83%E5%AF%B9%E4%BF%A1%E6%81%AF%E5%8A%A0%E5%AF%86%E3%80%82%203%20%EF%BC%883%EF%BC%89%E4%B9%99%E6%96%B9%E5%BE%97%E5%88%B0%E5%8A%A0%E5%AF%86%E5%90%8E%E7%9A%84%E4%BF%A1%E6%81%AF%EF%BC%8C%E7%94%A8%E7%A7%81%E9%92%A5%E8%A7%A3%E5%AF%86%E3%80%82

RSA加解密原理

RSA是目前使用最为广泛的公钥密码算法，公钥加密也称为非对称加密，与对称加密的最大区别在于加密与解密使用不同的密钥。

在RSA中，明文、密文和密钥都是数字，假设公钥用二元组(E,N)来表示，私钥用(D,N)来表示，其中E、D、N都是数字，那么加解密过程可表示如下：

可见，在RSA中，不论加密还是解密，都可归结为求x的y次幂对m取余问题。

生成RSA密钥可分成以下4步：

首先准备两个很大的质数p和q，那么N= p* q。

L= lcm(p-1, q-1)

由于存在恒等式gcd(a,b)* lcm(a,b)= a* b，求lcm可转换为求gcd，而求gcd可通过欧几里德算法在对数时间内算出。

E是一个比1大、比L小的数，且满足E与L互质，即有：gcd(E,L)=1, 1< E< L。gcd(E,L)=1是为了保证后面要求的数字D一定存在。

可不断地生成[2,L-1]之间的随机数作为E的候选数，检查是否满足条件，直到找出符合要求的E为止。

至此，E和N都已求出，那么公钥(E,N)也就得到了。

数D是由数E计算得到的，D、E和L之间满足关系：E* D mod L= 1, 1< D< L。

只要D满足运正上述条件，那么通过E与N加密的旁并悔内容，就可通过D和N进行解密。

求D也可采用类似求E的方法，不断产生随机数去试，直到找出满足条件的D为止，这样私钥(D,N)也准备好了。

为方面说明，这里用较小的数计算。先准备两个质数，例如，p=17, q=19，那么N=17*19=323，L=lcd(16,18)=144。

满足gcd(E,L)=1的数很多，例如5,7,11,13,25等，这里取E=5。

满足E*D mod L= 1的数也很多，这里取D=29。

到这里，公私钥都有了，公钥为(5,323)，私蔽信钥为(29,323)，公钥可任意公开，私钥则保密。

明文必须是小于N的数，因为加密运算中要求mod N。假设明文是123，用公钥(5,323)对其加密：

再用私钥(29,323)对密文225进行解密：

解出的明文与原始明文一致。

Android使用RSA加密和解密

1.data是要加密的数据，如果是字符串则getBytes。publicKey是公钥，privateKey是私钥。自定义密钥对测试

2.从文件中读取公钥

当加密的数据过长时，会出现javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes的异常。rsa算法规定一次加密的数据不能超过生成密钥对时的keyLength/8-11，keyLength一般是1024个字节，迹坦则加密的数据不能超过117个字节

测试分段加密和解密

生成公钥和私钥后，用base64编码

一、android加密的数据服务器上无法解密？

android的rsa加密方式是RSA/ECB/NoPadding，而标准jdk是RSA/ECB/PKCS1Padding，所以加密时要设置标准jdk的加密方式

二、base64编码。因为不同的设备对字符的处理方式不同，字符有可能处理出错，不利于传输。所以先把数据做base64编码，变成可见字符，减少出错

官方提供的base64类，Base64.encode编码，Base64.decode解码。用这个会有换行符，需要自定义

三、rsa是非对称加密算法。姿毕桐依赖于大数计算数运，加密速度比des慢，通常只用于加密少量数据或密钥

四、公钥加密比私钥加密块，公钥解密比私钥解密慢。加密后的数据大概是加密前的1.5倍

RSA加密解密算法示例(C语言)

#include<stdlib.h>

#include<stdio.h>

#include<没消string.h>

#include<math.h>

#include<time.h>

#define PRIME_MAX 200 //生成素数范围

#define EXPONENT_MAX 200//生成指数e范围

#define Element_Max 127  //加密单元的最大值，这里为一个char,即1Byte

char str_read[100]="hello world!"; //待加密的原文

int str_encrypt[100];        //加密后的内容

char str_decrypt[100];       //解密出来的内容

int str_read_len;          // str_read的长度

int prime1, prime2;         //随机生成的两个质数

int mod, eular;           //模数和欧拉数

int pubKey, priKey;         //公钥指数和私钥指数

//生成随机素数，实际应用中，这两个质数越大，就越难破解。

int randPrime()

{

int prime, prime2, i;

next:

prime= rand()% PRIME_MAX; //随机产生数

if(prime<= 1) goto next;   //不是质数，生成下一个随机数

if(prime== 2|| prime== 3) return prime;

prime2= prime/ 2;       // prime>=4, prime2的平方必定大于 prime,因此只检查银察厅小于等于prime2的数

for(i= 2; i<= prime2; i++) //判断是否为素数

{

if(i* i> prime) return prime;

if(prime% i== 0) goto next; //不是质数，生成下一个随机数

}

}

//欧几里德算法，判断a,b互质

int gcd(int a, int b)

{

int temp;

while(b!= 0){

temp= b;

b= a% b;

a= temp;

}

return a;

}

//生成公钥指数，条件是 1< e<欧拉数，且与欧拉数互质。

int randExponent()

{

int e;

while(1)

{

e= rand()% eular; if(e< EXPONENT_MAX) break;

}

while(1)

{

if(gcd(e, eular)== 1) return e; e=(e+ 1)% eular; if(e== 0|| e> EXPONENT_MAX) e= 2;

}

}

//生成私钥指数

int inverse()

{

int d, x;

while(1)

{

d= rand()% eular;

x= pubKey* d% eular;

if(x== 1)

{

return d;

}

}

}

//加密函数

void jiami()      

{

str_read_len= strlen(str_read);   //从参数表示的地址往后找，找到第一个'\0'，即串锋隐尾。计算'\0'至首地址的“距离”，即隔了几个字符，从而得出长度。

printf("密文是：");

for(int i= 0; i< str_read_len; i++)

{

int C= 1; int a= str_read[i], b= a% mod;

for(int j= 0; j< pubKey; j++)//实现加密

{

C=(C*b)% mod;

}

str_encrypt[i]= C;

printf("%d", str_encrypt[i]);

}

printf("\n");

}

//解密函数

void jiemi()     

{

int i=0;  for(i= 0; i< str_read_len; i++)

{

int C= 1; int a= str_encrypt[i], b=a%mod;

for(int j= 0; j< priKey; j++)

{

C=(C* b)% mod;

}

str_decrypt[i]= C;

}

str_decrypt[i]='\0'; printf("解密文是：%s\n", str_decrypt);

}

int main()

{

srand(time(NULL));

while(1)

{

prime1= randPrime(); prime2= randPrime(); printf("随机产生两个素数：prime1=%d, prime2=%d", prime1, prime2);

mod= prime1* prime2; printf("模数：mod= prime1* prime2=%d\n", mod); if(mod> Element_Max) break;//模数要大于每个加密单元的值

}

eular=(prime1- 1)*(prime2- 1);  printf("欧拉数：eular=(prime1-1)*(prime2-1)=%d\n", eular);

pubKey= randExponent(); printf("公钥指数：pubKey=%d\n", pubKey);

priKey= inverse(); printf("私钥指数：priKey=%d\n私钥为(%d,%d)\n", priKey, priKey, mod);

jiami(); jiemi();

return 0;

}

rsa在线加解密的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于rsa加密和解密c语言实现、rsa在线加解密的信息别忘了在本站进行查找哦。

本文来源于互联网，不代表趣虎号立场，转载联系作者并注明出处：https://www.quhuhao.com/wzfl/13936.html

打赏 微信扫一扫 微信扫一扫
雷锋的原名(雷锋原名叫什么)
« 上一篇
java审批流(python做审批流)
下一篇 »

相关推荐

联系我们

在线咨询：点击这里给我发消息

微信号：

工作日：9:30-18:30，节假日休息