144 lines
2.7 KiB
Go
144 lines
2.7 KiB
Go
package security
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"crypto/subtle"
|
|
"encoding/base64"
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"golang.org/x/crypto/argon2"
|
|
)
|
|
|
|
const (
|
|
memory = 64 * 1024
|
|
iterations = 3
|
|
parallelism = 2
|
|
saltLength = 16
|
|
hashLength = 32
|
|
)
|
|
|
|
var ErrInvalidHash = errors.New("invalid password hash")
|
|
|
|
func HashPassword(password string) (string, error) {
|
|
|
|
salt := make([]byte, saltLength)
|
|
|
|
if _, err := rand.Read(salt); err != nil {
|
|
return "", err
|
|
}
|
|
encodedSalt := base64.RawStdEncoding.EncodeToString(salt)
|
|
|
|
hash := argon2.IDKey(
|
|
[]byte(password),
|
|
salt,
|
|
iterations,
|
|
memory,
|
|
parallelism,
|
|
hashLength,
|
|
)
|
|
|
|
encodedHash := base64.RawStdEncoding.EncodeToString(hash)
|
|
|
|
hashPassword := fmt.Sprintf(
|
|
"$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
|
|
argon2.Version,
|
|
memory,
|
|
iterations,
|
|
parallelism,
|
|
encodedSalt,
|
|
encodedHash,
|
|
)
|
|
|
|
return hashPassword, nil
|
|
|
|
}
|
|
|
|
func VerifyPassword(password, encodedHash string) (bool, error) {
|
|
parts := strings.Split(encodedHash, "$")
|
|
|
|
if len(parts) != 6 || parts[0] != "" || parts[1] != "argon2id" {
|
|
return false, ErrInvalidHash
|
|
}
|
|
versionStr, ok := strings.CutPrefix(parts[2], "v=")
|
|
if !ok {
|
|
return false, ErrInvalidHash
|
|
}
|
|
|
|
version, err := strconv.ParseUint(versionStr, 10, 32)
|
|
if err != nil || version != uint64(argon2.Version) {
|
|
return false, ErrInvalidHash
|
|
}
|
|
|
|
params := strings.Split(parts[3], ",")
|
|
if len(params) != 3 {
|
|
return false, ErrInvalidHash
|
|
}
|
|
|
|
parseParam := func(value, prefix string, bits int) (uint64, error) {
|
|
number, ok := strings.CutPrefix(value, prefix)
|
|
if !ok {
|
|
return 0, ErrInvalidHash
|
|
}
|
|
|
|
return strconv.ParseUint(number, 10, bits)
|
|
}
|
|
|
|
m, err := parseParam(params[0], "m=", 32)
|
|
if err != nil {
|
|
return false, ErrInvalidHash
|
|
}
|
|
|
|
t, err := parseParam(params[1], "t=", 32)
|
|
if err != nil {
|
|
return false, ErrInvalidHash
|
|
}
|
|
|
|
p, err := parseParam(params[2], "p=", 8)
|
|
if err != nil {
|
|
return false, ErrInvalidHash
|
|
}
|
|
|
|
memory := uint32(m)
|
|
iterations := uint32(t)
|
|
parallelism := uint8(p)
|
|
|
|
if memory < 8*uint32(parallelism) ||
|
|
memory > 256*1024 ||
|
|
iterations < 1 || iterations > 10 ||
|
|
parallelism < 1 || parallelism > 8 {
|
|
return false, ErrInvalidHash
|
|
}
|
|
|
|
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
|
|
if err != nil {
|
|
return false, ErrInvalidHash
|
|
}
|
|
|
|
if len(salt) != saltLength {
|
|
return false, ErrInvalidHash
|
|
}
|
|
expectedHash, err := base64.RawStdEncoding.DecodeString(parts[5])
|
|
if err != nil {
|
|
return false, ErrInvalidHash
|
|
}
|
|
|
|
if len(expectedHash) != hashLength {
|
|
return false, ErrInvalidHash
|
|
}
|
|
|
|
computedHash := argon2.IDKey(
|
|
[]byte(password),
|
|
salt,
|
|
iterations,
|
|
memory,
|
|
parallelism,
|
|
uint32(len(expectedHash)),
|
|
)
|
|
|
|
return subtle.ConstantTimeCompare(computedHash, expectedHash) == 1, nil
|
|
|
|
}
|