用SSL构建安全的Socket

最新推荐文章于 2023-10-07 09:45:27 发布

_HYC_

最新推荐文章于 2023-10-07 09:45:27 发布

阅读量1.7k

点赞数

分类专栏：学习笔记文章标签： socket ssl 安全

学习笔记专栏收录该内容

10 篇文章 1 订阅

订阅专栏

##说明SSL
SSL(安全套接层)是 Netscape公司在1994年开发的，最初用于WEB浏览器，为浏览器与服务器间的数据传递提供安全保障，提供了加密、来源认证和数据完整性的功能。现在SSL3.0得到了普遍的使用，它的改进版TLS(传输层安全)已经成为互联网标准。SSL本身和TCP套接字连接是很相似的，在协议栈中，SSL可以被简单的看作是安全的TCP连接，但是某些TCP连接的特性它是不支持的，比如带外数据(out-of-bound)。

在构建基于 Socket的C/S程序时，通过添加对SSL的支持来保障数据安全和完整是不错的方法。完善的Java为我们提供了简单的实现方法：JSSE(Java 安全套接字扩展)。JSSE是一个纯Java实现的SSL和TLS协议框架，抽象了SSL和TLS复杂的算法，使安全问题变得简单。JSSE已经成为 J2SE1.4版本中的标准组件，支持SSL 3.0和TLS 1.0。我们将通过一个具体的例子演示JSSE的一些基本应用。例子中的服务器端将打开一个SSL Socket，只有持有指定证书的客户端可以与它连接，所有的数据传递都是加密的。

构造一个SSLSocket是非常简单的：

SSLServerSocketFactory factory=(SSLServerSocketFactory)SSLServerSocketFactory.getDefault();
SSLServerSocket server = (SSLServerSocket) factory.createServerSocket(portNumber);
SSLSocket socket = (SSLSocket);

但是执行这样的程序会产生一个异常，报告找不到可信任的证书。SSLSocket和普通的Socket是不一样的，它需要一个证书来进行安全认证。

1. 证书

生成一个CA证书，在命令行下执行：

keytool –genkey –keystore SSLKey –keyalg rsa –alias SSL

黑体部分是用户可以自己指定的参数，第一个参数是要生成的证书的名字，第二个参数是证书的别名。rsa指明了我们使用的加密方法。

系统会要求输入证书发放者的信息，逐项输入即可

系统生成的文件命将会和证书名相同。证书可以提交给权威CA认证组织审核，如果通过审核，组织会提供信任担保，向客户担保你的连接是安全的。当然这不是必须的。在我们的例子中会把证书直接打包到客户端程序中，保证客户端是授权用户，避免伪造客户，所以不需要提交审核。

二、服务器端

现在可以编写服务器端的代码，与普通的Socket代码不同，我们需要在程序中导入证书，并使用该证书构造SSLSocket。需要的说明的是：

●KeyStore ks=KeyStore.getInstance(“JKS”);

访问Java密钥库，JKS是keytool创建的Java密钥库，保存密钥。

● KeyManagerFactory kmf=KeyManagerFactory.getInstance(“SunX509”);

创建用于管理JKS密钥库的X.509密钥管理器。

● SSLContext sslContext=SSLContext.getInstance(“SSLv3”);

构造SSL环境，指定SSL版本为3.0，也可以使用TLSv1，但是SSLv3更加常用。

●sslContext.init(kmf.getKeyManagers(),null,null);

初始化SSL环境。第二个参数是告诉JSSE使用的可信任证书的来源，设置为null是从javax.NET.ssl.trustStore中获得证书。第三个参数是JSSE生成的随机数，这个参数将影响系统的安全性，设置为null是个好选择，可以保证JSSE的安全性。

     import java.net.*;
    import javax.net.ssl.*;
    import java.io.*;
    import java.security.*;

    public class SSLServer{
    static int port=8266;  
    static SSLServerSocket server;

    /*
    *构造函数
    */

    public SSLServer()
    {

    }


    /*
    *@param port 监听的端口号
    *@return 返回一个SSLServerSocket对象
    */

    private static SSLServerSocket getServerSocket(int thePort)
    {
        SSLServerSocket s=null;
    try
    {
        String key="SSLKey";  //要使用的证书名

        char keyStorePass[]="12345678".toCharArray();  //证书密码

        char keyPassword[]="12345678".toCharArray();  //证书别称所使用的主要密码

        KeyStore ks=KeyStore.getInstance("JKS");  //创建JKS密钥库

        ks.load(new FileInputStream(key),keyStorePass);

        //创建管理JKS密钥库的X.509密钥管理器
        KeyManagerFactory kmf=KeyManagerFactory.getInstance("SunX509");

        kmf.init(ks,keyPassword);

        SSLContext sslContext=SSLContext.getInstance("SSLv3");

        sslContext.init(kmf.getKeyManagers(),null,null);

        //根据上面配置的SSL上下文来产生SSLServerSocketFactory,与通常的产生方法不同
        SSLServerSocketFactory factory=sslContext.getServerSocketFactory();

        s=(SSLServerSocket)factory.createServerSocket(thePort);

    }catch(Exception e)
    {
    System.out.println(e);
    }
    return(s);
    }


    public static void main(String args[])
    {
    try
    {
    server=getServerSocket(port);
    System.out.println("在”+port+”端口等待连接...");

    while(true)
    {
    SSLSocket socket=(SSLSocket)server.accept();

    //将得到的socket交给CreateThread对象处理,主线程继续监听
    new CreateThread(socket);

    }
    }catch(Exception e)
    {
    System.out.println("main方法错误80:"+e);
    }
    }
    }

    /*
    *内部类,获得主线程的socket连接,生成子线程来处理
    */

    class CreateThread extends Thread
    {
    static BufferedReader in;
    static PrintWriter out;
    static Socket s;

    /*
    *构造函数,获得socket连接,初始化in和out对象
    */

    public CreateThread(Socket socket)
    {
    try
    {
    s=socket;
    in=new BufferedReader(new InputStreamReader(s.getInputStream(),"gb2312"));

    out=new PrintWriter(s.getOutputStream(),true);

    start();  //开新线程执行run方法

    }catch(Exception e)
    {
    System.out.println(e);
    }

    }

    /*
    *线程方法,处理socket传递过来的数据
    */

    public void run()
    {
    try
    {
    String msg=in.readLine();
    System.out.println(msg);
    s.close();
    }catch(Exception e)
    {
    System.out.println(e);
    }
    }
    }

将我们刚才生成的证书放到程序所在的目录下，上面的代码就可以在编译之后执行：

java org.ec107.ssl.SSLServer

在8266端口等待连接…

三、客户端

客户端的代码相对简单，我们可以不在程序中指定SSL环境，而是在执行客户端程序时指定。需要注意的是客户端并没有导入证书，而是采用了默认的工厂方法构造SSLSocket：

      ● SSLSocketFactory factory=(SSLSocketFactory)SSLSocketFactory.getDefault();

    构造默认的工厂方法

    ●Socket s=factory.createSocket("localhost",port);

    打开一个SSLSocket连接

     /*
    *SSL Socket 的客户端
    *@Author Bromon
    */

    package org.ec107.ssl;

    import java.net.*;
    import javax.net.ssl.*;
    import javax.net.*;
    import java.io.*;

    public class SSLClient
    {
    static int port=8266;
    public static void main(String args[])
    {
    try
    {
    SSLSocketFactory factory=(SSLSocketFactory)SSLSocketFactory.getDefault();

    Socket s=factory.createSocket("localhost",port);

    PrintWriter out=new PrintWriter(s.getOutputStream(),true);
    out.println("安全的说你好");
    out.close();
    s.close();
    }catch(Exception e)
    {
    System.out.println(e);
    }
    }
    }

把服务器产生的证书(SSLKey)拷贝到程序所在的目录，执行这个程序的时候需要向javax.net.ssl.trustStore环境变量传入证书名：

java –Djavax.net.ssl.trustStore=SSLKey org.ec107.ssl.SSLClient

可以在服务器的控制台看到客户端发送过来的数据。

执行客户端可以有另一种方法，把证书拷贝到java home/lib/security目录下，名字改为jssecacerts，然后可以直接执行客户端：

java org.ec107.ssl.SSLClient

程序会自动的到上述目录下去寻找jssecacerts文件作为默认的证书。需要注意的是这里的java home并不是我们在安装J2SE时指定的那个JAVA_HOME。可以执行一个程序来得到java home的位置：

public class GetJavaHome

{
public static void main(String args[])
{
System.out.println(System.getProperty(“java.home”));
}
}

一般情况下(windows 2K)hava home的位置是在C:Program FilesJavaj2re1.4.0_02，相对的，证书就应该拷贝到C:Program FilesJavaj2re1.4.0_02libsecurity下，如果安装了自带JDK的Java IDE，比如 JBuilder，情况可能会有不同。

如果程序客户在不持有证书的情况下直接进行连接，服务器端会产生运行时异常，不允许进行连接。

运行环境：windows 2K server，j2sdk1.4.1

SSL双向认证java实现

http://www.blogjava.net/stone2083/archive/2008/07/10/169015.html

本文通过模拟场景，介绍SSL双向认证的java实现

默认的情况下，我认为读者已经对SSL原理有一定的了解，所以文章中对SSL的原理，不做详细的介绍。
如果有这个需要，那么通过GOOGLE，可以搜索到很多这样的文章。

模拟场景：
Server端和Client端通信，需要进行授权和身份的验证，即Client只能接受Server的消息，Server只能接受Client的消息。

实现技术：
JSSE（Java Security Socket Extension）
是Sun为了解决在Internet上的安全通讯而推出的解决方案。它实现了SSL和TSL（传输层安全）协议。在JSSE中包含了数据加密，服务器验证，消息完整性和客户端验证等技术。通过使用JSSE，开发人员可以在客户机和服务器之间通过TCP/IP协议安全地传输数据

为了实现消息认证。
Server需要：
1）KeyStore: 其中保存服务端的私钥
2）Trust KeyStore:其中保存客户端的授权证书
同样，Client需要：
1）KeyStore：其中保存客户端的私钥
2）Trust KeyStore：其中保存服务端的授权证书

我们可以使用Java自带的keytool命令，去生成这样信息文件
1）生成服务端私钥，并且导入到服务端KeyStore文件中
keytool -genkey -alias serverkey -keystore kserver.keystore
过程中，分别需要填写，根据需求自己设置就行
keystore密码：123456
名字和姓氏：stone
组织单位名称：eulic
组织名称：eulic
城市或区域名称：HZ
州或省份名称：ZJ
国家代码：CN
serverkey私钥的密码，不填写和keystore的密码一致：123456
就可以生成kserver.keystore文件
server.keystore是给服务端用的，其中保存着自己的私钥

2）根据私钥，导出服务端证书
keytool -export -alias serverkey -keystore kserver.keystore -file server.crt
server.crt就是服务端的证书

3）将服务端证书，导入到客户端的Trust KeyStore中
keytool -import -alias serverkey -file server.crt -keystore tclient.keystore
tclient.keystore是给客户端用的，其中保存着受信任的证书

4) 查看服务端证书里面的内容
keytool -list -v -keystore kserver.keystore

采用同样的方法，生成客户端的私钥，客户端的证书，并且导入到服务端的Trust KeyStore中
1）keytool -genkey -alias clientkey -keystore kclient.keystore
2）keytool -export -alias clientkey -keystore kclient.keystore -file client.crt
3）keytool -import -alias clientkey -file client.crt -keystore tserver.keystore

如此一来，生成的文件分成两组
服务端保存：kserver.keystore tserver.keystore
客户端保存：kclient.keystore tclient.kyestore

接下来，就采用JSSE，分别生成SSLServerSocket,SSLSocket

服务端，生成SSLServerSocket代码:

package testSSLSocket;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;

import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.TrustManagerFactory;


public class Server {
    private static final String SERVER_KEY_STORE_PASSWORD = "xxx"; storepass 也就是密钥库的密码，进入文件的密码
    private static final String SERVER_TRUST_KEY_PASSWORD = "xxx";
    private static final int DEFAULT_PORT = 8085;

    public static void main(String[] args) {
        SSLServerSocket serverSocket = Server.getSSLServerSocket();
        while(true){
            try {
                Socket socket =serverSocket.accept();
                new CreateThread(socket);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static SSLServerSocket getSSLServerSocket() {
        SSLServerSocket serverSocket = null;
        try {
            SSLContext ctx= SSLContext.getInstance("SSL");
            KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
            TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
            KeyStore ks = KeyStore.getInstance("jks");
            KeyStore tks = KeyStore.getInstance("jks");
            ks.load(new FileInputStream("keytool/server/kserver.keystore"), SERVER_KEY_STORE_PASSWORD.toCharArray());
            tks.load(new FileInputStream("keytool/server/tserver.keystore"), SERVER_TRUST_KEY_PASSWORD.toCharArray());
            kmf.init(ks, SERVER_KEY_STORE_PASSWORD.toCharArray());//该函数的第二个参数是aliaspassword(密钥的密码)
            tmf.init(tks);
            ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
            serverSocket = (SSLServerSocket)ctx.getServerSocketFactory().createServerSocket(DEFAULT_PORT);  
            serverSocket.setNeedClientAuth(true);
        } catch (KeyManagementException | UnrecoverableKeyException
                | NoSuchAlgorithmException | KeyStoreException
                | CertificateException | IOException e) {
            e.printStackTrace();
        }   
        return serverSocket;
    }
}


class CreateThread extends Thread{
    private BufferedReader in;
    private PrintWriter out;
    private Socket socket;

    public CreateThread(Socket socket){
        try {
            this.socket = socket;
            in = new BufferedReader(new InputStreamReader(socket.getInputStream(), "gb2312"));
            out = new PrintWriter(socket.getOutputStream());
            start();
        } catch (IOException e) {
            e.printStackTrace();
        }   
    }

    @Override
    public void run() {
        try {
            String msg = in.readLine();
            System.out.println("msg = "+ msg);
            out.println("hello");
            out.flush();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

客户端，生成SSLSocket的代码，大同小异

package testSSLSocket;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;

import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;

public class Client1 {
    private static final String CLIENT_KEY_STORE_PASSWORD = "xxx"; storepass 也就是密钥库的密码，进入文件的密码
    private static final String CLIENT_TRUST_KEY_PASSWORD = "xxx";
    private static final String DEFAULT_HOST = "localhost";
    private static final int DEFAULT_PORT = 8085;


    public static void main(String[] args) {
        try {
            Socket socket =  Client1.getSocket();
            socket.setSoTimeout(30000);
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream(), "gb2312"));
            PrintWriter out = new PrintWriter(socket.getOutputStream());
            out.println("hello1");
            out.flush();
            System.out.println(in.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static Socket getSocket() {
        Socket socket = null;
        try {
            SSLContext ctx= SSLContext.getInstance("SSL");
            KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
            TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
            KeyStore ks = KeyStore.getInstance("jks");
            KeyStore tks = KeyStore.getInstance("jks");
            ks.load(new FileInputStream("keytool/client1/kclient.keystore"), CLIENT_KEY_STORE_PASSWORD.toCharArray());
            tks.load(new FileInputStream("keytool/client1/tclient.keystore"), CLIENT_TRUST_KEY_PASSWORD.toCharArray());
            kmf.init(ks, CLIENT_KEY_STORE_PASSWORD.toCharArray());//该函数的第二个参数是aliaspassword(密钥的密码)
            tmf.init(tks);
            ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
            socket = ctx.getSocketFactory().createSocket(DEFAULT_HOST, DEFAULT_PORT);   
        } catch (KeyManagementException | UnrecoverableKeyException
                | NoSuchAlgorithmException | KeyStoreException
                | CertificateException | IOException e) {
            e.printStackTrace();
        }   
        return socket;
    }

}

如此，就完成了服务端和客户端之间的基于身份认证的交互。

client采用kclient.keystore中的clientkey私钥进行数据加密，发送给server
server采用tserver.keystore中的client.crt证书（包含了clientkey的公钥）对数据解密，如果解密成功，证明消息来自client，进行逻辑处理

server采用kserver.keystore中的serverkey私钥进行数据叫米，发送给client
client采用tclient.keystore中的server.crt证书（包含了serverkey的公钥）对数据解密，如果解密成功，证明消息来自server，进行逻辑处理

如果过程中，解密失败，那么证明消息来源错误。不进行逻辑处理。这样就完成了双向的身份认证。

下面我附上简单的SSLServer.java SSLClient.java，供大家演示用。
启动服务端的时候，大家不妨采用telnet 127.0.0.1 7777连接，看看能不能实现消息传递。

ssl demo
备注：
demo是采用maven构建项目的
demo文件的编码是用utf8，为了避免中文乱码，请把workspace设置成utf8编码
java中,可以查看证书:
写个简单的方法:
FileInputStream fis = new FileInputStream(“cert.cer”);
CertificateFactory cf=CertificateFactory.getInstance(“X509”);
X509Certificate c=(X509Certificate) cf.generateCertificate(fis);
System.out.println(c.getSubjectDN());
//可以查看下X509Certificate的一些get方法.
其实keytool仅仅是jdk中的工具.
openssl是更常用的一个工具
可见:http://www.openssl.org/

_HYC_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
用SSL构建安全的Socket

说明SSLSSL(安全套接层)是 Netscape公司在1994年开发的，最初用于WEB浏览器，为浏览器与服务器间的数据传递提供安全保障，提供了加密、来源认证和数据完整性的功能。现在SSL3.0得到了普遍的使用，它的改进版TLS(传输层安全)已经成为互联网标准。SSL本身和TCP套接字连接是很相似的，在协议栈中，SSL可以被简单的看作是安全的TCP连接，但是某些TCP连接的特性它是不支持的，比如带外
复制链接

扫一扫