Encryption and Decryption with a DES Symmetric Key (ECB Mode) (ArkTS)

For details about the algorithm specifications, see DES.

Encryption

1. Call cryptoFramework.createSymKeyGenerator and SymKeyGenerator.convertKey to generate a 64-bit DES symmetric key (SymKey).

   In addition to the example in this topic, DES and Converting Binary Data into a Symmetric Key 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.

2. Call cryptoFramework.createCipher 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.

3. Call Cipher.init to initialize the Cipher instance. Specifically, set the mode to cryptoFramework.CryptoMode.ENCRYPT_MODE (encryption) and key to SymKey (the key used for encryption).

   If ECB mode is used, pass in null.

4. Call Cipher.update to pass in the data to be encrypted (plaintext).

   • If a small amount of data is to be encrypted, you can use Cipher.doFinal immediately after Cipher.init.
   • If a large amount of data is to be encrypted, you can call Cipher.update multiple times to pass in the data by segment.
   • 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.

5. Call Cipher.doFinal to obtain the encrypted data.

   • If data has been passed in by Cipher.update, pass in null in the data parameter of Cipher.doFinal.
   • The output of Cipher.doFinal may be null. To avoid exceptions, always check whether the result is null before accessing specific data.

Decryption

1. Call cryptoFramework.createCipher 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.

2. Call Cipher.init to initialize the Cipher instance. Specifically, set the mode to cryptoFramework.CryptoMode.DECRYPT_MODE (decryption) and key to SymKey (the key used for decryption). If ECB mode is used, pass in null.

3. Call Cipher.update to pass in the data to be decrypted (ciphertext).

4. Call Cipher.doFinal to obtain the decrypted data.

• Example (using asynchronous APIs):

  import { cryptoFramework } from '@kit.CryptoArchitectureKit';
  import { buffer } from '@kit.ArkTS';
  
  // Encrypt the message.
  async function encryptMessagePromise(symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob) {
    let cipher = cryptoFramework.createCipher('DES64|ECB|PKCS7');
    await cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null);
    let encryptData = await cipher.doFinal(plainText);
    return encryptData;
  }
  
  // Decrypt the message.
  async function decryptMessagePromise(symKey: cryptoFramework.SymKey, cipherText: cryptoFramework.DataBlob) {
    let decoder = cryptoFramework.createCipher('DES64|ECB|PKCS7');
    await decoder.init(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null);
    let decryptData = await decoder.doFinal(cipherText);
    return decryptData;
  }
  
  async function genSymKeyByData(symKeyData: Uint8Array) {
    let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData };
    let symGenerator = cryptoFramework.createSymKeyGenerator('DES64');
    let symKey = await symGenerator.convertKey(symKeyBlob);
    console.info('convertKey result: success.');
    return symKey;
  }
  
  async function main() {
    let keyData = new Uint8Array([238, 249, 61, 55, 128, 220, 183, 224]);
    let symKey = await genSymKeyByData(keyData);
    let message = 'This is a test';
    let plainText: cryptoFramework.DataBlob = { data: new Uint8Array(buffer.from(message, 'utf-8').buffer) };
    let encryptText = await encryptMessagePromise(symKey, plainText);
    let decryptText = await decryptMessagePromise(symKey, encryptText);
    if (plainText.data.toString() === decryptText.data.toString()) {
      console.info('decrypt ok.');
      console.info('decrypt plainText: ' + buffer.from(decryptText.data).toString('utf-8'));
    } else {
      console.error('decrypt failed.');
    }
  }
  

  des_ecb_encryption_decryption_asynchronous.ets

• Example (using synchronous APIs):

  import { cryptoFramework } from '@kit.CryptoArchitectureKit';
  import { buffer } from '@kit.ArkTS';
  
  // Encrypt the message.
  function encryptMessage(symKey: cryptoFramework.SymKey, plainText: cryptoFramework.DataBlob) {
    let cipher = cryptoFramework.createCipher('DES64|ECB|PKCS7');
    cipher.initSync(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null);
    let encryptData = cipher.doFinalSync(plainText);
    return encryptData;
  }
  
  // Decrypt the message.
  function decryptMessage(symKey: cryptoFramework.SymKey, cipherText: cryptoFramework.DataBlob) {
    let decoder = cryptoFramework.createCipher('DES64|ECB|PKCS7');
    decoder.initSync(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null);
    let decryptData = decoder.doFinalSync(cipherText);
    return decryptData;
  }
  
  function genSymKeyByData(symKeyData: Uint8Array) {
    let symKeyBlob: cryptoFramework.DataBlob = { data: symKeyData };
    let symGenerator = cryptoFramework.createSymKeyGenerator('DES64');
    let symKey = symGenerator.convertKeySync(symKeyBlob);
    console.info('convertKeySync result: success.');
    return symKey;
  }
  
  function main() {
    let keyData = new Uint8Array([238, 249, 61, 55, 128, 220, 183, 224]);
    let symKey = genSymKeyByData(keyData);
    let message = 'This is a test';
    let plainText: cryptoFramework.DataBlob = { data: new Uint8Array(buffer.from(message, 'utf-8').buffer) };
    let encryptText = encryptMessage(symKey, plainText);
    let decryptText = decryptMessage(symKey, encryptText);
    if (plainText.data.toString() === decryptText.data.toString()) {
      console.info('decrypt ok.');
      console.info('decrypt plainText: ' + buffer.from(decryptText.data).toString('utf-8'));
    } else {
      console.error('decrypt failed.');
    }
  }
  

  des_ecb_encryption_decryption_synchronous.ets