Files
mtusi2026lab2/internal/password/password.go
T

101 lines
2.3 KiB
Go

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