# Http 请求dns 劫持

解决方案：

• 
  

  HttpDns 服务器接入 「阿里云 收费 腾讯HttpDns 服务器免费（接入方案 七牛云 sdk）」

  
  


• 
  

  OkHttp HttpDns + 证书验证

  
  

# OkHttp HttpDns + 证书验证

OkHttp 是一个处理网络请求的开源项目，是 Android 端最火热的轻量级网络框架。在 OkHttp 中，默认是使用系统的 DNS 服务 InetAddress 进行域名解析

而想在 OkHttp 中使用 HTTPDNS，有两种方式。

• 通过拦截器，在发送请求之前，将域名替换为 IP 地址。


• 通过 OkHttp 提供的 .dns() 接口，配置 HTTPDNS。

对这两种方法来说，当然是推荐使用标准 API 来实现了。拦截器的方式，也建议有所了解，实现很简单，但是有坑。

# OkHttp 拦截器接入方式

拦截器是 OkHttp 中，非常强大的一种机制，它可以在请求和响应之间，做一些我们的定制操作。

在 OkHttp 中，可以通过实现 Interceptor 接口，来定制一个拦截器。使用时，只需要在 OkHttpClient.Builder 中，调用 addInterceptor() 方法来注册此拦截器即可。

class HTTPDNSInterceptor : Interceptor{

    override fun intercept(chain: Interceptor.Chain): Response {

        val originRequest = chain.request()

        val httpUrl = originRequest.url()



        val url = httpUrl.toString()

        val host = httpUrl.host()



        val hostIP = HttpDNS.getIpByHost(host)

        val builder = originRequest.newBuilder()



        if(hostIP!=null){

            builder.url(HttpDNS.getIpUrl(url,host,hostIP))

            builder.header("host",hostIP)

        }

        val newRequest = builder.build()

        val newResponse = chain.proceed(newRequest)

        return newResponse

    }

}

复制代码

在拦截器中，使用 HttpDNS 这个帮助类，通过 getIpByHost() 将 Host 转为对应的 IP。

如果通过抓包工具抓包，你会发现，原本的类似 http://www.cxmydev.com/api/user 的请求，被替换为：http://220.181.57.xxx/api/user

拦截器接入的坏处:

使用拦截器，直接绕过了 DNS 的步骤，在请求发送前，将 Host 替换为对应的 IP 地址。

这种方案，在流程上很清晰，没有任何技术性的问题。但是这种方案存在一些问题，例如：HTTPS 下 IP 直连的证书问题、代理的问题、Cookie 的问题等等。

其中最严重的问题是，此方案（拦截器+HTTPDNS）遇到 https 时，如果存在一台服务器支持多个域名，可能导致证书无法匹配的问题。

在说到这个问题之前，就要先了解一下 HTTPS 和 SNI。

HTTPS 是为了保证安全的，在发送 HTTPS 请求之前，首先要进行 SSL/TLS 握手，握手的大致流程如下：

1. 客户端发起握手请求，携带随机数、支持算法列表等参数。


2. 服务端根据请求，选择合适的算法，下发公钥证书和随机数。


3. 客户端对服务端证书，进行校验，并发送随机数信息，该信息使用公钥加密。


4. 服务端通过私钥获取随机数信息。


5. 双方根据以上交互的信息，生成 Session Ticket，用作该连接后续数据传输的加密密钥。

在这个流程中，客户端需要验证服务器下发的证书。首先通过本地保存的根证书解开证书链，确认证书可信任，然后客户端还需要检查证书的 domain 域和扩展域，看看是否包含本次请求的 HOST。

在这一步就出现了问题，当使用拦截器时，请求的 URL 中，HOST 会被替换成 HTTPDNS 解析出来的 IP。当服务器存在多域名和证书的情况下，服务器在建立 SSL/TLS 握手时，无法区分到底应该返回那个证书，此时的策略可能返回默认证书或者不返回，这就有可能导致客户端在证书验证 domain 时，出现不匹配的情况，最终导致 SSL/TLS 握手失败。

这就引发出来 SNI 方案，SNI（Server Name Indication）是为了解决一个服务器使用多个域名和证书的 SSL/TLS 扩展。

SNI 的工作原理，在连接到服务器建立 SSL 连接之前，先发送要访问站点的域名（hostname），服务器根据这个域名返回正确的证书。现在，大部分操作系统和浏览器，都已经很好的支持 SNI 扩展。

3. 拦截器 + HTTPDNS 的解决方案

这个问题，其实也有解决方案，这里简单介绍一下。

针对 "domain 不匹配" 的问题，可以通过 hook 证书验证过程中的第二步，将 IP 直接替换成原来的域名，再执行证书验证。

而 HttpURLConnect，提供了一个 HostnameVerifier 接口，实现它即可完成替换。

public interface HostnameVerifier {

    public boolean verify(String hostname, SSLSession session);

}

复制代码

如果使用 OkHttp，可以参考 OkHostnameVerifier (source://src/main/java/okhttp3/internal/tls/OkHostnameVerifier.java) 的实现，进行替换。

本身 OkHttp 就不建议通过拦截器去做 HTTPDNS 的支持，所以这里就不展开讨论了，这里只提出解决的思路，有兴趣可以研究研究源码

# OkHttp 标准 Api 接入

OkHttp 其实本身已经暴露了一个 Dns 接口，默认的实现是使用系统的 InetAddress 类，发送 UDP 请求进行 DNS 解析

我们只需要实现 OkHttp 的 Dns 接口，即可获得 HTTPDNS 的支持。

在我们实现的 Dns 接口实现类中，解析 DNS 的方式，换成 HTTPDNS，将解析结果返回。

class HttpDns : Dns {

    override fun lookup(hostname: String): List<InetAddress> {

        val ip = HttpDnsHelper.getIpByHost(hostname)

        if (!TextUtils.isEmpty(ip)) {

            //返回自己解析的地址列表

            return InetAddress.getAllByName(ip).toList() 

        } else {

            // 解析失败，使用系统解析

            return Dns.SYSTEM.lookup(hostname)

        }

    }

}

复制代码

使用也非常的简单，在 OkHttp.build() 时，通过 dns() 方法配置。

mOkHttpClient = httpBuilder

        .dns(HttpDns())

        .build();

复制代码

这样做的好处在于：

• 
  

  还是用域名进行访问，只是底层 DNS 解析换成了 HTTPDNS，以确保解析的 IP 地址符合预期。

  
  


• 
  

  HTTPS 下的问题也得到解决，证书依然使用域名进行校验。

  
  

OkHttp 既然暴露出 dns 接口，我们就尽量使用它。

# WebView loadUrl() dns 劫持

Android Webview场景下防止dns劫持的探索

解决方案:

• 
  

  HttpDns

  
  


• 
  

  webViewClient 配置

  
  


• 
  

  腾讯 x5 引擎 x5WebView 自带防劫持

  
  

# webView webViewClient

void setWebViewClient(WebViewClient client)

复制代码

@SuppressLint("NewApi")

        @Override

        public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {



            final String scheme = request.getUrl().getScheme().trim();

            final String url = request.getUrl().toString();

            final Map<String, String> headerFields = request.getRequestHeaders();



            // #1 只拦截get方法

            if (request.getMethod().equalsIgnoreCase("get") && (scheme.equalsIgnoreCase("http") || scheme.equalsIgnoreCase("https"))) {

                try {

                    final URL oldUrl = new URL(url);

                    HttpURLConnection conn;



                    // #2 通过httpdns替换ip

                    final String ip = mService.getIpByHostAsync(oldUrl.getHost());

                    if (!TextUtils.isEmpty(ip)) {

                        final String host = oldUrl.getHost();

                        final String newUrl = url.replaceFirst(host, ip);



                        // #3 设置HTTP请求头Host域

                        conn = (HttpURLConnection) new URL(newUrl).openConnection();

                        conn.setRequestProperty("Host", host);



                        // #4 设置HTTP请求header

                        for (String header : headerFields.keySet()) {

                            conn.setRequestProperty(header, headerFields.get(header));

                        }



                        // #5 处理https场景

                        if (conn instanceof HttpsURLConnection) {

                            ((HttpsURLConnection) conn).setHostnameVerifier(new HostnameVerifier() {

                                @Override

                                public boolean verify(String hostname, SSLSession session) {

                                    return HttpsURLConnection.getDefaultHostnameVerifier().verify(host, session);

                                }

                            });

                        }



                        // #6 拿到MINE和encoding

                        final String contentType = conn.getContentType();

                        final String mine = getMine(contentType);

                        final String encoding = getEncoding(contentType);



                        // #7 MINE和encoding拿不到的情况下，不拦截

                        if (TextUtils.isEmpty(mine) || TextUtils.isEmpty(encoding)) {

                            return super.shouldInterceptRequest(view, request);

                        }



                        return new WebResourceResponse(mine, encoding, conn.getInputStream());

                    }

                } catch (Exception e) {

                    e.printStackTrace();

                }

            }



            return super.shouldInterceptRequest(view, request);

        }

复制代码