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

var crypto = require('crypto');

var SaltLength = 9; // 盐值长度

// 生成随机盐值
function generateSalt(len) {
  var set = '0123456789abcdefghijklmnopqurstuvwxyzABCDEFGHIJKLMNOPQURSTUVWXYZ',
      setLen = set.length,
      salt = '';
  for (var i = 0; i < len; i++) {
    var p = Math.floor(Math.random() * setLen);
    salt += set[p];
  }
  return salt;
}

// 执行 MD5 散列
function md5(string) {
  return crypto.createHash('md5').update(string).digest('hex');
}

// 创建加盐的密码散列
function createHash(password) {
  var salt = generateSalt(SaltLength);
  var hash = md5(password + salt);
  return salt + hash; // 将盐值和散列值拼接返回
}

// 验证密码
function validateHash(hash, password) {
  var salt = hash.substr(0, SaltLength); // 从存储的散列中提取盐值
  var validHash = salt + md5(password + salt); // 使用提取的盐值和用户输入的密码重新计算散列
  return hash === validHash; // 比较是否匹配
}

package main

import (
    "crypto/md5"
    "fmt"
    "io"
)

func main() {
    h := md5.New() // 创建一个新的 MD5 散列器
    // 可以多次写入数据，MD5 会累积计算
    io.WriteString(h, "Hello, ")
    io.WriteString(h, "Go!")
    // Sum(nil) 返回最终的散列值（字节切片）
    // fmt.Printf("%x", ...) 将字节切片格式化为十六进制字符串
    fmt.Printf("%x\n", h.Sum(nil)) // 输出：f3729e2f49437149f7e52a22533038a8
}

package main

import (
    "crypto/md5"
    "fmt"
    "io"
)

// md5String 对输入字符串进行 MD5 散列，并返回十六进制字符串
func md5String(input string) string {
    h := md5.New()          // 创建一个新的 MD5 散列器
    io.WriteString(h, input) // 将输入字符串写入散列器
    return fmt.Sprintf("%x", h.Sum(nil)) // 获取散列结果并格式化为十六进制字符串
}

func main() {
    fmt.Println(md5String("Hello, Go!")) // 输出：f3729e2f49437149f7e52a22533038a8
}

package main

import (
    "math/rand"
    "time"
)

const saltCharset = "0123456789abcdefghijklmnopqurstuvwxyzABCDEFGHIJKLMNOPQURSTUVWXYZ"

// generateSalt 生成指定长度的随机盐值
func generateSalt(length int) string {
    // 初始化随机数生成器。对于生产环境，建议使用 crypto/rand 以获得更高质量的随机性。
    // 这里使用 math/rand 是为了更直接地模拟 Node.js 的 Math.random() 行为。
    // 每次程序启动只应调用一次 rand.Seed()。
    // 注意：如果函数被频繁调用，且在短时间内，可能会生成相同的盐值，因为种子只在程序启动时设置。
    // 更安全的做法是将 rand.Source 作为一个参数传递或使用全局的 Rand 实例。
    // 或者在每次调用时重新设置种子，但这样性能会受影响。
    // 为了简化，我们假设在一个主入口点设置一次种子。
    // 如果在实际应用中，建议在 main 函数中调用 rand.Seed(time.Now().UnixNano()) 一次。
    // 对于本示例，我们直接在函数内为了演示方便进行一次性初始化。
    // 注意：在实际的多并发场景中，不应在每次调用时都初始化 Seed，否则会引入并发问题。
    // 更好的做法是在 main 函数中初始化一次全局的 rand.Source 或使用 sync.Once。
    // 这里为了演示，我们假设在应用程序生命周期中，种子已被初始化。
    // 鉴于原始Node.js代码的简单性，我们保持类似的随机性。

    // 在 main 函数中初始化一次，或者使用局部随机源
    // r := rand.New(rand.NewSource(time.Now().UnixNano())) // 更安全的局部随机源

    seededRand := rand.New(rand.NewSource(time.Now().UnixNano()))

    salt := make([]byte, length)
    charsetLen := len(saltCharset)
    for i := 0; i < length; i++ {
        salt[i] = saltCharset[seededRand.Intn(charsetLen)]
    }
    return string(salt)
}

// 建议在 main 函数中调用一次此行：
// func init() {
//     rand.Seed(time.Now().UnixNano())
// }
// 然后 generateSalt 可以直接使用 rand.Intn

// 如果在 main 函数中初始化了 rand.Seed，则 generateSalt 可以简化为：
/*
func generateSalt(length int) string {
    salt := make([]byte, length)
    charsetLen := len(saltCharset)
    for i := 0; i < length; i++ {
        salt[i] = saltCharset[rand.Intn(charsetLen)]
    }
    return string(salt)
}
*/

package main

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

const (
    SaltLength  = 9
    saltCharset = "0123456789abcdefghijklmnopqurstuvwxyzABCDEFGHIJKLMNOPQURSTUVWXYZ"
)

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

// md5String 对输入字符串进行 MD5 散列，并返回十六进制字符串
func md5String(input string) string {
    h := md5.New()
    io.WriteString(h, input)
    return fmt.Sprintf("%x", h.Sum(nil))
}

// generateSalt 生成指定长度的随机盐值
func generateSalt(length int) string {
    salt := make([]byte, length)
    charsetLen := len(saltCharset)
    for i := 0; i < length; i++ {
        salt[i] = saltCharset[rand.Intn(charsetLen)] // 使用全局的 rand 实例
    }
    return string(salt)
}

// createHash 创建加盐的密码散列
func createHash(password string) string {
    salt := generateSalt(SaltLength)
    hash := md5String(password + salt)
    return salt + hash // 将盐值和散列值拼接返回
}

// validateHash 验证密码
func validateHash(hashedPassword string, password string) bool {
    if len(hashedPassword) < SaltLength {
        return false // 存储的散列字符串太短，无法提取盐值
    }
    salt := hashedPassword[:SaltLength] // 从存储的散列中提取盐值
    validHash := salt + md5String(password + salt) // 使用提取的盐值和用户输入的密码重新计算散列
    return hashedPassword == validHash // 比较是否匹配
}

func main() {
    // 示例用法
    password := "mysecretpassword"

    // 创建散列
    hashedPwd := createHash(password)
    fmt.Printf("原始密码: %s\n", password)
    fmt.Printf("散列密码 (含盐值): %s\n", hashedPwd)

    // 验证密码
    isValid := validateHash(hashedPwd, password)
    fmt.Printf("验证结果 (正确密码): %t\n", isValid) // 应该为 true

    isValidWrong := validateHash(hashedPwd, "wrongpassword")
    fmt.Printf("验证结果 (错误密码): %t\n", isValidWrong) // 应该为 false

    // 演示不同的盐值导致不同的散列
    hashedPwd2 := createHash(password)
    fmt.Printf("第二次散列密码 (含盐值): %s\n", hashedPwd2)
    fmt.Printf("两次散列是否相同: %t\n", hashedPwd == hashedPwd2) // 应该为 false
}