- The README keeps the JWT secret in a file that is passed every time, so an upgrade does not make a new one and sign everybody out. - A health check that succeeds is logged at debug level, so a container does not write thousands of lines a day; any other answer, and every other request, still goes at info. - .dockerignore patterns match in every folder, as .gitignore does. - compose.yaml waits 15 seconds for Sonda to stop (it allows itself 10) and requires MUSIC_DIR instead of creating an empty folder. - The README says that the library path is the one inside the container, that the health check follows SONDA_LISTEN, and that a sonda.toml in /data works as a secrets file.
162 lines
5.5 KiB
Go
162 lines
5.5 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"
|
|
ctxAccount = "account" // the auth.User that requireAuth already looked up
|
|
)
|
|
|
|
// 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()))
|
|
}
|
|
if c.Request.URL.Path == healthPath && c.Writer.Status() == http.StatusOK {
|
|
logger.Debug("http request", fields...) // a health check asks all day: it is not news
|
|
return
|
|
}
|
|
logger.Info("http request", fields...)
|
|
}
|
|
}
|
|
|
|
// healthPath is what the health check of a container asks; see the Dockerfile.
|
|
const healthPath = "/api/v1/health"
|
|
|
|
// 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) {
|
|
// requireAuth just read the account in this same request: use it, do not
|
|
// read it twice.
|
|
account, known := accountOf(c)
|
|
var err error
|
|
if !known {
|
|
account, 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 !account.IsAdmin:
|
|
writeError(c, http.StatusForbidden, "admin_required", "this action needs an admin account")
|
|
default:
|
|
c.Next()
|
|
}
|
|
}
|
|
}
|
|
|
|
// accountOf returns the account that requireAuth looked up for this request.
|
|
func accountOf(c *gin.Context) (auth.User, bool) {
|
|
v, ok := c.Get(ctxAccount)
|
|
u, isUser := v.(auth.User)
|
|
return u, ok && isUser
|
|
}
|
|
|
|
// 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
|
|
// (both times are whole seconds from the server's clock; a clock stepped back can make
|
|
// a new account look newer than its token for the length of the step).
|
|
//
|
|
// 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.Request.Context().Err() != nil:
|
|
// The client left (a player seeking aborts its Range request): nobody
|
|
// is waiting and nothing went wrong here.
|
|
c.AbortWithStatus(statusClientClosed)
|
|
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(ctxAccount, user)
|
|
c.Set(ctxUsername, claims.Username)
|
|
c.Next()
|
|
}
|
|
}
|