HTTPS 数字签名 证书

HTTPS

先来看一下HTTPS的定义： 
HTTPS(Hyper Text Transfer Protocol Secure)是一种经过计算机网络进行安全通信的传输协议。HTTPS经由HTTP进行通信，但利用TLS来加密数据包。HTTPS开发的主要目的，是提供对网站服务器的身份验证，保护交换数据的隐私与完整性。 
也就是说，HTTPS就是在HTTP协议的基础上加入了TLS协议。为什么用TLS协议而不是SSL协议呢？ 
TLS是传输层加密协议，前身是SSL协议。常用的TLS协议版本有： TLS1.2, TLS1.1, TLS1.0和SSL3.0。其中，SSL3.0已经被证实不安全，TLS1.0也存在部分安全漏洞。 
HTTPS相对HTTP提供了更安全的数据传输保障，主要体现在三个方面： 
(1)内容加密 
客户端到服务器的内容都是以加密形式传输，中间者无法直接查看明文内容 
(2)身份认证 
通过校验保证客户端访问的是自己的服务器 
(3)数据完整性 
防止内容被第三方冒充或者篡改

SSL/TLS协议及握手过程

和TCP在建立连接时的三次握手一样，SSL/TLS也需要客户端和服务器之间进行握手，但是目的不一样。在SSL/TLS握手的过程中，客户端和服务器彼此交换并验证证书，并协商出一个"对话密钥"，后续的所有通信都是用这个"对话密钥"进行加密，保证通信安全。 
用一张图来简单的说明一下握手的过程： 

为了提高安全性和效率，HTTPS结合了对称和非对称两种加密方式。客户端使用对称加密生成密钥key对传输数据进行加密，然后使用非对称加密的公钥对key再次加密。因此网络上传输的数据是被key加密的密文和用公钥加密后的密文key，即使被黑客截获，由于没有私钥便无法获取明文key，也就无法获取原始数据，因此HTTPS的加密方式是安全的。 
以TLS1.2为例来认识HTTPS的握手过程： 
(1)客户端发送client_hello，包含了一个随机数random1 
(2)服务器回复server_hello，包含一个随机数random2，携带证书公钥P 
(3)客户端拿到这个random2之后做两件事，第一件事是生成对称加密的密钥key，并用该密钥对要传输的数据加密；第二件事就是用公钥P对key加密，并将加密后的key和数据都发送给服务器 
(4)服务器使用私钥得到key，并用key对数据加密，在相同的输入参数下能得到跟客户端传来的一样的数据。

在访问某些HTTPS站点时可能会遇到下面的异常： 
javax.net.ssl.SSLHandshakeException: 
sun.security.validator.ValidatorException: PKIX path building failed: 
sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target 
这个异常就是HTTPS握手的过程中出现了问题。

 

数字证书

HTTPS通过对称加密和非对称加密实现数据的安全传输，在非对称加密的过程中需要用公钥来加密，这里的公钥实际上就被包含在数字证书中。 
数字证书通常来说是由受信任的数字证书颁发机构CA，在验证了服务器身份后颁发，证书中包含了一个密钥对(公钥和私钥)和所有者识别信息。数字证书被放到服务器端，具有服务器身份验证和数据传输加密的功能。 
来看一下证书的申请流程： 

如果一个用户想要得到一份属于自己的证书，首先应该向CA提出申请。在CA判明申请者的身份之后，便为他分配一个公钥，并且将该公钥与申请者的身份信息绑在一起，并为之签字，便形成了数字证书发给申请者。 
如果一个用户想要鉴别另一个证书的真伪，就用CA的公钥对那个证书上的签字进行验证。一旦验证通过，该证书就被认为是有效的。 
通过这种方式，黑客就不能简单的修改证书中的公钥了，因为公钥有了CA的数字签名，由CA证明公钥的有效性，不能被轻易篡改。

 

CA证书具有层级结构，它建立了自上而下的信任链。下级CA信任上级CA，下级CA由上级CA颁发证书并认证。那么根证书由谁来验证呢？根证书自己证明自己，换句话说，根证书不需要被证明。根证书是整个证书链的安全之本，如果根证书被篡改，那么整个证书体系的安全将受到威胁。所以不要轻易相信根证书，当下次访问某个网站遇到提示说，请安装我们的根证书，最好留个心眼。 
除了CA机构颁发的证书之外，还有非CA机构颁发的证书和自签名证书： 
(1)非CA机构即不受信任的机构颁发的证书 
(2)自签名证书，就是自己给自己颁发的证书 
比如12306网站在首页都会标明： 
为保障您顺畅购票，请下载安装根证书。 
关于12306的安装根证书的问题，可以看网上的几篇博客： 
在线买票为什么要安装根证书 
12306的证书问题

 

浏览器验证证书 
浏览器保存了一个常用的CA证书列表，在验证证书链的有效性时，直接使用保存的证书里的公钥进行校验。如果在证书列表中没有找到或者找到了但是校验不通过，那么浏览器会警告用户，由用户决定是否继续。 
浏览器主要从三个方面验证证书，任何一个不满足都会给出警告： 
(1)证书的颁发者是否在"根受信任的证书颁发机构列表"中 
(2)证书是否过期 
(3)证书的持有者是否和访问的网站一致 
另外，浏览器还会定期查看证书颁发者公布的"证书吊销列表"，如果某个证书符合上面的三个条件，但是被它的颁发者在"证书吊销列表"中列出，那么也将给出警告。Windows对这个列表是不敏感的，也就是说windows的api会缓存这个列表，直到设置的缓存过期才会再次去下载最新的列表。

操作系统验证证书 
同样，操作系统也保存了一份可信的证书列表，可以运行certmgr.msc打开证书管理器查看，这些证书实际上是存储在Windows的注册表中，一般在\SOFTWARE\Microsoft\SystemCertificates\下。

 

JAVA验证证书 
在Java平台下，证书常常被存储在KeyStore文件中，KeyStore不仅可以存储数字证书，还可以存储密钥。存储在KeyStore文件中的对象有三类： 
Certificate: 证书 
PrivateKey: 非对称加密中的私钥 
SecretKey: 对称加密中的密钥 
KeyStore文件根据用途有很多种不同的格式：JKS, JCEKS, PKCS12, DKS等等。 
Java里的KeyStore文件分成两种类型：KeyStore和TrustStore，不过这两个从文件格式上来看是一样的。KeyStore保存私钥，用来加解密或为别人做签名。TrustStore保存一些可信任的证书，访问HTTPS时对被访问者进行认证，以确保它是可信任的。 
除了KeyStore和TrustStore，Java还有两个类KeyManager和TrustManager与此相关。看下面一张图说明各个类之间的关系： 
 
那么具体的编程就可以包括以下几个步骤： 
(1)使用KeyStore类将证书库或信任库加载进来 
(2)使用KeyManagerFactory和加载了证书库的KeyStore实例，生成KeyManager实例数组 
(3)使用TrustManagerFactory和加载了信任库的KeyStore实例，生成TrustManager实例数组 
(4)使用SSLContext初始化KeyManager实例数组和TrustManager实例数组，从而设定好通信的环境 
(5)利用SSLContext产生的SSLSocket和SSLServerSocket进行通信

HTTPS单向认证 
单向认证是指只要服务器配置证书，客户端在请求服务器时验证服务器的证书即可。上述讲到的内容大部分都是HTTPS单向认证，对于安全性要求不高的网站单向认证即可。
在Android系统中已经内置了所有CA机构的根证书，也就是说，只要是CA机构颁发的证书，Android是直接信任的。对于这种情况，虽然能正常访问到服务器，但是仍然存在安全隐患。如果黑客自家搭建了一个服务器并申请到了CA证书，那么黑客仍然能发起中间人攻击劫持我们的请求到黑客的服务器，实际上就成了我们的客户端和黑客的服务器建立起了连接。 
对于非CA机构颁发的证书和自签名证书，我们是无法直接访问到服务器的，直接访问通常会抛出异常：

javax.net.ssl.SSLHandshakeException:
java.security.cert.CertPathValidatorException:
Trust anchor forcertification path not found.

有两种方法可以通过忽略证书直接调用： 
方法一：自定义TrustManager绕过证书检查

@Test
public void basicHttpsGetIgnoreCertificateValidation() throws Exception {
     
    String url = "https://kyfw.12306.cn/otn/";
     
    // Create a trust manager that does not validate certificate chains
    TrustManager[] trustAllCerts = new TrustManager[] {
        new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
            public void checkClientTrusted(X509Certificate[] certs, String authType) {
                // don't check
            }
            public void checkServerTrusted(X509Certificate[] certs, String authType) {
                // don't check
            }
        }
    };
     
    SSLContext ctx = SSLContext.getInstance("TLS");
    ctx.init(null, trustAllCerts, null);
     
    LayeredConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(ctx);
     
    CloseableHttpClient httpclient = HttpClients.custom()
            .setSSLSocketFactory(sslSocketFactory)
            .build();
     
    HttpGet request = new HttpGet(url);
    request.setHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64) ...");
     
    CloseableHttpResponse response = httpclient.execute(request);
    String responseBody = readResponseBody(response);
    System.out.println(responseBody);
}

方法二：信任所有证书

@Test
public void basicHttpsGetIgnoreCertificateValidation() throws Exception {
    
        SSLContextBuilder builder = new SSLContextBuilder();
        //JAVA8支持的新语法
        //TrustStrategy acceptingTrustStrategy = ((X509Certificate[] certificate,String type) -> true);
        //builder.loadTrustMaterial(null, acceptingTrustStrategy);
        
        //上面这两步可以这么写：
        builder.loadTrustMaterial(new TrustStrategy(){
            @Override
            public boolean isTrusted(X509Certificate[] arg0, String arg1)
                    throws CertificateException {
                return true;
            }
        });
        
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(builder.build());
        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(
            sslsf).build();
            HttpGet httpGet = new HttpGet("https://some-server");
    CloseableHttpResponse response = httpclient.execute(httpGet);
    try {
        System.out.println(response.getStatusLine());
        HttpEntity entity = response.getEntity();
        EntityUtils.consume(entity);
    }
    finally {
        response.close();
    }
}

方法二虽然解决了SSHHandshakeException异常，但是由于客户端信任所有的证书，反而存在更大的隐患。

单向验证且服务器证书可信

package com.ydd.study.hello.httpclient;
/**
 * @COPYRIGHT (C) 2018 Schenker AG
 * 

 * All rights reserved
 */

import org.apache.http.HttpHost;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.routing.HttpRoute;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;
import java.io.File;
import java.io.IOException;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;


public class oneWayAuthTest {
    public static CloseableHttpClient httpclient;

    // 获得池化得HttpClient
    static {
        // 设置truststore
        SSLContext sslcontext = null;
        try {
            sslcontext = SSLContexts.custom()
                                    .loadTrustMaterial(new File("D://https//ca//cl.jks"),
                                    "123456".toCharArray(), new TrustSelfSignedStrategy())
                                    .build();
        }
        catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 客户端支持TLSV1，TLSV2,TLSV3这三个版本
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                sslcontext, new String[]{"TLSv1", "TLSv2", "TLSv3"}, null,
                SSLConnectionSocketFactory.getDefaultHostnameVerifier());// 客户端验证服务器身份的策略

        // Create a registry of custom connection socket factories for supported
        // protocol schemes.
        Registry socketFactoryRegistry = RegistryBuilder
                .create()
                .register("http", PlainConnectionSocketFactory.INSTANCE)
                .register("https", new SSLConnectionSocketFactory(sslcontext))
                .build();
        PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(
                socketFactoryRegistry);
        // Configure total max or per route limits for persistent connections
        // that can be kept in the pool or leased by the connection manager.
        connManager.setMaxTotal(100);
        connManager.setDefaultMaxPerRoute(10);
        // 个性化设置某个url的连接
        connManager.setMaxPerRoute(new HttpRoute(new HttpHost("www.y.com",
                80)), 20);
        httpclient = HttpClients.custom().setConnectionManager(connManager)
                .build();

    }

    /**
     * 单向验证且服务端的证书可信
     * @throws IOException
     * @throws ClientProtocolException
     */
    public static void oneWayAuthorizationAccepted() throws ClientProtocolException, IOException {
        // Execution context can be customized locally.
        HttpClientContext context = HttpClientContext.create();
        HttpGet httpget = new HttpGet("https://www.yunzhu.com:8443");
        // 设置请求的配置
        RequestConfig requestConfig = RequestConfig.custom()
                .setSocketTimeout(5000).setConnectTimeout(5000)
                .setConnectionRequestTimeout(5000).build();
        httpget.setConfig(requestConfig);

        System.out.println("executing request " + httpget.getURI());
        CloseableHttpResponse response = httpclient.execute(httpget, context);
        try {
            System.out.println("----------------------------------------");
            System.out.println(response.getStatusLine());
            System.out.println(EntityUtils.toString(response.getEntity()));
            System.out.println("----------------------------------------");

            // Once the request has been executed the local context can
            // be used to examine updated state and various objects affected
            // by the request execution.

            // Last executed request
            context.getRequest();
            // Execution route
            context.getHttpRoute();
            // Target auth state
            context.getTargetAuthState();
            // Proxy auth state
            context.getTargetAuthState();
            // Cookie origin
            context.getCookieOrigin();
            // Cookie spec used
            context.getCookieSpec();
            // User security token
            context.getUserToken();

        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    public static void main(String[] a) throws KeyManagementException,
            NoSuchAlgorithmException, KeyStoreException, CertificateException,
            IOException {
        oneWayAuthorizationAccepted();
    }

}

 

转载于:https://www.cnblogs.com/lyy-2016/p/9140186.html