• 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. 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**).
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. 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**.
15
163. 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.
17
184. 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.
19
20
21**Decryption**
22
231. 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**.
24
252. 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.
26
273. 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.
28
29
30- Example (using asynchronous APIs):
31
32  ```ts
33  import { cryptoFramework } from '@kit.CryptoArchitectureKit';
34  import { buffer } from '@kit.ArkTS';
35
36  // Encrypt the message.
37  async function encryptMessagePromise(symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob) {
38    let cipher = cryptoFramework.createCipher('AES128|ECB|PKCS7');
39    await cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null); // If ECB mode is used, set params to null.
40    let cipherData = await cipher.doFinal(plainText);
41    return cipherData;
42  }
43  // Decrypt the message.
44  async function decryptMessagePromise(symKey: cryptoFramework.SymKey, cipherText: cryptoFramework.DataBlob) {
45    let decoder = cryptoFramework.createCipher('AES128|ECB|PKCS7');
46    await decoder.init(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null); // If ECB mode is used, set params to null.
47    let decryptData = await decoder.doFinal(cipherText);
48    return decryptData;
49  }
50
51  async function genSymKeyByData(symKeyData: Uint8Array) {
52    let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData };
53    let aesGenerator = cryptoFramework.createSymKeyGenerator('AES128');
54    let symKey = await aesGenerator.convertKey(symKeyBlob);
55    console.info('convertKey success');
56    return symKey;
57  }
58
59  async function aesECB() {
60    try {
61      let keyData = new Uint8Array([83, 217, 231, 76, 28, 113, 23, 219, 250, 71, 209, 210, 205, 97, 32, 159]);
62      let symKey = await genSymKeyByData(keyData);
63      let message = "This is a test";
64      let plainText: cryptoFramework.DataBlob = { data: new Uint8Array(buffer.from(message, 'utf-8').buffer) };
65      let encryptText = await encryptMessagePromise(symKey, plainText);
66      let decryptText = await decryptMessagePromise(symKey, encryptText);
67      if (plainText.data.toString() === decryptText.data.toString()) {
68        console.info('decrypt ok');
69        console.info('decrypt plainText: ' + buffer.from(decryptText.data).toString('utf-8'));
70      } else {
71        console.error('decrypt failed');
72      }
73    } catch (error) {
74      console.error(`AES ECB "${error}", error code: ${error.code}`);
75    }
76  }
77  ```
78
79- Example (using synchronous APIs):
80
81  ```ts
82  import { cryptoFramework } from '@kit.CryptoArchitectureKit';
83  import { buffer } from '@kit.ArkTS';
84
85  // Encrypt the message.
86  function encryptMessage(symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob) {
87    let cipher = cryptoFramework.createCipher('AES128|ECB|PKCS7');
88    cipher.initSync(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null); // If ECB mode is used, set params to null.
89    let cipherData = cipher.doFinalSync(plainText);
90    return cipherData;
91  }
92  // Decrypt the message.
93  function decryptMessage(symKey: cryptoFramework.SymKey, cipherText: cryptoFramework.DataBlob) {
94    let decoder = cryptoFramework.createCipher('AES128|ECB|PKCS7');
95    decoder.initSync(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null); // If ECB mode is used, set params to null.
96    let decryptData = decoder.doFinalSync(cipherText);
97    return decryptData;
98  }
99
100  function genSymKeyByData(symKeyData: Uint8Array) {
101    let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData };
102    let aesGenerator = cryptoFramework.createSymKeyGenerator('AES128');
103    let symKey = aesGenerator.convertKeySync(symKeyBlob);
104    console.info('convertKeySync success');
105    return symKey;
106  }
107
108  function main() {
109    try {
110      let keyData = new Uint8Array([83, 217, 231, 76, 28, 113, 23, 219, 250, 71, 209, 210, 205, 97, 32, 159]);
111      let symKey = genSymKeyByData(keyData);
112      let message = "This is a test";
113      let plainText: cryptoFramework.DataBlob = { data: new Uint8Array(buffer.from(message, 'utf-8').buffer) };
114      let encryptText = encryptMessage(symKey, plainText);
115      let decryptText = decryptMessage(symKey, encryptText);
116      if (plainText.data.toString() === decryptText.data.toString()) {
117        console.info('decrypt ok');
118        console.info('decrypt plainText: ' + buffer.from(decryptText.data).toString('utf-8'));
119      } else {
120        console.error('decrypt failed');
121      }
122    } catch (error) {
123      console.error(`AES ECB "${error}", error code: ${error.code}`);
124    }
125  }
126  ```
127