• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# Encryption and Decryption with a DES 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 about the algorithm specifications, see [DES](crypto-sym-encrypt-decrypt-spec.md#des).
11
12**Encryption**
13
141. 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 64-bit DES symmetric key (**SymKey**).
15
16   In addition to the example in this topic, [DES](crypto-sym-key-generation-conversion-spec.md#des) 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 DES symmetric key pair. Note that the input parameters in the reference documents may be different from those in the example below.
17
182. Call [cryptoFramework.createCipher](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#cryptoframeworkcreatecipher) with the string parameter **'DES64|ECB|PKCS7'** to create a **Cipher** instance for encryption. The key type is **DES64**, 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 **Cipher.init**, set **opMode** to **CryptoMode.ENCRYPT_MODE** (encryption) and **key** to **SymKey** (the key used for encryption).
21
22   If ECB mode is used, pass in **null**.
23
244. Call [Cipher.update](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#update-1) to pass in the data to be encrypted (plaintext).
25
26   - If a small amount of data is to be encrypted, you can use **Cipher.doFinal** immediately after **Cipher.init**.
27   - If a large amount of data is to be encrypted, you can call **Cipher.update** multiple times to pass in the data by segment.
28   - 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**.
29
305. Call [Cipher.doFinal](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#dofinal-1) to obtain the encrypted data.
31
32   - If data has been passed in by **Cipher.update**, pass in **null** in the **data** parameter of **Cipher.doFinal**.
33   - The output of **Cipher.doFinal** may be **null**. To avoid exceptions, always check whether the result is **null** before accessing specific data.
34
35**Decryption**
36
371. Call [cryptoFramework.createCipher](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#cryptoframeworkcreatecipher) with the string parameter **'DES64|ECB|PKCS7'** to create a **Cipher** instance for decryption. The key type is **DES64**, block cipher mode is **ECB**, and the padding mode is **PKCS7**.
38
392. 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). If ECB mode is used, pass in **null**.
40
413. Call [Cipher.update](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#update-1) to pass in the data to be decrypted (ciphertext).
42
434. Call [Cipher.doFinal](../../reference/apis-crypto-architecture-kit/js-apis-cryptoFramework.md#dofinal-1) to obtain the decrypted data.
44
45- Example (using asynchronous APIs):
46
47  ```ts
48  import { cryptoFramework } from '@kit.CryptoArchitectureKit';
49  import { buffer } from '@kit.ArkTS';
50
51  // Encrypt the message.
52  async function encryptMessagePromise(symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob) {
53    let cipher = cryptoFramework.createCipher('DES64|ECB|PKCS7');
54    await cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null);
55    let encryptData = await cipher.doFinal(plainText);
56    return encryptData;
57  }
58  // Decrypt the message.
59  async function decryptMessagePromise(symKey: cryptoFramework.SymKey, cipherText: cryptoFramework.DataBlob) {
60    let decoder = cryptoFramework.createCipher('DES64|ECB|PKCS7');
61    await decoder.init(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null);
62    let decryptData = await decoder.doFinal(cipherText);
63    return decryptData;
64  }
65  async function genSymKeyByData(symKeyData: Uint8Array) {
66    let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData };
67    let symGenerator = cryptoFramework.createSymKeyGenerator('DES64');
68    let symKey = await symGenerator.convertKey(symKeyBlob);
69    console.info('convertKey success');
70    return symKey;
71  }
72  async function main() {
73    let keyData = new Uint8Array([238, 249, 61, 55, 128, 220, 183, 224]);
74    let symKey = await genSymKeyByData(keyData);
75    let message = "This is a test";
76    let plainText: cryptoFramework.DataBlob = { data: new Uint8Array(buffer.from(message, 'utf-8').buffer) };
77    let encryptText = await encryptMessagePromise(symKey, plainText);
78    let decryptText = await decryptMessagePromise(symKey, encryptText);
79    if (plainText.data.toString() === decryptText.data.toString()) {
80      console.info('decrypt ok');
81      console.info('decrypt plainText: ' + buffer.from(decryptText.data).toString('utf-8'));
82    } else {
83      console.error('decrypt failed');
84    }
85  }
86  ```
87
88- Example (using synchronous APIs):
89
90  ```ts
91  import { cryptoFramework } from '@kit.CryptoArchitectureKit';
92  import { buffer } from '@kit.ArkTS';
93
94  // Encrypt the message.
95  function encryptMessage(symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob) {
96    let cipher = cryptoFramework.createCipher('DES64|ECB|PKCS7');
97    cipher.initSync(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null);
98    let encryptData = cipher.doFinalSync(plainText);
99    return encryptData;
100  }
101  // Decrypt the message.
102  function decryptMessage(symKey: cryptoFramework.SymKey, cipherText: cryptoFramework.DataBlob) {
103    let decoder = cryptoFramework.createCipher('DES64|ECB|PKCS7');
104    decoder.initSync(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null);
105    let decryptData = decoder.doFinalSync(cipherText);
106    return decryptData;
107  }
108  function genSymKeyByData(symKeyData: Uint8Array) {
109    let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData };
110    let symGenerator = cryptoFramework.createSymKeyGenerator('DES64');
111    let symKey = symGenerator.convertKeySync(symKeyBlob);
112    console.info('convertKeySync success');
113    return symKey;
114  }
115  function main() {
116    let keyData = new Uint8Array([238, 249, 61, 55, 128, 220, 183, 224]);
117    let symKey = genSymKeyByData(keyData);
118    let message = "This is a test";
119    let plainText: cryptoFramework.DataBlob = { data: new Uint8Array(buffer.from(message, 'utf-8').buffer) };
120    let encryptText = encryptMessage(symKey, plainText);
121    let decryptText = decryptMessage(symKey, encryptText);
122    if (plainText.data.toString() === decryptText.data.toString()) {
123      console.info('decrypt ok');
124      console.info('decrypt plainText: ' + buffer.from(decryptText.data).toString('utf-8'));
125    } else {
126      console.error('decrypt failed');
127    }
128  }
129  ```
130