@neosjs/create-app/template/config/crypto-js/src/utils/crypto.ts

帮助开发者快速创建Vue3应用并自动配置项目

import AES 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 Base64 from 'crypto-js/enc-base64'
import MD5 from 'crypto-js/md5'
import SHA256 from 'crypto-js/sha256'
import SHA512 from 'crypto-js/sha512'

// 定义一个加密器的接口
export interface Encryption {
  encrypt: (plainText: string) => string
  decrypt: (cipherText: string) => string
}

// 定义一个哈希算法的接口
export interface Hashing {
  hash: (data: string) => string
}

export interface EncryptionParams {
  key: string
  iv: string
}

// 定义一个AES加密器的接口
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: ECB,
      padding: pkcs7,
      iv: this.iv
    }
  }

  encrypt(plainText: string) {
    return AES.encrypt(plainText, this.key, this.getOptions).toString()
  }

  decrypt(cipherText: string) {
    return AES.decrypt(cipherText, this.key, this.getOptions).toString(UTF8)
  }
}

// 定义一个Base64加密器的接口
class Base64Encryption implements Encryption {
  private static instance: Base64Encryption

  private constructor() {}
  // 获取单例实例
  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)
  }
}

// 定义一个MD5加密器的接口
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()
  }
}

// 定义一个SHA256加密器的接口
class SHA256Hashing implements Hashing {
  private static instance: SHA256Hashing

  private constructor() {}
  // 获取单例实例
  public static getInstance(): SHA256Hashing {
    if (!SHA256Hashing.instance) {
      SHA256Hashing.instance = new SHA256Hashing()
    }
    return SHA256Hashing.instance
  }

  hash(plainText: string) {
    return SHA256(plainText).toString()
  }
}

// 定义一个SHA512加密器的接口
class SHA512Hashing implements Hashing {
  private static instance: SHA512Hashing

  private constructor() {}
  // 获取单例实例
  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()
  }
}

export const base64Encryption = EncryptionFactory.createBase64Encryption()
export const aesEncryption = EncryptionFactory.createAesEncryption({
  key: 'neosjs',
  iv: 'neosjs'
})
export const md5Encryption = HashingFactory.createMD5Hashing()
export const sha256Encryption = HashingFactory.createSHA256Hashing()
export const sha512Encryption = HashingFactory.createSHA512Hashing()