前端密码加密 —— 盐值、MD5、sha256

  前期回顾悄悄告诉你：前端如何获取本机IP，轻松一步开启网络探秘之旅_彩色之外的博客-CSDN博客前端获取 本机 IP 教程https://blog.csdn.net/m0_57904695/article/details/131855907?spm=1001.2014.3001.5501

        js-sha256是一个用于计算SHA-256哈希的JavaScript库。从技术角度来看，它可以提供一定程度的安全性。SHA-256是一种常用的加密散列函数，广泛应用于密码学和数据完整性验证领域。然而，重要的是要注意，安全性不仅取决于哈希算法本身，还取决于其使用方式和上下文。

目录

MD5

 SHA-256 + 盐值

源码位置

  谢谢观看

---

 

MD5

        MD5是一种广泛用于数据校验和加密的算法。它接受一个输入（通常是消息或数据）并生成一个128位（16字节）的哈希值作为输出。

MD5算法通过将输入数据分成固定大小的块，并对每个块进行一系列的运算来生成哈希值。生成的哈希值具有以下特点：

1. 不可逆性：无法从哈希值反推出原始输入数据。

2. 相同输入生成相同哈希值：对于相同的输入数据，无论执行多少次，都会生成相同的哈希值。

3. 哈希冲突可能性：不同的输入数据可能会生成相同的哈希值，这称为哈希冲突。

        由于MD5算法存在一些安全漏洞，例如容易被碰撞攻击和预映像攻击，因此不再推荐用于安全敏感的应用。在需要更高级别的数据安全性时，推荐使用更强大和安全性更高的哈希算法，如SHA-256、SHA-512等。

 SHA-256 + 盐值

        SHA-256（Secure Hash Algorithm 256-bit）是一种密码学安全散列函数，它接受任意长度的输入数据，并生成一个256位（32字节）的哈希值作为输出。

       SHA-256是SHA-2系列中的一种算法，是SHA-224和SHA-512之间的中间版本。它是由美国国家安全局（NSA）设计，广泛应用于数据完整性校验、数字签名、密码学协议等领域。

       与MD5相比，SHA-256提供了更高的安全性和更好的抗碰撞能力。它具有以下特点：

1. 不可逆性：无法从哈希值反推出原始输入数据。

2. 相同输入生成相同哈希值：对于相同的输入数据，无论执行多少次，都会生成相同的哈希值。

3. 哈希冲突可能性极低：不同的输入数据生成相同哈希值的可能性极低，可以被认为是可以忽略不计的。

       SHA-256广泛应用于密码学和信息安全领域，例如在数字证书、SSL/TLS握手过程、密码存储和验证等方面。它提供了更强大的数据完整性保护和安全性，是目前常用的哈希算法之一。

          加盐是指在密码哈希过程中引入一个随机生成的字符串，称为盐（salt），并将其与密码进行组合后再进行哈希计算。这个盐值会与每个用户的密码单独关联，并且将其存储在数据库中。 加盐可以增加密码哈希的复杂度，提高密码的安全性，即使两个用户使用相同的密码，由于使用了不同的盐值，其哈希结果也会有所区别。这样即使黑客获得了哈希值，也很难通过暴力破解找到原始的密码。

1：首先，安装 js-sha256库： 

pnpm install js-sha256

2：在您的Vue组件中引入js-sha256： 

import { sha256 } from 'js-sha256';

3：在需要使用SHA256哈希的地方，调用 sha256 函数并加盐，传入要哈希的字符串作为输入：

import { sha256 } from 'js-sha256';

const generateSalt = () => {
	const randomBytes = new Uint8Array(16);
	crypto.getRandomValues(randomBytes);
	return Array.from(randomBytes, (byte) =>
		byte.toString(16).padStart(2, '0')
	).join('');
};

const salt = generateSalt();
console.log('！这里输出  ==>：', salt);

const password = 'userPassword';
const saltedPassword = salt + password;
const hashedPassword = sha256(saltedPassword);
console.log('！这里输出  ==>：', hashedPassword);

可以将其用作数据验证、密码存储等用途，关于安全性，除了使用 js-sha256 库之外，还建议采取以下措施：

• 使用HTTPS协议来保护传输数据的安全性。
• 在前端进行输入验证和过滤，以确保只有有效和合法的数据被传递给哈希函数。
• 对于密码存储和认证，最好使用专门的密码哈希函数和密码学方案，如bcrypt、scrypt或Argon2等。
• 仔细保护密钥和敏感数据，避免将它们明文存储在前端代码或客户端浏览器中。

 SHA256哈希函数本身并不能防止所有安全问题，还需要综合考虑其他因素来确保系统的安全性，如合理的安全策略、用户身份验证和授权等。

源码位置

 

 http:// https://github.com/emn178/js-sha256

 不推荐这种方式使用

新建 SHA256.js

export function SHA256(s) {
    // 将字符串转换为 SHA256 哈希值
    //  s 只能是字符串并且不能为空
    if (typeof s !== 'string' || s.length === 0) {
        throw new Error('！这里输出 SHA256  ==>：s 只能是字符串并且不能为空');
    }


    let chrsz = 8;

    let hexcase = 0;

    function safe_add(x, y) {

        let lsw = (x & 0xFFFF) + (y & 0xFFFF);

        let msw = (x >> 16) + (y >> 16) + (lsw >> 16);

        return (msw << 16) | (lsw & 0xFFFF);

    }

    function S(X, n) { return (X >>> n) | (X << (32 - n)); }

    function R(X, n) { return (X >>> n); }

    function Ch(x, y, z) { return ((x & y) ^ ((~x) & z)); }

    function Maj(x, y, z) { return ((x & y) ^ (x & z) ^ (y & z)); }

    function Sigma0256(x) { return (S(x, 2) ^ S(x, 13) ^ S(x, 22)); }

    function Sigma1256(x) { return (S(x, 6) ^ S(x, 11) ^ S(x, 25)); }

    function Gamma0256(x) { return (S(x, 7) ^ S(x, 18) ^ R(x, 3)); }

    function Gamma1256(x) { return (S(x, 17) ^ S(x, 19) ^ R(x, 10)); }

    function core_sha256(m, l) {

        let K = new Array(0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, 0xE49B69C1, 0xEFBE4786, 0xFC19DC6, 0x240CA1CC, 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA, 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, 0xC6E00BF3, 0xD5A79147, 0x6CA6351, 0x14292967, 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070, 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3, 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2);

        let HASH = new Array(0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19);

        let W = new Array(64);

        let a, b, c, d, e, f, g, h;

        let T1, T2;

        m[l >> 5] |= 0x80 << (24 - l % 32);

        m[((l + 64 >> 9) << 4) + 15] = l;

        for (let i = 0; i < m.length; i += 16) {
            a = HASH[0];

            b = HASH[1];

            c = HASH[2];

            d = HASH[3];

            e = HASH[4];

            f = HASH[5];

            g = HASH[6];

            h = HASH[7];

            for (let j = 0; j < 64; j++) {

                if (j < 16) W[j] = m[j + i];

                else W[j] = safe_add(safe_add(safe_add(Gamma1256(W[j - 2]), W[j - 7]), Gamma0256(W[j - 15])), W[j - 16]);

                T1 = safe_add(safe_add(safe_add(safe_add(h, Sigma1256(e)), Ch(e, f, g)), K[j]), W[j]);

                T2 = safe_add(Sigma0256(a), Maj(a, b, c));

                h = g;

                g = f;

                f = e;

                e = safe_add(d, T1);

                d = c;

                c = b;

                b = a;

                a = safe_add(T1, T2);

            }

            HASH[0] = safe_add(a, HASH[0]);

            HASH[1] = safe_add(b, HASH[1]);

            HASH[2] = safe_add(c, HASH[2]);

            HASH[3] = safe_add(d, HASH[3]);

            HASH[4] = safe_add(e, HASH[4]);

            HASH[5] = safe_add(f, HASH[5]);

            HASH[6] = safe_add(g, HASH[6]);

            HASH[7] = safe_add(h, HASH[7]);

        }

        return HASH;

    }

    function str2binb(str) {

        let bin = Array();

        let mask = (1 << chrsz) - 1;

        for (let i = 0; i < str.length * chrsz; i += chrsz) {

            bin[i >> 5] |= (str.charCodeAt(i / chrsz) & mask) << (24 - i % 32);

        }

        return bin;

    }

    function Utf8Encode(string) {

        string = string.replace(/\r\n/g, "\n");

        let utftext = "";

        for (let n = 0; n < string.length; n++) {

            let c = string.charCodeAt(n);

            if (c < 128) {

                utftext += String.fromCharCode(c);

            }

            else if ((c > 127) && (c < 2048)) {

                utftext += String.fromCharCode((c >> 6) | 192);

                utftext += String.fromCharCode((c & 63) | 128);

            }

            else {

                utftext += String.fromCharCode((c >> 12) | 224);

                utftext += String.fromCharCode(((c >> 6) & 63) | 128);

                utftext += String.fromCharCode((c & 63) | 128);

            }

        }

        return utftext;

    }

    function binb2hex(binarray) {

        let hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";

        let str = "";

        for (let i = 0; i < binarray.length * 4; i++) {

            str += hex_tab.charAt((binarray[i >> 2] >> ((3 - i % 4) * 8 + 4)) & 0xF) +

                hex_tab.charAt((binarray[i >> 2] >> ((3 - i % 4) * 8)) & 0xF);

        }

        return str;

    }

    s = Utf8Encode(s);

    return binb2hex(core_sha256(str2binb(s), s.length * chrsz));

}

import { SHA256 } from '/@/utils/SHA256.js';

const generateSalt = () => {
	const randomBytes = new Uint8Array(16);
	crypto.getRandomValues(randomBytes);
	return Array.from(randomBytes, (byte) =>
		byte.toString(16).padStart(2, '0')
	).join('');
};

const salt = generateSalt();
console.log('！这里输出  ==>：', salt);

const password = 'userPassword';
const saltedPassword = salt + password;
const hashedPassword = SHA256 (saltedPassword);
console.log('！这里输出  ==>：', hashedPassword);

  谢谢观看

 _______________________________  期待再见  _______________________________