【Js】js前端hash加密库Crypto-js进行MD5/SHA256/SHA512加密的方法

哈希加密是一种常用的加密技术，用于将任意长度的数据转换为固定长度的数据，通常是一个固定大小的哈希值。哈希函数是一种将数据映射到固定长度的函数，它们具有以下特性：

1. 固定输出长度：哈希函数会将任意大小的输入数据映射到固定大小的输出，无论输入数据的大小如何，输出长度是固定的。

2. 唯一性：不同的输入数据应该产生不同的哈希值。即使输入数据只有一个比特的差异，也应该导致完全不同的哈希值。

3. 不可逆性：通常，从哈希值中无法恢复原始输入数据。这意味着无法通过哈希值来逆向推导出原始数据。

4. 抗碰撞性：哈希函数应该尽可能避免产生碰撞，即不同的输入数据生成相同的哈希值的情况。好的哈希函数应该具有高度抗碰撞性，即使输入数据发生微小变化，也应该显著改变哈希值。

常见的哈希加密算法包括：

1. MD5（Message Digest Algorithm 5）：MD5是一种广泛使用的哈希函数，生成128位（16字节）的哈希值。然而，由于MD5已被发现存在严重的漏洞，不再建议用于安全加密用途。

2. SHA-1（Secure Hash Algorithm 1）：SHA-1生成160位（20字节）的哈希值，曾经被广泛使用，但现在也被认为不安全，因为其哈希长度较短，易受碰撞攻击。

3. SHA-256/SHA-384/SHA-512：SHA-2系列是SHA-1的继任者，包括SHA-256、SHA-384和SHA-512等不同变种，分别生成256位、384位和512位的哈希值。它们目前被广泛认为是安全的哈希函数。

4. RIPEMD（RACE Integrity Primitives Evaluation Message Digest）：RIPEMD是一系列哈希函数，包括RIPEMD-128、RIPEMD-160、RIPEMD-256和RIPEMD-320等变种，分别生成128位、160位、256位和320位的哈希值。

5. Whirlpool：Whirlpool是一种密码哈希函数，生成512位的哈希值，被认为是SHA-512的竞争对手，但目前较少使用。

6. BLAKE2：BLAKE2是一种高速、安全的哈希函数，有BLAKE2b和BLAKE2s两种变种，分别生成不同长度的哈希值。

除了以上列出的哈希函数外，还有许多其他哈希函数可用于特定的应用和安全需求。在选择哈希函数时，需要考虑其安全性、性能、输出长度等因素，并根据具体需求进行选择。

最近有用到Hash加密，整理了一下常用的hash方法。

引入依赖：

# Hash算法的依赖
npm install crypto-js
# pipemd160算法的依赖
npm install ripemd160

工具类：

import CryptoJS from 'crypto-js';
import RIPEMD160 from 'ripemd160'

class HashUtils {

    // 计算MD5-十六进制
    static md5HexHash(input) {
        // 计算 MD5
        const hash = CryptoJS.MD5(input);
        // 输出十六进制字符串
        return hash.toString(CryptoJS.enc.Hex);
    }

    // 计算MD5-base64
    static md5Base64Hash(input) {
        // 对字符串进行MD5加密
        const md5Hash = CryptoJS.MD5(input);
        // 将MD5结果转换为Base64格式
        return md5Hash.toString(CryptoJS.enc.Base64);
    }

    // 计算sha1-十六进制
    static sha1HexHash(input) {
        const sha1Hash = CryptoJS.SHA1(input);
        // 输出SHA-1加密后的十六进制字符串
        return sha1Hash.toString(CryptoJS.enc.Hex);
    }

    // 计算sha1-base64
    static sha1Base64Hash(input) {
        const sha1Hash = CryptoJS.SHA1(input);
        // 输出SHA-1加密后的十六进制字符串
        return sha1Hash.toString(CryptoJS.enc.Base64);
    }

    // 计算sha256-十六进制
    static sha256HexHash(input) {
        const sha1Hash = CryptoJS.SHA256(input);
        return sha1Hash.toString(CryptoJS.enc.Hex);
    }

    // 计算sha256-base64
    static sha256Base64Hash(input) {
        const sha1Hash = CryptoJS.SHA256(input);
        return sha1Hash.toString(CryptoJS.enc.Base64);
    }

    // 计算sha384-十六进制
    static sha384HexHash(input) {
        const sha1Hash = CryptoJS.SHA384(input);
        return sha1Hash.toString(CryptoJS.enc.Hex);
    }

    // 计算sha384-base64
    static sha384Base64Hash(input) {
        const sha1Hash = CryptoJS.SHA384(input);
        return sha1Hash.toString(CryptoJS.enc.Base64);
    }

    // 计算sha512-十六进制
    static sha512HexHash(input) {
        const sha1Hash = CryptoJS.SHA512(input);
        return sha1Hash.toString(CryptoJS.enc.Hex);
    }

    // 计算sha512-base64
    static sha512Base64Hash(input) {
        const sha1Hash = CryptoJS.SHA512(input);
        return sha1Hash.toString(CryptoJS.enc.Base64);
    }

    // 计算sha3-十六进制
    static sha3HexHash(input) {
        const sha1Hash = CryptoJS.SHA3(input);
        return sha1Hash.toString(CryptoJS.enc.Hex);
    }

    // 计算sha3-base64
    static sha3Base64Hash(input) {
        const sha1Hash = CryptoJS.SHA3(input);
        return sha1Hash.toString(CryptoJS.enc.Base64);
    }

    // 计算sha224-十六进制
    static sha224HexHash(input) {
        const sha1Hash = CryptoJS.SHA224(input);
        return sha1Hash.toString(CryptoJS.enc.Hex);
    }

    // 计算sha224-base64
    static sha224Base64Hash(input) {
        const sha1Hash = CryptoJS.SHA224(input);
        return sha1Hash.toString(CryptoJS.enc.Base64);
    }

    // 计算pipemd160-十六进制
    static pipemd160HexHash(input) {
        const hash = new RIPEMD160()
            .update(input);
        return hash.digest('hex');
    }

    // 计算pipemd160-base64
    static pipemd160Base64Hash(input) {
        const hash = new RIPEMD160()
            .update(input);
        // 转base64
        return hash.digest('base64');
    }

    static hexToBinary(hexString) {
        let binaryString = "";
        for (let i = 0; i < hexString.length; i++) {
            const binaryValue = parseInt(hexString[i], 16)
                .toString(2)
                .padStart(4, '0');
            binaryString += binaryValue;
        }
        return binaryString;
    }

}

export default HashUtils;

如果你要将加密结果转换为二进制的，可以调用hexToBinary方法。

遇到了这个知识点，顺手扩展了一下工具类分享出来，有不对的地方欢迎指正。

不管做什么，只要坚持下去就会看到不一样！