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 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;
|
}
|
|
class AesEncryption implements Encryption {
|
private readonly key;
|
private readonly iv;
|
|
constructor({ key, iv }: EncryptionParams) {
|
this.key = parse(key);
|
this.iv = parse(iv);
|
}
|
|
get getOptions() {
|
return {
|
mode: CTR,
|
padding: pkcs7,
|
iv: this.iv,
|
};
|
}
|
|
encrypt(plainText: string) {
|
return aesEncrypt(plainText, this.key, this.getOptions).toString();
|
}
|
|
decrypt(cipherText: string) {
|
return aesDecrypt(cipherText, this.key, this.getOptions).toString(UTF8);
|
}
|
}
|
|
// 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);
|
}
|
}
|
|
// 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();
|
}
|
}
|
|
// 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();
|
}
|
}
|
