前言

参考：SSL编程指南
地址：https://blog.csdn.net/rzytc/article/details/50647095?spm=1001.2014.3001.5502

本文将介绍如何使用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);

安装证书和私钥

“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会话：

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

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

保存SSL会话信息

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

关闭第一个SSL连接

SSL_shutdown(ssl);

创建一个新的SSL结构

ssl = SSL_new(ctx);

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

SSL_set_session(ssl, sess);

使用重用会话启动新的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);
}

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.

Linux下c语言实现socket+openssl数据传输加密

参考：Linxu下c语言实现socket+openssl数据传输加密
地址：https://programtree.blog.csdn.net/article/details/133269452?spm=1001.2014.3001.5502

在进行网络编程的时候，我们通常使用socket进行数据的传输。然而socket作为一个数据传输协议，其本身对数据并不会作加密。所以数据传输的过程可以很轻松地被监听并截获到传输的数据。openssl提供了SSL的加密库，通过 ssl+socket 的方式可以保证连接安全和数据的加密。

1. Socket连接建立流程

在做socket加密之前，还是先与普通的socket做一个对比。

上面的是我们通常在做一个socket连接的时候会涉及到的握手过程。服务端会通过accept去接收客户端的请求。客户端通过connect去连接到客户端。使用send和recv去做数据的传输。那么传输过程中的参数data也就是我们交互的数据了。当我们建立连接开始发送数据的时候。使用一些抓包工具wireshark,或者tcpdump去监听socket端口就能很轻松地获取到传输的明文数据了。

2、Socket+SSL的初始化流程

所以为了避免数据的监听，我们就需要使用SSL去建立一个安全的通道。这里我们先把SSL的建立当作一个子流程：

SSL子过程主要插入在 socket 的 connect()/accept() 和数据交换之间。通过SSL建立完成的所以，一旦SSL握手完成，数据发送和接收的流程与普通的socket通信非常相似，只需要使用SSL_write()和SSL_read()来代替send()和recv()。

替换 send() 为 SSL_write(ssl, buffer, length)
替换recv() 为 SSL_read(ssl, buffer, length)

3、初始化SSL环境，证书和密钥

openssl 生成证书（分别生成私钥和自签名证书），确保环境上已经安装完成了openssl
openssl genpkey -algorithm RSA -out key.pem
openssl req -new -x509 -key key.pem -out cert.pem -days 365

days为证书的有效期。命令执行完成后在当前目录下就会生成key.pem 和cert.pem 。记下文件路径，后续会作为参数传入到我们的函数中去。

4、Socket+SSL 的c语言实现

4.1 编写SSL连接函数

在进行SSL初始化的时候需要注意的是，由于连接协商的过程使用的是非对称加密，因此客户端和服务端在初始化的时候是使用的不同的算法。因此，我在函数中加入了一个SSL_MODE参数。用来指明当前是服务端还是客户端的SSL。

SSL* sync_initialize_ssl(const char* cert_path, const char* key_path, SSL_MODE mode, int fd) 
{
    const SSL_METHOD *method;
    SSL_CTX *ctx;
    SSL *ssl = NULL;
    // 初始化OpenSSL库
    SSL_library_init();
    OpenSSL_add_all_algorithms();
    SSL_load_error_strings();

    // 根据模式(客户端/服务端)选择合适的方法
    if (mode == SSL_MODE_SERVER) 
    {
        method = SSLv23_server_method();
    } else if (mode == SSL_MODE_CLIENT) 
    {
        method = SSLv23_client_method();
    } else 
    {
        // 未知模式
        printf("Not found method");
        return NULL;
    }

    // 创建SSL上下文
    ctx = SSL_CTX_new(method);
    if (!ctx) {
        printf("Unable to create SSL context");
        return NULL;
    }

    // 配置SSL上下文
    if (SSL_CTX_use_certificate_file(ctx, cert_path, SSL_FILETYPE_PEM) <= 0 || SSL_CTX_use_PrivateKey_file(ctx, key_path, SSL_FILETYPE_PEM) <= 0 ) {
        printf("Not found certificate or private key");
        SSL_CTX_free(ctx);
        return NULL;
    }
    // SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);

    // 创建SSL对象
    ssl = SSL_new(ctx);
    if (!ssl) {
        printf("Failed to create SSL object.");
        return NULL;
    }

    // 设置文件描述符
    if (SSL_set_fd(ssl, fd) == 0) {
        printf("Failed to set fd to SSL object.");
        return NULL;
    }

    // SSL握手
    if ((mode == SSL_MODE_CLIENT && SSL_connect(ssl) <= 0) ||
        (mode == SSL_MODE_SERVER && SSL_accept(ssl) <= 0)) {
        int ssl_result;
        if (mode == SSL_MODE_CLIENT) 
        {
            ssl_result = SSL_connect(ssl);
        } else if (mode == SSL_MODE_SERVER) 
        {
            ssl_result = SSL_accept(ssl);
        }

        int ssl_err = SSL_get_error(ssl, ssl_result);

        const char *err_str;
        switch (ssl_err) {
            case SSL_ERROR_NONE:
                err_str = "No error";
                break;
            case SSL_ERROR_SSL:
                err_str = "Error in the SSL protocol";
                break;
            case SSL_ERROR_WANT_READ:
                err_str = "SSL read operation did not complete";
                break;
            case SSL_ERROR_WANT_WRITE:
                err_str = "SSL write operation did not complete";
                break;
            case SSL_ERROR_WANT_X509_LOOKUP:
                err_str = "SSL X509 lookup operation did not complete";
                break;
            case SSL_ERROR_SYSCALL:
                err_str = "Syscall error";
                break;
            case SSL_ERROR_ZERO_RETURN:
                err_str = "SSL connection was shut down cleanly";
                break;
            case SSL_ERROR_WANT_CONNECT:
                err_str = "SSL connect operation did not complete";
                break;
            case SSL_ERROR_WANT_ACCEPT:
                err_str = "SSL accept operation did not complete";
                break;
            default:
                err_str = "Unknown error";
                break;
        }
        printf("===============SSL handshake failed. Error: %s========!\n", err_str ? err_str : "Unknown");
        return NULL;
    }

    return ssl;
}

4.2 编写加密服务端server.c

#include <stdio.h>  
#include <stdlib.h>  
#include <stddef.h>
#include <string.h>  
#include <unistd.h>  
#include <sys/socket.h>  
#include <arpa/inet.h>
#include <netinet/in.h>  
#include <openssl/ssl.h>  
#include <openssl/err.h>  
  
#define SERVER_PORT 9990  
#define MAXLINE 4096  
typedef enum 
{
    SSL_MODE_SERVER,
    SSL_MODE_CLIENT
} SSL_MODE;

int main(int argc, char **argv) {  
    int listenfd, connfd;  
    struct sockaddr_in servaddr, cliaddr;  
    char buf[MAXLINE];  

    // 创建监听套接字  
    listenfd = socket(AF_INET, SOCK_STREAM, 0);  
  
    // 绑定地址和端口  
    memset(&servaddr, 0, sizeof(servaddr));  
    servaddr.sin_family = AF_INET;  
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
    servaddr.sin_port = htons(SERVER_PORT);  
    bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));  
  
    // 监听连接  
    listen(listenfd, 10);  
    printf("Listening on port %d...\n", SERVER_PORT);  
  
    while (1) {  
        // 接受连接请求  
        socklen_t len = sizeof(cliaddr);  
        connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &len);  
        printf("Accepted connection from %s:%d\n", inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));  
  
        // 创建 SSL 对象并进行握手  
        SSL *ssl = sync_initialize_ssl("cert.pem", "key.pem", SSL_MODE_SERVER, connfd); 
  
        // 读取客户端发送的数据并回复  
        memset(buf, 0, MAXLINE);  
        SSL_read(ssl, buf, MAXLINE);  
        printf("Received: %s\n", buf);  
        SSL_write(ssl, "Hello, client!", strlen("Hello, client!"));  
  
        // 关闭连接和清理资源  
        close(connfd);  
        SSL_shutdown(ssl);  
        SSL_free(ssl);  
    }  
  

    return 0;  
}

4.3 编写加密客户端client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stddef.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <openssl/ssl.h>
#include <openssl/err.h>

#define SERVER_IP "127.0.0.1"  // 请根据需要更改服务器IP
#define SERVER_PORT 9990  
#define MAXLINE 4096  
typedef enum 
{
    SSL_MODE_SERVER,
    SSL_MODE_CLIENT
} SSL_MODE;

int main(int argc, char **argv) 
{
    int sockfd;
    struct sockaddr_in servaddr;
    char buf[MAXLINE];
    // 创建 socket
    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    // 设置服务器地址和端口
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = inet_addr(SERVER_IP);
    servaddr.sin_port = htons(SERVER_PORT);

    // 连接到服务器
    connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr));

    // 创建 SSL 对象并进行握手
    SSL *ssl = sync_initialize_ssl("cert.pem", "key.pem", SSL_MODE_CLIENT, sockfd); 
    // 发送数据给服务器
    SSL_write(ssl, "Hello, server!", strlen("Hello, server!"));

    // 读取服务器的回复
    memset(buf, 0, MAXLINE);
    SSL_read(ssl, buf, MAXLINE);
    printf("Received: %s\n", buf);

    // 关闭连接和清理资源
    close(sockfd);
    SSL_shutdown(ssl);
    SSL_free(ssl);

    return 0;
}

使用tcpdump检验

服务端和客户端编写完成后，分别运行起来，这里我运行的端口是9990。使用tcpdump抓取9990端口的传输数据

tcpdump -i any port 9990 -A

此时分别运行后，服务端客户端数据完成交互后，抓包所看到的数据已经是密文传输了。

其他相关博文

SSL_write 发生了什么
SSL 多线程通信 linux openSSL C API编程
SSL编程- 简单函数介绍
openssl之ssl编程