From 1b419ccf217dbcace15987f1c0fe26b9e15d1d4b Mon Sep 17 00:00:00 2001
From: Ben Lin <maobin001@msn.com>
Date: 星期三, 16 十月 2024 10:26:56 +0800
Subject: [PATCH] 工艺绑定优化

---
 src/utils/cipher.ts |  155 +++++++++++++++++++++++++++++++++++++++++++--------
 1 files changed, 130 insertions(+), 25 deletions(-)

diff --git a/src/utils/cipher.ts b/src/utils/cipher.ts
index 7a02cfc..cbc2242 100644
--- a/src/utils/cipher.ts
+++ b/src/utils/cipher.ts
@@ -1,54 +1,159 @@
-import { encrypt, decrypt } from 'crypto-js/aes';
+import { decrypt as aesDecrypt, encrypt as aesEncrypt } from 'crypto-js/aes';
 import UTF8, { parse } from 'crypto-js/enc-utf8';
 import pkcs7 from 'crypto-js/pad-pkcs7';
-import ECB from 'crypto-js/mode-ecb';
-import md5 from 'crypto-js/md5';
+import CTR from 'crypto-js/mode-ctr';
 import Base64 from 'crypto-js/enc-base64';
+import MD5 from 'crypto-js/md5';
+import SHA256 from 'crypto-js/sha256';
+import SHA512 from 'crypto-js/sha512';
+
+// Define an interface for encryption
+// 瀹氫箟涓�涓姞瀵嗗櫒鐨勬帴鍙�
+export interface Encryption {
+  encrypt(plainText: string): string;
+  decrypt(cipherText: string): string;
+}
+// Define an interface for Hashing
+// 瀹氫箟涓�涓搱甯岀畻娉曠殑鎺ュ彛
+export interface Hashing {
+  hash(data: string): string;
+}
 
 export interface EncryptionParams {
   key: string;
   iv: string;
 }
 
-export class AesEncryption {
-  private key;
-  private iv;
+class AesEncryption implements Encryption {
+  private readonly key;
+  private readonly iv;
 
-  constructor(opt: Partial<EncryptionParams> = {}) {
-    const { key, iv } = opt;
-    if (key) {
-      this.key = parse(key);
-    }
-    if (iv) {
-      this.iv = parse(iv);
-    }
+  constructor({ key, iv }: EncryptionParams) {
+    this.key = parse(key);
+    this.iv = parse(iv);
   }
 
   get getOptions() {
     return {
-      mode: ECB,
+      mode: CTR,
       padding: pkcs7,
       iv: this.iv,
     };
   }
 
-  encryptByAES(cipherText: string) {
-    return encrypt(cipherText, this.key, this.getOptions).toString();
+  encrypt(plainText: string) {
+    return aesEncrypt(plainText, this.key, this.getOptions).toString();
   }
 
-  decryptByAES(cipherText: string) {
-    return decrypt(cipherText, this.key, this.getOptions).toString(UTF8);
+  decrypt(cipherText: string) {
+    return aesDecrypt(cipherText, this.key, this.getOptions).toString(UTF8);
   }
 }
 
-export function encryptByBase64(cipherText: string) {
-  return UTF8.parse(cipherText).toString(Base64);
+// Define a singleton class for Base64 encryption
+class Base64Encryption implements Encryption {
+  private static instance: Base64Encryption;
+
+  private constructor() {}
+
+  // Get the singleton instance
+  // 鑾峰彇鍗曚緥瀹炰緥
+  public static getInstance(): Base64Encryption {
+    if (!Base64Encryption.instance) {
+      Base64Encryption.instance = new Base64Encryption();
+    }
+    return Base64Encryption.instance;
+  }
+
+  encrypt(plainText: string) {
+    return UTF8.parse(plainText).toString(Base64);
+  }
+
+  decrypt(cipherText: string) {
+    return Base64.parse(cipherText).toString(UTF8);
+  }
 }
 
-export function decodeByBase64(cipherText: string) {
-  return Base64.parse(cipherText).toString(UTF8);
+// Define a singleton class for MD5 Hashing
+class MD5Hashing implements Hashing {
+  private static instance: MD5Hashing;
+
+  private constructor() {}
+
+  // Get the singleton instance
+  // 鑾峰彇鍗曚緥瀹炰緥
+  public static getInstance(): MD5Hashing {
+    if (!MD5Hashing.instance) {
+      MD5Hashing.instance = new MD5Hashing();
+    }
+    return MD5Hashing.instance;
+  }
+
+  hash(plainText: string) {
+    return MD5(plainText).toString();
+  }
 }
 
-export function encryptByMd5(password: string) {
-  return md5(password).toString();
+// Define a singleton class for SHA256 Hashing
+class SHA256Hashing implements Hashing {
+  private static instance: SHA256Hashing;
+
+  private constructor() {}
+
+  // Get the singleton instance
+  // 鑾峰彇鍗曚緥瀹炰緥
+  public static getInstance(): SHA256Hashing {
+    if (!SHA256Hashing.instance) {
+      SHA256Hashing.instance = new SHA256Hashing();
+    }
+    return SHA256Hashing.instance;
+  }
+
+  hash(plainText: string) {
+    return SHA256(plainText).toString();
+  }
+}
+
+// Define a singleton class for SHA512 Hashing
+class SHA512Hashing implements Hashing {
+  private static instance: SHA512Hashing;
+
+  private constructor() {}
+
+  // Get the singleton instance
+  // 鑾峰彇鍗曚緥瀹炰緥
+  public static getInstance(): SHA256Hashing {
+    if (!SHA512Hashing.instance) {
+      SHA512Hashing.instance = new SHA512Hashing();
+    }
+    return SHA512Hashing.instance;
+  }
+
+  hash(plainText: string) {
+    return SHA512(plainText).toString();
+  }
+}
+
+export class EncryptionFactory {
+  public static createAesEncryption(params: EncryptionParams): Encryption {
+    return new AesEncryption(params);
+  }
+
+  public static createBase64Encryption(): Encryption {
+    return Base64Encryption.getInstance();
+  }
+}
+
+export class HashingFactory {
+  public static createMD5Hashing(): Hashing {
+    return MD5Hashing.getInstance();
+  }
+
+  public static createSHA256Hashing(): Hashing {
+    return SHA256Hashing.getInstance();
+  }
+
+  public static createSHA512Hashing(): Hashing {
+    return SHA512Hashing.getInstance();
+  }
 }

--
Gitblit v1.9.3