update docs

Signed-off-by: Nzengyawen <zengyawen1@huawei.com>

zh-cn/application-dev/reference/apis/Readme-CN.md

@@ -127,6 +127,7 @@
 - 安全
   - [@ohos.abilityAccessCtrl (访问控制管理)](js-apis-abilityAccessCtrl.md)
   - [@ohos.privacyManager (隐私管理)](js-apis-privacyManager.md)
+  - [@ohos.security.cryptoFramework (加密算法库框架)](js-apis-cryptoFramework.md)
   - [@ohos.security.huks (通用密钥库系统)](js-apis-huks.md)
   - [@ohos.userIAM.faceAuth (人脸认证)](js-apis-useriam-faceauth.md)
   - [@ohos.userIAM.userAuth (用户认证)](js-apis-useriam-userauth.md)

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

+# 加解密算法库框架
+
+为屏蔽底层硬件和算法库，向上提供统一的密码算法库加解密和证书相关接口。
+
+> **说明：**
+> 
+> 本模块首批接口从API version 9开始支持。
+
+## 导入模块
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+```
+
+## Result
+
+ 表示执行结果的枚举。
+
+ **系统能力：** SystemCapability.Security.CryptoFramework
+
+| 名称                                  | 默认值   | 描述                          |
+| --------------------------------------| -------- | ------------------------------|
+| INVALID_PARAMS                        | 401      | 非法入参。                    |
+| NOT_SUPPORT                           | 801      | 操作不支持。                  |
+| ERR_OUT_OF_MEMORY                     | 17620001 | 内存错误。                    |
+| ERR_EXTERNAL_ERROR                    | 17620002 | 运行时外部错误。                  |
+| ERR_CRYPTO_OPERATION                  | 17630001 | 调用三方算法库API出错。       |
+| ERR_CERT_SIGNATURE_FAILURE            | 17630002 | 证书签名验证错误。            |
+| ERR_CERT_NOT_YET_VALID                | 17630003 | 证书尚未生效。                |
+| ERR_CERT_HAS_EXPIRED                  | 17630004 | 证书过期。                    |
+| ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY | 17630005 | 无法获取证书的颁发者。        |
+| ERR_KEYUSAGE_NO_CERTSIGN              | 17630006 | 证书的秘钥用途不含证书签名。  |
+| ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE     | 17630007 |  证书的秘钥用途不含数字签名。 |
+
+## DataBlob
+buffer数组。
+ **系统能力：** SystemCapability.Security.CryptoFramework
+| 名称           | 类型           | 可读 | 可写 | 描述               |
+| -------------- | -------------- | ---- | ---- | ----------------|
+| data           | Uint8Array     | 是   | 是   | 数据。    |
+
+## DataArray
+buffer数组的列表。
+ **系统能力：** SystemCapability.Security.CryptoFramework
+| 名称           | 类型           | 可读 | 可写 | 描述               |
+| -------------- | -------------- | ---- | ---- | ----------------|
+| data           | Uint8Array     | 是   | 是   | 数据列表。    |
+
+## EncodingFormat
+
+ 表示证书编码格式的枚举。
+
+ **系统能力：** SystemCapability.Security.CryptoFramework
+
+| 名称        | 默认值   | 描述       |
+| ------------| ---------| -----------|
+| FORMAT_DER  | 0        | DER格式。  |
+| FORMAT_PEM  | 1        | PEM格式。  |
+
+
+## EncodingBlob
+
+证书链数据，在证书链校验时，作为入参传入。
+
+### 属性
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 名称           | 类型           | 可读 | 可写 | 描述                              |
+| -------------- | -------------- | ---- | ---- | ----------------------------------|
+| data           | Uint8Array     | 是   | 是   | 传入的数据中，包含的证书数量。    |
+| encodingFormat | [EncodingFormat](#encodingformat) | 是   | 是   | 指明证书编码格式。 |
+
+
+## CertChainData
+
+证书链数据，在证书链校验时，作为入参传入。
+
+### 属性
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 名称           | 类型           | 可读 | 可写 | 描述                                                         |
+| -------------- | -------------- | ---- | ---- | ------------------------------------------------------------ |
+| data           | Uint8Array     | 是   | 是   | 证书数据，按照长度(2字节)-数据的形式传入，如：08ABCDEFGH07ABCDEFG,第一本证书，前2个字节表示证书的长度为8字节，后面附加8字节的证书数据；第2本证书前2个字节表示证书的长度为7字节，后面附加7字节的证书数据。   |
+| count          | number         | 是   | 是   | 传入的数据中，包含的证书数量。                             |
+| encodingFormat | [EncodingFormat](#encodingformat) | 是   | 是   | 指明证书编码格式。 |
+
+
+## cryptoFramework.createMac
+
+createMac(algName : string) : Mac
+
+生成Mac实例，用于进行消息认证码的计算与操作
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名  | 类型   | 必填 | 说明                                                         |
+| ------- | ------ | ---- | ------------------------------------------------------------ |
+| algName | string | 是   | 指定摘要算法，支持算法范围：SHA1/SHA224/SHA256/SHA384/SHA512 |
+
+**返回值**：
+
+| 类型 | 说明                                    |
+| ---- | --------------------------------------- |
+| Mac  | 返回由输入算法指定生成的[Mac](#mac)对象 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var mac;
+try {
+    mac = cryptoFramework.createMac("SHA256");
+} catch (error) {
+    console.error("[Promise]: error code: " + error.code + ", message is: " + error.message);
+}
+```
+
+## Mac
+
+Mac类，调用Mac方法可以进行MAC（Message Authentication Code）加密计算。调用前，需要通过[createMac](#cryptoframeworkcreatemac)构造Mac实例。
+
+### **属性**
+
+**系统能力：**SystemCapability.Security.CryptoFramework
+
+| 名称    | 类型   | 可读 | 可写 | 说明                 |
+| ------- | ------ | ---- | ---- | -------------------- |
+| algName | string | 是   | 否   | 代表指定的摘要算法名 |
+
+### init
+
+init(key : SymKey, callback : AsyncCallback\<void>) : void;	
+
+使用对称密钥初始化Mac计算
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名   | 类型                  | 必填 | 说明               |
+| -------- | --------------------- | ---- | ------------------ |
+| key   | SymKey                   | 是   | 共享对称密钥       |
+| callback | AsyncCallback\<void> | 是   | 回调函数 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var mac;
+try {
+    mac = cryptoFramework.createMac("SHA256");
+} catch (error) {
+    console.error("[Promise]: error code: " + error.code + ", message is: " + error.message);
+}
+var KeyBlob;
+var symKeyGenerator = cryptoFramework.createSymKeyGenerator("AES128");
+symKeyGenerator.convertKey(KeyBlob, (err, symKey) => {
+    if (err) {
+        console.error("[Callback] err: " + err.code);
+    }
+    mac.init(symKey, (err1, ) => {
+        if (err1) {
+            console.error("[Callback] err: " + err1.code);
+        }
+    });
+});
+```
+
+
+
+### init
+
+init(key : SymKey) : Promise\<void>;
+
+使用对称密钥初始化Mac计算
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名 | 类型   | 必填 | 说明         |
+| ------ | ------ | ---- | ------------ |
+| key    | SymKey | 是   | 共享对称密钥 |
+
+**返回值：**
+
+| 类型            | 说明         |
+| --------------- | ------------ |
+| Promise\<void> | Promise对象 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var mac;
+try {
+    mac = cryptoFramework.createMac("SHA256");
+} catch (error) {
+    AlertDialog.show({message: "[Promise]: error code: " + error.code + ", message is: " + error.message});
+    console.error("[Promise]: error code: " + error.code + ", message is: " + error.message);
+    
+}
+console.error("Mac algName is: " + mac.algName);
+
+var KeyBlob;
+var symKeyGenerator = cryptoFramework.createSymKeyGenerator("AES128");
+var promiseConvertKey = symKeyGenerator.convertKey(KeyBlob);
+promiseConvertKey.then(symKey => {
+    var promiseMacInit = mac.init(symKey);
+    return promiseMacInit;
+}).catch(error => {
+    console.error("[Promise]: error: " + error.message);
+});
+
+```
+
+### update
+
+update(input : DataBlob, callback : AsyncCallback\<void>) : void;
+
+传入消息进行Mac更新计算
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 参数名   | 类型                  | 必填 | 说明               |
+| -------- | --------------------- | ---- | ---------- |
+| input    | DataBlob              | 是   | 传入的消息         |
+| callback | AsyncCallback\<void> | 是   | 回调函数 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var KeyBlob;
+var mac;
+try {
+    mac = cryptoFramework.createMac("SHA256");
+} catch (error) {
+    AlertDialog.show({message: "[Callback]: error code: " + error.code + ", message is: " + error.message});
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);
+}
+var symKeyGenerator = cryptoFramework.createSymKeyGenerator("AES128");
+symKeyGenerator.convertKey(KeyBlob, (err, symKey) => {
+    if (err) {
+        console.error("[Callback] err: " + err.code);
+    }
+    mac.init(symKey, (err1, ) => {
+        if (err1) {
+            console.error("[Callback] err: " + err1.code);
+        }
+        let blob;
+      	mac.update(blob, (err2, data) => {
+        	if (err2) {
+            console.error("[Callback] err: " + err2.code);
+        	}
+      	});
+    });
+});
+```
+
+### update
+
+update(input : DataBlob) : Promise\<void>;
+
+传入消息进行Mac更新计算
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 参数名 | 类型     | 必填 | 说明       |
+| ------ | -------- | ---- | ---------- |
+| input  | DataBlob | 是   | 传入的消息 |
+
+**返回值：**
+
+| 类型            | 说明         |
+| --------------- | ----------- |
+| Promise\<void> | Promise对象 |
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var mac;
+try {
+    mac = cryptoFramework.createMac("SHA256");
+} catch (error) {
+    AlertDialog.show({message: "[Promise]: error code: " + error.code + ", message is: " + error.message});
+    console.error("[Promise]: error code: " + error.code + ", message is: " + error.message);
+}
+console.error("Mac algName is: " + mac.algName);
+AlertDialog.show({message: "Mac algName is: " + mac.algName});
+
+var KeyBlob;
+
+var symKeyGenerator = cryptoFramework.createSymKeyGenerator("AES128");
+var promiseConvertKey = symKeyGenerator.convertKey(KeyBlob);
+promiseConvertKey.then(symKey => {
+    var promiseMacInit = mac.init(symKey);
+    return promiseMacInit;
+}).then(() => {
+    let blob;
+    var promiseMacUpdate = mac.update(blob);
+    return promiseMacUpdate;
+}).catch(error => {
+    console.error("[Promise]: error: " + error.message);
+});
+
+```
+
+
+
+### doFinal
+
+doFinal(callback : AsyncCallback\<DataBlob>) : void;
+
+返回Mac的计算结果
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 参数名   | 类型                      | 必填 | 说明           |
+| -------- | ------------------------- | ---- | -------- |
+| callback | AsyncCallback\<DataBlob> | 是   | 回调函数 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var KeyBlob;
+var mac;
+try {
+    mac = cryptoFramework.createMac("SHA256");
+} catch (error) {
+    AlertDialog.show({message: "[Callback]: error code: " + error.code + ", message is: " + error.message});
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);  
+}
+var symKeyGenerator = cryptoFramework.createSymKeyGenerator("AES128");
+symKeyGenerator.convertKey(KeyBlob, (err, symKey) => {
+    if (err) {
+        console.error("[Callback] err: " + err.code);
+    }
+    mac.init(symKey, (err1, ) => {
+        if (err1) {
+            console.error("[Callback] err: " + err1.code);
+        }
+        let blob;
+        mac.update(blob, (err2, ) => {
+            if (err2) {
+                console.error("[Callback] err: " + err2.code);
+            }
+            mac.doFinal((err3, macOutput) => {
+                if (err3) {
+                    console.error("[Callback] err: " + err3.code);
+                } else {
+                    console.error("[Promise]: HMAC result: " + macOutput);
+                }
+            });
+        });
+    });
+});
+```
+
+### doFinal
+
+doFinal() : Promise\<DataBlob>
+
+返回Mac的计算结果
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**返回值：**
+
+| 类型              | 说明        |
+| ------------------- | ----------- |
+| Promise\<DataBlob> | Promise对象 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var mac;
+try {
+    mac = cryptoFramework.createMac("SHA256");
+} catch (error) {
+    console.error("[Promise]: error code: " + error.code + ", message is: " + error.message);  
+}
+console.error("Mac algName is: " + mac.algName);
+AlertDialog.show({message: "Mac algName is: " + mac.algName});
+
+var KeyBlob;
+var symKeyGenerator = cryptoFramework.createSymKeyGenerator("AES128");
+var promiseConvertKey = symKeyGenerator.convertKey(KeyBlob);
+promiseConvertKey.then(symKey => {
+    var promiseMacInit = mac.init(symKey);
+    return promiseMacInit;
+}).then(() => {
+    let blob;
+    var promiseMacUpdate = mac.update(blob);
+    return promiseMacUpdate;
+}).then(() => {
+    var PromiseMacDoFinal = mac.doFinal();
+    return PromiseMacDoFinal;
+}).then(macOutput => {
+    console.error("[Promise]: HMAC result: " + macOutput.data);
+}).catch(error => {
+    console.error("[Promise]: error: " + error.message);
+});
+```
+
+### getMacLength
+
+getMacLength() : number
+
+获取Mac消息认证码的长度（字节数）
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**返回值：**
+
+| 类型   | 说明                      |
+| ------ | ------------------------- |
+| number | 返回mac计算结果的字节长度 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var mac;
+try {
+    mac = cryptoFramework.createMac("SHA256");
+} catch (error) {
+    console.error("[Promise]: error code: " + error.code + ", message is: " + error.message);
+}
+console.error("Mac algName is: " + mac.algName);
+AlertDialog.show({message: "Mac algName is: " + mac.algName});
+
+var KeyBlob;
+var symKeyGenerator = cryptoFramework.createSymKeyGenerator("AES128");
+var promiseConvertKey = symKeyGenerator.convertKey(KeyBlob);
+promiseConvertKey.then(symKey => {
+    var promiseMacInit = mac.init(symKey);
+    return promiseMacInit;
+}).then(() => {
+    let blob;
+    var promiseMacUpdate = mac.update(blob);
+    return promiseMacUpdate;
+}).then(() => {
+    var PromiseMacDoFinal = mac.doFinal();
+    return PromiseMacDoFinal;
+}).then(macOutput => {
+    console.error("[Promise]: HMAC result: " + macOutput.data);
+    let macLen = mac.getMacLength();
+	AlertDialog.show({message: "MAC len: " + macLen});
+}).catch(error => {
+    console.error("[Promise]: error: " + error.message);
+});
+```
+
+## cryptoFramework.createMd
+
+createMd(algName : string) : Md
+
+生成Md实例，用于进行消息摘要的计算与操作
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名  | 类型   | 必填 | 说明                                                         |
+| ------- | ------ | ---- | ------------------------------------------------------------ |
+| algName | string | 是   | 指定摘要算法，支持算法范围：SHA1/SHA224/SHA256/SHA384/SHA512/MD5 |
+
+**返回值**：
+
+| 类型 | 说明                                  |
+| ---- | ------------------------------------- |
+| Md   | 返回由输入算法指定生成的[Md](#md)对象 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var md;
+try {
+    md = cryptoFramework.createMd("SHA256");
+} catch (error) {
+    console.error("[Promise]: error code: " + error.code + ", message is: " + error.message);
+}
+```
+
+## Md
+
+Md类，调用Md方法可以进行MD（Message Digest）摘要计算。调用前，需要通过[createMd](#cryptoframeworkcreatemd)构造Md实例。
+
+### **属性**
+
+**系统能力：**SystemCapability.Security.CryptoFramework
+
+| 名称    | 类型   | 可读 | 可写 | 说明                 |
+| ------- | ------ | ---- | ---- | -------------------- |
+| algName | string | 是   | 否   | 代表指定的摘要算法名 |
+
+### update
+
+update(input : DataBlob, callback : AsyncCallback\<void>) : void;
+
+传入消息进行Md更新计算
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 参数名   | 类型                  | 必填 | 说明         |
+| -------- | --------------------- | ---- | ------------ |
+| input    | DataBlob              | 是   | 传入的消息   |
+| callback | AsyncCallback\<void> | 是   | 回调函数 |
+
+**返回值：**
+
+| 类型            | 说明         |
+| --------------- | ------------ |
+| Promise\<void> | Promise对象 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var md;
+try {
+    md = cryptoFramework.createMd("SHA256");
+} catch (error) {
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);
+}
+console.error("Md algName is: " + md.algName);
+
+let blob;
+md.update(blob, (err,) => {
+    if (err) {
+        console.error("[Callback] err: " + err.code);
+    }
+});
+```
+
+### update
+
+update(input : DataBlob) : Promise\<void>;
+
+传入消息进行Md更新计算
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 参数名 | 类型     | 必填 | 说明       |
+| ------ | -------- | ---- | ---------- |
+| input  | DataBlob | 是   | 传入的消息 |
+
+**返回值：**
+
+| 类型            | 说明         |
+| --------------- | ------------ |
+| Promise\<void> | Promise对象 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var md;
+try {
+    md = cryptoFramework.createMd("SHA256");
+} catch (error) {
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);
+}
+console.error("Md algName is: " + md.algName);
+
+let blob;
+var promiseMdUpdate = md.update(blob);
+promiseMdUpdate.then(() => {
+    // do something
+}).catch(error => {
+    console.error("[Promise]: error: " + error.message);
+});
+```
+
+### digest
+
+digest(callback : AsyncCallback\<DataBlob>) : void
+
+返回Md的计算结果
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 参数名   | 类型                      | 必填 | 说明                 |
+| -------- | ------------------------- | ---- | -------------------- |
+| callback | AsyncCallback\<DataBlob> | 是   | 回调函数 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var md;
+try {
+    md = cryptoFramework.createMd("SHA256");
+} catch (error) {
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);
+}
+console.error("Md algName is: " + md.algName);
+
+let blob;
+md.update(blob, (err,) => {
+    if (err) {
+        console.error("[Callback] err: " + err.code);
+    }
+    md.digest((err1, mdOutput) => {
+		if (err1) {
+            console.error("[Callback] err: " + err1.code);
+        } else {
+            console.error("[Callback]: MD result: " + mdOutput);
+        }
+    });
+});
+```
+
+### digest
+
+digest() : Promise\<DataBlob>
+
+返回Md的计算结果
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**返回值：**
+
+| 类型              | 说明        |
+| ------------------- | ----------- |
+| Promise\<DataBlob> | Promise对象 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var md;
+try {
+    md = cryptoFramework.createMd("SHA256");
+} catch (error) {
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);
+}
+console.error("Md algName is: " + md.algName);
+
+let blob;
+var promiseMdUpdate = md.update(blob);
+promiseMdUpdate.then(() => {
+    var PromiseMdDigest = md.digest();
+    return PromiseMdDigest;
+}).then(mdOutput => {
+    console.error("[Promise]: MD result: " + mdOutput.data);
+}).catch(error => {
+    console.error("[Promise]: error: " + error.message);
+});
+```
+
+### getMdLength
+
+getMdLength() : number
+
+获取Md消息摘要长度（字节数）
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**返回值：**
+
+| 类型   | 说明                     |
+| ------ | ------------------------ |
+| number | 返回md计算结果的字节长度 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var md;
+try {
+    md = cryptoFramework.createMd("SHA256");
+} catch (error) {
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);
+}
+console.error("Md algName is: " + md.algName);
+
+let blob;
+var promiseMdUpdate = md.update(blob);
+promiseMdUpdate.then(() => {
+    var PromiseMdDigest = md.digest();
+    return PromiseMdDigest;
+}).then(mdOutput => {
+    console.error("[Promise]: MD result: " + mdOutput.data);
+    let mdLen = md.getMdLength();
+	AlertDialog.show({message: "MD len: " + mdLen});
+}).catch(error => {
+    console.error("[Promise]: error: " + error.message);
+});
+```
+
+## cryptoFramework.createRandom
+
+createRandom() : Random
+
+生成Random实例，用于进行随机数的计算与设置种子
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                                          |
+| ------ | --------------------------------------------- |
+| Random | 返回由输入算法指定生成的[Random](#random)对象 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+try {
+    var rand = cryptoFramework.createRandom();
+} catch (error) {
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message); 
+}
+```
+
+## Random
+
+Random类，调用Random方法可以进行随机数计算。调用前，需要通过[createRandom](#cryptoframeworkcreaterandom)构造Random实例。
+
+### generateRandom
+
+generateRandom(len : number, callback: AsyncCallback\<DataBlob>) : void;
+
+生成指定长度的随机数
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 参数名   | 类型                      | 必填 | 说明                 |
+| -------- | ------------------------- | ---- | -------------------- |
+| len      | number                    | 是   | 表示生成随机数的长度 |
+| callback | AsyncCallback\<DataBlob> | 是   | 回调函数 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var rand;
+try {
+    rand = cryptoFramework.createRandom();
+} catch (error) {
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);    
+}
+rand.generateRandom(12, (err, randData) => {
+    if (err) {
+        console.error("[Callback] err: " + err.code);
+    } else {
+        console.error("[Callback]: generate random result: " + randData.data);
+    }
+});
+```
+
+### generateRandom
+
+generateRandom(len : number) : Promise\<DataBlob>;
+
+生成指定长度的随机数
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 参数名 | 类型   | 必填 | 说明                 |
+| ------ | ------ | ---- | -------------------- |
+| len    | number | 是   | 表示生成随机数的长度 |
+
+**返回值：**
+
+| 类型              | 说明        |
+| ------------------- | ----------- |
+| Promise\<DataBlob> | Promise对象 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var rand;
+try {
+    rand = cryptoFramework.createRandom();
+} catch (error) {
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);
+}
+
+var promiseGenerateRand = rand.generateRandom(12);
+promiseGenerateRand.then(randData => {
+    console.error("[Promise]: rand result: " + randData.data);
+}).catch(error => {
+    console.error("[Promise]: error: " + error.message);
+});
+```
+
+### setSeed
+
+setSeed(seed : DataBlob, callback : AsyncCallback\<void>) : void;
+
+设置指定的种子
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 参数名   | 类型                 | 必填 | 说明         |
+| -------- | -------------------- | ---- | ------------ |
+| seed     | DataBlob             | 是   | 设置的种子   |
+| callback | AsyncCallback\<void\> | 是   | 回调函数 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var rand;
+try {
+    rand = cryptoFramework.createRandom();
+} catch (error) {
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);
+}
+
+rand.generateRandom(12, (err, randData) => {
+    if (err) {
+        console.error("[Callback] err: " + err.code);
+    } else {
+        console.error("[Callback]: generate random result: " + randData.data);
+        rand.setSeed(randData, (err1, data) => {
+            if (err1) {
+                console.error("[Callback] err: " + err1.code);
+            } else {
+                console.error("[Callback]: setSeed success");
+            }
+        });
+    }
+});
+```
+
+### setSeed
+
+setSeed(seed : DataBlob) : Promise\<void>;
+
+设置指定的种子
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 参数名 | 类型     | 必填 | 说明       |
+| ------ | -------- | ---- | ---------- |
+| seed   | DataBlob | 是   | 设置的种子 |
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+var rand;
+try {
+    rand = cryptoFramework.createRandom();
+} catch (error) {
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);
+}
+
+var promiseGenerateRand = rand.generateRandom(12);
+promiseGenerateRand.then(randData => {
+    console.error("[Promise]: rand result: " + randData.data);
+    var promiseSetSeed = rand.setSeed(randData);
+    return promiseSetSeed;
+}).then(() => {
+    console.error("[Promise]: setSeed success");
+}).catch(error => {
+    console.error("[Promise]: error: " + error.message);
+});
+```
+
+## ParamsSpec
+
+加解密参数，在进行对称加解密时需要构造其子类对象，并将子类对象传入[init()](#init-2)方法。适用于需要iv等参数的对称加解密模式（对于无iv等参数的模式如ECB模式，不需要构造其子类对象）。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 名称    | 类型   | 可读 | 可写 | 描述                   |
+| ------- | ------ | ---- | ---- | ---------------------- |
+| algoName | string | 是   | 是   | 指明对称加解密参数的算法模式。可选值如下:<br/>- "IvParamsSpec": 适用于CBC\|CTR\|OFB\|CFB模式<br/>- "GcmParamsSpec": 适用于GCM模式<br/>- "CcmParamsSpec": 适用于CCM模式 |
+
+## IvParamsSpec
+
+适用于CBC、CTR、OFB、CFB模式，仅使用iv的加解密参数，在对称加解密时构造并传入[init()](#init-2)方法作为参数。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 名称    | 类型   | 可读 | 可写 | 描述                   |
+| ------- | ------ | ---- | ---- | ---------------------- |
+| iv | [DataBlob](#datablob) | 是   | 是   | 指明加解密参数iv。常见取值如下：<br/>- AES的CBC\|CTR\|OFB\|CFB模式：iv长度为16字节<br/>- 3DES的CBC\|OFB\|CFB模式：iv长度为8字节|
+
+## GcmParamsSpec
+
+适用于GCM模式的加解密参数，在对称加解密时构造并传入[init()](#init-2)方法作为参数。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 名称    | 类型   | 可读 | 可写 | 描述                   |
+| ------- | ------ | ---- | ---- | ---------------------- |
+| iv | [DataBlob](#datablob) | 是   | 是   | 指明加解密参数iv，长度为12字节|
+| aad | [DataBlob](#datablob) | 是   | 是   | 指明加解密参数aad，长度为8字节|
+| authTag | [DataBlob](#datablob) | 是   | 是   | 指明加解密参数authTag，长度为16字节。<br/>采用GCM模式加密时，需要获取[doFinal()](#dofinal-2)输出的[DataBlob](#datablob)，将其作为解密时[GcmParamsSpec](#gcmparamsspec)中的authTag|
+
+## CcmParamsSpec
+
+适用于CCM模式的加解密参数，在对称加解密时构造并传入[init()](#init-2)方法作为参数。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 名称    | 类型     | 可读 | 可写 | 描述                                                         |
+| ------- | -------- | ---- | ---- | -------------------------------|
+| iv      | [DataBlob](#datablob) | 是   | 是   | 指明加解密参数iv，长度为7字节                                |
+| aad     | [DataBlob](#datablob) | 是   | 是   | 指明加解密参数aad，长度为8字节                               |
+| authTag | [DataBlob](#datablob) | 是   | 是   | 指明加解密参数authTag，长度为12字节。<br/>采用CCM模式加密时，需要获取[doFinal()](#dofinal-2)输出的[DataBlob](#datablob)，将其作为解密时[CcmParamsSpec](#ccmparamsspec)中的authTag |
+
+## CryptoMode
+
+表示加解密操作的枚举。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 名称         | 值        | 描述                             |
+| ------------ | -------- | -------------------------------- |
+| ENCRYPT_MODE | 0        | 表示进行加密操作                    |
+| DECRYPT_MODE | 1        | 表示进行解密操作                    |
+
+## Key
+
+密钥（父类），在运行密码算法（如加解密）时需要提前生成其子类对象，并传入[Cipher](#cipher)实例的[init()](#init-2)方法。密钥可以通过密钥生成器来生成。
+
+### 属性
+
+**系统能力：** SystemCapability.Security.CryptoFramework 
+
+| 名称    | 类型   | 可读 | 可写 | 描述                   |
+| ------- | ------ | ---- | ---- | ---------------------- |
+| format | string | 是   | 否   | 密钥的格式。|
+| algName | string | 是   | 否   | 密钥对应的算法名（含长度）。|
+
+### getEncoded
+
+getEncoded() : DataBlob
+
+以同步方法，获取16进制形式的密钥内容。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**返回值：**
+
+| 类型   |描述                   |
+| ------- | ----------- |
+| [DataBlob](#datablob) | 用于查看密钥的具体内容。|
+
+**示例：**
+
+```js
+function uint8ArrayToShowStr(uint8Array) {
+  return Array.prototype.map
+    .call(uint8Array, (x) => ('00' + x.toString(16)).slice(-2))
+    .join('');
+}
+
+let key;    // key为使用对称密钥生成器 生成的密钥，此处省略生成过程
+let encodedKey = key.getEncoded();
+console.info("key hex:" + uint8ArrayToShowStr(encodedKey.data));
+```
+
+## SymKey
+
+对称密钥，是[Key](#key)的子类，在对称加解密时需要将其对象传入[Cipher](#cipher)实例的[init()](#init-2)方法使用。对称密钥可以通过对称密钥生成器[SymKeyGenerator](#symkeygenerator)来生成。
+
+### clearMem
+
+clearMem() : void
+
+以同步方法，将系统底层内存中的的密钥内容清零。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**示例：**
+
+```js
+function uint8ArrayToShowStr(uint8Array) {
+  return Array.prototype.map
+    .call(uint8Array, (x) => ('00' + x.toString(16)).slice(-2))
+    .join('');
+}
+
+let key;    // key为使用对称密钥生成器 生成的密钥，此处省略生成过程
+let encodedKey = key.getEncoded();
+console.info("key hex:" + uint8ArrayToShowStr(encodedKey.data));    // 输出密钥内容
+key.clearMem();
+encodedKey = key.getEncoded();
+console.info("key hex:" + uint8ArrayToShowStr(encodedKey.data));    // 输出全零
+```
+
+## PubKey
+
+公钥，是Key的子类，在非对称加解密、验签、密钥协商时需要将其对象作为输入使用。公钥可以通过非对称密钥生成器AsyKeyGenerator来生成。
+
+### 属性
+
+**系统能力：** SystemCapability.Security.CryptoFramework 
+
+| 名称    | 类型   | 可读 | 可写 | 描述                   |
+| ------- | ------ | ---- | ---- | ---------------------- |
+| format | string | 是   | 否   | 密钥的格式。|
+| algName | string | 是   | 否   | 密钥对应的算法名（含长度）。|
+
+
+### getEncoded
+
+getEncoded() : DataBlob
+
+以同步方法，获取二进制形式的密钥内容。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**返回值：**
+
+| 类型   |描述                   |
+| ------- | ----------- |
+| [DataBlob](#datablob) | 用于查看密钥的具体内容。|
+
+**示例：**
+
+```js
+console.info("key format:" + key.format);
+console.info("key algName:" + key.algName);
+var encodedKey = key.getEncoded();
+console.info("key encoded:" + Uint8ArrayToShowStr(encodedKey.data));
+```
+
+## PriKey
+
+私钥，是Key的子类，在非对称加解密、签名、密钥协商时需要将其作为输入使用。私钥可以通过非对称密钥生成器AsyKeyGenerator来生成。
+
+### 属性
+
+**系统能力：** SystemCapability.Security.CryptoFramework 
+
+| 名称    | 类型   | 可读 | 可写 | 描述                   |
+| ------- | ------ | ---- | ---- | ---------------------- |
+| format | string | 是   | 否   | 密钥的格式。|
+| algName | string | 是   | 否   | 密钥对应的算法名（含长度）。|
+
+### getEncoded
+
+getEncoded() : DataBlob
+
+以同步方法，获取二进制形式的密钥内容。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**返回值：**
+
+| 类型   |描述                   |
+| ------- | ----------- |
+| [DataBlob](#datablob) | 用于查看密钥的具体内容。|
+
+**示例：**
+
+```js
+console.info("key format:" + key.format);
+console.info("key algName:" + key.algName);
+var encodedKey = key.getEncoded();
+console.info("key encoded:" + Uint8ArrayToShowStr(encodedKey.data));
+```
+
+### clearMem
+
+clearMem() : void
+
+以同步方法，将系统底层内存中的的密钥内容清零。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**示例：**
+
+```js
+key.clearMem();
+```
+
+## cryptoFramework.createSymKeyGenerator
+
+createSymKeyGenerator(algName : string) : SymKeyGenerator
+
+通过指定算法名称的字符串，获取相应的对称密钥生成器实例。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名  | 类型   | 必填 | 说明                             |
+| ------- | ------ | ---- | ----------------------------- |
+| algName | string | 是   | 待生成对称密钥生成器的算法名称。 |
+
+**返回值：**
+
+| 类型            | 说明                       |
+| ----------------------------------- | -------------------------- |
+| [SymKeyGenerator](#symkeygenerator) | 返回对称密钥生成器的对象。 |
+
+## SymKeyGenerator
+
+对称密钥生成器。在使用该类的方法前，需要先使用[createSymKeyGenerator](#cryptoframeworkcreatesymkeygenerator)方法构建一个symKeyGenerator实例。
+
+### 属性
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 名称    | 类型   | 可读 | 可写 | 描述                         |
+| ------- | ------ | ---- | ---- | ---------------------------- |
+| algName | string | 是   | 否   | 对称密钥生成器指定的算法名称。 |
+
+### generateSymKey
+
+generateSymKey(callback : AsyncCallback\<SymKey>) : void
+
+异步获取对称密钥生成器随机生成的密钥，通过注册回调函数获取结果。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 名称     | 类型               | 必填 | 说明                 |
+| -------- | ----------------- | ---- | ------------------- |
+| callback | AsyncCallback\<[SymKey](#symkey)> | 是  | 回调函数，用于获取对称密钥。 |
+
+**示例：**
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+let symAlgoName = '3DES192';
+let symKeyGenerator = cryptoFramework.createSymKeyGenerator(symAlgoName);
+symKeyGenerator.generateSymKey((err, symKey) => {
+    if (err) {
+        console.error('Failed to generate symKey');
+        return;
+    }
+    console.log('Generate symKey success, algName: ' + symKey.algName);
+})
+```
+
+### generateSymKey
+
+generateSymKey() : Promise\<SymKey>
+
+异步获取该对称密钥生成器随机生成的密钥，通过Promise获取结果。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**返回值：**
+
+| 类型                  | 说明                            |
+| --------------------- | ------------------------------- |
+| Promise\<[SymKey](#symkey)> | 使用Promise的方式获取对称密钥。 |
+
+**示例：**
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+let symAlgoName = 'AES128';
+let symKeyGenerator = cryptoFramework.createSymKeyGenerator(symAlgoName);
+symKeyGenerator.generateSymKey().then((symKey) => {
+    console.log('Generate symKey success, algName:' + symKey.algName);
+})
+```
+
+### convertKey
+
+convertKey(key : DataBlob, callback : AsyncCallback\<SymKey>) : void
+
+异步获取指定数据生成对称密钥，通过注册回调函数获取结果。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 名称     | 类型                | 必填 | 说明                  |
+| -------- | ----------------- | ---- | ---------------------- |
+| key      | [DataBlob](#datablob)  | 是   | 指定的对称密钥材料。         |
+| callback | AsyncCallback\<[SymKey](#symkey)> | 是   | 回调函数，用于获取对称密钥。 |
+
+**示例：**
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+function genKeyMaterialBlob() {
+  let arr = [
+    0xba, 0x3d, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
+    0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c,
+    0xba, 0x3b, 0xc2, 0x71, 0xab, 0xa0, 0x30, 0x72];    // keyLen = 192 (24 bytes)
+  let keyMaterial = new Uint8Array(arr);
+  return {data : keyMaterial};
+}
+
+let symAlgoName = '3DES192';
+let symKeyGenerator = cryptoFramework.createSymKeyGenerator(symAlgoName);
+let keyMaterialBlob = genKeyMaterialBlob();
+symKeyGenerator.convertKey(keyMaterial, (err,  symKey) => {
+    if (err) {
+        console.error('Failed to convert symKey');
+        return;
+    }
+    console.log('Convert symKey success, algName:' + symKey.algName);
+})
+```
+
+### convertKey
+
+convertKey(key : DataBlob) : Promise\<SymKey>
+
+异步获取指定数据生成对称密钥，通过Promise获取结果。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 名称 | 类型     | 必填 | 说明                 |
+| ---- | -------- | ---- | -------------------- |
+| key  | [DataBlob](#datablob) | 是   | 指定的密钥材料数据。 |
+
+**返回值：**
+
+| 类型                  | 说明                            |
+| --------------------- | ------------------------------- |
+| Promise\<[SymKey](#symkey)> | 使用Promise的方式获取对称密钥。 |
+
+**示例：**
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+function genKeyMaterialBlob() {
+  let arr = [
+    0xba, 0x3d, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
+    0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c,
+    0xba, 0x3b, 0xc2, 0x71, 0xab, 0xa0, 0x30, 0x72];    // keyLen = 192 (24 bytes)
+  let keyMaterial = new Uint8Array(arr);
+  return {data : keyMaterial};
+}
+
+let symAlgoName = '3DES192';
+let symKeyGenerator = cryptoFramework.createSymKeyGenerator(symAlgoName);
+let keyMaterialBlob = genKeyMaterialBlob();
+symKeyGenerator.convertKey(keyMaterial).then((symKey) => {
+    console.log('Convert symKey success, algName:' + symKey.algName);
+})
+```
+
+## cryptoFramework.createAsyKeyGenerator
+
+createAsyKeyGenerator(algName : string) : AsyKeyGenerator
+通过指定算法名称的字符串，获取相应的非对称密钥生成器实例。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名  | 类型   | 必填 | 说明                             |
+| ------- | ------ | ---- | -------------------------------- |
+| algName | string | 是   | 待生成对称密钥生成器的算法名称。 |
+
+**返回值：**
+
+| 类型            | 说明                       |
+| --------------- | -------------------------- |
+| asyKeyGenerator | 返回非对称密钥生成器的对象。 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let asyKeyGenerator = cryptoFramework.createAsyKeyGenerator("ECC256");
+```
+
+## AsyKeyGenerator
+
+非对称密钥生成器。在使用该类的方法前，需要先使用createAsyKeyGenerator()方法构建一个AsyKeyGenerator实例。
+
+### 属性
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+| 名称           | 类型           | 可读 | 可写 | 描述                              |
+| -------------- | -------------- | ---- | ---- | ----------------------------------|
+| algName        | string         | 是   | 否   | 非对称密钥生成器指定的算法名称。  |
+
+
+
+### generateKeyPair
+
+generateKeyPair(callback : AsyncCallback\<KeyPair>) : void;
+异步获取非对称密钥生成器随机生成的密钥，通过注册回调函数获取结果。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 名称     | 类型                       | 必填 | 说明                         |
+| -------- | -------------------------- | ---- | ---------------------------- |
+| callback | AsyncCallback\<KeyPair> | 是   | 回调函数，用于获取非对称密钥。 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let asyKeyGenerator = cryptoFramework.createAsyKeyGenerator("ECC256");
+asyKeyGenerator.generateKeyPair((err, keyPair) => {
+  if (err) {
+    console.error("generateKeyPair: error.");
+    return;
+  }
+  console.info("generateKeyPair: success.");
+})
+```
+
+
+### generateKeyPair
+
+generateKeyPair() : Promise\<KeyPair>
+异步获取该非对称密钥生成器随机生成的密钥，通过Promise获取结果。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**返回值：**
+
+| 类型                  | 说明                            |
+| --------------------- | ------------------------------- |
+| Promise\<KeyPair> | 使用Promise的方式获取非对称密钥。 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let asyKeyGenerator = cryptoFramework.createAsyKeyGenerator("ECC256");
+let keyGenPromise = asyKeyGenerator.generateKeyPair();
+keyGenPromise.then( keyPair => {
+  console.info("generateKeyPair success.");
+}).catch(error => {
+  console.error("generateKeyPair error.");
+});
+```
+
+### convertKey
+
+convertKey(pubKey : DataBlob, priKey : DataBlob, callback : AsyncCallback\<KeyPair\>) : void
+异步获取指定数据生成非对称密钥，通过注册回调函数获取结果。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 名称     | 类型                       | 必填 | 说明                         |
+| -------- | -------------------------- | ---- | ---------------------------- |
+| pubKey      | DataBlob                   | 否   | 指定的公钥材料。         |
+| priKey      | DataBlob                   | 否   | 指定的私钥材料。         |
+| callback | AsyncCallback\<KeyPair> | 是   | 回调函数，用于获取非对称密钥。 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let asyKeyGenerator = cryptoFramework.createAsyKeyGenerator("ECC256");
+asyKeyGenerator.convertKey(pubKey, priKey, (err, keyPair) => {
+  if (err) {
+    console.error("convertKey: error.");
+    return;
+  }
+  console.info("convertKey: success.");
+})
+```
+
+### convertKey
+
+convertKey(pubKey : DataBlob, priKey : DataBlob) : Promise\<KeyPair>
+异步获取指定数据生成非对称密钥，通过Promise获取结果。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 名称 | 类型     | 必填 | 说明                 |
+| ---- | -------- | ---- | -------------------- |
+| pubKey      | DataBlob                   | 否   | 指定的公钥材料。         |
+| priKey      | DataBlob                   | 否   | 指定的私钥材料。         |
+
+**返回值：**
+
+| 类型                  | 说明                            |
+| --------------------- | ------------------------------- |
+| Promise\<KeyPair> | 使用Promise的方式获取非对称密钥。 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let asyKeyGenerator = cryptoFramework.createAsyKeyGenerator("ECC256");
+let keyGenPromise = asyKeyGenerator.convertKey(pubKey, priKey);
+keyGenPromise.then( keyPair => {
+  console.info("convertKey success.");
+}).catch(error => {
+  console.error("convertKey error.");
+});
+```
+
+## cryptoFramework.createCipher
+
+createCipher(transformation : string) : Cipher
+通过指定算法名称，获取相应的[Cipher](#cipher)实例。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名         | 类型   |  必填  |  说明                                                         |
+| -------------- | ------ | -------- | ------------------------------------------------------------ |
+| transformation | string | 是   | 待生成Cipher的算法名称、加密模式以及填充方法的组合。输入可以为"RSA1024\|PKCS1", "RSA1024\|PKCS1_OAEP\|SHA256\|SHA256"等 |
+
+**返回值：**
+
+| 类型   | 说明                     |
+| ------ | ------------------------ |
+| [Cipher](#cipher) | 返回加解密生成器的对象。 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let cipherAlgoName = '3DES192|ECB|PKCS7';
+var cipher;
+try {
+  cipher = cryptoFramework.createCipher(cipherAlgoName);
+  console.info(`cipher algName: ${cipher.algName}`);
+} catch (error) {
+  console.error(`createCipher failed, ${error.code}, ${error.message}`);
+  return;
+}
+```
+
+## Cipher
+
+提供加解密的算法操作功能，按序调用本类中的[init()](#init-2)、[update()](#update-4)、[doFinal()](#dofinal-2)方法，可以实现对称加密/对称解密/非对称加密/非对称解密。
+
+### 属性
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+
+| 名称    | 类型   | 可读  | 可写  | 描述                         |
+| ------- | ------ | -------- | ----------- | ---------------------------- |
+| algName | string | 是   | 否   | 加解密生成器指定的算法名称。 |
+
+### init
+
+init(opMode : CryptoMode, key : Key, params : ParamsSpec, callback : AsyncCallback\<void>) : void
+
+初始化加解密的[cipher](#cipher)对象，通过注册回调函数获取结果。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 名称     | 类型                     | 必填    | 说明                     |
+| -------- | ------------------------ | ------- | ------------------------ |
+| opMode   | [CryptoMode](#cryptomode)      | 是   | 加密或者解密模式。       |
+| key      | [Key](#key)           | 是   | 指定加密或解密的密钥。   |
+| params   | [ParamsSpec](#paramsspec)               | 是   | 指定加密或解密的参数。   |
+| callback | AsyncCallback\<void> | 是   | 回调函数。 |
+
+**示例：**
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+let symKey;     // 此处省略生成对称密钥的过程
+let cipher;         // 此处省略生成cipher实例的过程
+cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null, (err, ) => {
+  if (err) {
+    console.error('Failed to init cipher');
+    return;
+  }
+  console.log('Init cipher success');
+  // 此处进行update等后续操作
+})
+```
+
+### init
+
+init(opMode : CryptoMode, key : Key, params : ParamsSpec) : Promise\<void>
+
+初始化加解密的cipher对象，通过Promise获取结果。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 名称   | 类型       | 必填 | 说明                   |
+| ------ | ---------- | ---- | ---------------------- |
+| opMode |  [CryptoMode](#cryptomode)  | 是   | 加密或者解密模式。     |
+| key    |  [Key](#key)       | 是   | 指定加密或解密的密钥。 |
+| params | [ParamsSpec](#paramsspec) | 是   | 指定加密或解密的参数，对于ECB等没有参数的算法模式，可以传入null。 |
+
+**返回值：**
+
+| 类型                | 说明                        |
+| ------------------- | --------------------------- |
+| Promise\<void> | 使用Promise的方式获取结果。 |
+
+**示例：**
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+let symKey;     // 此处省略生成对称密钥的过程
+let cipher;         // 此处省略生成cipher实例的过程
+cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null).then(() => {
+  console.log('Init cipher success');
+  // 此处进行update等后续操作
+})
+```
+
+### update
+
+update(data : DataBlob, callback : AsyncCallback\<DataBlob>) : void
+
+分段更新加密或者解密数据操作，通过注册回调函数获取加密或者解密数据。（根据数据量，可不调用update或调用多次update）
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 名称     | 类型                         | 必填 | 说明                                       |
+| -------- | ---------------------------- | ---- | ------------------------------------------ |
+| data     | [DataBlob](#datablob)                  | 是   | 加密或者解密的数据。                       |
+| callback | AsyncCallback\<[DataBlob](#datablob)> | 是   | 回调函数，用于获取加密或者解密的数据结果。 |
+
+**示例：**
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+function stringToUint8Array(str) {
+  let arr = [];
+  for (let i = 0, j = str.length; i < j; ++i) {
+    arr.push(str.charCodeAt(i));
+  }
+  return new Uint8Array(arr);
+}
+
+let cipher;         // 此处省略生成cipher实例的过程
+// 此处省略init()过程
+let plainText = {data : stringToUint8Array('this is test!')};
+cipher.update(plainText, (err, output) => {       // 加密过程举例
+  if (err) {
+    console.error('Failed to update cipher');
+    return;
+  }
+  console.log('Update cipher success');
+  // 此处进行doFinal等后续操作
+})
+```
+
+### update
+
+update(data : DataBlob) : Promise\<DataBlob>
+
+分段更新加密或者解密数据操作，通过Promise获取结果。（根据数据量，可不调用update或调用多次update）
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 名称 | 类型     | 必填 | 说明                 |
+| ---- | -------- | ---- | -------------------- |
+| data |  [DataBlob](#datablob) | 是   | 加密或者解密的数据。 |
+
+**返回值：**
+
+| 类型                    | 说明                        |
+| ----------------------- | --------------------------- |
+| Promise\<[DataBlob](#datablob)> | 使用Promise的方式获取结果。 |
+
+**示例：**
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+function stringToUint8Array(str) {
+  let arr = [];
+  for (let i = 0, j = str.length; i < j; ++i) {
+    arr.push(str.charCodeAt(i));
+  }
+  return new Uint8Array(arr);
+}
+
+let cipher;         // 此处省略生成cipher实例的过程
+// 此处省略init()过程
+let plainText = {data : stringToUint8Array('this is test!')};
+cipher.update(data).then((output) => {
+  console.log('Update cipher success');
+  // 此处进行doFinal等后续操作
+})
+```
+
+### doFinal
+
+doFinal(data : DataBlob, callback : AsyncCallback\<DataBlob>) : void
+
+最后结束加密或者解密数据操作，通过注册回调函数获取加密或者解密数据。如果在本次加解密过程中已经使用[update](#update-4)传入过数据，可以在doFinal的data参数处传入null。<br/>根据对称加解密的模式不同，doFinal的输出可能不同。<br/>对于GCM和CCM模式的对称加密，在doFinal完成后需要将其结果暂存作为解密时的authTag。<br/>对于其他模式的对称加解密，存在两种情况（1）update输出一部分加解密结果，doFinal输出剩余加解密结果；（2）update输出加解密结果全部由update输出，doFinal输出空。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 名称     | 类型                         | 必填 | 说明                                       |
+| -------- | ---------------------------- | ---- | ------------------------------------------ |
+| data     |  [DataBlob](#datablob)                     | 是   | 加密或者解密的数据。                       |
+| callback | AsyncCallback\<[DataBlob](#datablob)> | 是   | 回调函数，用于获取加密或者解密的数据结果。 |
+
+**示例：**
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+let cipher;         // 此处省略生成cipher实例的过程
+let data;           // 此处省略准备待加密/解密数据的过程
+// 此处省略init()和update()过程
+cipher.doFinal(data, (err, output) => {
+  if (err) {
+    console.error('Failed to final cipher');
+    return;
+  }
+  console.log('Final cipher success');
+})
+```
+
+### doFinal
+
+doFinal(data : DataBlob) : Promise\<DataBlob>
+
+最后结束加密或者解密数据操作，通过Promise获取结果。如果在本次加解密过程中已经使用update传入过数据，可以在doFinal的data参数处传入null。
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 名称 | 类型     | 必填 | 说明                 |
+| ---- | -------- | ---- | -------------------- |
+| data | [DataBlob](#datablob) | 是   | 加密或者解密的数据。 |
+
+**返回值：**
+
+| 类型                    | 说明                        |
+| ----------------------- | --------------------------- |
+| Promise\<[DataBlob](#datablob)> | 使用Promise的方式获取结果。 |
+
+**示例：**
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+let cipher;         // 此处省略生成cipher实例的过程
+let data;           // 此处省略准备待加密/解密数据的过程
+// 此处省略init()和update()过程
+cipher.doFinal(data).then((output) => {
+    console.log('Final cipher success');
+})
+```
+
+**callback示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let rsaGenerator = cryptoFramework.createAsyKeyGenerator("RSA1024|PRIMES_2");
+let cipher = cryptoFramework.createCipher("RSA1024|PKCS1");
+rsaGenerator.generateKeyPair(function (err, keyPair) {
+  let pubKey = keyPair.pubKey;
+  cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, pubKey, null, function (err, data) {
+    let input = {data : stringToUint8Array(plan) };
+    cipher.doFinal(input, function (err, data) {
+      AlertDialog.show({ message : "EncryptOutPut is " + data.data} );
+    });
+  });
+});
+```
+
+**promise示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let rsaGenerator = cryptoFramework.createAsyKeyGenerator("RSA1024|PRIMES_2");
+let cipher = cryptoFramework.createCipher("RSA1024|PKCS1");
+let keyGenPromise = rsaGenerator.generateKeyPair();
+keyGenPromise.then(rsaKeyPair => {
+  let pubKey = rsaKeyPair.pubKey;
+  return cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, pubKey, null); // 传入私钥和DECRYPT_MODE可初始化解密模式
+}).then(() => {
+  let input = { data : stringToUint8Array(plan) };
+  return cipher.doFinal(input);
+}).then(dataBlob => {
+  console.info("EncryptOutPut is " + dataBlob.data);
+});
+```
+
+
+## cryptoFramework.createSign
+
+createSign(algName : string) : Sign
+
+Sign实例生成
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名  | 类型   | 必填 | 说明                                                         |
+| ------- | ------ | ---- | ------------------------------------------------------------ |
+| algName | string | 是   | 指定签名算法：RSA或ECC，使用RSA PKCS1模式时需要设置摘要，使用RSA PSS模式时需要设置摘要和掩码摘要 |
+
+**返回值**：
+
+| 类型 | 说明                           |
+| ---- | ------------------------------ |
+| Sign   | 返回由输入算法指定生成的Sign对象 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let signer1 = cryptoFramework.createSign("RSA1024|PKCS1|SHA256");
+
+let singer2 = cryptoFramework.createSign("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256")
+```
+
+## Sign
+
+Sign类，使用Sign方法之前需要创建该类的实例进行操作，通过createSign(algName : string) : Sign方法构造此实例。
+
+### init
+
+init(priKey : PriKey, callback : AsyncCallback\<void>) : void
+
+使用私钥初始化Sign对象，Callback形式
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名   | 类型                  | 必填 | 说明               |
+| -------- | --------------------- | ---- | ------------------ |
+| priKey   | Key |是| 用于Sign的初始化 |
+| callback | AsyncCallback\<void> | 是   | 回调函数的 |
+
+### init
+
+init(opMode : CryptoMode, key : Key, params : ParamsSpec) : Promise\<void>
+
+使用私钥初始化Sign对象，Promise形式
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名   | 类型                  | 必填 | 说明               |
+| -------- | --------------------- | ---- | ------------------ |
+| priKey   | Key |是| 用于Sign的初始化 |
+
+**返回值：**
+
+| 类型          | 说明        |
+| ------------- | ----------- |
+| Promise<void> | Promise对象 |
+
+### update
+
+update(data : DataBlob, callback : AsyncCallback\<void>) : void
+
+追加待签名数据，callback方式
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名   | 类型                  | 必填 | 说明               |
+| -------- | --------------------- | ---- | ------------------ |
+| data    | DataBlob              | 是   | 传入的消息         |
+| callback | AsyncCallback<void> | 是   | 回调函数 |
+
+### update
+
+update(data : DataBlob) : Promise\<void>;
+
+追加待签名数据，promise方式
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名 | 类型     | 必填 | 说明       |
+| ------ | -------- | ---- | ---------- |
+| data  | DataBlob | 是   | 传入的消息 |
+
+**返回值：**
+
+| 类型          | 说明        |
+| ------------- | ----------- |
+| Promise\<void> | Promise对象 |
+
+### sign
+
+sign(data : DataBlob, callback : AsyncCallback\<DataBlob>) : void
+
+对数据进行签名，返回签名结果，callback方式
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名   | 类型                  | 必填 | 说明               |
+| -------- | --------------------- | ---- | ------------------ |
+| data    | DataBlob              | 是   | 传入的消息         |
+| callback | AsyncCallback\<void> | 是   | 回调函数 |
+
+### sign
+
+sign(data : DataBlob) : Promise\<DataBlob>
+
+对数据进行签名，返回签名结果，promise方式
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名 | 类型     | 必填 | 说明       |
+| ------ | -------- | ---- | ---------- |
+| data  | DataBlob | 是   | 传入的消息 |
+
+**返回值：**
+
+| 类型          | 说明        |
+| ------------- | ----------- |
+| Promise\<void> | Promise对象 |
+
+**callback示例：**
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let rsaGenerator = cryptoFramework.createAsyKeyGenerator("RSA1024|PRIMES_2");
+let signer = cryptoFramework.createSign("RSA1024|PKCS1|SHA256");
+rsaGenerator.generateKeyPair(function (err, keyPair) {
+  globalKeyPair = keyPair;
+  let priKey = globalKeyPair.priKey;
+  signer.init(priKey, function (err, data) {
+    signer.update(input1, function (err, data) {
+      signer.sign(input2, function (err, data) {
+        SignMessageBlob = data;
+        console.info("sign output is " + SignMessageBlob.data); 
+      });
+    });
+  });
+});
+```
+
+**promise示例：**
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let rsaGenerator = cryptoFramework.createAsyKeyGenerator("RSA1024|PRIMES_2");
+let signer = cryptoFramework.createSign("RSA1024|PKCS1|SHA256");
+let keyGenPromise = rsaGenerator.generateKeyPair();
+keyGenPromise.then( keyPair => {
+  globalKeyPair = keyPair;
+  let priKey = globalKeyPair.priKey;
+  return signer.init(priKey);
+}).then(() => {
+  return signer.update(input1);
+}).then(() => {
+  return signer.sign(input2);
+}).then(dataBlob => {
+  SignMessageBlob = dataBlob;
+  console.info("sign output is " + SignMessageBlob.data);
+});
+```
+
+## cryptoFramework.createVerify
+
+createVerify(algName : string) : Verify
+
+Verify实例生成
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名  | 类型   | 必填 | 说明                                                         |
+| ------- | ------ | ---- | ------------------------------------------------------------ |
+| algName | string | 是   | 指定签名算法：RSA或ECC，使用RSA PKCS1模式时需要设置摘要，使用RSA PSS模式时需要设置摘要和掩码摘要 |
+
+**返回值**：
+
+| 类型 | 说明                           |
+| ---- | ------------------------------ |
+| Verify   | 返回由输入算法指定生成的Verify对象 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let verifyer1 = cryptoFramework.createVerify("RSA1024|PKCS1|SHA256");
+
+let verifyer2 = cryptoFramework.createVerify("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256")
+```
+## Verify
+
+Verify类，使用Verify方法之前需要创建该类的实例进行操作，通过createVerify(algName : string) : Verify方法构造此实例。
+
+### init
+
+init(pubKey : PubKey, callback : AsyncCallback\<void>) : void
+
+传入私钥初始化Verify对象，Callback形式
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名   | 类型                  | 必填 | 说明               |
+| -------- | --------------------- | ---- | ------------------ |
+| pubKey   | Key |是| 公钥对象，用于Verify的初始化 |
+| callback | AsyncCallback\<void> | 是   | 回调函数 |
+
+### init
+init(pubKey : PubKey) : Promise\<void>
+
+传入私钥初始化Verify对象，Promise形式
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名   | 类型                  | 必填 | 说明               |
+| -------- | --------------------- | ---- | ------------------ |
+| pubKey   | Key |是|公钥对象，用于Verify的初始化 |
+
+**返回值：**
+
+| 类型            | 说明         |
+| --------------- | ------------ |
+| Promise\<void> | Promise对象 |
+
+### update
+
+update(data : DataBlob, callback : AsyncCallback\<void>) : void
+
+追加待验签数据，callback方式
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名   | 类型                  | 必填 | 说明               |
+| -------- | --------------------- | ---- | ------------------ |
+| data    | DataBlob              | 是   | 传入的消息         |
+| callback | AsyncCallback\<void> | 是   | 回调函数 |
+
+### update
+
+update(data : DataBlob) : Promise\<void>;
+
+追加待验签数据，promise方式
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名 | 类型     | 必填 | 说明       |
+| ------ | -------- | ---- | ---------- |
+| data  | DataBlob | 是   | 传入的消息 |
+
+**返回值：**
+
+| 类型          | 说明        |
+| ------------- | ----------- |
+| Promise\<void> | Promise对象 |
+
+### verify
+
+verify(data : DataBlob, signatureData : DataBlob, callback : AsyncCallback\<boolean>) : void
+
+对数据进行签名，返回签名结果，callback方式
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名   | 类型                  | 必填 | 说明               |
+| -------- | --------------------- | ---- | ------------------ |
+| data    | DataBlob              | 是   | 传入的消息         |
+| signatureData    | DataBlob              | 是   | 签名数据        |
+| callback | AsyncCallback\<void> | 是   | 回调函数 |
+
+### verify
+
+verify(data : DataBlob, signatureData : DataBlob) : Promise\<boolean>
+
+对数据进行签名，返回签名结果，promise方式
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名 | 类型     | 必填 | 说明       |
+| ------ | -------- | ---- | ---------- |
+| data  | DataBlob | 是   | 传入的消息 |
+| signatureData    | DataBlob| 是 | 签名数据 |
+
+**返回值：**
+
+| 类型            | 说明         |
+| --------------- | ------------ |
+| Promise\<boolean> | 异步返回值，代表验签是否通过|
+
+**callback示例：**
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let verifyer = cryptoFramework.createVerify("RSA1024|PKCS1|SHA25");
+verifyer.init(globalKeyPair.pubKey, function (err, data) {
+  verifyer.update(input1, function(err, data) {
+    verifyer.verify(input2, SignMessageBlob, function(err, data) {
+      console.info("verify result is " + data);
+    })
+  });
+})
+```
+
+**promise示例：**
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let verifyer = cryptoFramework.createVerify("RSA1024|PKCS1|SHA256");
+let verifyInitPromise = verifyer.init(globalKeyPair.pubKey);
+verifyInitPromise.then(() => {
+  return verifyer.update(input1);
+}).then(() => {
+  return verifyer.verify(input2, SignMessageBlob);
+}).then(res => {
+  console.log("Verify result is " + res);
+});
+```
+## cryptoFramework.createKeyAgreement
+
+createKeyAgreement(algName : string) : KeyAgreement
+
+KeyAgreement实例生成
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名  | 类型   | 必填 | 说明                                                         |
+| ------- | ------ | ---- | ------------------------------------------------------------ |
+| algName | string | 是   | 指定密钥协商算法：目前仅支持ECC |
+
+**返回值**：
+
+| 类型 | 说明                           |
+| ---- | ------------------------------ |
+| KeyAgreement   | 返回由输入算法指定生成的KeyAgreement对象 |
+
+**示例：**
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let keyAgreement = cryptoFramework.createKeyAgreement("ECC256");
+
+```
+
+## KeyAgreement
+
+KeyAgreement类，使用密钥协商方法之前需要创建该类的实例进行操作，通过createKeyAgreement(algName : string) : KeyAgreement方法构造此实例。
+
+### generateSecret
+
+generateSecret(priKey : PriKey, pubKey : PubKey, callback : AsyncCallback\<DataBlob>) : void
+
+基于传入的私钥与公钥进行密钥协商，返回共享秘密，Callback形式
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名   | 类型                  | 必填 | 说明               |
+| -------- | --------------------- | ---- | ------------------ |
+| priKey   | PriKey |是| 设置密钥协商的私钥输入 |
+| pubKey   | PubKey |是| 设置密钥协商的公钥输入 |
+| callback | AsyncCallback\<DataBlob> | 是   | 异步接受共享秘密的回调 |
+
+### generateSecret
+generateSecret(priKey : PriKey, pubKey : PubKey) : Promise\<DataBlob>
+
+基于传入的私钥与公钥进行密钥协商，返回共享秘密，Promise形式
+
+**系统能力：** SystemCapability.Security.CryptoFramework
+
+**参数：**
+
+| 参数名   | 类型                  | 必填 | 说明               |
+| -------- | --------------------- | ---- | ------------------ |
+| priKey   | PriKey |是| 设置密钥协商的私钥输入 |
+| pubKey   | PubKey |是| 设置密钥协商的公钥输入 |
+
+**返回值：**
+
+| 类型            | 说明         |
+| --------------- | ------------ |
+| Promise\<DataBlob> | 共享秘密 |
+
+**callback示例：**
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let keyAgreement = cryptoFramework.createKeyAgreement("ECC256");
+keyAgreement.generateSecret(globalKeyPair.priKey, globalKeyPair.pubKey, function (err, secret) {
+  if (err) {
+    console.error("keyAgreement error.");
+    return;
+  }
+  console.info("keyAgreement output is " + secret.data);
+});
+```
+
+**promise示例：**
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let keyAgreement = cryptoFramework.createKeyAgreement("ECC256");
+let keyAgreementPromise = keyAgreement.generateSecret(globalKeyPair.priKey, globalKeyPair.pubKey);
+keyAgreementPromise.then((secret) => {
+  console.info("keyAgreement output is " + secret.data);
+}).catch((error) => {
+  console.error("keyAgreement error.");
+});
+```
+## cryptoFramework.createX509Cert
+
+createX509Cert(inStream : EncodingBlob, callback : AsyncCallback\<X509Cert>) : void
+
+表示创建X509证书对象。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明               |
+| -------- | ------------- | ---- | ------------------ |
+| inStream | EncodingBlob  | 是   | X509证书序列化数据 |
+| callback | AsyncCallback\<X509Cert> | 否   | 回调函数。表示X509证书对象           |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+    }
+});
+```
+
+## cryptoFramework.createX509Cert
+
+createX509Cert(inStream : EncodingBlob) : Promise\<X509Cert>
+
+表示创建X509证书对象。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型         | 必填 | 说明               |
+| -------- | ------------ | ---- | ------------------ |
+| inStream | EncodingBlob | 是   | X509证书序列化数据 |
+
+**返回值**：
+
+| 类型     | 说明             |
+| :------- | ---------------- |
+| X509Cert | 表示X509证书对象 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob).then(x509Cert => {
+    Console.log("createX509Cert success");
+}, error => {
+    Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+## X509Cert
+
+X509证书类。
+
+### verify
+
+verify(key : PubKey, callback : AsyncCallback\<void>) : void
+
+表示对证书验签。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明               |
+| -------- | ------------- | ---- | ------------------ |
+| key      | PubKey        | 是   | 用于验签的公钥对象 |
+| callback | AsyncCallback\<void>) | 否   | 回调函数。使用AsyncCallback的第一个error参数判断是否验签成功，error为null表示成功，不为null表示失败           |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        // 业务需通过AsyKeyGenerator生成PubKey或通过上级X509Cert证书对象的getPublicKey获取PubKey
+		let pubKey = null;
+        x509Cert.verify(pubKey, function (error, data) {
+            if (error != null) {
+                Console.log("verify failed, errCode: " + error.code + ", errMsg: " + error.message);
+            } else {
+                Console.log("verify success");
+            }
+        });
+    }
+});
+```
+
+### verify
+
+verify(key : PubKey) : Promise\<void>
+
+表示对证书验签。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名 | 类型   | 必填 | 说明               |
+| ------ | ------ | ---- | ------------------ |
+| key    | PubKey | 是   | 用于验签的公钥对象 |
+
+**返回值**：
+
+| 类型 | 说明                                                         |
+| ---- | ------------------------------------------------------------ |
+| Promise\<void> | Promise对象 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob).then(x509Cert => {
+    Console.log("createX509Cert success");
+    // 业务需通过AsyKeyGenerator生成PubKey或通过上级X509Cert证书对象的getPublicKey获取PubKey
+	let pubKey = null;
+    x509Cert.verify(pubKey).then(result => {
+        Console.log("verify success");
+    }, error => {
+        Console.log("verify failed, errCode: " + error.code + ", errMsg: " + error.message);
+    });
+}, error => {
+    Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+### getEncoded
+
+getEncoded(callback : AsyncCallback\<EncodingBlob>) : void
+
+表示获取X509证书序列化数据。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明     |
+| -------- | ------------- | ---- | -------- |
+| callback | AsyncCallback\<EncodingBlob> | 否   | 回调函数。表示X509证书序列化数据 |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        x509Cert.getEncoded(function (error, data) {
+           if (error != null) {
+               Console.log("getEncoded failed, errCode: " + error.code + ", errMsg: " + error.message);
+           } else {
+               Console.log("getEncoded success");
+           }
+        });
+    }
+});
+```
+
+### getEncoded
+
+getEncoded() : Promise\<EncodingBlob>
+
+表示获取X509证书序列化数据。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型         | 说明                   |
+| ------------ | ---------------------- |
+| Promise\<EncodingBlob> | 表示X509证书序列化数据 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob).then(x509Cert => {
+    Console.log("createX509Cert success");
+    x509Cert.getEncoded().then(result => {
+        Console.log("getEncoded success");
+    }, error => {
+        Console.log("getEncoded failed, errCode: " + error.code + ", errMsg: " + error.message);
+    });
+}, error => {
+    Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+### getPublicKey
+
+getPublicKey(callback : AsyncCallback\<PubKey>) : void
+
+表示获取X509证书公钥。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明     |
+| -------- | ------------- | ---- | -------- |
+| callback | AsyncCallback | 否   | 回调函数，X509证书公钥对象 |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        x509Cert.getPublicKey(function (error, pubKey) {
+           if (error != null) {
+               Console.log("getPublicKey failed, errCode: " + error.code + ", errMsg: " + error.message);
+           } else {
+               Console.log("getPublicKey success");
+           }
+        });
+    }
+});
+```
+
+### getPublicKey
+
+getPublicKey() : Promise\<PubKey>
+
+表示获取X509证书公钥。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明             |
+| ------ | ---------------- |
+| PubKey | X509证书公钥对象 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob).then(x509Cert => {
+    Console.log("createX509Cert success");
+    x509Cert.getPublicKey().then(pubKey => {
+        Console.log("getPublicKey success");
+    }, error => {
+        Console.log("getPublicKey failed, errCode: " + error.code + ", errMsg: " + error.message);
+    });
+}, error => {
+    Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+### checkValidityWithDate
+
+checkValidityWithDate(date: string, callback : AsyncCallback\<void>) : void
+
+表示检查X509证书有效期。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明     |
+| -------- | ------------- | ---- | -------- |
+| date     | string        | 是   | 日期     |
+| callback | AsyncCallback\<void> | 否   | 回调函数。使用AsyncCallback的第一个error参数判断是否检查成功，error为null表示成功，不为null表示失败 |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let date = "150527000001Z";
+        x509Cert.checkValidityWithDate(date, function (error, data) {
+           if (error != null) {
+               Console.log("checkValidityWithDate failed, errCode: " + error.code + ", errMsg: " + error.message);
+           } else {
+               Console.log("checkValidityWithDate success");
+           }
+        });
+    }
+});
+```
+
+### checkValidityWithDate
+
+checkValidityWithDate(date: string) : Promise\<void>
+
+表示检查X509证书有效期。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名 | 类型   | 必填 | 说明 |
+| ------ | ------ | ---- | ---- |
+| date   | string | 是   | 日期 |
+
+**返回值**：
+
+| 类型 | 说明                                                         |
+| ---- | ------------------------------------------------------------ |
+| void | 使用AsyncCallback的第一个error参数判断是否检查成功，error为null表示成功，不为null表示失败 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob).then(x509Cert => {
+    Console.log("createX509Cert success");
+    let date = "150527000001Z";
+    x509Cert.checkValidityWithDate(date).then(result => {
+        Console.log("checkValidityWithDate success");
+    }, error => {
+        Console.log("checkValidityWithDate failed, errCode: " + error.code + ", errMsg: " + error.message);
+    });
+}, error => {
+    Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+### getVersion
+
+getVersion() : number
+
+表示获取X509证书版本。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明             |
+| ------ | ---------------- |
+| number | 表示X509证书版本 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let version = x509Cert.getVersion();
+    }
+});
+```
+
+### getSerialNumber
+
+getSerialNumber() : number
+
+表示获取X509证书序列号。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明               |
+| ------ | ------------------ |
+| number | 表示X509证书序列号 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let serialNumber = x509Cert.getSerialNumber();
+    }
+});
+```
+
+### getIssuerName
+
+getIssuerName() : DataBlob
+
+表示获取X509证书颁发者名称。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型     | 说明                   |
+| -------- | ---------------------- |
+| DataBlob | 表示X509证书颁发者名称 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let issuerName = x509Cert.getIssuerName();
+    }
+});
+```
+
+### getSubjectName
+
+getSubjectName() : DataBlob
+
+表示获取X509证书主体名称。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型     | 说明                 |
+| -------- | -------------------- |
+| DataBlob | 表示X509证书主体名称 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let subjectName = x509Cert.getSubjectName();
+    }
+});
+```
+
+### getNotBeforeTime
+
+getNotBeforeTime() : string
+
+表示获取X509证书有效期起始时间。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                       |
+| ------ | -------------------------- |
+| string | 表示X509证书有效期起始时间 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let notBefore = x509Cert.getNotBeforeTime();
+    }
+});
+```
+
+### getNotAfterTime
+
+getNotAfterTime() : string
+
+表示获取X509证书有效期截止时间。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                       |
+| ------ | -------------------------- |
+| string | 表示X509证书有效期截止时间 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let notAfter = x509Cert.getNotAfterTime();
+    }
+});
+```
+
+### getSignature
+
+getSignature() : DataBlob
+
+表示获取X509证书签名数据。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型     | 说明                 |
+| -------- | -------------------- |
+| DataBlob | 表示X509证书签名数据 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let signature = x509Cert.getSignature();
+    }
+});
+```
+
+### getSignatureAlgName
+
+getSignatureAlgName() : string
+
+表示获取X509证书签名算法名称。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                     |
+| ------ | ------------------------ |
+| string | 表示X509证书签名算法名称 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let sigAlgName = x509Cert.getSignatureAlgName();
+    }
+});
+```
+
+### getSignatureAlgOid
+
+getSignatureAlgOid() : string
+
+表示获取X509证书签名算法OID。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                    |
+| ------ | ----------------------- |
+| string | 表示X509证书签名算法OID |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let sigAlgOid = x509Cert.getSignatureAlgOid();
+    }
+});
+```
+
+### getSignatureAlgParams
+
+getSignatureAlgParams() : DataBlob
+
+表示获取X509证书签名算法参数。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型     | 说明                     |
+| -------- | ------------------------ |
+| DataBlob | 表示X509证书签名算法参数 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let sigAlgParams = x509Cert.getSignatureAlgParams();
+    }
+});
+```
+
+### getKeyUsage
+
+getKeyUsage() : DataBlob
+
+表示获取X509证书秘钥用途。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型     | 说明                 |
+| -------- | -------------------- |
+| DataBlob | 表示X509证书秘钥用途 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let keyUsage = x509Cert.getKeyUsage();
+    }
+});
+```
+
+### getExtKeyUsage
+
+getExtKeyUsage() : DataArray
+
+表示获取X509证书扩展秘钥用途。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型      | 说明                     |
+| --------- | ------------------------ |
+| DataArray | 表示X509证书扩展秘钥用途 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let extKeyUsage = x509Cert.getExtKeyUsage();
+    }
+});
+```
+
+### getBasicConstraints
+
+getBasicConstraints() : number
+
+表示获取X509证书基本约束。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                 |
+| ------ | -------------------- |
+| number | 表示X509证书基本约束 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let basicConstraints = x509Cert.getBasicConstraints();
+    }
+});
+```
+
+### getSubjectAltNames
+
+getSubjectAltNames() : DataArray
+
+表示获取X509证书主体可选名称。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型      | 说明                     |
+| --------- | ------------------------ |
+| DataArray | 表示X509证书主体可选名称 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let subjectAltNames = x509Cert.getSubjectAltNames();
+    }
+});
+```
+
+### getIssuerAltNames
+
+getIssuerAltNames() : DataArray
+
+表示获取X509证书颁发者可选名称。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型      | 说明                       |
+| --------- | -------------------------- |
+| DataArray | 表示X509证书颁发者可选名称 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Cert(encodingBlob, function (error, x509Cert) {
+    if (error != null) {
+        Console.log("createX509Cert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Cert success");
+        let issuerAltNames = x509Cert.getIssuerAltNames();
+    }
+});
+```
+
+## cryptoFramework.createX509Crl
+
+createX509Crl(inStream : EncodingBlob, callback : AsyncCallback\<X509Crl>) : void
+
+表示创建X509证书吊销列表的对象。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明                       |
+| -------- | ------------- | ---- | -------------------------- |
+| inStream | EncodingBlob  | 是   | 表示证书吊销列表序列化数据 |
+| callback | AsyncCallback\<X509Crl> | 否   | 回调函数。表示证书吊销列表对象                   |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+    }
+});
+```
+
+## cryptoFramework.createX509Crl
+
+createX509Crl(inStream : EncodingBlob) : Promise\<X509Crl>
+
+表示创建X509证书吊销列表的对象。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型         | 必填 | 说明                       |
+| -------- | ------------ | ---- | -------------------------- |
+| inStream | EncodingBlob | 是   | 表示证书吊销列表序列化数据 |
+
+**返回值**：
+
+| 类型    | 说明                 |
+| ------- | -------------------- |
+| Promise\<X509Crl> | 表示证书吊销列表对象 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob).then(x509Crl => {
+    Console.log("createX509Crl success");
+}, error => {
+    Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+## X509Crl
+
+X509证书吊销列表对象。
+
+### isRevoked
+
+isRevoked(cert : X509Cert, callback : AsyncCallback\<boolean>) : void
+
+表示检查证书是否吊销。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明                 |
+| -------- | ------------- | ---- | -------------------- |
+| cert     | X509Cert      | 是   | 表示被检查的证书对象 |
+| callback | AsyncCallback\<boolean> | 否   | 回调函数。表示证书吊销状态，true表示已吊销，false表示未吊销             |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        // 业务需自行生成X509Cert证书对象
+        let x509Cert = null;
+        x509Crl.isRevoked(x509Cert, function (error, isRevoked) {
+           if (error != null) {
+               Console.log("call isRevoked failed, errCode: " + error.code + ", errMsg: " + error.message);
+           } else {
+               Console.log("call isRevoked success");
+           }
+        });
+    }
+});
+```
+
+### isRevoked
+
+isRevoked(cert : X509Cert) : Promise\<boolean>
+
+表示检查证书是否吊销。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名 | 类型     | 必填 | 说明                 |
+| ------ | -------- | ---- | -------------------- |
+| cert   | X509Cert | 是   | 表示被检查的证书对象 |
+
+**返回值**：
+
+| 类型    | 说明                                              |
+| ------- | ------------------------------------------------- |
+| Promise\<boolean> | 表示证书吊销状态，true表示已吊销，false表示未吊销 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob).then(x509Crl => {
+    Console.log("createX509Crl success");
+    // 业务需自行生成X509Cert证书对象
+    let x509Cert = null;
+    x509Crl.isRevoked(x509Cert).then(isRevoked => {
+        Console.log("call isRevoked success");
+    }, error => {
+        Console.log("call isRevoked failed, errCode: " + error.code + ", errMsg: " + error.message);
+    });
+}, error => {
+    Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+### getType
+
+getType() : string
+
+表示获取证书吊销列表类型。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                 |
+| ------ | -------------------- |
+| string | 表示证书吊销列表类型 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        let type = x509Crl.getType();
+    }
+});
+```
+
+### getEncoded
+
+getEncoded(callback : AsyncCallback\<EncodingBlob>) : void
+
+表示获取X509证书吊销列表的序列化数据。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明     |
+| -------- | ------------- | ---- | -------- |
+| callback |  AsyncCallback\<EncodingBlob> | 否   | 回调函数，表示X509证书吊销列表的序列化数据 |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        x509Crl.getEncoded(function (error, data) {
+           if (error != null) {
+               Console.log("getEncoded failed, errCode: " + error.code + ", errMsg: " + error.message);
+           } else {
+               Console.log("getEncoded success");
+           }
+        });
+    }
+});
+```
+
+### getEncoded
+
+getEncoded() : Promise\<EncodingBlob>
+
+表示获取X509证书吊销列表的序列化数据。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型         | 说明                             |
+| ------------ | -------------------------------- |
+| Promise\<EncodingBlob> | 表示X509证书吊销列表的序列化数据 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob).then(x509Crl => {
+    Console.log("createX509Crl success");
+    x509Crl.getEncoded().then(result => {
+        Console.log("getEncoded success");
+    }, error => {
+        Console.log("getEncoded failed, errCode: " + error.code + ", errMsg: " + error.message);
+    });
+}, error => {
+    Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+### verify
+
+verify(key : PubKey, callback : AsyncCallback\<void>) : void
+
+表示对X509证书吊销列表进行验签。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明                   |
+| -------- | ------------- | ---- | ---------------------- |
+| key      | PubKey        | 是   | 表示用于验签的公钥对象 |
+| callback | AsyncCallback\<void> | 否   | 回调函数,使用AsyncCallback的第一个error参数判断是否验签成功，error为null表示成功，error不为null表示失败。       |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        // 业务需通过AsyKeyGenerator生成PubKey
+        let pubKey = null;
+        x509Crl.verify(pubKey, function (error, data) {
+           if (error != null) {
+               Console.log("verify failed, errCode: " + error.code + ", errMsg: " + error.message);
+           } else {
+               Console.log("verify success");
+           }
+        });
+    }
+});
+```
+
+### verify
+
+verify(key : PubKey) : Promise\<void>
+
+表示对X509证书吊销列表进行验签。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名 | 类型   | 必填 | 说明                   |
+| ------ | ------ | ---- | ---------------------- |
+| key    | PubKey | 是   | 表示用于验签的公钥对象 |
+
+**返回值**：
+
+| 类型 | 说明                                                         |
+| ---- | ------------------------------------------------------------ |
+| Promise\<void> | 使用AsyncCallback的第一个error参数判断是否验签成功，error为null表示成功，error不为null表示失败 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob).then(x509Crl => {
+    Console.log("createX509Crl success");
+    // 业务需通过AsyKeyGenerator生成PubKey
+    let pubKey = null;
+    x509Crl.verify(pubKey).then(result => {
+        Console.log("verify success");
+    }, error => {
+        Console.log("verify failed, errCode: " + error.code + ", errMsg: " + error.message);
+    });
+}, error => {
+    Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+### getVersion
+
+getVersion() : number
+
+表示获取X509证书吊销列表的版本号。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                             |
+| ------ | -------------------------------- |
+| number | 表示获取X509证书吊销列表的版本号 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        let version = x509Crl.getVersion();
+    }
+});
+```
+
+### getIssuerName
+
+getIssuerName() : DataBlob
+
+表示获取X509证书吊销列表颁发者名称。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型     | 说明                           |
+| -------- | ------------------------------ |
+| DataBlob | 表示X509证书吊销列表颁发者名称 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        let issuerName = x509Crl.getIssuerName();
+    }
+});
+```
+
+### getLastUpdate
+
+getLastUpdate() : string
+
+表示获取X509证书吊销列表最后一次更新日期。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                                 |
+| ------ | ------------------------------------ |
+| string | 表示X509证书吊销列表最后一次更新日期 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        let lastUpdate = x509Crl.getLastUpdate();
+    }
+});
+```
+
+### getNextUpdate
+
+getNextUpdate() : string
+
+表示获取证书吊销列表下一次更新的日期。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                                 |
+| ------ | ------------------------------------ |
+| string | 表示X509证书吊销列表下一次更新的日期 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        let nextUpdate = x509Crl.getNextUpdate();
+    }
+});
+```
+
+### getRevokedCert
+
+getRevokedCert(serialNumber : number, callback : AsyncCallback\<X509CrlEntry>) : void
+
+表示通过指定证书序列号获取被吊销X509证书对象。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名       | 类型          | 必填 | 说明           |
+| ------------ | ------------- | ---- | -------------- |
+| serialNumber | number        | 是   | 表示证书序列号 |
+| callback     | AsyncCallback\<X509CrlEntry> | 否   | 回调函数。表示被吊销X509证书对象       |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        // 业务需赋值为对应证书的序列号
+        let serialNumber = 1000;
+        x509Crl.getRevokedCert(serialNumber, function (error, entry) {
+            if (error != null) {
+                Console.log("getRevokedCert failed, errCode: " + error.code + ", errMsg: " + error.message);
+            } else {
+                Console.log("getRevokedCert success");
+            }
+        });
+    }
+});
+```
+
+### getRevokedCert
+
+getRevokedCert(serialNumber : number) : Promise\<X509CrlEntry>
+
+表示通过指定证书序列号获取被吊销X509证书对象。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名       | 类型   | 必填 | 说明           |
+| ------------ | ------ | ---- | -------------- |
+| serialNumber | number | 是   | 表示证书序列号 |
+
+**返回值**:
+
+| 类型         | 说明                   |
+| ------------ | ---------------------- |
+| Promise\<X509CrlEntry> | 表示被吊销X509证书对象 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob).then(x509Crl => {
+    Console.log("createX509Crl success");
+    // 业务需赋值为对应证书的序列号
+    let serialNumber = 1000;
+    x509Crl.getRevokedCert(serialNumber).then(entry => {
+        Console.log("getRevokedCert success");
+    }, error => {
+        Console.log("getRevokedCert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    });
+}, error => {
+    Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+### getRevokedCertWithCert
+
+getRevokedCertWithCert(cert : X509Cert, callback : AsyncCallback\<X509CrlEntry>) : void
+
+表示通过指定证书对象获取被吊销X509证书对象。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明         |
+| -------- | ------------- | ---- | ------------ |
+| cert     | X509Cert      | 是   | 表示证书对象 |
+| callback | AsyncCallback\<X509CrlEntry> | 否   | 回调函数,表示被吊销X509证书对象    |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        // 业务需自行生成X509Cert证书对象
+        let x509Cert = null;
+        x509Crl.getRevokedCertWithCert(x509Cert, function (error, entry) {
+            if (error != null) {
+                Console.log("getRevokedCertWithCert failed, errCode: " + error.code + ", errMsg: " + error.message);
+            } else {
+                Console.log("getRevokedCertWithCert success");
+            }
+        });
+    }
+});
+```
+
+### getRevokedCertWithCert
+
+getRevokedCertWithCert(cert : X509Cert) : Promise\<X509CrlEntry>
+
+表示通过指定证书对象获取被吊销X509证书对象。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名 | 类型     | 必填 | 说明         |
+| ------ | -------- | ---- | ------------ |
+| cert   | X509Cert | 是   | 表示证书对象 |
+
+**返回值**:
+
+| 类型         | 说明                   |
+| ------------ | ---------------------- |
+| Promise\<X509CrlEntry> | 表示被吊销X509证书对象 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob).then(x509Crl => {
+    Console.log("createX509Crl success");
+    // 业务需自行生成X509Cert证书对象
+    let x509Cert = null;
+    x509Crl.getRevokedCertWithCert(x509Cert).then(entry => {
+        Console.log("getRevokedCertWithCert success");
+    }, error => {
+        Console.log("getRevokedCertWithCert failed, errCode: " + error.code + ", errMsg: " + error.message);
+    });
+}, error => {
+    Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+### getRevokedCerts
+
+getRevokedCerts(callback : AsyncCallback<Array\<X509CrlEntry>>) : void
+
+表示获取被吊销X509证书列表。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明     |
+| -------- | ------------- | ---- | -------- |
+| callback | AsyncCallback<Array\<X509CrlEntry>> | 否   | 回调函数。表示被吊销X509证书列表 |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        x509Crl.getRevokedCerts(function (error, array) {
+            if (error != null) {
+                Console.log("getRevokedCerts failed, errCode: " + error.code + ", errMsg: " + error.message);
+            } else {
+                Console.log("getRevokedCerts success");
+            }
+        });
+    }
+});
+```
+
+### getRevokedCerts
+
+getRevokedCerts() : Promise<Array\<X509CrlEntry>>
+
+表示获取被吊销X509证书列表。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**:
+
+| 类型                | 说明                   |
+| ------------------- | ---------------------- |
+|Promise<Array\<X509CrlEntry>> | 表示被吊销X509证书列表 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob).then(x509Crl => {
+    Console.log("createX509Crl success");
+    x509Crl.getRevokedCerts().then(array => {
+        Console.log("getRevokedCerts success");
+    }, error => {
+        Console.log("getRevokedCerts failed, errCode: " + error.code + ", errMsg: " + error.message);
+    });
+}, error => {
+    Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+### getTbsInfo
+
+getTbsInfo(callback : AsyncCallback\<DataBlob>) : void
+
+表示获取证书吊销列表的tbsCertList信息。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明     |
+| -------- | ------------- | ---- | -------- |
+| callback | AsyncCallback\<DataBlob> | 否   | 回调函数。表示证书吊销列表的tbsCertList信息 |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        x509Crl.getTbsInfo(function (error, tbsInfo) {
+            if (error != null) {
+                Console.log("getTbsInfo failed, errCode: " + error.code + ", errMsg: " + error.message);
+            } else {
+                Console.log("getTbsInfo success");
+            }
+        });
+    }
+});
+```
+
+### getTbsInfo
+
+getTbsInfo() : Promise\<DataBlob>
+
+表示获取证书吊销列表的tbsCertList信息。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**:
+
+| 类型     | 说明                              |
+| -------- | --------------------------------- |
+| Promise\<DataBlob> | 表示证书吊销列表的tbsCertList信息 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob).then(x509Crl => {
+    Console.log("createX509Crl success");
+    x509Crl.getTbsInfo().then(tbsInfo => {
+        Console.log("getTbsInfo success");
+    }, error => {
+        Console.log("getTbsInfo failed, errCode: " + error.code + ", errMsg: " + error.message);
+    });
+}, error => {
+    Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+### getSignature
+
+getSignature() : DataBlob
+
+表示获取X509证书吊销列表的签名数据。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型     | 说明                           |
+| -------- | ------------------------------ |
+| DataBlob | 表示X509证书吊销列表的签名数据 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        let signature = x509Crl.getSignature();
+    }
+});
+```
+
+### getSignatureAlgName
+
+getSignatureAlgName() : string
+
+表示获取X509证书吊销列表签名的算法名称。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                             |
+| ------ | -------------------------------- |
+| string | 表示X509证书吊销列表签名的算法名 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        let sigAlgName = x509Crl.getSignatureAlgName();
+    }
+});
+```
+
+### getSignatureAlgOid
+
+getSignatureAlgOid() : string
+
+表示获取X509证书吊销列表签名的算法OID。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                                |
+| ------ | ----------------------------------- |
+| string | 表示X509证书吊销列表签名的算法OID。 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        let sigAlgOid = x509Crl.getSignatureAlgOid();
+    }
+});
+```
+
+### getSignatureAlgParams
+
+getSignatureAlgParams() : DataBlob
+
+表示获取X509证书吊销列表签名的算法参数。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型     | 说明                               |
+| -------- | ---------------------------------- |
+| DataBlob | 表示X509证书吊销列表签名的算法参数 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 证书吊销列表二进制数据，需业务自行赋值
+let encodingData = null;
+let encodingBlob = {
+    data: encodingData,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM
+};
+cryptoFramework.createX509Crl(encodingBlob, function (error, x509Crl) {
+    if (error != null) {
+        Console.log("createX509Crl failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("createX509Crl success");
+        let sigAlgParams = x509Crl.getSignatureAlgParams();
+    }
+});
+```
+
+## cryptoFramework.createCertChainValidator
+
+createCertChainValidator(algorithm :string) : CertChainValidator
+
+表示创建证书链校验器对象。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名    | 类型   | 必填 | 说明                 |
+| --------- | ------ | ---- | -------------------- |
+| algorithm | string | 是   | 表示证书链校验器算法 |
+
+**返回值**：
+
+| 类型               | 说明                 |
+| ------------------ | -------------------- |
+| CertChainValidator | 表示证书链校验器对象 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+let validator = cryptoFramework.createCertChainValidator("PKIX");
+```
+
+## CertChainValidator
+
+证书链校验器对象。
+
+### validate
+
+validate(certChain : CertChainData, callback : AsyncCallback\<void>) : void
+
+表示校验X509证书链。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名    | 类型          | 必填 | 说明                     |
+| --------- | ------------- | ---- | ------------------------ |
+| certChain | CertChainData | 是   | 表示X509证书链序列化数据 |
+| callback  | AsyncCallback\<void> | 否   | 回调函数。使用AsyncCallback的第一个error参数判断是否校验成功，error为null表示成功，error不为null表示失败                 |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+let validator = cryptoFramework.createCertChainValidator("PKIX");
+// 证书链二进制数据，需业务自行赋值
+let encodingData = null;
+// 证书链包含的证书个数，需业务自行赋值
+let certCount = 2;
+let certChainData = {
+    data: encodingData,
+    count: certCount,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM 
+};
+validator.validate(certChainData, function (error, data) {
+    if (error != null) {
+        Console.log("validate failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("validate success");
+    }
+});
+```
+
+### validate
+
+validate(certChain : CertChainData) : Promise\<void>
+
+表示校验X509证书链。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名    | 类型          | 必填 | 说明                     |
+| --------- | ------------- | ---- | ------------------------ |
+| certChain | CertChainData | 是   | 表示X509证书链序列化数据。使用AsyncCallback的第一个error参数判断是否校验成功，error为null表示成功，error不为null表示失败 |
+
+**返回值**：
+
+| 类型 | 说明                                                         |
+| ---- | ------------------------------------------------------------ |
+| Promise\<void> | Promise对象 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+let validator = cryptoFramework.createCertChainValidator("PKIX");
+// 证书链二进制数据，需业务自行赋值
+let encodingData = null;
+// 证书链包含的证书个数，需业务自行赋值
+let certCount = 2;
+let certChainData = {
+    data: encodingData,
+    count: certCount,
+    // 根据encodingData的格式进行赋值，支持FORMAT_PEM和FORMAT_DER
+    encodingFormat: cryptoFramework.EncodingFormat.FORMAT_PEM 
+};
+validator.validate(certChainData).then(result => {
+    Console.log("validate success");
+}, error => {
+    Console.log("validate failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+### algorithm
+
+algorithm : string
+
+表示X509证书链校验器算法名称。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                     |
+| ------ | ------------------------ |
+| string | 表示证书链校验器算法名称 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+let validator = cryptoFramework.createCertChainValidator("PKIX");
+let algorithm = validator.algorithm;
+```
+
+## X509CrlEntry
+
+被吊销证书对象。
+
+### getEncoded
+
+getEncoded(callback : AsyncCallback\<EncodingBlob>) : void
+
+表示获取被吊销证书的序列化数据。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明     |
+| -------- | ------------- | ---- | -------- |
+| callback | AsyncCallback\<EncodingBlob> | 否   | 回调函数。表示被吊销证书的序列化数据 |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 业务需通过X509Crl的getRevokedCert相关方法获取X509CrlEntry
+let x509CrlEntry = null;
+x509CrlEntry.getEncoded(function (error, data) {
+    if (error != null) {
+        Console.log("getEncoded failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("getEncoded success");
+    }
+});
+```
+
+### getEncoded
+
+getEncoded() : Promise\<EncodingBlob>
+
+表示获取被吊销证书的序列化数据。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型         | 说明                       |
+| ------------ | -------------------------- |
+| Promise\<EncodingBlob> | 表示被吊销证书的序列化数据 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 业务需通过X509Crl的getRevokedCert相关方法获取X509CrlEntry
+let x509CrlEntry = null;
+x509CrlEntry.getEncoded().then(result => {
+    Console.log("getEncoded success");
+}, error => {
+    Console.log("getEncoded failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+### getSerialNumber
+
+getSerialNumber() : number
+
+表示获取被吊销证书的序列号。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                   |
+| ------ | ---------------------- |
+| number | 表示被吊销证书的序列号 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 业务需通过X509Crl的getRevokedCert相关方法获取X509CrlEntry
+let x509CrlEntry = null;
+let serialNumber = x509CrlEntry.getSerialNumber();
+```
+
+### getCertIssuer
+
+getCertIssuer(callback : AsyncCallback\<DataBlob>) : void
+
+表示获取被吊销证书的颁发者信息。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明     |
+| -------- | ------------- | ---- | -------- |
+| callback | AsyncCallback\<DataBlob> | 否   | 回调函数。表示被吊销证书的颁发者信息 |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 业务需通过X509Crl的getRevokedCert相关方法获取X509CrlEntry
+let x509CrlEntry = null;
+x509CrlEntry.getCertIssuer(function (error, issuer) {
+    if (error != null) {
+        Console.log("getCertIssuer failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("getCertIssuer success");
+    }
+});
+```
+
+### getCertIssuer
+
+getCertIssuer() : Promise\<DataBlob>
+
+表示获取被吊销证书的颁发者信息。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型     | 说明                       |
+| -------- | -------------------------- |
+| Promise\<DataBlob> | 表示被吊销证书的颁发者信息 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 业务需通过X509Crl的getRevokedCert相关方法获取X509CrlEntry
+let x509CrlEntry = null;
+x509CrlEntry.getCertIssuer().then(issuer => {
+    Console.log("getCertIssuer success");
+}, error => {
+    Console.log("getCertIssuer failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```
+
+### getRevocationDate
+
+getRevocationDate(callback : AsyncCallback\<string>) : void
+
+表示获取证书被吊销的日期。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**参数**：
+
+| 参数名   | 类型          | 必填 | 说明     |
+| -------- | ------------- | ---- | -------- |
+| callback | AsyncCallback\<string> | 否   | 回调函数。表示证书被吊销的日期 |
+
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 业务需通过X509Crl的getRevokedCert相关方法获取X509CrlEntry
+let x509CrlEntry = null;
+x509CrlEntry.getRevocationDate(function (error, date) {
+    if (error != null) {
+        Console.log("getRevocationDate failed, errCode: " + error.code + ", errMsg: " + error.message);
+    } else {
+        Console.log("getRevocationDate success");
+    }
+});
+```
+
+### getRevocationDate
+
+getRevocationDate() : Promise\<string>
+
+表示获取证书被吊销的日期。
+
+**系统能力**：SystemCapability.Security.CryptoFramework
+
+**返回值**：
+
+| 类型   | 说明                 |
+| ------ | -------------------- |
+| Promise\<string> | 表示证书被吊销的日期 |
+
+**示例**：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+// 业务需通过X509Crl的getRevokedCert相关方法获取X509CrlEntry
+let x509CrlEntry = null;
+x509CrlEntry.getRevocationDate().then(date => {
+    Console.log("getRevocationDate success");
+}, error => {
+    Console.log("getRevocationDate failed, errCode: " + error.code + ", errMsg: " + error.message);
+});
+```

zh-cn/application-dev/security/Readme-CN.md

@@ -11,6 +11,9 @@
 - 密钥管理
   - [HUKS开发概述](huks-overview.md)
   - [HUKS开发指导](huks-guidelines.md)
+- 加密算法库框架
+  - [加密算法库框架概述](cryptoFramework-overview.md)
+  - [加密算法框架开发指导](cryptoFramework-guidelines.md)
 - Hap包签名工具
   - [Hap包签名工具概述](hapsigntool-overview.md)
   - [Hap包签名工具指导](hapsigntool-guidelines.md)

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

+# 加解密算法库框架开发指导
+## 使用加解密操作
+**场景说明**
+
+使用加解密操作中，典型的场景有：
+1. 使用对称密钥的加解密操作
+2. 使用非对称密钥的加解密操作
+
+**接口及参数说明**
+
+详细接口说明可参考[API参考](../reference/apis/js-apis-cryptoFramework.md)。
+
+以上场景设计的常用接口如下表所示：
+
+|实例名|接口名|描述|
+|---|---|---|
+|cryptoFramework|createCipher(transformation : string) : Cipher|根据transformation设置的算法参数创建Cipher对象|
+|Cipher|init(opMode : CryptoMode, key : Key, params : ParamsSpec, callback : AsyncCallback\<void>) : void|使用callback方式设置密钥并初始化Cipher对象|
+|Cipher|init(opMode : CryptoMode, key : Key, params : ParamsSpec) : Promise\<void>|使用Promise方式设置密钥并初始化Cipher对象|
+|Cipher|update(data : DataBlob, callback : AsyncCallback\<DataBlob>) : void|使用callback方式添加加解密数据|
+|Cipher|update(data : DataBlob) : Promise\<DataBlob>|使用Promise方式添加加解密数据|
+|Cipher|doFinal(data : DataBlob, callback : AsyncCallback\<DataBlob>) : void|使用callback方式结束对所有数据的加解密|
+|Cipher|doFinal(data : DataBlob) : Promise\<DataBlob>|使用Promise方式结束对所有数据的加解密|
+
+**开发步骤**
+
+示例1：使用对称密钥的加解密操作
+
+1. 生成对称密钥生成器。
+2. 通过密钥生成器生成对称密钥。
+3. 生成加解密生成器。
+4. 通过加解密生成器加密或解密数据。
+
+以AES GCM以Promise方式加解密为例：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+var globalCipher;
+var globalGcmParams;
+var globalKey;
+var globalCipherText;
+
+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, algoName : "GcmParamsSpec"};
+  return gcmParamsSpec;
+}
+
+// 可理解的字符串转成字节流
+function stringToUint8Array(str) {
+  let arr = [];
+  for (let i = 0, j = str.length; i < j; ++i) {
+    arr.push(str.charCodeAt(i));
+  }
+  return new Uint8Array(arr);
+}
+
+// 字节流转成可理解的字符串
+function uint8ArrayToShowStr(uint8Array) {
+  return Array.prototype.map
+    .call(uint8Array, (x) => ('00' + x.toString(16)).slice(-2))
+    .join('');
+}
+
+// 字节流以16进制输出
+function uint8ArrayToString(array) {
+  let arrayString = '';
+  for (let i = 0; i < array.length; i++) {
+    arrayString += String.fromCharCode(array[i]);
+  }
+  return arrayString;
+}
+
+function genKeyMaterialBlob() {
+  let arr = [
+    0xba, 0x3d, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
+    0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c,
+    0xba, 0x3b, 0xc2, 0x71, 0xab, 0xa0, 0x30, 0x72];    // keyLen = 192 (24 bytes)
+  let keyMaterial = new Uint8Array(arr);
+  return {data : keyMaterial};
+}
+
+
+// AES GCM模式示例，自动生成密钥（promise写法）
+function testAesGcm() {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      resolve('testAesGcm');
+    }, 10)
+  }).then(() => {
+    // 生成对称密钥生成器
+    let symAlgoName = 'AES128';
+    let symKeyGenerator = cryptoFramework.createSymKeyGenerator(symAlgoName);
+    if (symKeyGenerator == null) {
+      console.error('createSymKeyGenerator failed');
+      return;
+    }
+    console.info(`symKeyGenerator algName: ${symKeyGenerator.algName}`);
+    // 通过密钥生成器随机生成128位长度的对称密钥
+    let promiseSymKey = symKeyGenerator.generateSymKey();
+    // 构造参数
+    globalGcmParams = genGcmParamsSpec();
+
+    // 生成加解密生成器
+    let cipherAlgoName = 'AES128|GCM|PKCS7';
+    try {
+      globalCipher = cryptoFramework.createCipher(cipherAlgoName);
+      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(() => {
+      let plainText = {data : stringToUint8Array('this is test!')};
+      let promiseUpdate = globalCipher.update(plainText);   // update
+      return promiseUpdate;
+  }).then(updateOutput => {
+      globalCipherText = updateOutput;
+      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(() => {
+      let promiseUpdate = globalCipher.update(globalCipherText);    // update
+      return promiseUpdate;
+  }).then(updateOutput => {
+      console.info('decrypt plainText: ' + uint8ArrayToString(updateOutput.data));
+      let promiseFinal = globalCipher.doFinal(null);    // doFinal
+      return promiseFinal;
+  }).then(finalOutput => {
+      if (finalOutput == null) {
+          console.info('GCM finalOutput is null');
+      }
+  }).catch(error => {
+      console.error(`catch error, ${error.code}, ${error.message}`);
+  })
+}
+```
+
+以3DES ECB以callback方式加解密（采用已有数据生成密钥）为例：
+
+```js
+import cryptoFramework from '@ohos.security.cryptoFramework';
+
+var globalCipher;
+var globalGcmParams;
+var globalKey;
+var globalCipherText;
+
+// 可理解的字符串转成字节流
+function stringToUint8Array(str) {
+  let arr = [];
+  for (let i = 0, j = str.length; i < j; ++i) {
+    arr.push(str.charCodeAt(i));
+  }
+  return new Uint8Array(arr);
+}
+
+// 字节流转成可理解的字符串
+function uint8ArrayToShowStr(uint8Array) {
+  return Array.prototype.map
+    .call(uint8Array, (x) => ('00' + x.toString(16)).slice(-2))
+    .join('');
+}
+
+// 字节流以16进制输出
+function uint8ArrayToString(array) {
+  let arrayString = '';
+  for (let i = 0; i < array.length; i++) {
+    arrayString += String.fromCharCode(array[i]);
+  }
+  return arrayString;
+}
+
+function genKeyMaterialBlob() {
+  let arr = [
+    0xba, 0x3d, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
+    0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c,
+    0xba, 0x3b, 0xc2, 0x71, 0xab, 0xa0, 0x30, 0x72];    // keyLen = 192 (24 bytes)
+  let keyMaterial = new Uint8Array(arr);
+  return {data : keyMaterial};
+}
+
+// 3DES ECB模式示例，采用已有数据生成密钥（callback写法）
+function test3DesEcb() {
+  // 生成对称密钥生成器
+  let symAlgoName = '3DES192';
+  let symKeyGenerator = cryptoFramework.createSymKeyGenerator(symAlgoName);
+  if (symKeyGenerator == null) {
+    console.error('createSymKeyGenerator failed');
+    return;
+  }
+  console.info(`symKeyGenerator algName: ${symKeyGenerator.algName}`);
+
+  // 生成加解密生成器
+  let cipherAlgoName = '3DES192|ECB|PKCS7';
+  try {
+    globalCipher = cryptoFramework.createCipher(cipherAlgoName);
+    console.info(`cipher algName: ${globalCipher.algName}`);
+  } catch (error) {
+    console.error(`createCipher failed, ${error.code}, ${error.message}`);
+    return;
+  }
+
+  // 根据指定的数据，生成对称密钥
+  let keyMaterialBlob = genKeyMaterialBlob();
+  try {
+    symKeyGenerator.convertKey(keyMaterialBlob, (error, key) => {
+      if (error) {
+        console.error(`convertKey error, ${error.code}, ${error.message}`);
+        return;
+      }
+      console.info(`key algName: ${key.algName}`);
+      console.info(`key format: ${key.format}`);
+      let encodedKey = key.getEncoded();
+      console.info('key getEncoded hex: ' + uint8ArrayToShowStr(encodedKey.data));
+      globalKey = key;
+
+      // 初始化加解密操作环境:开始加密
+      let mode = cryptoFramework.CryptoMode.ENCRYPT_MODE;
+      // init
+      globalCipher.init(mode, key, null, (err, ) => {
+        let plainText = {data : stringToUint8Array('this is test!')};
+        // update
+        globalCipher.update(plainText, (err, updateOutput) => {
+          globalCipherText = updateOutput;
+          //doFinal
+          globalCipher.doFinal(null, (err, finalOutput) => {
+            if (error) {
+              console.error(`doFinal error, ${error.code}, ${error.message}`);
+              return;
+            }
+            if (finalOutput != null) {
+              globalCipherText = Array.from(globalCipherText.data);
+              finalOutput = Array.from(finalOutput.data);
+              globalCipherText = globalCipherText.concat(finalOutput);
+              globalCipherText = new Uint8Array(globalCipherText);
+              globalCipherText = {data : globalCipherText};
+            }
+            // 初始化加解密操作环境:开始解密
+            let mode = cryptoFramework.CryptoMode.DECRYPT_MODE;
+            // init
+            globalCipher.init(mode, globalKey, null, (err, ) => {
+              // update
+              globalCipher.update(globalCipherText, (err, updateOutput) => {
+                console.info('decrypt plainText: ' + uint8ArrayToString(updateOutput.data));
+                // doFinal
+                globalCipher.doFinal(null, (error, finalOutput) => {
+                  if (finalOutput != null) {
+                    console.info("decrypt plainText:" + uint8ArrayToString(finalOutput.data));
+                  }
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+  } catch (error) {
+    console.error(`convertKey failed, ${error.code}, ${error.message}`);
+    return;
+  }
+}
+```
+
+示例2：使用非对称密钥的加解密操作
+
+1. 生成RSA密钥。通过createAsyKeyGenerator接口创建AsyKeyGenerator对象，并生成RSA非对称密钥。
+2. 生成Cipher对象。通过createCipher接口创建Cipher对象，执行初始化操作，设置密钥及加解密模式。
+3. 执行加解密操作。通过调用Cipher对象提供的doFinal接口，执行加密操作生成密文或执行解密操作生成明文。
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+let plan = "This is cipher test.";
+
+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 encryptMessageProMise() {
+  let rsaGenerator = cryptoFramework.createAsyKeyGenerator("RSA1024|PRIMES_2");
+  let cipher = cryptoFramework.createCipher("RSA1024|PKCS1");
+  let keyGenPromise = rsaGenerator.generateKeyPair();
+  keyGenPromise.then(rsaKeyPair => {
+    let pubKey = rsaKeyPair.pubKey;
+    return cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, pubKey, null);
+  }).then(() => {
+    let input = { data : stringToUint8Array(plan) };
+    return cipher.doFinal(input);
+  }).then(dataBlob => {
+    console.info("EncryptOutPut is " + dataBlob.data);
+  });
+}
+
+function encryptMessageCallback() {
+  let rsaGenerator = cryptoFramework.createAsyKeyGenerator("RSA1024|PRIMES_2");
+  let cipher = cryptoFramework.createCipher("RSA1024|PKCS1");
+  rsaGenerator.generateKeyPair(function (err, keyPair) {
+    let pubKey = keyPair.pubKey;
+    cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, pubKey, null, function (err, data) {
+      let input = {data : stringToUint8Array(plan) };
+      cipher.doFinal(input, function (err, data) {
+        console.info("EncryptOutPut is " + data.data);
+      })
+    })
+  })
+}
+```
+
+## 使用签名验签操作
+
+**场景说明**
+使用签名验签操作中，典型的场景有：
+1. 使用RSA签名验签操作
+2. 使用ECC签名验签操作
+
+**接口及参数说明**
+
+详细接口说明可参考[API参考](../reference/apis/js-apis-cryptoFramework.md)。
+
+|实例名|接口名|描述|
+|---|---|---|
+|cryptoFramework|createSign(algName : string) : Sign|根据String设置的参数创建Sign对象|
+|Sign|init(priKey : PriKey, callback : AsyncCallback\<void>) : void|使用callback方式设置密钥并初始化Sign对象|
+|Sign|init(priKey : PriKey) : Promise\<void>|使用Promise方式设置密钥并初始化Sign对象|
+|Sign|update(data : DataBlob, callback : AsyncCallback\<void>) : void|使用callback方式添加签名数据|
+|Sign|update(data : DataBlob) : Promise\<void>|用Promise方式添加签名数据|
+|Sign|sign(data : DataBlob, callback : AsyncCallback<DataBlob>) : void|使用callback方式签名所有数据|
+|Sign|sign(data : DataBlob) : Promise<DataBlob>|使用Promise方式签名所有数据|
+|cryptoFramework|function createVerify(algName : string) : Verify|根据String设置的参数创建Verify对象|
+|Verify|init(priKey : PriKey, callback : AsyncCallback\<void>) : void|使用callback方式设置密钥并初始化Verify对象|
+|Verify|init(priKey : PriKey) : Promise\<void>|使用Promise方式设置密钥并初始化Verify对象|
+|Verify|update(data : DataBlob, callback : AsyncCallback\<void>) : void|使用callback方式添加验签数据|
+|Verify|update(data : DataBlob) : Promise\<void>|用Promise方式添加验签数据|
+|Verify|verify(data : DataBlob, signatureData : DataBlob, callback : AsyncCallback<boolean>) : void|使用callback方式验签所有数据|
+|Verify|verify(data : DataBlob, signatureData : DataBlob) : Promise<boolean>|使用Promise方式验签所有数据|
+
+**开发步骤**
+
+示例1：使用RSA签名验签操作
+1. 生成RSA密钥。通过createAsyKeyGenerator接口创建AsyKeyGenerator对象，并生成RSA非对称密钥。
+2. 生成Sign对象。通过createSign接口创建Sign对象，执行初始化操作并设置签名私钥。
+3. 执行签名操作。通过Sign类提供的update接口，添加签名数据，并调用doFinal接口生成数据的签名。
+4. 生成Verify对象。通过createVerify接口创建Verify对象，执行初始化操作并设置验签公钥。
+5. 执行验签操作。通过Verify类提供的update接口，添加签名数据，并调用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;
+}
+
+let globalKeyPair;
+let SignMessageBlob;
+let plan1 = "This is Sign test plan1";
+let plan2 = "This is Sign test plan1";
+let input1 = { data : stringToUint8Array(plan1) };
+let input2 = { data : stringToUint8Array(plan2) };
+
+function signMessagePromise() {
+  let rsaGenerator = cryptoFramework.createAsyKeyGenerator("RSA1024|PRIMES_2");
+  let signer = cryptoFramework.createSign("RSA1024|PKCS1|SHA256");
+  let keyGenPromise = rsaGenerator.generateKeyPair();
+  keyGenPromise.then( keyPair => {
+    globalKeyPair = keyPair;
+    let priKey = globalKeyPair.priKey;
+    return signer.init(priKey);
+  }).then(() => {
+    return signer.update(input1);
+  }).then(() => {
+    return signer.sign(input2);
+  }).then(dataBlob => {
+    SignMessageBlob = dataBlob;
+    console.info("sign output is " + SignMessageBlob.data);
+  });
+}
+
+function verifyMessagePromise() {
+  let verifyer = cryptoFramework.createVerify("RSA1024|PKCS1|SHA256");
+  let verifyInitPromise = verifyer.init(globalKeyPair.pubKey);
+  verifyInitPromise.then(() => {
+    return verifyer.update(input1);
+  }).then(() => {
+    return verifyer.verify(input2, SignMessageBlob);
+  }).then(res => {
+    console.log("Verify result is " + res);
+  });
+}
+
+function signMessageCallback() {
+  let rsaGenerator = cryptoFramework.createAsyKeyGenerator("RSA1024|PRIMES_2");
+  let signer = cryptoFramework.createSign("RSA1024|PKCS1|SHA256");
+  rsaGenerator.generateKeyPair(function (err, keyPair) {
+    globalKeyPair = keyPair;
+    let priKey = globalKeyPair.priKey;
+    signer.init(priKey, function (err, data) {
+      signer.update(input1, function (err, data) {
+        signer.sign(input2, function (err, data) {
+          SignMessageBlob = data;
+          console.info("sign output is " + SignMessageBlob.data);
+        });
+      });
+    });
+  });
+}
+
+function verifyMessageCallback() {
+  let verifyer = cryptoFramework.createVerify("RSA1024|PKCS1|SHA25");
+  verifyer.init(globalKeyPair.pubKey, function (err, data) {
+    verifyer.update(input1, function(err, data) {
+      verifyer.verify(input2, SignMessageBlob, function(err, data) {
+        console.info("verify result is " + data);
+      });
+    });
+  })
+}
+```
+
+示例2：使用ECDSA操作
+1. 生成ECC密钥。通过createAsyKeyGenerator接口创建AsyKeyGenerator对象，并生成ECC非对称密钥。
+2. 生成Sign对象。通过createSign接口创建Sign对象，执行初始化操作并设置签名私钥。
+3. 执行签名操作。通过Sign类提供的update接口，添加签名数据，并调用doFinal接口生成数据的签名。
+4. 生成Verify对象。通过createVerify接口创建Verify对象，执行初始化操作并设置验签公钥。
+5. 执行验签操作。通过Verify类提供的update接口，添加签名数据，并调用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;
+}
+
+let globalKeyPair;
+let SignMessageBlob;
+let plan1 = "This is Sign test plan1";
+let plan2 = "This is Sign test plan1";
+let input1 = { data : stringToUint8Array(plan1) };
+let input2 = { data : stringToUint8Array(plan2) };
+
+function signMessagePromise() {
+  let eccGenerator = cryptoFramework.createAsyKeyGenerator("ECC256");
+  let signer = cryptoFramework.createSign("ECC256|SHA256");
+  let keyGenPromise = eccGenerator.generateKeyPair();
+  keyGenPromise.then( keyPair => {
+    globalKeyPair = keyPair;
+    let priKey = globalKeyPair.priKey;
+    return signer.init(priKey);
+  }).then(() => {
+    return signer.update(input1);
+  }).then(() => {
+    return signer.sign(input2);
+  }).then(dataBlob => {
+    SignMessageBlob = dataBlob;
+    console.info("sign output is " + SignMessageBlob.data);
+  });
+}
+
+function verifyMessagePromise() {
+  let verifyer = cryptoFramework.createVerify("ECC256|SHA256");
+  let verifyInitPromise = verifyer.init(globalKeyPair.pubKey);
+  verifyInitPromise.then(() => {
+    return verifyer.update(input1);
+  }).then(() => {
+    return verifyer.verify(input2, SignMessageBlob);
+  }).then(res => {
+    console.log("Verify result is " + res);
+  });
+}
+
+function signMessageCallback() {
+  let eccGenerator = cryptoFramework.createAsyKeyGenerator("ECC256");
+  let signer = cryptoFramework.createSign("ECC256|SHA256");
+  eccGenerator.generateKeyPair(function (err, keyPair) {
+    globalKeyPair = keyPair;
+    let priKey = globalKeyPair.priKey;
+    signer.init(priKey, function (err, data) {
+      signer.update(input1, function (err, data) {
+        signer.sign(input2, function (err, data) {
+          SignMessageBlob = data;
+          console.info("sign output is " + SignMessageBlob.data);
+        });
+      });
+    });
+  });
+}
+
+function verifyMessageCallback() {
+  let verifyer = cryptoFramework.createVerify("ECC256|SHA256");
+  verifyer.init(globalKeyPair.pubKey, function (err, data) {
+    verifyer.update(input1, function(err, data) {
+      verifyer.verify(input2, SignMessageBlob, function(err, data) {
+        console.info("verify result is " + data);
+      });
+    });
+  })
+}
+```
+
+## 使用摘要操作
+
+**场景说明**
+
+使用摘要操作的主要场景为：
+
+用户指定摘要算法（如SHA256）生成Md实例，并输入单段或多段需要摘要的信息，进行摘要计算更新，并返回消息摘要计算结果，在指定算法后可获取当前算法名与摘要计算长度（字节）
+
+**接口及参数说明**
+
+详细接口说明可参考[API参考](../reference/apis/js-apis-cryptoFramework.md)。
+
+| 实例名          | 接口名                                                       | 描述                                               |
+| --------------- | ------------------------------------------------------------ | -------------------------------------------------- |
+| cryptoFramework | function createMd(algName : string) : Md;                    | 指定摘要算法，生成摘要操作实例Md                   |
+| Md              | update(input : DataBlob, callback : AsyncCallback\<void\>) : void; | 接受用户输入数据，通过Callback的方式，异步更新摘要 |
+| Md              | update(input : DataBlob) : Promise\<void\>;                  | 接受用户输入数据，通过Promise的方式，异步更新摘要  |
+| Md              | digest(callback : AsyncCallback\<DataBlob\>) : void;         | 通过Callback的方式，返回结果                       |
+| Md              | digest() : Promise\<DataBlob\>;                              | 通过Promise的方式，返回结果                        |
+| Md              | getMdLength() : number;                                      | 获取摘要的长度（由指定的摘要算法决定）             |
+| Md              | readonly algName : string;                                   | 获取当前设置的摘要算法名                           |
+
+**开发步骤**
+
+1. 设置算法，通过接口`createMd`生成摘要操作实例
+2. 接受用户数据，通过接口`update`，更新摘要，此步骤可重复
+3. 通过接口`digest`，返回摘要计算结果
+4. 获取当前摘要算法名与摘要计算长度
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+// turn string into uint8Arr
+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;
+}
+
+// generate dataBlob with given length
+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;
+}
+
+// md with promise async
+function doMdByPromise(algName) {
+  var md;
+  try {
+    md = cryptoFramework.createMd(algName);
+  } catch (error) {
+    console.error("[Promise]: error code: " + error.code + ", message is: " + error.message);
+  }
+  console.error("[Promise]: Md algName is: " + md.algName);
+  var promiseMdUpdate = md.update(GenDataBlob(12));
+  promiseMdUpdate.then(() => {
+    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);
+  });
+}
+
+// md with callback async
+function doMdByCallback(algName) {
+  var md;
+  try {
+    md = cryptoFramework.createMd(algName);
+  } catch (error) {
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);
+  }
+  console.error("[Callback]: Md algName is: " + md.algName);
+  md.update(GenDataBlob(12), (err,) => {
+    if (err) {
+      console.error("[Callback]: err: " + err.code);
+    }
+    md.digest((err1, mdOutput) => {
+      if (err1) {
+        console.error("[Callback]: err: " + err1.code);
+      } else {
+        console.error("[Callback]: MD result: " + mdOutput.data);
+        var mdLen = md.getMdLength();
+        console.error("[Callback]: MD len: " + mdLen);
+      }
+    });
+  });
+}
+```
+
+## 使用密钥协商操作
+
+**场景说明**
+
+使用签名验签操作中，典型的场景有：
+
+使用ECDH操作。
+
+**接口及参数说明**
+
+详细接口说明可参考[API参考](../reference/apis/js-apis-cryptoFramework.md)。
+
+|实例名|接口名|描述|
+|---|---|---|
+|cryptoFramework|createKeyAgreement(algName : string) : KeyAgreement|根据String设置的参数创建KeyAgreement对象|
+|KeyAgreement|generateSecret(priKey : PriKey, pubKey : PubKey, callback : AsyncCallback\<DataBlob>) : void|使用callback方式进行密钥协商|
+|KeyAgreement|generateSecret(priKey : PriKey, pubKey : PubKey) : Promise\<DataBlob>|使用Promise方式进行密钥协商|
+
+**开发步骤**
+
+1. 生成ECC密钥。通过createAsyKeyGenerator接口创建AsyKeyGenerator对象，并生成ECC非对称密钥。
+2. 基于ECC密钥的私钥及公钥执行ECDH操作。
+
+```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;
+}
+
+let globalKeyPair;
+
+function ecdhPromise() {
+  let eccGenerator = cryptoFramework.createAsyKeyGenerator("ECC256");
+  let eccKeyAgreement = cryptoFramework.createKeyAgreement("ECC256");
+  let keyGenPromise = eccGenerator.generateKeyPair();
+  keyGenPromise.then( keyPair => {
+    globalKeyPair = keyPair;
+    return eccKeyAgreement.generateSecret(keyPair.priKey, keyPair.pubKey);
+  }).then((secret) => {
+    console.info("ecdh output is " + secret.data);
+  }).catch((error) => {
+    console.error("ecdh error.");
+  });
+}
+
+function ecdhCallback() {
+  let eccGenerator = cryptoFramework.createAsyKeyGenerator("ECC256");
+  let eccKeyAgreement = cryptoFramework.createKeyAgreement("ECC256");
+  eccGenerator.generateKeyPair(function (err, keyPair) {
+    globalKeyPair = keyPair;
+    eccKeyAgreement.generateSecret(keyPair.priKey, keyPair.pubKey, function (err, secret) {
+      if (err) {
+        console.error("ecdh error.");
+        return;
+      }
+      console.info("ecdh output is " + secret.data);
+    });
+  });
+}
+```
+
+## 使用消息认证码操作
+
+**场景说明**
+
+使用消息认证码操作的主要场景为：
+
+用户指定摘要算法（如SHA256）生成消息认证码Mac实例，输入对称密钥初始化Mac，并传入单段或多段需要摘要的信息，进行消息认证码计算，并获取消息认证码计算结果，在指定算法后可获取当前算法名与消息认证码计算长度（字节）。
+
+**接口及参数说明**
+
+详细接口说明可参考[API参考](../reference/apis/js-apis-cryptoFramework.md)。
+
+| 实例名          | 接口名                                                       | 描述                                                |
+| --------------- | ------------------------------------------------------------ | --------------------------------------------------- |
+| cryptoFramework | function createMd(algName : string) : Md;                    | 指定摘要算法，生成消息认证码实例Mac                 |
+| Mac             | init(key : SymKey, callback : AsyncCallback\<void\>) : void; | 接收输入对称密钥，通过Callback的方式，异步初始化MAC |
+| Mac             | init(key : SymKey) : Promise\<void\>;                        | 接收输入对称密钥，通过Promise的方式，异步初始化MAC  |
+| Mac             | update(input : DataBlob, callback : AsyncCallback\<void\>) : void; | 接受输入数据，通过Callback的方式，异步更新MAC       |
+| Mac             | update(input : DataBlob) : Promise\<void\>;                  | 接受输入数据，通过Promise的方式，异步更新MAC        |
+| Mac             | doFinal(callback : AsyncCallback\<DataBlob\>) : void;        | 通过Callback的方式，返回MAC计算结果                 |
+| Mac             | doFinal() : Promise\<DataBlob\>;                             | 通过Promise的方式，返回MAC计算结果                  |
+| Mac             | getMacLength() : number;                                     | 获取MAC的长度（由指定的摘要算法决定）               |
+| Mac             | readonly algName : string;                                   | 获取当前设置的摘要算法名                            |
+
+**开发步骤**
+
+1. 设置算法，通过接口`createMac`生成消息认证码操作实例
+2. 接受输入对称密钥，通过接口`init`，初始化Mac
+3. 接受数据，通过接口`update`，更新Mac，此步骤可重复
+4. 通过接口`doFinal`，返回Mac计算结果
+5. 获取当前摘要算法名与Mac计算长度
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+// turn string into uint8Arr
+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;
+}
+
+// generate blob with this func
+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;
+}
+
+// process by promise
+function doHmacByPromise(algName) {
+  var mac;
+  try {
+    mac = cryptoFramework.createMac(algName);
+  } catch (error) {
+    console.error("[Promise]: error code: " + error.code + ", message is: " + error.message);
+  }
+  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(() => {
+    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);
+  });
+}
+
+// process by callback
+function doHmacByCallback(algName) {
+  var mac;
+  try {
+    mac = cryptoFramework.createMac(algName);
+  } catch (error) {
+    AlertDialog.show({message: "[Callback]: error code: " + error.code + ", message is: " + error.message});
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);
+  }
+  var KeyBlob = {
+    data : stringToUint8Array("12345678abcdefgh")
+  }
+  var symKeyGenerator = cryptoFramework.createSymKeyGenerator("AES128");
+  symKeyGenerator.convertKey(KeyBlob, (err, symKey) => {
+    if (err) {
+      console.error("[Callback]: err: " + err.code);
+    }
+    mac.init(symKey, (err1, ) => {
+      if (err1) {
+        console.error("[Callback]: err: " + err1.code);
+      }
+      mac.update(GenDataBlob(12), (err2, ) => {
+        if (err2) {
+          console.error("[Callback]: err: " + err2.code);
+        }
+        mac.doFinal((err3, macOutput) => {
+          if (err3) {
+            console.error("[Callback]: err: " + err3.code);
+          } else {
+            console.error("[Callback]: HMAC result: " + macOutput.data);
+            var macLen = mac.getMacLength();
+            console.error("[Callback]: MAC len: " + macLen);
+          }
+        });
+      });
+    });
+  });
+}
+```
+
+
+
+## 使用随机数操作
+
+**场景说明**
+
+使用随机数操作的主要场景为：
+
+- 用户生成随机数Random实例，输入随机数生成的长度（字节），生成指定长度的随机数。
+- 用户使用生成的随机数作为参数，进行种子设置。
+
+**接口及参数说明**
+
+详细接口说明可参考[API参考](../reference/apis/js-apis-cryptoFramework.md)。
+
+| 实例名          | 接口名                                                       | 描述                                           |
+| --------------- | ------------------------------------------------------------ | ---------------------------------------------- |
+| cryptoFramework | function createRandom() : Random;                            | 生成随机数Random实例                           |
+| Random          | generateRandom(len : number, callback: AsyncCallback\<DataBlob\>) : void; | 接受输入长度，通过Callback，异步生成随机数     |
+| Random          | generateRandom(len : number) : Promise\<DataBlob\>;          | 接受输入长度，通过Promise，异步生成随机数      |
+| Random          | setSeed(seed : DataBlob, callback : AsyncCallback\<void\>) : void; | 接受输入Blob，通过Callback的方式，异步设置种子 |
+| Random          | setSeed(seed : DataBlob) : Promise\<void\>;                  | 接受输入Blob，通过Promise的方式，异步设置种子  |
+
+**开发步骤**
+
+1. 通过接口`createRandom`生成随机数操作实例
+2. 接受输入长度，通过接口`generateRandom`，生成指定长度的随机数
+3. 接受DataBlob数据，通过接口`setSeed`，为随机数生成池设置种子
+
+```javascript
+import cryptoFramework from "@ohos.security.cryptoFramework"
+
+// process by promise
+function doRandByPromise(len) {
+  var rand;
+  try {
+    rand = cryptoFramework.createRandom();
+  } catch (error) {
+    console.error("[Promise]: error code: " + error.code + ", message is: " + error.message);
+  }
+  var promiseGenerateRand = rand.generateRandom(len);
+  promiseGenerateRand.then(randData => {
+    console.error("[Promise]: rand result: " + randData.data);
+    var promiseSetSeed = rand.setSeed(randData);
+    return promiseSetSeed;
+  }).then(() => {
+    console.error("[Promise]: setSeed success");
+  }).catch(error => {
+    console.error("[Promise]: error: " + error.message);
+  });
+}
+
+// process by callback
+function doRandByCallback(len) {
+  var rand;
+  try {
+    rand = cryptoFramework.createRandom();
+  } catch (error) {
+    console.error("[Callback]: error code: " + error.code + ", message is: " + error.message);
+  }
+  rand.generateRandom(len, (err, randData) => {
+    if (err) {
+      console.error("[Callback]: err: " + err.code);
+    } else {
+      console.error("[Callback]: generate random result: " + randData.data);
+      rand.setSeed(randData, (err1,) => {
+        if (err1) {
+          console.error("[Callback] err: " + err1.code);
+        } else {
+          console.error("[Callback]: setSeed success");
+        }
+      });
+    }
+  });
+}
+```

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

+# 加解密算法库框架概述
+加解密算法库框架是一个屏蔽了第三方密码学算法库实现差异的算法框架，提供加解密、签名验签、消息验证码、哈希、安全随机数和证书等相关功能。开发者可以通过调用加解密算法库框架，忽略底层不同三方算法库的差异，实现迅捷开发。
+## 框架实现原理
+加解密算法库框架提供的组件分为三层：接口层，Framework层和插件层。接口层负责对外提供统一的JS接口，插件层实现针对具体三方算法库的功能，Framework层通过灵活加载插件层的插件适配并屏蔽三方算法库差异。
+## 基本概念
+**对称密钥**
+
+对称密钥使用同一个密钥对数据进行加密解密操作。即对称加密算法中，数据发送方使用加密密钥对明文进行特殊加密算法处理后，使其变成复杂的加密密文发送出去。接收方收到密文后，若想解读原文，则需要使用同一个加密密钥以及相同算法的逆算法对密文进行解密，才能使其恢复成可读明文。
+
+- **AES加密**
+
+  AES的全称是Advanced Encryption Standard，是最常见的对称加密。AES为分组密码，分组密码也就是把明文分成一组一组的，每组长度相等，每次加密一组数据，直到加密完整个明文。在AES标准规范中，分组长度只能是128位，也就是说，每个分组为16个字节（每个字节8位）。密钥的长度可以使用128位、192位或256位。
+- **3DES加密**
+  
+  3DES，也称为 3DESede 或 TripleDES，是三重数据加密算法，相当于是对每个数据块应用三次DES的对称加密算法，它使用3个64位的密钥对数据块进行三次加密。相比DES，3DES因密钥长度变长，安全性有所提高，但其处理速度不高。因此又出现了AES加密算法，AES较于3DES速度更快、安全性更高。
+
+**非对称密钥**
+
+非对称密钥使用公钥和私钥两个密钥来进行算法操作，公钥对外公开，私钥对外保密。对于加解密操作，一般使用公钥对明文进行加密形成密文，持有私钥的人即可对密文解密形成明文。对于签名验签操作，使用私钥对明文进行签名，公钥持有者可以通过公钥对签名数据做验签，验证数据是否被篡改。
+
+- **RSA密钥**
+
+  RSA密钥以极大整数做因数分解的数学难题作为密钥安全性的基石。生成密钥时，首先需要随机出两个大素数p和q，计算n = p * q并将n做为模，再选择一个大于1且小于(p - 1) * (q - 1)的整数e，确保e与(p - 1)*(q - 1)互素，最后计算d，使得e * d - 1为(p - 1)和(q - 1)的倍数，则可得到公钥(n, e)和私钥(n, d)。
+
+  算法库框架除提供了默认的双素数RSA密钥生成外，还提供了多素数密钥生成方式，可以在密钥生成时通过指定primes参数（PRIMES_2, PRIMES_3, PRIMES_4, PRIMES_5）指定素数个数。多素数密钥的优点是可以减少解密、签名的计算量（中国剩余定理），但相对的劣势是密钥强度会越低，算法库依据OpenSSL的素数使用规则制定了相应规格，具体将在**约束与限制**章节中说明。
+- **ECC密钥**
+  
+  ECC是一种基于椭圆曲线数学的公开密钥加密算法，其数学基础是利用椭圆曲线上的有理点构成Abel加法群上椭圆离散对数的计算困难性，算法库框架提供了多种椭圆曲线的ECC密钥生成能力。
+
+**加解密**
+
+- **对称AES加解密**
+
+  算法库目前提供了AES加解密常用的7种加密模式：ECB、CBC、OFB、CFB、CTR、GCM和CCM。AES为分组加密算法，分组长度大小为128位。实际应用中明文最后一组可能不足128位，不足数据可以使用各种padding模式做数据填充。下文中描述了各个padding的区别：
+	- NoPadding：不带填充；
+	- PKCS5：填充字符由一个字节序列组成，每个字节填充该填充字节序列的长度，规定是8字节填充；
+	- PKCS7：填充字符和PKCS5填充方法一致，但是可以在1-255字节之间任意填充；
+
+  > **说明：** ECB、CBC加密模式，明文长度不是128位整数倍，必须使用填充方法补足；
+- **对称3DES加解密**
+
+  该算法的加解密过程分别是对明文/密文数据进行三次DES加密或解密，得到相应的密文或明文。
+
+  算法库目前提供了3DES加解密常用的4种加密模式：ECB、CBC、OFB和CFB。DES为分组加密算法，分组长度大小为64位。实际应用中明文最后一组可能不足64位，不足数据可以使用各种padding模式做数据填充。下文中描述了各个padding的区别：
+	- NoPadding：不带填充；
+	- PKCS5：填充字符由一个字节序列组成，每个字节填充该填充字节序列的长度，规定是8字节填充；
+	- PKCS7：填充字符和PKCS5填充方法一致，但是可以在1-255字节之间任意填充；
+
+  > **说明：** ECB、CBC加密模式，明文长度不是64位整数倍，必须使用填充方法补足
+
+- **非对称RSA加解密**
+
+  当持有RSA公钥(n, e)和私钥(n, d)后，RSA加密过程为：密文 = 明文 ^ e mod n, 解密过程为：明文 = 密文 ^ d mod n。算法库目前提供了RSA加解密常用的三种模式：PKCS1、PKCS1_OAEP和NoPadding。RSA为块加密算法，加密长度需要在固定长度进行，实际应用中会使用各种padding模式做数据填充。下文中描述了各个padding的区别：
+	- NoPadding：不带填充，输入的数据必须与RSA钥模一样长，输出数据长度与RSA钥模一样长；
+	- PKCS1：pkcs1padding V1.5是RSA加解密默认的填充方式，输入的数据必须<=RSA钥模-11，输出数据长度与RSA钥模一样长；
+	- PKCS1_OAEP：RSA_PKCS1_OAEP_PADDING填充模式是PKCS#1推出的新填充方式，此模式需要设置两个摘要（md和mgf1_md），输入的数据必须小于RSA钥模 - md摘要长度 - mgf1_md摘要长度 - 2，输出数据长度与RSA钥模一样长；<br/>
+
+  **补充说明：** RSA钥模 = (RSA的bits + 7) / 8
+
+**签名验签**
+
+- **RSA签名验签**
+
+	当持有RSA公钥(n, e)和私钥(n, d)后，RSA签名生成过程为：签名 = 消息 ^ d mod n, 验签过程为：消息 = 签名 ^ d mod n。消息发送方发送数据时，同时发送消息和私钥签名后的签名信息，消息接收方接受到数据后，将签名信息用公钥解密并验证消息是否一致。因发送的消息长度大多大于RSA钥模，因此算法库框架提供了两种padding模式，通过摘要提取消息的散列值再做签名。算法库框架中提供了签名验签相关的两种模式：PKCS1和PSS。下问对两种模式做详细描述：
+  - PKCS1: pkcs1padding V1.5是RSA加解密默认的填充方式，使用该模式时需要设置摘要（md）；
+  - PSS: PSS模式是RSA 算法的基础上叠加上一种填充算法，使用该签名算法时需要使用摘要(md)和掩码函数（mgf1_md）;
+- **ECDSA**
+
+  椭圆曲线数字签名算法（ECDSA）是基于椭圆曲线密码（ECC）模拟数字签名算法（DSA）。相比普通的离散对数问题（DLP）和大数分解问题（IFP），椭圆曲线密码的单位比特强度要高于其他公钥体制。算法库框架提供了多种椭圆曲线及摘要算法组合的椭圆曲线数字签名算法（ECDSA）能力。
+
+**密钥协商**
+
+- **ECDH**
+
+  ECDH的全称是椭圆曲线迪菲-赫尔曼秘钥交换，是用来在一个非安全通道中建立起安全的共有加密资料，交换双方可以在不共享任何秘密的情况下协商出一个密钥。算法库框架基于开源算法库提供了多种椭圆曲线的ECDH能力。
+
+**摘要**
+
+消息摘要MD算法是一种能将任意长度的输入消息，通过哈希算法生成长度固定的摘要的算法。消息摘要算法通过其不可逆的特性能被用于敏感信息的加密。消息摘要算法也被称为哈希算法或单向散列算法。
+在摘要算法相同时，生成的摘要值主要有下列特点：
+
+- 当输入消息相同时，生成摘要序列相同； 
+- 当输入消息的长度不一致时，生成摘要序列长度固定（摘要长度由算法决定）； 
+- 当输入消息不一致时，生成摘要序列几乎不会相同（依然存在相同概率，由摘要长度决定相同概率）；
+
+消息摘要算法主要分为三类：MD，SHA与MAC（详见HMAC章节）
+MD算法包括MD2，MD4和MD5。
+SHA算法主要包括SHA1，SHA224，SHA256，SHA384，SHA512。
+
+**消息验证码**
+
+HMAC（Hash-based Message Authentication Code）是一种基于密钥的消息认证码算法。HMAC通过指定摘要算法，以通信双方共享密钥与消息作为输入，生成消息认证码用于检验传递报文的完整性，HMAC生成的消息认证码为固定长度。HMAC在消息摘要算法的基础上增加了密钥的输入，确保了信息的正确性。
+
+**随机数**
+
+随机数在加解密过程中主要用于临时会话密钥的生成与非对称加密算法中密钥的生成。随机数由硬件生成的硬件随机数生成器或由软件生成的伪随机数生成器进行生成。在加解密的场景中，安全随机数生成器需要具备随机性，不可预测性，与不可重现性。密码学安全伪随机数生成器CSPRNG（Cryptography Secure Random Number Generators）生成的随机数满足密码学安全伪随机性
+
+- **内部状态**代表随机数生成器内存中的数值，当内部状态相同时，随机数生成器会生成固定的随机数序列
+- **种子**（seed）是一个用来对伪随机数的内部状态进行初始化的数据，随机数生成器通过种子来生成一系列的随机序列。
+
+**证书**
+
+数字证书提供了一种数字验证用户、设备、业务身份的方式。X509证书是国际定制的标准格式。加解密算法库框架部件提供X509证书、X509证书吊销列表、证书链校验器相关的功能。
+
+- X509证书：提供X509证书的解析、序列化、X509证书签名验证、证书相关的信息查询等功能
+- X509证书吊销列表：提供X509证书吊销列表的解析、序列化、信息查询等功能
+- 证书链校验器：提供证书链校验（不包括证书有效期的校验）、证书链算法名称查询的功能
+
+## 约束与限制
+
+- 算法库框架不支持多线程并发操作。
+
+### 密钥生成规格
+
+**对称密钥生成规格**
+
+支持的对称密钥生成参数：
+
+|对称密钥算法|密钥长度|生成密钥的字符串参数|
+|---|---|---|
+|3DES|192|3DES192|
+|AES|128|AES128|
+|AES|192|AES192|
+|AES|256|AES256|
+
+**非对称密钥生成规格**
+- **RSA密钥生成**
+
+  支持的非对称密钥生成参数：
+
+  |非对称密钥算法|密钥长度|素数个数|生成密钥的字符串参数|
+  |---|---|---|---|
+  |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|
+
+  > **说明**：生成RSA非对称密钥时，默认素数为2，PRIMES_2参数可省略。
+
+- **ECC密钥生成**
+
+  支持的非对称密钥生成参数：
+
+  |非对称密钥算法|密钥长度|
+  |---|---|
+  |ECC|ECC224|
+  |ECC|ECC256|
+  |ECC|ECC384|
+  |ECC|ECC512|
+
+### 加解密规格
+
+**对称加解密**
+
+支持的对称加密算法：
+
+|对称加解密算法|分组模式|指定算法名称字符串|
+|---|---|---|
+|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]|
+
+> **说明：** []中只能任选一项
+
+**非对称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]
+
+> **说明：** []内的参数只能任选一项，非[]内的为固定值
+
+### 签名验签规格
+
+**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]
+> **说明：** []内的参数只能任选一项，非[]内的为固定值
+
+**ECDSA签名验签**
+
+支持的ECDSA参数：
+
+  |非对称密钥算法|支持种类|
+  |---|---|
+  |ECC|ECC224|
+  |ECC|ECC256|
+  |ECC|ECC384|
+  |ECC|ECC512|
+
+  |摘要算法|支持种类|
+  |---|---|
+  |HASH|SHA1|
+  |HASH|SHA224|
+  |HASH|SHA256|
+  |HASH|SHA384|
+  |HASH|SHA512|
+
+### 密钥协商规格
+
+**ECDH**
+
+  支持的ECDH参数：
+
+  |非对称密钥算法|支持种类|
+  |---|---|
+  |ECC|ECC224|
+  |ECC|ECC256|
+  |ECC|ECC384|
+  |ECC|ECC512|
+
+### MD算法规格
+加解密算法库框架当前支持MD5算法
+
+### SHA算法规格
+加解密算法库框架当前支持：SHA1，SHA224，SHA256，SHA384，SHA512
+
+### 证书规格
+
+- **证书链校验**<br/>
+
+  由于端侧系统时间不可信，证书链校验不包含对证书有效时间的校验。如果需要检查证书的时间有效性，可使用X509证书的checkValidityWithDate()方法进行检查。
+
+- **证书格式**
+  
+  目前支持DER与PEM格式的证书。