這是RSA工具類，可以使用
/**
* RSA加密工具類
* <p>
* Create by Mazhanzhu on 2019/8/10
*/
public class RSAUtils {
private static final String TAG = "RSAUtils";
public static final String KEY_ALGORITHM = "RSA";
public static final String split = " ";// 分隔符
public static final int max = 117;// 加密分段長度//不可超過117
private static RSAUtils me;
private RSAUtils() {
}// 單例
public static RSAUtils create() {
if (me == null) {
me = new RSAUtils();
}
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;
}
}