Strategy Design Pattern

The Strategy design pattern is a behavioural pattern that defines a family of algorithms, encapsulates each one, and makes them interchangeable. This pattern allows a class’s behavior to be selected at runtime.

Key Concepts

1. Strategy Interface – Defines a common interface for all strategies.

2. Concrete Strategies – Implement different variations of the algorithm.

3. Context Class – Uses a strategy and allows the client to change it dynamically.

Example: Choosing Encryption algorithms at runtime

Let's implement the Strategy design pattern for an AES encryption system, where users can dynamically choose different AES encryption modes (CBC or GCM).

Step 1 : Define the Strategy Interface

This ensures all AES encryption strategies follow a common structure.

export interface AESEncryptionStrategy {
  encrypt(plainText: string, key: string, iv: string): string;
  decrypt(cipherText: string, key: string, iv: string): string;
}

Step 2 : Implement AES-CBC Encryption

AES-CBC requires an IV (Initialization Vector) for security.

import { AESEncryptionStrategy } from "./AESEncryptionStrategy";
import crypto from "crypto";

class AESCBCEncryption implements AESEncryptionStrategy {
    encrypt(plainText: string, key: string, iv: string): string {
      const cipher = crypto.createCipheriv("aes-256-cbc", Buffer.from(key, "hex"), Buffer.from(iv, "hex"));
      const encrypted = Buffer.concat([cipher.update(plainText, "utf-8"), cipher.final()]);
      return encrypted.toString("hex");
    }

    decrypt(cipherText: string, key: string, iv: string): string {
      const decipher = crypto.createDecipheriv("aes-256-cbc", Buffer.from(key, "hex"), Buffer.from(iv, "hex"));
      const decrypted = Buffer.concat([decipher.update(Buffer.from(cipherText, "hex")), decipher.final()]);
      return decrypted.toString("utf-8");
    }
  }

  /**

  AES-CBC requires an IV (Initialization Vector) for security.


   */

Step 3 : Implement AES-GCM Encryption

AES-GCM provides authentication using an Auth Tag.

import { AESEncryptionStrategy } from "./AESEncryptionStrategy";
import crypto from "crypto";

class AESGCMEncryption implements AESEncryptionStrategy {
    encrypt(plainText: string, key: string, iv: string): string {
      const cipher = crypto.createCipheriv("aes-256-gcm", Buffer.from(key, "hex"), Buffer.from(iv, "hex"));
      const encrypted = Buffer.concat([cipher.update(plainText, "utf-8"), cipher.final()]);
      const authTag = cipher.getAuthTag(); // Authentication tag
      return encrypted.toString("hex") + authTag.toString("hex");
    }

    decrypt(cipherText: string, key: string, iv: string): string {
      const authTag = cipherText.slice(-32); // Extract last 16 bytes (Auth Tag)
      const encryptedData = cipherText.slice(0, -32); // Extract encrypted data

      const decipher = crypto.createDecipheriv("aes-256-gcm", Buffer.from(key, "hex"), Buffer.from(iv, "hex"));
      decipher.setAuthTag(Buffer.from(authTag, "hex"));

      const decrypted = Buffer.concat([decipher.update(Buffer.from(encryptedData, "hex")), decipher.final()]);
      return decrypted.toString("utf-8");
    }
  }

Step 4 : Implement the Context Class

This class allows switching encryption strategies dynamically.

class AESEncryption {
  private strategy: AESEncryptionStrategy;

  constructor(strategy: AESEncryptionStrategy) {
    this.strategy = strategy;
  }

  setStrategy(strategy: AESEncryptionStrategy): void {
    this.strategy = strategy;
  }

  encryptText(plainText: string, key: string, iv: string): string {
    return this.strategy.encrypt(plainText, key, iv);
  }

  decryptText(cipherText: string, key: string, iv: string): string {
    return this.strategy.decrypt(cipherText, key, iv);
  }
}

Step 5 : Test the Implementation

We will:

• Generate a 256-bit AES key

• Generate a 128-bit IV

• Encrypt & decrypt text using CBC and GCM

   import crypto from "crypto";
   import { AESEncryption } from "./AESEncryption";
   import { AESCBCEncryption } from "./AESCBCEncryption";
   import { AESGCMEncryption } from "./AESGCMEncryption";
  
   function main() {
  
       const key = crypto.randomBytes(32).toString("hex"); // 256-bit key
       const iv = crypto.randomBytes(16).toString("hex");  // 128-bit IV
       const text = "Hello, AES Strategy Pattern!";
  
       // Use AES-CBC
       const aes = new AESEncryption(new AESCBCEncryption());
       const encryptedCBC = aes.encryptText(text, key, iv);
       console.log("CBC Encrypted:", encryptedCBC);
       console.log("CBC Decrypted:", aes.decryptText(encryptedCBC, key, iv));
  
       // Switch to AES-GCM
       aes.setStrategy(new AESGCMEncryption());
       const encryptedGCM = aes.encryptText(text, key, iv);
       console.log("GCM Encrypted:", encryptedGCM);
       console.log("GCM Decrypted:", aes.decryptText(encryptedGCM, key, iv));
  
   }
  
   main();
  

Why Use the Strategy Pattern for AES?

• Flexible Encryption – Easily switch between AES-CBC and AES-GCM.

• Secure & Scalable – Add new encryption strategies without modifying existing code.

• Reusable – Keep encryption logic separate from business logic.

  The GITHUB code link is here.