| /* |
| * 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. |
| */ |
| |
| package com.android.tools.lint.checks |
| |
| import com.android.sdklib.AndroidVersion |
| import com.android.tools.lint.client.api.LintClient |
| import com.android.tools.lint.detector.api.Category |
| import com.android.tools.lint.detector.api.ConstantEvaluator |
| import com.android.tools.lint.detector.api.Context |
| import com.android.tools.lint.detector.api.Detector |
| import com.android.tools.lint.detector.api.Implementation |
| import com.android.tools.lint.detector.api.Issue |
| import com.android.tools.lint.detector.api.JavaContext |
| import com.android.tools.lint.detector.api.Scope |
| import com.android.tools.lint.detector.api.Severity |
| import com.android.tools.lint.detector.api.SourceCodeScanner |
| import com.android.tools.lint.detector.api.TypeEvaluator |
| import com.android.tools.lint.detector.api.UastLintUtils |
| import com.intellij.psi.PsiClassType |
| import com.intellij.psi.PsiElement |
| import com.intellij.psi.PsiElementFactory |
| import com.intellij.psi.PsiMethod |
| import com.intellij.psi.PsiPrimitiveType |
| import com.intellij.psi.PsiType |
| import com.intellij.psi.PsiVariable |
| import org.jetbrains.uast.UCallExpression |
| import org.jetbrains.uast.UClassLiteralExpression |
| import org.jetbrains.uast.UElement |
| import org.jetbrains.uast.UExpression |
| import org.jetbrains.uast.UQualifiedReferenceExpression |
| import org.jetbrains.uast.UReferenceExpression |
| import org.jetbrains.uast.USimpleNameReferenceExpression |
| |
| /** |
| * Checks that the code is not using reflection to access hidden Android APIs |
| */ |
| class PrivateApiDetector : Detector(), SourceCodeScanner { |
| companion object Issues { |
| /** Using hidden/private APIs */ |
| @JvmField |
| val PRIVATE_API = Issue.create( |
| id = "PrivateApi", |
| briefDescription = "Using Private APIs", |
| explanation = """ |
| Using reflection to access hidden/private Android APIs is not safe; it will often not work on \ |
| devices from other vendors, and it may suddenly stop working (if the API is removed) or crash \ |
| spectacularly (if the API behavior changes, since there are no guarantees for compatibility). |
| """, |
| moreInfo = "https://developer.android.com/preview/restrictions-non-sdk-interfaces", |
| category = Category.CORRECTNESS, |
| priority = 6, |
| severity = Severity.WARNING, |
| androidSpecific = true, |
| implementation = Implementation( |
| PrivateApiDetector::class.java, |
| Scope.JAVA_FILE_SCOPE |
| ) |
| ) |
| |
| @JvmField |
| val DISCOURAGED_PRIVATE_API = Issue.create( |
| id = "DiscouragedPrivateApi", |
| briefDescription = "Using Discouraged Private API", |
| explanation = """ |
| Usage of restricted non-SDK interface may throw an exception at runtime. Accessing \ |
| non-SDK methods or fields through reflection has a high likelihood to break your app \ |
| between versions, and is being restricted to facilitate future app compatibility. |
| """, |
| moreInfo = "https://developer.android.com/preview/restrictions-non-sdk-interfaces", |
| category = Category.CORRECTNESS, |
| priority = 6, |
| severity = Severity.WARNING, |
| androidSpecific = true, |
| implementation = Implementation( |
| PrivateApiDetector::class.java, |
| Scope.JAVA_FILE_SCOPE |
| ) |
| ) |
| |
| @JvmField |
| val SOON_BLOCKED_PRIVATE_API = Issue.create( |
| id = "SoonBlockedPrivateApi", |
| briefDescription = "Using Soon-to-Be Blocked Private API", |
| explanation = """ |
| Usage of restricted non-SDK interface will throw an exception at runtime. Accessing \ |
| non-SDK methods or fields through reflection has a high likelihood to break your app \ |
| between versions, and is being restricted to facilitate future app compatibility. |
| """, |
| moreInfo = "https://developer.android.com/preview/restrictions-non-sdk-interfaces", |
| category = Category.CORRECTNESS, |
| priority = 6, |
| severity = Severity.ERROR, |
| androidSpecific = true, |
| implementation = Implementation( |
| PrivateApiDetector::class.java, |
| Scope.JAVA_FILE_SCOPE |
| ) |
| ) |
| |
| @JvmField |
| val BLOCKED_PRIVATE_API = Issue.create( |
| id = "BlockedPrivateApi", |
| briefDescription = "Using Blocked Private API", |
| explanation = """ |
| Usage of restricted non-SDK interface is forbidden for this targetSDK. Accessing \ |
| non-SDK methods or fields through reflection has a high likelihood to break your app \ |
| between versions, and is being restricted to facilitate future app compatibility. |
| """, |
| moreInfo = "https://developer.android.com/preview/restrictions-non-sdk-interfaces", |
| category = Category.CORRECTNESS, |
| priority = 6, |
| severity = Severity.FATAL, |
| androidSpecific = true, |
| implementation = Implementation( |
| PrivateApiDetector::class.java, |
| Scope.JAVA_FILE_SCOPE |
| ) |
| ) |
| |
| private const val LOAD_CLASS = "loadClass" |
| private const val FOR_NAME = "forName" |
| private const val GET_CLASS = "getClass" |
| private const val GET_DECLARED_CONSTRUCTOR = "getDeclaredConstructor" |
| private const val GET_DECLARED_METHOD = "getDeclaredMethod" |
| private const val GET_DECLARED_FIELD = "getDeclaredField" |
| private val KOTLIN_REFLECTION_METHODS = listOf( |
| "members", // this is available in kotlin-stdlib, the rest are in kotlin-reflect |
| "declaredMembers", |
| "declaredFunctions", |
| "declaredMemberFunctions", |
| "declaredMemberProperties" |
| ) |
| private const val ERROR_MESSAGE = "Accessing internal APIs via reflection is not " + |
| "supported and may not work on all devices or in the future" |
| } |
| |
| private var client: LintClient? = null |
| private var psiFactory: PsiElementFactory? = null |
| |
| // Only initialize private API database on demand, at most once per Lint session. |
| private var cachedApiDatabase: Boolean = false |
| private var privateApiDatabase: PrivateApiLookup? = null |
| private val apiDatabase: PrivateApiLookup? |
| get() { |
| if (!cachedApiDatabase && privateApiDatabase == null && client != null) { |
| privateApiDatabase = PrivateApiLookup.get(client!!) |
| cachedApiDatabase = true |
| } |
| return privateApiDatabase |
| } |
| |
| override fun beforeCheckRootProject(context: Context) { |
| client = context.client |
| cachedApiDatabase = false |
| psiFactory = PsiElementFactory.getInstance(context.project.ideaProject) |
| } |
| |
| // ---- Implements JavaPsiScanner ---- |
| |
| override fun getApplicableMethodNames(): List<String>? = |
| listOf( |
| FOR_NAME, |
| LOAD_CLASS, |
| GET_DECLARED_CONSTRUCTOR, |
| GET_DECLARED_METHOD, |
| GET_DECLARED_FIELD |
| ) |
| |
| override fun getApplicableReferenceNames(): List<String>? = KOTLIN_REFLECTION_METHODS |
| |
| override fun visitMethodCall(context: JavaContext, node: UCallExpression, method: PsiMethod) { |
| val evaluator = context.evaluator |
| if (LOAD_CLASS == method.name) { |
| if (evaluator.isMemberInClass(method, "java.lang.ClassLoader") || |
| evaluator.isMemberInClass(method, "dalvik.system.DexFile") |
| ) { |
| checkLoadClass(context, node) |
| } |
| } else { |
| if (!evaluator.isMemberInClass(method, "java.lang.Class")) { |
| return |
| } |
| if (GET_DECLARED_METHOD == method.name) { |
| checkGetDeclaredMethod(context, node) |
| } else { |
| checkLoadClass(context, node) |
| } |
| } |
| } |
| |
| override fun visitReference( |
| context: JavaContext, |
| reference: UReferenceExpression, |
| referenced: PsiElement |
| ) { |
| // Kotlin reflection is harder to analyze statically, there are multiple ways of |
| // finally matching a method from the collection of declared members, etc. We heuristically |
| // try to match the strings we see with method and field names from the private API list. |
| // TODO: implement once Lint supports resolving property access. |
| } |
| |
| private fun checkGetDeclaredMethod(context: JavaContext, call: UCallExpression) { |
| val cls = getJavaClassFromMemberLookup(call) ?: return |
| |
| val arguments = call.valueArguments |
| if (arguments.isEmpty()) { |
| return |
| } |
| val methodName = ConstantEvaluator.evaluateString(context, arguments[0], false) |
| |
| val aClass = context.evaluator.findClass(cls) |
| if (aClass != null && aClass.findMethodsByName(methodName, true).isNotEmpty()) { |
| return |
| } |
| |
| val targetSdk = context.project.targetSdk |
| val location = context.getLocation(call) |
| if (targetSdk < AndroidVersion.VersionCodes.O) { |
| if (!(cls.startsWith("com.android.") || cls.startsWith("android."))) { |
| return |
| } |
| context.report(PRIVATE_API, call, location, ERROR_MESSAGE) |
| } else if (methodName != null) { |
| // When targetSDK is at least 28, we perform stricter checks against the API blacklist. |
| val argTypes = |
| if (arguments.size >= 2) arguments.subList(1, arguments.size) |
| .mapNotNull { getJavaClassType(it) } |
| .toTypedArray() |
| else |
| emptyArray() |
| |
| val desc = context.evaluator |
| .constructMethodDescription(method = methodName, argumentTypes = argTypes) ?: return |
| |
| val restriction = apiDatabase?.getMethodRestriction(cls, methodName, desc) |
| reportIssue(context, restriction, methodName, call) |
| } |
| } |
| |
| private fun checkLoadClass( |
| context: JavaContext, |
| call: UCallExpression |
| ) { |
| val arguments = call.valueArguments |
| if (arguments.isEmpty()) { |
| return |
| } |
| val value = ConstantEvaluator.evaluate(context, arguments[0]) as? String ?: return |
| |
| var isInternal = false |
| if (value.startsWith("com.android.internal.")) { |
| isInternal = true |
| } else if (value.startsWith("com.android.") || value.startsWith("android.") && |
| !value.startsWith("android.support.") |
| ) { |
| // Attempting to access internal API? Look in two places: |
| // (1) SDK class |
| // (2) API database |
| val aClass = context.evaluator.findClass(value) |
| |
| if (aClass != null) { // Found in SDK: not internal |
| return |
| } |
| val apiLookup = ApiLookup.get( |
| context.client, |
| context.mainProject.buildTarget |
| ) ?: return |
| isInternal = !apiLookup.containsClass(value) |
| } |
| |
| if (isInternal) { |
| val location = context.getLocation(call) |
| context.report(PRIVATE_API, call, location, ERROR_MESSAGE) |
| } |
| } |
| |
| /** |
| * Given a Class#getMethodDeclaration or getFieldDeclaration etc call, |
| * figure out the corresponding class name the method is being invoked on |
| * |
| * @param call the [Class.getDeclaredMethod] or [Class.getDeclaredField] call |
| * |
| * @return the fully qualified name of the class, if found |
| */ |
| private fun getJavaClassFromMemberLookup(call: UCallExpression): String? = |
| getJavaClassType(call.receiver)?.canonicalText |
| |
| /** We know [element] has type java.lang.Class<T> and we try to find out the PsiType for T. */ |
| private fun getJavaClassType(element: UElement?): PsiType? { |
| if (element is UExpression) { |
| // First try the type inferred from the Psi, in case it's a known class reference. |
| val type = element.getExpressionType() |
| |
| if (type is PsiClassType && type.parameterCount == 1) { |
| var clazz = type.parameters[0] |
| |
| if (clazz is PsiClassType) { |
| PsiPrimitiveType.getUnboxedType(clazz)?.let { |
| // Make sure we extract the primitive type (int.class, Integer.TYPE in Java, |
| // Int::class.javaPrimitiveType in Kotlin) |
| if (element is UQualifiedReferenceExpression) { |
| val identifier = |
| (element.selector as? USimpleNameReferenceExpression)?.identifier |
| if (identifier == "javaPrimitiveType" || identifier == "TYPE") { |
| clazz = it |
| } |
| } |
| if (element is UClassLiteralExpression && element.evaluate() is PsiPrimitiveType) { |
| clazz = it |
| } |
| } |
| return clazz |
| } |
| // Here we might have a wildcard type, most likely an unbounded Class<?> coming from |
| // a loadClass or Class.forName() call. We can also have a bounded <? extends Foo>, |
| // from foo.getClass(), but if Foo is not final we cannot statically guarantee the |
| // receiver is indeed class Foo. So we fall-through to the handling below. |
| } |
| if (element is UReferenceExpression) { |
| val resolved = element.resolve() |
| if (resolved is PsiVariable) { |
| // Follow the indirection and inspect the actual definition |
| UastLintUtils.findLastAssignment(resolved, element)?.let { expression -> |
| return getJavaClassType(expression) |
| } |
| } |
| |
| if (element is UQualifiedReferenceExpression && element.selector is UCallExpression) { |
| val call = element.selector as UCallExpression |
| val name = call.methodName |
| |
| if (FOR_NAME == name || LOAD_CLASS == name) { |
| val arguments = call.valueArguments |
| if (arguments.isNotEmpty()) { |
| return ConstantEvaluator |
| .evaluateString(null, arguments[0], false)?.let { |
| psiFactory!!.createTypeFromText(it, null) |
| } |
| } |
| } else if (GET_CLASS == name) { |
| return TypeEvaluator.evaluate(element.receiver) |
| } |
| |
| // TODO: Are there any other common reflection utility methods (from reflection |
| // libraries etc) ? |
| } |
| } |
| } |
| return TypeEvaluator.evaluate(element) |
| } |
| |
| private fun reportIssue( |
| context: JavaContext, |
| restriction: Restriction?, |
| api: String, |
| call: UCallExpression |
| ) { |
| val targetSdk = context.project.targetSdk |
| |
| fun fatal() { |
| context.report( |
| BLOCKED_PRIVATE_API, call, context.getLocation(call), |
| "Reflective access to $api is forbidden when targeting API $targetSdk and above" |
| ) |
| } |
| |
| fun error() { |
| context.report( |
| SOON_BLOCKED_PRIVATE_API, call, context.getLocation(call), |
| "Reflective access to $api will throw an exception when targeting API $targetSdk and above" |
| ) |
| } |
| |
| fun warning() { |
| context.report( |
| DISCOURAGED_PRIVATE_API, call, context.getLocation(call), |
| "Reflective access to $api, which is not part of the public SDK and therefore likely to change in future Android releases" |
| ) |
| } |
| |
| when (restriction) { |
| Restriction.BLACK -> fatal() |
| Restriction.GREY_MAX_O -> |
| if (targetSdk <= AndroidVersion.VersionCodes.O || |
| VersionChecks.isWithinVersionCheckConditional( |
| context.evaluator, call, AndroidVersion.VersionCodes.O, false |
| ) |
| ) { |
| warning() |
| } else { |
| error() |
| } |
| Restriction.GREY_MAX_P -> |
| if (targetSdk <= AndroidVersion.VersionCodes.P || |
| VersionChecks.isWithinVersionCheckConditional( |
| context.evaluator, call, AndroidVersion.VersionCodes.P, false |
| ) |
| ) { |
| warning() |
| } else { |
| error() |
| } |
| Restriction.GREY -> warning() |
| else -> return // nothing to report |
| } |
| } |
| } |
