mathiasandClaude Opus 5.5
9eb3d2456d
brain_tunnel passes caller-supplied source and target paths to
WriteTunnel, which checked only the first segments ("wiki/<wing>/...")
and joined them onto the brain dir. "wiki/b/x/../../../../tmp/f.md"
resolved outside the brain, and appendSeeAlso read and rewrote that file
(verified by execution): any MCP token holder could append to any
existing file the pod user can write, inside the brain (raw/, sessions/,
classification.yaml) or outside it.
- checkNotePath: only a clean, local wiki/.../<slug>.md path, with no
".", ".." or empty segments.
- Both notes are read and rewritten through brainfs. New
brainfs.WriteRegular: never creates; Lstat through the root, open with
O_NOFOLLOW|O_NONBLOCK, and require the opened handle to be the same
regular file (os.SameFile). os.Root.OpenFile follows an in-root final
symlink even with O_NOFOLLOW (verified on go1.27), so the flag alone
does not refuse it.
- The source is no longer rewritten when the target is refused.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
237 lines
8.4 KiB
Go
237 lines
8.4 KiB
Go
package brainfs
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"syscall"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// The handle check is what stops a FIFO swapped in after the Lstat. A FIFO
|
|
// with no writer reads EOF at once, so a race test could not see the check
|
|
// missing; here a writer holds the FIFO open, as any local process can, and
|
|
// readOpened must refuse it promptly (PR #161 review).
|
|
func TestReadOpenedRefusesAFIFOHeldOpenByAWriter(t *testing.T) {
|
|
dir := t.TempDir()
|
|
fifo := filepath.Join(dir, "p.md")
|
|
require.NoError(t, syscall.Mkfifo(fifo, 0o644))
|
|
w, err := os.OpenFile(fifo, os.O_RDWR, 0)
|
|
require.NoError(t, err)
|
|
defer func() { _ = w.Close() }()
|
|
|
|
b, err := Open(dir)
|
|
require.NoError(t, err)
|
|
defer func() { _ = b.Close() }()
|
|
|
|
done := make(chan error, 1)
|
|
go func() { _, err := b.readOpened("p.md"); done <- err }()
|
|
select {
|
|
case err := <-done:
|
|
assert.True(t, errors.Is(err, ErrNotRegular), "got %v", err)
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("readOpened blocked on a FIFO with a writer")
|
|
}
|
|
}
|
|
|
|
func TestReadRegularRefusesSymlinksAndReadsRegularFiles(t *testing.T) {
|
|
dir := t.TempDir()
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "ok.md"), []byte("ok"), 0o644))
|
|
outside := filepath.Join(t.TempDir(), "s.md")
|
|
require.NoError(t, os.WriteFile(outside, []byte("secret"), 0o644))
|
|
require.NoError(t, os.Symlink(outside, filepath.Join(dir, "link.md")))
|
|
b, err := Open(dir)
|
|
require.NoError(t, err)
|
|
defer func() { _ = b.Close() }()
|
|
got, err := b.ReadRegular("ok.md")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "ok", string(got))
|
|
_, err = b.ReadRegular("link.md")
|
|
assert.True(t, errors.Is(err, ErrNotRegular), "got %v", err)
|
|
_, err = b.ReadRegular("../" + filepath.Base(outside))
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestRelAcceptsPathsInsideAndRefusesEscapes(t *testing.T) {
|
|
dir := t.TempDir()
|
|
b, err := Open(dir)
|
|
require.NoError(t, err)
|
|
defer func() { _ = b.Close() }()
|
|
for in, want := range map[string]string{
|
|
filepath.Join(dir, "wiki", "x.md"): "wiki/x.md",
|
|
filepath.Join(dir, "..foo", "x"): "..foo/x",
|
|
dir: ".",
|
|
} {
|
|
got, err := b.Rel(in)
|
|
require.NoError(t, err, in)
|
|
assert.Equal(t, want, got, in)
|
|
}
|
|
for _, bad := range []string{filepath.Join(dir, "..", "x"), dir + "-evil/x", "/etc/passwd", filepath.Join(dir, "wiki", "..", "..", "x")} {
|
|
_, err := b.Rel(bad)
|
|
assert.Error(t, err, bad)
|
|
}
|
|
}
|
|
|
|
func TestWalkRegularYieldsOnlyRegularFiles(t *testing.T) {
|
|
dir := t.TempDir()
|
|
require.NoError(t, os.MkdirAll(filepath.Join(dir, "a"), 0o755))
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "a", "n.md"), []byte("n"), 0o644))
|
|
require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(dir, "a", "dirlink")))
|
|
require.NoError(t, os.Symlink(filepath.Join(dir, "a", "n.md"), filepath.Join(dir, "a", "filelink.md")))
|
|
require.NoError(t, syscall.Mkfifo(filepath.Join(dir, "a", "p.md"), 0o644))
|
|
b, err := Open(dir)
|
|
require.NoError(t, err)
|
|
defer func() { _ = b.Close() }()
|
|
var got []string
|
|
require.NoError(t, b.WalkRegular(".", func(rel string) error { got = append(got, rel); return nil }, nil))
|
|
assert.Equal(t, []string{"a/n.md"}, got)
|
|
}
|
|
|
|
func TestReadRegularMaxRefusesAFileOverTheLimit(t *testing.T) {
|
|
dir := t.TempDir()
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "big.md"), make([]byte, 100), 0o644))
|
|
b, err := Open(dir)
|
|
require.NoError(t, err)
|
|
defer func() { _ = b.Close() }()
|
|
_, err = b.ReadRegularMax("big.md", 99)
|
|
assert.True(t, errors.Is(err, ErrTooLarge), "got %v", err)
|
|
got, err := b.ReadRegularMax("big.md", 100)
|
|
require.NoError(t, err)
|
|
assert.Len(t, got, 100)
|
|
}
|
|
|
|
func TestReadRegularMaxRefusesAndStopsReadingAFileThatGrowsPastTheLimit(t *testing.T) {
|
|
dir := t.TempDir()
|
|
p := filepath.Join(dir, "grow.md")
|
|
require.NoError(t, os.WriteFile(p, make([]byte, 10), 0o644))
|
|
consumed := &countingReader{}
|
|
wrapAfterStat = func(r io.Reader) io.Reader {
|
|
f, err := os.OpenFile(p, os.O_WRONLY|os.O_APPEND, 0)
|
|
require.NoError(t, err)
|
|
_, err = f.Write(make([]byte, 1000))
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.Close())
|
|
consumed.r = r
|
|
return consumed
|
|
}
|
|
t.Cleanup(func() { wrapAfterStat = nil })
|
|
b, err := Open(dir)
|
|
require.NoError(t, err)
|
|
defer func() { _ = b.Close() }()
|
|
got, err := b.ReadRegularMax("grow.md", 100)
|
|
assert.True(t, errors.Is(err, ErrTooLarge), "got %v", err)
|
|
assert.Nil(t, got)
|
|
assert.LessOrEqual(t, consumed.n, 101, "read past max+1 bytes")
|
|
}
|
|
|
|
type countingReader struct {
|
|
r io.Reader
|
|
n int
|
|
}
|
|
|
|
func (c *countingReader) Read(p []byte) (int, error) {
|
|
n, err := c.r.Read(p)
|
|
c.n += n
|
|
return n, err
|
|
}
|
|
|
|
func TestLstatDoesNotFollowSymlinksAndRefusesEscapes(t *testing.T) {
|
|
dir := t.TempDir()
|
|
outside := filepath.Join(t.TempDir(), "o.md")
|
|
require.NoError(t, os.WriteFile(outside, []byte("o"), 0o644))
|
|
require.NoError(t, os.Symlink(outside, filepath.Join(dir, "l.md")))
|
|
b, err := Open(dir)
|
|
require.NoError(t, err)
|
|
defer func() { _ = b.Close() }()
|
|
fi, err := b.Lstat("l.md")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, fs.ModeSymlink, fi.Mode().Type())
|
|
_, err = b.Lstat("../" + filepath.Base(filepath.Dir(outside)) + "/o.md")
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestWalkRegularReportsASymlinkedWalkRootAndYieldsNothing(t *testing.T) {
|
|
dir := t.TempDir()
|
|
require.NoError(t, os.MkdirAll(filepath.Join(dir, "real"), 0o755))
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "real", "n.md"), []byte("n"), 0o644))
|
|
require.NoError(t, os.Symlink("real", filepath.Join(dir, "alias")))
|
|
b, err := Open(dir)
|
|
require.NoError(t, err)
|
|
defer func() { _ = b.Close() }()
|
|
var got []string
|
|
var errs []error
|
|
require.NoError(t, b.WalkRegular("alias", func(rel string) error { got = append(got, rel); return nil },
|
|
func(_ string, err error) { errs = append(errs, err) }))
|
|
assert.Empty(t, got)
|
|
require.Len(t, errs, 1)
|
|
assert.ErrorIs(t, errs[0], ErrNotRegular)
|
|
}
|
|
|
|
func TestWalkRegularReportsASymlinkedIntermediateComponentOfTheWalkRoot(t *testing.T) {
|
|
dir := t.TempDir()
|
|
require.NoError(t, os.MkdirAll(filepath.Join(dir, "real", "sub"), 0o755))
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "real", "sub", "n.md"), []byte("n"), 0o644))
|
|
require.NoError(t, os.Symlink("real", filepath.Join(dir, "alias")))
|
|
b, err := Open(dir)
|
|
require.NoError(t, err)
|
|
defer func() { _ = b.Close() }()
|
|
var got []string
|
|
var errs []error
|
|
require.NoError(t, b.WalkRegular("alias/sub", func(rel string) error { got = append(got, rel); return nil },
|
|
func(_ string, err error) { errs = append(errs, err) }))
|
|
assert.Empty(t, got)
|
|
require.Len(t, errs, 1)
|
|
assert.ErrorIs(t, errs[0], ErrNotRegular)
|
|
}
|
|
|
|
func TestWriteRegularRefusesFinalSymlinksFIFOsEscapesAndMissingFilesAndRewritesRegularFiles(t *testing.T) {
|
|
dir := t.TempDir()
|
|
outside := filepath.Join(t.TempDir(), "o.md")
|
|
require.NoError(t, os.WriteFile(outside, []byte("untouched"), 0o644))
|
|
require.NoError(t, os.Symlink(outside, filepath.Join(dir, "l.md")))
|
|
require.NoError(t, syscall.Mkfifo(filepath.Join(dir, "f.md"), 0o644))
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "n.md"), []byte("old content"), 0o644))
|
|
b, err := Open(dir)
|
|
require.NoError(t, err)
|
|
defer func() { _ = b.Close() }()
|
|
|
|
assert.Error(t, b.WriteRegular("l.md", []byte("x")))
|
|
got, _ := os.ReadFile(outside)
|
|
assert.Equal(t, "untouched", string(got))
|
|
|
|
// A symlink to another file inside the brain: os.Root would allow it,
|
|
// only O_NOFOLLOW refuses it.
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "in.md"), []byte("inside"), 0o644))
|
|
require.NoError(t, os.Symlink("in.md", filepath.Join(dir, "il.md")))
|
|
assert.Error(t, b.WriteRegular("il.md", []byte("x")))
|
|
got, _ = os.ReadFile(filepath.Join(dir, "in.md"))
|
|
assert.Equal(t, "inside", string(got))
|
|
|
|
// A reader held open, so a non-blocking write open would succeed and
|
|
// only the type check on the handle refuses it.
|
|
r, err := os.OpenFile(filepath.Join(dir, "f.md"), os.O_RDONLY|syscall.O_NONBLOCK, 0)
|
|
require.NoError(t, err)
|
|
defer func() { _ = r.Close() }()
|
|
done := make(chan error, 1)
|
|
go func() { done <- b.WriteRegular("f.md", []byte("x")) }()
|
|
select {
|
|
case err := <-done:
|
|
assert.Error(t, err)
|
|
case <-time.After(3 * time.Second):
|
|
t.Fatal("WriteRegular hung on a FIFO")
|
|
}
|
|
|
|
assert.Error(t, b.WriteRegular("../"+filepath.Base(filepath.Dir(outside))+"/o.md", []byte("x")))
|
|
assert.Error(t, b.WriteRegular("missing.md", []byte("x")), "does not create files")
|
|
|
|
require.NoError(t, b.WriteRegular("n.md", []byte("new")))
|
|
got, _ = os.ReadFile(filepath.Join(dir, "n.md"))
|
|
assert.Equal(t, "new", string(got), "truncated and rewritten")
|
|
}
|