| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| import dalvik.system.VMRuntime; |
| |
| import java.lang.invoke.MethodHandles; |
| import java.lang.invoke.MethodType; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Modifier; |
| import java.util.function.Consumer; |
| |
| import sun.misc.Unsafe; |
| |
| public class ChildClass { |
| enum PrimitiveType { |
| TInteger('I', Integer.TYPE, Integer.valueOf(0)), |
| TLong('J', Long.TYPE, Long.valueOf(0)), |
| TFloat('F', Float.TYPE, Float.valueOf(0)), |
| TDouble('D', Double.TYPE, Double.valueOf(0)), |
| TBoolean('Z', Boolean.TYPE, Boolean.valueOf(false)), |
| TByte('B', Byte.TYPE, Byte.valueOf((byte) 0)), |
| TShort('S', Short.TYPE, Short.valueOf((short) 0)), |
| TCharacter('C', Character.TYPE, Character.valueOf('0')); |
| |
| PrimitiveType(char shorty, Class klass, Object value) { |
| mShorty = shorty; |
| mClass = klass; |
| mDefaultValue = value; |
| } |
| |
| public char mShorty; |
| public Class mClass; |
| public Object mDefaultValue; |
| } |
| |
| enum Hiddenness { |
| Sdk(PrimitiveType.TShort), |
| Unsupported(PrimitiveType.TBoolean), |
| ConditionallyBlocked(PrimitiveType.TByte), |
| Blocklist(PrimitiveType.TCharacter), |
| BlocklistAndCorePlatformApi(PrimitiveType.TInteger); |
| |
| Hiddenness(PrimitiveType type) { mAssociatedType = type; } |
| public PrimitiveType mAssociatedType; |
| } |
| |
| enum Visibility { |
| Public(PrimitiveType.TInteger), |
| Package(PrimitiveType.TFloat), |
| Protected(PrimitiveType.TLong), |
| Private(PrimitiveType.TDouble); |
| |
| Visibility(PrimitiveType type) { mAssociatedType = type; } |
| public PrimitiveType mAssociatedType; |
| } |
| |
| enum Behaviour { |
| Granted, |
| Warning, |
| Denied, |
| } |
| |
| // This needs to be kept in sync with DexDomain in Main. |
| enum DexDomain { |
| CorePlatform, |
| Platform, |
| Application |
| } |
| |
| private static final boolean booleanValues[] = new boolean[] { false, true }; |
| |
| // checkNativeOnly: Only run tests where the caller is in native code - this ChildClass object |
| // is in the core-platform domain when it is true. |
| public static void runTest(String libFileName, int parentDomainOrdinal, int childDomainOrdinal, |
| boolean everythingSdked, boolean checkNativeOnly) throws Exception { |
| System.load(libFileName); |
| |
| DexDomain parentDomain = DexDomain.values()[parentDomainOrdinal]; |
| DexDomain childDomain = DexDomain.values()[childDomainOrdinal]; |
| |
| boolean skipJniTests = false; |
| if (childDomain == DexDomain.Application) { |
| registerAppJniApiCallers(JNI.class); |
| } else if (childDomain == DexDomain.CorePlatform) { |
| registerCorePlatformJniApiCallers(JNI.class); |
| } else { |
| // It's difficult to put a .so in a location that identifies it as the platform domain, so |
| // skip those JNI tests. |
| skipJniTests = true; |
| } |
| |
| int targetSdkVersion = VMRuntime.getRuntime().getTargetSdkVersion(); |
| if (checkNativeOnly) { |
| if (targetSdkVersion != 10000) { |
| throw new RuntimeException( |
| "Expected future targetSdkVersion for native caller tests, got " + targetSdkVersion); |
| } |
| } |
| |
| // Check expectations about loading into boot class path. |
| boolean isParentInBoot = (ParentClass.class.getClassLoader().getParent() == null); |
| boolean expectedParentInBoot = (parentDomain != DexDomain.Application); |
| if (isParentInBoot != expectedParentInBoot) { |
| throw new RuntimeException("Expected ParentClass " + |
| (expectedParentInBoot ? "" : "not ") + "in boot class path"); |
| } |
| boolean isChildInBoot = (ChildClass.class.getClassLoader().getParent() == null); |
| boolean expectedChildInBoot = (childDomain != DexDomain.Application); |
| if (isChildInBoot != expectedChildInBoot && !checkNativeOnly) { |
| throw new RuntimeException("Expected ChildClass " + (expectedChildInBoot ? "" : "not ") + |
| "in boot class path"); |
| } |
| |
| boolean isSameBoot = (expectedParentInBoot == expectedChildInBoot); |
| |
| // For compat reasons, meta-reflection should still be usable by apps if hidden api check |
| // hardening is disabled (i.e. target SDK is Q or earlier). The only configuration where this |
| // workaround used to work is for ChildClass in the Application domain and ParentClass in the |
| // Platform domain, so only test that configuration with hidden api check hardening disabled. |
| boolean testHiddenApiCheckHardeningDisabled = |
| (childDomain == DexDomain.Application) && (parentDomain == DexDomain.Platform); |
| |
| // Run meaningful combinations of access flags. |
| for (Hiddenness hiddenness : Hiddenness.values()) { |
| final Behaviour expected; |
| final boolean invokesMemberCallback; |
| // Warnings are now disabled whenever access is granted, even for |
| // greylisted APIs. This is the behaviour for release builds. |
| if (everythingSdked || hiddenness == Hiddenness.Sdk) { |
| expected = Behaviour.Granted; |
| invokesMemberCallback = false; |
| } else if (parentDomain == DexDomain.CorePlatform && childDomain == DexDomain.Platform) { |
| expected = (hiddenness == Hiddenness.Unsupported |
| || hiddenness == Hiddenness.BlocklistAndCorePlatformApi) |
| ? Behaviour.Granted |
| : Behaviour.Denied; |
| invokesMemberCallback = false; |
| } else if (isSameBoot) { |
| expected = Behaviour.Granted; |
| invokesMemberCallback = false; |
| } else if (hiddenness == Hiddenness.Blocklist || |
| hiddenness == Hiddenness.BlocklistAndCorePlatformApi) { |
| expected = Behaviour.Denied; |
| invokesMemberCallback = true; |
| } else if (hiddenness == Hiddenness.ConditionallyBlocked && targetSdkVersion == 10000) { |
| expected = Behaviour.Denied; |
| invokesMemberCallback = true; // Not applicable when checkNativeOnly is true. |
| } else { |
| expected = Behaviour.Warning; |
| invokesMemberCallback = true; |
| } |
| |
| // Saved variables from the loops below to be shown in the test context if an exception is |
| // thrown. |
| boolean saveIsStatic = false; |
| Visibility saveVisibility = Visibility.Public; |
| Class saveParentClass = null; |
| |
| try { |
| for (boolean isStatic : booleanValues) { |
| saveIsStatic = isStatic; |
| String suffix = (isStatic ? "Static" : "") + hiddenness.name(); |
| |
| for (Visibility visibility : Visibility.values()) { |
| saveVisibility = visibility; |
| // Test reflection and JNI on methods and fields |
| for (Class parentClass : new Class<?>[] {ParentClass.class, ParentInterface.class}) { |
| saveParentClass = parentClass; |
| String baseName = visibility.name() + suffix; |
| checkField(parentClass, "field" + baseName, isStatic, visibility, expected, |
| invokesMemberCallback, testHiddenApiCheckHardeningDisabled, skipJniTests, |
| checkNativeOnly); |
| checkMethod(parentClass, "method" + baseName, isStatic, visibility, expected, |
| invokesMemberCallback, testHiddenApiCheckHardeningDisabled, skipJniTests, |
| checkNativeOnly); |
| } |
| saveParentClass = null; |
| |
| // Check whether one can use a class constructor. |
| checkConstructor(ParentClass.class, visibility, hiddenness, expected, |
| testHiddenApiCheckHardeningDisabled, skipJniTests, checkNativeOnly); |
| |
| // Check whether one can use an interface default method. |
| String name = "method" + visibility.name() + "Default" + hiddenness.name(); |
| checkMethod(ParentInterface.class, name, /*isStatic*/ false, visibility, expected, |
| invokesMemberCallback, testHiddenApiCheckHardeningDisabled, skipJniTests, |
| checkNativeOnly); |
| } |
| |
| if (!checkNativeOnly) { |
| // Test whether static linking succeeds. |
| checkLinking("LinkFieldGet" + suffix, /*takesParameter*/ false, expected); |
| checkLinking("LinkFieldSet" + suffix, /*takesParameter*/ true, expected); |
| checkLinking("LinkMethod" + suffix, /*takesParameter*/ false, expected); |
| checkLinking("LinkMethodInterface" + suffix, /*takesParameter*/ false, expected); |
| } |
| } |
| |
| if (!checkNativeOnly) { |
| // Check whether Class.newInstance succeeds. |
| checkNullaryConstructor( |
| Class.forName("NullaryConstructor" + hiddenness.name()), expected); |
| } |
| } catch (Exception e) { |
| throw new RuntimeException("Exception in test context {parentDomain=" + parentDomain.name() |
| + ", childDomain=" + childDomain.name() + ", everythingSdked=" + everythingSdked |
| + ", checkNativeOnly=" + checkNativeOnly |
| + ", targetSdkVersion=" + targetSdkVersion + ", hiddenness=" + hiddenness |
| + ", expected=" + expected + ", invokesMemberCallback=" + invokesMemberCallback |
| + ", isStatic=" + saveIsStatic + ", visibility=" + saveVisibility |
| + ", parentClass=" + saveParentClass + "}", |
| e); |
| } |
| } |
| } |
| |
| static final class RecordingConsumer implements Consumer<String> { |
| public String recordedValue = null; |
| |
| @Override |
| public void accept(String value) { |
| recordedValue = value; |
| } |
| } |
| |
| private static void checkMemberCallback(Class<?> klass, String name, |
| boolean isPublic, boolean isField, boolean expectedCallback) { |
| try { |
| RecordingConsumer consumer = new RecordingConsumer(); |
| VMRuntime.setNonSdkApiUsageConsumer(consumer); |
| try { |
| if (isPublic) { |
| if (isField) { |
| klass.getField(name); |
| } else { |
| klass.getMethod(name); |
| } |
| } else { |
| if (isField) { |
| klass.getDeclaredField(name); |
| } else { |
| klass.getDeclaredMethod(name); |
| } |
| } |
| } catch (NoSuchFieldException|NoSuchMethodException ignored) { |
| // We're not concerned whether an exception is thrown or not - we're |
| // only interested in whether the callback is invoked. |
| } |
| |
| boolean actualCallback = consumer.recordedValue != null && |
| consumer.recordedValue.contains(name); |
| if (expectedCallback != actualCallback) { |
| if (expectedCallback) { |
| throw new RuntimeException("Expected callback for member: " + name); |
| } else { |
| throw new RuntimeException("Did not expect callback for member: " + name); |
| } |
| } |
| } finally { |
| VMRuntime.setNonSdkApiUsageConsumer(null); |
| } |
| } |
| |
| private static void checkField(Class<?> klass, String name, boolean isStatic, |
| Visibility visibility, Behaviour behaviour, boolean invokesMemberCallback, |
| boolean testHiddenApiCheckHardeningDisabled, boolean skipJniTests, boolean checkNativeOnly) |
| throws Exception { |
| boolean isPublic = (visibility == Visibility.Public); |
| boolean canDiscover = (behaviour != Behaviour.Denied); |
| |
| if (klass.isInterface() && (!isStatic || !isPublic)) { |
| // Interfaces only have public static fields. |
| return; |
| } |
| |
| // Test discovery with JNI. |
| |
| if (!skipJniTests && JNI.canDiscoverField(klass, name, isStatic) != canDiscover) { |
| throwDiscoveryException(klass, name, true, "JNI", canDiscover); |
| } |
| |
| if (!checkNativeOnly) { |
| // Test discovery with reflection. |
| |
| if (Reflection.canDiscoverWithGetDeclaredField(klass, name) != canDiscover) { |
| throwDiscoveryException(klass, name, true, "getDeclaredField()", canDiscover); |
| } |
| |
| if (Reflection.canDiscoverWithGetDeclaredFields(klass, name) != canDiscover) { |
| throwDiscoveryException(klass, name, true, "getDeclaredFields()", canDiscover); |
| } |
| |
| if (Reflection.canDiscoverWithGetField(klass, name) != (canDiscover && isPublic)) { |
| throwDiscoveryException(klass, name, true, "getField()", (canDiscover && isPublic)); |
| } |
| |
| if (Reflection.canDiscoverWithGetFields(klass, name) != (canDiscover && isPublic)) { |
| throwDiscoveryException(klass, name, true, "getFields()", (canDiscover && isPublic)); |
| } |
| |
| // Test discovery with MethodHandles.lookup() which is caller |
| // context sensitive. |
| |
| final MethodHandles.Lookup lookup = MethodHandles.lookup(); |
| if (JLI.canDiscoverWithLookupFindGetter(lookup, klass, name, int.class) != canDiscover) { |
| throwDiscoveryException( |
| klass, name, true, "MethodHandles.lookup().findGetter()", canDiscover); |
| } |
| if (JLI.canDiscoverWithLookupFindStaticGetter(lookup, klass, name, int.class) |
| != canDiscover) { |
| throwDiscoveryException( |
| klass, name, true, "MethodHandles.lookup().findStaticGetter()", canDiscover); |
| } |
| |
| // Test discovery with MethodHandles.publicLookup() which can only |
| // see public fields. Looking up setters here and fields in |
| // interfaces are implicitly final. |
| |
| final MethodHandles.Lookup publicLookup = MethodHandles.publicLookup(); |
| if (JLI.canDiscoverWithLookupFindSetter(publicLookup, klass, name, int.class) |
| != canDiscover) { |
| throwDiscoveryException( |
| klass, name, true, "MethodHandles.publicLookup().findSetter()", canDiscover); |
| } |
| if (JLI.canDiscoverWithLookupFindStaticSetter(publicLookup, klass, name, int.class) |
| != canDiscover) { |
| throwDiscoveryException( |
| klass, name, true, "MethodHandles.publicLookup().findStaticSetter()", canDiscover); |
| } |
| |
| // Check for meta reflection. |
| |
| // With hidden api check hardening enabled, only white and light greylisted fields should be |
| // discoverable. |
| if (Reflection.canDiscoverFieldWithMetaReflection(klass, name, true) != canDiscover) { |
| throwDiscoveryException( |
| klass, name, false, "Meta reflection with hidden api hardening enabled", canDiscover); |
| } |
| |
| if (testHiddenApiCheckHardeningDisabled) { |
| // With hidden api check hardening disabled, all fields should be discoverable. |
| if (Reflection.canDiscoverFieldWithMetaReflection(klass, name, false) != true) { |
| throwDiscoveryException( |
| klass, name, false, "Meta reflection with hidden api hardening enabled", canDiscover); |
| } |
| } |
| } |
| |
| if (canDiscover) { |
| if (!checkNativeOnly) { |
| // Test that modifiers are unaffected. |
| |
| if (Reflection.canObserveFieldHiddenAccessFlags(klass, name)) { |
| throwModifiersException(klass, name, true); |
| } |
| |
| // Test getters and setters when meaningful. |
| |
| if (!Reflection.canGetField(klass, name)) { |
| throwAccessException(klass, name, true, "Field.getInt()"); |
| } |
| if (!isUnmodifiable(klass, name) && !Reflection.canSetField(klass, name)) { |
| throwAccessException(klass, name, true, "Field.setInt()"); |
| } |
| } |
| |
| if (!skipJniTests) { |
| if (!JNI.canGetField(klass, name, isStatic)) { |
| throwAccessException(klass, name, true, "getIntField"); |
| } |
| if (!isUnmodifiable(klass, name) && !JNI.canSetField(klass, name, isStatic)) { |
| throwAccessException(klass, name, true, "setIntField"); |
| } |
| } |
| } |
| |
| // Test that callbacks are invoked correctly. |
| if (!checkNativeOnly) { |
| checkMemberCallback(klass, name, isPublic, true /* isField */, invokesMemberCallback); |
| } |
| } |
| |
| private static final boolean isUnmodifiable(Class<?> klass, String fieldName) throws Exception { |
| Field field = klass.getDeclaredField(fieldName); |
| |
| return Modifier.isFinal(field.getModifiers()) && Modifier.isStatic(field.getModifiers()); |
| } |
| |
| private static void checkMethod(Class<?> klass, String name, boolean isStatic, |
| Visibility visibility, Behaviour behaviour, boolean invokesMemberCallback, |
| boolean testHiddenApiCheckHardeningDisabled, boolean skipJniTests, boolean checkNativeOnly) |
| throws Exception { |
| boolean isPublic = (visibility == Visibility.Public); |
| if (klass.isInterface() && !isPublic) { |
| // All interface members are public. |
| return; |
| } |
| |
| boolean canDiscover = (behaviour != Behaviour.Denied); |
| |
| // Test discovery with JNI. |
| |
| if (!skipJniTests && JNI.canDiscoverMethod(klass, name, isStatic) != canDiscover) { |
| throwDiscoveryException(klass, name, false, "JNI", canDiscover); |
| } |
| |
| if (!checkNativeOnly) { |
| // Test discovery with reflection. |
| |
| if (Reflection.canDiscoverWithGetDeclaredMethod(klass, name) != canDiscover) { |
| throwDiscoveryException(klass, name, false, "getDeclaredMethod()", canDiscover); |
| } |
| |
| if (Reflection.canDiscoverWithGetDeclaredMethods(klass, name) != canDiscover) { |
| throwDiscoveryException(klass, name, false, "getDeclaredMethods()", canDiscover); |
| } |
| |
| if (Reflection.canDiscoverWithGetMethod(klass, name) != (canDiscover && isPublic)) { |
| throwDiscoveryException(klass, name, false, "getMethod()", (canDiscover && isPublic)); |
| } |
| |
| if (Reflection.canDiscoverWithGetMethods(klass, name) != (canDiscover && isPublic)) { |
| throwDiscoveryException(klass, name, false, "getMethods()", (canDiscover && isPublic)); |
| } |
| |
| // Test discovery with MethodHandles.lookup(). |
| |
| final MethodHandles.Lookup lookup = MethodHandles.lookup(); |
| final MethodType methodType = MethodType.methodType(int.class); |
| if (JLI.canDiscoverWithLookupFindVirtual(lookup, klass, name, methodType) != canDiscover) { |
| throwDiscoveryException( |
| klass, name, false, "MethodHandles.lookup().findVirtual()", canDiscover); |
| } |
| |
| if (JLI.canDiscoverWithLookupFindStatic(lookup, klass, name, methodType) != canDiscover) { |
| throwDiscoveryException( |
| klass, name, false, "MethodHandles.lookup().findStatic()", canDiscover); |
| } |
| |
| // Check for meta reflection. |
| |
| // With hidden api check hardening enabled, only white and light greylisted methods should be |
| // discoverable. |
| if (Reflection.canDiscoverMethodWithMetaReflection(klass, name, true) != canDiscover) { |
| throwDiscoveryException( |
| klass, name, false, "Meta reflection with hidden api hardening enabled", canDiscover); |
| } |
| |
| if (testHiddenApiCheckHardeningDisabled) { |
| // With hidden api check hardening disabled, all methods should be discoverable. |
| if (Reflection.canDiscoverMethodWithMetaReflection(klass, name, false) != true) { |
| throwDiscoveryException( |
| klass, name, false, "Meta reflection with hidden api hardening enabled", canDiscover); |
| } |
| } |
| } |
| |
| // Finish here if we could not discover the method. |
| |
| if (canDiscover) { |
| // Test that modifiers are unaffected. |
| |
| if (!checkNativeOnly && Reflection.canObserveMethodHiddenAccessFlags(klass, name)) { |
| throwModifiersException(klass, name, false); |
| } |
| |
| // Test whether we can invoke the method. This skips non-static interface methods. |
| if (!klass.isInterface() || isStatic) { |
| if (!checkNativeOnly && !Reflection.canInvokeMethod(klass, name)) { |
| throwAccessException(klass, name, false, "invoke()"); |
| } |
| if (!skipJniTests) { |
| if (!JNI.canInvokeMethodA(klass, name, isStatic)) { |
| throwAccessException(klass, name, false, "CallMethodA"); |
| } |
| if (!JNI.canInvokeMethodV(klass, name, isStatic)) { |
| throwAccessException(klass, name, false, "CallMethodV"); |
| } |
| } |
| } |
| } |
| |
| // Test that callbacks are invoked correctly. |
| if (!checkNativeOnly) { |
| checkMemberCallback(klass, name, isPublic, false /* isField */, invokesMemberCallback); |
| } |
| } |
| |
| private static void checkConstructor(Class<?> klass, Visibility visibility, Hiddenness hiddenness, |
| Behaviour behaviour, boolean testHiddenApiCheckHardeningDisabled, boolean skipJniTests, |
| boolean checkNativeOnly) throws Exception { |
| boolean isPublic = (visibility == Visibility.Public); |
| String signature = "(" + visibility.mAssociatedType.mShorty + |
| hiddenness.mAssociatedType.mShorty + ")V"; |
| String fullName = "<init>" + signature; |
| Class<?> args[] = new Class[] { visibility.mAssociatedType.mClass, |
| hiddenness.mAssociatedType.mClass }; |
| Object initargs[] = new Object[] { visibility.mAssociatedType.mDefaultValue, |
| hiddenness.mAssociatedType.mDefaultValue }; |
| MethodType methodType = MethodType.methodType(void.class, args); |
| |
| boolean canDiscover = (behaviour != Behaviour.Denied); |
| |
| // Test discovery with JNI. |
| |
| if (!skipJniTests && JNI.canDiscoverConstructor(klass, signature) != canDiscover) { |
| throwDiscoveryException(klass, fullName, false, "JNI", canDiscover); |
| } |
| |
| if (!checkNativeOnly) { |
| // Test discovery with reflection. |
| |
| if (Reflection.canDiscoverWithGetDeclaredConstructor(klass, args) != canDiscover) { |
| throwDiscoveryException(klass, fullName, false, "getDeclaredConstructor()", canDiscover); |
| } |
| |
| if (Reflection.canDiscoverWithGetDeclaredConstructors(klass, args) != canDiscover) { |
| throwDiscoveryException(klass, fullName, false, "getDeclaredConstructors()", canDiscover); |
| } |
| |
| if (Reflection.canDiscoverWithGetConstructor(klass, args) != (canDiscover && isPublic)) { |
| throwDiscoveryException( |
| klass, fullName, false, "getConstructor()", (canDiscover && isPublic)); |
| } |
| |
| if (Reflection.canDiscoverWithGetConstructors(klass, args) != (canDiscover && isPublic)) { |
| throwDiscoveryException( |
| klass, fullName, false, "getConstructors()", (canDiscover && isPublic)); |
| } |
| |
| // Test discovery with MethodHandles.lookup() |
| |
| final MethodHandles.Lookup lookup = MethodHandles.lookup(); |
| if (JLI.canDiscoverWithLookupFindConstructor(lookup, klass, methodType) != canDiscover) { |
| throwDiscoveryException( |
| klass, fullName, false, "MethodHandles.lookup().findConstructor", canDiscover); |
| } |
| |
| final MethodHandles.Lookup publicLookup = MethodHandles.publicLookup(); |
| if (JLI.canDiscoverWithLookupFindConstructor(publicLookup, klass, methodType) |
| != canDiscover) { |
| throwDiscoveryException( |
| klass, fullName, false, "MethodHandles.publicLookup().findConstructor", canDiscover); |
| } |
| |
| // Check for meta reflection. |
| |
| // With hidden api check hardening enabled, only white and light greylisted constructors |
| // should be discoverable. |
| if (Reflection.canDiscoverConstructorWithMetaReflection(klass, args, true) != canDiscover) { |
| throwDiscoveryException(klass, fullName, false, |
| "Meta reflection with hidden api hardening enabled", canDiscover); |
| } |
| |
| if (testHiddenApiCheckHardeningDisabled) { |
| // With hidden api check hardening disabled, all constructors should be discoverable. |
| if (Reflection.canDiscoverConstructorWithMetaReflection(klass, args, false) != true) { |
| throwDiscoveryException(klass, fullName, false, |
| "Meta reflection with hidden api hardening enabled", canDiscover); |
| } |
| } |
| } |
| |
| if (canDiscover) { |
| // Test whether we can invoke the constructor. |
| |
| if (!checkNativeOnly && !Reflection.canInvokeConstructor(klass, args, initargs)) { |
| throwAccessException(klass, fullName, false, "invoke()"); |
| } |
| if (!skipJniTests) { |
| if (!JNI.canInvokeConstructorA(klass, signature)) { |
| throwAccessException(klass, fullName, false, "NewObjectA"); |
| } |
| if (!JNI.canInvokeConstructorV(klass, signature)) { |
| throwAccessException(klass, fullName, false, "NewObjectV"); |
| } |
| } |
| } |
| } |
| |
| private static void checkNullaryConstructor(Class<?> klass, Behaviour behaviour) |
| throws Exception { |
| boolean canAccess = (behaviour != Behaviour.Denied); |
| |
| if (Reflection.canUseNewInstance(klass) != canAccess) { |
| throw new RuntimeException( |
| "Expected to " + (canAccess ? "" : "not ") + "be able to construct " + klass.getName()); |
| } |
| } |
| |
| private static void checkLinking(String className, boolean takesParameter, Behaviour behaviour) |
| throws Exception { |
| boolean canAccess = (behaviour != Behaviour.Denied); |
| |
| if (Linking.canAccess(className, takesParameter) != canAccess) { |
| throw new RuntimeException( |
| "Expected to " + (canAccess ? "" : "not ") + "be able to verify " + className); |
| } |
| } |
| |
| private static void throwDiscoveryException(Class<?> klass, String name, boolean isField, |
| String fn, boolean canAccess) { |
| throw new RuntimeException("Expected " + (isField ? "field " : "method ") + klass.getName() |
| + "." + name + " to " + (canAccess ? "" : "not ") + "be discoverable with " + fn); |
| } |
| |
| private static void throwAccessException(Class<?> klass, String name, boolean isField, |
| String fn) { |
| throw new RuntimeException("Expected to be able to access " + (isField ? "field " : "method ") |
| + klass.getName() + "." + name + " using " + fn); |
| } |
| |
| private static void throwModifiersException(Class<?> klass, String name, boolean isField) { |
| throw new RuntimeException("Expected " + (isField ? "field " : "method ") + klass.getName() + |
| "." + name + " to not expose hidden modifiers"); |
| } |
| |
| private static native void registerCorePlatformJniApiCallers(Class targetClass); |
| private static native void registerAppJniApiCallers(Class targetClass); |
| |
| // Check a few real symbols that HiddenApiSdk28AppTest depends on being inaccessible from platform |
| // to core-platform, to avoid false negatives. Only called when ChildClass is in the platform |
| // domain. |
| public static void checkNonCorePlatformApis() { |
| try { |
| Field f = Byte.class.getDeclaredField("value"); |
| throw new RuntimeException("Expected java.lang.Byte.value to be inaccessible from platform"); |
| } catch (NoSuchFieldException expected) { |
| } |
| try { |
| Method m = |
| Unsafe.class.getDeclaredMethod("getAndAddInt", Object.class, Long.class, Integer.class); |
| throw new RuntimeException( |
| "Expected sun.misc.Unsafe.getAndAddInt to be inaccessible from platform"); |
| } catch (NoSuchMethodException expected) { |
| } |
| } |
| } |
