forked from mtusi2026/mtusi2026lab6
134 lines
3.7 KiB
Go
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)
|
|
}
|