package httpapi import ( "context" "errors" "net/http" "strings" "time" "github.com/gin-gonic/gin" "go.uber.org/zap" "git.kmalloc.org/squid/sonda/internal/auth" ) const ( ctxUserID = "user_id" ctxEmail = "email" ctxAccount = "account" // the auth.User that requireAuth already looked up ) // limitBody caps the request body size. The import of a Spotify export is the one request that may be far larger. func limitBody(max int64) gin.HandlerFunc { return func(c *gin.Context) { limit := max if c.FullPath() == spotifyImportPath { limit = importMaxBytes } c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, limit) 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 "; // when allowQuery is true and the header is absent it also accepts the // access_token query parameter. That is for routes loaded by an