changeset 447:bb1c74cae929

6622002: UIDefault.ProxyLazyValue has unsafe reflection usage Reviewed-by: malenkov
author alexp
date Tue, 28 Sep 2010 18:59:04 +0400
parents 1eaaf0f77762
children 57681551c11e
files src/share/classes/javax/swing/UIDefaults.java test/javax/swing/UIDefaults/6622002/bug6622002.java
diffstat 2 files changed, 79 insertions(+), 1 deletions(-) [+]
line wrap: on
line diff
--- a/src/share/classes/javax/swing/UIDefaults.java	Thu Sep 23 12:07:51 2010 -0700
+++ b/src/share/classes/javax/swing/UIDefaults.java	Tue Sep 28 18:59:04 2010 +0400
@@ -52,6 +52,7 @@
 import java.security.PrivilegedAction;
 
 import sun.reflect.misc.MethodUtil;
+import sun.reflect.misc.ReflectUtil;
 import sun.util.CoreResourceBundleControl;
 
 /**
@@ -1079,6 +1080,9 @@
             // In order to pick up the security policy in effect at the
             // time of creation we use a doPrivileged with the
             // AccessControlContext that was in place when this was created.
+            if (acc == null && System.getSecurityManager() != null) {
+                throw new SecurityException("null AccessControlContext");
+            } 
             return AccessController.doPrivileged(new PrivilegedAction() {
                 public Object run() {
                     try {
@@ -1094,7 +1098,9 @@
                                 cl = ClassLoader.getSystemClassLoader();
                             }
                         }
+                        ReflectUtil.checkPackageAccess(className);
                         c = Class.forName(className, true, (ClassLoader)cl);
+                        checkAccess(c.getModifiers());
                         if (methodName != null) {
                             Class[] types = getClassArray(args);
                             Method m = c.getMethod(methodName, types);
@@ -1102,6 +1108,7 @@
                         } else {
                             Class[] types = getClassArray(args);
                             Constructor constructor = c.getConstructor(types);
+                            checkAccess(constructor.getModifiers());
                             return constructor.newInstance(args);
                         }
                     } catch(Exception e) {
@@ -1115,8 +1122,15 @@
                 }
             }, acc);
         }
+        
+        private void checkAccess(int modifiers) {
+            if(System.getSecurityManager() != null && 
+                    !Modifier.isPublic(modifiers)) {
+                throw new SecurityException("Resource is not accessible");
+            }
+        }
 
-        /*
+        /* 
          * Coerce the array of class types provided into one which
          * looks the way the Reflection APIs expect.  This is done
          * by substituting primitive types for their Object counterparts,
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/javax/swing/UIDefaults/6622002/bug6622002.java	Tue Sep 28 18:59:04 2010 +0400
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2010, 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 6622002
+ * @author Alexander Potochkin
+ * @summary UIDefault.ProxyLazyValue has unsafe reflection usage
+ */
+
+import javax.swing.*;
+
+public class bug6622002 {
+     public static void main(String[] args) {
+
+         if (createPrivateValue() == null) {
+             throw new RuntimeException("The private value unexpectedly wasn't created");
+         }
+         
+         if (createPublicValue() == null) {
+             throw new RuntimeException("The public value unexpectedly wasn't created");
+         }
+         
+         System.setSecurityManager(new SecurityManager());
+         
+         if (createPrivateValue() != null) {
+             throw new RuntimeException("The private value was unexpectedly created");
+         }
+
+         if (createPublicValue() == null) {
+             throw new RuntimeException("The public value unexpectedly wasn't created");
+         }
+     }
+
+    private static Object createPrivateValue() {
+        return new UIDefaults.ProxyLazyValue(
+            "javax.swing.MultiUIDefaults").createValue(null);
+    }
+
+    private static Object createPublicValue() {
+        return new UIDefaults.ProxyLazyValue(
+            "javax.swing.UIDefaults").createValue(null);
+    }
+}