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 <gtsteffaniak@users.noreply.github.com>
This commit is contained in:
Cursor AgentandGraham Steffaniak committed 2026-11-16 14:16:28 +00:00
1 parent 53e4e04787
commit bf55ccd86a
2 files changed
+142 -9

No files matched your search

+65 -8
View File
@@ -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()
+77 -1
View File
@@ -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()