1. 速盾网络Home
  2. 网站运维

深入理解nginx stream proxy 模块的ssl连接原理

网络技术联盟站 • • 网站运维

1. 源起

??我一直来对ssl建立连接的过程一知半解，以前分析nginx代码的时候一旦碰到ssl连接部分的代码都是直接跳过，前面在分析ngx_http_upstream_dynamic_module的时候正好想到了是不是可以给它添加一个能够支持https健康检查的功能，所以今天决定沉下心来仔细分析一下nginx本身的与上游服务器建立连接的实现逻辑。

??为了简单起见，我决定选用ngx_stream_proxy_module模块作为分析学习的目标，因为相对于ngx_http_stream_proxy_module来说，前者逻辑上更加纯粹，少了七层的业务逻辑，让我能够更加专注地去分析关于ssl连接处理逻辑部分。

??希望这次通过分析，能够对ssl连接的建立以及其后续的读写交互的实现逻辑有个整体的把握，在此基础上，将来为ngx_http_upstream_dynamic_module实现一个能够支持https主动健康检测的功能。

??这次，我准备采用官方原生的最新稳定版nginx 1.24.0作为分析对象。为什么不用tengine呢？因为现在的tengine还夹杂了国密openssl的支持逻辑，采用官方原生版本更加纯粹，让分析的目标更加聚焦。

2. 分析验证环境的配置

??配置一个分析验证环境来进行测试分析还是非常简单的，过程如下：

??1. 从官网下载好nginx 1.24.0版本后进行解压，然后用以下命令进行配置：

./configure --prefix=`pwd` --with-stream --with-stream_ssl_module







??这样nginx从源码层面就开启了支持ssl的TCP代理能力。


??2. 对nginx.conf文件进行配置，配置内容如下：


#user  nobody;worker_processes  1;
#error_log  logs/error.log;#error_log  logs/error.log  notice;#error_log  logs/error.log  info;
#pid        logs/nginx.pid;

events {    worker_connections  1024;}

stream {  server {    listen 9000;    proxy_ssl on;               /* 连接上游服务器采用ssl协议 */    proxy_pass 104.193.88.77:443;  }}







??3. 启动nginx，进行curl测试：


 
curl \\\"http://127.0.0.1:9000/test/\\\" -v *   Trying 127.0.0.1:9000...* Connected to 127.0.0.1 (127.0.0.1) port 9000 (#0)> GET /test/ HTTP/1.1> Host: 127.0.0.1:9000> User-Agent: curl/7.81.0> Accept: */*> * Mark bundle as not supporting multiuse< HTTP/1.1 500 Internal Server Error< Content-Length: 0< Content-Type: text/plain; charset=utf-8< Date: Wed, 07 Feb 2024 02:57:01 GMT< Server: bfe< * Connection #0 to host 127.0.0.1 left intact






??从上面的信息中已经可以看到上游服务器已经响应了，只不过它响应是500错误，这个无所谓，至少表明https透明代理的功能已经正常工作了。




3. 源码分析
??本文主要聚焦在ssl连接逻辑的分析，所以中间会跳过和ssl逻辑不太相关的代码，虽然可能这部分对nginx本身的功能逻辑非常重要。另外，本文也假设只是TCP代理，不对UDP代理进行分析。


??下面直接进入主题，从代理模块的请求入口点开始分析。




3.1 代理模块的请求入口点分析
??代理模块的请求入口点是ngx_stream_proxy_handler函数，一旦客户端和nginx建立了TCP连接后，nginx就会调用代理模块的这个函数，开始与上游服务器建立连接。


??该函数源码主要就是以下列出的三个步骤：


static voidngx_stream_proxy_handler(ngx_stream_session_t *s){  /* 创建ngx_stream_upstream_t上下文,对它进行必要的初始化，     并关联到ngx_stream_session_t中 */  /* 如果上游服务器的地址已经解析好就调用ngx_stream_proxy_connect开始连接上游服务器 */  /* 如果上游服务器的地址需要域名解析则开启异步解析流程 */   }







??因此，我们需要重点关注的是ngx_stream_proxy_connect，它负责与上游服务器建立TCP连接。




3.2 发起与上游服务器的连接
static voidngx_stream_proxy_connect(ngx_stream_session_t *s){    ngx_int_t                     rc;    ngx_connection_t             *c, *pc;    ngx_stream_upstream_t        *u;    ngx_stream_proxy_srv_conf_t  *pscf;
    c = s->connection;
    c->log->action = \\\"connecting to upstream\\\";
    pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);
    u = s->upstream;
    u->connected = 0;    u->proxy_protocol = pscf->proxy_protocol;
    if (u->state) {        u->state->response_time = ngx_current_msec - u->start_time;    }
    u->state = ngx_array_push(s->upstream_states);    if (u->state == NULL) {        ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);        return;    }
    ngx_memzero(u->state, sizeof(ngx_stream_upstream_state_t));
    u->start_time = ngx_current_msec;
    u->state->connect_time = (ngx_msec_t) -1;    u->state->first_byte_time = (ngx_msec_t) -1;    u->state->response_time = (ngx_msec_t) -1;    /* 创建SOCKET，并发起异步连接请求*/    rc = ngx_event_connect_peer(&u->peer);
    ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0, \\\"proxy connect: %i\\\", rc);
    if (rc == NGX_ERROR) {        ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);        return;    }
    u->state->peer = u->peer.name;
    if (rc == NGX_BUSY) {        ngx_log_error(NGX_LOG_ERR, c->log, 0, \\\"no live upstreams\\\");        ngx_stream_proxy_finalize(s, NGX_STREAM_BAD_GATEWAY);        return;    }
    if (rc == NGX_DECLINED) {      /* 连接失败，则通过负载均衡请求下一个上游服务器 */        ngx_stream_proxy_next_upstream(s);        return;    }
    /* rc == NGX_OK || rc == NGX_AGAIN || rc == NGX_DONE */
    pc = u->peer.connection;
    pc->data = s;    pc->log = c->log;    pc->pool = c->pool;    pc->read->log = c->log;    pc->write->log = c->log;
    if (rc != NGX_AGAIN) {      /* 如果连接已经建立成功了，则进一步初始化 */        ngx_stream_proxy_init_upstream(s);        return;    }
  /* 设置连接的epoll读写回调函数 */    pc->read->handler = ngx_stream_proxy_connect_handler;    pc->write->handler = ngx_stream_proxy_connect_handler;    /* 开启连接超时定时器 */    ngx_add_timer(pc->write, pscf->connect_timeout);}



??这个函数就是发起向上游服务器的一个TCP连接请求，并设置epoll读写的回调函数，本身还和ssl没有太多的关系，其中几个关键步骤已经通过源码注释进行了解释。




3.3 连接回调
??一旦连接成功或者连接超时，nginx的epoll框架最终都会回调到ngx_stream_proxy_connect_handler函数。代码如下：


static voidngx_stream_proxy_connect_handler(ngx_event_t *ev){    ngx_connection_t      *c;    ngx_stream_session_t  *s;
    c = ev->data;    s = c->data;    /* 连接超时，通过负载均衡请求下一个上游服务器 */    if (ev->timedout) {        ngx_log_error(NGX_LOG_ERR, c->log, NGX_ETIMEDOUT, \\\"upstream timed out\\\");        ngx_stream_proxy_next_upstream(s);        return;    }  /* 连接成功了，删除超时定时器 */    ngx_del_timer(c->write);
    ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,                   \\\"stream proxy connect upstream\\\");    /* 检验是否连接成功，如果没有成功，则通过负载均衡请求下一个上游服务器 */    if (ngx_stream_proxy_test_connect(c) != NGX_OK) {        ngx_stream_proxy_next_upstream(s);        return;    }    /* 如果连接已经建立成功了，则进一步初始化 */    ngx_stream_proxy_init_upstream(s);}







??这里，进入到最关键的环节了，即ngx_stream_proxy_init_upstream。




3.4 TCP连接建立成功后为上下游数据透传做准备
??tcp连接建立成功后，需要在业务层面进一步进行初始化，这就是ngx_stream_proxy_init_upstream的功能。对于非ssl连接，那么tcp socket连接建立后就可以进入到本函数进行处理了；但是对于ssl连接，却需要两次进入本函数进行处理，第一次的时候会发现ssl握手还没有执行，就先跑去执行ssl 握手操作，等握手成功以后，会重新回调本函数执行和非ssl连接一样的后续流程。源码如下：


static voidngx_stream_proxy_init_upstream(ngx_stream_session_t *s){    u_char                       *p;    ngx_chain_t                  *cl;    ngx_connection_t             *c, *pc;    ngx_log_handler_pt            handler;    ngx_stream_upstream_t        *u;    ngx_stream_core_srv_conf_t   *cscf;    ngx_stream_proxy_srv_conf_t  *pscf;
    u = s->upstream;    pc = u->peer.connection;
    cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);
    if (pc->type == SOCK_STREAM        && cscf->tcp_nodelay        && ngx_tcp_nodelay(pc) != NGX_OK)    {        ngx_stream_proxy_next_upstream(s);        return;    }
    pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);
#if (NGX_STREAM_SSL)
    if (pc->type == SOCK_STREAM && pscf->ssl_enable) {
        if (u->proxy_protocol) {            if (ngx_stream_proxy_send_proxy_protocol(s) != NGX_OK) {                return;            }
            u->proxy_protocol = 0;        }    /* 如果开启了ssl但是ssl还没有进行握手，就先进行握手操作，       握手成功后会重新回调本函数进行后续处理    */        if (pc->ssl == NULL) {            ngx_stream_proxy_ssl_init_connection(s);            return;        }    }
#endif
    c = s->connection;
    if (c->log->log_level >= NGX_LOG_INFO) {        ngx_str_t  str;        u_char     addr[NGX_SOCKADDR_STRLEN];
        str.len = NGX_SOCKADDR_STRLEN;        str.data = addr;
        if (ngx_connection_local_sockaddr(pc, &str, 1) == NGX_OK) {            handler = c->log->handler;            c->log->handler = NULL;
            ngx_log_error(NGX_LOG_INFO, c->log, 0,                          \\\"%sproxy %V connected to %V\\\",                          pc->type == SOCK_DGRAM ? \\\"udp \\\" : \\\"\\\",                          &str, u->peer.name);
            c->log->handler = handler;        }    }
    u->state->connect_time = ngx_current_msec - u->start_time;
    if (u->peer.notify) {        u->peer.notify(&u->peer, u->peer.data,                       NGX_STREAM_UPSTREAM_NOTIFY_CONNECT);    }
    if (u->upstream_buf.start == NULL) {        p = ngx_pnalloc(c->pool, pscf->buffer_size);        if (p == NULL) {            ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);            return;        }
        u->upstream_buf.start = p;        u->upstream_buf.end = p + pscf->buffer_size;        u->upstream_buf.pos = p;        u->upstream_buf.last = p;    }
    if (c->buffer && c->buffer->pos <= c->buffer->last) {        ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,                       \\\"stream proxy add preread buffer: %uz\\\",                       c->buffer->last - c->buffer->pos);
        cl = ngx_chain_get_free_buf(c->pool, &u->free);        if (cl == NULL) {            ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);            return;        }
        *cl->buf = *c->buffer;
        cl->buf->tag = (ngx_buf_tag_t) &ngx_stream_proxy_module;        cl->buf->temporary = (cl->buf->pos == cl->buf->last) ? 0 : 1;        cl->buf->flush = 1;
        cl->next = u->upstream_out;        u->upstream_out = cl;    }  /* proxy_protocol 协议处理，发送proxy_protocol请求报文 */    if (u->proxy_protocol) {        ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,                       \\\"stream proxy add PROXY protocol header\\\");
        cl = ngx_chain_get_free_buf(c->pool, &u->free);        if (cl == NULL) {            ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);            return;        }
        p = ngx_pnalloc(c->pool, NGX_PROXY_PROTOCOL_V1_MAX_HEADER);        if (p == NULL) {            ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);            return;        }
        cl->buf->pos = p;
        p = ngx_proxy_protocol_write(c, p,                                     p + NGX_PROXY_PROTOCOL_V1_MAX_HEADER);        if (p == NULL) {            ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);            return;        }
        cl->buf->last = p;        cl->buf->temporary = 1;        cl->buf->flush = 0;        cl->buf->last_buf = 0;        cl->buf->tag = (ngx_buf_tag_t) &ngx_stream_proxy_module;
        cl->next = u->upstream_out;        u->upstream_out = cl;
        u->proxy_protocol = 0;    }  /* 设置上下游数据传输速率 */    u->upload_rate = ngx_stream_complex_value_size(s, pscf->upload_rate, 0);    u->download_rate = ngx_stream_complex_value_size(s, pscf->download_rate, 0);
    u->connected = 1;      /* 这里重新设置连接的epoll读写回调函数 */    pc->read->handler = ngx_stream_proxy_upstream_handler;    pc->write->handler = ngx_stream_proxy_upstream_handler;
    if (pc->read->ready) {        ngx_post_event(pc->read, &ngx_posted_events);    }
    ngx_stream_proxy_process(s, 0, 1);}







??这个函数和SSL连接相关的重点部分就是以下这部分代码了。




    



#if (NGX_STREAM_SSL)
if (pc->type == SOCK_STREAM && pscf->ssl_enable) {
  if (u->proxy_protocol) {    if (ngx_stream_proxy_send_proxy_protocol(s) != NGX_OK) {      return;    }
    u->proxy_protocol = 0;  }
  if (pc->ssl == NULL) {    ngx_stream_proxy_ssl_init_connection(s);    return;  }}#endif






??这段代码首先判断是否开启了proxy_protocol协议向上游服务器发起请求，关于proxy_protocol的内容可以参考网络协议之:haproxy的Proxy Protocol代理协议，这里略过。
?接下去就是关键的初始化连接的ssl上下文了“ngx_stream_proxy_ssl_init_connection”。


??连接建立成功后（包括非ssl的tcp连接建立和ssl的握手成功两种情况），最后都需要设置读写回调函数：




    

  • 

  • 



    pc->read->handler = ngx_stream_proxy_upstream_handler;    pc->write->handler = ngx_stream_proxy_upstream_handler;







??在这个ngx_stream_proxy_upstream_handler回调函数中，可以预见就是接收数据，然后发送到对端，这里的逻辑和ssl关系不大，不再赘述。
?但是有一个问题，普通的tcp连接和ssl连接在ngx_stream_proxy_upstream_handler里面最终都要操作系统的recv/send 或者read/write 之类的函数进行socket数据的读写，但是ssl连接通过操作系统的这些函数读取到的肯定是ssl加密后的数据，而write也必然需要发送加密的数据，这是如何做到的呢？这里暂且留一个悬念，留待3.7节进行说明。




3.5 TCP连接的ssl上下文初始化
static voidngx_stream_proxy_ssl_init_connection(ngx_stream_session_t *s){    ngx_int_t                     rc;    ngx_connection_t             *pc;    ngx_stream_upstream_t        *u;    ngx_stream_proxy_srv_conf_t  *pscf;
    u = s->upstream;      /* 获取与上游的连接 */    pc = u->peer.connection;      /* 获取stream proxy模块配置*/    pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);
  /* 创建ssl上下文，并将当前的socket句柄绑定到ssl上下文中 */    if (ngx_ssl_create_connection(pscf->ssl, pc, NGX_SSL_BUFFER|NGX_SSL_CLIENT)        != NGX_OK)    {        ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);        return;    }
  /* 如果设置了上游服务器需要校验客户端证书或者通过proxy_ssl_server_name设置了SNI则     需要将上游服务器的hostname绑定到ssl上下文中， ngx_stream_proxy_ssl_name函数     最终会调用SSL_set_tlsext_host_name函数进行绑定  */    if (pscf->ssl_server_name || pscf->ssl_verify) {        if (ngx_stream_proxy_ssl_name(s) != NGX_OK) {            ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);            return;        }    }
  /* 如果设置了客户端证书， 这里进行证书的绑定 */    if (pscf->ssl_certificate        && pscf->ssl_certificate->value.len        && (pscf->ssl_certificate->lengths            || pscf->ssl_certificate_key->lengths))    {        if (ngx_stream_proxy_ssl_certificate(s) != NGX_OK) {            ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);            return;        }    }
  /* 如果开启了ssl会话的复用功能，这里进行相关设置 */    if (pscf->ssl_session_reuse) {        pc->ssl->save_session = ngx_stream_proxy_ssl_save_session;
        if (u->peer.set_session(&u->peer, u->peer.data) != NGX_OK) {            ngx_stream_proxy_finalize(s, NGX_STREAM_INTERNAL_SERVER_ERROR);            return;        }    }
    s->connection->log->action = \\\"SSL handshaking to upstream\\\";    /* 发起调用openssl底层接口进行异步ssl握手 */    rc = ngx_ssl_handshake(pc);
    if (rc == NGX_AGAIN) {        /* 如果异步握手操作尚未完成，则设置连接超时定时器 */        if (!pc->write->timer_set) {            ngx_add_timer(pc->write, pscf->connect_timeout);        }
    /* 设置ssl握手成功后的回调函数 */        pc->ssl->handler = ngx_stream_proxy_ssl_handshake;        return;    }
  /* openssl底层握手已经成功，进行后续的处理 */    ngx_stream_proxy_ssl_handshake(pc);}



??这个函数的逻辑基本上可以分为两个部分，第一部分是创建ssl的上下文然后准备ssl握手的相关信息；第二部分是发起异步ssl握手操作。由于是异步操作，因此可能是立即完成了，或者要等后续epoll框架等待网络i/o事件发生后才能完成，这个时候就需要设置回调函数ngx_stream_proxy_ssl_handshake来接收完成事件。无论怎样，只要连接最终ssl握手成功，都会进入到ngx_stream_proxy_ssl_handshake函数中。




3.6 ssl握手成功后的处理
?接下来在来看看ngx_stream_proxy_ssl_handshake的实现：


static voidngx_stream_proxy_ssl_handshake(ngx_connection_t *pc){    long                          rc;    ngx_stream_session_t         *s;    ngx_stream_upstream_t        *u;    ngx_stream_proxy_srv_conf_t  *pscf;
    s = pc->data;
    pscf = ngx_stream_get_module_srv_conf(s, ngx_stream_proxy_module);
    if (pc->ssl->handshaked) {  /* 如果已经握手成功 */
        if (pscf->ssl_verify) { /* 如果设置了上游服务器证书有效性验证则需要检查验证结果*/            rc = SSL_get_verify_result(pc->ssl->connection);
            if (rc != X509_V_OK) {                ngx_log_error(NGX_LOG_ERR, pc->log, 0,                              \\\"upstream SSL certificate verify error: (%l:%s)\\\",                              rc, X509_verify_cert_error_string(rc));                goto failed;            }
            u = s->upstream;                  /* 检查握手收到的上游服务器响应信息中的服务器hostname是否和期望的一致*/            if (ngx_ssl_check_host(pc, &u->ssl_name) != NGX_OK) {                ngx_log_error(NGX_LOG_ERR, pc->log, 0,                              \\\"upstream SSL certificate does not match \\\\\\\"%V\\\\\\\"\\\",                              &u->ssl_name);                goto failed;            }        }        /* 握手已经成功了，可以删除连接超时定时器了 */        if (pc->write->timer_set) {            ngx_del_timer(pc->write);        }            /* 进入和非ssl一样的流程，为开始透传数据进行准备工作 */        ngx_stream_proxy_init_upstream(s);
        return;    }
failed:  /* 如果握手失败，则选择下一个可用的上游服务器进行连接 */    ngx_stream_proxy_next_upstream(s);}







??可以很清晰地看到，ssl连接最终还是回调了ngx_stream_proxy_init_upstream准备数据透传工作。ngx_stream_proxy_init_upstream的分析参考3.4节。




3.7 连接数据的收与发
??以上ssl连接建立成功后，接下去需要进行数据的收和发，因为和上游建立的是ssl连接，那么收到的上游服务器的报文需要解密后发送给下游客户端，反过来，从下游客户端收到的报文又需要经过加密后发送给上游服务器。加解密这个过程必然是openssl帮我们来解决，如果openssl的上层应用能够透明使用那就再好不过了，事实上也的确如此。如下图所示：


?   在上文3.5节中没有分析到的ngx_ssl_handshake函数内部，有一段如下代码：


c->recv = ngx_ssl_recv;c->send = ngx_ssl_write;c->recv_chain = ngx_ssl_recv_chain;c->send_chain = ngx_ssl_send_chain;
c->read->ready = 1;c->write->ready = 1;







??意思是握手成功后，将socket的读写函数替换为对应的ssl的读写函数，譬如ngx_ssl_recv它就是对openssl中对应的SSL_read进行了二次封装，其他几个函数也是类似的。具体在这里就不再展开了。


??再补充一下，如果是非ssl连接，nginx默认进行如下设置：


c->recv = ngx_recv;c->send = ngx_send;c->recv_chain = ngx_recv_chain;c->send_chain = ngx_send_chain;







而这个是在ngx_event_connect_peer函数中完成的。


??至此，ngx_stream_upstream_module的ssl连接的处理过程就全部分析完毕了。总体上来说处理过程还是比较清晰了，后面有时间就可以来考虑一下如何利用这个分析的结果来实现https主动健康检测功能了。





                                                        
原创文章，作者：网络技术联盟站，如若转载，请注明出处：https://www.sudun.com/ask/49782.html
Like (0)
网络技术联盟站的头像网络技术联盟站
0 0
Previous 2024年5月16日
Next 2024年5月16日

相关推荐

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注