package passwordutil import ( "crypto/rand" "crypto/sha256" "crypto/subtle" "encoding/base64" "encoding/hex" "errors" "fmt" "strings" "golang.org/x/crypto/argon2" ) const ( AlgoArgon2id = "argon2id" AlgoLegacy = "legacy" ) const ( argonTime = 3 argonMemory = 64 * 1024 argonThreads = 2 argonKeyLen = 32 argonSaltLen = 16 ) const ( saltBytes = 16 separator = "$" hashLength = 64 ) func Hash(plain string) (string, error) { plain = strings.TrimSpace(plain) if plain == "" { return "", errors.New("password 不能为空") } salt := make([]byte, argonSaltLen) if _, err := rand.Read(salt); err != nil { return "", err } key := argon2.IDKey([]byte(plain), salt, argonTime, argonMemory, argonThreads, argonKeyLen) return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s", argon2.Version, argonMemory, argonTime, argonThreads, base64.RawStdEncoding.EncodeToString(salt), base64.RawStdEncoding.EncodeToString(key), ), nil } func Verify(stored, plain string) bool { stored = strings.TrimSpace(stored) plain = strings.TrimSpace(plain) if stored == "" || plain == "" { return false } if strings.HasPrefix(stored, "$argon2id$") { return verifyArgon2id(stored, plain) } return verifyLegacy(stored, plain) } func NeedsRehash(stored string) bool { return !strings.HasPrefix(strings.TrimSpace(stored), "$argon2id$") } func AlgoOf(stored string) string { if strings.HasPrefix(strings.TrimSpace(stored), "$argon2id$") { return AlgoArgon2id } return AlgoLegacy } func verifyArgon2id(stored, plain string) bool { parts := strings.Split(stored, "$") if len(parts) != 6 { return false } var memory, iterations, parallelism uint32 if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &iterations, ¶llelism); err != nil { return false } if memory == 0 || iterations == 0 || parallelism == 0 || parallelism > 255 { return false } threads := uint8(parallelism) salt, err := base64.RawStdEncoding.DecodeString(parts[4]) if err != nil || len(salt) == 0 { return false } want, err := base64.RawStdEncoding.DecodeString(parts[5]) if err != nil || len(want) == 0 { return false } got := argon2.IDKey([]byte(plain), salt, iterations, memory, threads, uint32(len(want))) return subtle.ConstantTimeCompare(got, want) == 1 } func verifyLegacy(stored, plain string) bool { stored = strings.TrimSpace(stored) plain = strings.TrimSpace(plain) if stored == "" || plain == "" { return false } parts := strings.Split(stored, separator) if len(parts) != 2 { return false } saltHex := strings.TrimSpace(parts[0]) hashHexStored := strings.TrimSpace(parts[1]) if saltHex == "" || len(hashHexStored) != hashLength { return false } if _, err := hex.DecodeString(saltHex); err != nil { return false } return hashHex(saltHex, plain) == strings.ToLower(hashHexStored) } func hashHex(saltHex, plain string) string { sum := sha256.Sum256([]byte(saltHex + plain)) return hex.EncodeToString(sum[:]) }