Files
mtusi2026lab6/internal/password/password.go
T
2026-11-01 14:46:14 +03:00

134 lines
3.7 KiB
Go

package password
import (
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"errors"
"fmt"
"strconv"
"strings"
"golang.org/x/crypto/argon2"
)
var (
ErrInvalidConfig = errors.New("invalid password configuration")
ErrInvalidHash = errors.New("invalid password hash")
)
type Config struct {
MemoryKiB uint32
Iterations uint32
Parallelism uint8
SaltLength uint32
KeyLength uint32
}
type Hasher struct {
config Config
dummyHash string
}
func New(config Config) (*Hasher, error) {
if err := validateConfig(config); err != nil {
return nil, err
}
salt := make([]byte, config.SaltLength)
digest := argon2.IDKey([]byte("invalid-user-password"), salt, config.Iterations, config.MemoryKiB, config.Parallelism, config.KeyLength)
return &Hasher{config: config, dummyHash: encode(config, salt, digest)}, nil
}
func validateConfig(config Config) error {
if config.MemoryKiB < 8*1024 || config.MemoryKiB > 1024*1024 ||
config.Iterations < 1 || config.Iterations > 20 ||
config.Parallelism < 1 ||
config.SaltLength < 8 || config.SaltLength > 1024 ||
config.KeyLength < 16 || config.KeyLength > 1024 {
return ErrInvalidConfig
}
return nil
}
func (h *Hasher) Hash(value string) (string, error) {
salt := make([]byte, h.config.SaltLength)
if _, err := rand.Read(salt); err != nil {
return "", fmt.Errorf("generate password salt: %w", err)
}
digest := argon2.IDKey([]byte(value), salt, h.config.Iterations, h.config.MemoryKiB, h.config.Parallelism, h.config.KeyLength)
return encode(h.config, salt, digest), nil
}
func (h *Hasher) Verify(value, encodedHash string) (bool, error) {
config, salt, digest, err := decode(encodedHash)
if err != nil {
return false, err
}
actual := argon2.IDKey([]byte(value), salt, config.Iterations, config.MemoryKiB, config.Parallelism, config.KeyLength)
return subtle.ConstantTimeCompare(actual, digest) == 1, nil
}
func (h *Hasher) DummyHash() string {
return h.dummyHash
}
func encode(config Config, salt, digest []byte) string {
return fmt.Sprintf(
"$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
argon2.Version,
config.MemoryKiB,
config.Iterations,
config.Parallelism,
base64.RawStdEncoding.EncodeToString(salt),
base64.RawStdEncoding.EncodeToString(digest),
)
}
func decode(encodedHash string) (Config, []byte, []byte, error) {
parts := strings.Split(encodedHash, "$")
if len(parts) != 6 || parts[0] != "" || parts[1] != "argon2id" || parts[2] != fmt.Sprintf("v=%d", argon2.Version) {
return Config{}, nil, nil, ErrInvalidHash
}
parameters := strings.Split(parts[3], ",")
if len(parameters) != 3 {
return Config{}, nil, nil, ErrInvalidHash
}
memory, err := parameter(parameters[0], "m=", 32)
if err != nil {
return Config{}, nil, nil, ErrInvalidHash
}
iterations, err := parameter(parameters[1], "t=", 32)
if err != nil {
return Config{}, nil, nil, ErrInvalidHash
}
parallelism, err := parameter(parameters[2], "p=", 8)
if err != nil {
return Config{}, nil, nil, ErrInvalidHash
}
salt, err := base64.RawStdEncoding.Strict().DecodeString(parts[4])
if err != nil {
return Config{}, nil, nil, ErrInvalidHash
}
digest, err := base64.RawStdEncoding.Strict().DecodeString(parts[5])
if err != nil {
return Config{}, nil, nil, ErrInvalidHash
}
config := Config{
MemoryKiB: uint32(memory), Iterations: uint32(iterations), Parallelism: uint8(parallelism),
SaltLength: uint32(len(salt)), KeyLength: uint32(len(digest)),
}
if err := validateConfig(config); err != nil {
return Config{}, nil, nil, ErrInvalidHash
}
return config, salt, digest, nil
}
func parameter(value, prefix string, bitSize int) (uint64, error) {
if !strings.HasPrefix(value, prefix) {
return 0, ErrInvalidHash
}
return strconv.ParseUint(strings.TrimPrefix(value, prefix), 10, bitSize)
}