Golang常用的几种密码加密方式分享

go get -u golang.org/x/crypto/bcrypt

import "golang.org/x/crypto/bcrypt"

// HashPassword 使用 Bcrypt 算法生成密码哈希值
func HashPassword(password string) (string, error) {
    hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
    if err != nil {
        return "", err
    }
    return string(hashedPassword), nil
}

// ComparePasswords 比较输入的密码与哈希值是否匹配
func ComparePasswords(hashedPassword, password string) bool {
    err := bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(password))
    return err == nil
}

go get -u golang.org/x/crypto/argon2

import "golang.org/x/crypto/argon2"

// HashPassword 使用 Argon2 算法生成密码哈希值
func HashPassword(password, salt string) (string, error) {
	time := uint32(1)           // 迭代次数
	memory := uint32(64 * 1024) // 内存使用量（以字节为单位）
	threads := uint8(4)         // 并行线程数
	keyLen := uint32(32)        // 输出密钥长度为 32 字节
	hashedPassword := argon2.IDKey([]byte(password), []byte(salt), time, memory, threads, keyLen)
	return string(hashedPassword), nil
}

// ComparePasswords 验证密码是否匹配
func ComparePasswords(hashedPassword, password, salt string) bool {
	time := uint32(1)           // 迭代次数
	memory := uint32(64 * 1024) // 内存使用量（以字节为单位）
	threads := uint8(4)         // 并行线程数
	keyLen := uint32(32)        // 输出密钥长度为 32 字节
	derivedKey := argon2.IDKey([]byte(password), []byte(salt), time, memory, threads, keyLen)
	return subtle.ConstantTimeCompare([]byte(hashedPassword), derivedKey) == 1
}

go get -u golang.org/x/crypto/scrypt

import "golang.org/x/crypto/scrypt"

// HashPassword 使用 Scrypt 算法生成密码哈希值
func HashPassword(password, salt string) (string, error) {
	N := 16384   // 迭代次数，表示对哈希函数的重复计算次数。值越大，计算成本越高，安全性越好，但性能也会受到影响。通常建议选择一个大于 2^14 的值，例如 16384
	r := 8       // 块大小，表示每次哈希计算中使用的内存块大小。较大的值会增加内存消耗，并增加攻击成本。通常建议选择一个合适的值，例如 8
	p := 1       // 并行度，表示并行计算的线程或处理器数目。较高的值会增加计算成本，适当的值取决于你的硬件配置。通常建议选择一个合适的值，例如 1
	keyLen := 32 // 参数指定生成的密钥的长度
	hashedPassword, err := scrypt.Key([]byte(password), []byte(salt), N, r, p, keyLen)
	if err != nil {
		return "", err
	}
	return string(hashedPassword), nil
}

// ComparePasswords 验证密码是否匹配
func ComparePasswords(hashedPassword, password, salt string) bool {
	N := 16384   // 迭代次数，表示对哈希函数的重复计算次数。值越大，计算成本越高，安全性越好，但性能也会受到影响。通常建议选择一个大于 2^14 的值，例如 16384
	r := 8       // 块大小，表示每次哈希计算中使用的内存块大小。较大的值会增加内存消耗，并增加攻击成本。通常建议选择一个合适的值，例如 8
	p := 1       // 并行度，表示并行计算的线程或处理器数目。较高的值会增加计算成本，适当的值取决于你的硬件配置。通常建议选择一个合适的值，例如 1
	keyLen := 32 // 参数指定生成的密钥的长度
	derivedKey, err := scrypt.Key([]byte(password), []byte(salt), N, r, p, keyLen)
	if err != nil {
		return false
	}
	return subtle.ConstantTimeCompare([]byte(hashedPassword), derivedKey) == 1
}