forked from mtusi2026/mtusi2026lab2
132 lines
3.1 KiB
Go
132 lines
3.1 KiB
Go
package main
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"crypto/subtle"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"unicode/utf8"
|
|
|
|
"golang.org/x/crypto/argon2"
|
|
)
|
|
|
|
const (
|
|
argonTime = 2
|
|
argonMemory = 19456
|
|
argonThreads = 1
|
|
argonKeyLen = 32
|
|
argonSaltLen = 16
|
|
)
|
|
|
|
func hashPassword(password string) (string, error) {
|
|
salt := make([]byte, argonSaltLen)
|
|
if _, err := rand.Read(salt); err != nil {
|
|
return "", err
|
|
}
|
|
hash := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
|
|
b64Salt := base64.RawStdEncoding.EncodeToString(salt)
|
|
b64Hash := base64.RawStdEncoding.EncodeToString(hash)
|
|
return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
|
|
argon2.Version, argonMemory, argonTime, argonThreads, b64Salt, b64Hash), nil
|
|
}
|
|
|
|
func checkPassword(encoded, password string) (bool, error) {
|
|
parts := strings.Split(encoded, "$")
|
|
if len(parts) != 6 || parts[1] != "argon2id" {
|
|
return false, errors.New("bad hash")
|
|
}
|
|
var version int
|
|
if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil {
|
|
return false, err
|
|
}
|
|
var memory, timeCost, threads int
|
|
for _, p := range strings.Split(parts[3], ",") {
|
|
kv := strings.SplitN(p, "=", 2)
|
|
if len(kv) != 2 {
|
|
return false, errors.New("bad params")
|
|
}
|
|
n, err := strconv.Atoi(kv[1])
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
switch kv[0] {
|
|
case "m":
|
|
memory = n
|
|
case "t":
|
|
timeCost = n
|
|
case "p":
|
|
threads = n
|
|
}
|
|
}
|
|
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
want, err := base64.RawStdEncoding.DecodeString(parts[5])
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
got := argon2.IDKey([]byte(password), salt, uint32(timeCost), uint32(memory), uint8(threads), uint32(len(want)))
|
|
return subtle.ConstantTimeCompare(got, want) == 1, nil
|
|
}
|
|
|
|
func newToken() (string, []byte, string, error) {
|
|
raw := make([]byte, 32)
|
|
if _, err := rand.Read(raw); err != nil {
|
|
return "", nil, "", err
|
|
}
|
|
token := base64.RawURLEncoding.EncodeToString(raw)
|
|
sum := sha256.Sum256([]byte(token))
|
|
hash := make([]byte, len(sum))
|
|
copy(hash, sum[:])
|
|
return token, hash, hex.EncodeToString(hash), nil
|
|
}
|
|
|
|
func tokenHash(token string) ([]byte, string) {
|
|
sum := sha256.Sum256([]byte(token))
|
|
hash := make([]byte, len(sum))
|
|
copy(hash, sum[:])
|
|
return hash, hex.EncodeToString(hash)
|
|
}
|
|
|
|
func parseBasic(header string) (username, password string, ok bool) {
|
|
const prefix = "Basic "
|
|
if !strings.HasPrefix(header, prefix) {
|
|
return "", "", false
|
|
}
|
|
decoded, err := base64.StdEncoding.DecodeString(strings.TrimSpace(header[len(prefix):]))
|
|
if err != nil {
|
|
return "", "", false
|
|
}
|
|
s := string(decoded)
|
|
i := strings.IndexByte(s, ':')
|
|
if i < 0 {
|
|
return "", "", false
|
|
}
|
|
username = s[:i]
|
|
password = s[i+1:]
|
|
return username, password, true
|
|
}
|
|
|
|
func parseBearer(header string) (string, bool) {
|
|
const prefix = "Bearer "
|
|
if !strings.HasPrefix(header, prefix) {
|
|
return "", false
|
|
}
|
|
tok := strings.TrimSpace(header[len(prefix):])
|
|
if tok == "" {
|
|
return "", false
|
|
}
|
|
return tok, true
|
|
}
|
|
|
|
func validPassword(p string) bool {
|
|
n := utf8.RuneCountInString(p)
|
|
return n >= 12 && n <= 128
|
|
}
|