internal/handlers/profile.go

@@ -4,63 +4,202 @@ 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) {
-		// Get username from URL
+		sessionUserID, sessionUsername, ok :=
-		requestedUsername := chi.URLParam(r, "username")
+			h.profileOwnerOrDeny(w, r)
-		if requestedUsername == "" {
-			http.NotFound(w, r)
-
-			return
-		}
-
-		// 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)
-		if err != nil {
-			h.log.Error("failed to get session", "error", err)
-			http.Error(w, "Internal server error", http.StatusInternalServerError)
-
-			return
-		}
-
-		// Get user info from session
-		sessionUsername, ok := h.session.GetUsername(sess)
 		if !ok {
-			h.log.Error("authenticated session missing username")
-			http.Error(w, "Internal server error", http.StatusInternalServerError)
-
 			return
 		}
 
-		sessionUserID, ok := h.session.GetUserID(sess)
+		h.renderProfile(w, r, sessionUserID, sessionUsername, "", "")
-		if !ok {
-			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)
 	}
 }
+
+// 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)
+			http.Error(w, "Bad request", http.StatusBadRequest)
+
+			return
+		}
+
+		successMessage, errorMessage, handled := h.applyPasswordChange(
+			w,
+			sessionUsername,
+			r.FormValue("current_password"),
+			r.FormValue("new_password"),
+			r.FormValue("confirm_password"),
+		)
+		if !handled {
+			return
+		}
+
+		h.renderProfile(
+			w, r, sessionUserID, sessionUsername,
+			successMessage, errorMessage,
+		)
+	}
+}
+
+// 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,12 +4,15 @@ 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"
@@ -157,3 +160,134 @@ 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,3 +32,7 @@ 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,6 +14,16 @@ 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
@@ -24,19 +34,53 @@ 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 {
-	limiter := httprate.Limit(
+	return m.postRateLimit(
 		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("login rate limit exceeded",
+				m.log.Warn(logMessage,
 					"path", r.URL.Path,
 				)
 				http.Error(
 					w,
-					"Too many login attempts. "+
+					responseMessage,
-						"Please try again later.",
 					http.StatusTooManyRequests,
 				)
 			},
@@ -50,8 +94,7 @@ func (m *Middleware) LoginRateLimit() func(http.Handler) http.Handler {
 			w http.ResponseWriter,
 			r *http.Request,
 		) {
-			// Only rate-limit POST requests (actual login
+			// Only rate-limit POST requests.
-			// attempts)
 			if r.Method != http.MethodPost {
 				next.ServeHTTP(w, r)
 

internal/middleware/ratelimit_test.go

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