• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# Encryption and Decryption with an AES Symmetric Key (ECB Mode) (ArkTS)
2
3<!--Kit: Crypto Architecture Kit-->
4<!--Subsystem: Security-->
5<!--Owner: @zxz--3-->
6<!--Designer: @lanming-->
7<!--Tester: @PAFT-->
8<!--Adviser: @zengyawen-->
9
10For details, see [AES](crypto-sym-encrypt-decrypt-spec.md#aes).
11
12**Encryption**
13
141. Call [cryptoFramework.createSymKeyGenerator](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#cryptoframeworkcreatesymkeygenerator) and [SymKeyGenerator.generateSymKey](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#generatesymkey-1) to generate a 128-bit AES symmetric key (**SymKey**).
15
16   For details about how to generate an AES symmetric key, see the following example. To learn more, see [Symmetric Key Generation and Conversion Specifications: AES](crypto-sym-key-generation-conversion-spec.md#aes) and [Randomly Generating a Symmetric Key](crypto-generate-sym-key-randomly.md). There may be differences between the input parameters in the reference documents and those in the following example.
17
182. Call [cryptoFramework.createCipher](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#cryptoframeworkcreatecipher) with the string parameter **'AES128|ECB|PKCS7'** to create a **Cipher** instance for encryption. The key type is **AES128**, block cipher mode is **ECB**, and the padding mode is **PKCS7**.
19
203. Call [Cipher.init](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#init-1) to initialize the **Cipher** instance. In the **Cipher.init** API, set **opMode** to **CryptoMode.ENCRYPT_MODE** (encryption), **key** to **SymKey** (the key for encryption), and **params** to **null** for the ECB mode.
21
224. If a small amount of data is to be encrypted, you can use [Cipher.doFinal](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#dofinal-1) after **Cipher.init** to obtain the encrypted data.
23
24**Decryption**
25
261. Call [cryptoFramework.createCipher](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#cryptoframeworkcreatecipher) with the string parameter **'AES128|ECB|PKCS7'** to create a **Cipher** instance for decryption. The key type is **AES128**, block cipher mode is **ECB**, and the padding mode is **PKCS7**.
27
282. Call [Cipher.init](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#init-1) to initialize the **Cipher** instance. In the **Cipher.init** API, set **opMode** to **CryptoMode.DECRYPT_MODE** (decryption), **key** to **SymKey** (the key for decryption), and **params** to **null** for the ECB mode.
29
303. If a small amount of data is to be decrypted, you can use [Cipher.doFinal](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#dofinal-1) after **Cipher.init** to obtain the decrypted data.
31
32- Example (using asynchronous APIs):
33
34  ```ts
35  import { cryptoFramework } from '@kit.CryptoArchitectureKit';
36  import { buffer } from '@kit.ArkTS';
37
38  // Encrypt the message.
39  async function encryptMessagePromise(symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob) {
40    let cipher = cryptoFramework.createCipher('AES128|ECB|PKCS7');
41    await cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null); // If ECB mode is used, set params to null.
42    let cipherData = await cipher.doFinal(plainText);
43    return cipherData;
44  }
45  // Decrypt the message.
46  async function decryptMessagePromise(symKey: cryptoFramework.SymKey, cipherText: cryptoFramework.DataBlob) {
47    let decoder = cryptoFramework.createCipher('AES128|ECB|PKCS7');
48    await decoder.init(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null); // If ECB mode is used, set params to null.
49    let decryptData = await decoder.doFinal(cipherText);
50    return decryptData;
51  }
52
53  async function genSymKeyByData(symKeyData: Uint8Array) {
54    let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData };
55    let aesGenerator = cryptoFramework.createSymKeyGenerator('AES128');
56    let symKey = await aesGenerator.convertKey(symKeyBlob);
57    console.info('convertKey success');
58    return symKey;
59  }
60
61  async function aesECB() {
62    try {
63      let keyData = new Uint8Array([83, 217, 231, 76, 28, 113, 23, 219, 250, 71, 209, 210, 205, 97, 32, 159]);
64      let symKey = await genSymKeyByData(keyData);
65      let message = "This is a test";
66      let plainText: cryptoFramework.DataBlob = { data: new Uint8Array(buffer.from(message, 'utf-8').buffer) };
67      let encryptText = await encryptMessagePromise(symKey, plainText);
68      let decryptText = await decryptMessagePromise(symKey, encryptText);
69      if (plainText.data.toString() === decryptText.data.toString()) {
70        console.info('decrypt ok');
71        console.info('decrypt plainText: ' + buffer.from(decryptText.data).toString('utf-8'));
72      } else {
73        console.error('decrypt failed');
74      }
75    } catch (error) {
76      console.error(`AES ECB "${error}", error code: ${error.code}`);
77    }
78  }
79  ```
80
81- Example (using synchronous APIs):
82
83  ```ts
84  import { cryptoFramework } from '@kit.CryptoArchitectureKit';
85  import { buffer } from '@kit.ArkTS';
86
87  // Encrypt the message.
88  function encryptMessage(symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob) {
89    let cipher = cryptoFramework.createCipher('AES128|ECB|PKCS7');
90    cipher.initSync(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null); // If ECB mode is used, set params to null.
91    let cipherData = cipher.doFinalSync(plainText);
92    return cipherData;
93  }
94  // Decrypt the message.
95  function decryptMessage(symKey: cryptoFramework.SymKey, cipherText: cryptoFramework.DataBlob) {
96    let decoder = cryptoFramework.createCipher('AES128|ECB|PKCS7');
97    decoder.initSync(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null); // If ECB mode is used, set params to null.
98    let decryptData = decoder.doFinalSync(cipherText);
99    return decryptData;
100  }
101
102  function genSymKeyByData(symKeyData: Uint8Array) {
103    let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData };
104    let aesGenerator = cryptoFramework.createSymKeyGenerator('AES128');
105    let symKey = aesGenerator.convertKeySync(symKeyBlob);
106    console.info('convertKeySync success');
107    return symKey;
108  }
109
110  function main() {
111    try {
112      let keyData = new Uint8Array([83, 217, 231, 76, 28, 113, 23, 219, 250, 71, 209, 210, 205, 97, 32, 159]);
113      let symKey = genSymKeyByData(keyData);
114      let message = "This is a test";
115      let plainText: cryptoFramework.DataBlob = { data: new Uint8Array(buffer.from(message, 'utf-8').buffer) };
116      let encryptText = encryptMessage(symKey, plainText);
117      let decryptText = decryptMessage(symKey, encryptText);
118      if (plainText.data.toString() === decryptText.data.toString()) {
119        console.info('decrypt ok');
120        console.info('decrypt plainText: ' + buffer.from(decryptText.data).toString('utf-8'));
121      } else {
122        console.error('decrypt failed');
123      }
124    } catch (error) {
125      console.error(`AES ECB "${error}", error code: ${error.code}`);
126    }
127  }
128  ```
129