首页 > 系统 > Android > 正文

Android数据加密之Rsa加密的简单实现

2019-12-12 05:06:08
字体:
来源:转载
供稿:网友

最近无意中和同事交流数据安全传输的问题,想起自己曾经使用过的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加密的简单实现全部内容了,希望大家多多支持武林网~

发表评论 共有条评论
用户名: 密码:
验证码: 匿名发表