Android教程網
設為首頁|加入收藏
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> 關於Android編程 >> Android數據加密之Rsa加密

Android數據加密之Rsa加密

編輯：關於Android編程

前言：

最近無意中和同事交流數據安全傳輸的問題，想起自己曾經使用過的Rsa非對稱加密算法，閒下來總結一下。 

其他幾種加密方式：

 •Android數據加密之Rsa加密
 •Android數據加密之Aes加密
 •Android數據加密之Des加密
 •Android數據加密之MD5加密
 •Android數據加密之Base64編碼算法
 •Android數據加密之SHA安全散列算法 

什麼是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倍

 以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持本站。

  1. 上一頁:
  2. 下一頁:
關於Android編程
Android編程入門Android技術基礎Android資訊關於Android編程Android開發Android開發環境Android開發實例
相關文章
熱門文章
安卓代碼混淆注意事項 BlueTooth: 藍牙協議棧的原理和結構 Android基礎終極篇--Service Android基礎第十篇-內容提供者 android圖像繪制(二)畫布上放大縮小問題 android上傳圖片（及普通參數）到服務器（j2ee後台服務器，ssh框架）
Android版網易雲音樂唱片機唱片磁盤旋轉及唱片機機械臂動畫關鍵代碼實現思路

先看一看我的代碼運行結果。代碼運行起來初始化狀態：  
Android 高仿 QQ5.0 側滑菜單效果 自定義控件來襲

  上一篇博客帶大家實現了：Android 自定義控件打造史上
Android中利用matrix 控制圖片的旋轉、縮放、移動

本文主要講解利用android中Matrix控制圖形的旋轉縮放移動，具體
仿iPhone風格對話框(附件包含例子/jar包/jar包源碼)

效果圖：這個對框完全繼承、仿照AlertDialog，只是實現了自定義效
閱讀排行版
Copyright © Android教程網 All Rights Reserved