本文将介绍如何使用openssl APIs 实现一个简单的SSL 客户端和服务端

虽然SSL客户端和服务端在创建和配置上有所区别，但它们本质上的步骤可以总结为如下图，具体步骤将在后面章节介绍：

初始化SSL库

在SSL应用程序中调用其他Openssl APIs，需要先用下面的APIs进行初始化：

SSL_library_init(); /* 为SSL加载加密和哈希算法 */                
SSL_load_error_strings(); /* 为了更友好的报错，加载错误码的描述字符串 */

SSL_library_init 注册了所有在SSL APIs中的加密算法和哈希算法，该API加载的加密算法有：DES-CBC, DES-EDE3-CBC, RC2 和 RC4；哈希算法有MD2, MD5, 和 SHA。SSL_library_init正常情况只会返回1；

SSL应用程序需要调用SSL_load_error_strings，该函数为SSL接口和Crypto加密接口加载错误描述字符串。之所以SSL 和 Crypto加密错误描述字符串需要加载，因为SSL应用程序都会多次调用SSL 和Crypto接口；

创建SSL 上下文接口(SSL_CTX)

初始化的第一步是选择SSL/TLS协议版本号；通过下面的API创建一个SSL_METHOD结构；SSL_METHOD结构之后会用于通过SSL_CTX_new()创建SSL_CTX结构。

对于每个SSL/TSL来说，有三种APIs可以用来创建一个SSL_METHOD：一个可以用于服务端和客户端，一个只能用于服务端，另外一个只能由于客户端。SSLv2,SSLv3以及TLSv1有这和协议名一致的接口函数名，如下表所示：

创建 SSL_METHOD 的函数：

协议号 通用 服务端专用 客户端专用

SSLv2 SSLv2_method() SSLv2_server_ method() SSLv2_client_ method()

SSLv3 SSLv3_method() SSLv3_server_ method() SSLv3_client_ method()

TLSv1 TLSv1_method() TLSv1_server_ method() TLSv1_client_ method()

SSLv23 SSLv23_method() SSLv23_server_ method() SSLv23_client_ method()

说明： 并没有SSLv23这个协议号，SSLv23_method将会选择SSLv2,SSLv3或者TLSv1来匹配对端的版本号。

当开发一个SSL服务端或者客户端应用程序，需要考虑SSL/TLS版本的不兼容问题；比如，一个TLSv1的服务端不能支持来之SSLv2或者SSLv3客户端发来的client-hello消息；当需要考虑客户端的兼容性是，可以使用SSLv23_method和其他变体函数。使用SSLv23的服务器可以支持SSLv2,SSLv3以及TLSv1发来的hello消息。而使用SSLv23 函数的客户端不能和使用了SSLv3/TLSv1函数的服务端建立连接，因为客户端发送的SSLv2版本的hello包。

SSL_CTX_new函数以SSL_METHOD结构体作为参数，创建并且返回SSL_CTX结构。

下面的例子中，SSL_METHOD结构既可以用于穿件SSLv3客户端或者SSLv3服务端；并且SSL_CTX也将会被初始化；

meth = SSLv3_method();
ctx = SSL_CTX_new(meth);

Setting Up the Certificate and Key

安装证书和私钥

“Certificates for SSL Applications” 中介绍了如何安装SSL客户端和服务端适合的证书。这个安装步骤需要加载证书私钥到SSL_CTX或者SSL结构中。必须安装以及可选安装的证书如下：

• 服务端：

  服务器自己的证书(必须的)

  CA证书（可选的）

• 客户端：

  CA证书（强制的）

  客户端自己的证书(可选的)

加载证书(客户端/服务端证书)

SSL_CTX_use_certificate_file函数加载一个证书到一个SSL_CTX结构中

SSL_use_certificate_file函数加载一个证书到SSL结构中

当创建SSl结构，SSL结构自动加载同样的证书，并且包含了SSL_CTX结构；因此，当创建SSL结构只需要调用SSL_use_certificate_file()，除非需要加载一个不同的证书，而不是默认证书包含在SSL_CTX结构中。

加载私钥

接下来就是设置一个和服务端或者客户端证书相关的私钥。在SSL握手中，公钥会被传输给对端用于加密使用。对端的加密信息只能用本端的私钥解密。必须加载私钥，加载时会加载公钥信息到SSL结构中。

下面的函数用于加载私钥到SSL结构或者SSL_CTX结构中：

SSL_CTX_use_PrivateKey()

SSL_CTX_use_PrivateKey_ASN1()

SSL_CTX_use_PrivateKey_file()

SSL_CTX_use_RSAPrivateKey()

SSL_CTX_use_RSAPrivateKey_ASN1()

SSL_CTX_use_RSAPrivateKey_file()

SSL_use_PrivateKey()

SSL_use_PrivateKey_ASN1()

SSL_use_PrivateKey_file()

SSL_use_RSAPrivateKey()

SSL_use_RSAPrivateKey_ASN1()

SSL_use_RSAPrivateKey_file()

加载CA证书

为了验证证书，首先需要加载CA证书（因为对端证书需要用CA证书来验证）。SSL_CTX_load_verify_locations加载CA证书到SSL_CTX结构中。

函数原型如下：

int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
const char *CApath);

第一个参数ctx，指向 一个用于加载CA证书的SSL_CTX结构，第二个参数和第三个参数CAfile、CApatch，用于指向CA证书的路径；当查找CA证书时，Openssl库先通过CAfile查找，找不到再通过CApath。

CAfile和CApath参数有以下规则：

如果CAfile已经指定了证书(证书必须存在于SSL应用程序的相同路径下)，CApath可以指定为NULL。

如果使用了CApath，CAfile为NULL。必须对CApath指定的路径下的CA证书进行哈希。使用证书工具(第三章描述的)进行哈希操作

设置对端证书验证

SSL_CTX中加载的CA证书使用与对端证书验证的。比如，客户端的证书验证是在通过检查客户端加载的CA证书和服务端的证书之间的关系。

如果要验证成功，对端的证书必须通过CA证书直接或者间接的方式的签名（存在一个正确的证书链）。CA证书对对端的证书链的检查深度可以设置到SSL_CTX或者SSL结构的verify_depth 成员中。(如果通过SSL_new创建SSL，SSL中的值可以从SSL_CTX中继承下来)verify_depth设置为1意味着对端的证书必须被CA证书直接签名过的。

The SSL_CTX_set_verify() API allows you to set the verification flags in the SSL_CTX structure and a callback function for customized verification as its third argument. (Setting NULL to the callback function means the built-in default verification function is used.) In the second argument of SSL_CTX_set_verify(), you can set the following macros:

函数SSL_CTX_set_verify可以用于设置在SSL_CTX结构中的验证标记，第三个函数可以设置一个指定验证过程的回调函数。（回调参数如果设置为NULL意味着用内建默认的验证方式）。SSL_CTX_set_verify中的第二个参数可以指定以下宏：

SSL_VERIFY_NONE

SSL_VERIFY_PEER

SSL_VERIFY_FAIL_IF_NO_PEER_CERT

SSL_VERIFY_CLIENT_ONCE

SSL_VERIFY_PEER 可以指定与客户端和服务端，用于启动验证。但是，后续的行为取决于是服务端还是客户端所设置。比如；

    /* Set a callback function (verify_callback) for peer certificate */
    /* verification */
    SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, verify_callback);
    /* Set the verification depth to 1 */
    SSL_CTX_set_verify_depth(ctx,1);

验证对端证书也可以通过一个不常用的方式，使SSL_get_verify_result()。这种方式可以获取到验证对端证书的结果，而不需要使用SSL_CTX_set_verify()函数。

调用函数SSL_get_verify_result() 前需要调用以下两个函数：

调用SSL_connect(客户端)或者SSL_accept（服务端）完成SSL协商握手。在握手过程会完成证书验证。在验证步骤前不能调用SSL_get_verify_result(）获取不到验证结果。

调用SSL_get_peer_certificate() 不能明确地获取到对端证书。当对端证书不存在或者验证成功返回X509_V_OK。
The following code shows how to use SSL_get_verify_result() in the SSL client:
以下代码展示在客户端如何使用 SSL_get_verify_result：

 SSL_CTX_set_verify_depth(ctx, 1);
     err = SSL_connect(ssl);
 if(SSL_get_peer_certificate(ssl) != NULL)
      {
         if(SSL_get_verify_result(ssl) == X509_V_OK)


     BIO_printf(bio_c_out, "client verification with SSL_get_verify_result() 
      succeeded.\n");                
         else{

            BIO_printf(bio_err, "client verification with SSL_get_verify_result() 
      failed.\n");

           exit(1);
          }
      }
  else
      BIO_printf(bio_c_out, -the peer certificate was not presented.\n-);

例1 SSL服务端安装证书

SSL协议要求服务端设置证书和私钥。如果服务端要验证客户端的证书，服务端必须加载一个CA证书，以便于用于验证客户端证书。
以下例子展示服务端如何安装证书：

 /* Load server certificate into the SSL context */
               if (SSL_CTX_use_certificate_file(ctx, SERVER_CERT, 
         SSL_FILETYPE_PEM) <= 0) } 


                        ERR_print_errors(bio_err);  /* == 
                  ERR_print_errors_fp(stderr); */
                     exit(1);
            }

               /* Load the server private-key into the SSL context */
             if (SSL_CTX_use_PrivateKey_file(ctx, SERVER_KEY, 
          SSL_FILETYPE_PEM) <= 0) {


                   ERR_print_errors(bio_err);  /* == 
                  ERR_print_errors_fp(stderr); */
                     exit(1);
            }

/* Load trusted CA. */
            if (!SSL_CTX_load_verify_locations(ctx,CA_CERT,NULL)) { 
                    ERR_print_errors(bio_err);  /* == 
                  ERR_print_errors_fp(stderr); */
                     exit(1);
            }

               /* Set to require peer (client) certificate verification */
                SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, verify_callback);
          /* Set the verification depth to 1 */
               SSL_CTX_set_verify_depth(ctx,1);

例2 客户端安装证书

客户端通常情况在握手过程中验证服务端的证书。认证过程需要客户端安装它的信任的CA证书。服务端的证书必须使用客户端所加载的CA证书签名过的证书，以便于服务端验证可以通过。

以下例子展示了客户端如何安装证书：

/*----- Load a client certificate into the SSL_CTX structure -----*/
       if(SSL_CTX_use_certificate_file(ctx,CLIENT_CERT,
       SSL_FILETYPE_PEM) <= 0){
                    ERR_print_errors_fp(stderr);
                exit(1);
            }

/*----- Load a private-key into the SSL_CTX structure -----*/
        if(SSL_CTX_use_PrivateKey_file(ctx,CLIENT_KEY,
        SSL_FILETYPE_PEM) <= 0){
                    ERR_print_errors_fp(stderr);
                exit(1);
            }

/* Load trusted CA. */
            if (!SSL_CTX_load_verify_locations(ctx,CA_CERT,NULL)) {
                     ERR_print_errors_fp(stderr);
                    exit(1);
            }

创建和安装SSL结构

调用SSL_new创建SSL结构，SSL的连接信息都保存在SSL结构，SSL_new的使用方式如下：

ssl = SSL_new(ctx);

一个新的SSL结构会从SSL_CTX结构中继承包括，连接类型、选项、验证方式以及超时。如果SSL_CTX结构已经做过适合的初始化和配置，SSL结构就可以不需要做其他设置了。

SSL相关的API去修改SSL结构中的一些默认值，可以通过多个同名的函数去设置属性到SSL_CTX结构中。比如，可以使SSL_CTX_use_certificate加载证书到SSL_CTX中，也可以通过SSL_use_certificate加载证书到SSL结构中。

建立TCP/IP连接

SSL需要工作在可靠的协议之上，SSL使用最普遍的传输层协议TCP/IP.

下面的章节描述了如何使用SSL API来创建TCP/IP.使用方式和其他TCP/IP应用程序一样。这里TCP/IP创建使用普通的socket接口，虽然也可以通过OpenVMS系统的接口。

SSL服务端创建监听端口，SSL服务端和普通的TCP/IP服务器一样需要两个sockets，一个用于监听SSL客户端发来的请求，一个用于SSL通信。
以下代码，socket()函数创建监听socket，使用bind函数绑定了端口和地址后，在调用listen函数后，就可以处理来自客户端的TCP/IP请求了

 listen_sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
 CHK_ERR(listen_sock, "socket");

 memset(&sa_serv, 0, sizeof(sa_serv));
 sa_serv.sin_family      = AF_INET;
 sa_serv.sin_addr.s_addr = INADDR_ANY;
 sa_serv.sin_port        = htons(s_port);      /* Server Port number */

 err = bind(listen_sock, (struct sockaddr*)&sa_serv,sizeof(sa_serv));
 CHK_ERR(err, "bind");

 /* Receive a TCP connection. */
 err = listen(listen_sock, 5);
 CHK_ERR(err, "listen");

客户端创建socket

客户端需要创建一个TCP/IPsocket，然后尝试去连接服务端。调用connect()函数去连接到指定的服务器。如果成功后，可以使用connect的第一个参数(句柄)用于数据传输。

 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 CHK_ERR(sock, "socket");

 memset (&server_addr, '\0', sizeof(server_addr));
 server_addr.sin_family      = AF_INET;
 server_addr.sin_port        = htons(s_port);       /* Server Port number */
 server_addr.sin_addr.s_addr = inet_addr(s_ipaddr); /* Server IP */

 err = connect(sock, (struct sockaddr*) &server_addr, sizeof(server_addr));
 CHK_ERR(err, "connect");

服务端创建连接

SSL服务端调用accept()来接收一个客户请求，返回的句柄可以用于和客户端数据传输使用，如下：

 sock = accept(listen_sock, (struct sockaddr*)&sa_cli, &client_len);
 BIO_printf(bio_c_out, "Connection from %lx, port %x\n", 
 sa_cli.sin_addr.s_addr, sa_cli.sin_port);

创建SSL结构中的BIO

创建SSL结构和socket后，需要做些关联，以便于可以使用SSL结构来完成SSL数据传输。
下面的代码片段展示了多种方式将sock和ssl关联到一起，最简单的方式是将socket直接设置到SSL结构中，比如

SSL_set_fd(ssl, sock);

一种更好的方式是使用BIO结构，BIO是一种Openssl提供的IO抽象接口。这种方式更好，因为BIO隐藏了底层IO的细节。只要BIO接口设置合理，可以在任何IO之上建立SSL连接。
下面两个例子展示了如何创建一个BIO以及将BIO设置到SSL结构中：

 sbio=BIO_new(BIO_s_socket());
 BIO_set_fd(sbio, sock, BIO_NOCLOSE);
 SSL_set_bio(ssl, sbio, sbio);

下面的例子中，BIO_new_socket创建了一个tcp/ip的socket BIO，SSL_set_bio()将socket BIO设置到SSL结构中。以下两行代码等价于前面的三行：

 sbio = BIO_new_socket(socket, BIO_NOCLOSE);
 SSL_set_bio(ssl, sbio, sbio);

SSL握手

SSL握手过程是一个复杂过程，涉及到重要的加密秘钥交换。但是握手过程可以通过服务端调用SSL_accept和客户度调用SSL_connect完成。

服务端SSL握手

SSL_accept函数会等待客户端启动SSL握手。函数成功返回说明SSL握手已经成功完成。

 err = SSL_accept(ssl);

客户端握手

客户端调用SSL_connect开始SSL握手。握手成功返回1，之后数据就可以通过这个连接安全传输了。

 err = SSL_connect(ssl);

通过SSL_read以及SSL_write完成握手(可选的)

另外，和SSL数据交换一样也可以通过SSL_write和SSL_read来完成握手。按这种方式，必须先在服务端调用SSL_read前先调用SSL_set_accept_state，在客户端调用SSL_write前先调用SSL_set_connect_state()。举例：

 /* When SSL_accept() is not called, SSL_set_accept_state() */ 
 /* must be called prior to SSL_read() */
 SSL_set_accept_state(ssl);

 /* When SSL_connect() is not called, SSL_set_connect_state() */ 
 /* must be called prior to SSL_write() */
 SSL_set_connect_state(ssl);

获取对端证书（可选）

另外，在SSL握手完成后，可通过调用SSL_get_peer_certificate来获取对端的证书。这个函数通常用于直接方式的证书验证，比如检查证书信息（comman name和证书过期时间）

 peer_cert = SSL_get_peer_certificate(ssl);

数据传输

在SSL握手完成后，数据就可以通过已经建立好的连接安全的发送了。SSL_write和SSL_read用于SSL数据传输，和write、read、send、recv一样用在普通的tcp连接上。

发送数据

调用SSL_write在SSL连接上发送数据。被发送的数据存放在一个缓冲区中以第二个参数传入，比如：

 err = SSL_write(ssl, wbuf, strlen(wbuf));

接收数据

调用SSL_read在SSL连接上接收数据，接收数据的缓冲区放在第二个参数传入，比如

 err = SSL_read(ssl, rbuf, sizeof(rbuf)-1);

使用BIOs接口进行数据传输（可选的）

调用BIO_puts() 和IO_gets(), 和 BIO_write() 和 BIO_read()可以替代SSL_write() 和SSL_read进行数据收发，其中BIO buffer的创建和安装如下：

 BIO        *buf_io, *ssl_bio;
 char     rbuf[READBUF_SIZE];
 char    wbuf[WRITEBUF_SIZE]

 buf_io = BIO_new(BIO_f_buffer());  /* create a buffer BIO */
 ssl_bio = BIO_new(BIO_f_ssl());           /* create an ssl BIO */
 BIO_set_ssl(ssl_bio, ssl, BIO_CLOSE);       /* assign the ssl BIO to SSL */
 BIO_push(buf_io, ssl_bio);          /* add ssl_bio to buf_io */                     

 ret = BIO_puts(buf_io, wbuf);         
 /* Write contents of wbuf[] into buf_io */
 ret = BIO_write(buf_io, wbuf, wlen);        
 /* Write wlen-byte contents of wbuf[] into buf_io */

 ret = BIO_gets(buf_io, rbuf, READBUF_SIZE);  
 /* Read data from buf_io and store in rbuf[] */
 ret = BIO_read(buf_io, rbuf, rlen);            
 /* Read rlen-byte data from buf_io and store rbuf[] */

关闭SSL连接

当关闭SSL连接时，SSL客户端和服务端需要发送close_notify消息，通知对端SSL将要关闭了。调用SSL_shutdown函数来发送close_notify消息：

关闭过包含以下两个步骤：

• 发送一个close_notify关闭告警
• 从对端接收一个close_notify的关闭消息

关闭SSL连接有如下规则：

-任何一方都可以通过发送close_notify消息来发起关闭
-发送过关闭消息后，接收到任何数据将会被忽略
-任何一方在关闭写时，都要先发送close_notify消息
-收到close_notify的一端也需要应答它自己的close_notify，并且立刻关闭连接，丢弃未写出的数据。
-发起关闭的一端，在关闭读端关闭前，不需要等待响应的close_notify消息。

发起关闭的客户端或者服务端可以调用SSL_shutdown一次或者两次。如果调用了两次，一次调用用于发送close_notify消息，另外一次用于响应对端的。如果只调用一次，发起关闭一端将不会等待对端的响应(发起关闭的一端不需要等待对端的关闭响应)

一旦收到对端关闭消息就要马上发送关闭响应。

SSL会话重用

可以基于一个已建立连接的SSL会话创建一个新的SSL连接。因为重用了相同的会话秘钥，SSL握手将会快很多。SSL会话重用将有利于一个并发大的服务器减轻负载。

客户端可以按以下步骤去重用一个SSL会话：

1. 发起第一个SSL连接，同时会创建一个SSL会话

ret = SSL_connect(ssl)
(Use SSL_read() / SSL_write() for data communication 
      over the SSL connection)

1. 保存SSL会话信息

sess = SSL_get1_session(ssl);  
/* sess is an SSL_SESSION, and ssl is an SSL */

1. 关闭第一个SSL连接

SSL_shutdown(ssl);

1. 创建一个新的SSL结构

ssl = SSL_new(ctx);

1. SSL_connect前将SSL session设置到新的SSL结构中

SSL_set_session(ssl, sess);

1. 使用重用会话启动新的SSL连接

ret = SSL_connect(ssl)
(Use SSL_read() / SSL_write() for data communication 
over the SSL connection)

如果SSL客户端调用了SSL_get1_session和SSL_set_session,SSL服务端将不需要使用其他接口，就可以accept到一个重用之前会话的SSL连接。
服务器的实现步骤将在之前的章节中讨论过。

注意：调用了SSL_free会导致SSL sessoion无法重用，即使已经通过SSL_get1_session保存了就的会话信息。

SSL握手再协商

SSL再协商是在一个已经建立了SSL握手的连接上进行一个新的SSL握手。
因为再协商的信息包括加密秘钥在已加密的连接上进行传输的。SSL再协商可以安全地建立另一个SSL连接。如果已经创建了一个普通的SSL连接，SSL再协商可以在以下场景中使用：

• 需要客户端进行身份认证
• 需要使用不同的加解密秘钥
• 需要使用不同的加密和哈希的算法

SSL再协商可以由SSL客户端也可以是服务端发起。当在客户端发起时需要使用不同接口（发起的客户端和接收的服务端都需要使用不同函数）

以下章节将讨论两种情况的必要的接口：
注意：SSLv2 不支持SSL再协商，SSLv3或者TLSv3支持这个操作。

服务端发起再协商

服务端发起再协商，需要调用SSL_renegotiate一次和SSL_do_handshake两次。
SSL_renegotiate为SSL再协商设置标志。SSL_renegotiate实际上并没有启动再协商。在SSL_do_handshake时生效，SSL_do_handshake发现设置过标志需要和SSL客户端需要建立再协商。SSL_do_handshake才真正的执行SSL再协商。第一次调用将会发送一个Server-Hello消息给客户端。
如果第一次调用成功，表示客户端已经允许本次的SSL再协商。然后服务端将会设置SSL_ST_ACCEPT 到SSL结构中，并且再调用一次SSL_do_handshake完成再协商剩余的步骤。
以下的代码片段展示的这些函数的用法：

 printf("Starting SSL renegotiation on SSL server (initiating by SSL server)");
   if(SSL_renegotiate(ssl) <= 0){
           printf("SSL_renegotiate() failed\n");
             exit(1);
    }

      if(SSL_do_handshake(ssl) <= 0){
                 printf("SSL_do_handshake() failed\n");
             exit(1);
    }

      ssl->state = SSL_ST_ACCEPT;

         if(SSL_do_handshake(ssl) <= 0){
                 printf("SSL_do_handshake() failed\n");
             exit(1);
 }

以下片段展示服务端发起再协商时，客户端的调用：

 printf("Starting SSL renegotiation on SSL client (initiating by SSL server)");       
 /* SSL   renegotiation */
      err = SSL_read(ssl, buf, sizeof(buf)-1);

如上所示，SSL_read除了用于接收数据外，也可以用于处理连接相关的功能，比如再协商；

客户端发起再协商

SSL客户端也可以发起SSL再协商，启动方式与服务端启动相似。SSL客户端调用SSL_renegotiate设置一个再协商标志，然后只需要调用一次SSL_do_handshake即可完成再协商。

 printf("Starting SSL renegotiation on SSL client (initiating by SSL client)");
 if(SSL_renegotiate(ssl) <= 0){
        printf("SSL_renegotiate() failed\n");
        exit(1);
 }
 if(SSL_do_handshake(ssl) <= 0){
        printf("SSL_do_handshake() failed\n");
            exit(1);
 }

以下代码展示客户端发起再协商时，服务端的调用：

 printf("Starting SSL renegotiation on SSL server (initiating by SSL client)");
   /* SSL renegotiation */
      err = SSL_read(ssl, buf, sizeof(buf)-1);

SSL程序退出

当退出SSL程序运行时，首要任务是释放在程序中创建的相关结构体内存。释放相关的接口有包含_free后缀的(相反_new后缀则是用于创建结构体的)

必须释放程序中申请过的结构体内存。通过xxx_new结构申请的内存，通过xxx_free将会自动释放相关内存。比如，使用SSL_new创建BIO结构通过SSL_free将会释放相关内存，而不需要调用BIO_free去释放BIO内部的SSL结构。但是，如果滴啊用了BIO_new申请了BIO结构，就必须通过BIO_free来释放。

注意：在调用SSL_free前必须先释放SSL_shutdown.

原文链接：SSL Programming Tutorial