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倍

总结

以上就是关于Android Rsa数据加解密的全部内容，希望这篇文章的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流。