src/java.base/share/classes/sun/invoke/util/VerifyAccess.java

*** 1,7 ***
  /*
!  * Copyright (c) 2008, 2021, 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.  Oracle designates this
--- 1,7 ---
  /*
!  * Copyright (c) 2008, 2022, 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.  Oracle designates this

*** 25,11 ***
--- 25,13 ---
  
  package sun.invoke.util;
  
  import java.lang.reflect.Modifier;
  import static java.lang.reflect.Modifier.*;
+ 
  import jdk.internal.reflect.Reflection;
+ import jdk.internal.value.PrimitiveClass;
  
  /**
   * This class centralizes information about the JVM's linkage access control.
   * @author jrose
   */

*** 103,11 ***
          // The symbolic reference class (refc) must always be fully verified.
          if (!isClassAccessible(refc, lookupClass, prevLookupClass, allowedModes)) {
              return false;
          }
          // Usually refc and defc are the same, but verify defc also in case they differ.
!         if (defc == lookupClass  &&
              (allowedModes & PRIVATE) != 0)
              return true;        // easy check; all self-access is OK with a private lookup
  
          switch (mods & ALL_ACCESS_MODES) {
          case PUBLIC:
--- 105,11 ---
          // The symbolic reference class (refc) must always be fully verified.
          if (!isClassAccessible(refc, lookupClass, prevLookupClass, allowedModes)) {
              return false;
          }
          // Usually refc and defc are the same, but verify defc also in case they differ.
!         if (PrimitiveClass.asPrimaryType(defc) == lookupClass  &&
              (allowedModes & PRIVATE) != 0)
              return true;        // easy check; all self-access is OK with a private lookup
  
          switch (mods & ALL_ACCESS_MODES) {
          case PUBLIC:

*** 138,19 ***
              // Rules for privates follows access rules for nestmates.
              boolean canAccess = ((allowedModes & PRIVATE) != 0 &&
                                   Reflection.areNestMates(defc, lookupClass));
              // for private methods the selected method equals the
              // resolved method - so refc == defc
!             assert (canAccess && refc == defc) || !canAccess;
              return canAccess;
          default:
              throw new IllegalArgumentException("bad modifiers: "+Modifier.toString(mods));
          }
      }
  
      static boolean isRelatedClass(Class<?> refc, Class<?> lookupClass) {
!         return (refc == lookupClass ||
                  isSubClass(refc, lookupClass) ||
                  isSubClass(lookupClass, refc));
      }
  
      static boolean isSubClass(Class<?> lookupClass, Class<?> defc) {
--- 140,19 ---
              // Rules for privates follows access rules for nestmates.
              boolean canAccess = ((allowedModes & PRIVATE) != 0 &&
                                   Reflection.areNestMates(defc, lookupClass));
              // for private methods the selected method equals the
              // resolved method - so refc == defc
!             assert (canAccess && PrimitiveClass.asPrimaryType(refc) == PrimitiveClass.asPrimaryType(defc)) || !canAccess;
              return canAccess;
          default:
              throw new IllegalArgumentException("bad modifiers: "+Modifier.toString(mods));
          }
      }
  
      static boolean isRelatedClass(Class<?> refc, Class<?> lookupClass) {
!         return (PrimitiveClass.asPrimaryType(refc) == PrimitiveClass.asPrimaryType(lookupClass) ||
                  isSubClass(refc, lookupClass) ||
                  isSubClass(lookupClass, refc));
      }
  
      static boolean isSubClass(Class<?> lookupClass, Class<?> defc) {

*** 271,11 ***
       * reference of a given reference class, is really visible to that class.
       * @param type the supposed type of a member or symbolic reference of refc
       * @param refc the class attempting to make the reference
       */
      public static boolean isTypeVisible(Class<?> type, Class<?> refc) {
!         if (type == refc) {
              return true;  // easy check
          }
          while (type.isArray())  type = type.getComponentType();
          if (type.isPrimitive() || type == Object.class) {
              return true;
--- 273,11 ---
       * reference of a given reference class, is really visible to that class.
       * @param type the supposed type of a member or symbolic reference of refc
       * @param refc the class attempting to make the reference
       */
      public static boolean isTypeVisible(Class<?> type, Class<?> refc) {
!         if (PrimitiveClass.asPrimaryType(type) == PrimitiveClass.asPrimaryType(refc)) {
              return true;  // easy check
          }
          while (type.isArray())  type = type.getComponentType();
          if (type.isPrimitive() || type == Object.class) {
              return true;

*** 319,10 ***
--- 321,11 ---
          // type ("type") and then is discarded.  Thus, the worst that can happen to
          // the "child" class loader is that it is bothered to load and report a class
          // that differs from "type"; this happens once due to JVM system dictionary
          // memoization.  And the caller never gets to look at the alternate type binding
          // ("res"), whether it exists or not.
+ 
          final String name = type.getName();
          @SuppressWarnings("removal")
          Class<?> res = java.security.AccessController.doPrivileged(
                  new java.security.PrivilegedAction<>() {
                      public Class<?> run() {

*** 331,11 ***
                          } catch (ClassNotFoundException | LinkageError e) {
                              return null; // Assume the class is not found
                          }
                      }
              });
!         return (type == res);
      }
  
      /**
       * Decide if the given method type, attributed to a member or symbolic
       * reference of a given reference class, is really visible to that class.
--- 334,11 ---
                          } catch (ClassNotFoundException | LinkageError e) {
                              return null; // Assume the class is not found
                          }
                      }
              });
!         return (PrimitiveClass.asPrimaryType(type) == res);
      }
  
      /**
       * Decide if the given method type, attributed to a member or symbolic
       * reference of a given reference class, is really visible to that class.