undefect. CWE-407 — 63 sites patched across 27 ecosystems

Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com

Patches, unit tests, benchmarks, whitepaper, and outreach briefs.
Public domain — no copyright claimed. Use freely.

test/jdk/sun/security/provider/FileInputStreamPool/FileInputStreamPoolTest.java

@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2014, 2025, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @bug 8047769
+ * @modules java.base/java.io:open
+ *          java.base/sun.security.provider:open
+ * @summary SecureRandom should be more frugal with file descriptors
+ */
+
+import java.io.File;
+import java.io.FileDescriptor;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.UndeclaredThrowableException;
+import java.util.Arrays;
+import java.util.HashSet;
+
+public class FileInputStreamPoolTest {
+
+    static final byte[] bytes = new byte[]{1, 2, 3, 4, 5, 6, 7, 8};
+
+    static FilterInputStream testCaching(File file) throws IOException {
+        InputStream in1 = TestProxy.FileInputStreamPool_getInputStream(file);
+        InputStream in2 = TestProxy.FileInputStreamPool_getInputStream(file);
+        assertTrue(in1 == in2,
+            "1st InputStream: " + in1 +
+                " is not same as 2nd: " + in2);
+
+        byte[] readBytes = new byte[bytes.length];
+        int nread = in1.read(readBytes);
+        assertTrue(bytes.length == nread,
+            "short read: " + nread +
+                " bytes of expected: " + bytes.length);
+        assertTrue(Arrays.equals(readBytes, bytes),
+            "readBytes: " + Arrays.toString(readBytes) +
+                " not equal to expected: " + Arrays.toString(bytes));
+
+       return (FilterInputStream)in1;
+    }
+
+    static void assertTrue(boolean test, String message) {
+        if (!test) {
+            throw new AssertionError(message);
+        }
+    }
+
+    static void processReferences(FilterInputStream in1) throws InterruptedException, IOException {
+        FileInputStream fis = TestProxy.FilterInputStream_getInField(in1);
+        FileDescriptor fd = fis.getFD();
+        System.out.printf("fis: %s, fd: %s%n", fis, fd);
+        // Prepare to wait for FD to be reclaimed
+        ReferenceQueue<Object> queue = new ReferenceQueue<>();
+        HashSet<Reference<?>> pending = new HashSet<>();
+        pending.add(new WeakReference<>(in1, queue));
+        pending.add(new WeakReference<>(fis, queue));
+        pending.add(new WeakReference<>(fd, queue));
+
+        Reference<?> r;
+        while (((r = queue.remove(10L)) != null)
+                || !pending.isEmpty()) {
+            System.out.printf("r: %s, pending: %d%n", r, pending.size());
+            if (r != null) {
+                pending.remove(r);
+            } else {
+                fd = null;
+                fis = null;
+                in1 = null;
+                System.gc();  // attempt to reclaim the FD
+            }
+            Thread.sleep(10L);
+        }
+        Reference.reachabilityFence(fd);
+        Reference.reachabilityFence(fis);
+        Reference.reachabilityFence(in1);
+    }
+
+    public static void main(String[] args) throws Exception {
+        // 1st create temporary file
+        File file = File.createTempFile("test", ".dat");
+        try (AutoCloseable acf = () -> {
+            // On Windows, failure to delete file is probably a consequence
+            // of the file still being opened - so the test should fail.
+            assertTrue(file.delete(),
+                "Can't delete: " + file + " (is it still open?)");
+        }) {
+            try (FileOutputStream out = new FileOutputStream(file)) {
+                out.write(bytes);
+            }
+
+            // test caching 1st time
+
+            processReferences(testCaching(file));
+
+            // test caching 2nd time - this should only succeed if the stream
+            // is re-opened as a consequence of cleared WeakReference
+
+            processReferences(testCaching(file));
+        }
+    }
+
+    /**
+     * A proxy for (package)private static methods:
+     *   sun.security.provider.FileInputStreamPool.getInputStream
+     */
+    static class TestProxy {
+        private static final Method getInputStreamMethod;
+        private static final Field inField;
+
+        static {
+            try {
+                Class<?> fileInputStreamPoolClass =
+                    Class.forName("sun.security.provider.FileInputStreamPool");
+                getInputStreamMethod =
+                    fileInputStreamPoolClass.getDeclaredMethod(
+                        "getInputStream", File.class);
+                getInputStreamMethod.setAccessible(true);
+
+                inField = FilterInputStream.class.getDeclaredField("in");
+                inField.setAccessible(true);
+            } catch (Exception e) {
+                throw new Error(e);
+            }
+        }
+
+        static InputStream FileInputStreamPool_getInputStream(File file)
+            throws IOException {
+            try {
+                return (InputStream) getInputStreamMethod.invoke(null, file);
+            } catch (InvocationTargetException e) {
+                Throwable te = e.getTargetException();
+                if (te instanceof IOException) {
+                    throw (IOException) te;
+                } else if (te instanceof RuntimeException) {
+                    throw (RuntimeException) te;
+                } else if (te instanceof Error) {
+                    throw (Error) te;
+                } else {
+                    throw new UndeclaredThrowableException(te);
+                }
+            } catch (IllegalAccessException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        static FileInputStream FilterInputStream_getInField(FilterInputStream fis) {
+            try {
+                return (FileInputStream) inField.get(fis);
+            } catch (IllegalAccessException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+}