目录
- 前言
- 初始化SSL库
- 创建SSL 上下文接口(SSL_CTX)
- 安装证书和私钥
- 加载证书(客户端/服务端证书)
- 加载私钥/公钥
- 加载CA证书
- 设置对端证书验证
- 例1 SSL服务端安装证书
- 例2 客户端安装证书
- 创建和安装SSL结构
- 建立TCP/IP连接
- 客户端创建socket
- 服务端创建连接
- 创建SSL结构中的BIO
- SSL握手
- 服务端SSL握手
- 客户端握手
- 通过SSL_read以及SSL_write完成握手(可选)
- 获取对端证书(可选)
- 数据传输
- 发送数据
- 接收数据
- 使用BIOs接口进行数据传输(可选)
- 关闭SSL连接
- SSL会话重用
- SSL握手再协商
- 服务端发起再协商
- 客户端发起再协商
- SSL程序退出
- Linux下c语言实现socket+openssl数据传输加密
- 1. Socket连接建立流程
- 2、Socket+SSL的初始化流程
- 3、初始化SSL环境,证书和密钥
- 4、Socket+SSL 的c语言实现
- 使用tcpdump检验
- 其他相关博文
前言
参考: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)
调用connect和accept底层实现三次握手四次挥手;
调用ssl_connect和ssl_accept底层实现秘钥协商等。
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];// 创建 socketsockfd = 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编程