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

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