1 /*

     2  * Copyright (c) 2002, 2018, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package jdk.internal.misc;

    27 

    28 import javax.crypto.SealedObject;

    29 import java.io.ObjectInputFilter;

    30 import java.lang.module.ModuleDescriptor;

    31 import java.util.ResourceBundle;

    32 import java.util.jar.JarFile;

    33 import java.io.Console;

    34 import java.io.FileDescriptor;

    35 import java.io.FilePermission;

    36 import java.io.ObjectInputStream;

    37 import java.io.RandomAccessFile;

    38 import java.security.ProtectionDomain;

    39 

    40 /** A repository of "shared secrets", which are a mechanism for

    41     calling implementation-private methods in another package without

    42     using reflection. A package-private class implements a public

    43     interface and provides the ability to call package-private methods

    44     within that package; the object implementing that interface is

    45     provided through a third package to which access is restricted.

    46     This framework avoids the primary disadvantage of using reflection

    47     for this purpose, namely the loss of compile-time checking. */

    48 

    49 public class SharedSecrets {

    50     private static final Unsafe unsafe = Unsafe.getUnsafe();

    51     private static JavaUtilJarAccess javaUtilJarAccess;

    52     private static JavaLangAccess javaLangAccess;

    53     private static JavaLangModuleAccess javaLangModuleAccess;

    54     private static JavaLangInvokeAccess javaLangInvokeAccess;

    55     private static JavaLangRefAccess javaLangRefAccess;

    56     private static JavaIOAccess javaIOAccess;

    57     private static JavaNetInetAddressAccess javaNetInetAddressAccess;

    58     private static JavaNetHttpCookieAccess javaNetHttpCookieAccess;

    59     private static JavaNetSocketAccess javaNetSocketAccess;

    60     private static JavaNetUriAccess javaNetUriAccess;

    61     private static JavaNetURLAccess javaNetURLAccess;

    62     private static JavaNetURLClassLoaderAccess javaNetURLClassLoaderAccess;

    63     private static JavaNioAccess javaNioAccess;

    64     private static JavaIOFileDescriptorAccess javaIOFileDescriptorAccess;

    65     private static JavaIOFilePermissionAccess javaIOFilePermissionAccess;

    66     private static JavaSecurityAccess javaSecurityAccess;

    67     private static JavaUtilZipFileAccess javaUtilZipFileAccess;

    68     private static JavaUtilResourceBundleAccess javaUtilResourceBundleAccess;

    69     private static JavaAWTAccess javaAWTAccess;

    70     private static JavaAWTFontAccess javaAWTFontAccess;

    71     private static JavaBeansAccess javaBeansAccess;

    72     private static JavaObjectInputStreamAccess javaObjectInputStreamAccess;

    73     private static JavaObjectInputFilterAccess javaObjectInputFilterAccess;

    74     private static JavaIORandomAccessFileAccess javaIORandomAccessFileAccess;

    75     private static JavaxCryptoSealedObjectAccess javaxCryptoSealedObjectAccess;

    76 

    77     public static JavaUtilJarAccess javaUtilJarAccess() {

    78         if (javaUtilJarAccess == null) {

    79             // Ensure JarFile is initialized; we know that that class

    80             // provides the shared secret

    81             unsafe.ensureClassInitialized(JarFile.class);

    82         }

    83         return javaUtilJarAccess;

    84     }

    85 

    86     public static void setJavaUtilJarAccess(JavaUtilJarAccess access) {

    87         javaUtilJarAccess = access;

    88     }

    89 

    90     public static void setJavaLangAccess(JavaLangAccess jla) {

    91         javaLangAccess = jla;

    92     }

    93 

    94     public static JavaLangAccess getJavaLangAccess() {

    95         return javaLangAccess;

    96     }

    97 

    98     public static void setJavaLangInvokeAccess(JavaLangInvokeAccess jlia) {

    99         javaLangInvokeAccess = jlia;

   100     }

   101 

   102     public static JavaLangInvokeAccess getJavaLangInvokeAccess() {

   103         if (javaLangInvokeAccess == null) {

   104             try {

   105                 Class<?> c = Class.forName("java.lang.invoke.MethodHandleImpl");

   106                 unsafe.ensureClassInitialized(c);

   107             } catch (ClassNotFoundException e) {};

   108         }

   109         return javaLangInvokeAccess;

   110     }

   111 

   112     public static void setJavaLangModuleAccess(JavaLangModuleAccess jlrma) {

   113         javaLangModuleAccess = jlrma;

   114     }

   115 

   116     public static JavaLangModuleAccess getJavaLangModuleAccess() {

   117         if (javaLangModuleAccess == null) {

   118             unsafe.ensureClassInitialized(ModuleDescriptor.class);

   119         }

   120         return javaLangModuleAccess;

   121     }

   122 

   123     public static void setJavaLangRefAccess(JavaLangRefAccess jlra) {

   124         javaLangRefAccess = jlra;

   125     }

   126 

   127     public static JavaLangRefAccess getJavaLangRefAccess() {

   128         return javaLangRefAccess;

   129     }

   130 

   131     public static void setJavaNetUriAccess(JavaNetUriAccess jnua) {

   132         javaNetUriAccess = jnua;

   133     }

   134 

   135     public static JavaNetUriAccess getJavaNetUriAccess() {

   136         if (javaNetUriAccess == null)

   137             unsafe.ensureClassInitialized(java.net.URI.class);

   138         return javaNetUriAccess;

   139     }

   140 

   141     public static void setJavaNetURLAccess(JavaNetURLAccess jnua) {

   142         javaNetURLAccess = jnua;

   143     }

   144 

   145     public static JavaNetURLAccess getJavaNetURLAccess() {

   146         if (javaNetURLAccess == null)

   147             unsafe.ensureClassInitialized(java.net.URL.class);

   148         return javaNetURLAccess;

   149     }

   150 

   151     public static void setJavaNetURLClassLoaderAccess(JavaNetURLClassLoaderAccess jnua) {

   152         javaNetURLClassLoaderAccess = jnua;

   153     }

   154 

   155     public static JavaNetURLClassLoaderAccess getJavaNetURLClassLoaderAccess() {

   156         if (javaNetURLClassLoaderAccess == null)

   157             unsafe.ensureClassInitialized(java.net.URLClassLoader.class);

   158         return javaNetURLClassLoaderAccess;

   159     }

   160 

   161     public static void setJavaNetInetAddressAccess(JavaNetInetAddressAccess jna) {

   162         javaNetInetAddressAccess = jna;

   163     }

   164 

   165     public static JavaNetInetAddressAccess getJavaNetInetAddressAccess() {

   166         if (javaNetInetAddressAccess == null)

   167             unsafe.ensureClassInitialized(java.net.InetAddress.class);

   168         return javaNetInetAddressAccess;

   169     }

   170 

   171     public static void setJavaNetHttpCookieAccess(JavaNetHttpCookieAccess a) {

   172         javaNetHttpCookieAccess = a;

   173     }

   174 

   175     public static JavaNetHttpCookieAccess getJavaNetHttpCookieAccess() {

   176         if (javaNetHttpCookieAccess == null)

   177             unsafe.ensureClassInitialized(java.net.HttpCookie.class);

   178         return javaNetHttpCookieAccess;

   179     }

   180 

   181     public static void setJavaNetSocketAccess(JavaNetSocketAccess jnsa) {

   182         javaNetSocketAccess = jnsa;

   183     }

   184 

   185     public static JavaNetSocketAccess getJavaNetSocketAccess() {

   186         if (javaNetSocketAccess == null)

   187             unsafe.ensureClassInitialized(java.net.ServerSocket.class);

   188         return javaNetSocketAccess;

   189     }

   190 

   191     public static void setJavaNioAccess(JavaNioAccess jna) {

   192         javaNioAccess = jna;

   193     }

   194 

   195     public static JavaNioAccess getJavaNioAccess() {

   196         if (javaNioAccess == null) {

   197             // Ensure java.nio.Buffer is initialized, which provides the

   198             // shared secret.

   199             unsafe.ensureClassInitialized(java.nio.Buffer.class);

   200         }

   201         return javaNioAccess;

   202     }

   203 

   204     public static void setJavaIOAccess(JavaIOAccess jia) {

   205         javaIOAccess = jia;

   206     }

   207 

   208     public static JavaIOAccess getJavaIOAccess() {

   209         if (javaIOAccess == null) {

   210             unsafe.ensureClassInitialized(Console.class);

   211         }

   212         return javaIOAccess;

   213     }

   214 

   215     public static void setJavaIOFileDescriptorAccess(JavaIOFileDescriptorAccess jiofda) {

   216         javaIOFileDescriptorAccess = jiofda;

   217     }

   218 

   219     public static JavaIOFilePermissionAccess getJavaIOFilePermissionAccess() {

   220         if (javaIOFilePermissionAccess == null)

   221             unsafe.ensureClassInitialized(FilePermission.class);

   222 

   223         return javaIOFilePermissionAccess;

   224     }

   225 

   226     public static void setJavaIOFilePermissionAccess(JavaIOFilePermissionAccess jiofpa) {

   227         javaIOFilePermissionAccess = jiofpa;

   228     }

   229 

   230     public static JavaIOFileDescriptorAccess getJavaIOFileDescriptorAccess() {

   231         if (javaIOFileDescriptorAccess == null)

   232             unsafe.ensureClassInitialized(FileDescriptor.class);

   233 

   234         return javaIOFileDescriptorAccess;

   235     }

   236 

   237     public static void setJavaSecurityAccess(JavaSecurityAccess jsa) {

   238         javaSecurityAccess = jsa;

   239     }

   240 

   241     public static JavaSecurityAccess getJavaSecurityAccess() {

   242         if (javaSecurityAccess == null) {

   243             unsafe.ensureClassInitialized(ProtectionDomain.class);

   244         }

   245         return javaSecurityAccess;

   246     }

   247 

   248     public static JavaUtilZipFileAccess getJavaUtilZipFileAccess() {

   249         if (javaUtilZipFileAccess == null)

   250             unsafe.ensureClassInitialized(java.util.zip.ZipFile.class);

   251         return javaUtilZipFileAccess;

   252     }

   253 

   254     public static void setJavaUtilZipFileAccess(JavaUtilZipFileAccess access) {

   255         javaUtilZipFileAccess = access;

   256     }

   257 

   258     public static void setJavaAWTAccess(JavaAWTAccess jaa) {

   259         javaAWTAccess = jaa;

   260     }

   261 

   262     public static JavaAWTAccess getJavaAWTAccess() {

   263         // this may return null in which case calling code needs to

   264         // provision for.

   265         return javaAWTAccess;

   266     }

   267 

   268     public static void setJavaAWTFontAccess(JavaAWTFontAccess jafa) {

   269         javaAWTFontAccess = jafa;

   270     }

   271 

   272     public static JavaAWTFontAccess getJavaAWTFontAccess() {

   273         // this may return null in which case calling code needs to

   274         // provision for.

   275         return javaAWTFontAccess;

   276     }

   277 

   278     public static JavaBeansAccess getJavaBeansAccess() {

   279         return javaBeansAccess;

   280     }

   281 

   282     public static void setJavaBeansAccess(JavaBeansAccess access) {

   283         javaBeansAccess = access;

   284     }

   285 

   286     public static JavaUtilResourceBundleAccess getJavaUtilResourceBundleAccess() {

   287         if (javaUtilResourceBundleAccess == null)

   288             unsafe.ensureClassInitialized(ResourceBundle.class);

   289         return javaUtilResourceBundleAccess;

   290     }

   291 

   292     public static void setJavaUtilResourceBundleAccess(JavaUtilResourceBundleAccess access) {

   293         javaUtilResourceBundleAccess = access;

   294     }

   295 

   296     public static JavaObjectInputStreamAccess getJavaObjectInputStreamAccess() {

   297         if (javaObjectInputStreamAccess == null) {

   298             unsafe.ensureClassInitialized(ObjectInputStream.class);

   299         }

   300         return javaObjectInputStreamAccess;

   301     }

   302 

   303     public static void setJavaObjectInputStreamAccess(JavaObjectInputStreamAccess access) {

   304         javaObjectInputStreamAccess = access;

   305     }

   306 

   307     public static JavaObjectInputFilterAccess getJavaObjectInputFilterAccess() {

   308         if (javaObjectInputFilterAccess == null) {

   309             unsafe.ensureClassInitialized(ObjectInputFilter.Config.class);

   310         }

   311         return javaObjectInputFilterAccess;

   312     }

   313 

   314     public static void setJavaObjectInputFilterAccess(JavaObjectInputFilterAccess access) {

   315         javaObjectInputFilterAccess = access;

   316     }

   317 

   318     public static void setJavaIORandomAccessFileAccess(JavaIORandomAccessFileAccess jirafa) {

   319         javaIORandomAccessFileAccess = jirafa;

   320     }

   321 

   322     public static JavaIORandomAccessFileAccess getJavaIORandomAccessFileAccess() {

   323         if (javaIORandomAccessFileAccess == null) {

   324             unsafe.ensureClassInitialized(RandomAccessFile.class);

   325         }

   326         return javaIORandomAccessFileAccess;

   327     }

   328 

   329     public static void setJavaxCryptoSealedObjectAccess(JavaxCryptoSealedObjectAccess jcsoa) {

   330         javaxCryptoSealedObjectAccess = jcsoa;

   331     }

   332 

   333     public static JavaxCryptoSealedObjectAccess getJavaxCryptoSealedObjectAccess() {

   334         if (javaxCryptoSealedObjectAccess == null) {

   335             unsafe.ensureClassInitialized(SealedObject.class);

   336         }

   337         return javaxCryptoSealedObjectAccess;

   338     }

   339 }