从Node.js到Go：MD5密码认证逻辑的迁移与实现

package main

import (
    "crypto/md5"
    "encoding/hex"
    "io"
)

// md5sum 对输入字符串进行MD5哈希，并返回十六进制编码的字符串
func md5sum(input string) string {
    h := md5.New()          // 创建一个新的MD5哈希器
    io.WriteString(h, input) // 将输入字符串写入哈希器
    return hex.EncodeToString(h.Sum(nil)) // 计算哈希值并编码为十六进制字符串
}

// 示例用法
// func main() {
//  testString := "Hello, Go MD5!"
//  hashedString := md5sum(testString)
//  fmt.Printf("Original: %s\nMD5 Hash: %s\n", testString, hashedString)
// }

package main

import (
    "math/rand"
    "time"
)

// 定义用于生成盐值的字符集
const saltChars = "0123456789abcdefghijklmnopqurstuvwxyzABCDEFGHIJKLMNOPQURSTUVWXYZ"

// init 函数在包被导入时自动执行，用于初始化随机数种子
func init() {
    rand.Seed(time.Now().UnixNano()) // 使用当前时间的纳秒作为种子，确保每次运行的随机性
}

// generateSalt 生成指定长度的随机盐值
func generateSalt(length int) string {
    b := make([]byte, length)
    for i := 0; i < length; i++ {
        // 从saltChars中随机选择一个字符
        b[i] = saltChars[rand.Intn(len(saltChars))]
    }
    return string(b)
}

// 示例用法
// func main() {
//  salt := generateSalt(9)
//  fmt.Printf("Generated Salt: %s\n", salt)
// }

package main

// createHash 结合密码和盐值生成哈希字符串
// 它将盐值和密码拼接后进行MD5哈希，然后将盐值前置于哈希结果
func createHash(password string, saltLength int) string {
    salt := generateSalt(saltLength) // 生成一个随机盐值
    hash := md5sum(password + salt)  // 对密码和盐值的组合进行MD5哈希
    return salt + hash               // 返回盐值和哈希的组合
}

package main

import "strings"

// validateHash 验证密码是否与给定的哈希匹配
// storedHash: 存储在数据库中的完整哈希字符串（包含盐值）
// password: 用户输入的明文密码
// saltLength: 盐值的预期长度
func validateHash(storedHash, password string, saltLength int) bool {
    if len(storedHash) < saltLength {
        return false // 存储的哈希太短，无法提取盐值，视为无效
    }
    salt := storedHash[:saltLength]          // 从存储的哈希中提取盐值
    expectedHash := salt + md5sum(password+salt) // 使用提取的盐值和输入密码重新计算预期哈希
    return strings.EqualFold(storedHash, expectedHash) // 比较存储的哈希与计算出的预期哈希
}

package main

// validateHash 验证密码是否与给定的哈希匹配
// storedHash: 存储在数据库中的完整哈希字符串（包含盐值）
// password: 用户输入的明文密码
// saltLength: 盐值的预期长度
func validateHash(storedHash, password string, saltLength int) bool {
    if len(storedHash) < saltLength {
        return false // 存储的哈希太短，无法提取盐值，视为无效
    }
    salt := storedHash[:saltLength]          // 从存储的哈希中提取盐值
    expectedHash := salt + md5sum(password+salt) // 使用提取的盐值和输入密码重新计算预期哈希
    return storedHash == expectedHash // 直接比较存储的哈希与计算出的预期哈希
}

package main

import (
    "crypto/md5"
    "encoding/hex"
    "fmt"
    "io"
    "math/rand"
    "time"
)

// --- MD5 Hashing Function ---

// md5sum 对输入字符串进行MD5哈希，并返回十六进制编码的字符串
func md5sum(input string) string {
    h := md5.New()
    io.WriteString(h, input)
    return hex.EncodeToString(h.Sum(nil))
}

// --- Salt Generation Function ---

const saltChars = "0123456789abcdefghijklmnopqurstuvwxyzABCDEFGHIJKLMNOPQURSTUVWXYZ"

// init 函数在包被导入时自动执行，用于初始化随机数种子
func init() {
    rand.Seed(time.Now().UnixNano())
}

// generateSalt 生成指定长度的随机盐值
func generateSalt(length int) string {
    b := make([]byte, length)
    for i := 0; i < length; i++ {
        b[i] = saltChars[rand.Intn(len(saltChars))]
    }
    return string(b)
}

// --- Authentication Logic ---

const SaltLength = 9 // 定义盐值的固定长度，与Node.js示例保持一致

// createHash 结合密码和盐值生成哈希字符串
// 它将盐值和密码拼接后进行MD5哈希，然后将盐值前置于哈希结果
func createHash(password string) string {
    salt := generateSalt(SaltLength)
    hash := md5sum(password + salt)
    return salt + hash
}

// validateHash 验证密码是否与给定的哈希匹配
// storedHash: 存储在数据库中的完整哈希字符串（包含盐值）
// password: 用户输入的明文密码
func validateHash(storedHash, password string) bool {
    if len(storedHash) < SaltLength {
        return false // 存储的哈希太短，无法提取盐值，视为无效
    }
    salt := storedHash[:SaltLength]
    expectedHash := salt + md5sum(password+salt)
    return storedHash == expectedHash
}

func main() {
    // 示例用户密码
    userPassword := "mysecretpassword123"

    fmt.Println("--- MD5 认证逻辑迁移示例 ---")

    // 1. 创建哈希
    hashedPassword := createHash(userPassword)
    fmt.Printf("原始密码: %s\n", userPassword)
    fmt.Printf("生成的哈希 (包含盐值): %s\n", hashedPassword)
    fmt.Printf("提取的盐值: %s\n", hashedPassword[:SaltLength])

    // 2. 验证正确的密码
    isValid := validateHash(hashedPassword, userPassword)
    fmt.Printf("\n验证密码 '%s' 是否匹配: %t\n", userPassword, isValid)

    // 3. 验证错误的密码
    wrongPassword := "wrongpassword"
    isInvalid := validateHash(hashedPassword, wrongPassword)
    fmt.Printf("验证密码 '%s' 是否匹配: %t\n", wrongPassword, isInvalid)

    // 4. 验证空密码（根据业务逻辑可能需要额外处理）
    emptyPassword := ""
    isEmptyValid := validateHash(hashedPassword, emptyPassword)
    fmt.Printf("验证空密码是否匹配: %t\n", isEmptyValid)

    // 5. 验证一个不同的哈希（如果盐值不同，即使密码相同也会失败）
    anotherPassword := "anotherpassword"
    anotherHashedPassword := createHash(anotherPassword) // 生成一个新的哈希
    fmt.Printf("\n新的哈希: %s\n", anotherHashedPassword)
    fmt.Printf("验证原始密码 '%s' 是否匹配新的哈希: %t\n", userPassword, validateHash(anotherHashedPassword, userPassword))
}