forked from mtusi2026/mtusi2026lab5
ЛР 5: асинхронная обработка изображений и идемпотентность pipeline
This commit is contained in:
@@ -0,0 +1,147 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"crypto/sha256"
|
||||
"crypto/subtle"
|
||||
"encoding/base64"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/redis/go-redis/v9"
|
||||
"golang.org/x/crypto/argon2"
|
||||
)
|
||||
|
||||
func password(body map[string]json.RawMessage) (string, error) {
|
||||
var p string
|
||||
if json.Unmarshal(body["password"], &p) != nil || utf8.RuneCountInString(p) < 12 || utf8.RuneCountInString(p) > 128 {
|
||||
return "", invalid()
|
||||
}
|
||||
return p, nil
|
||||
}
|
||||
func hashPassword(p string) string {
|
||||
salt := make([]byte, 16)
|
||||
if _, err := rand.Read(salt); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
key := argon2.IDKey([]byte(p), salt, 3, 64*1024, 1, 32)
|
||||
return "$argon2id$v=19$m=65536,t=3,p=1$" + base64.RawStdEncoding.EncodeToString(salt) + "$" + base64.RawStdEncoding.EncodeToString(key)
|
||||
}
|
||||
func verifyPassword(hash, p string) bool {
|
||||
parts := strings.Split(hash, "$")
|
||||
if len(parts) != 6 || parts[1] != "argon2id" || parts[2] != "v=19" || parts[3] != "m=65536,t=3,p=1" {
|
||||
return false
|
||||
}
|
||||
salt, e := base64.RawStdEncoding.DecodeString(parts[4])
|
||||
if e != nil || len(salt) != 16 {
|
||||
return false
|
||||
}
|
||||
want, e := base64.RawStdEncoding.DecodeString(parts[5])
|
||||
if e != nil || len(want) != 32 {
|
||||
return false
|
||||
}
|
||||
actual := argon2.IDKey([]byte(p), salt, 3, 64*1024, 1, 32)
|
||||
return subtle.ConstantTimeCompare(want, actual) == 1
|
||||
}
|
||||
func (a *App) kdfSlot(ctx context.Context) error {
|
||||
select {
|
||||
case a.kdf <- struct{}{}:
|
||||
return nil
|
||||
case <-ctx.Done():
|
||||
return unavailable()
|
||||
}
|
||||
}
|
||||
|
||||
type storedSession struct {
|
||||
UserID string `json:"user_id"`
|
||||
ExpiresAt time.Time `json:"expires_at"`
|
||||
}
|
||||
|
||||
func sessionKey(token string) string {
|
||||
h := sha256.Sum256([]byte(token))
|
||||
return "sess:" + hex.EncodeToString(h[:])
|
||||
}
|
||||
func (a *App) authenticate(ctx context.Context, r *http.Request) (string, string, error) {
|
||||
values := r.Header.Values("Authorization")
|
||||
if len(values) != 1 {
|
||||
return "", "", unauthorized()
|
||||
}
|
||||
parts := strings.Fields(values[0])
|
||||
if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") {
|
||||
return "", "", unauthorized()
|
||||
}
|
||||
token, e := base64.RawURLEncoding.DecodeString(parts[1])
|
||||
if e != nil || len(token) != 32 {
|
||||
return "", "", unauthorized()
|
||||
}
|
||||
key := sessionKey(parts[1])
|
||||
raw, err := a.sessions.Get(ctx, key).Bytes()
|
||||
if errors.Is(err, redis.Nil) {
|
||||
return "", "", unauthorized()
|
||||
}
|
||||
if err != nil {
|
||||
return "", "", unavailable()
|
||||
}
|
||||
var session storedSession
|
||||
if json.Unmarshal(raw, &session) != nil {
|
||||
return "", "", unavailable()
|
||||
}
|
||||
if !time.Now().Before(session.ExpiresAt) {
|
||||
return "", "", unauthorized()
|
||||
}
|
||||
if _, err = a.user(ctx, session.UserID); err != nil {
|
||||
var ae apiError
|
||||
if errors.As(err, &ae) && ae.status == 404 {
|
||||
return "", "", unauthorized()
|
||||
}
|
||||
return "", "", err
|
||||
}
|
||||
return session.UserID, key, nil
|
||||
}
|
||||
func (a *App) login(ctx context.Context, r *http.Request) (int, any, error) {
|
||||
if r.ContentLength > 0 || len(r.TransferEncoding) > 0 {
|
||||
return 0, nil, invalid()
|
||||
}
|
||||
username, p, ok := r.BasicAuth()
|
||||
if len(r.Header.Values("Authorization")) != 1 || !ok || !usernamePattern.MatchString(username) || !utf8.ValidString(p) || utf8.RuneCountInString(p) < 12 || utf8.RuneCountInString(p) > 128 {
|
||||
return 0, nil, unauthorized()
|
||||
}
|
||||
var hash string
|
||||
var u User
|
||||
var created time.Time
|
||||
err := a.db.QueryRow(ctx, "SELECT id::text,username,display_name,created_at,password_hash FROM users WHERE username=$1", username).Scan(&u.ID, &u.Username, utf8String{&u.DisplayName}, &created, &hash)
|
||||
absent := errors.Is(err, pgx.ErrNoRows)
|
||||
if err != nil && !absent {
|
||||
return 0, nil, unavailable()
|
||||
}
|
||||
if absent {
|
||||
hash = a.dummyHash
|
||||
}
|
||||
if err = a.kdfSlot(ctx); err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
valid := verifyPassword(hash, p)
|
||||
<-a.kdf
|
||||
if !valid || absent {
|
||||
return 0, nil, unauthorized()
|
||||
}
|
||||
u.CreatedAt = stamp(created)
|
||||
tokenBytes := make([]byte, 32)
|
||||
if _, err = rand.Read(tokenBytes); err != nil {
|
||||
return 0, nil, unavailable()
|
||||
}
|
||||
token := base64.RawURLEncoding.EncodeToString(tokenBytes)
|
||||
expires := time.Now().UTC().Truncate(time.Second).Add(a.ttl)
|
||||
raw, _ := json.Marshal(storedSession{u.ID, expires})
|
||||
if err = a.sessions.SetArgs(ctx, sessionKey(token), raw, redis.SetArgs{Mode: "NX", ExpireAt: expires}).Err(); err != nil {
|
||||
return 0, nil, unavailable()
|
||||
}
|
||||
return 201, map[string]any{"token": token, "token_type": "Bearer", "expires_at": expires.Format(time.RFC3339), "user": u}, nil
|
||||
}
|
||||
Reference in New Issue
Block a user