Android Rsa數據加解密的介紹與使用示例

2019-12-12 05:12:39

字體：大中小

來源：轉載

供稿：網友

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使用

首先生成秘鑰對

  /**   * 隨機生成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);

運行結果：