• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# 使用SM4对称密钥（GCM模式）加解密(ArkTS)
2
3<!--Kit: Crypto Architecture Kit-->
4<!--Subsystem: Security-->
5<!--Owner: @zxz--3-->
6<!--Designer: @lanming-->
7<!--Tester: @PAFT-->
8<!--Adviser: @zengyawen-->
9
10对应的算法规格请查看[对称密钥加解密算法规格：SM4](crypto-sym-encrypt-decrypt-spec.md#sm4)。
11
12**加密**
13
141. 调用[cryptoFramework.createSymKeyGenerator](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#cryptoframeworkcreatesymkeygenerator)、[SymKeyGenerator.generateSymKey](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#generatesymkey-1)，生成密钥算法为SM4、密钥长度为128位的对称密钥（SymKey）。
15
16   如何生成SM4对称密钥，开发者可参考下文示例，并结合[对称密钥生成和转换规格：SM4](crypto-sym-key-generation-conversion-spec.md#sm4)和[随机生成对称密钥](crypto-generate-sym-key-randomly.md)理解，参考文档与当前示例可能存在入参差异，请在阅读时注意区分。
17
182. 调用[cryptoFramework.createCipher](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#cryptoframeworkcreatecipher)，指定字符串参数'SM4_128|GCM|PKCS7'，创建对称密钥类型为SM4_128、分组模式为GCM、填充模式为PKCS7的Cipher实例，用于完成加密操作。
19
203. 调用[Cipher.init](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#init-1)，设置模式为加密（CryptoMode.ENCRYPT_MODE），指定加密密钥（SymKey）和GCM模式对应的加密参数（GcmParamsSpec），初始化加密Cipher实例。
21
224. 调用[Cipher.update](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#update-1)，更新数据（明文）。
23
24   当前单次update长度没有限制，开发者可以根据数据量判断如何调用update。
25
26   - 当数据量较小时，可以在init完成后直接调用doFinal。
27   - 当数据量较大时，可以多次调用update，即[分段加解密](crypto-sm4-sym-encrypt-decrypt-gcm-by-segment.md)。
28
295. 调用[Cipher.doFinal](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#dofinal-1)，获取加密后的数据。
30   - 由于已使用update传入数据，此处data传入null。
31   - doFinal输出结果可能为null，在访问具体数据前，需要先判断结果是否为null，避免产生异常。
32
336. 读取[GcmParamsSpec](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#gcmparamsspec).authTag作为解密的认证信息。
34   在GCM模式下，需要从加密后的数据中取出末尾16字节，作为解密时初始化的认证信息。示例中authTag恰好为16字节。
35
36**解密**
37
381. 调用[cryptoFramework.createCipher](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#cryptoframeworkcreatecipher)，指定字符串参数'SM4_128|GCM|PKCS7'，创建对称密钥类型为SM4_128、分组模式为GCM、填充模式为PKCS7的Cipher实例，用于完成解密操作。
39
402. 调用[Cipher.init](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#init-1)，设置模式为解密（CryptoMode.DECRYPT_MODE），指定解密密钥（SymKey）和GCM模式对应的解密参数（GcmParamsSpec），初始化解密Cipher实例。
41
423. 调用[Cipher.update](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#update-1)，更新数据（密文）。
43
444. 调用[Cipher.doFinal](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#dofinal-1)，获取解密后的数据。
45
46- 异步方法示例：
47
48  ```ts
49  import { cryptoFramework } from '@kit.CryptoArchitectureKit';
50  import { buffer } from '@kit.ArkTS';
51
52  function generateRandom(len: number) {
53    let rand = cryptoFramework.createRandom();
54    let generateRandSync = rand.generateRandomSync(len);
55    return generateRandSync;
56  }
57
58  function genGcmParamsSpec() {
59    let ivBlob = generateRandom(12); // 12 bytes
60    let arr = [1, 2, 3, 4, 5, 6, 7, 8]; // 8 bytes
61    let dataAad = new Uint8Array(arr);
62    let aadBlob: cryptoFramework.DataBlob = { data: dataAad };
63    arr = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; // 16 bytes
64    let dataTag = new Uint8Array(arr);
65    let tagBlob: cryptoFramework.DataBlob = {
66      data: dataTag
67    };
68    // GCM的authTag在加密时从doFinal结果中获取，在解密时填入init函数的params参数中。
69    let gcmParamsSpec: cryptoFramework.GcmParamsSpec = {
70      iv: ivBlob,
71      aad: aadBlob,
72      authTag: tagBlob,
73      algName: "GcmParamsSpec"
74    };
75    return gcmParamsSpec;
76  }
77
78  let gcmParams = genGcmParamsSpec();
79
80  // 加密消息。
81  async function encryptMessagePromise(symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob) {
82    let cipher = cryptoFramework.createCipher('SM4_128|GCM|PKCS7');
83    await cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, gcmParams);
84    let encryptUpdate = await cipher.update(plainText);
85    // gcm模式加密doFinal时传入空，获得tag数据，并更新至gcmParams对象中。
86    gcmParams.authTag = await cipher.doFinal(null);
87    return encryptUpdate;
88  }
89  // 解密消息。
90  async function decryptMessagePromise(symKey: cryptoFramework.SymKey, cipherText: cryptoFramework.DataBlob) {
91    let decoder = cryptoFramework.createCipher('SM4_128|GCM|PKCS7');
92    await decoder.init(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, gcmParams);
93    let decryptUpdate = await decoder.update(cipherText);
94    // gcm模式解密doFinal时传入空，验证init时传入的tag数据，如果验证失败会抛出异常。
95    let decryptData = await decoder.doFinal(null);
96    if (decryptData === null) {
97      console.info('GCM decrypt success, decryptData is null');
98    }
99    return decryptUpdate;
100  }
101  async function genSymKeyByData(symKeyData: Uint8Array) {
102    let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData };
103    let sm4Generator = cryptoFramework.createSymKeyGenerator('SM4_128');
104    let symKey = await sm4Generator.convertKey(symKeyBlob);
105    console.info('convertKey success');
106    return symKey;
107  }
108  async function main() {
109    let keyData = new Uint8Array([83, 217, 231, 76, 28, 113, 23, 219, 250, 71, 209, 210, 205, 97, 32, 159]);
110    let symKey = await genSymKeyByData(keyData);
111    let message = "This is a test";
112    let plainText: cryptoFramework.DataBlob = { data: new Uint8Array(buffer.from(message, 'utf-8').buffer) };
113    let encryptText = await encryptMessagePromise(symKey, plainText);
114    let decryptText = await decryptMessagePromise(symKey, encryptText);
115    if (plainText.data.toString() === decryptText.data.toString()) {
116      console.info('decrypt ok');
117      console.info('decrypt plainText: ' + buffer.from(decryptText.data).toString('utf-8'));
118    } else {
119      console.error('decrypt failed');
120    }
121  }
122  ```
123
124- 同步方法示例：
125
126  ```ts
127  import { cryptoFramework } from '@kit.CryptoArchitectureKit';
128  import { buffer } from '@kit.ArkTS';
129
130  function generateRandom(len: number) {
131    let rand = cryptoFramework.createRandom();
132    let generateRandSync = rand.generateRandomSync(len);
133    return generateRandSync;
134  }
135
136  function genGcmParamsSpec() {
137    let ivBlob = generateRandom(12); // 12 bytes
138    let arr = [1, 2, 3, 4, 5, 6, 7, 8]; // 8 bytes
139    let dataAad = new Uint8Array(arr);
140    let aadBlob: cryptoFramework.DataBlob = { data: dataAad };
141    arr = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; // 16 bytes
142    let dataTag = new Uint8Array(arr);
143    let tagBlob: cryptoFramework.DataBlob = {
144      data: dataTag
145    };
146    // GCM的authTag在加密时从doFinal结果中获取，在解密时填入init函数的params参数中。
147    let gcmParamsSpec: cryptoFramework.GcmParamsSpec = {
148      iv: ivBlob,
149      aad: aadBlob,
150      authTag: tagBlob,
151      algName: "GcmParamsSpec"
152    };
153    return gcmParamsSpec;
154  }
155
156  let gcmParams = genGcmParamsSpec();
157
158  // 加密消息。
159  function encryptMessage(symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob) {
160    let cipher = cryptoFramework.createCipher('SM4_128|GCM|PKCS7');
161    cipher.initSync(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, gcmParams);
162    let encryptUpdate = cipher.updateSync(plainText);
163    // gcm模式加密doFinal时传入空，获得tag数据，并更新至gcmParams对象中。
164    gcmParams.authTag = cipher.doFinalSync(null);
165    return encryptUpdate;
166  }
167  // 解密消息。
168  function decryptMessage(symKey: cryptoFramework.SymKey, cipherText: cryptoFramework.DataBlob) {
169    let decoder = cryptoFramework.createCipher('SM4_128|GCM|PKCS7');
170    decoder.initSync(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, gcmParams);
171    let decryptUpdate = decoder.updateSync(cipherText);
172    // gcm模式解密doFinal时传入空，验证init时传入的tag数据，如果验证失败会抛出异常。
173    let decryptData = decoder.doFinalSync(null);
174    if (decryptData === null) {
175      console.info('GCM decrypt success, decryptData is null');
176    }
177    return decryptUpdate;
178  }
179  function genSymKeyByData(symKeyData: Uint8Array) {
180    let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData };
181    let sm4Generator = cryptoFramework.createSymKeyGenerator('SM4_128');
182    let symKey = sm4Generator.convertKeySync(symKeyBlob);
183    console.info('convertKeySync success');
184    return symKey;
185  }
186  function main() {
187    let keyData = new Uint8Array([83, 217, 231, 76, 28, 113, 23, 219, 250, 71, 209, 210, 205, 97, 32, 159]);
188    let symKey = genSymKeyByData(keyData);
189    let message = "This is a test";
190    let plainText: cryptoFramework.DataBlob = { data: new Uint8Array(buffer.from(message, 'utf-8').buffer) };
191    let encryptText = encryptMessage(symKey, plainText);
192    let decryptText = decryptMessage(symKey, encryptText);
193    if (plainText.data.toString() === decryptText.data.toString()) {
194      console.info('decrypt ok');
195      console.info('decrypt plainText: ' + buffer.from(decryptText.data).toString('utf-8'));
196    } else {
197      console.error('decrypt failed');
198    }
199  }
200  ```