這兩天在看Android開發中用到的加密解密算法,就上網搜,找到了一些不錯的文章,現和大家分享一下。今天分享的是非對稱加密算法——RSA。
一、什麼是Rsa加密?
RSA算法是最流行的公鑰密碼算法,使用長度可以變化的密鑰。RSA是第一個既能用於數據加密也能用於數字簽名的算法。
RSA算法原理如下:
1.隨機選擇兩個大質數p和q,p不等於q,計算N=pq;
2.選擇一個大於1小於N的自然數e,e必須與(p-1)(q-1)互素。
3.用公式計算出d:d×e = 1 (mod (p-1)(q-1)) 。
4.銷燬p和q。
最終得到的N和e就是“公鑰”,d就是“私鑰”,發送方使用N去加密數據,接收方只有使用d才能解開數據內容。
RSA的安全性依賴於大數分解,小於1024位的N已經被證明是不安全的,而且由於RSA算法進行的都是大數計算,使得RSA最快的情況也比DES慢上倍,這是RSA最大的缺陷,因此通常只能用於加密少量數據或者加密密鑰,但RSA仍然不失爲一種高強度的算法。
二、該如何使用呢?
首先生成祕鑰對
/**
* 隨機生成RSA密鑰對
*
* @param keyLength 密鑰長度,範圍:512~2048;一般爲1024
* @return 密鑰對兒(包含公鑰和私鑰)
*/
public static KeyPair generateRSAKeyPair(int keyLength) {
try {
KeyPairGenerator kpg = KeyPairGenerator.getInstance(RSA);
kpg.initialize(keyLength);
return kpg.genKeyPair();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
}
生成了密鑰對——一個公鑰和一個私鑰,兩個密鑰都可以進行加密和解密。這樣我們就需要寫四個方法,分別是:公鑰加密、公鑰解密、私密加密、私鑰解密四個方法。
具體加密實現如下:
三、正常的加密、解密實現
1.公鑰加密
/**
* 使用公鑰加密
*
* @param data 待加密數據
* @param publicKey 公鑰
* @return byte[] 加密數據
*/
public static byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
// 得到公鑰
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PublicKey keyPublic = kf.generatePublic(keySpec);
// 加密數據
Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);
cp.init(Cipher.ENCRYPT_MODE, keyPublic);
return cp.doFinal(data);
}
2.私鑰加密
/**
* 使用私鑰加密
*
* @param data 待加密數據
* @param privateKey 私鑰
* @return byte[] 加密數據
*/
public static byte[] encryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
// 得到私鑰
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PrivateKey keyPrivate = kf.generatePrivate(keySpec);
// 數據加密
Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
cipher.init(Cipher.ENCRYPT_MODE, keyPrivate);
return cipher.doFinal(data);
}
3.公鑰解密
/**
* 使用公鑰解密
*
* @param data 待解密數據
* @param publicKey 公鑰
* @return byte[] 解密數據
*/
public static byte[] decryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
// 得到公鑰
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PublicKey keyPublic = kf.generatePublic(keySpec);
// 數據解密
Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
cipher.init(Cipher.DECRYPT_MODE, keyPublic);
return cipher.doFinal(data);
}
4.私鑰解密
/**
* 使用私鑰進行解密
*
* @param data 待解密數據
* @param privateKey 私鑰
* @return byte[] 解密數據
*/
public static byte[] decryptByPrivateKey(byte[] encrypted, byte[] privateKey) throws Exception {
// 得到私鑰
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PrivateKey keyPrivate = kf.generatePrivate(keySpec);
// 解密數據
Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);
cp.init(Cipher.DECRYPT_MODE, keyPrivate);
byte[] arr = cp.doFinal(encrypted);
return arr;
}
幾個全局變量解說:public static final String RSA = "RSA";// 非對稱加密密鑰算法
public static final String ECB_PKCS1_PADDING = "RSA/ECB/PKCS1Padding";//加密填充方式
public static final int DEFAULT_KEY_SIZE = 2048;//祕鑰默認長度
public static final byte[] DEFAULT_SPLIT = "#PART#".getBytes(); // 當要加密的內容超過bufferSize,則採用partSplit進行分塊加密
public static final int DEFAULT_BUFFERSIZE = (DEFAULT_KEY_SIZE / 8) - 11;// 當前祕鑰支持加密的最大字節數
public static RSAPublicKey publicKey; // 公鑰
public static RSAPrivateKey privateKey; // 私鑰
關於加密填充方式:之前以爲上面這些操作就能實現rsa加解密,以爲萬事大吉了,呵呵,這事還沒完,悲劇還是發生了,Android這邊加密過的數據,服務器端死活解密不了,原來android系統的RSA實現是"RSA/None/NoPadding",而標準JDK實現是"RSA/None/PKCS1Padding" ,這造成了在android機上加密後無法在服務器上解密的原因,所以在實現的時候這個一定要注意。
實現分段加密:搞定了填充方式之後又自信的認爲萬事大吉了,可是意外還是發生了,RSA非對稱加密內容長度有限制,1024位key的最多隻能加密127位數據,否則就會報錯(javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes) , RSA 是常用的非對稱加密算法。最近使用時卻出現了“不正確的長度”的異常,研究發現是由於待加密的數據超長所致。RSA 算法規定:待加密的字節數不能超過密鑰的長度值除以 8 再減去 11(即:KeySize / 8 - 11),而加密後得到密文的字節數,正好是密鑰的長度值除以 8(即:KeySize / 8)。
四、分段加密解密實現
1.公鑰分段加密
/**
* 用公鑰對字符串進行分段加密
*
* @param data 待加密數據
* @param publicKey 公鑰
*/
public static byte[] encryptByPublicKeyForSpilt(byte[] data, byte[] publicKey) throws Exception {
int dataLen = data.length;
// 如果數據的長度不超過密鑰支持的最大值,就直接進行加密操作
if (dataLen <= DEFAULT_BUFFERSIZE) {
return encryptByPublicKey(data, publicKey);
}
// 否則進行分段加密,allBytes是分段加密後數據的載體
List<Byte> allBytes = new ArrayList<Byte>(2048);
int bufIndex = 0;
int subDataLoop = 0;
byte[] buf = new byte[DEFAULT_BUFFERSIZE];
for (int i = 0; i < dataLen; i++) {
buf[bufIndex] = data[i];
// 如果到最大長度了或是到數組結尾了,就添加一個分段標識
if (++bufIndex == DEFAULT_BUFFERSIZE || i == dataLen - 1) {
subDataLoop++;
// 除了第一段,之後每兩段之間加一個分段標識
if (subDataLoop != 1) {
for (byte b : DEFAULT_SPLIT) {
allBytes.add(b);
}
}
byte[] encryptBytes = encryptByPublicKey(buf, publicKey);
for (byte b : encryptBytes) {
allBytes.add(b);
}
bufIndex = 0;
if (i == dataLen - 1) {
buf = null;
} else {
buf = new byte[Math.min(DEFAULT_BUFFERSIZE, dataLen - i - 1)];
}
}
}
byte[] bytes = new byte[allBytes.size()];
{
int i = 0;
for (Byte b : allBytes) {
bytes[i++] = b.byteValue();
}
}
return bytes;
}
2.私鑰分段加密
/**
* 用私鑰對字符串進行分段加密
*
* @param data 要加密的原始數據
* @param privateKey 私鑰
*/
public static byte[] encryptByPrivateKeyForSpilt(byte[] data, byte[] privateKey) throws Exception {
int dataLen = data.length;
// 如果數據的長度不超過密鑰支持的最大值,就直接進行加密操作
if (dataLen <= DEFAULT_BUFFERSIZE) {
return encryptByPrivateKey(data, privateKey);
}
// 否則進行分段加密,allBytes是分段加密後數據的載體
List<Byte> allBytes = new ArrayList<Byte>(2048);
int bufIndex = 0;
int subDataLoop = 0;
byte[] buf = new byte[DEFAULT_BUFFERSIZE];
for (int i = 0; i < dataLen; i++) {
buf[bufIndex] = data[i];
// 如果到最大長度了或是到數組結尾了,就添加一個分段標識
if (++bufIndex == DEFAULT_BUFFERSIZE || i == dataLen - 1) {
subDataLoop++;
// 除了第一段,之後每兩段之間加一個分段標識
if (subDataLoop != 1) {
for (byte b : DEFAULT_SPLIT) {
allBytes.add(b);
}
}
byte[] encryptBytes = encryptByPrivateKey(buf, privateKey);
for (byte b : encryptBytes) {
allBytes.add(b);
}
bufIndex = 0;
if (i == dataLen - 1) {
buf = null;
} else {
buf = new byte[Math.min(DEFAULT_BUFFERSIZE, dataLen - i - 1)];
}
}
}
byte[] bytes = new byte[allBytes.size()];
{
int i = 0;
for (Byte b : allBytes) {
bytes[i++] = b.byteValue();
}
}
return bytes;
}
3.公鑰分段解密
/**
* 用公鑰對字符串進行分段解密
*
* @param encrypted 待解密數據
* @param publicKey 公鑰
*/
public static byte[] decryptByPublicKeyForSpilt(byte[] encrypted, byte[] publicKey) throws Exception {
int splitLen = DEFAULT_SPLIT.length;
// 如果分塊解密的標識的長度爲0,就直接進行加密操作,換句話說:如果沒有分塊解密的標識,直接進行解密
if (splitLen <= 0) {
return decryptByPublicKey(encrypted, publicKey);
}
// 否則進行分塊解密
int dataLen = encrypted.length;
// 解密後數據的載體
List<Byte> allBytes = new ArrayList<Byte>(1024);
int latestStartIndex = 0;
for (int i = 0; i < dataLen; i++) {
byte bt = encrypted[i];
boolean isMatchSplit = false;
if (i == dataLen - 1) {
// 到data的最後了,直接進行解密
byte[] part = new byte[dataLen - latestStartIndex];
System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
byte[] decryptPart = decryptByPublicKey(part, publicKey);
for (byte b : decryptPart) {
allBytes.add(b);
}
latestStartIndex = i + splitLen;
i = latestStartIndex - 1;
} else if (bt == DEFAULT_SPLIT[0]) {
// 如果找到以split[0]開頭字節,就開始判斷其是否爲分組標識,如果是就將isMatchSplit改爲true
if (splitLen > 1) {
if (i + splitLen < dataLen) {
// 沒有超出data的範圍
for (int j = 1; j < splitLen; j++) {
if (DEFAULT_SPLIT[j] != encrypted[i + j]) {
break;
}
if (j == splitLen - 1) {
// 驗證到split的最後一位,都沒有break,則表明已經確認是split段(即:是分組標識)
isMatchSplit = true;
}
}
}
} else {
// split只有一位,則已經匹配了
isMatchSplit = true;
}
}
// 如果isMatchSplit爲true,則就進行分割數據串,然後解密後放入allBytes
if (isMatchSplit) {
byte[] part = new byte[i - latestStartIndex];
System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
byte[] decryptPart = decryptByPublicKey(part, publicKey);
for (byte b : decryptPart) {
allBytes.add(b);
}
latestStartIndex = i + splitLen;
i = latestStartIndex - 1;
}
}
// 返回解密後數據
byte[] bytes = new byte[allBytes.size()];
{
int i = 0;
for (Byte b : allBytes) {
bytes[i++] = b.byteValue();
}
}
return bytes;
}
4.私鑰分段解密
/**
* 用私鑰對字符串進行分段解密
*
* @param encrypted 待解密的數據
* @param privateKey 私鑰
*/
public static byte[] decryptByPrivateKeyForSpilt(byte[] encrypted, byte[] privateKey) throws Exception {
int splitLen = DEFAULT_SPLIT.length;
// 如果分塊解密的標識的長度爲0,就直接進行加密操作,換句話說:如果沒有分塊解密的標識,直接進行解密
if (splitLen <= 0) {
return decryptByPrivateKey(encrypted, privateKey);
}
// 否則進行分塊解密
int dataLen = encrypted.length;
// 解密後數據的載體
List<Byte> allBytes = new ArrayList<Byte>(1024);
int latestStartIndex = 0;
for (int i = 0; i < dataLen; i++) {
byte bt = encrypted[i];
boolean isMatchSplit = false;
if (i == dataLen - 1) {
// 到data的最後了,直接進行解密
byte[] part = new byte[dataLen - latestStartIndex];
System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
byte[] decryptPart = decryptByPrivateKey(part, privateKey);
for (byte b : decryptPart) {
allBytes.add(b);
}
latestStartIndex = i + splitLen;
i = latestStartIndex - 1;
} else if (bt == DEFAULT_SPLIT[0]) {
// 如果找到以split[0]開頭字節,就開始判斷其是否爲分組標識,如果是就將isMatchSplit改爲true
if (splitLen > 1) {
if (i + splitLen < dataLen) {
// 沒有超出data的範圍
for (int j = 1; j < splitLen; j++) {
if (DEFAULT_SPLIT[j] != encrypted[i + j]) {
break;
}
if (j == splitLen - 1) {
// 驗證到split的最後一位,都沒有break,則表明已經確認是split段(即:是分組標識)
isMatchSplit = true;
}
}
}
} else {
// split只有一位,則已經匹配了
isMatchSplit = true;
}
}
// 如果isMatchSplit爲true,則就進行分割數據串,然後解密後放入allBytes
if (isMatchSplit) {
byte[] part = new byte[i - latestStartIndex];
System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
byte[] decryptPart = decryptByPrivateKey(part, privateKey);
for (byte b : decryptPart) {
allBytes.add(b);
}
latestStartIndex = i + splitLen;
i = latestStartIndex - 1;
}
}
// 返回解密後數據
byte[] bytes = new byte[allBytes.size()];
{
int i = 0;
for (Byte b : allBytes) {
bytes[i++] = b.byteValue();
}
}
return bytes;
}
}
5.加密、解密的圖文註解
在這兒我需要掛圖進行註釋一下,主要是將其邏輯可視化,讓看代碼的人更省時間,可以更快、更清楚的理解分塊兒加密、分塊解密的原理。好了,直接上圖:
關於分塊加密圖解(私鑰分塊加密和公鑰分塊加密的原理一樣一樣的):
關於分塊解密圖解(私鑰分塊解密和公鑰分塊解密的原理一樣一樣的):
這樣總算把遇見的問題解決了,接下來我們就進行一番測試,通過效率,我們來看看到底是選用公鑰加密——私密解密的方式好,還是選用私鑰加密——公鑰解密的方式好。
五、實例測試
第一步:準備100條對象數據(基本數據不具代表性,我們平時還是用的對象多)
public static String getData() {
List<Person> personList=new ArrayList<>();
int testMaxCount=100;//測試的最大數據條數
//添加測試數據
for(int i=0;i<testMaxCount;i++){
Person person =new Person();
person.setAge(i);
person.setName("name->" + String.valueOf(i));
personList.add(person);
}
// 生成自己想要測試的數據
String jsonData = personList.toString();
System.out.println("MainActivity:加密前數據 ---->" + jsonData);
System.out.println("MainActivity:加密前數據長度 ---->"+jsonData.length());
return jsonData;
}
第二步:生成祕鑰對
public static void getkey() {
// 隨機生成RSA密鑰對
KeyPair keyPair=RSAUtils.generateRSAKeyPair(RSAUtils.DEFAULT_KEY_SIZE);
// 公鑰
publicKey = (RSAPublicKey) keyPair.getPublic();
// 私鑰
privateKey = (RSAPrivateKey) keyPair.getPrivate();
}
第三步:分別使用公鑰加密——私鑰解密 和 私鑰加密——公鑰解密
public static void main(String[] args) {
// 生成待加密的數據源
String rawData = getData();
// 得到隨機的密鑰對兒
getkey();
// 記錄加密/解密開始時的系統時間(單位:ms)
long start= 0;
// 記錄加密/解密結束時的系統時間(單位:ms)
long end = 0;
// 加密後的數據串(String型)
String encryStr = "";
// 解密後數據串(String型)
String decryStr = "";
// 加密後的數據(byte[]型的)
byte[] encryptBytes;
// 解密後數據(byte[]型的)
byte[] decryptBytes;
/**
* 對數據進行:公鑰加密,私鑰解密
*/
try {
//公鑰加密
start = System.currentTimeMillis();
encryptBytes = RSAUtils.encryptByPublicKeyForSpilt(rawData.getBytes(),publicKey.getEncoded());
end=System.currentTimeMillis();
System.out.println("公鑰加密耗時 cost time---->"+(end-start));
encryStr=Base64.getEncoder().encodeToString(encryptBytes);
System.out.println("加密後數據串 --1-->"+encryStr);
System.out.println("加密後數據串長度 --1-->"+encryStr.length());
//私鑰解密
start=System.currentTimeMillis();
decryptBytes= RSAUtils.decryptByPrivateKeyForSpilt(Base64.getDecoder().decode(encryStr), privateKey.getEncoded());
end=System.currentTimeMillis();
System.out.println("私鑰解密耗時 cost time---->"+(end-start));
decryStr=new String(decryptBytes);
System.out.println("解密後數據串 --1-->"+decryStr);
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
/**
* 對數據進行:公鑰加密,私鑰解密
*/
try {
//私鑰加密
start=System.currentTimeMillis();
encryptBytes= RSAUtils.encryptByPrivateKeyForSpilt(rawData.getBytes(),privateKey.getEncoded());
end=System.currentTimeMillis();
System.out.println("私鑰加密密耗時 cost time---->"+(end-start));
encryStr=Base64.getEncoder().encodeToString(encryptBytes);
System.out.println("加密後數據串 --2-->"+encryStr);
System.out.println("加密後數據串長度 --2-->"+encryStr.length());
//公鑰解密
start=System.currentTimeMillis();
decryptBytes= RSAUtils.decryptByPublicKeyForSpilt(Base64.getDecoder().decode(encryStr),publicKey.getEncoded());
end=System.currentTimeMillis();
System.out.println("公鑰解密耗時 cost time---->"+(end-start));
decryStr=new String(decryptBytes);
System.out.println("解密後數據串 --2-->"+decryStr);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
六、輸出結果
接下來我們來看幾組數據進行比較一番:
比對一:
公鑰加密耗時 cost time---->224
私鑰解密耗時 cost time---->111
私鑰加密耗時 cost time---->116
公鑰解密耗時 cost time---->5
對比發現:私鑰的加解密都很耗時,所以可以根據不同的需求採用不能方案來進行加解密。個人覺得服務器要求解密效率高,客戶端私鑰加密,服務器公鑰解密比較好一點
比對二:
加密前數據長度 ---->3180
公鑰加密後數據串長度 --1-->4536
私鑰解密後數據串長度 --1-->3180
私鑰加密後數據串長度 --2-->4536
公鑰解密後數據串長度 --2-->3180
加密後數據大小的變化:數據量差不多是加密前的1.5倍
本文參考:http://www.cnblogs.com/whoislcj/p/5470095.html 博主的,並進行了驗證和整理添加了註釋。該博主是用Android Studio開發的,我是用Eclipse驗證的,就是公鑰加密耗時這塊兒沒對上,其他都對上了。不過對比發現的規律不變。
謝謝大家的閱讀,如果有什麼建議和疑問的朋友,還是老規矩,請留言,我們一塊兒交流互動!謝謝!