使用32字节秘钥加解密后报错

import cryptoFramework from '@ohos.security.cryptoFramework'; 
import { hilog } from '@kit.PerformanceAnalysisKit'; 
import { util } from '@kit.ArkTS'; 
 
const TAG: string = 'testTag' 
 
@Entry 
@Component 
struct CryptoPage { 
  @State message: string = 'CryptoPage'; 
 
  build() { 
    Row() { 
      Column() { 
        Text(this.message) 
          .fontSize(20) 
          .fontWeight(FontWeight.Bold) 
          .margin({ 
            bottom: '3%' 
          }) 
        Button('加密#解密').onClick(async () => { 
          hilog.info(0x00000, TAG, '加密#解密'); 
          let msg: string = "2.解密内容较短时，可以不调用update，直接调用Cipher.doFinal，获取解密后的数据。" 
          let u8arr = string2uint8Array(msg) 
          let targetData: cryptoFramework.DataBlob = { data: u8arr } 
          let symKey = await genSymKey('AES256') 
          hilog.info(0x00000, TAG, '生成的随机秘钥-name#' + symKey.algName); 
          hilog.info(0x00000, TAG, '生成的随机秘钥-format#' + symKey.format); 
          hilog.info(0x00000, TAG, '生成的随机秘钥-内容#' + uint8Array2string(symKey.getEncoded().data)); 
          let result = await encryptMessagePromise('AES256|CBC|PKCS7', symKey, targetData) 
          hilog.info(0x00000, TAG, '加密前的数据#' + u8arr.toLocaleString()); 
          hilog.info(0x00000, TAG, '加密后的数据#' + result.data.toLocaleString()); 
          let deResult = await decryptMessagePromise('AES256|CBC|PKCS7', symKey, result) 
          hilog.info(0x00000, TAG, '解密出来的数据-u8Arr#' + deResult.data.toLocaleString()); 
          hilog.info(0x00000, TAG, '解密出来的数据-内容##' + uint8Array2string(deResult.data)); 
        }).margin({ 
          bottom: '3%' 
        }) 
      } 
      .width('100%') 
    } 
    .height('100%') 
  } 
} 
/** 
 * 异步获取对称密钥生成器随机生成的密钥，通过注册回调函数获取结果。 
 * @returns 随机对称秘钥 
 */ 
async function genSymKey(algName: string): Promise<cryptoFramework.SymKey> { 
  let symKeyGenerator = cryptoFramework.createSymKeyGenerator(algName); 
  //异步获取对称密钥生成器随机生成的密钥，通过注册回调函数获取结果。 
  //目前支持使用OpenSSL的RAND_priv_bytes()作为底层能力生成随机密钥。 
  let symKey = await symKeyGenerator.generateSymKey(); 
  let encodedKey = symKey.getEncoded(); 
  hilog.info(0x00000, TAG, 'key hex:' + encodedKey.data); 
  return symKey; 
} 
/** 
 * 异步根据指定数据生成对称密钥，通过Promise获取结果。 
 * @param symKeyData 
 * @returns 特定对称秘钥 
 */ 
async function genSymKeyByData(algName: string, symKeyData: Uint8Array): Promise<cryptoFramework.SymKey> { 
  //buffer数组，提供blob数据类型。 
  let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData }; 
  //通过指定算法名称的字符串，获取相应的对称密钥生成器实例。 
  let aesGenerator = cryptoFramework.createSymKeyGenerator(algName); 
  //异步根据指定数据生成对称密钥，通过Promise获取结果。 
  // 必须在使用createSymKeyGenerator创建对称密钥生成器后，才能使用本函数。 
  let symKey = await aesGenerator.convertKey(symKeyBlob); 
  hilog.info(0x00000, TAG, 'convertKey success'); 
  //对称密钥，是Key的子类，在对称加解密时需要将其对象传入Cipher实例的init()方法使用。 
  // 对称密钥可以通过对称密钥生成器SymKeyGenerator来生成。 
  return symKey; 
} 
/** 
 * 加解密参数，适用对称加解密模式（CBC、CTR、OFB、CFB） 
 * @returns 
 */ 
function genIvParamsSpec() { 
  let arr = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; // 16 bytes 
  let dataIv = new Uint8Array(arr); 
  let ivBlob: cryptoFramework.DataBlob = { data: dataIv }; 
  let ivParamsSpec: cryptoFramework.IvParamsSpec = { 
    algName: "IvParamsSpec", 
    //指明加解密参数iv。常见取值如下： 
    // - AES的CBC|CTR|OFB|CFB模式：iv长度为16字节 
    // - 3DES的CBC|OFB|CFB模式：iv长度为8字节 
    // - SM410+的CBC|CTR|OFB|CFB模式：iv长度为16字节。 
    iv: ivBlob 
  }; 
  return ivParamsSpec; 
} 
// 加密消息 
async function encryptMessagePromise(transformation: string, symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob): Promise<cryptoFramework.DataBlob> { 
  let cipher = cryptoFramework.createCipher(transformation); 
  let iv = genIvParamsSpec(); 
  await cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, iv); 
  let cipherData = await cipher.doFinal(plainText); 
  return cipherData; 
} 
// 解密消息 
async function decryptMessagePromise(transformation: string, symKey: cryptoFramework.SymKey, cipherData: cryptoFramework.DataBlob): Promise<cryptoFramework.DataBlob> { 
  let decoder = cryptoFramework.createCipher(transformation); 
  let iv = genIvParamsSpec(); 
  await decoder.init(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, iv); 
  let decryptData = await decoder.doFinal(cipherData); 
  return decryptData; 
} 
/** 
 * 字符转uint8Array 
 * @param str 
 * @returns 
 */ 
function string2uint8Array(str: string): Uint8Array { 
  hilog.info(0x00000, TAG, 'string2uint8Array传入的参数为#' + str); 
  let result: Uint8Array = new util.TextEncoder('utf-8').encodeInto(str) 
  return result; 
} 
/** 
 * uint8Array转字符 
 * @param str 
 * @returns 
 */ 
function uint8Array2string(str: Uint8Array): string { 
  hilog.info(0x00000, TAG, '传入的Uint8Array内容为#' + str.toLocaleString()); 
  let result: string = util.TextDecoder.create().decodeWithStream(str) 
  return result; 
}