dnd kitten: Never create remote directories through a staged symlink

The fix for CVE-2026-54056 only made remote regular file creation
exclusive. A remote source could still send a symlink and then a
directory with the same name, as names were only de-duplicated on
case insensitive filesystems. CreateDirAt() would then follow the
symlink and the directory's children would be written outside the
staging directory.

Always de-duplicate names, create remote directories exclusively and
never follow symlinks when opening a newly created directory.
This commit is contained in:
Kovid Goyal 2026-11-19 12:48:00 +05:30
parent 494e749a43
commit 72c2b119c3
No known key found for this signature in database
GPG key ID: 06BC317B515ACE7C
5 changed files with 94 additions and 25 deletions

View file

@ -125,6 +125,8 @@ Detailed list of changes
0.51.1 [future]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- dnd kitten: Fix a malicious remote drop source being able to write files outside the staging directory by sending a directory with the same name as a previously sent symlink (follow up to :cve:`2026-54056`)
- Fix a crash when calling :code:`Screen.hyperlink_at()` with coordinates outside the screen, such as from a watcher (:iss:`10890`)
- Fix animated images stopping when switching to a tab without animations and then back (:iss:`10894`)

View file

@ -117,28 +117,34 @@ type remote_dir_entry struct {
const case_conflict_template = "case-conflict-%d-%s"
// The key under which a case and normalization insensitive filesystem
// stores name, so that names that would alias each other compare equal.
func filesystem_name_key(name string) string {
// The key under which the filesystem stores name, so that names that would
// alias each other compare equal. On a case and normalization insensitive
// filesystem, names differing only in case or normalization alias each other.
func filesystem_name_key(name string, is_case_sensitive_filesystem bool) string {
if is_case_sensitive_filesystem {
return name
}
return strings.ToLower(norm.NFC.String(name))
}
// Ensure no two names in names refer to the same directory entry. This is
// needed even on case sensitive filesystems as a remote source can send
// duplicate names, which must not be allowed to alias each other, for example,
// a symlink and a directory with the same name.
func uniqify_child_names(names []string, is_case_sensitive_filesystem bool) []string {
if !is_case_sensitive_filesystem {
seen := utils.NewSet[string](len(names))
for i, x := range names {
names[i] = uniqify_name(x, seen)
}
seen := utils.NewSet[string](len(names))
for i, x := range names {
names[i] = uniqify_name(x, seen, is_case_sensitive_filesystem)
}
return names
}
func uniqify_name(name string, seen *utils.Set[string]) string {
func uniqify_name(name string, seen *utils.Set[string], is_case_sensitive_filesystem bool) string {
ans := name
key := filesystem_name_key(ans)
key := filesystem_name_key(ans, is_case_sensitive_filesystem)
for q := 0; seen.Has(key); q++ {
ans = fmt.Sprintf(case_conflict_template, q+1, name)
key = filesystem_name_key(ans)
key = filesystem_name_key(ans, is_case_sensitive_filesystem)
}
seen.Add(key)
return ans
@ -189,10 +195,7 @@ func do_local_copy(ctx context.Context, dest_dir *os.File, uri_list []string, ac
if src_file, err = os.Open(path); err != nil {
return err
}
if err := utils.MkdirAt(dest_dir, name, st.Mode().Perm()); err != nil {
return err
}
d, err := utils.OpenDirAt(dest_dir, name)
d, err := utils.CreateExclusiveDirAt(dest_dir, name, st.Mode().Perm())
if err != nil {
return err
}
@ -499,7 +502,9 @@ func (d *remote_dir_entry) add_remote_data(data []byte, output_buf []byte, has_m
return derr
}
} else { // directory
if f, derr := utils.CreateDirAt(d.base_dir.handle, d.name, 0o755); derr != nil {
// Never reuse an existing entry, it could be a symlink
// staged by the remote source.
if f, derr := utils.CreateExclusiveDirAt(d.base_dir.handle, d.name, 0o755); derr != nil {
return derr
} else {
handle := new_dir_handle(f)
@ -987,9 +992,7 @@ func (dnd *dnd) all_mime_data_dropped() (err error) {
drop_status.root_remote_dir.num_children_finished++
} else {
name := filepath.Base(u.path)
if !dnd.is_case_sensitive_filesystem {
name = uniqify_name(name, seen)
}
name = uniqify_name(name, seen, dnd.is_case_sensitive_filesystem)
c = &remote_dir_entry{base_dir: dnd.drop_status.dropping_to.newref(), name: name}
dnd.queue_data_request(DC{Type: 'r', X: idx + 1, Y: i + 1})
}

View file

@ -3,6 +3,7 @@
package dnd
import (
"bytes"
"context"
"fmt"
"os"
@ -1223,6 +1224,37 @@ func TestUniqifyChildNamesNormalization(t *testing.T) {
}
}
func TestUniqifyChildNamesCaseSensitive(t *testing.T) {
got := uniqify_child_names([]string{"x", "X", "x", "x"}, true)
want := []string{"x", "X", fmt.Sprintf(case_conflict_template, 1, "x"), fmt.Sprintf(case_conflict_template, 2, "x")}
if !equalStringSlices(got, want) {
t.Errorf("got %q, want %q", got, want)
}
}
// A remote directory entry must never be created through a symlink staged
// earlier by the remote source under the same name.
func TestRemoteDirDoesNotFollowStagedSymlink(t *testing.T) {
staging, outside := t.TempDir(), t.TempDir()
h := new_dir_handle(openDir(t, staging))
defer h.unref()
buf := make([]byte, 4096)
link := &remote_dir_entry{base_dir: h.newref(), name: "x", item_type: 1, dest: &bufferWriteCloser{bytes.NewBufferString(outside)}}
if err := link.add_remote_data(nil, buf, false, true); err != nil {
t.Fatalf("staging symlink: %v", err)
}
dir := &remote_dir_entry{base_dir: h.newref(), name: "x", item_type: 2, dest: &bufferWriteCloser{bytes.NewBufferString("pwned")}}
if err := dir.add_remote_data(nil, buf, false, true); err == nil {
t.Fatal("creating a directory over a staged symlink unexpectedly succeeded")
}
if len(dir.children) != 0 {
t.Errorf("directory entry got children: %d", len(dir.children))
}
if entries, err := os.ReadDir(outside); err != nil || len(entries) != 0 {
t.Errorf("outside directory was modified: %v %v", entries, err)
}
}
// TestRenameContents_SimpleFiles verifies that plain files are moved from src
// to dst.
func TestRenameContents_SimpleFiles(t *testing.T) {

View file

@ -85,17 +85,30 @@ func CreateExclusiveAt(dirFile *os.File, name string, permissions os.FileMode) (
return openAt(dirFile, name, unix.O_RDWR|unix.O_CREAT|unix.O_EXCL, permissions)
}
// Opens a directory relative to the directory pointed to by dirFile. Fails if
// name is a symlink, even one pointing to a directory.
func OpenDirNoFollowAt(dirFile *os.File, name string) (*os.File, error) {
return openAt(dirFile, name, unix.O_RDONLY|unix.O_DIRECTORY|unix.O_NOFOLLOW, 0)
}
// Create the specified directory, open it and return the file object. If the
// directory already exists, it is opened and returned, without changing its
// permissions, matching the behavior of CreateAt().
// permissions, matching the behavior of CreateAt(). Fails if name is a
// symlink, it is never followed.
func CreateDirAt(parent *os.File, name string, permissions os.FileMode) (*os.File, error) {
if err := MkdirAt(parent, name, permissions); err != nil {
if errors.Is(err, unix.EEXIST) {
return OpenDirAt(parent, name)
}
if err := MkdirAt(parent, name, permissions); err != nil && !errors.Is(err, unix.EEXIST) {
return nil, err
}
return OpenDirAt(parent, name)
return OpenDirNoFollowAt(parent, name)
}
// Create the specified directory, open it and return the file object. Fails
// if a directory entry with the same name already exists.
func CreateExclusiveDirAt(parent *os.File, name string, permissions os.FileMode) (*os.File, error) {
if err := MkdirAt(parent, name, permissions); err != nil {
return nil, err
}
return OpenDirNoFollowAt(parent, name)
}
// Internal helper to wrap the unix.Openat syscall

View file

@ -163,6 +163,25 @@ func TestCreateDirAt(t *testing.T) {
t.Fatalf("CreateDirAt existing: %v", err)
}
sub2.Close()
if err := os.Symlink(tmp, filepath.Join(tmp, "link")); err != nil {
t.Fatal(err)
}
if sub3, err := CreateDirAt(d, "link", 0700); err == nil {
sub3.Close()
t.Fatal("CreateDirAt followed a symlink")
}
for _, name := range []string{"mydir", "link"} {
if sub4, err := CreateExclusiveDirAt(d, name, 0700); err == nil {
sub4.Close()
t.Fatalf("CreateExclusiveDirAt succeeded for existing entry: %s", name)
}
}
sub5, err := CreateExclusiveDirAt(d, "newdir", 0700)
if err != nil {
t.Fatalf("CreateExclusiveDirAt new: %v", err)
}
sub5.Close()
}
func TestSymlinkAt(t *testing.T) {