One Level Up Top Level

src/stream/ngx_stream_ssl_preread_module.c - nginx source code

Global variables defined

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Nginx, Inc.
  4. */


  7. #include <ngx_config.h>
  8. #include <ngx_core.h>
  9. #include <ngx_stream.h>


  12. ‌typedef struct {
  13.     ngx_flag_t      enabled;
  14. ‌} ngx_stream_ssl_preread_srv_conf_t;


  17. ‌typedef struct {
  18.     size_t          left;
  19.     size_t          size;
  20.     size_t          ext;
  21.     u_char         *pos;
  22.     u_char         *dst;
  23.     u_char          buf[4];
  24.     u_char          version[2];
  25.     ngx_str_t       host;
  26.     ngx_str_t       alpn;
  27.     ngx_log_t      *log;
  28.     ngx_pool_t     *pool;
  29.     ngx_uint_t      state;
  30. ‌} ngx_stream_ssl_preread_ctx_t;


  33. static ngx_int_t ngx_stream_ssl_preread_handler(ngx_stream_session_t *s);
  34. static ngx_int_t ngx_stream_ssl_preread_parse_record(
  35.     ngx_stream_ssl_preread_ctx_t *ctx, u_char *pos, u_char *last);
  36. static ngx_int_t ngx_stream_ssl_preread_servername(ngx_stream_session_t *s,
  37.     ngx_str_t *servername);
  38. static ngx_int_t ngx_stream_ssl_preread_protocol_variable(
  39.     ngx_stream_session_t *s, ngx_stream_variable_value_t *v, uintptr_t data);
  40. static ngx_int_t ngx_stream_ssl_preread_server_name_variable(
  41.     ngx_stream_session_t *s, ngx_stream_variable_value_t *v, uintptr_t data);
  42. static ngx_int_t ngx_stream_ssl_preread_alpn_protocols_variable(
  43.     ngx_stream_session_t *s, ngx_stream_variable_value_t *v, uintptr_t data);
  44. static ngx_int_t ngx_stream_ssl_preread_add_variables(ngx_conf_t *cf);
  45. static void *ngx_stream_ssl_preread_create_srv_conf(ngx_conf_t *cf);
  46. static char *ngx_stream_ssl_preread_merge_srv_conf(ngx_conf_t *cf, void *parent,
  47.     void *child);
  48. static ngx_int_t ngx_stream_ssl_preread_init(ngx_conf_t *cf);


  51. ‌static ngx_command_t  ngx_stream_ssl_preread_commands[] = {

  53.     { ngx_string("ssl_preread"),
  54.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  55.       ngx_conf_set_flag_slot,
  56.       NGX_STREAM_SRV_CONF_OFFSET,
  57.       offsetof(ngx_stream_ssl_preread_srv_conf_t, enabled),
  58.       NULL },

  60.       ngx_null_command
  61. };


  64. ‌static ngx_stream_module_t  ngx_stream_ssl_preread_module_ctx = {
  65.     ngx_stream_ssl_preread_add_variables,   /* preconfiguration */
  66.     ngx_stream_ssl_preread_init,            /* postconfiguration */

  68.     NULL,                                   /* create main configuration */
  69.     NULL,                                   /* init main configuration */

  71.     ngx_stream_ssl_preread_create_srv_conf, /* create server configuration */
  72.     ngx_stream_ssl_preread_merge_srv_conf   /* merge server configuration */
  73. };


  76. ‌ngx_module_t  ngx_stream_ssl_preread_module = {
  77.     NGX_MODULE_V1,
  78.     &ngx_stream_ssl_preread_module_ctx,     /* module context */
  79.     ngx_stream_ssl_preread_commands,        /* module directives */
  80.     NGX_STREAM_MODULE,                      /* module type */
  81.     NULL,                                   /* init master */
  82.     NULL,                                   /* init module */
  83.     NULL,                                   /* init process */
  84.     NULL,                                   /* init thread */
  85.     NULL,                                   /* exit thread */
  86.     NULL,                                   /* exit process */
  87.     NULL,                                   /* exit master */
  88.     NGX_MODULE_V1_PADDING
  89. };


  92. ‌static ngx_stream_variable_t  ngx_stream_ssl_preread_vars[] = {

  94.     { ngx_string("ssl_preread_protocol"), NULL,
  95.       ngx_stream_ssl_preread_protocol_variable, 0, 0, 0 },

  97.     { ngx_string("ssl_preread_server_name"), NULL,
  98.       ngx_stream_ssl_preread_server_name_variable, 0, 0, 0 },

  100.     { ngx_string("ssl_preread_alpn_protocols"), NULL,
  101.       ngx_stream_ssl_preread_alpn_protocols_variable, 0, 0, 0 },

  103.       ngx_stream_null_variable
  104. };


  107. static ngx_int_t
  108. ‌ngx_stream_ssl_preread_handler(ngx_stream_session_t *s)
  109. {
  110.     u_char                             *last, *p;
  111.     size_t                              len;
  112.     ngx_int_t                           rc;
  113.     ngx_connection_t                   *c;
  114.     ngx_stream_ssl_preread_ctx_t       *ctx;
  115.     ngx_stream_ssl_preread_srv_conf_t  *sscf;

  117.     c = s->connection;

  119.     ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0, "ssl preread handler");

  121.     sscf = ngx_stream_get_module_srv_conf(s, ngx_stream_ssl_preread_module);

  123.     if (!sscf->enabled) {
  124.         return NGX_DECLINED;
  125.     }

  127.     if (c->type != SOCK_STREAM) {
  128.         return NGX_DECLINED;
  129.     }

  131.     if (c->buffer == NULL) {
  132.         return NGX_AGAIN;
  133.     }

  135.     ctx = ngx_stream_get_module_ctx(s, ngx_stream_ssl_preread_module);
  136.     if (ctx == NULL) {
  137.         ctx = ngx_pcalloc(c->pool, sizeof(ngx_stream_ssl_preread_ctx_t));
  138.         if (ctx == NULL) {
  139.             return NGX_ERROR;
  140.         }

  142.         ngx_stream_set_ctx(s, ctx, ngx_stream_ssl_preread_module);

  144.         ctx->pool = c->pool;
  145.         ctx->log = c->log;
  146.         ctx->pos = c->buffer->pos;
  147.     }

  149.     p = ctx->pos;
  150.     last = c->buffer->last;

  152.     while (last - p >= 5) {

  154.         if ((p[0] & 0x80) && p[2] == 1 && (p[3] == 0 || p[3] == 3)) {
  155.             ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0,
  156.                            "ssl preread: version 2 ClientHello");
  157.             ctx->version[0] = p[3];
  158.             ctx->version[1] = p[4];
  159.             return NGX_OK;
  160.         }

  162.         if (p[0] != 0x16) {
  163.             ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0,
  164.                            "ssl preread: not a handshake");
  165.             ngx_stream_set_ctx(s, NULL, ngx_stream_ssl_preread_module);
  166.             return NGX_DECLINED;
  167.         }

  169.         if (p[1] != 3) {
  170.             ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0,
  171.                            "ssl preread: unsupported SSL version");
  172.             ngx_stream_set_ctx(s, NULL, ngx_stream_ssl_preread_module);
  173.             return NGX_DECLINED;
  174.         }

  176.         len = (p[3] << 8) + p[4];

  178.         /* read the whole record before parsing */
  179.         if ((size_t) (last - p) < len + 5) {
  180.             break;
  181.         }

  183.         p += 5;

  185.         rc = ngx_stream_ssl_preread_parse_record(ctx, p, p + len);

  187.         if (rc == NGX_DECLINED) {
  188.             ngx_stream_set_ctx(s, NULL, ngx_stream_ssl_preread_module);
  189.             return NGX_DECLINED;
  190.         }

  192.         if (rc == NGX_OK) {
  193.             return ngx_stream_ssl_preread_servername(s, &ctx->host);
  194.         }

  196.         if (rc != NGX_AGAIN) {
  197.             return rc;
  198.         }

  200.         p += len;
  201.     }

  203.     ctx->pos = p;

  205.     return NGX_AGAIN;
  206. }


  209. static ngx_int_t
  210. ‌ngx_stream_ssl_preread_parse_record(ngx_stream_ssl_preread_ctx_t *ctx,
  211.     u_char *pos, u_char *last)
  212. {
  213.     size_t   left, n, size, ext;
  214.     u_char  *dst, *p;

  216. ‌    enum {
  217.         sw_start = 0,
  218.         sw_header,          /* handshake msg_type, length */
  219.         sw_version,         /* client_version */
  220.         sw_random,          /* random */
  221.         sw_sid_len,         /* session_id length */
  222.         sw_sid,             /* session_id */
  223.         sw_cs_len,          /* cipher_suites length */
  224.         sw_cs,              /* cipher_suites */
  225.         sw_cm_len,          /* compression_methods length */
  226.         sw_cm,              /* compression_methods */
  227.         sw_ext,             /* extension */
  228.         sw_ext_header,      /* extension_type, extension_data length */
  229.         sw_sni_len,         /* SNI length */
  230.         sw_sni_host_head,   /* SNI name_type, host_name length */
  231.         sw_sni_host,        /* SNI host_name */
  232.         sw_alpn_len,        /* ALPN length */
  233.         sw_alpn_proto_len,  /* ALPN protocol_name length */
  234.         sw_alpn_proto_data, /* ALPN protocol_name */
  235.         sw_supver_len       /* supported_versions length */
  236.     } state;

  238.     ngx_log_debug2(NGX_LOG_DEBUG_STREAM, ctx->log, 0,
  239.                    "ssl preread: state %ui left %z", ctx->state, ctx->left);

  241.     state = ctx->state;
  242.     size = ctx->size;
  243.     left = ctx->left;
  244.     ext = ctx->ext;
  245.     dst = ctx->dst;
  246.     p = ctx->buf;

  248.     for ( ;; ) {
  249.         n = ngx_min((size_t) (last - pos), size);

  251.         if (dst) {
  252.             dst = ngx_cpymem(dst, pos, n);
  253.         }

  255.         pos += n;
  256.         size -= n;
  257.         left -= n;

  259.         if (size != 0) {
  260.             break;
  261.         }

  263.         switch (state) {

  265.         case sw_start:
  266.             state = sw_header;
  267.             dst = p;
  268.             size = 4;
  269.             left = size;
  270.             break;

  272.         case sw_header:
  273.             if (p[0] != 1) {
  274.                 ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0,
  275.                                "ssl preread: not a client hello");
  276.                 return NGX_DECLINED;
  277.             }

  279.             state = sw_version;
  280.             dst = ctx->version;
  281.             size = 2;
  282.             left = (p[1] << 16) + (p[2] << 8) + p[3];
  283.             break;

  285.         case sw_version:
  286.             state = sw_random;
  287.             dst = NULL;
  288.             size = 32;
  289.             break;

  291.         case sw_random:
  292.             state = sw_sid_len;
  293.             dst = p;
  294.             size = 1;
  295.             break;

  297.         case sw_sid_len:
  298.             state = sw_sid;
  299.             dst = NULL;
  300.             size = p[0];
  301.             break;

  303.         case sw_sid:
  304.             state = sw_cs_len;
  305.             dst = p;
  306.             size = 2;
  307.             break;

  309.         case sw_cs_len:
  310.             state = sw_cs;
  311.             dst = NULL;
  312.             size = (p[0] << 8) + p[1];
  313.             break;

  315.         case sw_cs:
  316.             state = sw_cm_len;
  317.             dst = p;
  318.             size = 1;
  319.             break;

  321.         case sw_cm_len:
  322.             state = sw_cm;
  323.             dst = NULL;
  324.             size = p[0];
  325.             break;

  327.         case sw_cm:
  328.             if (left == 0) {
  329.                 /* no extensions */
  330.                 return NGX_OK;
  331.             }

  333.             state = sw_ext;
  334.             dst = p;
  335.             size = 2;
  336.             break;

  338.         case sw_ext:
  339.             if (left == 0) {
  340.                 return NGX_OK;
  341.             }

  343.             state = sw_ext_header;
  344.             dst = p;
  345.             size = 4;
  346.             break;

  348.         case sw_ext_header:
  349.             if (p[0] == 0 && p[1] == 0 && ctx->host.data == NULL) {
  350.                 /* SNI extension */
  351.                 state = sw_sni_len;
  352.                 dst = p;
  353.                 size = 2;
  354.                 break;
  355.             }

  357.             if (p[0] == 0 && p[1] == 16 && ctx->alpn.data == NULL) {
  358.                 /* ALPN extension */
  359.                 state = sw_alpn_len;
  360.                 dst = p;
  361.                 size = 2;
  362.                 break;
  363.             }

  365.             if (p[0] == 0 && p[1] == 43) {
  366.                 /* supported_versions extension */
  367.                 state = sw_supver_len;
  368.                 dst = p;
  369.                 size = 1;
  370.                 break;
  371.             }

  373.             state = sw_ext;
  374.             dst = NULL;
  375.             size = (p[2] << 8) + p[3];
  376.             break;

  378.         case sw_sni_len:
  379.             ext = (p[0] << 8) + p[1];
  380.             state = sw_sni_host_head;
  381.             dst = p;
  382.             size = 3;
  383.             break;

  385.         case sw_sni_host_head:
  386.             if (p[0] != 0) {
  387.                 ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0,
  388.                                "ssl preread: SNI hostname type is not DNS");
  389.                 return NGX_DECLINED;
  390.             }

  392.             size = (p[1] << 8) + p[2];

  394.             if (ext < 3 + size) {
  395.                 ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0,
  396.                                "ssl preread: SNI format error");
  397.                 return NGX_DECLINED;
  398.             }
  399.             ext -= 3 + size;

  401.             ctx->host.data = ngx_pnalloc(ctx->pool, size);
  402.             if (ctx->host.data == NULL) {
  403.                 return NGX_ERROR;
  404.             }

  406.             state = sw_sni_host;
  407.             dst = ctx->host.data;
  408.             break;

  410.         case sw_sni_host:
  411.             ctx->host.len = (p[1] << 8) + p[2];

  413.             state = sw_ext;
  414.             dst = NULL;
  415.             size = ext;
  416.             break;

  418.         case sw_alpn_len:
  419.             ext = (p[0] << 8) + p[1];

  421.             ctx->alpn.data = ngx_pnalloc(ctx->pool, ext);
  422.             if (ctx->alpn.data == NULL) {
  423.                 return NGX_ERROR;
  424.             }

  426.             state = sw_alpn_proto_len;
  427.             dst = p;
  428.             size = 1;
  429.             break;

  431.         case sw_alpn_proto_len:
  432.             size = p[0];

  434.             if (size == 0) {
  435.                 ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0,
  436.                                "ssl preread: ALPN empty protocol");
  437.                 return NGX_DECLINED;
  438.             }

  440.             if (ext < 1 + size) {
  441.                 ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0,
  442.                                "ssl preread: ALPN format error");
  443.                 return NGX_DECLINED;
  444.             }
  445.             ext -= 1 + size;

  447.             state = sw_alpn_proto_data;
  448.             dst = ctx->alpn.data + ctx->alpn.len;
  449.             break;

  451.         case sw_alpn_proto_data:
  452.             ctx->alpn.len += p[0];

  454.             ngx_log_debug1(NGX_LOG_DEBUG_STREAM, ctx->log, 0,
  455.                            "ssl preread: ALPN protocols \"%V\"", &ctx->alpn);

  457.             if (ext) {
  458.                 ctx->alpn.data[ctx->alpn.len++] = ',';

  460.                 state = sw_alpn_proto_len;
  461.                 dst = p;
  462.                 size = 1;
  463.                 break;
  464.             }

  466.             state = sw_ext;
  467.             dst = NULL;
  468.             size = 0;
  469.             break;

  471.         case sw_supver_len:
  472.             ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0,
  473.                            "ssl preread: supported_versions");

  475.             /* set TLSv1.3 */
  476.             ctx->version[0] = 3;
  477.             ctx->version[1] = 4;

  479.             state = sw_ext;
  480.             dst = NULL;
  481.             size = p[0];
  482.             break;
  483.         }

  485.         if (left < size) {
  486.             ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ctx->log, 0,
  487.                            "ssl preread: failed to parse handshake");
  488.             return NGX_DECLINED;
  489.         }
  490.     }

  492.     ctx->state = state;
  493.     ctx->size = size;
  494.     ctx->left = left;
  495.     ctx->ext = ext;
  496.     ctx->dst = dst;

  498.     return NGX_AGAIN;
  499. }


  502. static ngx_int_t
  503. ‌ngx_stream_ssl_preread_servername(ngx_stream_session_t *s,
  504.     ngx_str_t *servername)
  505. {
  506.     ngx_int_t                    rc;
  507.     ngx_str_t                    host;
  508.     ngx_connection_t            *c;
  509.     ngx_stream_core_srv_conf_t  *cscf;

  511.     c = s->connection;

  513.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
  514.                    "SSL preread server name: \"%V\"", servername);

  516.     if (servername->len == 0) {
  517.         return NGX_OK;
  518.     }

  520.     host = *servername;

  522.     rc = ngx_stream_validate_host(&host, c->pool, 0);

  524.     if (rc == NGX_ERROR) {
  525.         return NGX_ERROR;
  526.     }

  528.     if (rc == NGX_DECLINED) {
  529.         return NGX_OK;
  530.     }

  532.     rc = ngx_stream_find_virtual_server(s, &host, &cscf);

  534.     if (rc == NGX_ERROR) {
  535.         return NGX_ERROR;
  536.     }

  538.     if (rc == NGX_DECLINED) {
  539.         return NGX_OK;
  540.     }

  542.     s->srv_conf = cscf->ctx->srv_conf;

  544.     ngx_set_connection_log(c, cscf->error_log);

  546.     return NGX_OK;
  547. }


  550. static ngx_int_t
  551. ‌ngx_stream_ssl_preread_protocol_variable(ngx_stream_session_t *s,
  552.     ngx_variable_value_t *v, uintptr_t data)
  553. {
  554.     ngx_str_t                      version;
  555.     ngx_stream_ssl_preread_ctx_t  *ctx;

  557.     ctx = ngx_stream_get_module_ctx(s, ngx_stream_ssl_preread_module);

  559.     if (ctx == NULL) {
  560.         v->not_found = 1;
  561.         return NGX_OK;
  562.     }

  564.     /* SSL_get_version() format */

  566.     ngx_str_null(&version);

  568.     switch (ctx->version[0]) {
  569.     case 0:
  570.         switch (ctx->version[1]) {
  571.         case 2:
  572.             ngx_str_set(&version, "SSLv2");
  573.             break;
  574.         }
  575.         break;
  576.     case 3:
  577.         switch (ctx->version[1]) {
  578.         case 0:
  579.             ngx_str_set(&version, "SSLv3");
  580.             break;
  581.         case 1:
  582.             ngx_str_set(&version, "TLSv1");
  583.             break;
  584.         case 2:
  585.             ngx_str_set(&version, "TLSv1.1");
  586.             break;
  587.         case 3:
  588.             ngx_str_set(&version, "TLSv1.2");
  589.             break;
  590.         case 4:
  591.             ngx_str_set(&version, "TLSv1.3");
  592.             break;
  593.         }
  594.     }

  596.     v->valid = 1;
  597.     v->no_cacheable = 0;
  598.     v->not_found = 0;
  599.     v->len = version.len;
  600.     v->data = version.data;

  602.     return NGX_OK;
  603. }


  606. static ngx_int_t
  607. ‌ngx_stream_ssl_preread_server_name_variable(ngx_stream_session_t *s,
  608.     ngx_variable_value_t *v, uintptr_t data)
  609. {
  610.     ngx_stream_ssl_preread_ctx_t  *ctx;

  612.     ctx = ngx_stream_get_module_ctx(s, ngx_stream_ssl_preread_module);

  614.     if (ctx == NULL) {
  615.         v->not_found = 1;
  616.         return NGX_OK;
  617.     }

  619.     v->valid = 1;
  620.     v->no_cacheable = 0;
  621.     v->not_found = 0;
  622.     v->len = ctx->host.len;
  623.     v->data = ctx->host.data;

  625.     return NGX_OK;
  626. }


  629. static ngx_int_t
  630. ‌ngx_stream_ssl_preread_alpn_protocols_variable(ngx_stream_session_t *s,
  631.     ngx_variable_value_t *v, uintptr_t data)
  632. {
  633.     ngx_stream_ssl_preread_ctx_t  *ctx;

  635.     ctx = ngx_stream_get_module_ctx(s, ngx_stream_ssl_preread_module);

  637.     if (ctx == NULL) {
  638.         v->not_found = 1;
  639.         return NGX_OK;
  640.     }

  642.     v->valid = 1;
  643.     v->no_cacheable = 0;
  644.     v->not_found = 0;
  645.     v->len = ctx->alpn.len;
  646.     v->data = ctx->alpn.data;

  648.     return NGX_OK;
  649. }


  652. static ngx_int_t
  653. ‌ngx_stream_ssl_preread_add_variables(ngx_conf_t *cf)
  654. {
  655.     ngx_stream_variable_t  *var, *v;

  657.     for (v = ngx_stream_ssl_preread_vars; v->name.len; v++) {
  658.         var = ngx_stream_add_variable(cf, &v->name, v->flags);
  659.         if (var == NULL) {
  660.             return NGX_ERROR;
  661.         }

  663.         var->get_handler = v->get_handler;
  664.         var->data = v->data;
  665.     }

  667.     return NGX_OK;
  668. }


  671. static void *
  672. ‌ngx_stream_ssl_preread_create_srv_conf(ngx_conf_t *cf)
  673. {
  674.     ngx_stream_ssl_preread_srv_conf_t  *conf;

  676.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_ssl_preread_srv_conf_t));
  677.     if (conf == NULL) {
  678.         return NULL;
  679.     }

  681.     conf->enabled = NGX_CONF_UNSET;

  683.     return conf;
  684. }


  687. static char *
  688. ‌ngx_stream_ssl_preread_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  689. {
  690.     ngx_stream_ssl_preread_srv_conf_t *prev = parent;
  691.     ngx_stream_ssl_preread_srv_conf_t *conf = child;

  693.     ngx_conf_merge_value(conf->enabled, prev->enabled, 0);

  695.     return NGX_CONF_OK;
  696. }


  699. static ngx_int_t
  700. ‌ngx_stream_ssl_preread_init(ngx_conf_t *cf)
  701. {
  702.     ngx_stream_handler_pt        *h;
  703.     ngx_stream_core_main_conf_t  *cmcf;

  705.     cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);

  707.     h = ngx_array_push(&cmcf->phases[NGX_STREAM_PREREAD_PHASE].handlers);
  708.     if (h == NULL) {
  709.         return NGX_ERROR;
  710.     }

  712.     *h = ngx_stream_ssl_preread_handler;

  714.     return NGX_OK;
  715. }

One Level Up Top Level