基于【GO】的cmf_password加密密码的逻辑，和校验密码逻辑

1. 导入必要的包：

   import (
       "crypto/rand"
       "crypto/sha256"
       "encoding/hex"
       "fmt"
       "io"
   )
   1
   2
   3
   4
   5
   6
   7

   这里导入了一些标准库的包，用于生成随机数、计算SHA-256哈希和处理十六进制编码。

2. main 函数：

   • 在 main 函数中，首先定义了要加密的原始密码 password。
   • 使用 generateSalt 函数生成一个随机的盐值 salt。
   • 然后，使用 hashPassword 函数将原始密码和盐值一起加密，生成 hashedPassword。
   • 打印原始密码、加密后的密码和盐值的十六进制字符串表示。
   • 将盐值转换为十六进制字符串 saltString，以便将其存入数据库（这里没有实际的数据库操作，只是演示）。
   • 模拟密码验证过程，使用用户输入的密码 inputPassword 调用 verifyPassword 函数来验证密码是否有效。

3. verifyPassword 函数：

   • 这个函数用于验证用户输入的密码是否与存储的哈希密码匹配。
   • 它使用相同的盐值和用户输入的密码来计算哈希值，并将其与存储的哈希密码进行比较。
   • 如果哈希值匹配，返回 true，否则返回 false。

4. generateSalt 函数：

   • 这个函数生成一个随机的盐值，用于密码加密。
   • 它创建一个长度为 32 字节的字节数组，然后使用 crypto/rand 包中的 ReadFull 函数填充数组以获取随机数据。

5. hashPassword 函数：

   • 这个函数接受原始密码和盐值作为输入，并将它们连接在一起。
   • 然后，它使用 SHA-256 哈希函数计算连接后的数据的哈希值。
   • 最后，它将哈希值转换为十六进制字符串，并返回结果。

总之，这段代码演示了如何使用盐值和哈希函数来加密和验证用户密码，以提高密码安全性。盐值使得相同的密码在每次加密时都生成不同的哈希值，增加了密码的安全性，同时也可以防止彩虹表攻击等密码破解技术的应用。
完整代码：

package main

import (
	"crypto/rand"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"io"
)

func main() {
	// 要加密的密码
	password := "your_password_here"

	// 生成随机盐值
	salt, err := generateSalt()
	if err != nil {
		fmt.Println("生成盐值时发生错误:", err)
		return
	}

	// 使用盐值加密密码
	hashedPassword, err := hashPassword(password, salt)
	if err != nil {
		fmt.Println("加密密码时发生错误:", err)
		return
	}

	fmt.Println("原始密码:", password)
	fmt.Println("加密后的密码:", hashedPassword)
	fmt.Println("盐值:", hex.EncodeToString(salt))
	// 存入数据库时将盐值转换为十六进制字符串
	saltString := hex.EncodeToString(salt)

	// 将 saltString 存入数据库中的 user_salt 列
	// 你可以使用合适的数据库操作库来实现这一步
	// 例如，如果你使用了数据库/SQL库，你可以执行 INSERT 操作
	// 将 saltString 插入到相应的用户记录中
	// 假设从数据库中读取的 user_salt 列的值是 saltString
	saltS, err := hex.DecodeString(saltString)
	if err != nil {
		fmt.Println("从数据库中读取盐值时发生错误:", err)
		return
	}
	// 模拟验证过程
	inputPassword := "your_password_here" // 用户输入的密码
	isPasswordValid, err := verifyPassword(inputPassword, hashedPassword, saltS)
	if err != nil {
		fmt.Println("验证密码时发生错误:", err)
		return
	}

	if isPasswordValid {
		fmt.Println("密码验证成功")
	} else {
		fmt.Println("密码验证失败")
	}
}

// 验证密码
func verifyPassword(inputPassword string, storedHashedPassword string, salt []byte) (bool, error) {
	// 使用相同的盐值和输入密码计算哈希值
	hashedInputPassword, err := hashPassword(inputPassword, salt)
	if err != nil {
		return false, err
	}

	// 比较计算出的哈希值与存储的哈希密码是否相等
	return hashedInputPassword == storedHashedPassword, nil
}

// 生成一个随机的盐值
func generateSalt() ([]byte, error) {
	salt := make([]byte, 32) // 32字节的盐值
	_, err := io.ReadFull(rand.Reader, salt)
	if err != nil {
		return nil, err
	}
	return salt, nil
}

// 使用盐值对密码进行加密
func hashPassword(password string, salt []byte) (string, error) {
	// 将密码和盐值连接起来
	saltedPassword := append([]byte(password), salt...)

	// 计算SHA-256散列值
	hash := sha256.Sum256(saltedPassword)

	// 将散列值转换为十六进制字符串
	hashedPassword := hex.EncodeToString(hash[:])

	return hashedPassword, nil
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95