Condom是用于防止第三方唤醒行为的框架，比较小众，这里做下最近使用和学习笔记。

基本操作

Condom 提供基础两个操作。
提供给第三方Context包装，监控在本进程中的唤醒行为。

XxxClient.init(CondomContext.wrap(context, "XxxSDK"),...);

提供进程隔离唤醒处理

CondomProcess.installExceptDefaultProcess(this)

另外提供完全自定义隔离入口

CondomProcess.installExcept(final Application app, final CondomOptions options, final String... process_names)

主要结构说明

Condom框架功能结构上比较清晰。以下为记录的主要功能说明

类名	功能说明	备注
CondomCore	提供主要拦截验证逻辑
CondomContext	Context代理，用于处理Context方法相关调用拦截，其中实现了内部的代理类CondomPackageManger（代理 PackageManager）、CondomContentResolver（代理ContentResolver）
CondomProcess	处理非主要进程的进程隔离，通过动态代理代理ActivityManager和PackageManager对象
CondomOptions	提供验证配置逻辑，在CondomContext.wrap和CondomProcess.installExcept 中可以对两个入口进行校验配置

CondomOptions配置项说明

方法	说明	备注
preventBroadcastToBackgroundPackages(final boolean prevent_or_not)	进行查询启动Broadcast/Receivers动作时是否需要考虑添加FLAG_RECEIVER_EXCLUDE_BACKGROUND（FLAG_RECEIVER_REGISTERED_ONLY）flag,排除后台或强制杀死应用
preventServiceInBackgroundPackages(final boolean prevent_or_not)	进行查询校验时是否排除非正常启动应用（僵尸进程也不算，进程等级需要高于IMPORTANCE_BACKGROUND）
setOutboundJudge(final OutboundJudge judge)	设置一个在进行外部唤醒时的自定义校验
CondomOptions setDryRun(final boolean dry_run)	设置为true将忽略校验处理（即使校验不通过，还是会无条件按正常流进行），比如查询结果过滤

OutboundType

OutboundType提供发生校验时所进行的操作，结合OutboundJudge使用可以精确自定义校验处理。
但是发生自定义校验仅限于所发生的行为是针对非项目内的的操作才会执行该回调，比如所执行startService中Intent的packagename为非本项目。

原理探索

验证器 - CondomCore

CondomCore主要负责验证逻辑，无论在哪种拦截处都需要执行这里的验证逻辑，所以需要先熟悉这里面的逻辑。

主要拦截操作

方法	说明	备注
processd(final OutboundType type, final Intent intent, final @Nullable R negative_value,final CondomCore.WrappedValueProcedureThrows<R, T> procedure)	处理基本入口，这里负责两件事情： （1）判定所请求的Intent目标包名是否为项目包名，如果一致则忽略验证。 （2）验证自定义拦截 OutboundJudge.showldAllow （3）调整Intent Flag 模式，参照 adjustIntentFlags 说明。
proceedBroadcast(final Intent intent, final CondomCore.WrappedProcedure procedure)	proceed(OutboundType.BROADCAST, intent, null, procedure)代理
proceedQuery(final OutboundType type, final Intent intent, final CondomCore.WrappedValueProcedureThrows<List<ResolveInfo>, T> procedure)	依然是proceed代理，在WrappedProcedure回调中拦截查询所得的ResolveInfo结果，并进行OutboundJudge.showldAllow回调查询是否过滤。

调整操作

方法	说明	备注
adjustIntentFlags(final OutboundType type, final Intent intent)	（1）根据CondomOptions.mExcludeBackgroundReceivers 参数决定是否在调用前对Intent添加 FLAG_RECEIVER_EXCLUDE_BACKGROUND（FLAG_RECEIVER_REGISTERED_ONLY）flag，该标记意味着如果没有显示设置package name则如果应用被强制杀死或者未启动过则不会执行广播接收 （2）根据CondomOptions.mExcludeStoppedPackages 参数决定是否在调用前对Intent移除 FLAG_INCLUDE_STOPPED_PACKAGES（添加FLAG_EXCLUDE_STOPPED_PACKAGES）该标记意味着如果应用被强制杀死或者未启动过则不会执行
filterCandidates(final OutboundType type, final Intent original_intent, final @Nullable List<ResolveInfo> candidates, final String tag, final boolean remove)	用于对ResolveInfo结果查询过滤，这里会根据remove 参数有两个操作（公用的原因不知） （1）如果remove被设置true则在如果所查询的ResolveInfo的uid和当前项目uid不一致则会被从结果中过滤移除。 （2）如果被置为false则会范围第一个复合条件的ResolveInfo 在不符合uid不为主项目的uid则执行验证流程中同时加入对OutboundJudge.showldAllow和mExcludeBackgroundServices的验证，如果符合则也视为通过验证。
shouldAllowProvider(final @Nullable ProviderInfo provider)	过滤ProviderInfo信息。 （1）查询结果是否为主项目包名信息 （2）验证自定义自定义拦截OutboundJudge.showldAllow （3）验证查询信息应用是否非系统应用（FLAG_SYSTEM）并且不处于FLAG_STOPPED状态

结论

在核心操作中，可以知道Condom主要在两个方面进行拦截。

调用时验证

在Intent执行调用时，对Intent信息进行监控，如果所指向的对象为关联项目（非其他无关应用）则视为合法操作，这样可以防止启动其他无关项目，另外为了保证效果在启动的Intent又加入对应的限制性Flag，防止后台已经被关闭停止的应用被启动。

查询后验证

在对系统、包信息等查询信息动作时，除了在查询动作前进行拦截外（有些操作需要Intent还是会被第一项所约束），还会执行对查询结果的过滤。如果所查询应用的uid为非相关应用则会被过滤，或者在非相关uid查询操作后，根据自定义过滤动作进行过滤。

拦截器 - CondomContext 、CondomProcess

验证逻辑有了，剩下的就是寻找切面时机。从验证逻辑中可以清楚知道验证所针对的功能目标是启动行为和查询行为。

CondomContext 提供两个入口：

包装Context

在大部分情况下第三方应用如果需要在主项目中执行调用、查询行为，大部分都是使用Context引用进行相关操作，所以较多第三方SDK初始化的第一步就是需要主项目传入其Context。
应对这种方式，Condom提供对需要提供给第三方框架Context进行包装的方法。

CondomContext.wrap(Context, String)

通过代理Context（CondomContext）来监控方法调用情况。

CondomContext的包装Context实现均来自CondomContext自身构造中

private CondomContext(final CondomCore condom, final @Nullable Context app_context, final @Nullable @Size(max=16) String tag) {
        super(condom.mBase);
        final Context base = condom.mBase;
        mCondom = condom;
        mApplicationContext = app_context != null ? app_context : this;
        mBaseContext = new Lazy<Context>() { @Override protected Context create() {
            return new PseudoContextImpl(CondomContext.this);
        }};
        mPackageManager = new Lazy<PackageManager>() { @Override protected PackageManager create() {
            return new CondomPackageManager(base.getPackageManager());
        }};
        mContentResolver = new Lazy<ContentResolver>() { @Override protected ContentResolver create() {
            return new CondomContentResolver(base, base.getContentResolver());
        }};
        TAG = CondomCore.buildLogTag("Condom", "Condom.", tag);
    }

在构造中对PackageManager、ContentResolver、BaseContext、Applicaiton 又进行重新包装并在CondomContext中重写Context的相关实现。在代理类中实现对方法执行的调用校验。

    @Override public ContentResolver getContentResolver() { return mContentResolver.get(); }
    @Override public PackageManager getPackageManager() { return mPackageManager.get(); }
    @Override public Context getApplicationContext() { return mApplicationContext; }
    @Override public Context getBaseContext() {
        mCondom.logConcern(TAG, "getBaseContext");
        return mBaseContext.get();
    }

进程隔离

除了包装层面，Condom还提供进程隔离的处理，通过动态代理，将 ActivityManagerNative 中的 gDefault（IActivityManager) 和 ActivityThread中的sPackageManager（IPackageManager）进行代理

以下为相关代码：

动态代理ActivityManager

@SuppressLint("PrivateApi") private static void installCondomProcessActivityManager(final CondomCore condom)
            throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        final Class<?> ActivityManagerNative = Class.forName("android.app.ActivityManagerNative");
        Field ActivityManagerNative_gDefault = null;
        if (SDK_INT <= N_MR1) try {
            ActivityManagerNative_gDefault = ActivityManagerNative.getDeclaredField("gDefault");
        } catch (final NoSuchFieldException ignored) {}     // ActivityManagerNative.gDefault is no longer available on Android O.
        if (ActivityManagerNative_gDefault == null) {
            ActivityManagerNative_gDefault = ActivityManager.class.getDeclaredField("IActivityManagerSingleton");
        }
        ActivityManagerNative_gDefault.setAccessible(true);
        final Class<?> Singleton = Class.forName("android.util.Singleton");
        final Method Singleton_get = Singleton.getDeclaredMethod("get");
        Singleton_get.setAccessible(true);
        final Field Singleton_mInstance = Singleton.getDeclaredField("mInstance");
        Singleton_mInstance.setAccessible(true);
        final Class<?> IActivityManager = Class.forName("android.app.IActivityManager");

        final Object/* Singleton */singleton = ActivityManagerNative_gDefault.get(null);
        if (singleton == null) throw new IllegalStateException("ActivityManagerNative.gDefault is null");
        final Object/* IActivityManager */am = Singleton_get.invoke(singleton);
        if (am == null) throw new IllegalStateException("ActivityManagerNative.gDefault.get() returns null");

        if (Proxy.isProxyClass(am.getClass()) && Proxy.getInvocationHandler(am) instanceof CondomProcessActivityManager) {
            Log.d(TAG, "CondomActivityManager is already installed in this process.");
            return;
        }

        final Object condom_am = Proxy.newProxyInstance(condom.mBase.getClassLoader(), new Class[] {IActivityManager}, new CondomProcessActivityManager(condom, am));
        Singleton_mInstance.set(singleton, condom_am);
    }

动态代理 PackageManager

@SuppressLint("PrivateApi") private static void installCondomProcessPackageManager(final CondomCore condom)
            throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        final Class<?> ActivityThread = Class.forName("android.app.ActivityThread");
        final Field ActivityThread_sPackageManager = ActivityThread.getDeclaredField("sPackageManager");
        ActivityThread_sPackageManager.setAccessible(true);
        final Class<?> IPackageManager = Class.forName("android.content.pm.IPackageManager");

        final Object pm = ActivityThread_sPackageManager.get(null);
        if (Proxy.isProxyClass(pm.getClass()) && Proxy.getInvocationHandler(pm) instanceof CondomProcessPackageManager) {
            Log.d(TAG, "CondomPackageManager is already installed in this process.");
            return;
        }

        final Object condom_pm = Proxy.newProxyInstance(condom.mBase.getClassLoader(), new Class[] {IPackageManager}, new CondomProcessPackageManager(condom, pm));
        ActivityThread_sPackageManager.set(null, condom_pm);
    }

同样的既然是动态代理也需要实现其代理类

    @VisibleForTesting static class CondomProcessActivityManager extends CondomSystemService {

        private Object proceed(final Object proxy, final Method method, final Object[] args) throws Exception {
            ...
            case "broadcastIntent":
                ...
            case "bindService":
                ...
            case "startService":
                ...
            case "getContentProvider":
                ...
            }
            return super.invoke(proxy, method, args);
        }

        ...
    }

@VisibleForTesting static class CondomProcessPackageManager extends CondomSystemService {

        private Object proceed(final Object proxy, final Method method, final Object[] args) throws Exception {
            ...
            case "queryIntentServices":
                ...
            case "resolveService":
                ...
            case "resolveContentProvider":
                ...
            case "getInstalledApplications":
            case "getInstalledPackages":
                ...
            }
            return super.invoke(proxy, method, args);
        }

        ...
    }