104 lines
2.6 KiB
Go
104 lines
2.6 KiB
Go
package auth
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"crypto/subtle"
|
|
"encoding/base64"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"golang.org/x/crypto/argon2"
|
|
)
|
|
|
|
const (
|
|
argon2Memory uint32 = 19 * 1024
|
|
argon2Time uint32 = 2
|
|
argon2Threads uint8 = 1
|
|
argon2KeyLen uint32 = 32
|
|
argon2SaltLen = 16
|
|
)
|
|
|
|
type argon2Params struct {
|
|
memory uint32
|
|
time uint32
|
|
threads uint8
|
|
}
|
|
|
|
func HashPassword(password string) (string, error) {
|
|
if err := validatePassword(password); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
salt := make([]byte, argon2SaltLen)
|
|
if _, err := rand.Read(salt); err != nil {
|
|
return "", fmt.Errorf("auth: génération du sel : %w", err)
|
|
}
|
|
|
|
key := argon2.IDKey([]byte(password), salt, argon2Time, argon2Memory, argon2Threads, argon2KeyLen)
|
|
|
|
return fmt.Sprintf(
|
|
"$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
|
|
argon2.Version,
|
|
argon2Memory,
|
|
argon2Time,
|
|
argon2Threads,
|
|
base64.RawStdEncoding.EncodeToString(salt),
|
|
base64.RawStdEncoding.EncodeToString(key),
|
|
), nil
|
|
}
|
|
|
|
func VerifyPassword(password, encoded string) (bool, error) {
|
|
params, salt, key, err := decodePasswordHash(encoded)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
candidate := argon2.IDKey([]byte(password), salt, params.time, params.memory, params.threads, uint32(len(key)))
|
|
|
|
return subtle.ConstantTimeCompare(candidate, key) == 1, nil
|
|
}
|
|
|
|
func decodePasswordHash(encoded string) (argon2Params, []byte, []byte, error) {
|
|
var params argon2Params
|
|
|
|
parts := strings.Split(encoded, "$")
|
|
if len(parts) != 6 || parts[0] != "" || parts[1] != "argon2id" {
|
|
return params, nil, nil, errors.New("auth: hash Argon2id invalide")
|
|
}
|
|
|
|
var version int
|
|
if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil || version != argon2.Version {
|
|
return params, nil, nil, errors.New("auth: version Argon2id invalide")
|
|
}
|
|
|
|
var memory, iterations, threads uint32
|
|
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &iterations, &threads); err != nil {
|
|
return params, nil, nil, errors.New("auth: paramètres Argon2id invalides")
|
|
}
|
|
|
|
if memory < 8*1024 || memory > 1024*1024 ||
|
|
iterations < 1 || iterations > 10 ||
|
|
threads < 1 || threads > 16 {
|
|
return params, nil, nil, errors.New("auth: paramètres Argon2id hors limites")
|
|
}
|
|
|
|
params = argon2Params{
|
|
memory: memory,
|
|
time: iterations,
|
|
threads: uint8(threads),
|
|
}
|
|
|
|
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
|
|
if err != nil || len(salt) < 8 || len(salt) > 64 {
|
|
return params, nil, nil, errors.New("auth: sel Argon2id invalide")
|
|
}
|
|
|
|
key, err := base64.RawStdEncoding.DecodeString(parts[5])
|
|
if err != nil || len(key) < 16 || len(key) > 64 {
|
|
return params, nil, nil, errors.New("auth: clé Argon2id invalide")
|
|
}
|
|
|
|
return params, salt, key, nil
|
|
}
|