編輯:關於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; } }
具體加密實現:
公鑰加密
/** * 用公鑰對字符串進行加密 * * @param data 原文 */ 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); }
私鑰加密
/** * 私鑰加密 * * @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); }
公鑰解密
/** * 公鑰解密 * * @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); }
私鑰解密
/** * 使用私鑰進行解密 */ 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;// 當前秘鑰支持加密的最大字節數
關於加密填充方式:之前以為上面這些操作就能實現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)。
公鑰分段加密
/** * 用公鑰對字符串進行分段加密 * */ public static byte[] encryptByPublicKeyForSpilt(byte[] data, byte[] publicKey) throws Exception { int dataLen = data.length; if (dataLen <= DEFAULT_BUFFERSIZE) { return encryptByPublicKey(data, publicKey); } 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; }
私鑰分段加密
/** * 分段加密 * * @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); } 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; }
公鑰分段解密
/** * 公鑰分段解密 * * @param encrypted 待解密數據 * @param publicKey 密鑰 */ public static byte[] decryptByPublicKeyForSpilt(byte[] encrypted, byte[] publicKey) throws Exception { int splitLen = DEFAULT_SPLIT.length; 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]開頭 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; } } 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; }
私鑰分段解密
/** * 使用私鑰分段解密 * */ public static byte[] decryptByPrivateKeyForSpilt(byte[] encrypted, byte[] privateKey) throws Exception { int splitLen = DEFAULT_SPLIT.length; 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]開頭 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; } } 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; }
這樣總算把遇見的問題解決了,項目中使用的方案是客戶端公鑰加密,服務器私鑰解密,服務器開發人員說是出於效率考慮,所以還是自己寫了個程序測試一下真正的效率
第一步:准備100條對象數據
List<Person> personList=new ArrayList<>(); int testMaxCount=100;//測試的最大數據條數 //添加測試數據 for(int i=0;i<testMaxCount;i++){ Person person =new Person(); person.setAge(i); person.setName(String.valueOf(i)); personList.add(person); } //FastJson生成json數據 String jsonData=JsonUtils.objectToJsonForFastJson(personList); Log.e("MainActivity","加密前json數據 ---->"+jsonData); Log.e("MainActivity","加密前json數據長度 ---->"+jsonData.length());
第二步生成秘鑰對
KeyPair keyPair=RSAUtils.generateRSAKeyPair(RSAUtils.DEFAULT_KEY_SIZE); // 公鑰 RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); // 私鑰 RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
接下來分別使用公鑰加密 私鑰解密 私鑰加密 公鑰解密
//公鑰加密 long start=System.currentTimeMillis(); byte[] encryptBytes= RSAUtils.encryptByPublicKeyForSpilt(jsonData.getBytes(),publicKey.getEncoded()); long end=System.currentTimeMillis(); Log.e("MainActivity","公鑰加密耗時 cost time---->"+(end-start)); String encryStr=Base64Encoder.encode(encryptBytes); Log.e("MainActivity","加密後json數據 --1-->"+encryStr); Log.e("MainActivity","加密後json數據長度 --1-->"+encryStr.length()); //私鑰解密 start=System.currentTimeMillis(); byte[] decryptBytes= RSAUtils.decryptByPrivateKeyForSpilt(Base64Decoder.decodeToBytes(encryStr),privateKey.getEncoded()); String decryStr=new String(decryptBytes); end=System.currentTimeMillis(); Log.e("MainActivity","私鑰解密耗時 cost time---->"+(end-start)); Log.e("MainActivity","解密後json數據 --1-->"+decryStr); //私鑰加密 start=System.currentTimeMillis(); encryptBytes= RSAUtils.encryptByPrivateKeyForSpilt(jsonData.getBytes(),privateKey.getEncoded()); end=System.currentTimeMillis(); Log.e("MainActivity","私鑰加密密耗時 cost time---->"+(end-start)); encryStr=Base64Encoder.encode(encryptBytes); Log.e("MainActivity","加密後json數據 --2-->"+encryStr); Log.e("MainActivity","加密後json數據長度 --2-->"+encryStr.length()); //公鑰解密 start=System.currentTimeMillis(); decryptBytes= RSAUtils.decryptByPublicKeyForSpilt(Base64Decoder.decodeToBytes(encryStr),publicKey.getEncoded()); decryStr=new String(decryptBytes); end=System.currentTimeMillis(); Log.e("MainActivity","公鑰解密耗時 cost time---->"+(end-start)); Log.e("MainActivity","解密後json數據 --2-->"+decryStr);
運行結果:
對比發現:私鑰的加解密都很耗時,所以可以根據不同的需求采用不能方案來進行加解密。個人覺得服務器要求解密效率高,客戶端私鑰加密,服務器公鑰解密比較好一點
加密後數據大小的變化:數據量差不多是加密前的1.5倍
以上就是小編為大家帶來的Android數據加密之Rsa加密的簡單實現全部內容了,希望大家多多支持本站~
綜述 在Retrofit2.0使用詳解這篇文章中詳細介紹了retrofit的用法。並且在retrofit中我們可以通過ResponseBody進行對文件的下載。但是在r
簡介 在Android中運用了很多機制,例如:廣播、服務、數據庫、通知、包……等等。什麼是廣播?Broadcast是一種廣泛運用的在應用程序之間傳輸
最近在開發中遇到了這樣一個問題,在下拉刷新組件中包含了一個輪播圖組件,當左右滑動的圖片時很容易觸發下拉刷新,如下圖所示:如圖中紅色箭頭所示方向切換輪播圖,很容易觸發下拉刷
IN THIS DOCUMENTCreating an Activity 創建一個ActivityImplementing a user interface 實現用戶界面