forked from mtusi2026/mtusi2026lab2
101 lines
2.3 KiB
Go
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
|
|
}
|