依旧是练习的产物，java的加密算法有很多，可惜用起来很痛苦（个人感受），有时间的话打算做个简化过程的所有加密算法工具类，之前已经写过一个包含MD5、SHA1、DES、AES、异或的简单工具类
这里简单讲一下RSA：
我们平时所知道的密码什么的都基本是一个，DES、AES的加密解密也都是用同一个密码，但是RSA就不一样了，RSA有2个密码：公钥、私钥。
为什么要用2个密码？要怎么用？
用2个密码自然是为了数据的安全，防止丢失数据后被人恶意破解。
至于怎么用，其实就是用公钥加密后只能用私钥解密，私钥加密后只能用公钥解密。
就以支付宝的集成为例，你得在本地生成公钥跟私钥，然后上传给支付宝，之后传输数据的时候就是用这对密码来加解密的。（当然，加解密的步骤支付宝已经帮你做了，你是不用去写RSA的代码的）
题外话：其实我一直觉得支付宝这个生成公钥私钥可以在支付宝平台做的，每次都要我在本地生成，然后还要去传给支付宝平台，真的有一点点、一点点的烦。。。
---
v1.1 加入分段处理
package com.lwx.encrypt;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.interfaces.RSAPrivateCrtKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.Cipher;
public class RSA {
public static void main(String ...args){
RSA rsa = RSA.create();
String pubKey = rsa.getPublicKey();
String priKey = rsa.getPrivateKey();
//原文
StringBuffer res = new StringBuffer();
for (int i = 0; i < 40; i++) {
res.append("测试");
}
System.out.println("原文对比:"+res.toString());
System.out.println("------------");
String enStr = rsa.encodeByPublicKey(res.toString(), pubKey);
String deStr = rsa.decodeByPrivateKey(enStr, priKey);
System.out.println("公钥加密:"+enStr);
System.out.println("私钥解密:"+deStr);
System.out.println("------------");
enStr = rsa.encodeByPrivateKey(res.toString(), priKey);
deStr = rsa.decodeByPublicKey(enStr, pubKey);
System.out.println("私钥加密:"+enStr);
System.out.println("公钥解密:"+deStr);
}
public static final String KEY_ALGORITHM = "RSA";
public static final String split = " ";//分隔符
public static final int max = 117;//加密分段长度//不可超过117
private static RSA me;
private RSA(){}//单例
public static RSA create(){
if (me==null) {
me = new RSA();
}
//生成公钥、私钥
try {
KeyPairGenerator kpg = KeyPairGenerator.getInstance(KEY_ALGORITHM);
kpg.initialize(1024);
KeyPair kp = kpg.generateKeyPair();
me.publicKey = (RSAPublicKey) kp.getPublic();
me.privateKey = (RSAPrivateCrtKey) kp.getPrivate();
} catch (Exception e) {
e.printStackTrace();
}
return me;
}
private RSAPublicKey publicKey;
private RSAPrivateCrtKey privateKey;
/**获取公钥*/
public String getPublicKey(){
return parseByte2HexStr(publicKey.getEncoded());
}
/**获取私钥*/
public String getPrivateKey(){
return parseByte2HexStr(privateKey.getEncoded());
}
/**加密-公钥*/
public String encodeByPublicKey(String res,String key){
byte[] resBytes = res.getBytes();
byte[] keyBytes = parseHexStr2Byte(key);//先把公钥转为2进制
StringBuffer result = new StringBuffer();//结果
//如果超过了100个字节就分段
if (keyBytes.length<=max) {//不超过直接返回即可
return encodePub(resBytes, keyBytes);
}else {
int size = resBytes.length/max + (resBytes.length%max>0?1:0);
for (int i = 0; i < size; i++) {
int len = i==size-1?resBytes.length%max:max;
byte[] bs = new byte[len];//临时数组
System.arraycopy(resBytes, i*max, bs, 0, len);
result.append(encodePub(bs, keyBytes));
if(i!=size-1)result.append(split);
}
return result.toString();
}
}
/**加密-私钥*/
public String encodeByPrivateKey(String res,String key){
byte[] resBytes = res.getBytes();
byte[] keyBytes = parseHexStr2Byte(key);
StringBuffer result = new StringBuffer();
//如果超过了100个字节就分段
if (keyBytes.length<=max) {//不超过直接返回即可
return encodePri(resBytes, keyBytes);
}else {
int size = resBytes.length/max + (resBytes.length%max>0?1:0);
for (int i = 0; i < size; i++) {
int len = i==size-1?resBytes.length%max:max;
byte[] bs = new byte[len];//临时数组
System.arraycopy(resBytes, i*max, bs, 0, len);
result.append(encodePri(bs, keyBytes));
if(i!=size-1)result.append(split);
}
return result.toString();
}
}
/**解密-公钥*/
public String decodeByPublicKey(String res,String key){
byte[] keyBytes = parseHexStr2Byte(key);
//先分段
String[] rs = res.split("\\"+split);
//分段解密
if(rs!=null){
int len = 0;
//组合byte[]
byte[] result = new byte[rs.length*max];
for (int i = 0; i < rs.length; i++) {
byte[] bs = decodePub(parseHexStr2Byte(rs[i]), keyBytes);
System.arraycopy(bs, 0, result, i*max, bs.length);
len+=bs.length;
}
byte[] newResult = new byte[len];
System.arraycopy(result, 0, newResult, 0, len);
//还原字符串
return new String(newResult);
}
return null;
}
/**解密-私钥*/
public String decodeByPrivateKey(String res,String key){
byte[] keyBytes = parseHexStr2Byte(key);
//先分段
String[] rs = res.split("\\"+split);
//分段解密
if(rs!=null){
int len = 0;
//组合byte[]
byte[] result = new byte[rs.length*max];
for (int i = 0; i < rs.length; i++) {
byte[] bs = decodePri(parseHexStr2Byte(rs[i]), keyBytes);
System.arraycopy(bs, 0, result, i*max, bs.length);
len+=bs.length;
}
byte[] newResult = new byte[len];
System.arraycopy(result, 0, newResult, 0, len);
//还原字符串
return new String(newResult);
}
return null;
}
/**将二进制转换成16进制 */
public static String parseByte2HexStr(byte buf[]) {
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());
}
return sb.toString();
}
/**将16进制转换为二进制*/
public static byte[] parseHexStr2Byte(String hexStr) {
if (hexStr.length() < 1)
return null;
byte[] result = new byte[hexStr.length()/2];
for (int i = 0;i< hexStr.length()/2; i++) {
int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);
int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);
result[i] = (byte) (high * 16 + low);
}
return result;
}
/**加密-公钥-无分段*/
private String encodePub(byte[] res,byte[] keyBytes){
X509EncodedKeySpec x5 = new X509EncodedKeySpec(keyBytes);//用2进制的公钥生成x509
try {
KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM);
Key pubKey = kf.generatePublic(x5);//用KeyFactory把x509生成公钥pubKey
Cipher cp = Cipher.getInstance(kf.getAlgorithm());//生成相应的Cipher
cp.init(Cipher.ENCRYPT_MODE, pubKey);//给cipher初始化为加密模式，以及传入公钥pubKey
return parseByte2HexStr(cp.doFinal(res));//以16进制的字符串返回
} catch (Exception e) {
System.out.println("公钥加密失败");
e.printStackTrace();
}
return null;
}
/**加密-私钥-无分段*/
private String encodePri(byte[] res,byte[] keyBytes){
PKCS8EncodedKeySpec pk8 = new PKCS8EncodedKeySpec(keyBytes);
try {
KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM);
Key priKey = kf.generatePrivate(pk8);
Cipher cp = Cipher.getInstance(kf.getAlgorithm());
cp.init(Cipher.ENCRYPT_MODE, priKey);
return parseByte2HexStr(cp.doFinal(res));
} catch (Exception e) {
System.out.println("私钥加密失败");
e.printStackTrace();
}
return null;
}
/**解密-公钥-无分段*/
private byte[] decodePub(byte[] res,byte[] keyBytes){
X509EncodedKeySpec x5 = new X509EncodedKeySpec(keyBytes);
try {
KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM);
Key pubKey = kf.generatePublic(x5);
Cipher cp = Cipher.getInstance(kf.getAlgorithm());
cp.init(Cipher.DECRYPT_MODE, pubKey);
return cp.doFinal(res);
} catch (Exception e) {
System.out.println("公钥解密失败");
e.printStackTrace();
}
return null;
}
/**解密-私钥-无分段*/
private byte[] decodePri(byte[] res,byte[] keyBytes){
PKCS8EncodedKeySpec pk8 = new PKCS8EncodedKeySpec(keyBytes);
try {
KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM);
Key priKey = kf.generatePrivate(pk8);
Cipher cp = Cipher.getInstance(kf.getAlgorithm());
cp.init(Cipher.DECRYPT_MODE, priKey);
return cp.doFinal(res);
} catch (Exception e) {
System.out.println("私钥解密失败");
e.printStackTrace();
}
return null;
}
}
来源：oschina
链接：https://my.oschina.net/u/816576/blog/746246