「rsa算法java代码」RSA算法的实现

博主：adminadmin 2023-01-24 20:45:15 347

本篇文章给大家谈谈rsa算法java代码，以及RSA算法的实现对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

RSA PKCS#1在java中怎么实现？

楼主看看下面的代码是不是你所需要的，这是我原来用的时候收集的

import javax.crypto.Cipher;

import java.security.*;

import java.security.spec.RSAPublicKeySpec;

import java.security.spec.RSAPrivateKeySpec;

import java.security.spec.InvalidKeySpecException;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.io.*;

import java.math.BigInteger;

/**

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

* 需要到下载bcprov-jdk14-123.jar。

* RSA加密原理概述

* RSA的安全性依赖于大数的分解，公钥和私钥都是两个大素数（大于100的十进制位）的函数。

* 据猜测，从一个密钥和密文推断出明文的难度等同于分解两个大素数的积

* ===================================================================

* （该算法的安全性未得到理论的证明）

* ===================================================================

* 密钥的产生：

* 1.选择两个大素数 p,q ,计算 n=p*q;

* 2.随机选择加密密钥 e ,要求 e 和 (p-1)*(q-1)互质

* 3.利用 Euclid 算法计算解密密钥 d , 使其满足 e*d = 1(mod(p-1)*(q-1)) (其中 n,d 也要互质)

* 4:至此得出公钥为 (n,e) 私钥为 (n,d)

* ===================================================================

* 加解密方法：

* 1.首先将要加密的信息 m(二进制表示) 分成等长的数据块 m1,m2,...,mi 块长 s(尽可能大) ,其中 2^sn

* 2:对应的密文是： ci = mi^e(mod n)

* 3:解密时作如下计算： mi = ci^d(mod n)

* ===================================================================

* RSA速度

* 由于进行的都是大数计算，使得RSA最快的情况也比DES慢上100倍，无论是软件还是硬件实现。

* 速度一直是RSA的缺陷。一般来说只用于少量数据加密。

* 文件名：RSAUtil.javabr

* @author 赵峰br

* 版本:1.0.1br

* 描述：本算法摘自网络，是对RSA算法的实现br

* 创建时间:2009-7-10 下午09:58:16br

* 文件描述：首先生成两个大素数，然后根据Euclid算法生成解密密钥br

*/

public class RSAUtil {

//密钥对

private KeyPair keyPair = null;

/**

* 初始化密钥对

*/

public RSAUtil(){

try {

this.keyPair = this.generateKeyPair();

} catch (Exception e) {

e.printStackTrace();

}

}

/**

* 生成密钥对

* @return KeyPair

* @throws Exception

*/

private KeyPair generateKeyPair() throws Exception {

try {

KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA",new org.bouncycastle.jce.provider.BouncyCastleProvider());

//这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低

final int KEY_SIZE = 1024;

keyPairGen.initialize(KEY_SIZE, new SecureRandom());

KeyPair keyPair = keyPairGen.genKeyPair();

return keyPair;

} catch (Exception e) {

throw new Exception(e.getMessage());

}

}

/**

* 生成公钥

* @param modulus

* @param publicExponent

* @return RSAPublicKey

* @throws Exception

*/

private RSAPublicKey generateRSAPublicKey(byte[] modulus, byte[] publicExponent) throws Exception {

KeyFactory keyFac = null;

try {

keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());

} catch (NoSuchAlgorithmException ex) {

throw new Exception(ex.getMessage());

}

RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(modulus), new BigInteger(publicExponent));

try {

return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);

} catch (InvalidKeySpecException ex) {

throw new Exception(ex.getMessage());

}

}

/**

* 生成私钥

* @param modulus

* @param privateExponent

* @return RSAPrivateKey

* @throws Exception

*/

private RSAPrivateKey generateRSAPrivateKey(byte[] modulus, byte[] privateExponent) throws Exception {

KeyFactory keyFac = null;

try {

keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());

} catch (NoSuchAlgorithmException ex) {

throw new Exception(ex.getMessage());

}

RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(modulus), new BigInteger(privateExponent));

try {

return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);

} catch (InvalidKeySpecException ex) {

throw new Exception(ex.getMessage());

}

}

/**

* 加密

* @param key 加密的密钥

* @param data 待加密的明文数据

* @return 加密后的数据

* @throws Exception

*/

public byte[] encrypt(Key key, byte[] data) throws Exception {

try {

Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());

cipher.init(Cipher.ENCRYPT_MODE, key);

// 获得加密块大小，如:加密前数据为128个byte，而key_size=1024 加密块大小为127 byte,加密后为128个byte;

// 因此共有2个加密块，第一个127 byte第二个为1个byte

int blockSize = cipher.getBlockSize();

// System.out.println("blockSize:"+blockSize);

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

// System.out.println("加密块大小："+outputSize);

int leavedSize = data.length % blockSize;

// System.out.println("leavedSize:"+leavedSize);

int blocksSize = leavedSize != 0 ? data.length / blockSize + 1 : data.length / blockSize;

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

int i = 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++;

}

return raw;

} catch (Exception e) {

throw new Exception(e.getMessage());

}

}

/**

* 解密

* @param key 解密的密钥

* @param raw 已经加密的数据

* @return 解密后的明文

* @throws Exception

*/

@SuppressWarnings("static-access")

public byte[] decrypt(Key key, byte[] raw) throws Exception {

try {

Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());

cipher.init(cipher.DECRYPT_MODE, key);

int blockSize = cipher.getBlockSize();

ByteArrayOutputStream bout = new ByteArrayOutputStream(64);

int j = 0;

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

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

j++;

}

return bout.toByteArray();

} catch (Exception e) {

throw new Exception(e.getMessage());

}

}

/**

* 返回公钥

* @return

* @throws Exception

*/

public RSAPublicKey getRSAPublicKey() throws Exception{

//获取公钥

RSAPublicKey pubKey = (RSAPublicKey) keyPair.getPublic();

//获取公钥系数(字节数组形式)

byte[] pubModBytes = pubKey.getModulus().toByteArray();

//返回公钥公用指数(字节数组形式)

byte[] pubPubExpBytes = pubKey.getPublicExponent().toByteArray();

//生成公钥

RSAPublicKey recoveryPubKey = this.generateRSAPublicKey(pubModBytes,pubPubExpBytes);

return recoveryPubKey;

}

/**

* 获取私钥

* @return

* @throws Exception

*/

public RSAPrivateKey getRSAPrivateKey() throws Exception{

// 获取私钥

RSAPrivateKey priKey = (RSAPrivateKey) keyPair.getPrivate();

// 返回私钥系数(字节数组形式)

byte[] priModBytes = priKey.getModulus().toByteArray();

// 返回私钥专用指数(字节数组形式)

byte[] priPriExpBytes = priKey.getPrivateExponent().toByteArray();

// 生成私钥

RSAPrivateKey recoveryPriKey = this.generateRSAPrivateKey(priModBytes,priPriExpBytes);

return recoveryPriKey;

}

/**

* 测试

* @param args

* @throws Exception

*/

public static void main(String[] args) throws Exception {

RSAUtil rsa = new RSAUtil();

String str = "天龙八部、神雕侠侣、射雕英雄传白马啸西风";

RSAPublicKey pubKey = rsa.getRSAPublicKey();

RSAPrivateKey priKey = rsa.getRSAPrivateKey();

// System.out.println("加密后==" + new String(rsa.encrypt(pubKey,str.getBytes())));

String mw = new String(rsa.encrypt(pubKey, str.getBytes()));

System.out.println("加密后："+mw);

// System.out.println("解密后：");

System.out.println("解密后==" + new String(rsa.decrypt(priKey,rsa.encrypt(pubKey,str.getBytes()))));

}

}

用JAVA实现RSA算法的加密解密 跪求

#####################################

我已经说的很清楚了。。。只要把我说的用程序写下来，加个菜单就行了。。。要是这样都不会的话。。。那就当我没说了。。。

####################################

RSA。。。难道你自己建立PKI，否则没法弄。。。

你说这个题。。直接手算的了。。。又不是大数

N = P * Q = 1739

N的欧拉函数

F(N) = ( p - 1 ) * ( Q - 1 ) = 1656

然后算模拟嘛。。。5 模 1656的逆。。。

1656 = 1 + 1655 = 1 + 5 * 331

所以5模1656的逆就是-331 = 1656 - 331 = 1325

所以D = 1325啦

你要加密你至少告诉我明文是什么吧。。。。

如果加密明文M的话，密文C = M 模 1739的E次幂

解密是M = C 模1739的D次幂

小数直接手算啦～费马小定理，从左向右计算，可以简化一部分计算，不过你这个题已经差不多最简化了。。。。你这个题实际上就是用来手算的。真正RSA一般人根本做不出来，光是素性检验就很麻烦了。。而且就算你能实现，你有PKI吗？？？没有PKI。。。RSA的安全从何而来？？？

我们也上学期刚学的密码。。。呵呵～～～有问题继续问。。。现在无聊啊。。

求助JAVA的RSA算法X509编码密钥的详解

对相应的Applet源代码进行单独的修改，不影响其他应用的实现和稳定性，不影响底层的JavaCard平台的实现和稳定性。

java给汉字进行RSA加密

类似的，楼上说的针对一个汉字的写法也没错。

假如是RSA，应该使用BigDecimal函数来做。

那么，把字符串按照某一编码格式进行转换成byte [] ，然后使用BigDecimal转换成大整数，就能进行RSA计算了。

String 转 byte [] 方法是String.getBytes (字符集) 字符集可能是“UTF-16” 或者汉字的“GBK” 。

RSA算法如何加密文件，请教。。。java

RSA算法很简单，就是基于欧拉定理的简单算法 M=5是明文，计算过程如下： n=p*q=33; (p-1)*(q-1)=20; 加密：y=密文，x=明文=5; y=x^e mod n = 5^7 mod 33 = 14; 解密： x=y^d mod n; d*e= 1 [mod(p-1)*(q-1)]; 7d=1(mod 20)所以d=3; 所以x=y^d mod n= 14^3 mod 33 = 5;解完 加密由5~14，解密由14~5，实现了RSA算法的加密解密过程，证明了计算的正确性。

求救求救。。。刚学习JAVA，有没有JAVA的RSA完整算法？？？？急。。。

1 RSA算法的原理如下：

1.1原理

假设我们需要将信息从机器A传到机器B，首先由机器B随机确定一个Key，我们称之为密匙private_key，将这个可KEY始终保存在机器B中而不发出来；然后，由这个private_key计算出另一个Key，我们称之为公匙Public_key。这个Public_key的特性是几乎不可能通过该Key计算生成它的private_key。接下来通过网络把这个Public_key传给机器A，

机器A受到Public_key后，利用该key，将信息加密，并把加密后的信息通过网络发送到机器B，最后机器B利用已知的private_key，就可以解开加密信息。

1.2步骤

RSA算法的安全性依赖于大数因数分解的困难性。公匙和私匙都是两个大素数的函数。

1.2.1

首先选择两个大素数p、q,计算n=p*q; m=(p-1)*(q-1);

1.2.2

而后随机选择加密密匙Public_key，要求和m互质，比如Public_key=m-1;

1.2.3

利用欧几里德算法计算解密密匙private_key，使private_key满足

Public_key*private_key三1(mod m)

其中Public_key，n是公匙，private_key是密匙

1.2.4

加密信息text时，利用公式secretword=text^Public_key (mod n)得到密文secretword

1.2.5

解密时利用公式word=text^private_key(mod n)得到原文word=text.。

2程序

本算法用JAVA编程语言实现，开发环境为Eclipse

//BJTU 软件0404

import java.io.*;

public class Rsa

{

private int p=0;

private int q=0;

private long n=0;

private long m=0;

private long public_key=0;//公匙

private long private_key=0;//密匙

private long text=0;//明文

private long secretword=0;//密文

private long word=0;//解密后明文

//判断是否为素数

public boolean primenumber(long t)

{

long k=0;

k=(long)Math.sqrt((double)t);

boolean flag=true;

outer:for(int i=2;i=k;i++)

{

if((t%i)==0)

{

flag = false;

break outer;

}

}

return flag;

}

//输入PQ

public void inputPQ()throws Exception

{

do{

System.out.println("请输入素数p: ");

BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));

String br=stdin.readLine();

this.p=Integer.parseInt(br);

}

while(!primenumber(this.p));

do{

System.out.println("请输入素数q: ");

BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));

String br=stdin.readLine();

this.q=Integer.parseInt(br);

}

while(!primenumber(this.q));

this.n=this.p*this.q;

this.m=(p-1)*(q-1);

System.out.println("这两个素数的乘积为p*q："+this.n);

System.out.println("所得的小于N并且与N互素的整数的个数为m=(p-1)(q-1)："+this.m);

}

//求最大公约数

public long gcd(long a,long b)

{

long gcd;

if(b==0)

gcd=a;

else

gcd=gcd(b,a%b);

System.out.println("gcd:"+gcd);

return gcd;

}

//输入公匙

public void getPublic_key()throws Exception

{

do{

System.out.println("请输入一个公钥的值，这个值要求小于m并且和m互质： ");

BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));

String br=stdin.readLine();

this.public_key=Long.parseLong(br);

}while((this.public_key = this.m) || (this.gcd(this.m,this.public_key)!=1));

System.out.println("公钥为："+this.public_key);

}

//计算得到密匙

public void getPrivate_key()

{

long value=1;

outer:for(long i=1;;i++)

{

value=i*this.m+1;

System.out.println("value: "+value);

if((value%this.public_key==0) (value/this.public_key this.m))

{

this.private_key=value/this.public_key;

break outer;

}

}

System.out.println("产生的一个私钥为："+this.private_key);

}

//输入明文

public void getText()throws Exception

{

System.out.println("请输入明文：");

BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));

String br=stdin.readLine();

this.text=Long.parseLong(br);

}

//加密、解密计算

public long colum(long y,long n,long key)

{

long mul;

if(key==1)

mul=y%n;

else

mul=y*this.colum(y,n,key-1)%n;

return mul;

}

//加密后解密

public void pascolum()throws Exception

{

this.getText();

System.out.println("输入明文为: "+this.text);

//加密

this.secretword=this.colum(this.text,this.n,this.public_key);

System.out.println("所得的密文为："+this.secretword);

//解密

this.word=this.colum(this.secretword,this.n,this.private_key);

System.out.println("解密后所得的明文为："+this.word);

}

public static void main(String []args)throws Exception

{

Rsa t = new Rsa();

t.inputPQ();

t.getPublic_key();

t.getPrivate_key();

t.pascolum();

}

}

3试验介绍

2.1输入PQ，计算m、n

3.2输入公匙，产生密匙

3.3输入明文，产生密文，并解密

此处时间限制，明文暂时用个数字代替，有兴趣的可以改变程序，变成一段数字

请输入素数p:

23

请输入素数q:

29

这两个素数的乘积为p*q：667

所得的小于N并且与N互素的整数的个数为m=(p-1)(q-1)：616

请输入一个公钥的值，这个值要求小于m并且和m互质：

611

gcd:1

gcd:1

gcd:1

gcd:1

公钥为：611

产生的一个私钥为：123

请输入明文：

311

输入明文为: 311

所得的密文为：653

解密后所得的明文为：311

关于rsa算法java代码和RSA算法的实现的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。

标签：