HarmonyOS RSA加密分段加密处理，支持NoPadding处理

后台的接口认证是很早以前的RSA加密，采用的是Nopadding模式(偶尔听后台说每次加密结果一样才想到这个方向，😭)，最开始采用的网上别人讲jsencrypt库封装暴露出TypeScript库JSEncrypt，可参考https://gitee.com/luvi/jsencrypt3.3.2，如果需要分段加密可以调整js库代码，网上很多案例可以参考。

找了很久，没找到可行的jsencrypt既支持分段长加密还支持Nopadding的(官方认为不安全，chatgpt都强烈建议不要使用),最后只能再回头看看鸿蒙原生的API了，好在发现了这个模式，然后就自己编写了。希望给后面从0开始踩坑鸿蒙的童鞋们一点参考。

官方文档参考https://developer.harmonyos.com/cn/docs/documentation/doc-references-V3/js-apis-cryptoframework-0000001477981409-V3

本次加密处理使用的是RSA1024|NoPadding 模式，因此分段处理的blockSize是128

const blockSize = 128;

如果是PKCS1，需要改成

let cipher = cryptoFramework.createCipher("RSA1024|PKCS1”);

const blockSize = 117;

参考代码如下，由于需要多段加密所以采用Promise.all统一回调

export class EncryptUtil {
  stringToUint8Array(str) {
    var arr = [];
    for (var i = 0, j = str.length; i < j; ++i) {
      arr.push(str.charCodeAt(i));
    }

    var tmpArray = new Uint8Array(arr);
    return tmpArray;
  }

   async encryptMessageCallback(pubKey, planText): Promise<any> {

    let rsaGenerator: cryptoFramework.AsyKeyGenerator;
    rsaGenerator = cryptoFramework.createAsyKeyGenerator("RSA1024|PRIMES_2");
    let cipher = cryptoFramework.createCipher("RSA1024|NoPadding");
    let base64 = new util.Base64Helper();
    let key = base64.decodeSync(pubKey);
    let blob: cryptoFramework.DataBlob = { data: key };
    let encryptedSegments: Uint8Array[] = [];
    let resultStr;
    let encryptedPromises: Promise<cryptoFramework.DataBlob | undefined>[] = [];
    const blockSize = 128;
    let dataByte = Utils.stringToUint8Array(JSON.stringify(planText));
    let keyPairPubKey;
    await rsaGenerator.convertKey(blob, null)
      .then(keyPair => {
        keyPairPubKey = keyPair.pubKey;
        return;
      });

    await cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, keyPairPubKey, null).then(() => {
      return;
    });

    for (let i = 0; i < dataByte.length; i += blockSize) {
      var chunk;
      if (i + blockSize < dataByte.length) {
        chunk = dataByte.subarray(i, i + blockSize);
      } else {
        chunk = dataByte.subarray(i, dataByte.length);
        const paddingLength = blockSize - chunk.length;
        let zeros: Uint8Array = new Uint8Array(paddingLength).fill(0);

        // 创建一个新的足够大的Uint8Array来存放合并后的内容
        let paddedChunk: Uint8Array = new Uint8Array(blockSize);
        // 将原始chunk复制到新数组中
        paddedChunk.set(chunk);
        // 将填充的零数组复制到新数组的相应位置
        paddedChunk.set(zeros, chunk.length);
        chunk = paddedChunk;
      }

      // Logger.info('分段后的内容', JSON.stringify(chunk));
      let input = { data: chunk };

      // 将doFinal的回调封装成Promise，并始终返回DataBlob或undefined

      const encryptionPromise = new Promise<cryptoFramework.DataBlob | undefined>((resolve, reject) => {
        cipher.doFinal(input, (err, datas) => {
          if (err) {
            Logger.error('加密失败', JSON.stringify(err));
            reject(err);
          } else {
            encryptedSegments.push(datas.data);
            // 检查是否已加密完所有数据
            if ((i + blockSize) >= dataByte.length) {
              resolve({data:datas.data});
            } else {
              resolve(undefined); // 非最后一个分段完成时也返回一个undefined（实际上这里不需要返回任何值）
            }
          }
        });
      });

      // 添加到待处理的Promise数组中
      encryptedPromises.push(encryptionPromise);
      await Promise.all(encryptedPromises).then(() => {
        if ((i + blockSize) >= dataByte.length) {
          // 合并所有加密后的数据片段
          const concatenatedData = encryptedSegments.reduce((total, segment) => {
            const tmp = new Uint8Array(total.length + segment.length);
            tmp.set(total, 0);
            tmp.set(segment, total.length);
            return tmp;
          }, new Uint8Array());

          let finalEncryptedData = new Uint8Array(concatenatedData);

          Logger.info('加密完成后数据', base64.encodeToStringSync(finalEncryptedData));
          resultStr = base64.encodeToStringSync(finalEncryptedData);
          return ;
        }
      }).catch((error) => {

        Logger.error('加密过程中发生错误', JSON.stringify(error));
        return '加密失败';
      });
    }
    return resultStr;
  }
  }