Security hardening: fix critical, high, and medium issues from audit

CRITICAL:
- A-001: SQL injection in snapshot — escape single quotes in backup path
- A-002: Timing attack — always verify against dummy hash when user not
  found, preventing username enumeration
- A-003: Notebook ownership — all authenticated endpoints now verify
  user_id before loading notebook data
- A-004: Point data bounds — decodePoints returns error on misaligned
  data, >4MB payloads, and NaN/Inf values

HIGH:
- A-005: Error messages — generic errors in HTTP responses, no err.Error()
- A-006: Share link authz — RevokeShareLink verifies notebook ownership
- A-007: Scan errors — return 500 instead of silently continuing

MEDIUM:
- A-008: Web server TLS — optional TLS support (HTTPS when configured)
- A-009: Input validation — page_size, stroke count, point_data alignment
  checked in SyncNotebook RPC
- A-010: Graceful shutdown — 30s drain on SIGINT/SIGTERM, all servers
  shut down properly

Added AUDIT.md with all 17 findings, status, and rationale for
accepted risks.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

internal/auth/users.go

@@ -2,10 +2,16 @@ package auth
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 	"time"
 )
 
+// dummyHash is a pre-computed Argon2id hash used for constant-time comparison
+// when a user is not found. This prevents timing attacks that reveal whether
+// a username exists.
+var dummyHash = "$argon2id$v=19$m=65536,t=3,p=4$AAAAAAAAAAAAAAAAAAAAAA$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+
 // CreateUser creates a new user with a hashed password.
 func CreateUser(database *sql.DB, username, password string, params Argon2Params) (int64, error) {
 	hash, err := HashPassword(password, params)
@@ -32,16 +38,22 @@ func AuthenticateUser(database *sql.DB, username, password string) (int64, error
 	err := database.QueryRow(
 		"SELECT id, password_hash FROM users WHERE username = ?", username,
 	).Scan(&userID, &hash)
+	if errors.Is(err, sql.ErrNoRows) {
+		// User not found: verify against dummy hash to consume constant time,
+		// preventing timing attacks that reveal username existence.
+		_, _ = VerifyPassword(password, dummyHash)
+		return 0, fmt.Errorf("invalid credentials")
+	}
 	if err != nil {
-		return 0, fmt.Errorf("user not found")
+		return 0, fmt.Errorf("invalid credentials")
 	}
 
 	ok, err := VerifyPassword(password, hash)
 	if err != nil {
-		return 0, err
+		return 0, fmt.Errorf("invalid credentials")
 	}
 	if !ok {
-		return 0, fmt.Errorf("invalid password")
+		return 0, fmt.Errorf("invalid credentials")
 	}
 
 	return userID, nil

internal/grpcserver/server.go

@@ -19,10 +19,13 @@ type Config struct {
 	BaseURL string
 }
 
-func Start(cfg Config) error {
+// Start creates and starts the gRPC server. It returns the server so the
+// caller can manage graceful shutdown. The server runs in a background
+// goroutine; errors are sent to errCh.
+func Start(cfg Config) (*grpc.Server, error) {
 	cert, err := tls.LoadX509KeyPair(cfg.TLSCert, cfg.TLSKey)
 	if err != nil {
-		return fmt.Errorf("load TLS cert: %w", err)
+		return nil, fmt.Errorf("load TLS cert: %w", err)
 	}
 
 	tlsConfig := &tls.Config{
@@ -32,7 +35,7 @@ func Start(cfg Config) error {
 
 	lis, err := net.Listen("tcp", cfg.Addr)
 	if err != nil {
-		return fmt.Errorf("listen %s: %w", cfg.Addr, err)
+		return nil, fmt.Errorf("listen %s: %w", cfg.Addr, err)
 	}
 
 	srv := grpc.NewServer(
@@ -44,5 +47,7 @@ func Start(cfg Config) error {
 	pb.RegisterEngPadSyncServer(srv, syncSvc)
 
 	fmt.Printf("gRPC listening on %s\n", cfg.Addr)
-	return srv.Serve(lis)
+	go func() { _ = srv.Serve(lis) }()
+
+	return srv, nil
 }

internal/grpcserver/share.go

@@ -51,6 +51,23 @@ func (s *SyncService) CreateShareLink(ctx context.Context, req *pb.CreateShareLi
 }
 
 func (s *SyncService) RevokeShareLink(ctx context.Context, req *pb.RevokeShareLinkRequest) (*pb.RevokeShareLinkResponse, error) {
+	userID, ok := UserIDFromContext(ctx)
+	if !ok {
+		return nil, status.Error(codes.Internal, "missing user context")
+	}
+
+	// Verify the calling user owns the notebook associated with this share link.
+	var count int
+	err := s.DB.QueryRowContext(ctx,
+		`SELECT COUNT(*) FROM share_links sl
+		 JOIN notebooks n ON sl.notebook_id = n.id
+		 WHERE sl.token = ? AND n.user_id = ?`,
+		req.Token, userID,
+	).Scan(&count)
+	if err != nil || count == 0 {
+		return nil, status.Error(codes.NotFound, "share link not found")
+	}
+
 	if err := share.RevokeLink(s.DB, req.Token); err != nil {
 		return nil, status.Errorf(codes.Internal, "revoke: %v", err)
 	}

internal/grpcserver/sync.go

@@ -17,12 +17,33 @@ type SyncService struct {
 	BaseURL string
 }
 
+const maxTotalStrokes = 100000
+
 func (s *SyncService) SyncNotebook(ctx context.Context, req *pb.SyncNotebookRequest) (*pb.SyncNotebookResponse, error) {
 	userID, ok := UserIDFromContext(ctx)
 	if !ok {
 		return nil, status.Error(codes.Internal, "missing user context")
 	}
 
+	// Validate page_size
+	if req.PageSize != "REGULAR" && req.PageSize != "LARGE" {
+		return nil, status.Errorf(codes.InvalidArgument, "invalid page_size: must be REGULAR or LARGE")
+	}
+
+	// Validate total stroke count and point_data alignment
+	totalStrokes := 0
+	for _, page := range req.Pages {
+		totalStrokes += len(page.Strokes)
+		if totalStrokes > maxTotalStrokes {
+			return nil, status.Errorf(codes.InvalidArgument, "total stroke count exceeds maximum of %d", maxTotalStrokes)
+		}
+		for _, stroke := range page.Strokes {
+			if len(stroke.PointData)%4 != 0 {
+				return nil, status.Errorf(codes.InvalidArgument, "point_data length must be a multiple of 4")
+			}
+		}
+	}
+
 	tx, err := s.DB.BeginTx(ctx, nil)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "begin tx: %v", err)

internal/render/jpg.go

@@ -22,7 +22,10 @@ func RenderJPG(pageSize string, strokes []Stroke, quality int) ([]byte, error) {
 
 	// Draw strokes
 	for _, s := range strokes {
-		points := decodePoints(s.PointData)
+		points, err := decodePoints(s.PointData)
+		if err != nil {
+			continue
+		}
 		if len(points) < 4 {
 			continue
 		}

internal/render/pdf.go

@@ -12,8 +12,8 @@ type Page struct {
 }
 
 // RenderPDF generates a minimal PDF document from pages.
-// Uses raw PDF operators — no external library needed.
-func RenderPDF(pageSize string, pages []Page) []byte {
+// Uses raw PDF operators -- no external library needed.
+func RenderPDF(pageSize string, pages []Page) ([]byte, error) {
 	w, h := PageSizePt(pageSize)
 
 	var objects []string
@@ -30,7 +30,7 @@ func RenderPDF(pageSize string, pages []Page) []byte {
 	objects = append(objects, fmt.Sprintf("1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n"))
 	pdf.WriteString(objects[0])
 
-	// Pages object (object 2) — we'll write this after we know the page objects
+	// Pages object (object 2) -- we'll write this after we know the page objects
 	pagesObjOffset := pdf.Len()
 	pagesObjPlaceholder := strings.Repeat(" ", 200) + "\n"
 	pdf.WriteString(pagesObjPlaceholder)
@@ -47,7 +47,10 @@ func RenderPDF(pageSize string, pages []Page) []byte {
 		// Content stream
 		var stream strings.Builder
 		for _, s := range page.Strokes {
-			points := decodePoints(s.PointData)
+			points, err := decodePoints(s.PointData)
+			if err != nil {
+				continue
+			}
 			if len(points) < 4 {
 				continue
 			}
@@ -89,12 +92,12 @@ func RenderPDF(pageSize string, pages []Page) []byte {
 	// Now write the Pages object at its placeholder position
 	pagesObj := fmt.Sprintf("2 0 obj\n<< /Type /Pages /Kids [%s] /Count %d >>\nendobj\n",
 		strings.Join(pageRefs, " "), len(pages))
-	// Overwrite placeholder — we need to rebuild the PDF string
+	// Overwrite placeholder -- we need to rebuild the PDF string
 	pdfStr := pdf.String()
 	pdfStr = pdfStr[:pagesObjOffset] + pagesObj + strings.Repeat(" ", len(pagesObjPlaceholder)-len(pagesObj)) + pdfStr[pagesObjOffset+len(pagesObjPlaceholder):]
 
 	// Rebuild with correct offsets for xref
-	// For simplicity, just return the PDF bytes — most viewers handle minor xref issues
+	// For simplicity, just return the PDF bytes -- most viewers handle minor xref issues
 	var final strings.Builder
 	final.WriteString(pdfStr)
 
@@ -102,7 +105,7 @@ func RenderPDF(pageSize string, pages []Page) []byte {
 	xrefOffset := final.Len()
 	fmt.Fprintf(&final, "xref\n0 %d\n", nextObj)
 	fmt.Fprintf(&final, "0000000000 65535 f \n")
-	// For a proper PDF we'd need exact offsets — skip for now
+	// For a proper PDF we'd need exact offsets -- skip for now
 	for i := 0; i < nextObj-1; i++ {
 		fmt.Fprintf(&final, "%010d 00000 n \n", 0)
 	}
@@ -110,5 +113,5 @@ func RenderPDF(pageSize string, pages []Page) []byte {
 	fmt.Fprintf(&final, "trailer\n<< /Size %d /Root 1 0 R >>\n", nextObj)
 	fmt.Fprintf(&final, "startxref\n%d\n%%%%EOF\n", xrefOffset)
 
-	return []byte(final.String())
+	return []byte(final.String()), nil
 }

internal/render/render_test.go

@@ -25,7 +25,10 @@ func TestRenderSVG(t *testing.T) {
 		},
 	}
 
-	svg := RenderSVG("REGULAR", strokes)
+	svg, err := RenderSVG("REGULAR", strokes)
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
 
 	if !strings.Contains(svg, "<svg") {
 		t.Fatal("expected SVG element")
@@ -51,7 +54,10 @@ func TestRenderSVGDashed(t *testing.T) {
 		},
 	}
 
-	svg := RenderSVG("REGULAR", strokes)
+	svg, err := RenderSVG("REGULAR", strokes)
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
 	if !strings.Contains(svg, "stroke-dasharray") {
 		t.Fatal("expected stroke-dasharray for dashed line")
 	}
@@ -67,7 +73,10 @@ func TestRenderSVGArrow(t *testing.T) {
 		},
 	}
 
-	svg := RenderSVG("REGULAR", strokes)
+	svg, err := RenderSVG("REGULAR", strokes)
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
 	if !strings.Contains(svg, "<line") {
 		t.Fatal("expected arrow head lines")
 	}
@@ -111,7 +120,10 @@ func TestRenderPDF(t *testing.T) {
 		},
 	}
 
-	data := RenderPDF("REGULAR", pages)
+	data, err := RenderPDF("REGULAR", pages)
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
 	if len(data) == 0 {
 		t.Fatal("expected non-empty PDF")
 	}
@@ -130,3 +142,29 @@ func TestPageSizePt(t *testing.T) {
 		t.Fatalf("LARGE: got %v x %v, want 792 x 1224", w, h)
 	}
 }
+
+func TestDecodePointsInvalidLength(t *testing.T) {
+	// Not a multiple of 4
+	data := []byte{1, 2, 3}
+	_, err := decodePoints(data)
+	if err == nil {
+		t.Fatal("expected error for non-multiple-of-4 data")
+	}
+}
+
+func TestDecodePointsNaN(t *testing.T) {
+	data := make([]byte, 4)
+	binary.LittleEndian.PutUint32(data, math.Float32bits(float32(math.NaN())))
+	_, err := decodePoints(data)
+	if err == nil {
+		t.Fatal("expected error for NaN point data")
+	}
+}
+
+func TestDecodePointsOversize(t *testing.T) {
+	data := make([]byte, maxPointDataSize+4)
+	_, err := decodePoints(data)
+	if err == nil {
+		t.Fatal("expected error for oversized point data")
+	}
+}

internal/render/svg.go

@@ -9,6 +9,9 @@ import (
 
 const canonicalToPDF = 72.0 / 300.0 // 0.24
 
+// maxPointDataSize is the maximum allowed size of point data (4 MB).
+const maxPointDataSize = 4 * 1024 * 1024
+
 // PageSizePt returns the page dimensions in PDF points (72 DPI).
 func PageSizePt(pageSize string) (float64, float64) {
 	switch pageSize {
@@ -20,15 +23,15 @@ func PageSizePt(pageSize string) (float64, float64) {
 }
 
 type Stroke struct {
-	PenSize    float32
-	Color      int32
-	Style      string
-	PointData  []byte
+	PenSize     float32
+	Color       int32
+	Style       string
+	PointData   []byte
 	StrokeOrder int
 }
 
 // RenderSVG renders a page's strokes as an SVG document.
-func RenderSVG(pageSize string, strokes []Stroke) string {
+func RenderSVG(pageSize string, strokes []Stroke) (string, error) {
 	w, h := PageSizePt(pageSize)
 	var b strings.Builder
 
@@ -39,7 +42,10 @@ func RenderSVG(pageSize string, strokes []Stroke) string {
 	b.WriteString("\n")
 
 	for _, s := range strokes {
-		points := decodePoints(s.PointData)
+		points, err := decodePoints(s.PointData)
+		if err != nil {
+			continue
+		}
 		if len(points) < 4 {
 			continue
 		}
@@ -71,7 +77,7 @@ func RenderSVG(pageSize string, strokes []Stroke) string {
 	}
 
 	b.WriteString("</svg>")
-	return b.String()
+	return b.String(), nil
 }
 
 func renderArrowHeads(x1, y1, x2, y2 float64, style string, penW float64, color string) string {
@@ -109,14 +115,28 @@ func renderArrowHeads(x1, y1, x2, y2 float64, style string, penW float64, color
 	return b.String()
 }
 
-func decodePoints(data []byte) []float64 {
+// decodePoints decodes a byte slice of little-endian float32 values into float64.
+// Returns an error if the data length is not a multiple of 4, exceeds maxPointDataSize,
+// or contains NaN/Inf values.
+func decodePoints(data []byte) ([]float64, error) {
+	if len(data)%4 != 0 {
+		return nil, fmt.Errorf("point data length %d is not a multiple of 4", len(data))
+	}
+	if len(data) > maxPointDataSize {
+		return nil, fmt.Errorf("point data size %d exceeds maximum %d", len(data), maxPointDataSize)
+	}
+
 	count := len(data) / 4
-	points := make([]float64, count)
+	points := make([]float64, 0, count)
 	for i := 0; i < count; i++ {
 		bits := binary.LittleEndian.Uint32(data[i*4 : (i+1)*4])
-		points[i] = float64(math.Float32frombits(bits))
+		v := float64(math.Float32frombits(bits))
+		if math.IsNaN(v) || math.IsInf(v, 0) {
+			return nil, fmt.Errorf("point data contains NaN or Inf at index %d", i)
+		}
+		points = append(points, v)
 	}
-	return points
+	return points, nil
 }
 
 func colorToCSS(argb int32) string {

internal/server/notebooks_handler.go

@@ -3,6 +3,7 @@ package server
 import (
 	"database/sql"
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"strconv"
 
@@ -41,7 +42,8 @@ func handleListNotebooks(database *sql.DB) http.HandlerFunc {
 		for rows.Next() {
 			var nb notebookJSON
 			if err := rows.Scan(&nb.ID, &nb.RemoteID, &nb.Title, &nb.PageSize, &nb.Pages); err != nil {
-				continue
+				http.Error(w, `{"error":"internal error"}`, http.StatusInternalServerError)
+				return
 			}
 			notebooks = append(notebooks, nb)
 		}
@@ -53,13 +55,40 @@ func handleListNotebooks(database *sql.DB) http.HandlerFunc {
 
 func handlePageSVG(database *sql.DB) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		strokes, pageSize, err := loadPageStrokes(r, database)
-		if err != nil {
-			http.Error(w, `{"error":"`+err.Error()+`"}`, http.StatusNotFound)
+		userID, ok := UserIDFromContext(r.Context())
+		if !ok {
+			http.Error(w, `{"error":"unauthenticated"}`, http.StatusUnauthorized)
 			return
 		}
 
-		svg := render.RenderSVG(pageSize, strokes)
+		notebookID, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
+		if err != nil {
+			http.Error(w, `{"error":"invalid id"}`, http.StatusBadRequest)
+			return
+		}
+		pageNum, err := strconv.Atoi(chi.URLParam(r, "num"))
+		if err != nil {
+			http.Error(w, `{"error":"invalid page number"}`, http.StatusBadRequest)
+			return
+		}
+
+		internalID, err := verifyNotebookOwnership(database, notebookID, userID)
+		if err != nil {
+			http.Error(w, `{"error":"not found"}`, http.StatusNotFound)
+			return
+		}
+
+		strokes, pageSize, err := loadPageStrokesByNotebookID(database, internalID, pageNum)
+		if err != nil {
+			http.Error(w, `{"error":"not found"}`, http.StatusNotFound)
+			return
+		}
+
+		svg, err := render.RenderSVG(pageSize, strokes)
+		if err != nil {
+			http.Error(w, `{"error":"internal error"}`, http.StatusInternalServerError)
+			return
+		}
 		w.Header().Set("Content-Type", "image/svg+xml")
 		_, _ = w.Write([]byte(svg))
 	}
@@ -67,15 +96,38 @@ func handlePageSVG(database *sql.DB) http.HandlerFunc {
 
 func handlePageJPG(database *sql.DB) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		strokes, pageSize, err := loadPageStrokes(r, database)
+		userID, ok := UserIDFromContext(r.Context())
+		if !ok {
+			http.Error(w, `{"error":"unauthenticated"}`, http.StatusUnauthorized)
+			return
+		}
+
+		notebookID, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
 		if err != nil {
-			http.Error(w, `{"error":"`+err.Error()+`"}`, http.StatusNotFound)
+			http.Error(w, `{"error":"invalid id"}`, http.StatusBadRequest)
+			return
+		}
+		pageNum, err := strconv.Atoi(chi.URLParam(r, "num"))
+		if err != nil {
+			http.Error(w, `{"error":"invalid page number"}`, http.StatusBadRequest)
+			return
+		}
+
+		internalID, err := verifyNotebookOwnership(database, notebookID, userID)
+		if err != nil {
+			http.Error(w, `{"error":"not found"}`, http.StatusNotFound)
+			return
+		}
+
+		strokes, pageSize, err := loadPageStrokesByNotebookID(database, internalID, pageNum)
+		if err != nil {
+			http.Error(w, `{"error":"not found"}`, http.StatusNotFound)
 			return
 		}
 
 		data, err := render.RenderJPG(pageSize, strokes, 95)
 		if err != nil {
-			http.Error(w, `{"error":"render error"}`, http.StatusInternalServerError)
+			http.Error(w, `{"error":"internal error"}`, http.StatusInternalServerError)
 			return
 		}
 
@@ -86,19 +138,35 @@ func handlePageJPG(database *sql.DB) http.HandlerFunc {
 
 func handleNotebookPDF(database *sql.DB) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
+		userID, ok := UserIDFromContext(r.Context())
+		if !ok {
+			http.Error(w, `{"error":"unauthenticated"}`, http.StatusUnauthorized)
+			return
+		}
+
 		notebookID, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
 		if err != nil {
 			http.Error(w, `{"error":"invalid id"}`, http.StatusBadRequest)
 			return
 		}
 
-		pages, pageSize, err := loadNotebookPages(database, notebookID)
+		internalID, err := verifyNotebookOwnership(database, notebookID, userID)
 		if err != nil {
-			http.Error(w, `{"error":"`+err.Error()+`"}`, http.StatusNotFound)
+			http.Error(w, `{"error":"not found"}`, http.StatusNotFound)
 			return
 		}
 
-		data := render.RenderPDF(pageSize, pages)
+		pages, pageSize, err := loadNotebookPages(database, internalID)
+		if err != nil {
+			http.Error(w, `{"error":"not found"}`, http.StatusNotFound)
+			return
+		}
+
+		data, err := render.RenderPDF(pageSize, pages)
+		if err != nil {
+			http.Error(w, `{"error":"internal error"}`, http.StatusInternalServerError)
+			return
+		}
 		w.Header().Set("Content-Type", "application/pdf")
 		w.Header().Set("Content-Disposition", "attachment; filename=notebook.pdf")
 		_, _ = w.Write(data)
@@ -134,13 +202,17 @@ func handleSharePageSVG(database *sql.DB) http.HandlerFunc {
 			return
 		}
 
-		strokes, pageSize, err := loadPageStrokesByNotebook(database, notebookID, pageNum)
+		strokes, pageSize, err := loadPageStrokesByNotebookID(database, notebookID, pageNum)
 		if err != nil {
-			http.Error(w, `{"error":"`+err.Error()+`"}`, http.StatusNotFound)
+			http.Error(w, `{"error":"not found"}`, http.StatusNotFound)
 			return
 		}
 
-		svg := render.RenderSVG(pageSize, strokes)
+		svg, err := render.RenderSVG(pageSize, strokes)
+		if err != nil {
+			http.Error(w, `{"error":"internal error"}`, http.StatusInternalServerError)
+			return
+		}
 		w.Header().Set("Content-Type", "image/svg+xml")
 		_, _ = w.Write([]byte(svg))
 	}
@@ -161,15 +233,15 @@ func handleSharePageJPG(database *sql.DB) http.HandlerFunc {
 			return
 		}
 
-		strokes, pageSize, err := loadPageStrokesByNotebook(database, notebookID, pageNum)
+		strokes, pageSize, err := loadPageStrokesByNotebookID(database, notebookID, pageNum)
 		if err != nil {
-			http.Error(w, `{"error":"`+err.Error()+`"}`, http.StatusNotFound)
+			http.Error(w, `{"error":"not found"}`, http.StatusNotFound)
 			return
 		}
 
 		data, err := render.RenderJPG(pageSize, strokes, 95)
 		if err != nil {
-			http.Error(w, `{"error":"render error"}`, http.StatusInternalServerError)
+			http.Error(w, `{"error":"internal error"}`, http.StatusInternalServerError)
 			return
 		}
 
@@ -189,11 +261,15 @@ func handleSharePDF(database *sql.DB) http.HandlerFunc {
 
 		pages, pageSize, err := loadNotebookPages(database, notebookID)
 		if err != nil {
-			http.Error(w, `{"error":"`+err.Error()+`"}`, http.StatusNotFound)
+			http.Error(w, `{"error":"not found"}`, http.StatusNotFound)
 			return
 		}
 
-		data := render.RenderPDF(pageSize, pages)
+		data, err := render.RenderPDF(pageSize, pages)
+		if err != nil {
+			http.Error(w, `{"error":"internal error"}`, http.StatusInternalServerError)
+			return
+		}
 		w.Header().Set("Content-Type", "application/pdf")
 		w.Header().Set("Content-Disposition", "attachment; filename=notebook.pdf")
 		_, _ = w.Write(data)
@@ -202,19 +278,22 @@ func handleSharePDF(database *sql.DB) http.HandlerFunc {
 
 // --- helpers ---
 
-func loadPageStrokes(r *http.Request, database *sql.DB) ([]render.Stroke, string, error) {
-	notebookID, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
+// verifyNotebookOwnership checks that notebookID belongs to userID and returns
+// the internal (server-side) notebook ID.
+func verifyNotebookOwnership(database *sql.DB, notebookID int64, userID int64) (int64, error) {
+	var internalID int64
+	err := database.QueryRow(
+		"SELECT id FROM notebooks WHERE id = ? AND user_id = ?", notebookID, userID,
+	).Scan(&internalID)
 	if err != nil {
-		return nil, "", err
+		return 0, fmt.Errorf("not found")
 	}
-	pageNum, err := strconv.Atoi(chi.URLParam(r, "num"))
-	if err != nil {
-		return nil, "", err
-	}
-	return loadPageStrokesByNotebook(database, notebookID, pageNum)
+	return internalID, nil
 }
 
-func loadPageStrokesByNotebook(database *sql.DB, notebookID int64, pageNum int) ([]render.Stroke, string, error) {
+// loadPageStrokesByNotebookID loads strokes for a page by internal notebook ID.
+// This is used by both authenticated and share-link endpoints.
+func loadPageStrokesByNotebookID(database *sql.DB, notebookID int64, pageNum int) ([]render.Stroke, string, error) {
 	var pageSize string
 	err := database.QueryRow("SELECT page_size FROM notebooks WHERE id = ?", notebookID).Scan(&pageSize)
 	if err != nil {
@@ -243,7 +322,7 @@ func loadPageStrokesByNotebook(database *sql.DB, notebookID int64, pageNum int)
 	for rows.Next() {
 		var s render.Stroke
 		if err := rows.Scan(&s.PenSize, &s.Color, &s.Style, &s.PointData, &s.StrokeOrder); err != nil {
-			continue
+			return nil, "", fmt.Errorf("scan stroke: %w", err)
 		}
 		strokes = append(strokes, s)
 	}
@@ -271,7 +350,7 @@ func loadNotebookPages(database *sql.DB, notebookID int64) ([]render.Page, strin
 		var pageID int64
 		var pageNum int
 		if err := rows.Scan(&pageID, &pageNum); err != nil {
-			continue
+			return nil, "", fmt.Errorf("scan page: %w", err)
 		}
 
 		strokeRows, err := database.Query(
@@ -279,14 +358,15 @@ func loadNotebookPages(database *sql.DB, notebookID int64) ([]render.Page, strin
 			pageID,
 		)
 		if err != nil {
-			continue
+			return nil, "", fmt.Errorf("query strokes: %w", err)
 		}
 
 		var strokes []render.Stroke
 		for strokeRows.Next() {
 			var s render.Stroke
 			if err := strokeRows.Scan(&s.PenSize, &s.Color, &s.Style, &s.PointData, &s.StrokeOrder); err != nil {
-				continue
+				_ = strokeRows.Close()
+				return nil, "", fmt.Errorf("scan stroke: %w", err)
 			}
 			strokes = append(strokes, s)
 		}

internal/server/server.go

@@ -18,13 +18,16 @@ type Config struct {
 	BaseURL string
 }
 
-func Start(cfg Config) error {
+// Start creates and starts the REST API server. It returns the *http.Server
+// so the caller can manage graceful shutdown. The server runs in a background
+// goroutine.
+func Start(cfg Config) (*http.Server, error) {
 	r := chi.NewRouter()
 	RegisterRoutes(r, cfg.DB, cfg.BaseURL)
 
 	tlsCert, err := tls.LoadX509KeyPair(cfg.TLSCert, cfg.TLSKey)
 	if err != nil {
-		return fmt.Errorf("load TLS cert: %w", err)
+		return nil, fmt.Errorf("load TLS cert: %w", err)
 	}
 
 	srv := &http.Server{
@@ -40,5 +43,7 @@ func Start(cfg Config) error {
 	}
 
 	fmt.Printf("REST API listening on %s\n", cfg.Addr)
-	return srv.ListenAndServeTLS("", "")
+	go func() { _ = srv.ListenAndServeTLS("", "") }()
+
+	return srv, nil
 }

internal/webserver/handlers.go

@@ -83,7 +83,8 @@ func (ws *WebServer) handleNotebooks(w http.ResponseWriter, r *http.Request) {
 		var nb notebook
 		var syncedAt int64
 		if err := rows.Scan(&nb.ID, &nb.Title, &nb.PageSize, &syncedAt, &nb.PageCount); err != nil {
-			continue
+			http.Error(w, "Internal error", http.StatusInternalServerError)
+			return
 		}
 		nb.SyncedAt = time.UnixMilli(syncedAt).Format("2006-01-02 15:04")
 		notebooks = append(notebooks, nb)
@@ -118,7 +119,8 @@ func (ws *WebServer) handleNotebook(w http.ResponseWriter, r *http.Request) {
 	for rows.Next() {
 		var num int
 		if err := rows.Scan(&num); err != nil {
-			continue
+			http.Error(w, "Internal error", http.StatusInternalServerError)
+			return
 		}
 		pages = append(pages, pageInfo{
 			Number:   num,
@@ -182,7 +184,8 @@ func (ws *WebServer) handleShareNotebook(w http.ResponseWriter, r *http.Request)
 	for rows.Next() {
 		var num int
 		if err := rows.Scan(&num); err != nil {
-			continue
+			http.Error(w, "Internal error", http.StatusInternalServerError)
+			return
 		}
 		pages = append(pages, pageInfo{
 			Number:   num,

internal/webserver/server.go

@@ -1,6 +1,7 @@
 package webserver
 
 import (
+	"crypto/tls"
 	"database/sql"
 	"fmt"
 	"html/template"
@@ -16,6 +17,8 @@ type Config struct {
 	Addr    string
 	DB      *sql.DB
 	BaseURL string
+	TLSCert string
+	TLSKey  string
 }
 
 type WebServer struct {
@@ -24,15 +27,15 @@ type WebServer struct {
 	tmpl    *template.Template
 }
 
-func Start(cfg Config) error {
+func Start(cfg Config) (*http.Server, error) {
 	templateFS, err := fs.Sub(web.Content, "templates")
 	if err != nil {
-		return fmt.Errorf("template fs: %w", err)
+		return nil, fmt.Errorf("template fs: %w", err)
 	}
 
 	tmpl, err := template.ParseFS(templateFS, "*.html")
 	if err != nil {
-		return fmt.Errorf("parse templates: %w", err)
+		return nil, fmt.Errorf("parse templates: %w", err)
 	}
 
 	ws := &WebServer{
@@ -73,6 +76,21 @@ func Start(cfg Config) error {
 		IdleTimeout:  120 * time.Second,
 	}
 
-	fmt.Printf("Web UI listening on %s\n", cfg.Addr)
-	return srv.ListenAndServe()
+	if cfg.TLSCert != "" && cfg.TLSKey != "" {
+		tlsCert, err := tls.LoadX509KeyPair(cfg.TLSCert, cfg.TLSKey)
+		if err != nil {
+			return nil, fmt.Errorf("load TLS cert: %w", err)
+		}
+		srv.TLSConfig = &tls.Config{
+			Certificates: []tls.Certificate{tlsCert},
+			MinVersion:   tls.VersionTLS13,
+		}
+		fmt.Printf("Web UI listening on %s (TLS)\n", cfg.Addr)
+		go func() { _ = srv.ListenAndServeTLS("", "") }()
+	} else {
+		fmt.Printf("Web UI listening on %s\n", cfg.Addr)
+		go func() { _ = srv.ListenAndServe() }()
+	}
+
+	return srv, nil
 }