源码分析 Android 9.0 http请求适配原理

96
Parallel_Lines
0.4 2018.12.04 21:58* 字数 1438

Android P 要求网络请求必须为Https,Http请求会抛异常。

这里我通过访问http://www.hao123.cn这个地址,测试了下面三种场景,以及给出相应的结果:

TargetSDK 场景 结果
26 Volley访问Http链接 正常访问
26 OkHttp访问Http链接 正常访问
26 Socket实现Http请求 正常访问
28 Volley访问Http链接 抛出异常:java.io.IOException: Cleartext HTTP traffic to www.hao123.cn not permitted
28 OkHttp访问Http链接 CLEARTEXT communication to www.hao123.cn not permitted by network security policy
28 Socket实现Http请求 正常访问

我们知道,Volley底层使用HttpUrlConnection实现,而HttpUrlConnection底层实质是OkHttp

到这里,只能简单推导出:
Android 9.0对于Http网络请求的限制,源于应用框架层,且一定和OkHttp源码有关。

源码分析

目的:通过分析源码,研究Http网络请求限制的原理、以及如何打开限制开关。

通过全局查找CLEARTEXT communication to www.hao123.cn not permitted by network security policy报错日志,发现这个异常是在OkHttp执行connect()方法时抛出的:

RealConnection

  public void connect(int connectTimeout, int readTimeout, int writeTimeout,
      boolean connectionRetryEnabled, Call call, EventListener eventListener) {
      ...
    if (route.address().sslSocketFactory() == null) {
      if (!connectionSpecs.contains(ConnectionSpec.CLEARTEXT)) {
        throw new RouteException(new UnknownServiceException(
            "CLEARTEXT communication not enabled for client"));
      }
      String host = route.address().url().host();
      if (!Platform.get().isCleartextTrafficPermitted(host)) {
        throw new RouteException(new UnknownServiceException(
            "CLEARTEXT communication to " + host + " not permitted by network security policy"));
      }
    }
    ...

route.address()会返回一个Address对象,这里可以看下Address构造函数截取的部分代码:

    this.url = new HttpUrl.Builder()
        .scheme(sslSocketFactory != null ? "https" : "http")
        .host(uriHost)
        .port(uriPort)
        .build();

从源码可以看出,只有scheme为http,才会进入下面的条件判断

Android 9.0不允许Http请求,可见Platform.get().isCleartextTrafficPermitted(host)在9.0系统上返回了false,该方法意为是否可以明文传输。
Platform的真正实现类是AndroidPlatform,所以实际源码如下:

AndroidPlatform

  @Override public boolean isCleartextTrafficPermitted(String hostname) {
    try {
      Class<?> networkPolicyClass = Class.forName("android.security.NetworkSecurityPolicy");
      Method getInstanceMethod = networkPolicyClass.getMethod("getInstance");
      Object networkSecurityPolicy = getInstanceMethod.invoke(null);
      return api24IsCleartextTrafficPermitted(hostname, networkPolicyClass, networkSecurityPolicy);
    } catch (ClassNotFoundException | NoSuchMethodException e) {
      return super.isCleartextTrafficPermitted(hostname);
    } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
      throw assertionError("unable to determine cleartext support", e);
    }
  }

通过反射,获取到android.security.NetworkSecurityPolicy对象,并执行了api24IsCleartextTrafficPermitted方法:

AndroidPlatform

  private boolean api24IsCleartextTrafficPermitted(String hostname, Class<?> networkPolicyClass,
      Object networkSecurityPolicy) throws InvocationTargetException, IllegalAccessException {
    try {
      Method isCleartextTrafficPermittedMethod = networkPolicyClass
          .getMethod("isCleartextTrafficPermitted", String.class);
      return (boolean) isCleartextTrafficPermittedMethod.invoke(networkSecurityPolicy, hostname);
    } catch (NoSuchMethodException e) {
      return api23IsCleartextTrafficPermitted(hostname, networkPolicyClass, networkSecurityPolicy);
    }
  }

这里仍然通过反射,最终执行了android.security.NetworkSecurityPolicyisCleartextTrafficPermitted方法:

android.security.NetworkSecurityPolicy

    public boolean isCleartextTrafficPermitted(String hostname) {
        return libcore.net.NetworkSecurityPolicy.getInstance()
                .isCleartextTrafficPermitted(hostname);
    }

libcore是Android的Java核心库。

libcore.net.NetworkSecurityPolicy是个抽象类,它的实现类是android.security.net.config.ConfigNetworkSecurityPolicy,它的源码如下:

ConfigNetworkSecurityPolicy

public class ConfigNetworkSecurityPolicy extends libcore.net.NetworkSecurityPolicy {
    private final ApplicationConfig mConfig;

    public ConfigNetworkSecurityPolicy(ApplicationConfig config) {
        mConfig = config;
    }

    @Override
    public boolean isCleartextTrafficPermitted() {
        return mConfig.isCleartextTrafficPermitted();
    }

    @Override
    public boolean isCleartextTrafficPermitted(String hostname) {
        return mConfig.isCleartextTrafficPermitted(hostname);
    }

    @Override
    public boolean isCertificateTransparencyVerificationRequired(String hostname) {
        return false;
    }
}

ConfigNetworkSecurityPolicy又是通过调用ApplicationConfigisCleartextTrafficPermitted来返回是否可以明文传输的,接着往下找。

ApplicationConfig

    public boolean isCleartextTrafficPermitted(String hostname) {
        return getConfigForHostname(hostname).isCleartextTrafficPermitted();
   }

getConfigForHostname()源码很长,这里我们不关注细节,只需要知道假如我们没有单独做配置,getConfigForHostname()会默认返回NetworkSecurityConfig,它在内部维护了一个布尔值变量,它决定是否允许Http明文传输。

现在只需要找到这个布尔值何时被赋值,就可以明白Http明文传输的条件。
这里从NetworkSecurityConfig的初始化开始找:

private void ensureInitialized() {
        synchronized(mLock) {
            ...
            mConfigs = mConfigSource.getPerDomainConfigs();
            mDefaultConfig = mConfigSource.getDefaultConfig();
            ...
        }
    }

可以看到,NetworkSecurityConfig来源于ConfigSource,而ConfigSource是个接口,真正的实现类是ManifestConfigSource,而它则提供了获取其它ConfigSource实现类的方法:

ManifestConfigSource

    private ConfigSource getConfigSource() {
        synchronized (mLock) {
            if (mConfigSource != null) {
                return mConfigSource;
            }
            int configResource = mApplicationInfo.networkSecurityConfigRes;
            ConfigSource source;
            if (configResource != 0) {
                boolean debugBuild =
                        (mApplicationInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
                if (DBG) {
                    Log.d(LOG_TAG, "Using Network Security Config from resource "
                            + mContext.getResources()
                                .getResourceEntryName(configResource)
                            + " debugBuild: " + debugBuild);
                }
                source = new XmlConfigSource(mContext, configResource, mApplicationInfo);
            } else {
                if (DBG) {
                    Log.d(LOG_TAG, "No Network Security Config specified, using platform default");
                }
                // the legacy FLAG_USES_CLEARTEXT_TRAFFIC is not supported for Ephemeral apps, they
                // should use the network security config.
                boolean usesCleartextTraffic =
                        (mApplicationInfo.flags & ApplicationInfo.FLAG_USES_CLEARTEXT_TRAFFIC) != 0
                        && mApplicationInfo.targetSandboxVersion < 2;
                source = new DefaultConfigSource(usesCleartextTraffic, mApplicationInfo);
            }
            mConfigSource = source;
            return mConfigSource;
        }
    }

这里我们暂时不关心XmlConfigSource这个ConfigSource,只关心DefaultConfigSource,它的源码如下:

DefaultConfigSource

    private static final class DefaultConfigSource implements ConfigSource {

        private final NetworkSecurityConfig mDefaultConfig;

        DefaultConfigSource(boolean usesCleartextTraffic, ApplicationInfo info) {
            mDefaultConfig = NetworkSecurityConfig.getDefaultBuilder(info)
                    .setCleartextTrafficPermitted(usesCleartextTraffic)
                    .build();
        }

        @Override
        public NetworkSecurityConfig getDefaultConfig() {
            return mDefaultConfig;
        }

        @Override
        public Set<Pair<Domain, NetworkSecurityConfig>> getPerDomainConfigs() {
            return null;
        }
    }

这里可以看到关键方法:setCleartextTrafficPermitted(usesCleartextTraffic),这个方法中的usesCleartextTraffic就是前文所说的布尔值变量,它决定了是否支持Http明文传输。
usesCleartextTraffic来源于上一步getConfigSource中的代码:

boolean usesCleartextTraffic = (mApplicationInfo.flags & ApplicationInfo.FLAG_USES_CLEARTEXT_TRAFFIC) != 0 && mApplicationInfo.targetSandboxVersion < 2;

其中:

public static final int FLAG_USES_CLEARTEXT_TRAFFIC = 1<<27;

关于ApplicationInfo.flags各位可以百度另行了解,这里这段代码的意义为:

API版本为>27,则返回 usesCleartextTraffic = false。

整个系统调用流程如下:

流程图.png

但是到此为止,我们的问题--【如何打破网络限制】还没有得到解决。

上述代码里,ManifestConfigSource会优先调用XmlConfigSource

所以我们可以初步得出:通过在AndroidManifest中配置xml文件,就能打破限制。那么如何配置呢?

我们先来看一下ManifestConfigSource的构造函数:

public ManifestConfigSource(Context context) {
        mContext = context;
        ApplicationInfo info = context.getApplicationInfo(); //1
        mApplicationInfoFlags = info.flags;
        mTargetSdkVersion = info.targetSdkVersion; 
        mConfigResourceId = info.networkSecurityConfigRes; //2
        mTargetSandboxVesrsion = info.targetSandboxVersion;
    }

这里,我们可以知道俩个信息:

  1. 注释2处,会去获取networkSecurityConfigRes网络安全配置;
  2. 注释1处可以看出,该网络安全配置信息来自application;

于是我在AndroidManifest-application尝试输入net...,果然as的代码提示就展示出了我要的配置:

application.png

networkSecurityConfig需要的是个xml文件,那么这个xml文件该如何配置才能绕过网络限制呢?

回到刚才的XmlConfigSource源码,这里我们需要关注俩个地方:

源码1:


    private List<Pair<NetworkSecurityConfig.Builder, Set<Domain>>> parseConfigEntry(
            XmlResourceParser parser, Set<String> seenDomains,
            NetworkSecurityConfig.Builder parentBuilder, int configType)
            throws IOException, XmlPullParserException, ParserException {
        ...
        for (int i = 0; i < parser.getAttributeCount(); i++) {
            String name = parser.getAttributeName(i);
            if ("hstsEnforced".equals(name)) {
                builder.setHstsEnforced(
                        parser.getAttributeBooleanValue(i,
                                NetworkSecurityConfig.DEFAULT_HSTS_ENFORCED));
            } else if ("cleartextTrafficPermitted".equals(name)) {
                builder.setCleartextTrafficPermitted(
                        parser.getAttributeBooleanValue(i,
                                NetworkSecurityConfig.DEFAULT_CLEARTEXT_TRAFFIC_PERMITTED));
            }
        }
        ...

parseConfigEntry解析并设置了是否允许明文传输,看来他就是关键。这里可以得出我们要配置的属性名为cleartextTrafficPermitted,它的值是boolean类型。

不要问我怎么找到cleartextTrafficPermitted这个属性的...明文传输就这一个关键字,全局搜索你就会发现只有这儿一处被调用。

源码2:

    private static final String getConfigString(int configType) {
        switch (configType) {
            case CONFIG_BASE:
                return "base-config";
            case CONFIG_DOMAIN:
                return "domain-config";
            case CONFIG_DEBUG:
                return "debug-overrides";
            default:
                throw new IllegalArgumentException("Unknown config type: " + configType);
        }
    }

上述源码可得:config的Type仅能为三者之一。这里我们不需要遍历源码去分析,从字段名就可以基本推断出是第一个。

所以这个xml如下所示:

<?xml version="1.0" encoding="utf-8"?>
<自定义你的名字>
    <base-config cleartextTrafficPermitted="true" />
</自定义你的名字>

将xml配置在上述networkSecurityConfig即可。

结论

OkHttp通过调用Android API中的isCleartextTrafficPermitted(host),在9.0系统上限制了Http明文请求。

所以可以有俩种方式绕过Http明文限制:
1.通过上述源码分析中的XmlConfigSource打开开关限制。
2.自己通过Socket写Http请求,或使用底层非OkHttp、且没有进行过Http明文判断的第三方网络框架。

通过配置XML绕过HTTP限制

下面就上述结论中的第一个方案给出完整的解决步骤:

首先在res文件夹下创建xml目录,新建network_security_config.xml文件,生成如下代码:

<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
    <base-config cleartextTrafficPermitted="true" />
</network-security-config>

然后在AndroidManifest.xml的Application中做如下配置:

android:networkSecurityConfig="@xml/network_security_config"

通过上述解析,应该可以大致理解这样配置的原理。

另外使用Volley还需要在application里配置如下代码:

 <uses-library android:name="org.apache.http.legacy" android:required="false" />

最后还是要说一句:

Android9.0选择了禁用Http明文请求,无论是从安全还是从其它方面考虑,我们都应该尽量遵守Android规定,共同维护Android环境,而不是想办法绕过限制。

Android框架源码