Maišymas, sesijų saugykla, Manager

Pirma nauja priklausomybė (bcrypt gyvena Go komandos išplėstinėje kriptografijoje):

go get golang.org/x/crypto/bcrypt

Penki failai kaip skirtukai, priklausomybių tvarka: 00002_sessions.sql → sessions.sql → users.sql → password.go → session.go (lentelė, jos užklausos, vartotojų užklausos, kurių reikia registracijai, maišytojas, tada Manager, kuris viską suriša). Tada paleisk sqlc generate, kad naujos užklausos taptų Go.

1. db/migrations/00002_sessions.sql — sesijų saugykla. Atkreipk dėmesį, kas čia yra ir ko nėra:

token_hash TEXT NOT NULL UNIQUE,                        -- saugom MAIŠĄ, ne žetoną
user_id    UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at TIMESTAMPTZ NOT NULL

ON DELETE CASCADE reiškia, kad ištrynus vartotoją jo sesijos pašalinamos automatiškai. token_hash yra UNIQUE (vienas žetonas → viena sesija) ir, svarbiausia, tai maiša — neapdorotas žetonas niekada neliečia duomenų bazės.

2. internal/db/queries/sessions.sql — CreateSession, GetUserBySessionToken (jungtis, kuri paverčia žetoną tiesiai į vartotoją ir filtruoja expires_at > now()) ir DeleteSession (atsijungimas, kitą pamoką). GetUserBySessionToken naudoja sqlc.embed(users), tad grąžina visą tipizuotą User.

3. internal/db/queries/users.sql (modify) — registracijai reikia dar dviejų užklausų: CreateUser (įrašymas, RETURNING *) ir GetUserByEmail (dublikatų patikra + prisijungimas, kitą pamoką). CountUsers iš 3 pamokos nepaliesta — diff yra grynas papildymas.

4. internal/auth/password.go — HashPassword / CheckPassword. Ilgio riba — įdomioji eilutė:

// MaxPasswordLen guards bcrypt's 72-byte input limit so passwords are never
// silently truncated. (A byte, not a rune, but 64 chars is plenty.)
MaxPasswordLen = 64

CheckPassword naudoja bcrypt.CompareHashAndPassword, kuris veikia pastoviu laiku — jo negalima panaudoti kaip laiko orakulo slaptažodžiui atspėti.

5. internal/session/session.go — Manager: Create (sukuria atsitiktinį žetoną, saugo jo maišą, nustato slapuką), User (slapukas → maiša → vartotojas, arba ErrNoSession), Destroy (ištrina eilutę + panaikina slapuką). cookie pagalbininke gyvena vėliavos:

HttpOnly: true,                 // JS jo neperskaitys — mažina XSS žetono vagystę
Secure:   m.secure,             // tik HTTPS produkcijoje (cfg.IsProd())
SameSite: http.SameSiteLaxMode, // siunčiamas su navigacija, ne kryžminiais POST

Create naudojamas šią pamoką (registracija); User ir Destroy — mechanizmas, kurį 5 pamoka kvies prisijungimui ir atsijungimui — parašyti dabar, nes tai viena vientisa dalis.

00002_sessions.sql SUKURTI

Sukurk šį failą kataloge db/migrations/

-- +goose Up
-- +goose StatementBegin
-- Server-side session store. The cookie holds an opaque random token; we store
-- only the SHA-256 hash of it, so a database leak does not hand out live
-- sessions. This is the "session in a cookie" half of the sessions-vs-JWT
-- contrast the course teaches.
CREATE TABLE sessions (
    id         UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
    token_hash TEXT        NOT NULL UNIQUE,
    user_id    UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    expires_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX idx_sessions_user_id ON sessions(user_id);
-- +goose StatementEnd

-- +goose Down
-- +goose StatementBegin
DROP TABLE sessions;
-- +goose StatementEnd

sessions.sql SUKURTI

Sukurk šį failą kataloge internal/db/queries/

-- name: CreateSession :one
INSERT INTO sessions (token_hash, user_id, expires_at)
VALUES ($1, $2, $3)
RETURNING *;

-- name: GetUserBySessionToken :one
SELECT sqlc.embed(users)
FROM users
JOIN sessions ON sessions.user_id = users.id
WHERE sessions.token_hash = $1
  AND sessions.expires_at > now();

-- name: DeleteSession :exec
DELETE FROM sessions WHERE token_hash = $1;

users.sql MODIFIKUOTI 8 eilutės pakeistos

Redaguok šį failą kataloge internal/db/queries/

-- name: CountUsers :one
SELECT count(*) FROM users;

-- name: CreateUser :one
INSERT INTO users (email, password_hash)
VALUES ($1, $2)
RETURNING *;

-- name: GetUserByEmail :one
SELECT * FROM users WHERE email = $1;

password.go SUKURTI

Sukurk šį failą kataloge internal/auth/

// Package auth handles password hashing and credential checks.
//
// Hashing choice: bcrypt (golang.org/x/crypto/bcrypt).
//
// Why bcrypt and not argon2id? For a teaching reference app the deciding factor
// is a small, hard-to-misuse surface:
//   - One tuning knob (cost). argon2id needs three (memory, time, parallelism)
//     that you must choose, store, and keep in sync — more to get wrong.
//   - The cost is embedded in the hash string, so verification needs no external
//     parameters and rehashing on cost bumps is trivial.
//   - It ships in the Go team's golang.org/x/crypto with a decade of scrutiny.
//
// The honest tradeoff: argon2id is memory-hard and is OWASP's first
// recommendation for new systems; bcrypt is GPU-friendlier and truncates input
// at 72 bytes. We accept that by capping password length (see MaxPasswordLen) so
// nothing is silently truncated, and we document argon2id as the upgrade path.
package auth

import (
	"errors"

	"golang.org/x/crypto/bcrypt"
)

const (
	// bcryptCost of 12 is ~250ms/hash on typical 2020s hardware — a sensible
	// balance of user-facing latency and brute-force resistance.
	bcryptCost = 12

	// MinPasswordLen is a floor; NIST guidance favours length over complexity.
	MinPasswordLen = 8
	// MaxPasswordLen guards bcrypt's 72-byte input limit so passwords are never
	// silently truncated. (A byte, not a rune, but 64 chars is plenty.)
	MaxPasswordLen = 64
)

var ErrPasswordLength = errors.New("password must be between 8 and 64 characters")

// HashPassword returns a bcrypt hash suitable for storage.
func HashPassword(plain string) (string, error) {
	if len(plain) < MinPasswordLen || len(plain) > MaxPasswordLen {
		return "", ErrPasswordLength
	}
	b, err := bcrypt.GenerateFromPassword([]byte(plain), bcryptCost)
	if err != nil {
		return "", err
	}
	return string(b), nil
}

// CheckPassword reports whether plain matches the stored bcrypt hash. It runs in
// constant time relative to the hash, so it is safe against timing attacks.
func CheckPassword(hash, plain string) bool {
	return bcrypt.CompareHashAndPassword([]byte(hash), []byte(plain)) == nil
}

session.go SUKURTI

Sukurk šį failą kataloge internal/session/

// Package session implements server-side sessions backed by Postgres.
//
// The browser only ever holds an opaque random token in an HttpOnly cookie. The
// authoritative session lives in the `sessions` table, keyed by the SHA-256 hash
// of that token. This is the deliberate counterpoint to the Pica app's JWT: no
// claims in the token, state on the server, and revocation is a single DELETE.
package session

import (
	"context"
	"crypto/rand"
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"errors"
	"net/http"
	"time"

	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgtype"

	"github.com/programuoki/signflow/internal/db"
)

// CookieName is the session cookie. The __Host- prefix would be even stricter
// but requires HTTPS always; we keep a plain name so dev over http works.
const CookieName = "signflow_session"

// Lifetime is how long a session (and its cookie) stays valid.
const Lifetime = 30 * 24 * time.Hour

// ErrNoSession means the request carried no valid session.
var ErrNoSession = errors.New("no session")

// Manager creates, resolves, and destroys sessions.
type Manager struct {
	q      *db.Queries
	secure bool // set Secure flag on cookies (true in production)
}

func NewManager(q *db.Queries, secure bool) *Manager {
	return &Manager{q: q, secure: secure}
}

// Create issues a new session for userID and writes the cookie.
func (m *Manager) Create(ctx context.Context, w http.ResponseWriter, userID pgtype.UUID) error {
	token, err := randomToken()
	if err != nil {
		return err
	}
	expires := time.Now().Add(Lifetime)
	if _, err := m.q.CreateSession(ctx, db.CreateSessionParams{
		TokenHash: hashToken(token),
		UserID:    userID,
		ExpiresAt: pgtype.Timestamptz{Time: expires, Valid: true},
	}); err != nil {
		return err
	}
	http.SetCookie(w, m.cookie(token, expires))
	return nil
}

// User resolves the current user from the request's session cookie. It returns
// ErrNoSession when there is no cookie or the session is expired/unknown.
func (m *Manager) User(ctx context.Context, r *http.Request) (db.User, error) {
	c, err := r.Cookie(CookieName)
	if err != nil || c.Value == "" {
		return db.User{}, ErrNoSession
	}
	row, err := m.q.GetUserBySessionToken(ctx, hashToken(c.Value))
	if errors.Is(err, pgx.ErrNoRows) {
		return db.User{}, ErrNoSession
	}
	if err != nil {
		return db.User{}, err
	}
	return row.User, nil
}

// Destroy deletes the current session server-side and clears the cookie.
func (m *Manager) Destroy(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
	if c, err := r.Cookie(CookieName); err == nil && c.Value != "" {
		if err := m.q.DeleteSession(ctx, hashToken(c.Value)); err != nil {
			return err
		}
	}
	// Expire the cookie in the browser.
	http.SetCookie(w, m.cookie("", time.Unix(0, 0)))
	return nil
}

// cookie builds the session cookie with security flags applied.
func (m *Manager) cookie(value string, expires time.Time) *http.Cookie {
	return &http.Cookie{
		Name:     CookieName,
		Value:    value,
		Path:     "/",
		Expires:  expires,
		HttpOnly: true,                 // JS can't read it — mitigates XSS token theft
		Secure:   m.secure,             // HTTPS-only in production
		SameSite: http.SameSiteLaxMode, // sent on top-level navigations, not cross-site POSTs
	}
}

// randomToken returns 32 bytes of CSPRNG entropy, URL-safe base64 encoded.
func randomToken() (string, error) {
	b := make([]byte, 32)
	if _, err := rand.Read(b); err != nil {
		return "", err
	}
	return base64.RawURLEncoding.EncodeToString(b), nil
}

// hashToken is what we actually store/look up, so a DB dump reveals no usable
// session tokens.
func hashToken(token string) string {
	sum := sha256.Sum256([]byte(token))
	return hex.EncodeToString(sum[:])
}