• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# Encryption and Decryption with a 3DES Symmetric Key (ECB Mode) (ArkTS)
2
3
4For details about the algorithm specifications, see [3DES](crypto-sym-encrypt-decrypt-spec.md#3des).
5
6
7**Encryption**
8
9
101. Call [cryptoFramework.createSymKeyGenerator](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#cryptoframeworkcreatesymkeygenerator) and [SymKeyGenerator.convertKey](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#convertkey-1) to generate a 192-bit 3DES symmetric key (**SymKey**).
11
12   In addition to the example in this topic, [3DES](crypto-sym-key-generation-conversion-spec.md#3des) and [Converting Binary Data into a Symmetric Key](crypto-convert-binary-data-to-sym-key.md) may help you better understand how to generate a 3DES symmetric key pair. 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 **'3DES192|ECB|PKCS7'** to create a **Cipher** instance for encryption. The key type is **3DES192**, 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 **Cipher.init**, set **opMode** to **CryptoMode.ENCRYPT_MODE** (encryption) and **key** to **SymKey** (the key used for encryption).
17
18   When ECB mode is used, pass in **null** in **params**.
19
204. Call [Cipher.update](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#update-1) to pass in the data to be encrypted (plaintext).
21
22   - If a small amount of data is to be encrypted, you can use **Cipher.doFinal** immediately after **Cipher.init**.
23   - If a large amount of data is to be encrypted, you can call **Cipher.update** multiple times to pass in the data by segment.
24   - You can determine the method to use based on the data size. For example, if the message is greater than 20 bytes, use **Cipher.update**.
25
265. Call [Cipher.doFinal](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#dofinal-1) to obtain the encrypted data.
27
28   - If data has been passed in by **Cipher.update**, pass in **null** in the **data** parameter of **Cipher.doFinal**.
29   - The output of **Cipher.doFinal** may be **null**. To avoid exceptions, always check whether the result is **null** before accessing specific data.
30
31
32**Decryption**
33
341. Call [cryptoFramework.createCipher](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#cryptoframeworkcreatecipher) with the string parameter **'3DES192|ECB|PKCS7'** to create a **Cipher** instance for decryption. The key type is **3DES192**, block cipher mode is **ECB**, and the padding mode is **PKCS7**.
35
362. Call [Cipher.init](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#init-1) to initialize the **Cipher** instance. In **Cipher.init**, set **opMode** to **CryptoMode.DECRYPT_MODE** (decryption) and **key** to **SymKey** (the key used for decryption). When ECB mode is used, pass in **null** in **params**.
37
383. Call [Cipher.update](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#update-1) to pass in the data to be decrypted (ciphertext).
39
404. Call [Cipher.doFinal](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#dofinal-1) to obtain the decrypted data.
41
42- Example (using asynchronous APIs):
43
44  ```ts
45  import { cryptoFramework } from '@kit.CryptoArchitectureKit';
46  import { buffer } from '@kit.ArkTS';
47
48  // Encrypt the message.
49  async function encryptMessagePromise(symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob) {
50    let cipher = cryptoFramework.createCipher('3DES192|ECB|PKCS7');
51    await cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null);
52    let encryptData = await cipher.doFinal(plainText);
53    return encryptData;
54  }
55  // Decrypt the message.
56  async function decryptMessagePromise(symKey: cryptoFramework.SymKey, cipherText: cryptoFramework.DataBlob) {
57    let decoder = cryptoFramework.createCipher('3DES192|ECB|PKCS7');
58    await decoder.init(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null);
59    let decryptData = await decoder.doFinal(cipherText);
60    return decryptData;
61  }
62  async function genSymKeyByData(symKeyData: Uint8Array) {
63    let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData };
64    let symGenerator = cryptoFramework.createSymKeyGenerator('3DES192');
65    let symKey = await symGenerator.convertKey(symKeyBlob);
66    console.info('convertKey success');
67    return symKey;
68  }
69  async function main() {
70    let keyData = new Uint8Array([238, 249, 61, 55, 128, 220, 183, 224, 139, 253, 248, 239, 239, 41, 71, 25, 235, 206, 230, 162, 249, 27, 234, 114]);
71    let symKey = await genSymKeyByData(keyData);
72    let message = "This is a test";
73    let plainText: cryptoFramework.DataBlob = { data: new Uint8Array(buffer.from(message, 'utf-8').buffer) };
74    let encryptText = await encryptMessagePromise(symKey, plainText);
75    let decryptText = await decryptMessagePromise(symKey, encryptText);
76    if (plainText.data.toString() === decryptText.data.toString()) {
77      console.info('decrypt ok');
78      console.info('decrypt plainText: ' + buffer.from(decryptText.data).toString('utf-8'));
79    } else {
80      console.error('decrypt failed');
81    }
82  }
83  ```
84
85- Example (using synchronous APIs):
86
87  ```ts
88  import { cryptoFramework } from '@kit.CryptoArchitectureKit';
89  import { buffer } from '@kit.ArkTS';
90
91  // Encrypt the message.
92  function encryptMessage(symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob) {
93    let cipher = cryptoFramework.createCipher('3DES192|ECB|PKCS7');
94    cipher.initSync(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null);
95    let encryptData = cipher.doFinalSync(plainText);
96    return encryptData;
97  }
98  // Decrypt the message.
99  function decryptMessage(symKey: cryptoFramework.SymKey, cipherText: cryptoFramework.DataBlob) {
100    let decoder = cryptoFramework.createCipher('3DES192|ECB|PKCS7');
101    decoder.initSync(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null);
102    let decryptData = decoder.doFinalSync(cipherText);
103    return decryptData;
104  }
105  function genSymKeyByData(symKeyData: Uint8Array) {
106    let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData };
107    let symGenerator = cryptoFramework.createSymKeyGenerator('3DES192');
108    let symKey = symGenerator.convertKeySync(symKeyBlob);
109    console.info('convertKeySync success');
110    return symKey;
111  }
112  function main() {
113    let keyData = new Uint8Array([238, 249, 61, 55, 128, 220, 183, 224, 139, 253, 248, 239, 239, 41, 71, 25, 235, 206, 230, 162, 249, 27, 234, 114]);
114    let symKey = genSymKeyByData(keyData);
115    let message = "This is a test";
116    let plainText: cryptoFramework.DataBlob = { data: new Uint8Array(buffer.from(message, 'utf-8').buffer) };
117    let encryptText = encryptMessage(symKey, plainText);
118    let decryptText = decryptMessage(symKey, encryptText);
119    if (plainText.data.toString() === decryptText.data.toString()) {
120      console.info('decrypt ok');
121      console.info('decrypt plainText: ' + buffer.from(decryptText.data).toString('utf-8'));
122    } else {
123      console.error('decrypt failed');
124    }
125  }
126  ```
127