Summary

Recently, rsa encryption is required to transmit data in the background in the project, but some data is too long, the key is 2048 bits, so only 256 characters can be encrypted, so I want to use segmented encryption to encrypt.

problem analysis

Because the encrypted data contains Chinese and English, it is too troublesome to use charAt to extract each character to determine the bytes occupied by the character, so I use base64 to encode the data so that the original data will not contain Chinese. Can carry out simple length division, thus go to encrypt directly.

Use JSEncrypt.js library for encryption, filling algorithm library is pkcs1pad2 filling algorithm

Below is my own method of segment encryption

JSEncrypt.prototype.encryptLong = function (string) {
        var k = this.getKey();
        var strings = base64.encode(string);
        var encrypArray = new Array();
        try {
          var ct = "";
          if (strings.length > 245) {
            for (var i = 0; i < strings.length; i = i + 245) {
              var str;
              if (strings.length >= (i + 245)) {
                str = strings.substring(i, i + 245);
              } else {
                str = strings.substring(i);
              }
              var t1 = k.encrypt(str);
              encrypArray.push(hex2b64(t1));
            }
            return encrypArray;
          }
          var t = k.encrypt(strings);
          encrypArray.push(hex2b64(t));
          return encrypArray;
        } catch (ex) {
          return false;
        }
      };

My own segmented decryption method

JSEncrypt.prototype.decryptLong = function (encrypArray) {
        var key = this.getKey();
        try {
          var t3 = "";
          for(var j=0; j < encrypArray.length; j++){
            var t4 = key.decrypt(b64tohex(encrypArray[j]));
            t3 += t4;
          }
          var strings = String(base64.decode(t3));
          return t3;
        } catch (ex) {
          return false;
        }
      };

Since the maximum encryption length when JSEncrypt is used for encryption is 245, because the minimum 11 bytes need to be set aside for pkcs1pad2 padding, so I use the length of 245 to intercept and encrypt the data. After the encryption of each segment is completed, I call hex2b64 () Convert hexadecimal to base64, and then put it in the array, so that we can get an array with complete encrypted data.

Simple research on pkcs1pad2 filling

function pkcs1pad2(s,n) {
  if(n < s.length + 11) { // TODO: fix for utf-8
    console.error("Message too long for RSA");
    return null;
  }
  var ba = new Array();
  var i = s.length - 1;
  while(i >= 0 && n > 0) {
    var c = s.charCodeAt(i--);
    if(c < 128) { // encode using utf-8
      ba[--n] = c;
    }
    else if((c > 127) && (c < 2048)) {
      ba[--n] = (c & 63) | 128;
      ba[--n] = (c >> 6) | 192;
    }
    else {
      ba[--n] = (c & 63) | 128;
      ba[--n] = ((c >> 6) & 63) | 128;
      ba[--n] = (c >> 12) | 224;
    }
  }
  ba[--n] = 0;
  var rng = new SecureRandom();
  var x = new Array();
  while(n > 2) { // random non-zero pad
    x[0] = 0;
    while(x[0] == 0) rng.nextBytes(x);
    ba[--n] = x[0];
  }
  ba[--n] = 2;
  ba[--n] = 0;
  return new BigInteger(ba);
}

After the data is encrypted, there will be at least 11 bytes left for non-zero padding, and the first and second bits filled must be 0, 2, and the eleventh bit must be 0. Presumably this is the distinction when decrypting. Which are the real data or the basis for filling the data.