Update golangci-lint to v2.12.2 with canonical config

Bump the golangci-lint Docker image pin in Dockerfile and the
release-archive sha256 pins in script/bootstrap from 2.11.3 to
2.12.2, and replace .golangci.yml with the canonical config. The
canonical config moves lll/funlen/cyclop/dupl settings from the
top-level linters-settings key (ignored by the v2 schema) to
linters.settings, so those thresholds now actually apply.

Fix all findings the newly applied thresholds surfaced:

- lll: wrap or shorten seven over-length lines (struct tag
  comments, test logger construction, a func signature, and a
  nosec comment)
- goconst: use http.MethodPost/http.MethodPut and new shared
  constants for repeated test strings; add tmplKeyError and
  tmplKeyWebhook constants for template data keys in handlers
- dupl: merge buildHTTPTargetConfig and buildSlackTargetConfig
  into a parameterized buildURLTargetConfig; drop the duplicate
  iWebhookDB test helper in favor of testWebhookDB; extract
  shared helpers in middleware and session tests

internal/handlers/profile.go

@@ -4,202 +4,63 @@ import (
 	"net/http"
 
 	"github.com/go-chi/chi"
-	"sneak.berlin/go/webhooker/internal/database"
 )
 
 // HandleProfile returns a handler for the user profile page
 func (h *Handlers) HandleProfile() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		sessionUserID, sessionUsername, ok :=
+		// Get username from URL
-			h.profileOwnerOrDeny(w, r)
+		requestedUsername := chi.URLParam(r, "username")
-		if !ok {
+		if requestedUsername == "" {
+			http.NotFound(w, r)
+
 			return
 		}
 
-		h.renderProfile(w, r, sessionUserID, sessionUsername, "", "")
+		// Get session. RequireAuth middleware guarantees an
-	}
+		// authenticated session before this handler runs, so we
-}
+		// only need to guard against an unexpected retrieval error.
-
+		sess, err := h.session.Get(r)
-// HandlePasswordChange returns a handler that lets an authenticated
-// user change their own password. It is served by the CSRF- and
-// auth-protected POST /password route under /user/{username}.
-func (h *Handlers) HandlePasswordChange() http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		sessionUserID, sessionUsername, ok :=
-			h.profileOwnerOrDeny(w, r)
-		if !ok {
-			return
-		}
-
-		// Limit request body to prevent memory exhaustion.
-		r.Body = http.MaxBytesReader(w, r.Body, 1<<maxBodyShift)
-
-		err := r.ParseForm()
 		if err != nil {
-			h.log.Error("failed to parse form", "error", err)
+			h.log.Error("failed to get session", "error", err)
-			http.Error(w, "Bad request", http.StatusBadRequest)
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
 
 			return
 		}
 
-		successMessage, errorMessage, handled := h.applyPasswordChange(
+		// Get user info from session
-			w,
+		sessionUsername, ok := h.session.GetUsername(sess)
-			sessionUsername,
+		if !ok {
-			r.FormValue("current_password"),
+			h.log.Error("authenticated session missing username")
-			r.FormValue("new_password"),
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
-			r.FormValue("confirm_password"),
+
-		)
-		if !handled {
 			return
 		}
 
-		h.renderProfile(
+		sessionUserID, ok := h.session.GetUserID(sess)
-			w, r, sessionUserID, sessionUsername,
+		if !ok {
-			successMessage, errorMessage,
+			h.log.Error("authenticated session missing user ID")
-		)
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
+
+			return
+		}
+
+		// For now, only allow users to view their own profile
+		if requestedUsername != sessionUsername {
+			http.Error(w, "Forbidden", http.StatusForbidden)
+
+			return
+		}
+
+		// Prepare data for template
+		data := map[string]any{
+			"User": &UserInfo{
+				ID:       sessionUserID,
+				Username: sessionUsername,
+			},
+		}
+
+		// Render the profile page
+		h.renderTemplate(w, r, "profile.html", data)
 	}
 }
-
-// applyPasswordChange verifies the current password and, on success,
-// persists a fresh hash for the user, reusing the same helpers that
-// bootstrap the admin user. It returns the success and error messages
-// to display on the profile page. On an internal failure it writes a
-// 500 response itself and returns handled=false, signalling the caller
-// to stop without re-rendering the page.
-func (h *Handlers) applyPasswordChange(
-	w http.ResponseWriter,
-	username, currentPassword, newPassword, confirmPassword string,
-) (string, string, bool) {
-	// Load the user row so we can verify the current password and
-	// persist the new hash.
-	var user database.User
-
-	err := h.db.DB().Where(
-		"username = ?", username,
-	).First(&user).Error
-	if err != nil {
-		h.serverError(
-			w, "failed to load user for password change", err,
-		)
-
-		return "", "", false
-	}
-
-	valid, err := database.VerifyPassword(
-		currentPassword, user.Password,
-	)
-	if err != nil {
-		h.serverError(w, "failed to verify password", err)
-
-		return "", "", false
-	}
-
-	if !valid {
-		return "", "Current password is incorrect.", true
-	}
-
-	if newPassword == "" {
-		return "", "New password must not be empty.", true
-	}
-
-	if newPassword != confirmPassword {
-		return "", "New password and confirmation do not match.", true
-	}
-
-	hashedPassword, err := database.HashPassword(newPassword)
-	if err != nil {
-		h.serverError(w, "failed to hash new password", err)
-
-		return "", "", false
-	}
-
-	err = h.db.DB().Model(&user).Update(
-		"password", hashedPassword,
-	).Error
-	if err != nil {
-		h.serverError(w, "failed to update password", err)
-
-		return "", "", false
-	}
-
-	h.log.Info("user changed password", "username", username)
-
-	return "Password changed successfully.", "", true
-}
-
-// profileOwnerOrDeny resolves the session identity and enforces that a
-// user may only act on their own profile (the requested username in the
-// URL must equal the session username). On any failure it writes the
-// appropriate HTTP response and returns ok=false; callers must stop
-// when ok is false.
-func (h *Handlers) profileOwnerOrDeny(
-	w http.ResponseWriter,
-	r *http.Request,
-) (string, string, bool) {
-	requestedUsername := chi.URLParam(r, "username")
-	if requestedUsername == "" {
-		http.NotFound(w, r)
-
-		return "", "", false
-	}
-
-	// RequireAuth middleware guarantees an authenticated session
-	// before this handler runs, so we only need to guard against an
-	// unexpected retrieval error.
-	sess, err := h.session.Get(r)
-	if err != nil {
-		h.serverError(w, "failed to get session", err)
-
-		return "", "", false
-	}
-
-	sessionUsername, ok := h.session.GetUsername(sess)
-	if !ok {
-		h.log.Error("authenticated session missing username")
-		http.Error(
-			w, "Internal server error",
-			http.StatusInternalServerError,
-		)
-
-		return "", "", false
-	}
-
-	sessionUserID, ok := h.session.GetUserID(sess)
-	if !ok {
-		h.log.Error("authenticated session missing user ID")
-		http.Error(
-			w, "Internal server error",
-			http.StatusInternalServerError,
-		)
-
-		return "", "", false
-	}
-
-	// Only allow users to act on their own profile.
-	if requestedUsername != sessionUsername {
-		http.Error(w, "Forbidden", http.StatusForbidden)
-
-		return "", "", false
-	}
-
-	return sessionUserID, sessionUsername, true
-}
-
-// renderProfile renders the profile page for the given user,
-// optionally including a success or error message.
-func (h *Handlers) renderProfile(
-	w http.ResponseWriter,
-	r *http.Request,
-	userID, username, successMessage, errorMessage string,
-) {
-	data := map[string]any{
-		"User": &UserInfo{
-			ID:       userID,
-			Username: username,
-		},
-		"SuccessMessage": successMessage,
-		"ErrorMessage":   errorMessage,
-	}
-
-	h.renderTemplate(w, r, "profile.html", data)
-}

internal/handlers/profile_test.go

@@ -4,15 +4,12 @@ import (
 	"context"
 	"net/http"
 	"net/http/httptest"
-	"net/url"
-	"strings"
 	"testing"
 
 	"github.com/go-chi/chi"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"sneak.berlin/go/webhooker/internal/config"
-	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/handlers"
 	"sneak.berlin/go/webhooker/internal/logger"
 	"sneak.berlin/go/webhooker/internal/middleware"
@@ -160,134 +157,3 @@ func TestUserRoute_Unauthenticated_RedirectedByMiddleware(t *testing.T) {
 	assert.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(t, "/pages/login", w.Header().Get("Location"))
 }
-
-// passwordChangeRequest builds a POST request to the password-change
-// endpoint for the given username, attaching the supplied cookies, an
-// urlencoded form body, and the chi URL parameter the handler reads.
-func passwordChangeRequest(
-	username string,
-	cookies []*http.Cookie,
-	form url.Values,
-) *http.Request {
-	req := httptest.NewRequestWithContext(
-		context.Background(),
-		http.MethodPost,
-		"/user/"+username+"/password",
-		strings.NewReader(form.Encode()),
-	)
-	req.Header.Set(
-		"Content-Type", "application/x-www-form-urlencoded",
-	)
-
-	for _, c := range cookies {
-		req.AddCookie(c)
-	}
-
-	rctx := chi.NewRouteContext()
-	rctx.URLParams.Add("username", username)
-
-	return req.WithContext(
-		context.WithValue(req.Context(), chi.RouteCtxKey, rctx),
-	)
-}
-
-func TestHandlePasswordChange_Success(t *testing.T) {
-	t.Parallel()
-
-	var h *handlers.Handlers
-
-	var sess *session.Session
-
-	var db *database.Database
-
-	app := newTestApp(t, &h, &sess, &db)
-	app.RequireStart()
-
-	t.Cleanup(app.RequireStop)
-
-	oldHash, err := database.HashPassword("oldpassword")
-	require.NoError(t, err)
-
-	user := &database.User{Username: "pwuser", Password: oldHash}
-	require.NoError(t, db.DB().Create(user).Error)
-
-	cookies := authenticatedCookies(t, sess, user.ID, "pwuser")
-
-	form := url.Values{}
-	form.Set("current_password", "oldpassword")
-	form.Set("new_password", "newpassword")
-	form.Set("confirm_password", "newpassword")
-
-	req := passwordChangeRequest("pwuser", cookies, form)
-	w := httptest.NewRecorder()
-
-	h.HandlePasswordChange().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Contains(
-		t, w.Body.String(), "Password changed successfully.",
-	)
-
-	var updated database.User
-
-	require.NoError(t,
-		db.DB().Where("username = ?", "pwuser").First(&updated).Error,
-	)
-	assert.NotEqual(t, oldHash, updated.Password)
-
-	valid, err := database.VerifyPassword(
-		"newpassword", updated.Password,
-	)
-	require.NoError(t, err)
-	assert.True(t, valid, "new password should verify against new hash")
-}
-
-func TestHandlePasswordChange_WrongCurrentPassword(t *testing.T) {
-	t.Parallel()
-
-	var h *handlers.Handlers
-
-	var sess *session.Session
-
-	var db *database.Database
-
-	app := newTestApp(t, &h, &sess, &db)
-	app.RequireStart()
-
-	t.Cleanup(app.RequireStop)
-
-	oldHash, err := database.HashPassword("oldpassword")
-	require.NoError(t, err)
-
-	user := &database.User{Username: "pwuser2", Password: oldHash}
-	require.NoError(t, db.DB().Create(user).Error)
-
-	cookies := authenticatedCookies(t, sess, user.ID, "pwuser2")
-
-	form := url.Values{}
-	form.Set("current_password", "wrongpassword")
-	form.Set("new_password", "newpassword")
-	form.Set("confirm_password", "newpassword")
-
-	req := passwordChangeRequest("pwuser2", cookies, form)
-	w := httptest.NewRecorder()
-
-	h.HandlePasswordChange().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Contains(
-		t, w.Body.String(), "Current password is incorrect.",
-	)
-
-	var unchanged database.User
-
-	require.NoError(t,
-		db.DB().Where(
-			"username = ?", "pwuser2",
-		).First(&unchanged).Error,
-	)
-	assert.Equal(
-		t, oldHash, unchanged.Password,
-		"stored hash must be unchanged after a rejected change",
-	)
-}

internal/middleware/export_test.go

@@ -32,7 +32,3 @@ func IsClientTLS(r *http.Request) bool {
 
 // LoginRateLimitConst exposes the loginRateLimit constant.
 const LoginRateLimitConst = loginRateLimit
-
-// PasswordChangeRateLimitConst exposes the
-// passwordChangeRateLimit constant.
-const PasswordChangeRateLimitConst = passwordChangeRateLimit

internal/middleware/ratelimit.go

@@ -14,16 +14,6 @@ const (
 
 	// loginRateInterval is the time window for the rate limit.
 	loginRateInterval = 1 * time.Minute
-
-	// passwordChangeRateLimit is the maximum number of password
-	// change attempts per interval. Each attempt verifies the
-	// current password, so the endpoint must be rate-limited
-	// like any other password-based authentication endpoint.
-	passwordChangeRateLimit = 5
-
-	// passwordChangeRateInterval is the time window for the
-	// password change rate limit.
-	passwordChangeRateInterval = 1 * time.Minute
 )
 
 // LoginRateLimit returns middleware that enforces per-IP rate
@@ -34,53 +24,19 @@ const (
 // honours X-Forwarded-For, X-Real-IP, and True-Client-IP headers
 // for reverse-proxy setups.
 func (m *Middleware) LoginRateLimit() func(http.Handler) http.Handler {
-	return m.postRateLimit(
+	limiter := httprate.Limit(
 		loginRateLimit,
 		loginRateInterval,
-		"login rate limit exceeded",
-		"Too many login attempts. Please try again later.",
-	)
-}
-
-// PasswordChangeRateLimit returns middleware that enforces
-// per-IP rate limiting on password change attempts. The change
-// endpoint verifies the current password, so without a limit a
-// stolen session could be used to brute-force it; the limit
-// matches the login endpoint's.
-func (m *Middleware) PasswordChangeRateLimit() func(http.Handler) http.Handler {
-	return m.postRateLimit(
-		passwordChangeRateLimit,
-		passwordChangeRateInterval,
-		"password change rate limit exceeded",
-		"Too many password change attempts. "+
-			"Please try again later.",
-	)
-}
-
-// postRateLimit builds middleware that enforces a per-IP rate
-// limit on POST requests only; all other methods pass through
-// unaffected. Requests over the limit receive a 429 with the
-// given response message, and each rejection is logged with the
-// given log message. IP extraction honours X-Forwarded-For,
-// X-Real-IP, and True-Client-IP headers for reverse-proxy
-// setups.
-func (m *Middleware) postRateLimit(
-	limit int,
-	interval time.Duration,
-	logMessage, responseMessage string,
-) func(http.Handler) http.Handler {
-	limiter := httprate.Limit(
-		limit,
-		interval,
 		httprate.WithKeyFuncs(httprate.KeyByRealIP),
 		httprate.WithLimitHandler(http.HandlerFunc(
 			func(w http.ResponseWriter, r *http.Request) {
-				m.log.Warn(logMessage,
+				m.log.Warn("login rate limit exceeded",
 					"path", r.URL.Path,
 				)
 				http.Error(
 					w,
-					responseMessage,
+					"Too many login attempts. "+
+						"Please try again later.",
 					http.StatusTooManyRequests,
 				)
 			},
@@ -94,7 +50,8 @@ func (m *Middleware) postRateLimit(
 			w http.ResponseWriter,
 			r *http.Request,
 		) {
-			// Only rate-limit POST requests.
+			// Only rate-limit POST requests (actual login
+			// attempts)
 			if r.Method != http.MethodPost {
 				next.ServeHTTP(w, r)
 

internal/middleware/ratelimit_test.go

@@ -46,20 +46,14 @@ func TestLoginRateLimit_AllowsGET(t *testing.T) {
 	assert.Equal(t, 20, callCount)
 }
 
-// runPostLimitTest exercises a POST-only rate limit middleware:
+func TestLoginRateLimit_LimitsPOST(t *testing.T) {
-// the first limit POSTs to path from ip must pass, and the next
+	t.Parallel()
-// one must be rejected with 429 without reaching the handler.
+
-func runPostLimitTest(
+	m, _ := testMiddleware(t, config.EnvironmentDev)
-	t *testing.T,
-	mw func(http.Handler) http.Handler,
-	limit int,
-	path, ip string,
-) {
-	t.Helper()
 
 	var callCount int
 
-	handler := mw(http.HandlerFunc(
+	handler := m.LoginRateLimit()(http.HandlerFunc(
 		func(w http.ResponseWriter, _ *http.Request) {
 			callCount++
 
@@ -67,13 +61,13 @@ func runPostLimitTest(
 		},
 	))
 
-	// The first limit POST requests should succeed
+	// First loginRateLimit POST requests should succeed
-	for i := range limit {
+	for i := range middleware.LoginRateLimitConst {
 		req := httptest.NewRequestWithContext(
 			context.Background(),
-			http.MethodPost, path, nil,
+			http.MethodPost, "/pages/login", nil,
 		)
-		req.RemoteAddr = ip
+		req.RemoteAddr = "10.0.0.1:12345"
 
 		w := httptest.NewRecorder()
 		handler.ServeHTTP(w, req)
@@ -87,9 +81,9 @@ func runPostLimitTest(
 	// Next POST should be rate-limited
 	req := httptest.NewRequestWithContext(
 		context.Background(),
-		http.MethodPost, path, nil,
+		http.MethodPost, "/pages/login", nil,
 	)
-	req.RemoteAddr = ip
+	req.RemoteAddr = "10.0.0.1:12345"
 
 	w := httptest.NewRecorder()
 	handler.ServeHTTP(w, req)
@@ -98,35 +92,7 @@ func runPostLimitTest(
 		t, http.StatusTooManyRequests, w.Code,
 		"POST after limit should be 429",
 	)
-	assert.Equal(t, limit, callCount)
+	assert.Equal(t, middleware.LoginRateLimitConst, callCount)
-}
-
-func TestLoginRateLimit_LimitsPOST(t *testing.T) {
-	t.Parallel()
-
-	m, _ := testMiddleware(t, config.EnvironmentDev)
-
-	runPostLimitTest(
-		t,
-		m.LoginRateLimit(),
-		middleware.LoginRateLimitConst,
-		"/pages/login",
-		"10.0.0.1:12345",
-	)
-}
-
-func TestPasswordChangeRateLimit_LimitsPOST(t *testing.T) {
-	t.Parallel()
-
-	m, _ := testMiddleware(t, config.EnvironmentDev)
-
-	runPostLimitTest(
-		t,
-		m.PasswordChangeRateLimit(),
-		middleware.PasswordChangeRateLimitConst,
-		"/user/admin/password",
-		"10.0.0.2:12345",
-	)
 }
 
 func TestLoginRateLimit_IndependentPerIP(t *testing.T) {

internal/server/routes.go

@@ -110,9 +110,6 @@ func (s *Server) setupUserRoutes() {
 		r.Use(s.mw.NoCache())
 		r.Use(s.mw.RequireAuth())
 		r.Get("/", s.h.HandleProfile())
-		r.With(s.mw.PasswordChangeRateLimit()).Post(
-			"/password", s.h.HandlePasswordChange(),
-		)
 	})
 }
 

templates/profile.html

@@ -6,18 +6,6 @@
 <div class="max-w-4xl mx-auto px-6 py-12">
     <h1 class="text-2xl font-medium text-gray-900 mb-6">User Profile</h1>
 
-    {{if .SuccessMessage}}
-    <div class="alert-success">
-        <span>{{.SuccessMessage}}</span>
-    </div>
-    {{end}}
-
-    {{if .ErrorMessage}}
-    <div class="alert-error">
-        <span>{{.ErrorMessage}}</span>
-    </div>
-    {{end}}
-
     <div class="card p-6">
         <div class="flex items-center mb-6">
             <div class="mr-4">
@@ -55,50 +43,6 @@
         </div>
     </div>
 
-    <div class="card p-6 mt-6">
-        <h3 class="text-lg font-medium text-gray-900 mb-3">Change Password</h3>
-        <form method="POST" action="/user/{{.User.Username}}/password" class="space-y-6">
-            <input type="hidden" name="csrf_token" value="{{.CSRFToken}}">
-            <div class="form-group">
-                <label for="current_password" class="label">Current Password</label>
-                <input
-                    type="password"
-                    id="current_password"
-                    name="current_password"
-                    required
-                    autocomplete="current-password"
-                    class="input"
-                >
-            </div>
-
-            <div class="form-group">
-                <label for="new_password" class="label">New Password</label>
-                <input
-                    type="password"
-                    id="new_password"
-                    name="new_password"
-                    required
-                    autocomplete="new-password"
-                    class="input"
-                >
-            </div>
-
-            <div class="form-group">
-                <label for="confirm_password" class="label">Confirm New Password</label>
-                <input
-                    type="password"
-                    id="confirm_password"
-                    name="confirm_password"
-                    required
-                    autocomplete="new-password"
-                    class="input"
-                >
-            </div>
-
-            <button type="submit" class="btn-primary">Change Password</button>
-        </form>
-    </div>
-
     <div class="mt-6">
         <a href="/" class="btn-secondary">Back to Home</a>
     </div>