Implement POSIX test and [ builtin commands

interp/allowed_paths.go

@@ -77,6 +77,65 @@ func (s *pathSandbox) resolve(absPath string) (*os.Root, string, bool) {
 	return nil, "", false
 }
 
+// access checks whether the resolved path is accessible with the given mode.
+// All operations go through os.Root to stay within the sandbox.
+// Mode: 0x04 = read, 0x02 = write, 0x01 = execute.
+func (s *pathSandbox) access(ctx context.Context, path string, mode uint32) error {
+	absPath := toAbs(path, HandlerCtx(ctx).Dir)
+
+	if s == nil {
+		return &os.PathError{Op: "access", Path: path, Err: os.ErrPermission}
+	}
+	for _, ar := range s.roots {
+		rel, err := filepath.Rel(ar.absPath, absPath)
+		if err != nil {
+			continue
+		}
+		if rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
+			continue
+		}
+
+		// Open through os.Root once. This checks read access and gives
+		// us a file descriptor for an atomic Stat (no TOCTOU window).
+		f, err := ar.root.Open(rel)
+		if err != nil {
+			if mode&0x04 != 0 && !isErrIsDirectory(err) {
+				return portablePathError(err)
+			}
+			// Read not requested, or target is a directory; fall back to Stat.
+			info, serr := ar.root.Stat(rel)
+			if serr != nil {
+				return portablePathError(serr)
+			}
+			if !effectiveHasPerm(info, 0222, 0111, mode&0x02 != 0, mode&0x01 != 0) {
+				return &os.PathError{Op: "access", Path: path, Err: os.ErrPermission}
+			}
+			return nil
+		}
+
+		// For write and execute, use mode bits from f.Stat() on the
+		// open fd — atomic, no TOCTOU window.
+		// The sandbox is read-only so -w is informational only.
+		// effectiveHasPerm checks the permission class (owner/group/other)
+		// that applies to the current process's effective UID/GID on Unix,
+		// rather than the union of all classes.
+		if mode&0x03 != 0 {
+			info, err := f.Stat()
+			if err != nil {
+				f.Close()
+				return portablePathError(err)
+			}
+			if !effectiveHasPerm(info, 0222, 0111, mode&0x02 != 0, mode&0x01 != 0) {
+				f.Close()
+				return &os.PathError{Op: "access", Path: path, Err: os.ErrPermission}
+			}
+		}
+		f.Close()
+		return nil
+	}
+	return &os.PathError{Op: "access", Path: path, Err: os.ErrPermission}
+}
+
 // toAbs resolves path against cwd when it is not already absolute.
 func toAbs(path, cwd string) string {
 	if filepath.IsAbs(path) {
@@ -133,6 +192,40 @@ func (s *pathSandbox) readDir(ctx context.Context, path string) ([]fs.DirEntry,
 	return entries, nil
 }
 
+// stat implements the restricted stat policy. The file is resolved through
+// os.Root for atomic path validation, matching the open policy.
+func (s *pathSandbox) stat(ctx context.Context, path string) (fs.FileInfo, error) {
+	absPath := toAbs(path, HandlerCtx(ctx).Dir)
+
+	root, relPath, ok := s.resolve(absPath)
+	if !ok {
+		return nil, &os.PathError{Op: "stat", Path: path, Err: os.ErrPermission}
+	}
+
+	info, err := root.Stat(relPath)
+	if err != nil {
+		return nil, portablePathError(err)
+	}
+	return info, nil
+}
+
+// lstat implements the restricted lstat policy. Unlike stat, it does not
+// follow symlinks — it returns information about the link itself.
+func (s *pathSandbox) lstat(ctx context.Context, path string) (fs.FileInfo, error) {
+	absPath := toAbs(path, HandlerCtx(ctx).Dir)
+
+	root, relPath, ok := s.resolve(absPath)
+	if !ok {
+		return nil, &os.PathError{Op: "lstat", Path: path, Err: os.ErrPermission}
+	}
+
+	info, err := root.Lstat(relPath)
+	if err != nil {
+		return nil, portablePathError(err)
+	}
+	return info, nil
+}
+
 // Close releases all os.Root file descriptors. It is safe to call multiple times.
 func (s *pathSandbox) Close() error {
 	if s == nil {

interp/builtins/builtins.go

@@ -9,6 +9,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"io/fs"
 	"os"
 
 	"github.com/spf13/pflag"
@@ -80,6 +81,16 @@ type CallContext struct {
 	// OpenFile opens a file within the shell's path restrictions.
 	OpenFile func(ctx context.Context, path string, flags int, mode os.FileMode) (io.ReadWriteCloser, error)
 
+	// StatFile returns file info within the shell's path restrictions (follows symlinks).
+	StatFile func(ctx context.Context, path string) (fs.FileInfo, error)
+
+	// LstatFile returns file info within the shell's path restrictions (does not follow symlinks).
+	LstatFile func(ctx context.Context, path string) (fs.FileInfo, error)
+
+	// AccessFile checks whether the file at path is accessible with the given mode
+	// within the shell's path restrictions. Mode: 0x04=read, 0x02=write, 0x01=execute.
+	AccessFile func(ctx context.Context, path string, mode uint32) error
+
 	// PortableErr normalizes an OS error to a POSIX-style message.
 	PortableErr func(err error) string
 }