• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# Encryption and Decryption with an AES Symmetric Key (ECB Mode) (ArkTS)
2
3
4For details about the algorithm specifications, see [AES](crypto-sym-encrypt-decrypt-spec.md#aes).
5
6
7**Encryption**
8
9
101. Use [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**).
11
12   In addition to the example in this topic, [AES](crypto-sym-key-generation-conversion-spec.md#aes) and [Randomly Generating a Symmetric Key](crypto-generate-sym-key-randomly.md) may help you better understand how to generate an AES symmetric key. Note that the input parameters in the reference documents may be different from those in the example below.
13
142. Use [cryptoFramework.createCipher](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#cryptoframeworkcreatecipher) with the string parameter **'AES128|ECB|PKCS7'** to create a **Cipher** instance. The key type is **AES128**, block cipher mode is **ECB**, and the padding mode is **PKCS7**.
15
163. Use [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 **IvParamsSpec** corresponding to the ECB mode.
17
184. If a small amount of data is to be encrypted, use [Cipher.doFinal](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#dofinal-1) after **Cipher.init** to generate the ciphertext.
19
20**Decryption**
21
22
231. Use [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 **IvParamsSpec** corresponding to the ECB mode.
24
252. 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 generate the plaintext.
26
27
28- Example (using asynchronous APIs):
29
30  ```ts
31  import { cryptoFramework } from '@kit.CryptoArchitectureKit';
32  import { buffer } from '@kit.ArkTS';
33
34  // Encrypt the message.
35  async function encryptMessagePromise(symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob) {
36    let cipher = cryptoFramework.createCipher('AES128|ECB|PKCS7');
37    await cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null);
38    let cipherData = await cipher.doFinal(plainText);
39    return cipherData;
40  }
41  // Decrypt the message.
42  async function decryptMessagePromise(symKey: cryptoFramework.SymKey, cipherText: cryptoFramework.DataBlob) {
43    let decoder = cryptoFramework.createCipher('AES128|ECB|PKCS7');
44    await decoder.init(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null);
45    let decryptData = await decoder.doFinal(cipherText);
46    return decryptData;
47  }
48
49  async function genSymKeyByData(symKeyData: Uint8Array) {
50    let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData };
51    let aesGenerator = cryptoFramework.createSymKeyGenerator('AES128');
52    let symKey = await aesGenerator.convertKey(symKeyBlob);
53    console.info('convertKey success');
54    return symKey;
55  }
56
57  async function aesECB() {
58    try {
59      let keyData = new Uint8Array([83, 217, 231, 76, 28, 113, 23, 219, 250, 71, 209, 210, 205, 97, 32, 159]);
60      let symKey = await genSymKeyByData(keyData);
61      let message = "This is a test";
62      let plainText: cryptoFramework.DataBlob = { data: new Uint8Array(buffer.from(message, 'utf-8').buffer) };
63      let encryptText = await encryptMessagePromise(symKey, plainText);
64      let decryptText = await decryptMessagePromise(symKey, encryptText);
65      if (plainText.data.toString() === decryptText.data.toString()) {
66        console.info('decrypt ok');
67        console.info('decrypt plainText: ' + buffer.from(decryptText.data).toString('utf-8'));
68      } else {
69        console.error('decrypt failed');
70      }
71    } catch (error) {
72      console.error(`AES ECB "${error}", error code: ${error.code}`);
73    }
74  }
75  ```
76
77- Example (using synchronous APIs):
78
79  ```ts
80  import { cryptoFramework } from '@kit.CryptoArchitectureKit';
81  import { buffer } from '@kit.ArkTS';
82
83  // Encrypt the message.
84  function encryptMessage(symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob) {
85    let cipher = cryptoFramework.createCipher('AES128|ECB|PKCS7');
86    cipher.initSync(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null);
87    let cipherData = cipher.doFinalSync(plainText);
88    return cipherData;
89  }
90  // Decrypt the message.
91  function decryptMessage(symKey: cryptoFramework.SymKey, cipherText: cryptoFramework.DataBlob) {
92    let decoder = cryptoFramework.createCipher('AES128|ECB|PKCS7');
93    decoder.initSync(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null);
94    let decryptData = decoder.doFinalSync(cipherText);
95    return decryptData;
96  }
97
98  async function genSymKeyByData(symKeyData: Uint8Array) {
99    let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData };
100    let aesGenerator = cryptoFramework.createSymKeyGenerator('AES128');
101    let symKey = await aesGenerator.convertKey(symKeyBlob);
102    console.info('convertKey success');
103    return symKey;
104  }
105
106  async function main() {
107    try {
108      let keyData = new Uint8Array([83, 217, 231, 76, 28, 113, 23, 219, 250, 71, 209, 210, 205, 97, 32, 159]);
109      let symKey = await genSymKeyByData(keyData);
110      let message = "This is a test";
111      let plainText: cryptoFramework.DataBlob = { data: new Uint8Array(buffer.from(message, 'utf-8').buffer) };
112      let encryptText = encryptMessage(symKey, plainText);
113      let decryptText = decryptMessage(symKey, encryptText);
114      if (plainText.data.toString() === decryptText.data.toString()) {
115        console.info('decrypt ok');
116        console.info('decrypt plainText: ' + buffer.from(decryptText.data).toString('utf-8'));
117      } else {
118        console.error('decrypt failed');
119      }
120    } catch (error) {
121      console.error(`AES ECB "${error}", error code: ${error.code}`);
122    }
123  }
124  ```
125