4.1.3 高级话题

4.1.3.1 组合导出属性和意图过滤器（对于活动）

我们已经解释了如何实现本指南中的四类活动：私有活动，公共活动，伙伴活动和内部活动。 下表中定义了每种类型的导出属性的允许的设置，和intent-filter元素的各种组合，它们在AndroidManifest.xml文件中定义。 请使用你尝试创建的活动，验证导出属性和intent-filter元素的兼容性。

导出属性的值
True False
意图过滤器已定义 公开 （不使用）
意图过滤器未定义 公开、伙伴、内部 AndroidManifest.xml

表 4.1-2

当未指定Activity的导出属性时，Activity是否为公开的，取决于Activity的意图过滤器的存在与否 [4]。 但是，在本手册中，禁止将导出属性设置为未指定。通常，如前所述，最好避免依赖任何给定 API 的默认行为的实现；此外，如果存在明确的方法（例如导出属性）来启用重要的安全相关设置，那么使用这些方法总是一个好主意。

如果定义了任何意图过滤器，则该活动是公开的；否则它是私有的。更多信息请参阅 https://developer.android.com/guide/topics/manifest/activity-element.html#exported。

不应该使用未定义的意图过滤器和导出属性false的原因，是 Android 的行为存在漏洞，并且由于意图过滤器的工作原理，其他应用的活动可能会意外调用它。下面的两个图展示了这个解释。图 4.1-4 是一个正常行为的例子，其中私有活动（应用 A）只能由同一个应用的隐式Intent调用。 意图过滤器（action ="X"）被定义为仅在应用 A 内部工作，所以这是预期的行为。

4.1.3.md - 图1

下面的图 4.1-5 展示了一个场景，其中在应用 B 和应用 A 中定义了相同的意图过滤器（action ="X"）。应用 A 试图通过发送隐式意图，来调用同一应用中的私有活动 ，但是这次显示了对话框，询问用户选择哪个应用，以及应用 B 中的公共活动 B-1 ，由于用户的选择而错误调用。 由于这个漏洞，可能会将敏感信息发送到其他应用，或者应用可能会收到意外的返回值。

4.1.3.md - 图2

如上所示，使用意图过滤器，将隐式意图发送到私有应用，可能会导致意外行为，因此最好避免此设置。 另外，我们已经验证了这种行为不依赖于应用 A 和应用 B 的安装顺序。

4.1.3.2 验证请求应用

我们在此解释一些技术信息，关于如何实现伙伴活动。 伙伴应用只允许白名单中注册的特定应用访问，并且所有其他应用都被拒绝。 由于除内部应用之外的其他应用也需要访问权限，因此我们无法使用签名权限进行访问控制。

简而言之，我们希望验证尝试使用伙伴活动的应用，通过检查它是否在预定义的白名单中注册，如果是，则允许访问，如果不是，则拒绝访问。 应用验证的方式是，从请求访问的应用获取证书，并将其与白名单中的散列进行比较。

一些开发人员可能会认为，仅仅比较软件包名称而不获取证书就足够了，但是，很容易伪装成合法应用的软件包名称，因此这不是检查真实性的好方法。 任意指定的值不应用于认证。 另一方面，由于只有应用开发人员拥有用于签署证书的开发人员密钥，因此这是识别的更好方法。 由于证书不容易被伪造，除非恶意第三方可以窃取开发人员密钥，否则恶意应用被信任的可能性很小。 虽然可以将整个证书存储在白名单中，但为了使文件大小最小，仅存储 SHA-256 散列值就足够了。

使用这个方法有两个限制：

  • 请求应用需要使用startActivityForResult()而不是startActivity()。
  • 请求应用应该只从Activity调用。

第二个限制是由于第一个限制而施加的限制，因此技术上只有一个限制。

由于Activity.getCallingPackage()的限制，它获取调用应用的包名称，所以会发生此限制。 Activity.getCallingPackage()仅在由startActivityForResult()调用时，才返回源（请求）应用的包名，但不幸的是，当它由startActivity()调用时，它仅返回null。 因此，使用此处解释的方法时，源（请求）应用需要使用startActivityForResult()，即使它不需要获取返回值。 另外，startActivityForResult()只能在Activity类中使用，所以源（请求者）仅限于活动。

PartnerActivity.java

  1. package org.jssec.android.activity.partneractivity;
  3. import org.jssec.android.shared.PkgCertWhitelists;
  4. import org.jssec.android.shared.Utils;
  5. import android.app.Activity;
  6. import android.content.Context;
  7. import android.content.Intent;
  8. import android.os.Bundle;
  9. import android.view.View;
  10. import android.widget.Toast;
  12. public class PartnerActivity extends Activity {
  14.     // *** POINT 4 *** Verify the requesting application's certificate through a predefined whitelist.
  15.     private static PkgCertWhitelists sWhitelists = null;
  17.     private static void buildWhitelists(Context context) {
  18.         boolean isdebug = Utils.isDebuggable(context);
  19.         sWhitelists = new PkgCertWhitelists();
  20.         // Register certificate hash value of partner application org.jssec.android.activity.partneruser
  21.             .sWhitelists.add("org.jssec.android.activity.partneruser", isdebug ?
  22.             // Certificate hash value of "androiddebugkey" in the debug.keystore.
  23.             "0EFB7236 328348A9 89718BAD DF57F544 D5CCB4AE B9DB34BC 1E29DD26 F77C8255" :
  24.             // Certificate hash value of "partner key" in the keystore.
  25.             "1F039BB5 7861C27A 3916C778 8E78CE00 690B3974 3EB8259F E2627B8D 4C0EC35A");
  26.             // Register the other partner applications in the same way.
  27.     }
  29.     private static boolean checkPartner(Context context, String pkgname) {
  30.         if (sWhitelists == null) buildWhitelists(context);
  31.         return sWhitelists.test(context, pkgname);
  32.     }
  34.     @Override
  35.     public void onCreate(Bundle savedInstanceState) {
  36.         super.onCreate(savedInstanceState);
  37.         setContentView(R.layout.main);
  38.         // *** POINT 4 *** Verify the requesting application's certificate through a predefined whitelist.
  39.         if (!checkPartner(this, getCallingActivity().getPackageName())) {
  40.             Toast.makeText(this,
  41.             "Requesting application is not a partner application.", Toast.LENGTH_LONG).show();
  42.             finish();
  43.             return;
  44.         }
  45.         // *** POINT 5 *** Handle the received intent carefully and securely, even though the intent was sent from a partner application.
  46.         // Omitted, since this is a sample. Refer to "3.2 Handling Input Data Carefully and Securely."
  47.         Toast.makeText(this, "Accessed by Partner App", Toast.LENGTH_LONG).show();
  48.     }
  50.     public void onReturnResultClick(View view) {
  51.         // *** POINT 6 *** Only return Information that is granted to be disclosed to a partner application.
  52.         Intent intent = new Intent();
  53.         intent.putExtra("RESULT", "Information for partner applications");
  54.         setResult(RESULT_OK, intent);
  55.         finish();
  56.     }
  57. }

PkgCertWhitelists.java

  1. package org.jssec.android.shared;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import android.content.Context;
  7. public class PkgCertWhitelists {
  9.     private Map<String, String> mWhitelists = new HashMap<String, String>();
  10.     public boolean add(String pkgname, String sha256) {
  11.         if (pkgname == null) return false;
  12.         if (sha256 == null) return false;
  13.         sha256 = sha256.replaceAll(" ", "");
  14.         if (sha256.length() != 64) return false; // SHA-256 -> 32 bytes -> 64 chars
  15.         sha256 = sha256.toUpperCase();
  16.         if (sha256.replaceAll("[0-9A-F]+", "").length() != 0) return false; // found non hex char
  17.         mWhitelists.put(pkgname, sha256);
  18.         return true;
  19.     }
  21.     public boolean test(Context ctx, String pkgname) {
  22.         // Get the correct hash value which corresponds to pkgname.
  23.         String correctHash = mWhitelists.get(pkgname);
  24.         // Compare the actual hash value of pkgname with the correct hash value.
  25.         return PkgCert.test(ctx, pkgname, correctHash);
  26.     }
  27. }

PkgCert.java

  2. package org.jssec.android.shared;
  4. import java.security.MessageDigest;
  5. import java.security.NoSuchAlgorithmException;
  6. import android.content.Context;
  7. import android.content.pm.PackageInfo;
  8. import android.content.pm.PackageManager;
  9. import android.content.pm.PackageManager.NameNotFoundException;
  10. import android.content.pm.Signature;
  12. public class PkgCert {
  14.     public static boolean test(Context ctx, String pkgname, String correctHash) {
  15.         if (correctHash == null) return false;
  16.         correctHash = correctHash.replaceAll(" ", "");
  17.         return correctHash.equals(hash(ctx, pkgname));
  18.     }
  20.     public static String hash(Context ctx, String pkgname) {
  21.         if (pkgname == null) return null;
  22.         try {
  23.             PackageManager pm = ctx.getPackageManager();
  24.             PackageInfo pkginfo = pm.getPackageInfo(pkgname, PackageManager.GET_SIGNATURES);
  25.             if (pkginfo.signatures.length != 1) return null; // Will not handle multiple signatures.
  26.             Signature sig = pkginfo.signatures[0];
  27.             byte[] cert = sig.toByteArray();
  28.             byte[] sha256 = computeSha256(cert);
  29.             return byte2hex(sha256);
  30.         } catch (NameNotFoundException e) {
  31.             return null;
  32.         }
  33.     }
  35.     private static byte[] computeSha256(byte[] data) {
  36.         try {
  37.             return MessageDigest.getInstance("SHA-256").digest(data);
  38.         } catch (NoSuchAlgorithmException e) {
  39.             return null;
  40.         }
  41.     }
  43.     private static String byte2hex(byte[] data) {
  44.         if (data == null) return null;
  45.         final StringBuilder hexadecimal = new StringBuilder();
  46.         for (final byte b : data) {
  47.             hexadecimal.append(String.format("%02X", b));
  48.         }
  49.         return hexadecimal.toString();
  50.     }
  51. }

4.1.3.3 读取发送给活动的意图

在 Android 5.0（API Level 21）及更高版本中，使用getRecentTasks()得到的信息仅限于调用者自己的任务，并且可能还有一些其他任务，例如已知不敏感的其他任务。 但是支持 Android 5.0（API Level 21）版本的应用应该防止泄露敏感信息。 以下描述了问题内容，它出现在 Android 5.0 及更早版本中。

发送到任务的根Activity的意图，被添加到任务历史中。 根活动是在任务中启动的第一个活动。 任何应用都可以通过使用ActivityManager类，读取添加到任务历史的意图。

下面显示了从应用中读取任务历史的示例代码。 要浏览任务历史，请在AndroidManifest.xml文件中指定GET_TASKS权限。

AndroidManifest.xml

  1. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  2.     package="org.jssec.android.intent.maliciousactivity" >
  4.     <!-- Use GET_TASKS Permission -->
  5.     <uses-permission android:name="android.permission.GET_TASKS" />
  7.     <application
  8.         android:allowBackup="false"
  9.         android:icon="@drawable/ic_launcher"
  10.         android:label="@string/app_name"
  11.         android:theme="@style/AppTheme" >
  12.         <activity
  13.             android:name=".MaliciousActivity"
  14.             android:label="@string/title_activity_main"
  15.             android:exported="true" >
  16.             <intent-filter>
  17.                 <action android:name="android.intent.action.MAIN" />
  18.                 <category android:name="android.intent.category.LAUNCHER" />
  19.             </intent-filter>
  20.         </activity>
  21.     </application>
  22. </manifest>

MaliciousActivity.java

  1. package org.jssec.android.intent.maliciousactivity;
  3. import java.util.List;
  4. import java.util.Set;
  5. import android.app.Activity;
  6. import android.app.ActivityManager;
  7. import android.content.Intent;
  8. import android.os.Bundle;
  9. import android.util.Log;
  11. public class MaliciousActivity extends Activity {
  13.     @Override
  14.     public void onCreate(Bundle savedInstanceState) {
  15.         super.onCreate(savedInstanceState);
  16.         setContentView(R.layout.malicious_activity);
  17.         // Get am ActivityManager instance.
  18.         ActivityManager activityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
  19.         // Get 100 recent task info.
  20.         List<ActivityManager.RecentTaskInfo> list = activityManager
  21.             .getRecentTasks(100, ActivityManager.RECENT_WITH_EXCLUDED);
  22.         for (ActivityManager.RecentTaskInfo r : list) {
  23.             // Get Intent sent to root Activity and Log it.
  24.             Intent intent = r.baseIntent;
  25.             Log.v("baseIntent", intent.toString());
  26.             Log.v(" action:", intent.getAction());
  27.             Log.v(" data:", intent.getDataString());
  28.             if (r.origActivity != null) {
  29.                 Log.v(" pkg:", r.origActivity.getPackageName() + r.origActivity.getClassName());
  30.             }
  31.             Bundle extras = intent.getExtras();
  32.             if (extras != null) {
  33.                 Set<String> keys = extras.keySet();
  34.                 for(String key : keys) {
  35.                     Log.v(" extras:", key + "=" + extras.get(key).toString());
  36.                 }
  37.             }
  38.         }
  39.     }
  40. }

你可以使用AcitivityManager类的getRecentTasks()函数，来获取任务历史的指定条目。 每个任务的信息存储在ActivityManager.RecentTaskInfo类的实例中，但发送到任务根Activity的意图存储在其成员变量baseIntent中。 由于根Activity是创建任务时启动的Activity，请务必在调用Activity时，不要满足以下两个条件。

  • 新的任务在活动被调用时创建
  • 被调用的活动是任务的根活动，它已经在前台或者后台存在

4.1.3.4 根活动

根活动是作为任务起点的活动。 换句话说，这是创建任务时启动的活动。 例如，当默认活动由启动器启动时，此活动将是根活动。 根据 Android 规范，发送到根Activity的意图的内容可以从任意应用中读取。 因此，有必要采取对策，不要将敏感信息发送到根活动。 在本指南中，已经制定了以下三条规则来避免被调用的Activity成为根活动。

  • 不要指定taskAffinity
  • 不要指定launchMode
  • 发送给活动的意图中，不要设置FLAG_ACTIVITY_NEW_TASK

我们考虑一个情况，活动可以成为下面的根活动。 被调用的活动成为根活动，取决于以下内容。

  • 被调用活动的启动模式
  • 被调用活动的任务及其启动模式

首先，让我解释一下“被调用活动的启动模式”。 可以通过在AndroidManifest.xml中编写android:launchMode来设置Activity的启动模式。 当它没有编写时，它被认为是“标准”。 另外，启动模式也可以通过设置意图的标志来更改。 标志FLAG_ACTIVITY_NEW_TASK以singleTask模式启动活动。

启动模式可以指定为这些。我会解释它们和根活动的关系。

标准（standard）

此模式调用的活动不会是根，它属于调用者端的任务。 每次调用时，都会生成活动实例。

singleTop

这个启动模式和“标准”相同，除了启动一个活动，它显示在前台任务的最前面时，不会生成实例。

singleTask

这个启动模式根据 Affinity 值确定活动所属的任务。 当匹配Activity的 Affinity 的任务不存在于后台或前台时，新任务随Activity的实例一起生成。 当任务存在时，它们都不会被生成。 在前者中，已启动的Activity实例成为根。

singleInstance

与singleTask相同，但以下几点不同。 只有根活动可以属于新生成的任务。 因此，通过此模式启动的活动实例，始终是根活动。 现在，我们需要注意的是，虽然任务已经存在，并且名称和被调用Activity的 Affinity 相同，但是被调用Activity的类名和包含在任务中的Activity的类名是不同的。

从上面我们可以知道，由singleTask或singleInstance启动的Activity有可能成为根。 为了确保应用的安全性，它不应该由这些模式启动。

接下来，我将解释“被调用活动的任务及其启动模式”。 即使Activity以“标准”模式调用，它也会成为根Activity。在某些情况下，取决于Activity所属的任务状态。

例如，考虑被调用Activity的任务已经在后台运行的情况。 这里的问题是，任务的活动实例以singleInstance启动，当以“标准”调用的Activity的 Affinity 与任务相同时，新任务的生成受到现有的singleInstance 活动的限制。但是，当每个活动的类名称相同时，不会生成任务，并使用现有活动实例。在任何情况下，被调用活动都将成为根活动。

如上所述，调用根Activity的条件很复杂，例如取决于执行状态。 因此，在开发应用时，最好设法以“标准”来调用活动。

这是一个示例，其中发送给私有活动的意图，可以从其他应用中读取。示例代码表明，私有活动的调用方活动以singleInstance模式启动。 在这个示例代码中，私有活动以“标准”模式启动，但由于调用方Activity的singleInstance条件，这个私有活动成为新任务的根Activity。 此时，发送给私有活动的敏感信息，在任务历史中记录，因此可以从其他应用读取。 仅供参考，调用方活动和私有活动都具有相同的 Affinity。

AndroidManifest.xml（不推荐）

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     package="org.jssec.android.activity.singleinstanceactivity" >
  5.     <application
  6.         android:allowBackup="false"
  7.         android:icon="@drawable/ic_launcher"
  8.         android:label="@string/app_name" >
  10.         <!-- Set the launchMode of the root Activity to "singleInstance". -->
  11.         <!-- Do not use taskAffinity -->
  12.         <activity
  13.             android:name="org.jssec.android.activity.singleinstanceactivity.PrivateUserActivity"
  14.             android:label="@string/app_name"
  15.             android:launchMode="singleInstance"
  16.             android:exported="true" >
  17.             <intent-filter>
  18.                 <action android:name="android.intent.action.MAIN" />
  19.                 <category android:name="android.intent.category.LAUNCHER" />
  20.             </intent-filter>
  21.         </activity>
  23.         <!-- Private activity -->
  24.         <!-- Set the launchMode to "standard." -->
  25.         <!-- Do not use taskAffinity -->
  26.         <activity
  27.         android:name="org.jssec.android.activity.singleinstanceactivity.PrivateActivity"
  28.         android:label="@string/app_name"
  29.         android:exported="false" />
  30.     </application>
  31. </manifest>

私有活动仅仅将结果返回个收到的意图。

PrivateActivity.java

  1. package org.jssec.android.activity.singleinstanceactivity;
  3. import android.app.Activity;
  4. import android.content.Intent;
  5. import android.os.Bundle;
  6. import android.view.View;
  7. import android.widget.Toast;
  9. public class PrivateActivity extends Activity {
  11.     @Override
  12.     public void onCreate(Bundle savedInstanceState) {
  13.         super.onCreate(savedInstanceState);
  14.         setContentView(R.layout.private_activity);
  15.         // Handle intent securely, even though the intent sent from the same application.
  16.         // Omitted, since this is a sample. Please refer to "3.2 Handling Input Data Carefully and Securely."
  17.         String param = getIntent().getStringExtra("PARAM");
  18.         Toast.makeText(this, String.format("Received param: ¥"%s¥"", param), Toast.LENGTH_LONG).show();
  19.     }
  21.     public void onReturnResultClick(View view) {
  22.         Intent intent = new Intent();
  23.         intent.putExtra("RESULT", "Sensitive Info");
  24.         setResult(RESULT_OK, intent);
  25.         finish();
  26.     }
  27. }

在私有活动的调用方，私有活动以“标准”模式启动，意图不带有任何标志。

PrivateUserActivity.java

  1. package org.jssec.android.activity.singleinstanceactivity;
  3. import android.app.Activity;
  4. import android.content.Intent;
  5. import android.os.Bundle;
  6. import android.view.View;
  7. import android.widget.Toast;
  9. public class PrivateUserActivity extends Activity {
  11.     private static final int REQUEST_CODE = 1;
  13.     @Override
  14.     public void onCreate(Bundle savedInstanceState) {
  15.         super.onCreate(savedInstanceState);
  16.         setContentView(R.layout.user_activity);
  17.     }
  19.     public void onUseActivityClick(View view) {
  20.         // Start the Private Activity with "standard" lanchMode.
  21.         Intent intent = new Intent(this, PrivateActivity.class);
  22.         intent.putExtra("PARAM", "Sensitive Info");
  23.         startActivityForResult(intent, REQUEST_CODE);
  24.     }
  26.     @Override
  27.     public void onActivityResult(int requestCode, int resultCode, Intent data) {
  28.         super.onActivityResult(requestCode, resultCode, data);
  29.         if (resultCode != RESULT_OK) return;
  30.         switch (requestCode) {
  31.             case REQUEST_CODE:
  32.                 String result = data.getStringExtra("RESULT");
  33.                 // Handle received result data carefully and securely,
  34.                 // even though the data came from the Activity in the same application.
  35.                 // Omitted, since this is a sample. Please refer to "3.2 Handling Input Data Carefully and Securely."
  36.                 Toast.makeText(this, Str();
  37.                 break;
  38.         }
  39.     }
  40. }

4.1.3.5 使用活动时的日志输出

当使用一个活动时，意图的内容通过ActivityManager输出到LogCat。 以下内容将被输出到LogCat，因此在这种情况下，敏感信息不应该包含在这里。

  • 目标包名称
  • 目标类名称
  • 由Intent#setData()设置的 URI

例如，当应用发送邮件时，如果应用将邮件地址指定为 URI，则邮件地址不幸会输出到LogCat。 所以，最好通过设置Extras来发送。 如下所示发送邮件时，邮件地址会显示给logCat。

MainActivity.java

  1. // URI is output to the LogCat.
  2. Uri uri = Uri.parse("mailtoest@gmail.com");
  3. Intent intent = new Intent(Intent.ACTION_SENDTO, uri);
  4. startActivity(intent);

当使用Extras时，邮件地址不会再展示给LogCat了。

MainActivity.java

  1. // Contents which was set to Extra, is not output to the LogCat.
  2. Uri uri = Uri.parse("mailto:");
  3. Intent intent = new Intent(Intent.ACTION_SENDTO, uri);
  4. intent.putExtra(Intent.EXTRA_EMAIL, new String[] {"test@gmail.com"});
  5. startActivity(intent);

但是，有些情况下，其他应用可以使用ActivityManager#getRecentTasks()读取意图的附加数据。 请参阅“4.1.2.2 不指定taskAffinity（必需）”，“4.1.2.3 不指定launchMode（必需）”和“4.1.2.4 不要为启动活动的Intent设置FLAG_ACTIVITY_NEW_TASK标志（必需）”。

4.1.3.6 防止PreferenceActivity中的Fragment注入

当从PreferenceActivity派生的类是公共活动时，可能会出现称为片段注入 [5] 的问题。 为了防止出现这个问题，有必要重写PreferenceActivity.IsValidFragment()，并检查其参数的有效性，来确保Activity不会无意中处理任何Fragment`。 （输入数据安全的更多信息，请参见第3.2节“小心和安全地处理输入数据”。）

[5] Fragement注入的更多信息，请参考：https://securityintelligence.com/new-vulnerability-android-framework-fragment-injection/。

下面我们显示一个覆盖IsValidFragment()的示例。 请注意，如果源代码已被混淆，则类名称和参数值比较的结果可能会更改。 在这种情况下，有必要寻求替代对策。

覆盖的isValidFragment()方法的示例

  1. protected boolean isValidFragment(String fragmentName) {
  2.     // If the source code is obfuscated, we must pursue alternative strategies
  3.     return PreferenceFragmentA.class.getName().equals(fragmentName)
  4.         || PreferenceFragmentB.class.getName().equals(fragmentName)
  5.         || PreferenceFragmentC.class.getName().equals(fragmentName)
  6.         || PreferenceFragmentD.class.getName().equals(fragmentName);
  7. }

请注意，如果应用的targetSdkVersion为 19 或更大，不覆盖PreferenceActivity.isValidFragment()将导致安全异常，并在插入Fragment时终止应用 [调用isValidFragment()时]，因此在这种情况下，覆盖 PreferenceActivity.isValidFragment()是强制性的。