RSA 非对称加密算法的Java实现
关于RSA的介绍Google一下很多，这里不做说明。项目开发中一般会把公钥放在本地进行加密，服务端通过私钥进行解密。Android项目开发中要用到这个加密算法，总结后实现如下：
import android.content.Context;
import android.util.Base64;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.Key;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.Cipher;
public class RSAUtil {
/**
* KEY_ALGORITHM
*/
public static final String KEY_ALGORITHM = "RSA";
/**
* 加密Key的长度等于1024
*/
public static int KEYSIZE = 1024;
/**
* 解密时必须按照此分组解密
*/
public static int decodeLen = KEYSIZE / 8;
/**
* 加密时小于117即可
*/
public static int encodeLen = 110;//(DEFAULT_KEY_SIZE / 8) - 11;
/**
* 加密填充方式,android系统的RSA实现是"RSA/None/NoPadding"，而标准JDK实现是"RSA/None/PKCS1Padding" ，这造成了在android机上加密后无法在服务器上解密的原因
*/
public static final String ECB_PKCS1_PADDING = "RSA/ECB/PKCS1Padding";
public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
/**
* 通过公钥加密
*/
public static byte[] encryptPublicKey(byte[] encryptedData, String key) throws Exception {
if (encryptedData == null) {
throw new IllegalArgumentException("Input encryption data is null");
}
byte[] encode = new byte[]{};
for (int i = 0; i < encryptedData.length; i += encodeLen) {
byte[] subarray = subarray(encryptedData, i, i + encodeLen);
byte[] doFinal = encryptByPublicKey(subarray, key);
encode = addAll(encode, doFinal);
}
return encode;
}
/**
* 通过私钥解密
*/
public static byte[] decryptPrivateKey(byte[] encode, String key) throws Exception {
if (encode == null) {
throw new IllegalArgumentException("Input data is null");
}
byte[] buffers = new byte[]{};
for (int i = 0; i < encode.length; i += decodeLen) {
byte[] subarray = subarray(encode, i, i + decodeLen);
byte[] doFinal = decryptByPrivateKey(subarray, key);
buffers = addAll(buffers, doFinal);
}
return buffers;
}
/**
* 从字符串中加载公钥
*
* @param publicKeyStr 公钥数据字符串
*/
private static PublicKey loadPublicKey(String publicKeyStr) throws Exception {
try {
byte[] buffer = decode(publicKeyStr);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//表示根据 ASN.1 类型 SubjectPublicKeyInfo 进行编码的公用密钥的 ASN.1 编码。
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
return keyFactory.generatePublic(keySpec);
} catch (NoSuchAlgorithmException e) {
throw new Exception("无此算法");
} catch (InvalidKeySpecException e) {
throw new Exception("公钥非法");
} catch (NullPointerException e) {
throw new Exception("公钥数据为空");
}
}
/**
* 从字符串中加载私钥<br>
* 加载时使用的是PKCS8EncodedKeySpec（PKCS#8编码的Key指令）。
*/
private static PrivateKey loadPrivateKey(String privateKeyStr) throws Exception {
try {
byte[] buffer = decode(privateKeyStr);
//表示按照 ASN.1 类型 PrivateKeyInfo 进行编码的专用密钥的 ASN.1 编码。
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
return keyFactory.generatePrivate(keySpec);
} catch (NoSuchAlgorithmException e) {
throw new Exception("无此算法");
} catch (InvalidKeySpecException e) {
throw new Exception("私钥非法");
} catch (NullPointerException e) {
throw new Exception("私钥数据为空");
}
}
/**
* 用私钥解密
*/
private static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception {
if (data == null) {
throw new IllegalArgumentException("Input data is null");
}
//取得私钥
Key privateKey = loadPrivateKey(key);
// 对数据解密
Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return cipher.doFinal(data);
}
/**
* 用公钥加密
*/
private static byte[] encryptByPublicKey(byte[] data, String key) throws Exception {
if (data == null) {
throw new IllegalArgumentException("Input data is null");
}
// 取得公钥
Key publicKey = loadPublicKey(key);
// 对数据加密
Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
return cipher.doFinal(data);
}
/**
* <p>
* BASE64字符串解码为二进制数据
* </p>
*/
public static byte[] decode(String base64) {
return Base64.decode(base64, Base64.DEFAULT);
}
/**
* <p>
* 二进制数据编码为BASE64字符串
* </p>
*/
public static String encode(byte[] bytes) {
return Base64.encodeToString(bytes, Base64.DEFAULT);
}
/**
* <p>Produces a new {@code byte} array containing the elements
* between the start and end indices.
*
* <p>The start index is inclusive, the end index exclusive.
* Null array input produces null output.
*
* @param array the array
* @param startIndexInclusive the starting index. Undervalue (<0)
* is promoted to 0, overvalue (>array.length) results
* in an empty array.
* @param endIndexExclusive elements up to endIndex-1 are present in the
* returned subarray. Undervalue (< startIndex) produces
* empty array, overvalue (>array.length) is demoted to
* array length.
* @return a new array containing the elements between
* the start and end indices.
* @since 2.1
*/
private static byte[] subarray(final byte[] array, int startIndexInclusive, int endIndexExclusive) {
if (array == null) {
return null;
}
if (startIndexInclusive < 0) {
startIndexInclusive = 0;
}
if (endIndexExclusive > array.length) {
endIndexExclusive = array.length;
}
final int newSize = endIndexExclusive - startIndexInclusive;
if (newSize <= 0) {
return EMPTY_BYTE_ARRAY;
}
final byte[] subarray = new byte[newSize];
System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
return subarray;
}
/**
* <p>Adds all the elements of the given arrays into a new array.
* <p>The new array contains all of the element of {@code array1} followed
* by all of the elements {@code array2}. When an array is returned, it is always
* a new array.
*
* @param array1 the first array whose elements are added to the new array.
* @param array2 the second array whose elements are added to the new array.
* @return The new byte[] array.
* @since 2.1
*/
private static byte[] addAll(final byte[] array1, final byte... array2) {
if (array1 == null) {
return clone(array2);
} else if (array2 == null) {
return clone(array1);
}
final byte[] joinedArray = new byte[array1.length + array2.length];
System.arraycopy(array1, 0, joinedArray, 0, array1.length);
System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
return joinedArray;
}
/**
* <p>Clones an array returning a typecast result and handling
* {@code null}.
*
* <p>This method returns {@code null} for a {@code null} input array.
*
* @param array the array to clone, may be {@code null}
* @return the cloned array, {@code null} if {@code null} input
*/
private static byte[] clone(final byte[] array) {
if (array == null) {
return null;
}
return array.clone();
}
/**
* 读取密钥信息
*/
public static String readString(InputStream in) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String readLine = null;
StringBuilder sb = new StringBuilder();
while ((readLine = br.readLine()) != null) {
if (readLine.charAt(0) == '-') {
continue;
} else {
sb.append(readLine);
sb.append('\r');
}
}
return sb.toString();
}
}
使用如下：
/**
* 获取加密数据
*
* @param encryptStr 待加密字符串
* rsa_public_key.pem 为本地公钥
*/
public String getEncryptData(Context context, String encryptStr) {
try {
InputStream inPublic = context.getResources().getAssets().open("rsa_public_key.pem");
String publicKey = readString(inPublic);
byte[] encodedData = encryptPublicKey(encryptStr.getBytes(), publicKey);
return encode(encodedData);
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return "";
}
