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

首先生成秘钥对

 /**
  * 随机生成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倍

总结