From 9b56c4db1e376af7ed140985c2513a519386f69d Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 27 Oct 2026 18:49:34 +0100 Subject: [PATCH 1/2] Reject Unix socket paths that are too long (JNI) Unix socket paths have a size limit: 104 bytes on macOS, 108 on Linux. The JNI code copied the path into a fixed-size buffer without checking its length, so a longer path overwrote memory and crashed the JVM. Such paths are realistic, for example under ~/.sbt in a deep home directory. Now bind and connect throw an IOException for a path that is too long, as the JNA code already did. Two related bugs in connect are fixed too: it passed the number of characters in the path instead of the number of bytes, so paths with non-ASCII characters failed, and it leaked the socket when it failed. Co-Authored-By: Claude Opus 5.5 --- ...ocket_JNIUnixDomainSocketLibraryProvider.c | 17 ++++-- .../scalasbt/ipcsocket/UnixDomainSocket.java | 8 ++- .../ipcsocket/UnixSocketPathTest.java | 53 +++++++++++++++++++ .../ipcsocket/UnixSocketPathTestJNI.java | 8 +++ 4 files changed, 81 insertions(+), 5 deletions(-) create mode 100644 src/test/java/org/scalasbt/ipcsocket/UnixSocketPathTest.java create mode 100644 src/test/java/org/scalasbt/ipcsocket/UnixSocketPathTestJNI.java diff --git a/jni/org_scalasbt_ipcsocket_JNIUnixDomainSocketLibraryProvider.c b/jni/org_scalasbt_ipcsocket_JNIUnixDomainSocketLibraryProvider.c index 4faf2df..0da6d26 100644 --- a/jni/org_scalasbt_ipcsocket_JNIUnixDomainSocketLibraryProvider.c +++ b/jni/org_scalasbt_ipcsocket_JNIUnixDomainSocketLibraryProvider.c @@ -26,9 +26,13 @@ return result < 0 ? -ERRNO_OF(result) : result; \ } while (0); -static void native_sockaddr(JNIEnv *env, struct sockaddr_un *native, - jobject array, jint len) { +/* Returns 0, or -ENAMETOOLONG if the path and its terminating NUL don't fit. */ +static int native_sockaddr(JNIEnv *env, struct sockaddr_un *native, + jobject array, jint len) { memset(native, 0, sizeof(struct sockaddr_un)); + if (len < 0 || (size_t)len >= sizeof(native->sun_path)) { + return -ENAMETOOLONG; + } if (array) { jbyte *bytes = (*env)->GetByteArrayElements(env, (jbyteArray)array, 0); memcpy(native->sun_path, bytes, len); @@ -38,6 +42,7 @@ static void native_sockaddr(JNIEnv *env, struct sockaddr_un *native, #ifdef __APPLE__ native->sun_len = len + 2; #endif + return 0; } jint JNICALL @@ -56,7 +61,9 @@ Java_org_scalasbt_ipcsocket_JNIUnixDomainSocketLibraryProvider_bindNative( errno = 0; struct sockaddr_un addr; const struct sockaddr *sa = (struct sockaddr *)&addr; - native_sockaddr(env, &addr, path, len); + int err = native_sockaddr(env, &addr, path, len); + if (err) + return err; int res = bind(fd, sa, sizeof(struct sockaddr_un)); THROW_ON_ERROR(res) } @@ -85,7 +92,9 @@ Java_org_scalasbt_ipcsocket_JNIUnixDomainSocketLibraryProvider_connectNative( UNUSED JNIEnv *env, UNUSED jclass clazz, jint fd, jbyteArray path, jint len) { struct sockaddr_un addr; - native_sockaddr(env, &addr, path, len); + int err = native_sockaddr(env, &addr, path, len); + if (err) + return err; errno = 0; int res = connect(fd, (struct sockaddr *)&addr, sizeof(struct sockaddr_un)); THROW_ON_ERROR(res); diff --git a/src/main/java/org/scalasbt/ipcsocket/UnixDomainSocket.java b/src/main/java/org/scalasbt/ipcsocket/UnixDomainSocket.java index 568bcd6..9d617f8 100644 --- a/src/main/java/org/scalasbt/ipcsocket/UnixDomainSocket.java +++ b/src/main/java/org/scalasbt/ipcsocket/UnixDomainSocket.java @@ -54,7 +54,13 @@ public UnixDomainSocket(String path, boolean useJNI) throws IOException { provider.socket( UnixDomainSocketLibrary.PF_LOCAL, UnixDomainSocketLibrary.SOCK_STREAM, 0)); int socketFd = fd.get(); - provider.connect(socketFd, path.getBytes(), path.length()); + byte[] address = path.getBytes(); + try { + provider.connect(socketFd, address, address.length); + } catch (NativeErrorException e) { + provider.close(socketFd); + throw e; + } this.fd = new ReferenceCountedFileDescriptor(socketFd, provider); this.is = new UnixDomainSocketInputStream(); this.os = new UnixDomainSocketOutputStream(); diff --git a/src/test/java/org/scalasbt/ipcsocket/UnixSocketPathTest.java b/src/test/java/org/scalasbt/ipcsocket/UnixSocketPathTest.java new file mode 100644 index 0000000..664b6c0 --- /dev/null +++ b/src/test/java/org/scalasbt/ipcsocket/UnixSocketPathTest.java @@ -0,0 +1,53 @@ +package org.scalasbt.ipcsocket; + +import java.io.IOException; +import java.net.ServerSocket; +import java.net.Socket; +import java.nio.file.Files; +import java.nio.file.Path; +import org.junit.Test; +import static org.junit.Assert.*; + +public class UnixSocketPathTest extends BaseSocketSetup { + private static String repeat(char c, int n) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < n; i++) sb.append(c); + return sb.toString(); + } + + @Test + public void tooLongPathIsAnError() throws IOException { + if (isWin) return; + String path = "/tmp/" + repeat('x', 300) + ".sock"; + try { + newServerSocket(path).close(); + fail("bind accepted a path longer than sun_path"); + } catch (IOException e) { + } + try { + newClientSocket(path).close(); + fail("connect accepted a path longer than sun_path"); + } catch (IOException e) { + } + } + + @Test + public void nonAsciiPath() throws IOException { + if (isWin) return; + Path dir = Files.createTempDirectory("ipcsocket-jürgen"); + String path = dir.resolve("söck").toString(); + try { + ServerSocket server = newServerSocket(path); + try (Socket client = newClientSocket(path); + Socket peer = server.accept()) { + client.getOutputStream().write(42); + assertEquals(42, peer.getInputStream().read()); + } finally { + server.close(); + } + } finally { + Files.deleteIfExists(dir.resolve("söck")); + Files.deleteIfExists(dir); + } + } +} diff --git a/src/test/java/org/scalasbt/ipcsocket/UnixSocketPathTestJNI.java b/src/test/java/org/scalasbt/ipcsocket/UnixSocketPathTestJNI.java new file mode 100644 index 0000000..b401ac6 --- /dev/null +++ b/src/test/java/org/scalasbt/ipcsocket/UnixSocketPathTestJNI.java @@ -0,0 +1,8 @@ +package org.scalasbt.ipcsocket; + +public class UnixSocketPathTestJNI extends UnixSocketPathTest { + @Override + boolean useJNI() { + return true; + } +} From 24472a8f6d37e18716be52e325cc4267466e832a Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 27 Oct 2026 18:53:32 +0100 Subject: [PATCH 2/2] Check array bounds in Unix socket streams write(b, off, len) didn't check that off and len are within the array. With JNI, the native code then read past the end of the array and sent whatever memory came after it over the socket. read(b, off, len) only noticed bad bounds after it had already consumed the data. Now both throw IndexOutOfBoundsException before doing anything, as InputStream and OutputStream require. Co-Authored-By: Claude Opus 5.5 --- .../scalasbt/ipcsocket/UnixDomainSocket.java | 10 +++++++++ .../ipcsocket/UnixSocketPathTest.java | 22 ++++++++++++++++--- 2 files changed, 29 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/scalasbt/ipcsocket/UnixDomainSocket.java b/src/main/java/org/scalasbt/ipcsocket/UnixDomainSocket.java index 9d617f8..71c29b9 100644 --- a/src/main/java/org/scalasbt/ipcsocket/UnixDomainSocket.java +++ b/src/main/java/org/scalasbt/ipcsocket/UnixDomainSocket.java @@ -129,6 +129,14 @@ public void close() throws IOException { fd.close(); } + // The JNI provider passes off and len to native code unchecked + private static void checkBounds(byte[] b, int off, int len) { + if (off < 0 || len < 0 || len > b.length - off) { + throw new IndexOutOfBoundsException( + "off " + off + ", len " + len + ", array length " + b.length); + } + } + private class UnixDomainSocketInputStream extends InputStream { public int available() throws IOException { int socketFd = fd.acquire(); @@ -154,6 +162,7 @@ public int read() throws IOException { } public int read(byte[] b, int off, int len) throws IOException { + checkBounds(b, off, len); if (len == 0) { return 0; } @@ -195,6 +204,7 @@ public void write(int b) throws IOException { } public void write(byte[] b, int off, int len) throws IOException { + checkBounds(b, off, len); if (len == 0) { return; } diff --git a/src/test/java/org/scalasbt/ipcsocket/UnixSocketPathTest.java b/src/test/java/org/scalasbt/ipcsocket/UnixSocketPathTest.java index 664b6c0..fa0ac3a 100644 --- a/src/test/java/org/scalasbt/ipcsocket/UnixSocketPathTest.java +++ b/src/test/java/org/scalasbt/ipcsocket/UnixSocketPathTest.java @@ -34,8 +34,8 @@ public void tooLongPathIsAnError() throws IOException { @Test public void nonAsciiPath() throws IOException { if (isWin) return; - Path dir = Files.createTempDirectory("ipcsocket-jürgen"); - String path = dir.resolve("söck").toString(); + Path dir = Files.createTempDirectory("ipcsocket-j\u00fcrgen"); + String path = dir.resolve("s\u00f6ck").toString(); try { ServerSocket server = newServerSocket(path); try (Socket client = newClientSocket(path); @@ -46,8 +46,24 @@ public void nonAsciiPath() throws IOException { server.close(); } } finally { - Files.deleteIfExists(dir.resolve("söck")); + Files.deleteIfExists(dir.resolve("s\u00f6ck")); Files.deleteIfExists(dir); } } + + @Test + public void outOfBoundsWriteIsAnError() throws IOException, InterruptedException { + if (isWin) return; + withSocket( + path -> { + ServerSocket server = newServerSocket(path); + try (Socket client = newClientSocket(path)) { + client.getOutputStream().write(new byte[4], 2, 100); + fail("write sent bytes past the end of the array"); + } catch (IndexOutOfBoundsException e) { + } finally { + server.close(); + } + }); + } }