!14532 【回合1018monthly分支】crypto_framework仓相关资料更新

Merge pull request !14532 from xuejikan/cherry-pick-1676011806

zh-cn/application-dev/reference/apis/js-apis-cryptoFramework.md

@@ -41,7 +41,7 @@ buffer数组。
 
 createMac(algName : string) : Mac
 
-生成Mac实例，用于进行消息认证码的计算与操作
+生成Mac实例，用于进行消息认证码的计算与操作。<br/>支持的规格详见框架概述“[HMAC消息认证码算法规格](../../security/cryptoFramework-overview.md#hmac消息认证码算法规格)”一节。
 
 **系统能力：** SystemCapability.Security.CryptoFramework
 
@@ -49,7 +49,7 @@ createMac(algName : string) : Mac
 
 | 参数名  | 类型   | 必填 | 说明                                                         |
 | ------- | ------ | ---- | ------------------------------------------------------------ |
-| algName | string | 是   | 指定摘要算法，支持算法范围：SHA1/SHA224/SHA256/SHA384/SHA512 |
+| algName | string | 是   | 指定摘要算法，支持算法请参考“[HMAC算法支持范围](../../security/cryptoFramework-overview.md#hmac消息认证码算法规格)”一节 |
 
 **返回值**：
 
@@ -192,6 +192,9 @@ update(input : DataBlob, callback : AsyncCallback\<void>) : void;
 
 传入消息进行Mac更新计算
 
+> **说明：** 
+> Hmac算法多次调用update更新的代码示例详见开发指导“[使用消息认证码操作](../../security/cryptoFramework-guidelines.md#使用消息认证码操作)”。
+
 **系统能力：** SystemCapability.Security.CryptoFramework
 
 **参数：**
@@ -244,6 +247,9 @@ update(input : DataBlob) : Promise\<void>;
 
 传入消息进行Mac更新计算
 
+> **说明：** 
+> Hmac算法多次调用update更新的代码示例详见开发指导“[使用消息认证码操作](../../security/cryptoFramework-guidelines.md#使用消息认证码操作)”。
+
 **系统能力：** SystemCapability.Security.CryptoFramework
 
 **参数：**
@@ -465,7 +471,7 @@ promiseConvertKey.then(symKey => {
 
 createMd(algName : string) : Md
 
-生成Md实例，用于进行消息摘要的计算与操作
+生成Md实例，用于进行消息摘要的计算与操作。<br/>支持的规格详见框架概述“[MD消息摘要算法规格](../../security/cryptoFramework-overview.md#md消息摘要算法规格)”一节。
 
 **系统能力：** SystemCapability.Security.CryptoFramework
 
@@ -473,7 +479,7 @@ createMd(algName : string) : Md
 
 | 参数名  | 类型   | 必填 | 说明                                                         |
 | ------- | ------ | ---- | ------------------------------------------------------------ |
-| algName | string | 是   | 指定摘要算法，支持算法范围：SHA1/SHA224/SHA256/SHA384/SHA512/MD5 |
+| algName | string | 是   | 指定摘要算法，支持算法请参考“[MD算法支持范围](../../security/cryptoFramework-overview.md#md消息摘要算法规格)”一节 |
 
 **返回值**：
 
@@ -519,6 +525,9 @@ update(input : DataBlob, callback : AsyncCallback\<void>) : void;
 
 传入消息进行Md更新计算
 
+> **说明：** 
+> Md算法多次调用update更新的代码示例详见开发指导“[使用摘要操作](../../security/cryptoFramework-guidelines.md#使用摘要操作)”。
+
 **系统能力：** SystemCapability.Security.CryptoFramework
 
 **参数：**
@@ -561,6 +570,9 @@ update(input : DataBlob) : Promise\<void>;
 
 传入消息进行Md更新计算
 
+> **说明：** 
+> Md算法多次调用update更新的代码示例详见开发指导“[使用摘要操作](../../security/cryptoFramework-guidelines.md#使用摘要操作)”。
+
 **系统能力：** SystemCapability.Security.CryptoFramework
 
 | 参数名 | 类型     | 必填 | 说明       |
@@ -745,7 +757,7 @@ promiseMdUpdate.then(() => {
 
 createRandom() : Random
 
-生成Random实例，用于进行随机数的计算与设置种子
+生成Random实例，用于进行随机数的计算与设置种子。
 
 **系统能力：** SystemCapability.Security.CryptoFramework
 
@@ -917,7 +929,7 @@ rand.generateRandom(12, (err, randData) => {
 **系统能力：** SystemCapability.Security.CryptoFramework
 
 | 名称    | 类型   | 可读 | 可写 | 说明                                                         |
-| -------- | ------ | ---- | ---- | ----------------------- |
+| ------- | ------ | ---- | ---- | ------------------------------------------------------------ |
 | algName | string | 是   | 是   | 指明对称加解密参数的算法模式。可选值如下:<br/>- "IvParamsSpec": 适用于CBC\|CTR\|OFB\|CFB模式<br/>- "GcmParamsSpec": 适用于GCM模式<br/>- "CcmParamsSpec": 适用于CCM模式 |
 
 > **说明：** 
@@ -1153,7 +1165,11 @@ key.clearMem();
 
 ## KeyPair
 
-非对称密钥对，包含：公钥与私钥，。<br/>可以通过非对称密钥生成器AsyKeyGenerator来生成。
+非对称密钥对，包含：公钥与私钥。<br/>可以通过非对称密钥生成器AsyKeyGenerator来生成。
+
+> **说明：** 
+> 
+> KeyPair对象中的pubKey对象和priKey对象，作为KeyPair对象中的一个参数存在，当离开KeyPair对象作用域时，其内部对象可能被析构。<br/>业务方使用时应持有KeyPair对象的引用，而非内部pubKey或priKey对象的引用。
 
 ### 属性
 
@@ -1375,7 +1391,7 @@ symKeyGenerator.convertKey(keyMaterialBlob)
 
 createAsyKeyGenerator(algName : string) : AsyKeyGenerator
 
-通过指定算法名称的字符串，获取相应的非对称密钥生成器实例。
+通过指定算法名称的字符串，获取相应的非对称密钥生成器实例。<br/>支持的规格详见框架概述“[密钥生成规格](../../security/cryptoFramework-overview.md#密钥生成规格)”一节。
 
 **系统能力：** SystemCapability.Security.CryptoFramework
 
@@ -1720,7 +1736,7 @@ update(data : DataBlob, callback : AsyncCallback\<DataBlob>) : void
 
 > **说明：** 
 > 1. 在进行对称加解密操作的时候，如果开发者对各个分组模式不够熟悉，建议对每次update和doFinal的结果都判断是否为null，并在结果不为null时取出其中的数据进行拼接，形成完整的密文/明文。这是因为选择的分组模式等各项规格都可能对update和[doFinal](#dofinal-2)结果产生影响。<br/>（例如对于ECB和CBC模式，不论update传入的数据是否为分组长度的整数倍，都会以分组作为基本单位进行加/解密，并输出本次update新产生的加/解密分组结果。<br/>可以理解为，update只要凑满一个新的分组就会有输出，如果没有凑满则此次update输出为null，把当前还没被加/解密的数据留着，等下一次update/doFinal传入数据的时候，拼接起来继续凑分组。<br/>最后doFinal的时候，会把剩下的还没加/解密的数据，根据[createCipher](#cryptoframeworkcreatecipher)时设置的padding模式进行填充，补齐到分组的整数倍长度，再输出剩余加解密结果。<br/>而对于可以将分组密码转化为流模式实现的模式，还可能出现密文长度和明文长度相同的情况等。）
-> 2. 根据数据量，可以不调用update（即[init](#init-2)完成后直接调用[doFinal](#dofinal-2)）或多次调用update。<br/>算法库目前没有对update（单次或累计）的数据量设置大小限制，建议对于大数据量的对称加解密，采用多次update的方式传入数据。
+> 2. 根据数据量，可以不调用update（即[init](#init-2)完成后直接调用[doFinal](#dofinal-2)）或多次调用update。<br/>算法库目前没有对update（单次或累计）的数据量设置大小限制，建议对于大数据量的对称加解密，采用多次update的方式传入数据。<br/>AES使用多次update操作的示例代码详见开发指导“[使用加解密操作](../../security/cryptoFramework-guidelines.md#使用加解密操作)”。
 > 3. RSA非对称加解密不支持update操作。
 
 **系统能力：** SystemCapability.Security.CryptoFramework
@@ -1777,7 +1793,7 @@ update(data : DataBlob) : Promise\<DataBlob>
 
 > **说明：** 
 > 1. 在进行对称加解密操作的时候，如果开发者对各个分组模式不够熟悉，建议对每次update和doFinal的结果都判断是否为null，并在结果不为null时取出其中的数据进行拼接，形成完整的密文/明文。这是因为选择的分组模式等各项规格都可能对update和[doFinal](#dofinal-2)结果产生影响。<br/>（例如对于ECB和CBC模式，不论update传入的数据是否为分组长度的整数倍，都会以分组作为基本单位进行加/解密，并输出本次update新产生的加/解密分组结果。<br/>可以理解为，update只要凑满一个新的分组就会有输出，如果没有凑满则此次update输出为null，把当前还没被加/解密的数据留着，等下一次update/doFinal传入数据的时候，拼接起来继续凑分组。<br/>最后doFinal的时候，会把剩下的还没加/解密的数据，根据[createCipher](#cryptoframeworkcreatecipher)时设置的padding模式进行填充，补齐到分组的整数倍长度，再输出剩余加解密结果。<br/>而对于可以将分组密码转化为流模式实现的模式，还可能出现密文长度和明文长度相同的情况等。）
-> 2. 根据数据量，可以不调用update（即[init](#init-2)完成后直接调用[doFinal](#dofinal-2)）或多次调用update。<br/>算法库目前没有对update（单次或累计）的数据量设置大小限制，建议对于大数据量的对称加解密，可以采用多次update的方式传入数据。
+> 2. 根据数据量，可以不调用update（即[init](#init-2)完成后直接调用[doFinal](#dofinal-2)）或多次调用update。<br/>算法库目前没有对update（单次或累计）的数据量设置大小限制，建议对于大数据量的对称加解密，可以采用多次update的方式传入数据。<br/>AES使用多次update操作的示例代码详见开发指导“[使用加解密操作](../../security/cryptoFramework-guidelines.md#使用加解密操作)”。
 > 3. RSA非对称加解密不支持update操作。
 
 **系统能力：** SystemCapability.Security.CryptoFramework
@@ -1844,6 +1860,8 @@ doFinal(data : DataBlob, callback : AsyncCallback\<DataBlob>) : void
 >  **说明：** 
 >  1. 对称加解密中，调用doFinal标志着一次加解密流程已经完成，即[Cipher](#cipher)实例的状态被清除，因此当后续开启新一轮加解密流程时，需要重新调用[init()](init-2)并传入完整的参数列表进行初始化<br/>（比如即使是对同一个Cipher实例，采用同样的对称密钥，进行加密然后解密，则解密中调用init的时候仍需填写params参数，而不能直接省略为null）。
 >  2. 如果遇到解密失败，需检查加解密数据和[init](#init-2)时的参数是否匹配，包括GCM模式下加密得到的authTag是否填入解密时的GcmParamsSpec等。
+>  3. doFinal的结果可能为null，因此使用.data字段访问doFinal结果的具体数据前，请记得先判断结果是否为null，避免产生异常。
+>  4. RSA非对称加解密时多次doFinal操作的示例代码详见开发指导“[使用加解密操作](../../security/cryptoFramework-guidelines.md#使用加解密操作)”。
 
 **系统能力：** SystemCapability.Security.CryptoFramework
 
@@ -1896,6 +1914,8 @@ doFinal(data : DataBlob) : Promise\<DataBlob>
 >  **说明：** 
 >  1. 对称加解密中，调用doFinal标志着一次加解密流程已经完成，即[Cipher](#cipher)实例的状态被清除，因此当后续开启新一轮加解密流程时，需要重新调用[init()](init-2)并传入完整的参数列表进行初始化<br/>（比如即使是对同一个Cipher实例，采用同样的对称密钥，进行加密然后解密，则解密中调用init的时候仍需填写params参数，而不能直接省略为null）。
 >  2. 如果遇到解密失败，需检查加解密数据和[init](#init-2)时的参数是否匹配，包括GCM模式下加密得到的authTag是否填入解密时的GcmParamsSpec等。
+>  3. doFinal的结果可能为null，因此使用.data字段访问doFinal结果的具体数据前，请记得先判断结果是否为null，避免产生异常。
+>  4. RSA非对称加解密时多次doFinal操作的示例代码详见开发指导“[使用加解密操作](../../security/cryptoFramework-guidelines.md#使用加解密操作)”。
 
 **系统能力：** SystemCapability.Security.CryptoFramework
 
@@ -2000,7 +2020,7 @@ keyGenPromise.then(rsaKeyPair => {
 
 createSign(algName : string) : Sign
 
-Sign实例生成
+Sign实例生成。<br/>支持的规格详见框架概述“[签名验签规格](../../security/cryptoFramework-overview.md#签名验签规格)”一节。
 
 **系统能力：** SystemCapability.Security.CryptoFramework
 
@@ -2103,6 +2123,9 @@ update(data : DataBlob, callback : AsyncCallback\<void>) : void
 
 追加待签名数据，callback方式
 
+> **说明：** 
+> Sign多次调用update的代码示例详见开发指导“[使用签名验签操作](../../security/cryptoFramework-guidelines.md#使用签名验签操作)”。
+
 **系统能力：** SystemCapability.Security.CryptoFramework
 
 **参数：**
@@ -2126,6 +2149,9 @@ update(data : DataBlob) : Promise\<void>;
 
 追加待签名数据，promise方式
 
+> **说明：** 
+> Sign多次调用update的代码示例详见开发指导“[使用签名验签操作](../../security/cryptoFramework-guidelines.md#使用签名验签操作)”。
+
 **系统能力：** SystemCapability.Security.CryptoFramework
 
 **参数：**
@@ -2281,7 +2307,7 @@ function signMessagePromise() {
 
 createVerify(algName : string) : Verify
 
-Verify实例生成
+Verify实例生成。<br/>支持的规格详见框架概述“[签名验签规格](../../security/cryptoFramework-overview.md#签名验签规格)”一节。
 
 **系统能力：** SystemCapability.Security.CryptoFramework
 
@@ -2388,6 +2414,9 @@ update(data : DataBlob, callback : AsyncCallback\<void>) : void
 
 追加待验签数据，callback方式
 
+> **说明：** 
+> Verify多次调用update的代码示例详见开发指导“[使用签名验签操作](../../security/cryptoFramework-guidelines.md#使用签名验签操作)”。
+
 **系统能力：** SystemCapability.Security.CryptoFramework
 
 **参数：**
@@ -2411,6 +2440,9 @@ update(data : DataBlob) : Promise\<void>;
 
 追加待验签数据，promise方式
 
+> **说明：** 
+> Verify多次调用update的代码示例详见开发指导“[使用签名验签操作](../../security/cryptoFramework-guidelines.md#使用签名验签操作)”。
+
 **系统能力：** SystemCapability.Security.CryptoFramework
 
 **参数：**
@@ -2529,7 +2561,7 @@ verifyInitPromise.then(() => {
 
 createKeyAgreement(algName : string) : KeyAgreement
 
-KeyAgreement实例生成
+KeyAgreement实例生成。<br/>支持的规格详见框架概述“[密钥协商规格](../../security/cryptoFramework-overview.md#密钥协商规格)”一节。
 
 **系统能力：** SystemCapability.Security.CryptoFramework
 

zh-cn/application-dev/security/cryptoFramework-guidelines.md

@@ -130,8 +130,8 @@ function convertAsyKey() {
 
 ```javascript
 function convertEccAsyKey() {
-    let pubKeyArray = new Uint8Array([4,196,55,233,100,227,224,38,38,5,128,81,53,112,129,7,59,189,116,105,182,87,190,85,31,248,172,116,213,7,206,85,190,65,169,193,138,173,232,187,74,54,78,251,29,131,192,223,251,227,170,138,80,7,98,193,216,168,235,114,255,188,70,134,104]);
-    let priKeyArray = new Uint8Array([255,70,89,220,189,19,41,157,175,173,83,60,74,216,195,96,24,181,231,23,112,247,150,126,15,155,24,79,33,97,31,225]);
+    let pubKeyArray = new Uint8Array([48,89,48,19,6,7,42,134,72,206,61,2,1,6,8,42,134,72,206,61,3,1,7,3,66,0,4,83,96,142,9,86,214,126,106,247,233,92,125,4,128,138,105,246,162,215,71,81,58,202,121,26,105,211,55,130,45,236,143,55,16,248,75,167,160,167,106,2,152,243,44,68,66,0,167,99,92,235,215,159,239,28,106,124,171,34,145,124,174,57,92]);
+    let priKeyArray = new Uint8Array([48,49,2,1,1,4,32,115,56,137,35,207,0,60,191,90,61,136,105,210,16,27,4,171,57,10,61,123,40,189,28,34,207,236,22,45,223,10,189,160,10,6,8,42,134,72,206,61,3,1,7]);
     let pubKeyBlob = { data: pubKeyArray };
     let priKeyBlob = { data: priKeyArray };
     let generator = cryptoFrameWork.createAsyKeyGenerator("ECC256");
@@ -204,7 +204,7 @@ function testConvertAesKey() {
 
 **接口及参数说明**
 
-详细接口说明可参考[API参考](../reference/apis/js-apis-cryptoFramework.md)。
+详细接口说明可参考[API参考](../reference/apis/js-apis-cryptoFramework.md)。<br/>由于密码算法的复杂性，在选取不同规格和参数时，开发差异较大，无法通过代码示例一一列举，请仔细阅读API参考资料中的相关接口，确保使用正确。
 
 以上场景设计的常用接口如下表所示：
 
@@ -248,7 +248,8 @@ function genGcmParamsSpec() {
 
   arr = [0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0 , 0, 0, 0, 0]; // 16 bytes
   let dataTag = new Uint8Array(arr);
-  let tagBlob = {data : dataTag};
+  let tagBlob = {data : dataTag};  // GCM的authTag在加密时从doFinal结果中获取，在解密时填入init函数的params参数中
+  
   let gcmParamsSpec = {iv : ivBlob, aad : aadBlob, authTag : tagBlob, algName : "GcmParamsSpec"};
   return gcmParamsSpec;
 }
@@ -337,7 +338,7 @@ function testAesGcm() {
       let promiseFinal = globalCipher.doFinal(null);    // doFinal
       return promiseFinal;
   }).then(authTag => {
-      // 获取加密后的认证信息
+      // GCM模式需要从doFinal的输出中取出加密后的认证信息并填入globalGcmParams，在解密时传入init()
       globalGcmParams.authTag = authTag;
       return;
   }).then(() => {
@@ -353,7 +354,7 @@ function testAesGcm() {
       let promiseFinal = globalCipher.doFinal(null);    // doFinal
       return promiseFinal;
   }).then(finalOutput => {
-      if (finalOutput == null) {
+      if (finalOutput == null) {  // 使用finalOutput.data前，先判断结果是否为null
           console.info('GCM finalOutput is null');
       }
   }).catch(error => {
@@ -471,7 +472,7 @@ function test3DesEcb() {
                 console.info('decrypt plainText: ' + uint8ArrayToString(updateOutput.data));
                 // doFinal
                 globalCipher.doFinal(null, (error, finalOutput) => {
-                  if (finalOutput != null) {
+                  if (finalOutput != null) {  // 使用finalOutput.data前，先判断结果是否为null
                     console.info("decrypt plainText:" + uint8ArrayToString(finalOutput.data));
                   }
                 })
@@ -487,6 +488,147 @@ function test3DesEcb() {
   }
 }
 ```
+以AES GCM以promise方式，分段update()实现加解密为例：
+
+```javascript
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+var globalCipher;
+var globalGcmParams;
+var globalKey;
+var globalCipherText;
+var globalPlainText;
+
+function genGcmParamsSpec() {
+  let arr = [0, 0, 0, 0 , 0, 0, 0, 0, 0, 0 , 0, 0]; // 12 bytes
+  let dataIv = new Uint8Array(arr);
+  let ivBlob = {data : dataIv};
+
+  arr = [0, 0, 0, 0 , 0, 0, 0, 0]; // 8 bytes
+  let dataAad = new Uint8Array(arr);
+  let aadBlob = {data : dataAad};
+
+  arr = [0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0 , 0, 0, 0, 0]; // 16 bytes
+  let dataTag = new Uint8Array(arr);
+  let tagBlob = {data : dataTag};
+  let gcmParamsSpec = {iv : ivBlob, aad : aadBlob, authTag : tagBlob, algName : "GcmParamsSpec"};
+  return gcmParamsSpec;
+}
+
+// 字节流以16进制输出
+function uint8ArrayToShowStr(uint8Array) {
+  return Array.prototype.map
+    .call(uint8Array, (x) => ('00' + x.toString(16)).slice(-2))
+    .join('');
+}
+
+// 字节流转成可理解的字符串
+function uint8ArrayToString(array) {
+  let arrayString = '';
+  for (let i = 0; i < array.length; i++) {
+    arrayString += String.fromCharCode(array[i]);
+  }
+  return arrayString;
+}
+
+// 算法库不限定update的次数和每次加解密的数据量，业务可根据自身内存情况对明文/密文进行多次分段。
+function testAesMultiUpdate() {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      resolve('testAesMultiUpdate');
+    }, 10)
+  }).then(() => {
+    // 生成对称密钥生成器
+    let symAlgName = 'AES128';
+    let symKeyGenerator = cryptoFramework.createSymKeyGenerator(symAlgName);
+    if (symKeyGenerator == null) {
+      console.error('createSymKeyGenerator failed');
+      return;
+    }
+    console.info(`symKeyGenerator algName: ${symKeyGenerator.algName}`);
+    // 通过密钥生成器随机生成128位长度的对称密钥
+    let promiseSymKey = symKeyGenerator.generateSymKey();
+    // 构造参数
+    globalGcmParams = genGcmParamsSpec();
+
+    // 生成加解密生成器
+    let cipherAlgName = 'AES128|GCM|PKCS7';
+    try {
+      globalCipher = cryptoFramework.createCipher(cipherAlgName);
+      console.info(`cipher algName: ${globalCipher.algName}`);
+    } catch (error) {
+      console.error(`createCipher failed, ${error.code}, ${error.message}`);
+      return;
+    }
+    return promiseSymKey;
+  }).then(key => {
+    let encodedKey = key.getEncoded();
+    console.info('key hex:' + uint8ArrayToShowStr(encodedKey.data));
+    globalKey = key;
+    return key;
+  }).then(key => {
+    // 初始化加解密操作环境:开始加密
+    let mode = cryptoFramework.CryptoMode.ENCRYPT_MODE;
+    let promiseInit = globalCipher.init(mode, key, globalGcmParams);    // init
+    return promiseInit;
+  }).then(async () => {
+    let plainText = "aaaaa.....bbbbb.....ccccc.....ddddd.....eee";   // 假设明文总共43字节
+    let messageArr = [];
+    let updateLength = 20;  // 假设每20字节分段update一次
+    globalCipherText = [];
+    
+    for (let i = 0; i <= plainText.length; i++) {
+      if ((i % updateLength == 0 || i == plainText.length) && messageArr.length != 0) {
+        let message = new Uint8Array(messageArr);
+        let messageBlob = { data : message };
+        let updateOutput = await globalCipher.update(messageBlob);    // 分段update
+        // 把update的结果拼接起来，得到密文（有些情况下还需拼接doFinal的结果，这取决于分组模式
+        // 和填充模式，本例中GCM模式的doFinal结果只包含authTag而不含密文，所以不需要拼接）
+        globalCipherText = globalCipherText.concat(Array.from(updateOutput.data));
+        messageArr = [];
+      }
+      if (i < plainText.length) {
+        messageArr.push(plainText.charCodeAt(i));
+      }
+    }
+    return;
+  }).then(() => {
+    let promiseFinal = globalCipher.doFinal(null);    // doFinal
+    return promiseFinal;
+  }).then(authTag => {
+    // 获取加密后的认证信息
+    globalGcmParams.authTag = authTag;
+    return;
+  }).then(() => {
+    // 初始化加解密操作环境:开始解密
+    let mode = cryptoFramework.CryptoMode.DECRYPT_MODE;
+    let promiseInit = globalCipher.init(mode, globalKey, globalGcmParams);    // init
+    return promiseInit;
+  }).then(async () => {
+    let updateLength = 20;
+    let updateTimes = Math.ceil(globalCipherText.length / updateLength);  // 上取整
+    globalPlainText = "";
+    for (let i = 0; i < updateTimes; i++) {
+      let messageArr = globalCipherText.slice(i * updateLength, (i + 1) * updateLength);
+      let message = new Uint8Array(messageArr);
+      let messageBlob = { data : message };
+      let updateOutput = await globalCipher.update(messageBlob);    // 分段update
+      globalPlainText += uint8ArrayToString(updateOutput.data);     // 恢复出原始明文
+    }
+    return;
+  }).then(() => {
+    let promiseFinal = globalCipher.doFinal(null);      // doFinal
+    return promiseFinal;
+  }).then(finalOutput => {
+    if (finalOutput == null) {
+      console.info('GCM finalOutput is null');
+    }
+    console.info(`decrypt output: ${globalPlainText}`);
+  }).catch(error => {
+      console.error(`catch error, ${error.code}, ${error.message}`);
+  })
+}
+```
 
 示例2：使用非对称密钥的加解密操作
 
@@ -536,6 +678,147 @@ function encryptMessageCallback() {
     })
   })
 }
+
+function decryptMessageProMise() {
+  let rsaGenerator = cryptoFramework.createAsyKeyGenerator("RSA1024|PRIMES_2");
+  let cipher = cryptoFramework.createCipher("RSA1024|PKCS1");
+  let decoder = cryptoFramework.createCipher("RSA1024|PKCS1");
+  let keyGenPromise = rsaGenerator.generateKeyPair();
+  let keyPair;
+  let cipherDataBlob;
+  let input = { data : stringToUint8Array(plan) };
+  keyGenPromise.then(rsaKeyPair => {
+    keyPair = rsaKeyPair;
+    return cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, keyPair.pubKey, null);
+  }).then(() => {
+    return cipher.doFinal(input);
+  }).then(dataBlob => {
+    console.info("EncryptOutPut is " + dataBlob.data);
+    AlertDialog.show({message : "output" + dataBlob.data});
+    cipherDataBlob = dataBlob;
+    return decoder.init(cryptoFramework.CryptoMode.DECRYPT_MODE, keyPair.priKey, null);
+  }).then(() => {
+    return decoder.doFinal(cipherDataBlob);
+  }).then(decodeData => {
+    if (decodeData.data.toString() === input.data.toString()) {
+      AlertDialog.show({message : "decrypt success"});
+      return;
+    }
+    AlertDialog.show({message : "decrypt fail"});
+  });
+}
+
+function decryptMessageCallback() {
+  let rsaGenerator = cryptoFramework.createAsyKeyGenerator("RSA1024|PRIMES_2");
+  let cipher = cryptoFramework.createCipher("RSA1024|PKCS1");
+  let decoder = cryptoFramework.createCipher("RSA1024|PKCS1");
+  let plainText = "this is cipher text";
+  let input = {data : stringToUint8Array(plainText) };
+  let cipherData;
+  let keyPair;
+  rsaGenerator.generateKeyPair(function (err, newKeyPair) {
+    keyPair = newKeyPair;
+    cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, keyPair.pubKey, null, function (err, data) {
+      cipher.doFinal(input, function (err, data) {
+        AlertDialog.show({ message : "EncryptOutPut is " + data.data} );
+        cipherData = data;
+        decoder.init(cryptoFramework.CryptoMode.DECRYPT_MODE, keyPair.priKey, null, function (err, data) {
+          decoder.doFinal(cipherData, function (err, data) {
+            if (input.data.toString() === data.data.toString()) {
+              AlertDialog.show({ message : "decrype success"} );
+              return;
+            }
+            AlertDialog.show({ message : "decrype fail"} );
+          });
+        });
+      });
+    });
+  });
+}
+```
+以RSA非对称加解密（多次调用doFinal实现分段）为例：
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+function 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;
+}
+
+// 字节流转成可理解的字符串
+function uint8ArrayToString(array) {
+  let arrayString = '';
+  for (let i = 0; i < array.length; i++) {
+    arrayString += String.fromCharCode(array[i]);
+  }
+  return arrayString;
+}
+
+function encryptLongMessagePromise() {
+  let globalPlainText = "This is a long plainTest! This is a long plainTest! This is a long plainTest!" +
+  "This is a long plainTest! This is a long plainTest! This is a long plainTest! This is a long plainTest!" +
+  "This is a long plainTest! This is a long plainTest! This is a long plainTest! This is a long plainTest!" +
+  "This is a long plainTest! This is a long plainTest! This is a long plainTest! This is a long plainTest!" +
+  "This is a long plainTest! This is a long plainTest! This is a long plainTest! This is a long plainTest!" +
+  "This is a long plainTest! This is a long plainTest! This is a long plainTest! This is a long plainTest!" +
+  "This is a long plainTest! This is a long plainTest! This is a long plainTest! This is a long plainTest!" +
+  "This is a long plainTest! This is a long plainTest! This is a long plainTest! This is a long plainTest!";
+  let globalCipherOutput;
+  let globalDecodeOutput;
+  var globalKeyPair;
+  let plainTextSplitLen = 64; // RSA每次加解密允许的原文长度大小与密钥位数和填充模式等有关，详细规格内容见overview文档
+  let cipherTextSplitLen = 128; // RSA密钥每次加密生成的密文数据长度计算方式：密钥位数/8
+  let keyGenName = "RSA1024";
+  let cipherAlgName = "RSA1024|PKCS1";
+  let asyKeyGenerator = cryptoFramework.createAsyKeyGenerator(keyGenName); // 创建非对称密钥生成器对象
+  let cipher = cryptoFramework.createCipher(cipherAlgName); // 创建加密Cipher对象
+  let decoder = cryptoFramework.createCipher(cipherAlgName); // 创建解密Decoder对象
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      resolve("testRsaMultiDoFinal");
+    }, 10);
+  }).then(() => {
+    return asyKeyGenerator.generateKeyPair(); // 生成rsa密钥
+  }).then(keyPair => {
+    globalKeyPair = keyPair; // 保存到密钥对全局变量
+    return cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, globalKeyPair.pubKey, null);
+  }).then(async () => {
+    globalCipherOutput = [];
+    // 将原文按64字符进行拆分，循环调用doFinal进行加密，使用1024bit密钥时，每次加密生成128B长度的密文
+    for (let i = 0; i < (globalPlainText.length / plainTextSplitLen); i++) {
+      let tempStr = globalPlainText.substr(i * plainTextSplitLen, plainTextSplitLen);
+      let tempBlob = { data : stringToUint8Array(tempStr) };
+      let tempCipherOutput = await cipher.doFinal(tempBlob);
+      globalCipherOutput = globalCipherOutput.concat(Array.from(tempCipherOutput.data));
+    }
+    console.info(`globalCipherOutput len is ${globalCipherOutput.length}, data is: ${globalCipherOutput.toString()}`);
+    return;
+  }).then(() =>{
+    return decoder.init(cryptoFramework.CryptoMode.DECRYPT_MODE, globalKeyPair.priKey, null);
+  }).then(async() => {
+    globalDecodeOutput = [];
+    // 将密文按128B进行拆分解密，得到原文后进行拼接
+    for (let i = 0; i < (globalCipherOutput.length / cipherTextSplitLen); i++) {
+      let tempBlobData = globalCipherOutput.slice(i * cipherTextSplitLen, (i + 1) * cipherTextSplitLen);
+      let message = new Uint8Array(tempBlobData);
+      let tempBlob = { data : message };
+      let tempDecodeOutput = await decoder.doFinal(tempBlob);
+      globalDecodeOutput += uint8ArrayToString(tempDecodeOutput.data);
+    }
+    if (globalDecodeOutput === globalPlainText) {
+      console.info(`encode and decode success`);
+    } else {
+      console.info(`encode and decode error`);
+    }
+    return;
+  }).catch(error => {
+    console.error(`catch error, ${error.code}, ${error.message}`);
+  })
+}
 ```
 
 **说明**
@@ -554,7 +837,7 @@ function encryptMessageCallback() {
 
 **接口及参数说明**
 
-详细接口说明可参考[API参考](../reference/apis/js-apis-cryptoFramework.md)。
+详细接口说明可参考[API参考](../reference/apis/js-apis-cryptoFramework.md)。<br/>由于密码算法的复杂性，在选取不同规格和参数时，开发差异较大，无法通过代码示例一一列举，请仔细阅读API参考资料中的相关接口，确保使用正确。
 
 |实例名|接口名|描述|
 |---|---|---|
@@ -743,6 +1026,73 @@ function verifyMessageCallback() {
   })
 }
 ```
+以执行签名、验签操作时多次调用update实现分段为例：
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+function 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;
+}
+
+function signLongMessagePromise() {
+  let globalPlainText = "This is a long plainTest! This is a long plainTest! This is a long plainTest!" +
+  "This is a long plainTest! This is a long plainTest! This is a long plainTest! This is a long plainTest!" +
+  "This is a long plainTest! This is a long plainTest! This is a long plainTest! This is a long plainTest!" +
+  "This is a long plainTest! This is a long plainTest! This is a long plainTest! This is a long plainTest!" +
+  "This is a long plainTest! This is a long plainTest! This is a long plainTest! This is a long plainTest!" +
+  "This is a long plainTest! This is a long plainTest! This is a long plainTest! This is a long plainTest!" +
+  "This is a long plainTest! This is a long plainTest! This is a long plainTest! This is a long plainTest!" +
+  "This is a long plainTest! This is a long plainTest! This is a long plainTest! This is a long plainTest!";
+  let globalSignData;
+  let textSplitLen = 64; // 自定义的数据拆分长度
+  let keyGenName = "RSA1024";
+  let cipherAlgName = "RSA1024|PKCS1|SHA256";
+  let globalKeyPair;
+  let asyKeyGenerator = cryptoFramework.createAsyKeyGenerator(keyGenName); // 创建非对称密钥生成器对象
+  let signer = cryptoFramework.createSign(cipherAlgName); // 创建加密Cipher对象
+  let verifier = cryptoFramework.createVerify(cipherAlgName); // 创建解密Decoder对象
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      resolve("testRsaMultiUpdate");
+    }, 10);
+  }).then(() => {
+    return asyKeyGenerator.generateKeyPair(); // 生成rsa密钥
+  }).then(keyPair => {
+    globalKeyPair = keyPair; // 保存到密钥对全局变量
+    return signer.init(globalKeyPair.priKey);
+  }).then(async () => {
+    // 当原文过大时，可将原文按理想长度进行拆分，循环调用update添加原文
+    for (let i = 0; i < (globalPlainText.length / textSplitLen); i++) {
+      let tempStr = globalPlainText.substr(i * textSplitLen, textSplitLen);
+      let tempBlob = { data : stringToUint8Array(tempStr) };
+      await signer.update(tempBlob);
+    }
+    return signer.sign(null);
+  }).then(data =>{
+    globalSignData = data.data;
+    console.info(`globalSignOutput len is ${globalSignData.length}, data is: ${globalSignData.toString()}`);
+    return verifier.init(globalKeyPair.pubKey);
+  }).then(async() => {
+    // 将密文按128B进行拆分解密，得到原文后进行拼接
+    for (let i = 0; i < (globalPlainText.length / textSplitLen); i++) {
+      let tempData = globalPlainText.slice(i * textSplitLen, (i + 1) * textSplitLen);
+      let tempBlob = { data : stringToUint8Array(tempData) };
+      await verifier.update(tempBlob);
+    }
+    return verifier.verify(null, { data : globalSignData});
+  }).then(res => {
+    console.info(`verify res is ${res}`);
+  }).catch(error => {
+    console.error(`catch error, ${error.code}, ${error.message}`);
+  })
+}
+```
 
 ## 使用摘要操作
 
@@ -809,8 +1159,13 @@ function doMdByPromise(algName) {
     console.error("[Promise]: error code: " + error.code + ", message is: " + error.message);
   }
   console.error("[Promise]: Md algName is: " + md.algName);
+  // 初次update
   var promiseMdUpdate = md.update(GenDataBlob(12));
   promiseMdUpdate.then(() => {
+    // 可根据情况进行多次update
+    promiseMdUpdate = md.update(GenDataBlob(12));
+    return promiseMdUpdate;
+  }).then(mdOutput => {
     var PromiseMdDigest = md.digest();
     return PromiseMdDigest;
   }).then(mdOutput => {
@@ -831,13 +1186,19 @@ function doMdByCallback(algName) {
     console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);
   }
   console.error("[Callback]: Md algName is: " + md.algName);
+  // 初次update
   md.update(GenDataBlob(12), (err,) => {
     if (err) {
       console.error("[Callback]: err: " + err.code);
     }
-    md.digest((err1, mdOutput) => {
+    // 可根据情况进行多次update
+    md.update(GenDataBlob(12), (err1,) => {
       if (err1) {
         console.error("[Callback]: err: " + err1.code);
+      }
+      md.digest((err2, mdOutput) => {
+        if (err2) {
+          console.error("[Callback]: err: " + err2.code);
         } else {
           console.error("[Callback]: MD result: " + mdOutput.data);
           var mdLen = md.getMdLength();
@@ -845,6 +1206,64 @@ function doMdByCallback(algName) {
         }
       });
     });
+  });
+}
+```
+以MD更新时多次调用update实现分段为例：
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+async function updateData(index, obj, data) {
+  console.error("update " + (index + 1) + " MB data...");
+  return obj.update(data);
+}
+
+function stringToUint8Array(str) {
+  var arr = [];
+  for (var i = 0, j = str.length; i < j; ++i) {
+    arr.push(str.charCodeAt(i));
+  }
+  var tmpUint8Array = new Uint8Array(arr);
+  return tmpUint8Array;
+}
+
+function GenDataBlob(dataBlobLen) {
+  var dataBlob;
+  if (dataBlobLen == 12) {
+    dataBlob = {data: stringToUint8Array("my test data")};
+  } else {
+    console.error("GenDataBlob: dataBlobLen is invalid");
+    dataBlob = {data: stringToUint8Array("my test data")};
+  }
+  return dataBlob;
+}
+
+function LoopMdPromise(algName, loopSize) {
+  var md;
+  try {
+    md = cryptoFramework.createMd(algName);
+  } catch (error) {
+    console.error("[Promise]: error code: " + error.code + ", message is: " + error.message);
+    return;
+  }
+  console.error("[Promise]: Md algName is: " + md.algName);
+  var promiseMdUpdate = md.update(GenDataBlob(12));
+  promiseMdUpdate.then(() => {
+    var PromiseMdDigest = md.digest();
+    return PromiseMdDigest;
+  }).then(async () => {
+    for (var i = 0; i < loopSize; i++) {
+      await updateData(i, md, GenDataBlob(12));
+    }
+    var PromiseMdDigest = md.digest();
+    return PromiseMdDigest;
+  }).then(mdOutput => {
+    console.error("[Promise]: MD result: " + mdOutput.data);
+    var mdLen = md.getMdLength();
+    console.error("[Promise]: MD len: " + mdLen);
+  }).catch(error => {
+    console.error("[Promise]: error: " + error.message);
+  });
 }
 ```
 
@@ -965,7 +1384,6 @@ function GenDataBlob(dataBlobLen) {
   return dataBlob;
 }
 
-// process by promise
 function doHmacByPromise(algName) {
   var mac;
   try {
@@ -983,6 +1401,11 @@ function doHmacByPromise(algName) {
     var promiseMacInit = mac.init(symKey);
     return promiseMacInit;
   }).then(() => {
+    // 初次update
+    var promiseMacUpdate = mac.update(GenDataBlob(12));
+    return promiseMacUpdate;
+  }).then(() => {
+    // 可根据情况进行多次update
     var promiseMacUpdate = mac.update(GenDataBlob(12));
     return promiseMacUpdate;
   }).then(() => {
@@ -1018,13 +1441,19 @@ function doHmacByCallback(algName) {
       if (err1) {
         console.error("[Callback]: err: " + err1.code);
       }
+      // 初次update
       mac.update(GenDataBlob(12), (err2, ) => {
         if (err2) {
           console.error("[Callback]: err: " + err2.code);
         }
-        mac.doFinal((err3, macOutput) => {
+        // 可根据情况进行多次update
+        mac.update(GenDataBlob(12), (err3, ) => {
           if (err3) {
             console.error("[Callback]: err: " + err3.code);
+          }
+          mac.doFinal((err4, macOutput) => {
+            if (err4) {
+              console.error("[Callback]: err: " + err4.code);
             } else {
               console.error("[Callback]: HMAC result: " + macOutput.data);
               var macLen = mac.getMacLength();
@@ -1034,9 +1463,73 @@ function doHmacByCallback(algName) {
         });
       });
     });
+  });
 }
 ```
+以HMAC更新MAC时多次调用update实现分段为例：
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+async function updateData(index, obj, data) {
+  console.error("update " + (index + 1) + " MB data...");
+  return obj.update(data);
+}
+
+function stringToUint8Array(str) {
+  var arr = [];
+  for (var i = 0, j = str.length; i < j; ++i) {
+    arr.push(str.charCodeAt(i));
+  }
+  var tmpUint8Array = new Uint8Array(arr);
+  return tmpUint8Array;
+}
 
+function GenDataBlob(dataBlobLen) {
+  var dataBlob;
+  if (dataBlobLen == 12) {
+    dataBlob = {data: stringToUint8Array("my test data")};
+  } else {
+    console.error("GenDataBlob: dataBlobLen is invalid");
+    dataBlob = {data: stringToUint8Array("my test data")};
+  }
+  return dataBlob;
+}
+
+function LoopHmacPromise(algName, loopSize) {
+  var mac;
+  try {
+    mac = cryptoFramework.createMac(algName);
+  } catch (error) {
+    console.error("[Promise]: error code: " + error.code + ", message is: " + error.message);
+    return;
+  }
+  console.error("[Promise]: Mac algName is: " + mac.algName);
+  var KeyBlob = {
+    data : stringToUint8Array("12345678abcdefgh")
+  }
+  var symKeyGenerator = cryptoFramework.createSymKeyGenerator("AES128");
+  var promiseConvertKey = symKeyGenerator.convertKey(KeyBlob);
+  promiseConvertKey.then(symKey => {
+    var promiseMacInit = mac.init(symKey);
+    return promiseMacInit;
+  }).then(async () => {
+    for (var i = 0; i < loopSize; i++) {
+      await updateData(i, mac, GenDataBlob(12));
+    }
+    var promiseMacUpdate = mac.update(GenDataBlob(12));
+    return promiseMacUpdate;
+  }).then(() => {
+    var PromiseMacDoFinal = mac.doFinal();
+    return PromiseMacDoFinal;
+  }).then(macOutput => {
+    console.error("[Promise]: HMAC result: " + macOutput.data);
+    var macLen = mac.getMacLength();
+    console.error("[Promise]: MAC len: " + macLen);
+  }).catch(error => {
+    console.error("[Promise]: error: " + error.message);
+  });
+}
+```
 
 
 ## 使用随机数操作

zh-cn/application-dev/security/cryptoFramework-overview.md

 # 加解密算法库框架概述
 加解密算法库框架是一个屏蔽了第三方密码学算法库实现差异的算法框架，提供加解密、签名验签、消息验证码、哈希、安全随机数等相关功能。开发者可以通过调用加解密算法库框架，忽略底层不同三方算法库的差异，实现迅捷开发。
+
+> **说明：** 加解密算法库框架仅提供密钥的密码学操作，而不提供密钥管理功能。因此，使用算法库时，需要应用自己来保管密钥（适用于临时会话密钥等仅在内存中使用的场景，或者应用自己实现密钥安全存储的场景）。如果业务需要由系统提供密钥管理功能（密钥存储等），请使用[HUKS部件](huks-overview.md)。
+
 ## 框架实现原理
 加解密算法库框架提供的组件分为三层：接口层，Framework层和插件层。接口层负责对外提供统一的JS接口，插件层实现针对具体三方算法库的功能，Framework层通过灵活加载插件层的插件适配并屏蔽三方算法库差异。
+
 ## 基本概念
 **对称密钥**
 
@@ -102,19 +106,20 @@ HMAC（Hash-based Message Authentication Code）是一种基于密钥的消息
 ## 约束与限制
 
 - 算法库框架不支持多线程并发操作。
+- 算法库当前只支持OpenSSL。
 
 ### 密钥生成规格
 
 **对称密钥生成规格**
 
-支持的对称密钥生成参数：
+- 支持的对称密钥生成参数：
 
-|对称密钥算法|密钥长度（bit）|字符串参数|
-|---|---|---|
-|3DES|192|3DES192|
-|AES|128|AES128|
-|AES|192|AES192|
-|AES|256|AES256|
+  |对称密钥算法|密钥长度（bit）|字符串参数|
+  |---|---|---|
+  |3DES|192|3DES192|
+  |AES|128|AES128|
+  |AES|192|AES192|
+  |AES|256|AES256|
 
   > **说明**：“字符串参数”是“对称密钥算法”和“密钥长度”拼接而成，用于在创建对称密钥生成器时，指定密钥规格。
 
@@ -123,23 +128,23 @@ HMAC（Hash-based Message Authentication Code）是一种基于密钥的消息
 
   支持的非对称密钥生成参数：
 
-  |非对称密钥算法|密钥长度（bit）|素数个数|字符串参数|
-  |---|---|---|---|
-  |RSA|512|2|RSA512\|PRIMES_2|
-  |RSA|768|2|RSA768\|PRIMES_2|
-  |RSA|1024|2|RSA1024\|PRIMES_2|
-  |RSA|1024|3|RSA1024\|PRIMES_3|
-  |RSA|2048|2|RSA2048\|PRIMES_2|
-  |RSA|2048|3|RSA2048\|PRIMES_3|
-  |RSA|3072|2|RSA3072\|PRIMES_2|
-  |RSA|3072|3|RSA3072\|PRIMES_3|
-  |RSA|4096|2|RSA4096\|PRIMES_2|
-  |RSA|4096|3|RSA4096\|PRIMES_3|
-  |RSA|4096|4|RSA4096\|PRIMES_4|
-  |RSA|8192|2|RSA8192\|PRIMES_2|
-  |RSA|8192|3|RSA8192\|PRIMES_3|
-  |RSA|8192|4|RSA8192\|PRIMES_4|
-  |RSA|8192|5|RSA8192\|PRIMES_5|
+  |非对称密钥类型|素数个数|字符串参数|
+  |---|---|---|
+  |RSA512|2|RSA512\|PRIMES_2|
+  |RSA768|2|RSA768\|PRIMES_2|
+  |RSA1024|2|RSA1024\|PRIMES_2|
+  |RSA1024|3|RSA1024\|PRIMES_3|
+  |RSA2048|2|RSA2048\|PRIMES_2|
+  |RSA2048|3|RSA2048\|PRIMES_3|
+  |RSA3072|2|RSA3072\|PRIMES_2|
+  |RSA3072|3|RSA3072\|PRIMES_3|
+  |RSA4096|2|RSA4096\|PRIMES_2|
+  |RSA4096|3|RSA4096\|PRIMES_3|
+  |RSA4096|4|RSA4096\|PRIMES_4|
+  |RSA8192|2|RSA8192\|PRIMES_2|
+  |RSA8192|3|RSA8192\|PRIMES_3|
+  |RSA8192|4|RSA8192\|PRIMES_4|
+  |RSA8192|5|RSA8192\|PRIMES_5|
 
   > **说明**：生成RSA非对称密钥时，默认素数为2，PRIMES_2参数可省略。
 
@@ -158,47 +163,175 @@ HMAC（Hash-based Message Authentication Code）是一种基于密钥的消息
 
 **对称加解密**
 
-支持的对称加密算法：
-
-|对称加解密算法|分组模式| 字符串参数                                         |
-|---|---|---|
-|3DES|ECB|3DES192\|ECB\|[NoPadding\|PKCS5\|PKCS7]|
-|3DES|CBC|3DES192\|CBC\|[NoPadding\|PKCS5\|PKCS7]|
-|3DES|OFB|3DES192\|OFB\|[NoPadding\|PKCS5\|PKCS7]|
-|3DES|CFB|3DES192\|CFB\|[NoPadding\|PKCS5\|PKCS7]|
-|AES|ECB|AES[128\|192\|256]\|ECB\|[NoPadding\|PKCS5\|PKCS7]|
-|AES|CBC|AES[128\|192\|256]\|CBC\|[NoPadding\|PKCS5\|PKCS7]|
-|AES|CTR|AES[128\|192\|256]\|CTR\|[NoPadding\|PKCS5\|PKCS7]|
-|AES|OFB|AES[128\|192\|256]\|OFB\|[NoPadding\|PKCS5\|PKCS7]|
-|AES|CFB|AES[128\|192\|256]\|CFB\|[NoPadding\|PKCS5\|PKCS7]|
-|AES|GCM|AES[128\|192\|256]\|GCM\|[NoPadding\|PKCS5\|PKCS7]|
-|AES|CCM|AES[128\|192\|256]\|CCM\|[NoPadding\|PKCS5\|PKCS7]|
+- 支持的对称加密算法：
+
+  |对称加解密算法|分组模式| 字符串参数                                         |
+  |---|---|---|
+  |3DES|ECB|3DES192\|ECB\|[NoPadding\|PKCS5\|PKCS7]|
+  |3DES|CBC|3DES192\|CBC\|[NoPadding\|PKCS5\|PKCS7]|
+  |3DES|OFB|3DES192\|OFB\|[NoPadding\|PKCS5\|PKCS7]|
+  |3DES|CFB|3DES192\|CFB\|[NoPadding\|PKCS5\|PKCS7]|
+  |AES|ECB|AES[128\|192\|256]\|ECB\|[NoPadding\|PKCS5\|PKCS7]|
+  |AES|CBC|AES[128\|192\|256]\|CBC\|[NoPadding\|PKCS5\|PKCS7]|
+  |AES|CTR|AES[128\|192\|256]\|CTR\|[NoPadding\|PKCS5\|PKCS7]|
+  |AES|OFB|AES[128\|192\|256]\|OFB\|[NoPadding\|PKCS5\|PKCS7]|
+  |AES|CFB|AES[128\|192\|256]\|CFB\|[NoPadding\|PKCS5\|PKCS7]|
+  |AES|GCM|AES[128\|192\|256]\|GCM\|[NoPadding\|PKCS5\|PKCS7]|
+  |AES|CCM|AES[128\|192\|256]\|CCM\|[NoPadding\|PKCS5\|PKCS7]|
 
 > **说明：** 
+> 
 > 1. []中只能任选一项。
 > 2. “字符串参数”是“对称加解密算法（含密钥长度）”、“分组模式”、“填充模式”拼接而成，用于在创建对称加解密实例时，指定对称加解密算法规格。
 
 **非对称RSA加解密**
 
 RSA加解密时，涉及三种填充模式：NoPadding, PKCS1和PKCS1_OAEP。
-- 使用NoPadding模式时可以指定的参数: [RSA512|RSA768|RSA1024|RSA2048|RSA3072|RSA4096|RSA8192]|NoPadding
-- 使用PKCS1模式时可以指定的参数: [RSA512|RSA768|RSA1024|RSA2048|RSA3072|RSA4096|RSA8192]|PKCS1
-- 使用PKCS1_OAEP模式时可以指定的参数：[RSA512|RSA768|RSA1024|RSA2048|RSA3072|RSA4096|RSA8192]|PKCS1_OAEP|[MD5|SHA1|SHA224|SHA256|SHA384|SHA512]|[MGF1_MD5|MGF1_SHA1|MGF1_SHA224|MGF1_SHA256|MGF1_SHA384|MGF1_SHA512]
+- 使用NoPadding模式时可以指定的参数:
+
+  |非对称密钥类型| 填充模式 | 字符串参数 |
+  |---|---|---|
+  |RSA512|NoPadding|RSA512\|NoPadding|
+  |RSA768|NoPadding|RSA768\|NoPadding|
+  |RSA1024|NoPadding|RSA1024\|NoPadding|
+  |RSA2048|NoPadding|RSA2048\|NoPadding|
+  |RSA3072|NoPadding|RSA3072\|NoPadding|
+  |RSA4096|NoPadding|RSA4096\|NoPadding|
+  |RSA8192|NoPadding|RSA8192\|NoPadding|
+
+- 使用PKCS1模式时可以指定的参数: 
+
+  |非对称密钥类型| 填充模式 | 字符串参数 |
+  |---|---|---|
+  |RSA512|PKCS1|RSA512\|PKCS1|
+  |RSA768|PKCS1|RSA768\|PKCS1|
+  |RSA1024|PKCS1|RSA1024\|PKCS1|
+  |RSA2048|PKCS1|RSA2048\|PKCS1|
+  |RSA3072|PKCS1|RSA3072\|PKCS1|
+  |RSA4096|PKCS1|RSA4096\|PKCS1|
+  |RSA8192|PKCS1|RSA8192\|PKCS1|
+
+- 使用PKCS1_OAEP模式时可以指定的参数：
+  > **说明：** 
+  > 
+  > 1.[]内的参数只能任选一项，非[]内的为固定值；
+  > 2.使用时请从表格中选择非对称密钥类型、填充模式、摘要、掩码摘要四个数据，用|拼接成字符串。
+  >   例如："RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256"
+
+  | 非对称密钥类型 | 填充模式 | 摘要 | 掩码摘要 |
+  |---|---|---|---|
+  |RSA512|PKCS1_OAEP|MD5|  [MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256]|
+  |RSA512|PKCS1_OAEP|SHA1|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256]|
+  |RSA512|PKCS1_OAEP|SHA224|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256]|
+  |RSA512|PKCS1_OAEP|SHA256|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224]
+  |RSA768|PKCS1_OAEP|MD5|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA768|PKCS1_OAEP|SHA1|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA768|PKCS1_OAEP|SHA224|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA768|PKCS1_OAEP|SHA256|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384]|
+  |RSA768|PKCS1_OAEP|SHA384|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256]|
+  |RSA768|PKCS1_OAEP|SHA512|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224]|
+  |RSA1024|PKCS1_OAEP|MD5|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA1024|PKCS1_OAEP|SHA1|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA1024|PKCS1_OAEP|SHA224|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA1024|PKCS1_OAEP|SHA256|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA1024|PKCS1_OAEP|SHA384|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA1024|PKCS1_OAEP|SHA512|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384]|
+  |RSA2048|PKCS1_OAEP|MD5|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA2048|PKCS1_OAEP|SHA1|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA2048|PKCS1_OAEP|SHA224|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA2048|PKCS1_OAEP|SHA256|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA2048|PKCS1_OAEP|SHA384|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA2048|PKCS1_OAEP|SHA512|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA3072|PKCS1_OAEP|MD5|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA3072|PKCS1_OAEP|SHA1|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA3072|PKCS1_OAEP|SHA224|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA3072|PKCS1_OAEP|SHA256|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA3072|PKCS1_OAEP|SHA384|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA3072|PKCS1_OAEP|SHA512|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA4096|PKCS1_OAEP|MD5|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA4096|PKCS1_OAEP|SHA1|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA4096|PKCS1_OAEP|SHA224|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA4096|PKCS1_OAEP|SHA256|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA4096|PKCS1_OAEP|SHA384|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA4096|PKCS1_OAEP|SHA512|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA8192|PKCS1_OAEP|MD5|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA8192|PKCS1_OAEP|SHA1|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA8192|PKCS1_OAEP|SHA224|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA8192|PKCS1_OAEP|SHA256|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512  ]|
+  |RSA8192|PKCS1_OAEP|SHA384|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA8192|PKCS1_OAEP|SHA512|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
 
-> **说明：** []内的参数只能任选一项，非[]内的为固定值
 
 ### 签名验签规格
 
 **RSA签名验签**
 
 RSA签名验签时，涉及两种填充模式：PKCS1和PSS。
-- 使用PKCS1模式时可以指定的参数: [RSA512|RSA768|RSA1024|RSA2048|RSA3072|RSA4096|RSA8192]|PKCS1|[MD5|SHA1|SHA224|SHA256|SHA384|SHA512]
-- 使用PSS模式时可以指定的参数：[RSA512|RSA768|RSA1024|RSA2048|RSA3072|RSA4096|RSA8192]|PSS|[MD5|SHA1|SHA224|SHA256|SHA384|SHA512]|[MGF1_MD5|MGF1_SHA1|MGF1_SHA224|MGF1_SHA256|MGF1_SHA384|MGF1_SHA512]
-> **说明：** []内的参数只能任选一项，非[]内的为固定值
+-  使用PKCS1模式时可以指定的参数: 
+
+  | 非对称密钥类型 | 填充模式 | 摘要 | 字符串参数 |
+  |---|---|---|---|
+  |RSA512|PKCS1|[MD5\|SHA1\|SHA224\|SHA256\|SHA384]|RSA512\|PKCS1\|  [MD5\|SHA1\|SHA224\|SHA256\|SHA384]|
+  |RSA768|PKCS1|[MD5\|SHA1\|SHA224\|SHA256\|SHA384\|SHA512]|RSA768\|PKCS1\|[MD5\|SHA1\|SHA224\|SHA256\|SHA384\|SHA512]|
+  |RSA1024|PKCS1|[MD5\|SHA1\|SHA224\|SHA256\|SHA384\|SHA512]|RSA1024\|PKCS1\|[MD5\|SHA1\|SHA224\|SHA256\|SHA384\|SHA512]|
+  |RSA2048|PKCS1|[MD5\|SHA1\|SHA224\|SHA256\|SHA384\|SHA512]|RSA2048\|PKCS1\|[MD5\|SHA1\|SHA224\|SHA256\|SHA384\|SHA512]|
+  |RSA3072|PKCS1|[MD5\|SHA1\|SHA224\|SHA256\|SHA384\|SHA512]|RSA3072\|PKCS1\|[MD5\|SHA1\|SHA224\|SHA256\|SHA384\|SHA512]|
+  |RSA4096|PKCS1|[MD5\|SHA1\|SHA224\|SHA256\|SHA384\|SHA512]|RSA4096\|PKCS1\|[MD5\|SHA1\|SHA224\|SHA256\|SHA384\|SHA512]|
+  |RSA8192|PKCS1|[MD5\|SHA1\|SHA224\|SHA256\|SHA384\|SHA512]|RSA8192\|PKCS1\|[MD5\|SHA1\|SHA224\|SHA256\|SHA384\|SHA512]|
+
+- 使用PSS模式时可以指定的参数：
+  > **说明：** 
+  > 
+  > 1.[]内的参数只能任选一项，非[]内的为固定值；
+  > 2.使用时请从表格中选择非对称密钥类型、填充模式、摘要、掩码摘要四个数据，用|拼接成字符串。
+  >  例如："RSA2048|PSS|SHA256|MGF1_SHA256"
+
+  | 非对称密钥类型 | 填充模式 | 摘要 | 掩码摘要 |
+  |---|---|---|---|
+  |RSA512|PSS|MD5|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256]|
+  |RSA512|PSS|SHA1|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256]|
+  |RSA512|PSS|SHA224|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256]|
+  |RSA512|PSS|SHA256|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224]|RSA512\|PSS\|SHA256\|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224]|
+  |RSA768|PSS|MD5|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA768|PSS|SHA1|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA768|PSS|SHA224|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA768|PSS|SHA256|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384]|
+  |RSA768|PSS|SHA384|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256]|
+  |RSA768|PSS|SHA512|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224]|
+  |RSA1024|PSS|MD5|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA1024|PSS|SHA1|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA1024|PSS|SHA224|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA1024|PSS|SHA256|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA1024|PSS|SHA384|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA1024|PSS|SHA512| [MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384]|
+  |RSA2048|PSS|MD5|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA2048|PSS|SHA1|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA2048|PSS|SHA224|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA2048|PSS|SHA256|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA2048|PSS|SHA384|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA2048|PSS|SHA512|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA3072|PSS|MD5|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA3072|PSS|SHA1|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA3072|PSS|SHA224|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA3072|PSS|SHA256|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA3072|PSS|SHA384|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA3072|PSS|SHA512|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA4096|PSS|MD5|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA4096|PSS|SHA1|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA4096|PSS|SHA224|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA4096|PSS|SHA256|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA4096|PSS|SHA384|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA4096|PSS|SHA512|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA8192|PSS|MD5|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA8192|PSS|SHA1|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA8192|PSS|SHA224|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA8192|PSS|SHA256|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA8192|PSS|SHA384|[MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
+  |RSA8192|PSS|SHA512| [MGF1_MD5\|MGF1_SHA1\|MGF1_SHA224\|MGF1_SHA256\|MGF1_SHA384\|MGF1_SHA512]|
 
 **ECDSA签名验签**
 
-支持的ECDSA参数：
+- 支持的ECDSA参数：
 
   |非对称密钥算法|支持种类|
   |---|---|
@@ -219,7 +352,7 @@ RSA签名验签时，涉及两种填充模式：PKCS1和PSS。
 
 **ECDH**
 
-  支持的ECDH参数：
+- 支持的ECDH参数：
 
   |非对称密钥算法|支持种类|
   |---|---|
@@ -228,8 +361,25 @@ RSA签名验签时，涉及两种填充模式：PKCS1和PSS。
   |ECC|ECC384|
   |ECC|ECC521|
 
-### MD算法规格
-加解密算法库框架当前支持MD5算法
+### MD消息摘要算法规格
+- 加解密算法库框架当前支持的MD算法参数：
+
+  |摘要算法|支持种类|
+  |---|---|
+  |HASH|SHA1|
+  |HASH|SHA224|
+  |HASH|SHA256|
+  |HASH|SHA384|
+  |HASH|SHA512|
+  |HASH|MD5|
+
+### HMAC消息认证码算法规格
+- 加解密算法库框架当前支持的HMAC算法参数：
 
-### SHA算法规格
-加解密算法库框架当前支持：SHA1，SHA224，SHA256，SHA384，SHA512
+  |摘要算法|支持种类|
+  |---|---|
+  |HASH|SHA1|
+  |HASH|SHA224|
+  |HASH|SHA256|
+  |HASH|SHA384|
+  |HASH|SHA512|