[GR-75851] CompositeFileSystem symlink target mismatch.

Author: tzezula

truffle/src/com.oracle.truffle.api.test/src/com/oracle/truffle/api/test/polyglot/TruffleFileTest.java

@@ -1277,6 +1277,56 @@ protected Object execute(RootNode node, Env env, Object[] contextArguments, Obje
         }
     }
 
+    @Test
+    public void testCompositeFileSystemCreateSymbolicLinkRelativeTargetEscape() throws Exception {
+        Path tmp = Files.createTempDirectory("truffle-file-test");
+        try {
+            Path allowed = tmp.resolve("allowed").toAbsolutePath();
+            Files.createDirectories(allowed);
+            Path cwd = allowed.resolve("cwd").toAbsolutePath();
+            Files.createDirectories(cwd);
+            Path denied = tmp.resolve("denied").toAbsolutePath();
+            Files.writeString(denied, "denied");
+
+            FileSystem noIO = FileSystem.newDenyIOFileSystem();
+            FileSystem fullIO = FileSystem.newDefaultFileSystem();
+            FileSystem.Selector fullIOPredicate = new FileSystem.Selector(fullIO) {
+                @Override
+                public boolean test(Path path) {
+                    return path.startsWith(allowed);
+                }
+            };
+            FileSystem compositeFs = FileSystem.newCompositeFileSystem(noIO, fullIOPredicate);
+            compositeFs.setCurrentWorkingDirectory(cwd);
+
+            IOAccess ioAccess = IOAccess.newBuilder().fileSystem(compositeFs).build();
+            try (Context context = Context.newBuilder().allowIO(ioAccess).build()) {
+                assertFails(
+                                () -> AbstractExecutableTestLanguage.evalTestLanguage(
+                                                context, TestCompositeFileSystemCreateSymbolicLinkRelativeTargetEscape.class, "", allowed.toString()),
+                                PolyglotException.class,
+                                (e) -> Assert.assertTrue(e.getMessage().contains("Cross file system linking is not supported.")));
+                assertFalse(Files.exists(allowed.resolve("link")));
+            }
+        } finally {
+            delete(tmp);
+        }
+    }
+
+    @Registration
+    static final class TestCompositeFileSystemCreateSymbolicLinkRelativeTargetEscape extends AbstractExecutableTestLanguage {
+
+        @Override
+        @TruffleBoundary
+        protected Object execute(RootNode node, Env env, Object[] contextArguments, Object[] frameArguments) throws Exception {
+            TruffleFile allowed = env.getPublicTruffleFile((String) contextArguments[0]);
+            TruffleFile link = allowed.resolve("link");
+            TruffleFile target = env.getPublicTruffleFile("..").resolve("denied");
+            link.createSymbolicLink(target);
+            return null;
+        }
+    }
+
     private static void delete(Path path) throws IOException {
         if (Files.isDirectory(path)) {
             try (DirectoryStream<Path> dir = Files.newDirectoryStream(path)) {

truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/FileSystems.java

@@ -1725,8 +1725,11 @@ public void createLink(Path link, Path existing) throws IOException {
         @Override
         public void createSymbolicLink(Path link, Path target, FileAttribute<?>... attrs) throws IOException {
             FileSystemInfo linkFileSystemInfo = selectFileSystem(link);
-            FileSystemInfo targetFileSystemInfo = selectFileSystem(target);
-            if (linkFileSystemInfo.fileSystem == targetFileSystemInfo.fileSystem) {
+            Path absoluteLink = linkFileSystemInfo.absolutePath;
+            Path linkParent = absoluteLink.getParent();
+            // A relative symbolic-link target is interpreted relative to the link's parent.
+            Path normalizedTarget = target.isAbsolute() ? target.normalize() : (linkParent == null ? absoluteLink : linkParent).resolve(target).normalize();
+            if (linkFileSystemInfo.fileSystem == findOwningFileSystem(normalizedTarget)) {
                 linkFileSystemInfo.fileSystem.createSymbolicLink(linkFileSystemInfo.path, target);
             } else {
                 throw new IOException("Cross file system linking is not supported.");
@@ -1836,20 +1839,23 @@ private FileSystemInfo selectFileSystem(Path path) {
             changeDirLock.readLock().lock();
             try {
                 Path absolutePath = toNormalizedAbsolutePath(path);
-                FileSystem fs = fallBackFileSystem;
-                for (Selector delegate : delegates) {
-                    if (delegate.test(absolutePath)) {
-                        fs = delegate.getFileSystem();
-                        break;
-                    }
-                }
-                return new FileSystemInfo(fs, currentWorkingDirectory != null ? absolutePath : path);
+                FileSystem fs = findOwningFileSystem(absolutePath);
+                return new FileSystemInfo(fs, currentWorkingDirectory != null ? absolutePath : path, absolutePath);
             } finally {
                 changeDirLock.readLock().unlock();
             }
         }
 
-        private record FileSystemInfo(FileSystem fileSystem, Path path) {
+        private FileSystem findOwningFileSystem(Path absolutePath) {
+            for (Selector delegate : delegates) {
+                if (delegate.test(absolutePath)) {
+                    return delegate.getFileSystem();
+                }
+            }
+            return fallBackFileSystem;
+        }
+
+        private record FileSystemInfo(FileSystem fileSystem, Path path, Path absolutePath) {
         }
 
         private Path toNormalizedAbsolutePath(Path path) {