zoukankan      html  css  js  c++  java
  • 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握手的过程中,客户端和服务器彼此交换并验证证书,并协商出一个"对话密钥",后续的所有通信都是用这个"对话密钥"进行加密,保证通信安全。 
    用一张图来简单的说明一下握手的过程: 
    Capture.PNG-90.5kB

    为了提高安全性和效率,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,在验证了服务器身份后颁发,证书中包含了一个密钥对(公钥和私钥)和所有者识别信息。数字证书被放到服务器端,具有服务器身份验证和数据传输加密的功能。 
    来看一下证书的申请流程: 
    Capture1.PNG-27.4kB

    如果一个用户想要得到一份属于自己的证书,首先应该向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的注册表中,一般在SOFTWAREMicrosoftSystemCertificates下。

     

    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与此相关。看下面一张图说明各个类之间的关系: 
    Capture3.PNG-73.8kB 
    那么具体的编程就可以包括以下几个步骤: 
    (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
     * <p/>
     * 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<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder
                    .<ConnectionSocketFactory>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();
        }
    
    }
  • 相关阅读:
    把自己电脑搭建为服务器(免费内网穿透心得)
    多态复习
    hadoop 第一个 mapreduce 程序(对MapReduce的几种固定代码的理解)
    Anaconda下的 Jupyter Notebook 安装 多python环境
    C++读写内存工具类X64 X86
    VS中MFC项目文件特别大的解决办法
    python记事本实现查询替换
    java格式化代码(java格式化代码工具类)
    Vue 之 slot(插槽)
    Vue全家桶之——Vuex
  • 原文地址:https://www.cnblogs.com/lyy-2016/p/9140186.html
Copyright © 2011-2022 走看看