From bf55ccd86af20187862dca53697c177440c0a67f Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Mon, 16 Nov 2026 14:16:28 +0000 Subject: [PATCH] fix(archive): cap symlink expansions and resolve absolute hop targets Share a 255-expansion budget across resolveSymlinkTargetAt recursion, resolve absolute Readlink targets via resolveSymlinkTargetAbsolute, stop trimming Readlink text, and add regression tests (expansion bomb, absolute hop, trailing space). Co-authored-by: Graham Steffaniak --- backend/internal/web/archive.go | 73 +++++++++++++++++++++++--- backend/internal/web/archive_test.go | 78 +++++++++++++++++++++++++++- 2 files changed, 142 insertions(+), 9 deletions(-) diff --git a/backend/internal/web/archive.go b/backend/internal/web/archive.go index ed20b37b2..0103f67bf 100644 --- a/backend/internal/web/archive.go +++ b/backend/internal/web/archive.go @@ -1163,8 +1163,11 @@ func applyArchivedTimesAndPerm(path string, mode fs.FileMode, modTime time.Time) } } -// maxSymlinkResolveDepth bounds symlink target resolution during archive extraction (GHSA-jg32 / #3384). -const maxSymlinkResolveDepth = 40 +// Bounds symlink target resolution during archive extraction (GHSA-jg32 / #3384). +const ( + maxSymlinkResolveDepth = 40 + maxSymlinkResolveExpansions = 255 +) // symlinkTargetStaysUnderDest rejects absolute targets and symlink text that would resolve // outside destRoot after following symlinks already created under the destination tree. @@ -1189,7 +1192,8 @@ func symlinkTargetStaysUnderDest(destRoot, destPath, linkname string) error { if err != nil { return fmt.Errorf("symlink target escapes destination directory") } - resolved, err := resolveSymlinkTargetAt(linkDir, linkname, 0) + expansionsLeft := maxSymlinkResolveExpansions + resolved, err := resolveSymlinkTargetAt(linkDir, linkname, 0, &expansionsLeft) if err != nil { return err } @@ -1224,11 +1228,30 @@ func resolvedSymlinkParentDir(destPath string) (string, error) { return filepath.Dir(linkPath), nil } +func errSymlinkTargetEscape() error { + return fmt.Errorf("symlink target escapes destination directory") +} + +func consumeSymlinkExpansion(expansionsLeft *int) error { + if expansionsLeft == nil { + return nil + } + if *expansionsLeft <= 0 { + return errSymlinkTargetEscape() + } + *expansionsLeft-- + return nil +} + // resolveSymlinkTargetAt walks linkname relative to linkDir, following existing symlinks at // each component without collapsing ".." lexically first (closes chained-link extraction bypass). -func resolveSymlinkTargetAt(linkDir, linkname string, depth int) (string, error) { +// expansionsLeft is decremented on every symlink expansion and shared across recursion. +func resolveSymlinkTargetAt(linkDir, linkname string, depth int, expansionsLeft *int) (string, error) { if depth > maxSymlinkResolveDepth { - return "", fmt.Errorf("symlink target escapes destination directory") + return "", errSymlinkTargetEscape() + } + if filepath.IsAbs(linkname) { + return resolveSymlinkTargetAbsolute(linkname, depth, expansionsLeft) } linkDir = filepath.Clean(linkDir) cur := linkDir @@ -1250,15 +1273,19 @@ func resolveSymlinkTargetAt(linkDir, linkname string, depth int) (string, error) return "", err } if info.Mode()&os.ModeSymlink != 0 { + if err := consumeSymlinkExpansion(expansionsLeft); err != nil { + return "", err + } target, err := os.Readlink(next) if err != nil { return "", err } - target = strings.TrimSpace(target) + var nested string if filepath.IsAbs(target) { - return "", fmt.Errorf("symlink has absolute target") + nested, err = resolveSymlinkTargetAbsolute(target, depth+1, expansionsLeft) + } else { + nested, err = resolveSymlinkTargetAt(filepath.Dir(next), target, depth+1, expansionsLeft) } - nested, err := resolveSymlinkTargetAt(filepath.Dir(next), target, depth+1) if err != nil { return "", err } @@ -1271,6 +1298,36 @@ func resolveSymlinkTargetAt(linkDir, linkname string, depth int) (string, error) return filepath.Clean(cur), nil } +// resolveSymlinkTargetAbsolute continues resolution from an absolute path without treating +// leading slash-separated components as relative to linkDir. +func resolveSymlinkTargetAbsolute(path string, depth int, expansionsLeft *int) (string, error) { + if depth > maxSymlinkResolveDepth { + return "", errSymlinkTargetEscape() + } + path = filepath.Clean(path) + info, err := os.Lstat(path) + if err != nil { + if os.IsNotExist(err) { + return path, nil + } + return "", err + } + if info.Mode()&os.ModeSymlink == 0 { + return path, nil + } + if cerr := consumeSymlinkExpansion(expansionsLeft); cerr != nil { + return "", cerr + } + target, err := os.Readlink(path) + if err != nil { + return "", err + } + if filepath.IsAbs(target) { + return resolveSymlinkTargetAbsolute(target, depth+1, expansionsLeft) + } + return resolveSymlinkTargetAt(filepath.Dir(path), target, depth+1, expansionsLeft) +} + // extractArchivedDir creates a directory from an archive entry and reapplies mode and mtime. func extractArchivedDir(destPath string, mode fs.FileMode, modTime time.Time) error { perm := mode.Perm() diff --git a/backend/internal/web/archive_test.go b/backend/internal/web/archive_test.go index 5a3cbd19b..f191e135b 100644 --- a/backend/internal/web/archive_test.go +++ b/backend/internal/web/archive_test.go @@ -4,11 +4,13 @@ import ( "archive/tar" "archive/zip" "errors" + "fmt" "io" "os" "path/filepath" "strings" "testing" + "time" commonerrors "github.com/gtsteffaniak/filebrowser/backend/internal/errors" "github.com/gtsteffaniak/filebrowser/backend/pkg/indexing" @@ -621,7 +623,8 @@ func assertNoEscapingSymlinksUnderDest(t *testing.T, destDir string) { if err != nil { return err } - resolved, err := resolveSymlinkTargetAt(linkDir, target, 0) + expansionsLeft := maxSymlinkResolveExpansions + resolved, err := resolveSymlinkTargetAt(linkDir, target, 0, &expansionsLeft) if err != nil { return nil } @@ -708,6 +711,79 @@ func TestExtractZip_rejectsChainedSymlinkEscape_preExistingHop(t *testing.T) { assertNoEscapingSymlinksUnderDest(t, destDir) } +func TestResolveSymlinkTargetAt_rejectsSymlinkExpansionBomb(t *testing.T) { + dest := t.TempDir() + if err := os.Symlink(".", filepath.Join(dest, "l0")); err != nil { + t.Fatal(err) + } + prev := "l0" + for i := 1; i <= 25; i++ { + name := fmt.Sprintf("l%d", i) + target := prev + "/" + prev + if err := os.Symlink(target, filepath.Join(dest, name)); err != nil { + t.Fatal(err) + } + prev = name + } + expansionsLeft := maxSymlinkResolveExpansions + start := time.Now() + _, err := resolveSymlinkTargetAt(dest, "l25/l25", 0, &expansionsLeft) + elapsed := time.Since(start) + if err == nil || !strings.Contains(err.Error(), "escapes destination") { + t.Fatalf("expected rejection, got %v after %v", err, elapsed) + } + if elapsed > 2*time.Second { + t.Fatalf("symlink expansion bomb took too long: %v", elapsed) + } +} + +func TestSymlinkTargetStaysUnderDest_rejectsAbsolutePreExistingHop(t *testing.T) { + destDir := t.TempDir() + outside := filepath.Join(filepath.Dir(destDir), "outside-abs-hop") + if err := os.MkdirAll(outside, 0o755); err != nil { + t.Fatal(err) + } + if err := os.Symlink(outside, filepath.Join(destDir, "bad")); err != nil { + t.Fatal(err) + } + newLink := filepath.Join(destDir, "newlink") + if err := symlinkTargetStaysUnderDest(destDir, newLink, "bad"); err == nil { + t.Fatal("expected absolute pre-existing hop outside dest to be rejected") + } +} + +func TestSymlinkTargetStaysUnderDest_hopTargetVerbatimReadlink(t *testing.T) { + destDir := t.TempDir() + allowed := filepath.Join(destDir, "allowed.txt") + if err := os.WriteFile(allowed, []byte("ok"), 0o644); err != nil { + t.Fatal(err) + } + hop := filepath.Join(destDir, "hop") + // Trailing space must be preserved (no TrimSpace on Readlink); the literal name is not allowed.txt. + if err := os.Symlink("allowed.txt ", hop); err != nil { + t.Fatal(err) + } + got, err := os.Readlink(hop) + if err != nil || got != "allowed.txt " { + t.Fatalf("readlink verbatim target: %q err=%v", got, err) + } + expansionsLeft := maxSymlinkResolveExpansions + resolved, err := resolveSymlinkTargetAt(destDir, "hop", 0, &expansionsLeft) + if err != nil { + t.Fatalf("resolve hop: %v", err) + } + want := filepath.Join(destDir, "allowed.txt ") + if resolved != want { + t.Fatalf("hop should resolve to literal spaced name %q, got %q", want, resolved) + } + if _, statErr := os.Stat(resolved); !os.IsNotExist(statErr) { + t.Fatalf("spaced target should not alias allowed.txt without trimming: stat %v", statErr) + } + if _, statErr := os.Stat(allowed); statErr != nil { + t.Fatalf("allowed.txt should exist: %v", statErr) + } +} + func TestArchiveCreateDestination_RejectsEscapingSymlinkLeaf(t *testing.T) { t.Parallel() root := t.TempDir()