SSL和HTTPS

来源：互联网发布：qq清除数据后会怎样编辑：程序博客网时间：2024/06/05 08:05

SSL说明：

　　1）简介

　　SSL (Secure Socket Layer)为Netscape所研发，用以保障在Internet上数据传输之安全，利用数据加密(Encryption)技术，可确保数据在网络上之传输过程中不会被截取。它已被广泛地用于Web浏览器与服务器之间的身份认证和加密数据传输。SSL协议位于TCP/IP协议与各种应用层协议之间，为数据通讯提供安全支持。

　　2）SSL提供的服务

　　a.认证用户和服务器，确保数据发送到正确的客户机和服务器

　　b.加密数据以防止数据中途被窃取

　　c.维护数据的完整性，确保数据在传输过程中不被改变。

　　3) SSL协议的握手过程

　　SSL 协议既用到了公钥加密技术又用到了对称加密技术，对称加密技术虽然比公钥加密技术的速度快，可是公钥加密技术提供了更好的身份认证技术。SSL 的握手协议非常有效的让客户和服务器之间完成相互之间的身份认证，其主要过程如下：

　　①客户端的浏览器向服务器传送客户端SSL 协议的版本号，加密算法的种类，产生的随机数，以及其他服务器和客户端之间通讯所需要的各种信息。

　　②服务器向客户端传送SSL 协议的版本号，加密算法的种类，随机数以及其他相关信息，同时服务器还将向客户端传送自己的证书。

　　③客户利用服务器传过来的信息验证服务器的合法性，服务器的合法性包括：证书是否过期，发行服务器证书的CA 是否可靠，发行者证书的公钥能否正确解开服务器证书的“发行者的数字签名”，服务器证书上的域名是否和服务器的实际域名相匹配。如果合法性验证没有通过，通讯将断开；如果合法性验证通过，将继续进行第四步。

　　④用户端随机产生一个用于后面通讯的“对称密码”，然后用服务器的公钥（服务器的公钥从步骤②中的服务器的证书中获得）对其加密，然后传给服务器。

　　⑤服务器用私钥解密“对称密码”(此处的公钥和私钥是相互关联的，公钥加密的数据只能用私钥解密，私钥只在服务器端保留。详细请参看： http://zh.wikipedia.org/wiki/RSA%E7%AE%97%E6%B3%95)，然后用其作为服务器和客户端的“通话密码”加解密通讯。同时在SSL 通讯过程中还要完成数据通讯的完整性，防止数据通讯中的任何变化。

　　⑥客户端向服务器端发出信息，指明后面的数据通讯将使用的步骤⑤中的主密码为对称密钥，同时通知服务器客户端的握手过程结束。

　　⑦服务器向客户端发出信息，指明后面的数据通讯将使用的步骤⑤中的主密码为对称密钥，同时通知客户端服务器端的握手过程结束。

　　⑧SSL 的握手部分结束，SSL 安全通道的数据通讯开始，客户和服务器开始使用相同的对称密钥进行数据通讯，同时进行通讯完整性的检验。

1. 生成密钥库，密钥库中必须存放私钥和证书，此外为私钥设置的密码应该和密钥库的密码相同。服务器程序将自动从密钥库中提取证书，向客户程序表明自己是谁。

keytool -genkey -alias mytest -keyalg RSA -keysize 1024 -keystore mykeystore -validity 4000

2. 客户端欲和SSL服务器通信，则必须信任SSL服务器程序所使用的数字证书。因此客户程序应该将所信任的证书放在一个密钥库中，指定客户信任哪些证书，这样当其接收到服务器程序发来的证书后就可以判断是否相信服务器。

keytool -export -alias mytest -file mytest.cer -keystore mykeystore -storepass 123456 -rfc

keytool -import -alias mytest -file mytest.cer -keystore clienttrust

Server端的程序：

Java代码  
import java.io.PrintStream;  
import java.net.ServerSocket;  
import java.net.Socket;  
  
import javax.net.ssl.SSLServerSocketFactory;  
  
/** 
 * SSL server 
 * SSL编程和基于Socket的编程不同的地方在于其ServerSocket对象是通过一个特殊的对象：SSLServerSocketFactory类型的对象创建的， 
 * 这样以后的输入和输出流将自动按照SSL协议指定的方法交换密钥并对数据进行加密。 
 *  
 * @author jimmee 
 */  
public class MySSLServer {  
    public static void main(String args[]) throws Exception {  
        System.setProperty("javax.net.ssl.keyStore", "mykeystore");  
        System.setProperty("javax.net.ssl.keyStorePassword", "123456");  
        SSLServerSocketFactory ssf = (SSLServerSocketFactory) SSLServerSocketFactory  
                .getDefault();  
        ServerSocket ss = ssf.createServerSocket(5432);  
        System.out.println("Waiting for connection...");  
        while (true) {  
            Socket s = ss.accept();  
            PrintStream out = new PrintStream(s.getOutputStream());  
            out.println("Hi");  
            out.close();  
            s.close();  
        }  
    }  
}  

Client的程序：

Java代码  
import java.net.*;  
import java.io.*;  
import javax.net.ssl.*;  
  
/** 
 * SSL client程序 
 *  
 * <p> 
 * SSL客户端编程和基于Socket的客户端编程不同的地方在于其Socket对象是通过一个特殊 
 * 的对象：SSLSocketFactory类型的对象创建的。 
 *  
 * 由于clienttrust中存放的只是可以公开的证书，因此程序中不需要给出密钥库的密码。 
 *  
 * @author jimmee 
 * 
 */  
public class MySSLClient {  
    public static void main(String args[]) throws Exception {  
        System.setProperty("javax.net.ssl.trustStore", "clienttrust");  
  
        SSLSocketFactory ssf = (SSLSocketFactory) SSLSocketFactory.getDefault();  
        Socket s = ssf.createSocket("127.0.0.1", 5432);  
        BufferedReader in = new BufferedReader(new InputStreamReader(  
                s.getInputStream()));  
        String x = in.readLine();  
        System.out.println(x);  
        in.close();  
    }  
}  
  
import java.io.BufferedReader;  
import java.io.InputStreamReader;  
import java.net.Socket;  
import java.security.SecureRandom;  
import java.security.cert.CertificateException;  
import java.security.cert.X509Certificate;  
  
import javax.net.ssl.SSLContext;  
import javax.net.ssl.SSLSocketFactory;  
import javax.net.ssl.TrustManager;  
import javax.net.ssl.X509TrustManager;  
  
/** 
 * client端也可以选择不验证证书，直接通信 
 *  
 * @author jimmee 
 *  
 */  
public class MyClientNoValidate {  
  
    public static void main(String[] args) {  
        // Create a trust manager that does not validate certificate chains  
        TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {  
            public void checkClientTrusted(  
                    java.security.cert.X509Certificate[] arg0, String arg1)  
                    throws CertificateException {  
            }  
  
            public void checkServerTrusted(  
                    java.security.cert.X509Certificate[] arg0, String arg1)  
                    throws CertificateException {  
            }  
  
            public java.security.cert.X509Certificate[] getAcceptedIssuers() {  
                return new X509Certificate[0];  
            }  
        } };  
  
        // Install the all-trusting trust manager  
        try {  
            SSLContext sc = SSLContext.getInstance("SSL");  
            sc.init(null, trustAllCerts, new SecureRandom());  
            SSLSocketFactory ssf = sc.getSocketFactory();  
            Socket s = ssf.createSocket("127.0.0.1", 5432);  
            BufferedReader in = new BufferedReader(new InputStreamReader(  
                    s.getInputStream()));  
            String x = in.readLine();  
            System.out.println(x);  
            in.close();  
        } catch (Exception e) {  
        }  
    }  
}  

https：

Server端：

Java代码  
import java.net.*;  
import java.io.*;  
  
import javax.net.ssl.*;  
  
/** 
 * https 
 *  
 * @author jimmee 
 * 
 */  
  
public class MyHttpsServer {  
    public static void main(String args[]) {  
        int i = 0;  
        try {  
            System.setProperty("javax.net.ssl.keyStore", "mykeystore");  
            System.setProperty("javax.net.ssl.keyStorePassword", "123456");  
            SSLServerSocketFactory ssf = (SSLServerSocketFactory) SSLServerSocketFactory  
                    .getDefault();  
            ServerSocket ss = ssf.createServerSocket(443);  
            System.out.println("Web Server OK ");  
  
            while (true) {  
                Socket s = ss.accept(); // 等待请求  
                PrintStream out = new PrintStream(s.getOutputStream());  
                BufferedReader in = new BufferedReader(new InputStreamReader(  
                        s.getInputStream()));  
                String info = null;  
                while ((info = in.readLine()) != null) {  
                    System.out.println("now got " + info);  
                    if (info.equals(""))  
                        break;  
                }  
  
                System.out.println("now go");  
                out.println("HTTP/1.0 200 OK");  
                out.println("MIME_version:1.0");  
                out.println("Content_Type:text/html");  
                i++;  
                String c = "<html> <head></head><body> <h1> Hi,  this is " + i  
                        + "</h1></Body></html>";  
                out.println("Content_Length:" + c.length());  
                out.println("");  
                out.println(c);  
                out.close();  
                s.close();  
                in.close();  
            }  
        } catch (IOException e) {  
            System.out.println(e);  
        }  
    }  
}  

client端：

Java代码  
import java.io.BufferedReader;  
import java.io.InputStreamReader;  
import java.net.URL;  
import java.net.URLConnection;  
import java.security.SecureRandom;  
import java.security.cert.CertificateException;  
import java.security.cert.X509Certificate;  
  
import javax.net.ssl.HostnameVerifier;  
import javax.net.ssl.HttpsURLConnection;  
import javax.net.ssl.SSLContext;  
import javax.net.ssl.SSLSession;  
import javax.net.ssl.TrustManager;  
import javax.net.ssl.X509TrustManager;  
  
/** 
 * https的client选择不验证证书，直接通信 
 *  
 * @author jimmee 
 *  
 */  
public class MyHttpsClientNoValidate {  
  
    public static void main(String[] args) {  
        // Create a trust manager that does not validate certificate chains  
        TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {  
            public void checkClientTrusted(  
                    java.security.cert.X509Certificate[] arg0, String arg1)  
                    throws CertificateException {  
            }  
  
            public void checkServerTrusted(  
                    java.security.cert.X509Certificate[] arg0, String arg1)  
                    throws CertificateException {  
            }  
  
            public java.security.cert.X509Certificate[] getAcceptedIssuers() {  
                return new X509Certificate[0];  
            }  
        } };  
          
        // Ignore differences between given hostname and certificate hostname  
        HostnameVerifier hv = new HostnameVerifier() {  
            public boolean verify(String hostname, SSLSession session) {  
                return true;  
            }  
        };  
  
        // Install the all-trusting trust manager  
        try {  
            SSLContext sc = SSLContext.getInstance("SSL");  
            sc.init(null, trustAllCerts, new SecureRandom());  
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());  
            HttpsURLConnection.setDefaultHostnameVerifier(hv);  
              
            URL url = new URL("https://127.0.0.1");  
            URLConnection con = url.openConnection();  
            BufferedReader in = new BufferedReader(new InputStreamReader(  
                    con.getInputStream()));  
            String x = in.readLine();  
            System.out.println(x);  
            in.close();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}  
转载：http://jimmee.iteye.com/blog/2070990

阅读全文

0 0