rsa在线加解密(rsa加密和解密c语言实现)
今天给各位分享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解密正确性证明_国科大网安二班的博客-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://quhuhao.com/wzfl/13936.html
微信扫一扫