sonda/internal/api/http/middleware.go
tgiachi 52d1828b46 fix(auth): a token stops working when its account is deleted
SQLite gives the highest user id again after that user is deleted, and an access
token lives for minutes, so the token of a deleted user worked as whoever got the
id next (settings, taste, listens, account).

requireAuth now looks the account up after checking the token and refuses it when
the account is gone, has another name, or was created after the token was signed.
The token carries its issue time for this.

Tests: a unit test of every case, and the real scenario on SQLite (delete the
highest id, create another user, the old token gets 401, the new one works).

Closes #30
2026-11-11 19:25:09 +01:00

133 lines
4.3 KiB
Go

package httpapi
import (
"context"
"errors"
"net/http"
"strings"
"time"
"github.com/gin-gonic/gin"
"go.uber.org/zap"
"codeberg.org/squidd/sonda/internal/auth"
)
const (
ctxUserID = "user_id"
ctxUsername = "username"
)
// limitBody caps the request body size.
func limitBody(max int64) gin.HandlerFunc {
return func(c *gin.Context) {
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, max)
c.Next()
}
}
// requestLog logs one line per request. It never logs headers, query strings
// or bodies, so tokens and passwords cannot leak into the log.
func requestLog(logger *zap.Logger) gin.HandlerFunc {
return func(c *gin.Context) {
start := time.Now()
c.Next()
fields := []zap.Field{
zap.String("method", c.Request.Method),
zap.String("path", c.Request.URL.Path),
zap.Int("status", c.Writer.Status()),
zap.Duration("latency", time.Since(start)),
}
if last := c.Errors.Last(); last != nil {
// Internal errors are hidden from the client; keep them in the log.
fields = append(fields, zap.String("error", last.Error()))
}
logger.Info("http request", fields...)
}
}
// currentUserID returns the authenticated user's id (set by requireAuth).
func currentUserID(c *gin.Context) int64 {
v, _ := c.Get(ctxUserID)
id, _ := v.(int64)
return id
}
// userLookup finds an account by id.
type userLookup interface {
User(ctx context.Context, id int64) (auth.User, error)
}
// requireAdmin runs after requireAuth. It reads the role from the database on
// every call, so a demoted or deleted admin loses access immediately instead
// of when the access token expires.
func requireAdmin(users userLookup) gin.HandlerFunc {
return func(c *gin.Context) {
user, err := users.User(c.Request.Context(), currentUserID(c))
switch {
case errors.Is(err, auth.ErrUserNotFound):
writeError(c, http.StatusUnauthorized, "unauthorized", "account no longer exists")
case err != nil:
_ = c.Error(err)
writeError(c, http.StatusInternalServerError, "internal", "internal error")
case !user.IsAdmin:
writeError(c, http.StatusForbidden, "admin_required", "this action needs an admin account")
default:
c.Next()
}
}
}
// requireAuth checks the access token, then that it was issued for the account
// that has this id now. User ids can be given again after an account is deleted
// (SQLite reuses the highest one), and a token lives for minutes: without this check
// the token of a deleted user would work as whoever gets the id next. The account
// must exist, have the same name, and not have been created after the token was signed.
//
// It reads "Authorization: Bearer <jwt>";
// when allowQuery is true and the header is absent it also accepts the
// access_token query parameter. That is for routes loaded by an <audio> element,
// which cannot send headers. A header that is present always wins, so a bad
// header is never rescued by a query token.
func requireAuth(tokens tokenParser, users userLookup, allowQuery bool) gin.HandlerFunc {
return func(c *gin.Context) {
token := ""
if header := c.GetHeader("Authorization"); header != "" {
// The scheme name is case-insensitive (RFC 7235). Any other scheme,
// or a bare token, is not accepted.
const scheme = "Bearer "
if len(header) < len(scheme) || !strings.EqualFold(header[:len(scheme)], scheme) {
writeError(c, http.StatusUnauthorized, "unauthorized", "missing bearer token")
return
}
token = header[len(scheme):]
} else if allowQuery {
token = c.Query("access_token")
}
if token == "" {
writeError(c, http.StatusUnauthorized, "unauthorized", "missing bearer token")
return
}
claims, err := tokens.Parse(token)
if err != nil {
writeError(c, http.StatusUnauthorized, "unauthorized", "invalid or expired token")
return
}
user, err := users.User(c.Request.Context(), claims.UserID)
switch {
case errors.Is(err, auth.ErrUserNotFound):
writeError(c, http.StatusUnauthorized, "unauthorized", "account no longer exists")
return
case err != nil:
_ = c.Error(err)
writeError(c, http.StatusInternalServerError, "internal", "internal error")
return
case user.Username != claims.Username || user.CreatedAt.Unix() > claims.IssuedAt.Unix():
writeError(c, http.StatusUnauthorized, "unauthorized", "invalid or expired token")
return
}
c.Set(ctxUserID, claims.UserID)
c.Set(ctxUsername, claims.Username)
c.Next()
}
}