将Node.js MD5认证逻辑安全地移植到Go语言

var crypto = require('crypto');

var SaltLength = 9;

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;
}

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;
}

function md5(string) {
  return crypto.createHash('md5').update(string).digest('hex');
}

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

// md5String 计算给定字符串的MD5哈希值并返回十六进制字符串
func md5String(input string) string {
    h := md5.New()
    io.WriteString(h, input)
    return fmt.Sprintf("%x", h.Sum(nil))
}

import (
    "crypto/rand" // 导入crypto/rand用于安全随机数生成
    "fmt"
    "io"
    "math/big"    // 用于处理大整数，crypto/rand.Int返回*big.Int
)

// generateSalt 生成指定长度的随机盐值
func generateSalt(length int) (string, error) {
    const charset = "0123456789abcdefghijklmnopqurstuvwxyzABCDEFGHIJKLMNOPQURSTUVWXYZ"
    salt := make([]byte, length)
    for i := 0; i < length; i++ {
        // 使用crypto/rand生成一个在charset范围内的随机数
        num, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
        if err != nil {
            return "", fmt.Errorf("failed to generate random number for salt: %w", err)
        }
        salt[i] = charset[num.Int64()]
    }
    return string(salt), nil
}

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

const SaltLength = 9 // 盐值长度，与Node.js保持一致

// 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, error) {
    const charset = "0123456789abcdefghijklmnopqurstuvwxyzABCDEFGHIJKLMNOPQURSTUVWXYZ"
    salt := make([]byte, length)
    for i := 0; i < length; i++ {
        num, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
        if err != nil {
            return "", fmt.Errorf("failed to generate random number for salt: %w", err)
        }
        salt[i] = charset[num.Int64()]
    }
    return string(salt), nil
}

// createHash 根据密码生成带盐值的哈希字符串
func createHash(password string) (string, error) {
    salt, err := generateSalt(SaltLength)
    if err != nil {
        return "", fmt.Errorf("failed to create salt: %w", err)
    }
    hash := md5String(password + salt)
    return salt + hash, nil
}

// validateHash 验证密码是否与存储的哈希匹配
func validateHash(storedHash string, password string) bool {
    if len(storedHash) < SaltLength {
        return false // 存储的哈希字符串太短，无法提取盐值
    }
    salt := storedHash[:SaltLength]
    validHash := salt + md5String(password + salt)
    return storedHash == validHash
}

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

    // 创建哈希
    hashedPassword, err := createHash(password)
    if err != nil {
        fmt.Println("Error creating hash:", err)
        return
    }
    fmt.Println("Generated Hashed Password:", hashedPassword)

    // 验证密码
    isValid := validateHash(hashedPassword, password)
    fmt.Println("Password validation result (correct password):", isValid) // 应该为 true

    isValidWrong := validateHash(hashedPassword, "wrongPassword")
    fmt.Println("Password validation result (wrong password):", isValidWrong) // 应该为 false

    // 尝试使用不同的盐值创建哈希，以验证其唯一性
    hashedPassword2, _ := createHash(password)
    fmt.Println("Generated Hashed Password 2:", hashedPassword2) // 应该与 hashedPassword 不同
}