鸿蒙开发RSA加解密实现方案

import cryptoFramework from '@ohos.security.cryptoFramework';
import util from '@ohos.util';
import Logger from './Logger'


//公钥 这里只展示部分
export const pubKeyX509Str = "MIGfMA0GCSqG...+wIDAQAB";
//私钥 这里只展示部分
export const priKeyPKCS8Str = "MIICdwIBADANBg...yhE/3J2I=";

export class RSA {
  
  //将字符串转换为Uint8Array
  string2Uint8Array(str: string, len:number = null) {
    let textEncoder = util.TextEncoder.create('utf-8')
  	return textEncoder.encodeInto(str)
  }
  
  //字节流转成可理解的字符串
  uint8ArrayToString(array) {
    let textDecoder = util.TextDecoder.create('utf-8')
    return textDecoder.decodeWithStream(array)
  }
  
  /**
   * RSA分段加密
   * @param value 待加密字符串
   * @returns 
   */
  rsaEncryption(value: string) {
    let base64 = new util.Base64Helper();
    let data = base64.decodeSync(pubKeyX509Str)
    //RSA每次加解密允许的原文长度大小与密钥位数和填充模式等有关，详细规格内容见overview文档
    let plainTextSplitLen = 117;
    let globalEncryptionOutput; //加密输出
    let arrTest = this.string2Uint8Array(value);
    //创建非对称密钥生成器对象
    let asyKeyGenerator = cryptoFramework.createAsyKeyGenerator("RSA1024|PRIMES_2");
    // 创建加密Cipher对象
    let cipherEncryption = cryptoFramework.createCipher("RSA1024|PKCS1");
    let pubKeyBlob = { data: data }
    return asyKeyGenerator.convertKey(pubKeyBlob, null)
      .then(keyPair => {
        return cipherEncryption.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, keyPair.pubKey, null);
      })
      .then(async () => {
        globalEncryptionOutput = [];

        // 将原文按64字符进行拆分，循环调用doFinal进行加密，使用1024bit密钥时，每次加密生成128B长度的密文
        for (let i = 0; i < (arrTest.length / plainTextSplitLen); i++) {
          let tempArr = arrTest.slice(i * plainTextSplitLen, (i + 1) * plainTextSplitLen);
          let tempBlob = { data: tempArr };
          let tempCipherOutput = await cipherEncryption.doFinal(tempBlob);
          globalEncryptionOutput = globalEncryptionOutput.concat(Array.from(tempCipherOutput.data));
        }
        let enStr = base64.encodeToStringSync(new Uint8Array(globalEncryptionOutput))
        Logger.info("加密总长度：" + globalEncryptionOutput.length + "\n生成加密串：\n" + enStr)
        return enStr
      })
      .catch(error => {
        Logger.info(`加密异常, ${error.code}, ${error.message}`);
      })
  }
  
  
  /**
   * RSA分段解密
   * @param value 待解密字符串
   * @returns 
   */
  rsaDecryption(value: string) {
    let base64 = new util.Base64Helper();
    let data = base64.decodeSync(priKeyPKCS8Str)
    // RSA密钥每次加密生成的密文数据长度计算方式：密钥位数/8
    let cipherTextSplitLen = 128;
    //创建非对称密钥生成器对象
    let asyKeyGenerator = cryptoFramework.createAsyKeyGenerator("RSA1024|PRIMES_2");
    // 创建解密Decoder对象
    let cipherDecryption = cryptoFramework.createCipher("RSA1024|PKCS1");
    let priKeyBlob = { data: data }
    return asyKeyGenerator.convertKey(null, priKeyBlob)
      .then(keyPair => {
        return cipherDecryption.init(cryptoFramework.CryptoMode.DECRYPT_MODE, keyPair.priKey, null);
      }).then(async () => {
        let globalCipherOutput = base64.decodeSync(value)
        let len = globalCipherOutput.length
        //解密输出
        let globalDecryptionOutput = new Uint8Array(len);
        let globalOffset = 0
        // 将密文按128B进行拆分解密，得到原文后进行拼接
        for (let i = 0; i < (len / cipherTextSplitLen); i++) {
          let tempBlobData = globalCipherOutput.subarray(i * cipherTextSplitLen, (i + 1) * cipherTextSplitLen);
          let message = new Uint8Array(tempBlobData);
          let tempBlob = { data: message };
          let tempDecodeOutput = await cipherDecryption.doFinal(tempBlob);
          //存入数组 解决边累加边转中文时 字节错乱出现乱码
          globalDecryptionOutput.set(tempDecodeOutput.data, globalOffset)
          //偏移量
          globalOffset += tempDecodeOutput.data.byteLength
        }
        let result = this.uint8ArrayToString(globalDecryptionOutput)
        Logger.info("解密串:cipherAlgName[RSA1024|PKCS1]\n" + result);
        return result
      })
      .catch(error => {
        Logger.info(`解密异常,cipherAlgName[RSA1024|PKCS1] ${error.code}, ${error.message}`);
      })
  }
  
}

import http from '@ohos.net.http'
import {RSA} from '../tools/RSA'

@Entry
@Component
struct Second {
  @State message: string = "Hi there"
  @State requestStr: string = ''
  @State responseStr: string = ''
  private rsa: RSA = new RSA()
  
  text = {"brandName":"UPOS","lnglat":"116.192321,39.911187","merDetailedAddress":"中国北京市石景山区古城街道古城南街辅路","channel":"guanwang","sign":"5acea2dc35e7a856db260c6ca6f5c993","sysMark":"1","merAreas":"北京市,北京市,石景山区","rpid":"13476A6FC3370A20","version":"63","token":"13670AF3KlZzvhe9Dzju7uDqnc9JrqBv9Ttfy"}
 
  //此处省略build方法
  
  //网络请求
  async requestUpdate() {
    let encrypt = await this.rsa.rsaEncryption(JSON.stringify(this.text))
    this.requestStr = `------请求json------\n{"data": "${encrypt}"}\n------返回json-----\n`
    //每一个httpRequest对应一个Http请求任务，不可复用
    let httpRequest = http.createHttp();
    httpRequest.request(
      "https://www.xxx.com/xxx/xxxx/xxxx.do", {
      method: http.RequestMethod.POST,
      header: {
        'content-type': 'application/json; charset=utf-8',
      },
      extraData: {
        'data': encrypt
      }
    }, async (err, data) => {
      if (!err) {
        //请求成功
        if (data.responseCode === 200) {
          //后台返回json{"ret_code":null,"ret_msg":null,"data":"FGAIlls512...5jplOrXosEIw=="}
          let resultStr = JSON.parse(`${data.result}`)
          this.responseStr = await this.rsa.rsaDecryption(resultStr.data) || "解密失败"
        }
      } else {
        //请求失败
        console.info(`error: ${JSON.stringify(err)}`)
      }
      //请求完毕时，调用destroy方法主动销毁
      httpRequest.destroy()
    })
  }
}