Compare commits

..
Author SHA1 Message Date
Cursor AgentandGraham Steffaniak a3f2b90fc5 fix(archive): walk absolute symlink targets from volume root
resolveSymlinkTargetAbsolute delegates to resolveSymlinkTargetAt from the
volume root without cleaning away .. first, so ancestor symlinks and
trailing path segments are resolved before containment checks.

Co-authored-by: Graham Steffaniak <gtsteffaniak@users.noreply.github.com>
2026-11-16 15:32:08 +00:00
Cursor AgentandGraham Steffaniak bf55ccd86a 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>
2026-11-16 14:16:28 +00:00
Cursor AgentandGraham Steffaniak 53e4e04787 fix(archive): resolve symlink targets before containment check (GHSA-jg32)
Archive extraction validated symlink linknames only lexically, so chained
relative links could be created inside the destination yet resolve outside
it at runtime (#3384). Reject targets with .. segments and walk targets
through existing destination symlinks before allowing creation.

Co-authored-by: Graham Steffaniak <gtsteffaniak@users.noreply.github.com>
2026-11-16 13:41:00 +00:00
2 changed files with 445 additions and 5 deletions

No files matched your search

+132 -5
View File
@@ -1163,30 +1163,157 @@ func applyArchivedTimesAndPerm(path string, mode fs.FileMode, modTime time.Time)
}
}
// symlinkTargetStaysUnderDest rejects absolute targets and paths that would resolve outside destRoot.
// 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.
// Lexical filepath.Clean alone is insufficient: a chained link can pass a prefix check yet
// resolve outside dest when an intermediate path component is a symlink.
func symlinkTargetStaysUnderDest(destRoot, destPath, linkname string) error {
linkname = strings.TrimSpace(linkname)
if linkname == "" {
return fmt.Errorf("empty symlink target")
}
if filepath.IsAbs(linkname) {
return fmt.Errorf("symlink has absolute target")
}
destAbs, err := filepath.Abs(destRoot)
if symlinkTargetHasDotDot(linkname) {
return fmt.Errorf("symlink target escapes destination directory")
}
destResolved, err := filepath.EvalSymlinks(destRoot)
if err != nil {
return err
}
resolved := filepath.Clean(filepath.Join(filepath.Dir(destPath), linkname))
resAbs, err := filepath.Abs(resolved)
linkDir, err := resolvedSymlinkParentDir(destPath)
if err != nil {
return fmt.Errorf("symlink target escapes destination directory")
}
expansionsLeft := maxSymlinkResolveExpansions
resolved, err := resolveSymlinkTargetAt(linkDir, linkname, 0, &expansionsLeft)
if err != nil {
return err
}
rel, err := filepath.Rel(filepath.Clean(destResolved), filepath.Clean(resolved))
if err != nil {
return fmt.Errorf("symlink target escapes destination directory")
}
sep := string(filepath.Separator)
if resAbs != destAbs && !strings.HasPrefix(resAbs, destAbs+sep) {
if rel == ".." || strings.HasPrefix(rel, ".."+sep) {
return fmt.Errorf("symlink target escapes destination directory")
}
return nil
}
// symlinkTargetHasDotDot reports whether linkname contains a ".." path segment before cleaning.
func symlinkTargetHasDotDot(linkname string) bool {
linkname = filepath.ToSlash(strings.TrimSpace(linkname))
for _, seg := range strings.Split(linkname, "/") {
if seg == ".." {
return true
}
}
return false
}
// resolvedSymlinkParentDir returns the real directory that will host the new symlink at destPath.
func resolvedSymlinkParentDir(destPath string) (string, error) {
linkPath, err := resolvedLinkPath(destPath)
if err != nil {
return "", err
}
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).
// 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 "", errSymlinkTargetEscape()
}
if filepath.IsAbs(linkname) {
return resolveSymlinkTargetAbsolute(linkname, depth, expansionsLeft)
}
linkDir = filepath.Clean(linkDir)
cur := linkDir
for _, part := range strings.Split(filepath.ToSlash(linkname), "/") {
if part == "" || part == "." {
continue
}
switch part {
case "..":
cur = filepath.Dir(cur)
default:
next := filepath.Join(cur, part)
info, err := os.Lstat(next)
if err != nil {
if os.IsNotExist(err) {
cur = next
continue
}
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
}
var nested string
if filepath.IsAbs(target) {
nested, err = resolveSymlinkTargetAbsolute(target, depth+1, expansionsLeft)
} else {
nested, err = resolveSymlinkTargetAt(filepath.Dir(next), target, depth+1, expansionsLeft)
}
if err != nil {
return "", err
}
cur = nested
continue
}
cur = next
}
}
return filepath.Clean(cur), nil
}
// resolveSymlinkTargetAbsolute walks an absolute path from the volume root so every path
// component is resolved, including ancestor symlinks (a single Lstat on the full path would skip them).
// The path must not be filepath.Clean'd before walking or ".." segments collapse before symlinks are seen.
func resolveSymlinkTargetAbsolute(path string, depth int, expansionsLeft *int) (string, error) {
if depth > maxSymlinkResolveDepth {
return "", errSymlinkTargetEscape()
}
path = filepath.FromSlash(filepath.ToSlash(path))
root := filepath.VolumeName(path) + string(filepath.Separator)
if !strings.HasPrefix(path, root) {
return "", errSymlinkTargetEscape()
}
rel := path[len(root):]
return resolveSymlinkTargetAt(root, rel, depth, 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()
+313
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"
@@ -563,6 +565,317 @@ func TestExtractZip_symlinkDestination(t *testing.T) {
}
}
func writeChainedSymlinkEscapeTar(t *testing.T, path string) {
t.Helper()
writeTestTarGz(t, path, func(tw *tar.Writer) error {
if err := tw.WriteHeader(&tar.Header{Name: "a/b/", Mode: 0o755, Typeflag: tar.TypeDir}); err != nil {
return err
}
if err := tw.WriteHeader(&tar.Header{Name: "a/b/l1", Mode: 0o777, Typeflag: tar.TypeSymlink, Linkname: "../.."}); err != nil {
return err
}
return tw.WriteHeader(&tar.Header{Name: "esc", Mode: 0o777, Typeflag: tar.TypeSymlink, Linkname: "a/b/l1/../x"})
})
}
func writeChainedSymlinkEscapeZip(t *testing.T, path string) {
t.Helper()
writeTestZip(t, path, func(zw *zip.Writer) error {
hdr := &zip.FileHeader{Name: "a/b/l1", Method: zip.Store}
hdr.SetMode(0o777 | os.ModeSymlink)
w, err := zw.CreateHeader(hdr)
if err != nil {
return err
}
if _, err = w.Write([]byte("../..")); err != nil {
return err
}
hdr = &zip.FileHeader{Name: "esc", Method: zip.Store}
hdr.SetMode(0o777 | os.ModeSymlink)
w, err = zw.CreateHeader(hdr)
if err != nil {
return err
}
_, err = w.Write([]byte("a/b/l1/../x"))
return err
})
}
func assertNoEscapingSymlinksUnderDest(t *testing.T, destDir string) {
t.Helper()
destResolved, err := filepath.EvalSymlinks(destDir)
if err != nil {
t.Fatal(err)
}
sep := string(filepath.Separator)
walkErr := filepath.WalkDir(destDir, func(path string, d os.DirEntry, err error) error {
if err != nil {
return err
}
if d.Type()&os.ModeSymlink == 0 {
return nil
}
target, err := os.Readlink(path)
if err != nil {
return err
}
linkDir, err := resolvedSymlinkParentDir(path)
if err != nil {
return err
}
expansionsLeft := maxSymlinkResolveExpansions
resolved, err := resolveSymlinkTargetAt(linkDir, target, 0, &expansionsLeft)
if err != nil {
return nil
}
rel, err := filepath.Rel(destResolved, resolved)
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+sep) {
t.Fatalf("symlink %q resolves outside destination to %q", path, resolved)
}
return nil
})
if walkErr != nil {
t.Fatal(walkErr)
}
}
func TestSymlinkTargetStaysUnderDest_rejectsChainedRelativeEscape(t *testing.T) {
destDir := t.TempDir()
if err := os.MkdirAll(filepath.Join(destDir, "a", "b"), 0o755); err != nil {
t.Fatal(err)
}
l1 := filepath.Join(destDir, "a", "b", "l1")
if err := os.Symlink("../..", l1); err != nil {
t.Fatal(err)
}
escPath := filepath.Join(destDir, "esc")
if err := symlinkTargetStaysUnderDest(destDir, escPath, "a/b/l1/../x"); err == nil {
t.Fatal("expected chained symlink target to be rejected")
}
}
func TestExtractZip_rejectsChainedSymlinkEscape(t *testing.T) {
destDir := t.TempDir()
zipPath := filepath.Join(t.TempDir(), "chain.zip")
writeChainedSymlinkEscapeZip(t, zipPath)
err := extractZip(zipPath, destDir)
if err == nil || !strings.Contains(err.Error(), "escapes destination") {
t.Fatalf("expected rejection, got %v", err)
}
if _, statErr := os.Lstat(filepath.Join(destDir, "esc")); !os.IsNotExist(statErr) {
t.Fatal("escaping symlink should not be created")
}
assertNoEscapingSymlinksUnderDest(t, destDir)
}
func TestExtractTarGz_rejectsChainedSymlinkEscape(t *testing.T) {
destDir := t.TempDir()
archivePath := filepath.Join(t.TempDir(), "chain.tar.gz")
writeChainedSymlinkEscapeTar(t, archivePath)
err := extractTarGz(archivePath, destDir, nil)
if err == nil || !strings.Contains(err.Error(), "escapes destination") {
t.Fatalf("expected rejection, got %v", err)
}
if _, statErr := os.Lstat(filepath.Join(destDir, "esc")); !os.IsNotExist(statErr) {
t.Fatal("escaping symlink should not be created")
}
assertNoEscapingSymlinksUnderDest(t, destDir)
}
func TestExtractZip_rejectsChainedSymlinkEscape_preExistingHop(t *testing.T) {
destDir := t.TempDir()
if err := os.MkdirAll(filepath.Join(destDir, "a", "b"), 0o755); err != nil {
t.Fatal(err)
}
if err := os.Symlink("../..", filepath.Join(destDir, "a", "b", "l1")); err != nil {
t.Fatal(err)
}
zipPath := filepath.Join(t.TempDir(), "hop.zip")
writeTestZip(t, zipPath, func(zw *zip.Writer) error {
hdr := &zip.FileHeader{Name: "esc", Method: zip.Store}
hdr.SetMode(0o777 | os.ModeSymlink)
w, err := zw.CreateHeader(hdr)
if err != nil {
return err
}
_, err = w.Write([]byte("a/b/l1/../x"))
return err
})
err := extractZip(zipPath, destDir)
if err == nil || !strings.Contains(err.Error(), "escapes destination") {
t.Fatalf("expected rejection, got %v", err)
}
if _, statErr := os.Lstat(filepath.Join(destDir, "esc")); !os.IsNotExist(statErr) {
t.Fatal("escaping symlink should not be created")
}
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 setupAbsoluteHopThroughOutsidePivot(t *testing.T) (destDir, outside string, hopLeafAbs string) {
t.Helper()
destDir = t.TempDir()
outside = filepath.Join(filepath.Dir(destDir), "abs-pivot-outside")
if err := os.MkdirAll(outside, 0o755); err != nil {
t.Fatal(err)
}
pivot := filepath.Join(destDir, "pivot")
if err := os.Symlink(outside, pivot); err != nil {
t.Fatal(err)
}
leafAbs, err := filepath.Abs(filepath.Join(pivot, "leaf"))
if err != nil {
t.Fatal(err)
}
return destDir, outside, leafAbs
}
func TestSymlinkTargetStaysUnderDest_rejectsAbsoluteHopThroughOutsidePivot_fileExists(t *testing.T) {
destDir, outside, hopLeafAbs := setupAbsoluteHopThroughOutsidePivot(t)
if err := os.WriteFile(filepath.Join(outside, "leaf"), []byte("secret"), 0o644); err != nil {
t.Fatal(err)
}
if err := os.Symlink(hopLeafAbs, filepath.Join(destDir, "hop")); err != nil {
t.Fatal(err)
}
newLink := filepath.Join(destDir, "newlink")
if err := symlinkTargetStaysUnderDest(destDir, newLink, "hop"); err == nil {
t.Fatal("expected rejection when hop resolves through outside pivot to existing file")
}
}
func TestSymlinkTargetStaysUnderDest_rejectsAbsoluteHopThroughOutsidePivot_fileMissing(t *testing.T) {
destDir, _, hopLeafAbs := setupAbsoluteHopThroughOutsidePivot(t)
if err := os.Symlink(hopLeafAbs, filepath.Join(destDir, "hop")); err != nil {
t.Fatal(err)
}
newLink := filepath.Join(destDir, "newlink")
if err := symlinkTargetStaysUnderDest(destDir, newLink, "hop"); err == nil {
t.Fatal("expected rejection when hop resolves through outside pivot to missing leaf")
}
}
func TestSymlinkTargetStaysUnderDest_rejectsAbsoluteHopWithDotDotAfterOutsidePivot(t *testing.T) {
destDir, outside, _ := setupAbsoluteHopThroughOutsidePivot(t)
sibling := filepath.Join(filepath.Dir(outside), "sibling-out")
if err := os.MkdirAll(sibling, 0o755); err != nil {
t.Fatal(err)
}
pivot := filepath.Join(destDir, "pivot")
sep := string(filepath.Separator)
// Build without filepath.Clean/Join collapsing pivot before sibling resolution.
hopTarget := pivot + sep + ".." + sep + filepath.Base(outside) + sep + ".." + sep + filepath.Base(sibling)
if err := os.Symlink(hopTarget, filepath.Join(destDir, "hop")); err != nil {
t.Fatal(err)
}
newLink := filepath.Join(destDir, "newlink")
if err := symlinkTargetStaysUnderDest(destDir, newLink, "hop"); err == nil {
t.Fatal("expected rejection for absolute hop with .. after ancestor symlink")
}
}
func TestSymlinkTargetStaysUnderDest_allowsInDestAbsoluteHopChain(t *testing.T) {
destDir := t.TempDir()
inner := filepath.Join(destDir, "inner")
if err := os.MkdirAll(inner, 0o755); err != nil {
t.Fatal(err)
}
targetFile := filepath.Join(inner, "data.txt")
if err := os.WriteFile(targetFile, []byte("ok"), 0o644); err != nil {
t.Fatal(err)
}
innerAbs, err := filepath.Abs(inner)
if err != nil {
t.Fatal(err)
}
if err = os.Symlink(innerAbs, filepath.Join(destDir, "pivot")); err != nil {
t.Fatal(err)
}
hopTarget, err := filepath.Abs(targetFile)
if err != nil {
t.Fatal(err)
}
if err = os.Symlink(hopTarget, filepath.Join(destDir, "hop")); err != nil {
t.Fatal(err)
}
newLink := filepath.Join(destDir, "ref")
if err := symlinkTargetStaysUnderDest(destDir, newLink, "hop"); err != nil {
t.Fatalf("in-dest absolute hop chain should be allowed: %v", err)
}
}
func TestArchiveCreateDestination_RejectsEscapingSymlinkLeaf(t *testing.T) {
t.Parallel()
root := t.TempDir()