javarsa代码 Java RSA

JAVA里面RSA加密算法的使用

RSA的Java实现不能一次加密很大的字符，自己处理了一下，见下面的代码。Base64编码类用的是一个Public domain Base64 for java 其他的保存公钥到文件等简单的实现，就不详细说了，看代码吧。==============================================import java.security.*;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.HashMap;import java.util.Map;import javax.crypto.*;import java.io.*;public class Encryptor {private static final String KEY_FILENAME = "c:\\mykey.dat";private static final String OTHERS_KEY_FILENAME = "c:\\Otherskey.dat";// private static final int KEY_SIZE = 1024;// private static final int BLOCK_SIZE = 117;// private static final int OUTPUT_BLOCK_SIZE = 128;private static final int KEY_SIZE = 2048; //RSA key 是多少位的private static final int BLOCK_SIZE = 245; //一次RSA加密操作所允许的最大长度//这个值与 KEY_SIZE 已经padding方法有关。因为 1024的key的输出是128，2048key输出是256字节//可能11个字节用于保存padding信息了，所以最多可用的就只有245字节了。private static final int OUTPUT_BLOCK_SIZE = 256;private SecureRandom secrand;private Cipher rsaCipher;private KeyPair keys;private MapString, Key allUserKeys;public Encryptor() throws Exception {try {allUserKeys = new HashMapString, Key();secrand = new SecureRandom();//SunJCE Provider 中只支持ECB mode，试了一下只有PKCS1PADDING可以直接还原原始数据，//NOPadding导致解压出来的都是blocksize长度的数据，还要自己处理//参见另外根据 Open-JDK-6.b17-src（）// 中代码的注释，使用RSA来加密大量数据不是一种标准的用法。所以现有实现一次doFinal调用之进行一个RSA操作，//如果用doFinal来加密超过的一个操作所允许的长度数据将抛出异常。//根据keysize的长度，典型的1024个长度的key和PKCS1PADDING一起使用时//一次doFinal调用只能加密117个byte的数据。（NOPadding 和1024 keysize时128个字节长度）//（2048长度的key和PKCS1PADDING 最多允许245字节一次）//想用来加密大量数据的只能自己用其他办法实现了。可能RSA加密速度比较慢吧，要用AES才行rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1PADDING");} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (NoSuchPaddingException e) {e.printStackTrace();throw e;}ObjectInputStream in;try {in = new ObjectInputStream(new FileInputStream(KEY_FILENAME));} catch (FileNotFoundException e) {if (false == GenerateKeys()){throw e;}LoadKeys();return;}keys = (KeyPair) in.readObject();in.close();LoadKeys();}/** 生成自己的公钥和私钥*/private Boolean GenerateKeys() {try {KeyPairGenerator keygen = KeyPairGenerator.getInstance("RSA");// secrand = new SecureRandom();// sedSeed之后会造成生成的密钥都是一样的// secrand.setSeed("chatencrptor".getBytes()); // 初始化随机产生器//key长度至少512长度，不过好像说现在用2048才算比较安全的了keygen.initialize(KEY_SIZE, secrand); // 初始化密钥生成器keys = keygen.generateKeyPair(); // 生成密钥组AddKey("me", EncodeKey(keys.getPublic()));} catch (NoSuchAlgorithmException e) {e.printStackTrace();return false;}ObjectOutputStream out;try {out = new ObjectOutputStream(new FileOutputStream(KEY_FILENAME));} catch (IOException e) {e.printStackTrace();return false;}try {out.writeObject(keys);} catch (IOException e) {e.printStackTrace();return false;} finally {try {out.close();} catch (IOException e) {e.printStackTrace();return false;}}return true;}public String EncryptMessage(String toUser, String Message) throws IOException {Key pubkey = allUserKeys.get(toUser);if ( pubkey == null ){throw new IOException("NoKeyForThisUser") ;}try {//PublicKey pubkey = keys.getPublic();rsaCipher.init(Cipher.ENCRYPT_MODE, pubkey, secrand);//System.out.println(rsaCipher.getBlockSize()); 返回0，非block 加密算法来的？//System.out.println(Message.getBytes("utf-8").length);//byte[] encryptedData = rsaCipher.doFinal(Message.getBytes("utf-8"));byte[] data = Message.getBytes("utf-8");int blocks = data.length / BLOCK_SIZE ;int lastBlockSize = data.length % BLOCK_SIZE ;byte [] encryptedData = new byte[ (lastBlockSize == 0 ? blocks : blocks + 1)* OUTPUT_BLOCK_SIZE];for (int i=0; i blocks; i++){//int thisBlockSize = ( i + 1 ) * BLOCK_SIZE data.length ? data.length - i * BLOCK_SIZE : BLOCK_SIZE ;rsaCipher.doFinal(data,i * BLOCK_SIZE, BLOCK_SIZE, encryptedData ,i * OUTPUT_BLOCK_SIZE);}if (lastBlockSize != 0 ){rsaCipher.doFinal(data, blocks * BLOCK_SIZE, lastBlockSize,encryptedData ,blocks * OUTPUT_BLOCK_SIZE);}//System.out.println(encrypted.length); 如果要机密的数据不足128/256字节，加密后补全成为变为256长度的。//数量比较小时，Base64.GZIP产生的长度更长，没什么优势//System.out.println(Base64.encodeBytes(encrypted,Base64.GZIP).length());//System.out.println(Base64.encodeBytes(encrypted).length());//System.out.println (rsaCipher.getOutputSize(30));//这个getOutputSize 只对输入小于最大的block时才能得到正确的结果。其实就是补全数据为128/256 字节return Base64.encodeBytes(encryptedData);} catch (InvalidKeyException e) {e.printStackTrace();throw new IOException("InvalidKey") ;}catch (ShortBufferException e) {e.printStackTrace();throw new IOException("ShortBuffer") ;}catch (UnsupportedEncodingException e) {e.printStackTrace();throw new IOException("UnsupportedEncoding") ;} catch (IllegalBlockSizeException e) {e.printStackTrace();throw new IOException("IllegalBlockSize") ;} catch (BadPaddingException e) {e.printStackTrace();throw new IOException("BadPadding") ;}finally {//catch 中 return 或者throw之前都会先调用一下这里}}public String DecryptMessage(String Message) throws IOException {byte[] decoded = Base64.decode(Message);PrivateKey prikey = keys.getPrivate();try {rsaCipher.init(Cipher.DECRYPT_MODE, prikey, secrand);int blocks = decoded.length / OUTPUT_BLOCK_SIZE;ByteArrayOutputStream decodedStream = new ByteArrayOutputStream(decoded.length);for (int i =0 ;i blocks ; i ++ ){decodedStream.write (rsaCipher.doFinal(decoded,i * OUTPUT_BLOCK_SIZE, OUTPUT_BLOCK_SIZE));}return new String(decodedStream.toByteArray(), "UTF-8");} catch (InvalidKeyException e) {e.printStackTrace();throw new IOException("InvalidKey");} catch (UnsupportedEncodingException e) {e.printStackTrace();throw new IOException("UnsupportedEncoding");} catch (IllegalBlockSizeException e) {e.printStackTrace();throw new IOException("IllegalBlockSize");} catch (BadPaddingException e) {e.printStackTrace();throw new IOException("BadPadding");} finally {// catch 中 return 或者throw之前都会先调用一下这里。}}public boolean AddKey(String user, String key) {PublicKey publickey;try {publickey = DecodePublicKey(key);} catch (Exception e) {return false;}allUserKeys.put(user, publickey);SaveKeys();return true;}private boolean LoadKeys() {BufferedReader input;try {input = new BufferedReader(new InputStreamReader(new FileInputStream(OTHERS_KEY_FILENAME)));} catch (FileNotFoundException e1) {// e1.printStackTrace();return false;}

创新互联专注于汉川网站建设服务及定制，我们拥有丰富的企业做网站经验。热诚为您提供汉川营销型网站建设，汉川网站制作、汉川网页设计、汉川网站官网定制、微信小程序开发服务，打造汉川网络公司原创品牌,更为您提供汉川网站排名全网营销落地服务。

Java中RSA的方式如何实现非对称加密的示例

代码如下，需要依赖一个jar包commons-codec-1.9.jar，用于Base64转换，请自行下载。

import org.apache.commons.codec.binary.Base64;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import java.io.ByteArrayOutputStream;

import java.io.UnsupportedEncodingException;

import java.security.*;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

public class RSAUtils {

// 加密方式

public static final String ALGORITHM = "RSA";

// 签名算法

private static final String SIGNATURE_ALGORITHM = "SHA1WithRSA";

// 创建密钥对初始长度

private static final int KEY_SIZE = 512;

// 字符编码格式

private static final String CHARSET = "UTF-8";

// RSA最大加密明文大小

private static final int MAX_ENCRYPT_BLOCK = 117;

// RSA最大解密密文大小

private static final int MAX_DECRYPT_BLOCK = 128;

private KeyFactory keyFactory;

public RSAUtils() throws NoSuchAlgorithmException {

keyFactory = KeyFactory.getInstance(ALGORITHM);

}

/**

* 私钥加密

* @param content 待加密字符串

* @param privateKey 私钥

* @return 加密后字符串（BASE64编码）

public String encryptByPrivateKey(String content, String privateKey) throws Exception {

String result;

try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

byte[] keyBytes = new Base64().decode(privateKey);

PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

PrivateKey pKey = keyFactory.generatePrivate(pkcs8KeySpec);

Cipher cipher = Cipher.getInstance(ALGORITHM);

cipher.init(Cipher.ENCRYPT_MODE, pKey);

byte[] data = content.getBytes(CHARSET);

write2Stream(cipher, data, out);

byte[] resultBytes = out.toByteArray();

result = Base64.encodeBase64String(resultBytes);

} catch (Exception e) {

throw new Exception(e);

}

return result;

}

/**

* 公钥解密

* @param content 已加密字符串（BASE64加密）

* @param publicKey 公钥

* @return

public String decryptByPublicKey(String content, String publicKey) throws Exception {

String result = "";

try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

byte[] keyBytes = new Base64().decode(publicKey);

X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

PublicKey pKey = keyFactory.generatePublic(x509KeySpec);

Cipher cipher = Cipher.getInstance(ALGORITHM);

cipher.init(Cipher.DECRYPT_MODE, pKey);

byte[] data = Base64.decodeBase64(content);

write2Stream(cipher, data, out);

byte[] resultBytes = out.toByteArray();

result = new String(resultBytes);

} catch (Exception e) {

throw new Exception(e);

}

return result;

}

/**

* 公钥加密

* @param content 待加密字符串

* @param publicKey 公钥

* @return 加密后字符串（BASE64编码）

public String encryptByPublicKey(String content, String publicKey) throws Exception {

String result = "";

try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

byte[] keyBytes = new Base64().decode(publicKey);

X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

PublicKey pKey = keyFactory.generatePublic(x509KeySpec);

Cipher cipher = Cipher.getInstance(ALGORITHM);

cipher.init(Cipher.ENCRYPT_MODE, pKey);

byte[] data = content.getBytes(CHARSET);

write2Stream(cipher,

data, out);

byte[] resultBytes = out.toByteArray();

result = Base64.encodeBase64String(resultBytes);

} catch (Exception e) {

throw new Exception(e);

}

return result;

}

/**

* 私钥解密

* @param content 已加密字符串

* @param privateKey 私钥

* @return 解密后字符串

public String decryptByPrivateKey(String content, String privateKey) throws Exception {

String result = "";

try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

byte[] keyBytes = new Base64().decode(privateKey);

PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

PrivateKey pKey = keyFactory.generatePrivate(pkcs8KeySpec);

Cipher cipher = Cipher.getInstance(ALGORITHM);

cipher.init(Cipher.DECRYPT_MODE, pKey);

byte[] data = Base64.decodeBase64(content);

write2Stream(cipher, data, out);

byte[] resultBytes = out.toByteArray();

result = new String(resultBytes);

} catch (Exception e) {

throw new Exception(e);

}

return result;

}

private static void write2Stream(Cipher cipher, byte[] data, ByteArrayOutputStream out) throws

BadPaddingException, IllegalBlockSizeException {

int dataLen = data.length;

int offSet = 0;

byte[] cache;

int i = 0;

// 对数据分段解密

while (dataLen - offSet 0) {

if (dataLen - offSet MAX_DECRYPT_BLOCK) {

cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);

} else {

cache = cipher.doFinal(data, offSet, dataLen - offSet);

}

out.write(cache, 0, cache.length);

i++;

offSet = i * MAX_DECRYPT_BLOCK;

}

/**

* 用私钥对信息生成数字签名

* @param data 已加密数据

* @param privateKey 私钥(BASE64编码)

* @return sign

public String sign(String data, String privateKey) throws Exception {

String result = "";

try {

byte[] keyBytes = new Base64().decode(privateKey);

PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);

Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

signature.initSign(privateK);

signature.update(parse2HexStr(data).getBytes(CHARSET));

result = new Base64().encodeToString(signature.sign());

} catch (Exception e) {

throw new Exception(e);

}

return result;

}

/**

* 校验数字签名

* @param data 已加密数据

* @param publicKey 公钥(BASE64编码)

* @param sign 数字签名

* @return

* @throws Exception

public boolean verify(String data, String publicKey, String sign) throws Exception {

boolean result;

try {

byte[] keyBytes = new Base64().decode(publicKey);

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

PublicKey publicK = keyFactory.generatePublic(keySpec);

Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

signature.initVerify(publicK);

signature.update(parse2HexStr(data).getBytes(CHARSET));

result = signature.verify(new Base64().decode(sign));

} catch (Exception e) {

throw new Exception(e);

}

return result;

}

/**

* 将二进制转换成16进制

* @param data

* @return

public static String parse2HexStr(String data) throws Exception {

String result = "";

try {

byte[] buf = data.getBytes(CHARSET);

StringBuffer sb = new StringBuffer();

for (int i = 0; i buf.length; i++) {

String hex = Integer.toHexString(buf[i] 0xFF);

if (hex.length() == 1) {

hex = '0' + hex;

}

sb.append(hex.toUpperCase());

}

result = sb.toString();

} catch (UnsupportedEncodingException e) {

throw new Exception(e);

}

return result;

}

/**

* 生成公钥与私钥

public static void createKey() throws Exception {

try {

KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);

keyPairGenerator.initialize(KEY_SIZE);

KeyPair keyPair = keyPairGenerator.generateKeyPair();

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

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

String publicKey = Base64.encodeBase64String(rsaPublicKey.getEncoded());

String privateKey = Base64.encodeBase64String(rsaPrivateKey.getEncoded());

System.out.println("publicKey=" + publicKey + "\nprivateKey=" + privateKey);

} catch (NoSuchAlgorithmException e) {

throw new Exception(e);

}

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

String PRIVATE_KEY = "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAKeYGXH6Vz+m+KuL11RDRaNdHB4YQeZgqpJGPRSwBelgvEoHu2/fNs1bmgfJhI8lhr/o/Hy8EFB/I/DDyLcCcU4bCLtxpki8edC+KJR2WvyYfnVmWEe/3q2jSVKRf81868q9Cd3MMfrQPMsY4x0TQ0GtOf/nMSMbAltV2W8J86IfAgMBAAECgYEApYu4lr2SMW3ddJZNvQ42W4g9nfyYG9igpJx8+VJmhIDpfLbmjzsOBwvUupx0NHH9CNQ7k3qxItJzzf+W5C+lesEOAqdO5nahRZsL8BIDoxTEn2j+1GXkzQw3vqPY50xqRnZsoP5TyNNsOM7KYaOoz4VFMdVIFwoT3OKM5z7mxgECQQD51r17WZDSa/kucaH7gCOePxJPS6Ust0eVd5tBOMpFzD/VtziogSIWyhGKkLH0SyTJEe91CCpdpxufLSZgIiN5AkEAq7ojtvU4twak1N1/1qX+t8f5wD8i/8GU702PeCwkGI5ymrARq+W2yCuvU1bouXBhjKHV4KhafKYixdHUMg00VwJAYVUjpLaUESY3gbyLWqvlNHVl8LaLtwwAO17JgXNaei7Ef8JNtHf6i95VTyJn8cCEqEDwhSuVNb8wp6azWKh0IQJBAJHrcT2d0bt0IcvfCynRk0eG3WnGPG8mhu9w8GAk4ecb47YdtmZio5YjyK8AQnCQVdOyEJL9eyY/5XxCeBSvs7ECQQCKQ2f5HLDkkHvc6rlaHCJmqNRCS+CxhoaiaSPYLAac7WXmb614ACLECc86C/nkefTq0SNpUDVbGxVpJi9/FOUf";

String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCnmBlx+lc/pviri9dUQ0WjXRweGEHmYKqSRj0UsAXpYLxKB7tv3zbNW5oHyYSPJYa/6Px8vBBQfyPww8i3AnFOGwi7caZIvHnQviiUdlr8mH51ZlhHv96to0lSkX/NfOvKvQndzDH60DzLGOMdE0NBrTn/5zEjGwJbVdlvCfOiHwIDAQAB";

RSAUtils rsaUtil = new RSAUtils();

String encryptByPublicKey = rsaUtil.encryptByPublicKey("你好！", PUBLIC_KEY);

System.out.println(encryptByPublicKey);

String decryptByPrivateKey = rsaUtil.decryptByPrivateKey(encryptByPublicKey, PRIVATE_KEY);

System.out.println(decryptByPrivateKey);

String encryptByPrivateKey = rsaUtil.encryptByPrivateKey("你好！", PRIVATE_KEY);

System.out.println(encryptByPrivateKey);

String decryptByPublicKey = rsaUtil.decryptByPublicKey(encryptByPrivateKey, PUBLIC_KEY);

System.out.println(decryptByPublicKey);

String sign = rsaUtil.sign("1234", PRIVATE_KEY);

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

System.out.println(rsaUtil.verify("1234", PUBLIC_KEY, sign));

}

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 和IDEA 加密解密算法

RSA算法非常简单，概述如下：

找两素数p和q

取n=p*q

取t=(p-1)*(q-1)

取任何一个数e,要求满足et并且e与t互素（就是最大公因数为1）

取d*e%t==1

这样最终得到三个数： n d e

设消息为数M (M n)

设c=(M**d)%n就得到了加密后的消息c

设m=(c**e)%n则 m == M，从而完成对c的解密。

注：**表示次方,上面两式中的d和e可以互换。

在对称加密中：

n d两个数构成公钥，可以告诉别人；

n e两个数构成私钥，e自己保留，不让任何人知道。

给别人发送的信息使用e加密，只要别人能用d解开就证明信息是由你发送的，构成了签名机制。

别人给你发送信息时使用d加密，这样只有拥有e的你能够对其解密。

rsa的安全性在于对于一个大数n，没有有效的方法能够将其分解

从而在已知n d的情况下无法获得e；同样在已知n e的情况下无法

求得d。

二实践

接下来我们来一个实践，看看实际的操作：

找两个素数：

p=47

q=59

这样

n=p*q=2773

t=(p-1)*(q-1)=2668

取e=63，满足et并且e和t互素

用perl简单穷举可以获得满主 e*d%t ==1的数d：

C:\Tempperl -e "foreach $i (1..9999){ print($i),last if $i*63%2668==1 }"

847

即d＝847

最终我们获得关键的

n=2773

d=847

e=63

取消息M=244我们看看

加密：

c=M**d%n = 244**847%2773

用perl的大数计算来算一下：

C:\Tempperl -Mbigint -e "print 244**847%2773"

465

即用d对M加密后获得加密信息c＝465

解密：

我们可以用e来对加密后的c进行解密，还原M：

m=c**e%n=465**63%2773 ：

C:\Tempperl -Mbigint -e "print 465**63%2773"

244

即用e对c解密后获得m=244 , 该值和原始信息M相等。

三字符串加密

把上面的过程集成一下我们就能实现一个对字符串加密解密的示例了。

每次取字符串中的一个字符的ascii值作为M进行计算，其输出为加密后16进制

的数的字符串形式，按3字节表示，如01F

代码如下：

#!/usr/bin/perl -w

#RSA 计算过程学习程序编写的测试程序

#watercloud 2003-8-12

use strict;

use Math::BigInt;

my %RSA_CORE = (n=2773,e=63,d=847); #p=47,q=59

my $N=new Math::BigInt($RSA_CORE{n});

my $E=new Math::BigInt($RSA_CORE{e});

my $D=new Math::BigInt($RSA_CORE{d});

print "N=$N D=$D E=$E\n";

sub RSA_ENCRYPT

{

my $r_mess = shift @_;

my ($c,$i,$M,$C,$cmess);

for($i=0;$i length($$r_mess);$i++)

{

$c=ord(substr($$r_mess,$i,1));

$M=Math::BigInt-new($c);

$C=$M-copy(); $C-bmodpow($D,$N);

$c=sprintf "%03X",$C;

$cmess.=$c;

}

return \$cmess;

}

sub RSA_DECRYPT

{

my $r_mess = shift @_;

my ($c,$i,$M,$C,$dmess);

for($i=0;$i length($$r_mess);$i+=3)

{

$c=substr($$r_mess,$i,3);

$c=hex($c);

$M=Math::BigInt-new($c);

$C=$M-copy(); $C-bmodpow($E,$N);

$c=chr($C);

$dmess.=$c;

}

return \$dmess;

}

my $mess="RSA 娃哈哈哈～～～";

$mess=$ARGV[0] if @ARGV = 1;

print "原始串：",$mess,"\n";

my $r_cmess = RSA_ENCRYPT(\$mess);

print "加密串：",$$r_cmess,"\n";

my $r_dmess = RSA_DECRYPT($r_cmess);

print "解密串：",$$r_dmess,"\n";

#EOF

测试一下：

C:\Tempperl rsa-test.pl

N=2773 D=847 E=63

原始串：RSA 娃哈哈哈～～～

加密串：5CB6CD6BC58A7709470AA74A0AA74A0AA74A6C70A46C70A46C70A4

解密串：RSA 娃哈哈哈～～～

C:\Tempperl rsa-test.pl 安全焦点（xfocus）

N=2773 D=847 E=63

原始串：安全焦点（xfocus）

加密串：3393EC12F0A466E0AA9510D025D7BA0712DC3379F47D51C325D67B

解密串：安全焦点（xfocus）

四提高

前面已经提到，rsa的安全来源于n足够大，我们测试中使用的n是非常小的，根本不能保障安全性，

我们可以通过RSAKit、RSATool之类的工具获得足够大的N 及D E。

通过工具，我们获得1024位的N及D E来测试一下：

n=0x328C74784DF31119C526D18098EBEBB943B0032B599CEE13CC2BCE7B5FCD15F90B66EC3A85F5005D

BDCDED9BDFCB3C4C265AF164AD55884D8278F791C7A6BFDAD55EDBC4F017F9CCF1538D4C2013433B383B

47D80EC74B51276CA05B5D6346B9EE5AD2D7BE7ABFB36E37108DD60438941D2ED173CCA50E114705D7E2

BC511951

d=0x10001

e=0xE760A3804ACDE1E8E3D7DC0197F9CEF6282EF552E8CEBBB7434B01CB19A9D87A3106DD28C523C2995

4C5D86B36E943080E4919CA8CE08718C3B0930867A98F635EB9EA9200B25906D91B80A47B77324E66AFF2

C4D70D8B1C69C50A9D8B4B7A3C9EE05FFF3A16AFC023731D80634763DA1DCABE9861A4789BD782A592D2B

1965

设原始信息

M=0x11111111111122222222222233333333333

完成这么大数字的计算依赖于大数运算库，用perl来运算非常简单：

A) 用d对M进行加密如下：

c=M**d%n :

C:\Tempperl -Mbigint -e " $x=Math::BigInt-bmodpow(0x11111111111122222222222233

333333333, 0x10001, 0x328C74784DF31119C526D18098EBEBB943B0032B599CEE13CC2BCE7B5F

CD15F90B66EC3A85F5005DBDCDED9BDFCB3C4C265AF164AD55884D8278F791C7A6BFDAD55EDBC4F0

17F9CCF1538D4C2013433B383B47D80EC74B51276CA05B5D6346B9EE5AD2D7BE7ABFB36E37108DD6

0438941D2ED173CCA50E114705D7E2BC511951);print $x-as_hex"

0x17b287be418c69ecd7c39227ab681ac422fcc84bb35d8a632543b304de288a8d4434b73d2576bd

45692b007f3a2f7c5f5aa1d99ef3866af26a8e876712ed1d4cc4b293e26bc0a1dc67e247715caa6b

3028f9461a3b1533ec0cb476441465f10d8ad47452a12db0601c5e8beda686dd96d2acd59ea89b91

f1834580c3f6d90898

即用d对M加密后信息为：

c=0x17b287be418c69ecd7c39227ab681ac422fcc84bb35d8a632543b304de288a8d4434b73d2576bd

45692b007f3a2f7c5f5aa1d99ef3866af26a8e876712ed1d4cc4b293e26bc0a1dc67e247715caa6b

3028f9461a3b1533ec0cb476441465f10d8ad47452a12db0601c5e8beda686dd96d2acd59ea89b91

f1834580c3f6d90898

B) 用e对c进行解密如下：

m=c**e%n ：

C:\Tempperl -Mbigint -e " $x=Math::BigInt-bmodpow(0x17b287be418c69ecd7c39227ab

681ac422fcc84bb35d8a632543b304de288a8d4434b73d2576bd45692b007f3a2f7c5f5aa1d99ef3

866af26a8e876712ed1d4cc4b293e26bc0a1dc67e247715caa6b3028f9461a3b1533ec0cb4764414

65f10d8ad47452a12db0601c5e8beda686dd96d2acd59ea89b91f1834580c3f6d90898, 0xE760A

3804ACDE1E8E3D7DC0197F9CEF6282EF552E8CEBBB7434B01CB19A9D87A3106DD28C523C29954C5D

86B36E943080E4919CA8CE08718C3B0930867A98F635EB9EA9200B25906D91B80A47B77324E66AFF

2C4D70D8B1C69C50A9D8B4B7A3C9EE05FFF3A16AFC023731D80634763DA1DCABE9861A4789BD782A

592D2B1965, 0x328C74784DF31119C526D18098EBEBB943B0032B599CEE13CC2BCE7B5FCD15F90

B66EC3A85F5005DBDCDED9BDFCB3C4C265AF164AD55884D8278F791C7A6BFDAD55EDBC4F017F9CCF

1538D4C2013433B383B47D80EC74B51276CA05B5D6346B9EE5AD2D7BE7ABFB36E37108DD60438941

D2ED173CCA50E114705D7E2BC511951);print $x-as_hex"

0x11111111111122222222222233333333333

(我的P4 1.6G的机器上计算了约5秒钟）

得到用e解密后的m=0x11111111111122222222222233333333333 == M

C) RSA通常的实现

RSA简洁幽雅，但计算速度比较慢，通常加密中并不是直接使用RSA 来对所有的信息进行加密，

最常见的情况是随机产生一个对称加密的密钥，然后使用对称加密算法对信息加密，之后用

RSA对刚才的加密密钥进行加密。

最后需要说明的是，当前小于1024位的N已经被证明是不安全的

自己使用中不要使用小于1024位的RSA，最好使用2048位的。

----------------------------------------------------------

一个简单的RSA算法实现JAVA源代码：

filename:RSA.java

* Created on Mar 3, 2005

* TODO To change the template for this generated file go to

* Window - Preferences - Java - Code Style - Code Templates

import java.math.BigInteger;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.FileWriter;

import java.io.FileReader;

import java.io.BufferedReader;

import java.util.StringTokenizer;

/**

* @author Steve

* TODO To change the template for this generated type comment go to

* Window - Preferences - Java - Code Style - Code Templates

public class RSA {

/**

* BigInteger.ZERO

private static final BigInteger ZERO = BigInteger.ZERO;

/**

* BigInteger.ONE

private static final BigInteger ONE = BigInteger.ONE;

/**

* Pseudo BigInteger.TWO

private static final BigInteger TWO = new BigInteger("2");

private BigInteger myKey;

private BigInteger myMod;

private int blockSize;

public RSA (BigInteger key, BigInteger n, int b) {

myKey = key;

myMod = n;

blockSize = b;

}

public void encodeFile (String filename) {

byte[] bytes = new byte[blockSize / 8 + 1];

byte[] temp;

int tempLen;

InputStream is = null;

FileWriter writer = null;

try {

is = new FileInputStream(filename);

writer = new FileWriter(filename + ".enc");

}

catch (FileNotFoundException e1){

System.out.println("File not found: " + filename);

}

catch (IOException e1){

System.out.println("File not found: " + filename + ".enc");

}

/**

* Write encoded message to 'filename'.enc

try {

while ((tempLen = is.read(bytes, 1, blockSize / 8)) 0) {

for (int i = tempLen + 1; i bytes.length; ++i) {

bytes[i] = 0;

}

writer.write(encodeDecode(new BigInteger(bytes)) + " ");

}

catch (IOException e1) {

System.out.println("error writing to file");

}

/**

* Close input stream and file writer

try {

is.close();

writer.close();

}

catch (IOException e1) {

System.out.println("Error closing file.");

}

public void decodeFile (String filename) {

FileReader reader = null;

OutputStream os = null;

try {

reader = new FileReader(filename);

os = new FileOutputStream(filename.replaceAll(".enc", ".dec"));

}

catch (FileNotFoundException e1) {

if (reader == null)

System.out.println("File not found: " + filename);

else

System.out.println("File not found: " + filename.replaceAll(".enc", "dec"));

}

BufferedReader br = new BufferedReader(reader);

int offset;

byte[] temp, toFile;

StringTokenizer st = null;

try {

while (br.ready()) {

st = new StringTokenizer(br.readLine());

while (st.hasMoreTokens()){

toFile = encodeDecode(new BigInteger(st.nextToken())).toByteArray();

System.out.println(toFile.length + " x " + (blockSize / 8));

if (toFile[0] == 0 toFile.length != (blockSize / 8)) {

temp = new byte[blockSize / 8];

offset = temp.length - toFile.length;

for (int i = toFile.length - 1; (i = 0) ((i + offset) = 0); --i) {

temp[i + offset] = toFile[i];

}

toFile = temp;

}

/*if (toFile.length != ((blockSize / 8) + 1)){

temp = new byte[(blockSize / 8) + 1];

System.out.println(toFile.length + " x " + temp.length);

for (int i = 1; i temp.length; i++) {

temp[i] = toFile[i - 1];

}

toFile = temp;

}

else

System.out.println(toFile.length + " " + ((blockSize / 8) + 1));*/

os.write(toFile);

}

catch (IOException e1) {

System.out.println("Something went wrong");

}

/**

* close data streams

try {

os.close();

reader.close();

}

catch (IOException e1) {

System.out.println("Error closing file.");

}

/**

* Performs ttbase/tt^supttpow/tt/sup within the modular

* domain of ttmod/tt.

* @param base the base to be raised

* @param pow the power to which the base will be raisded

* @param mod the modular domain over which to perform this operation

* @return ttbase/tt^supttpow/tt/sup within the modular

* domain of ttmod/tt.

public BigInteger encodeDecode(BigInteger base) {

BigInteger a = ONE;

BigInteger s = base;

BigInteger n = myKey;

while (!n.equals(ZERO)) {

if(!n.mod(TWO).equals(ZERO))

a = a.multiply(s).mod(myMod);

s = s.pow(2).mod(myMod);

n = n.divide(TWO);

}

return a;

}

在这里提供两个版本的RSA算法JAVA实现的代码下载：

1. 来自于的RSA算法实现源代码包:

2. 来自于的实现:

- 源代码包

- 编译好的jar包

另外关于RSA算法的php实现请参见文章:

php下的RSA算法实现

关于使用VB实现RSA算法的源代码下载(此程序采用了psc1算法来实现快速的RSA加密):

RSA加密的JavaScript实现:

有一段用java实现rsa加解密的程序看不懂，希望高手帮我做下注释，详细些，谢谢

//引入文件

import java.security.*;

import javax.crypto.*;

/**

* RSACryptography

* RSACryptography use the privated key to encrypt the plain text and decrypt

* the cipher text with the public key

public class RSACryptography {

Cipher cipher;

/**

构造函数，就是你每次new这个对象RSACryptography 时候就会执行里面的方法

返回一个Cipher对象（其实他就是用来加密解密的）

public RSACryptography() {

try {

cipher = Cipher.getInstance("RSA");//返回一个cipher对象，该类

//应该是单例的

} catch (NoSuchAlgorithmException e) {//抛出异常，没什么说的

e.printStackTrace();

} catch (NoSuchPaddingException e) {

e.printStackTrace();

}

/**

好了，重点来了，你需要加密解密的就调用这个方法encrypt_decrypt（），传入一个byte[]的类型值byteInput,，就是你要加密的东西，在传入一个key，这个key 就像钥匙一样，你根据这个key进行加密，也可以根据这个key进行解密的，boolean 类型的 crypto，如果true就是加密，false就是解密

public byte[] encrypt_decrypt(byte[] byteInput, Key key, boolean crypto) {

try {

if(crypto){

cipher.init(Cipher.ENCRYPT_MODE,key);//加密前初始化

}else{

cipher.init(Cipher.DECRYPT_MODE,key);//解密前初始化

}

byte[] cipherByte = cipher.doFinal(byteInput);//进行加密或解密

return cipherByte;//返回你的加密或者解密值类型为byte[]

} catch (InvalidKeyException e) {//抛出异常

e.printStackTrace();

} catch (IllegalBlockSizeException e) {

e.printStackTrace();

} catch (BadPaddingException e) {

e.printStackTrace();

}

return null;

}

网页标题：javarsa代码 Java RSA
路径分享：http://6mz.cn/article/dodhdch.html

网站建设知识

javarsa代码 Java RSA

JAVA里面RSA加密算法的使用

Java中RSA的方式如何实现非对称加密的示例

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

高分求java的RSA 和IDEA 加密解密算法

有一段用java实现rsa加解密的程序看不懂，希望高手帮我做下注释，详细些，谢谢

其他资讯