refactor: cipher (#3174)

src/utils/cache/storageCache.ts

@@ -1,6 +1,6 @@
 import { cacheCipher } from '/@/settings/encryptionSetting';
-import type { EncryptionParams } from '/@/utils/cipher';
-import { AesEncryption } from '/@/utils/cipher';
+import type { EncryptionParams } from '/@/utils/cipherOld';
+import { AesEncryption } from '/@/utils/cipherOld';
 import { isNullOrUnDef } from '/@/utils/is';
 
 export interface CreateStorageParams extends EncryptionParams {

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();
+  }
 }

src/utils/cipherOld.ts

@@ -0,0 +1,54 @@
+import { encrypt, decrypt } 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 Base64 from 'crypto-js/enc-base64';
+
+export interface EncryptionParams {
+  key: string;
+  iv: string;
+}
+
+export class AesEncryption {
+  private key;
+  private iv;
+
+  constructor(opt: Partial<EncryptionParams> = {}) {
+    const { key, iv } = opt;
+    if (key) {
+      this.key = parse(key);
+    }
+    if (iv) {
+      this.iv = parse(iv);
+    }
+  }
+
+  get getOptions() {
+    return {
+      mode: ECB,
+      padding: pkcs7,
+      iv: this.iv,
+    };
+  }
+
+  encryptByAES(cipherText: string) {
+    return encrypt(cipherText, this.key, this.getOptions).toString();
+  }
+
+  decryptByAES(cipherText: string) {
+    return decrypt(cipherText, this.key, this.getOptions).toString(UTF8);
+  }
+}
+
+export function encryptByBase64(cipherText: string) {
+  return UTF8.parse(cipherText).toString(Base64);
+}
+
+export function decodeByBase64(cipherText: string) {
+  return Base64.parse(cipherText).toString(UTF8);
+}
+
+export function encryptByMd5(password: string) {
+  return md5(password).toString();
+}