One Level Up Top Level

src/stream/ngx_stream_ssl_module.c - nginx source code

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


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


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


  13. ‌typedef ngx_int_t (*ngx_ssl_variable_handler_pt)(ngx_connection_t *c,
  14.     ngx_pool_t *pool, ngx_str_t *s);


  17. ‌#define NGX_DEFAULT_CIPHERS     "HIGH:!aNULL:!MD5"
  18. ‌#define NGX_DEFAULT_ECDH_CURVE  "auto"


  21. static ngx_int_t ngx_stream_ssl_handler(ngx_stream_session_t *s);
  22. static ngx_int_t ngx_stream_ssl_init_connection(ngx_ssl_t *ssl,
  23.     ngx_connection_t *c);
  24. static void ngx_stream_ssl_handshake_handler(ngx_connection_t *c);
  25. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
  26. static int ngx_stream_ssl_servername(ngx_ssl_conn_t *ssl_conn, int *ad,
  27.     void *arg);
  28. #endif
  29. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
  30. static int ngx_stream_ssl_alpn_select(ngx_ssl_conn_t *ssl_conn,
  31.     const unsigned char **out, unsigned char *outlen,
  32.     const unsigned char *in, unsigned int inlen, void *arg);
  33. #endif
  34. #ifdef SSL_R_CERT_CB_ERROR
  35. static int ngx_stream_ssl_certificate(ngx_ssl_conn_t *ssl_conn, void *arg);
  36. #endif
  37. static ngx_int_t ngx_stream_ssl_static_variable(ngx_stream_session_t *s,
  38.     ngx_stream_variable_value_t *v, uintptr_t data);
  39. static ngx_int_t ngx_stream_ssl_variable(ngx_stream_session_t *s,
  40.     ngx_stream_variable_value_t *v, uintptr_t data);

  42. static ngx_int_t ngx_stream_ssl_add_variables(ngx_conf_t *cf);
  43. static void *ngx_stream_ssl_create_srv_conf(ngx_conf_t *cf);
  44. static char *ngx_stream_ssl_merge_srv_conf(ngx_conf_t *cf, void *parent,
  45.     void *child);

  47. static ngx_int_t ngx_stream_ssl_compile_certificates(ngx_conf_t *cf,
  48.     ngx_stream_ssl_srv_conf_t *conf);

  50. static char *ngx_stream_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd,
  51.     void *conf);
  52. static char *ngx_stream_ssl_session_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  53.     void *conf);
  54. static char *ngx_stream_ssl_ocsp_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  55.     void *conf);
  56. static char *ngx_stream_ssl_alpn(ngx_conf_t *cf, ngx_command_t *cmd,
  57.     void *conf);

  59. static char *ngx_stream_ssl_conf_command_check(ngx_conf_t *cf, void *post,
  60.     void *data);

  62. static ngx_int_t ngx_stream_ssl_init(ngx_conf_t *cf);


  65. ‌static ngx_conf_bitmask_t  ngx_stream_ssl_protocols[] = {
  66.     { ngx_string("SSLv2"), NGX_SSL_SSLv2 },
  67.     { ngx_string("SSLv3"), NGX_SSL_SSLv3 },
  68.     { ngx_string("TLSv1"), NGX_SSL_TLSv1 },
  69.     { ngx_string("TLSv1.1"), NGX_SSL_TLSv1_1 },
  70.     { ngx_string("TLSv1.2"), NGX_SSL_TLSv1_2 },
  71.     { ngx_string("TLSv1.3"), NGX_SSL_TLSv1_3 },
  72.     { ngx_null_string, 0 }
  73. };


  76. ‌static ngx_conf_enum_t  ngx_stream_ssl_verify[] = {
  77.     { ngx_string("off"), 0 },
  78.     { ngx_string("on"), 1 },
  79.     { ngx_string("optional"), 2 },
  80.     { ngx_string("optional_no_ca"), 3 },
  81.     { ngx_null_string, 0 }
  82. };


  85. ‌static ngx_conf_enum_t  ngx_stream_ssl_ocsp[] = {
  86.     { ngx_string("off"), 0 },
  87.     { ngx_string("on"), 1 },
  88.     { ngx_string("leaf"), 2 },
  89.     { ngx_null_string, 0 }
  90. };


  93. ‌static ngx_conf_post_t  ngx_stream_ssl_conf_command_post =
  94.     { ngx_stream_ssl_conf_command_check };


  97. ‌static ngx_command_t  ngx_stream_ssl_commands[] = {

  99.     { ngx_string("ssl_handshake_timeout"),
  100.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  101.       ngx_conf_set_msec_slot,
  102.       NGX_STREAM_SRV_CONF_OFFSET,
  103.       offsetof(ngx_stream_ssl_srv_conf_t, handshake_timeout),
  104.       NULL },

  106.     { ngx_string("ssl_certificate"),
  107.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  108.       ngx_conf_set_str_array_slot,
  109.       NGX_STREAM_SRV_CONF_OFFSET,
  110.       offsetof(ngx_stream_ssl_srv_conf_t, certificates),
  111.       NULL },

  113.     { ngx_string("ssl_certificate_key"),
  114.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  115.       ngx_conf_set_str_array_slot,
  116.       NGX_STREAM_SRV_CONF_OFFSET,
  117.       offsetof(ngx_stream_ssl_srv_conf_t, certificate_keys),
  118.       NULL },

  120.     { ngx_string("ssl_password_file"),
  121.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  122.       ngx_stream_ssl_password_file,
  123.       NGX_STREAM_SRV_CONF_OFFSET,
  124.       0,
  125.       NULL },

  127.     { ngx_string("ssl_dhparam"),
  128.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  129.       ngx_conf_set_str_slot,
  130.       NGX_STREAM_SRV_CONF_OFFSET,
  131.       offsetof(ngx_stream_ssl_srv_conf_t, dhparam),
  132.       NULL },

  134.     { ngx_string("ssl_ecdh_curve"),
  135.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  136.       ngx_conf_set_str_slot,
  137.       NGX_STREAM_SRV_CONF_OFFSET,
  138.       offsetof(ngx_stream_ssl_srv_conf_t, ecdh_curve),
  139.       NULL },

  141.     { ngx_string("ssl_protocols"),
  142.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_1MORE,
  143.       ngx_conf_set_bitmask_slot,
  144.       NGX_STREAM_SRV_CONF_OFFSET,
  145.       offsetof(ngx_stream_ssl_srv_conf_t, protocols),
  146.       &ngx_stream_ssl_protocols },

  148.     { ngx_string("ssl_ciphers"),
  149.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  150.       ngx_conf_set_str_slot,
  151.       NGX_STREAM_SRV_CONF_OFFSET,
  152.       offsetof(ngx_stream_ssl_srv_conf_t, ciphers),
  153.       NULL },

  155.     { ngx_string("ssl_verify_client"),
  156.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  157.       ngx_conf_set_enum_slot,
  158.       NGX_STREAM_SRV_CONF_OFFSET,
  159.       offsetof(ngx_stream_ssl_srv_conf_t, verify),
  160.       &ngx_stream_ssl_verify },

  162.     { ngx_string("ssl_verify_depth"),
  163.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  164.       ngx_conf_set_num_slot,
  165.       NGX_STREAM_SRV_CONF_OFFSET,
  166.       offsetof(ngx_stream_ssl_srv_conf_t, verify_depth),
  167.       NULL },

  169.     { ngx_string("ssl_client_certificate"),
  170.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  171.       ngx_conf_set_str_slot,
  172.       NGX_STREAM_SRV_CONF_OFFSET,
  173.       offsetof(ngx_stream_ssl_srv_conf_t, client_certificate),
  174.       NULL },

  176.     { ngx_string("ssl_trusted_certificate"),
  177.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  178.       ngx_conf_set_str_slot,
  179.       NGX_STREAM_SRV_CONF_OFFSET,
  180.       offsetof(ngx_stream_ssl_srv_conf_t, trusted_certificate),
  181.       NULL },

  183.     { ngx_string("ssl_prefer_server_ciphers"),
  184.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  185.       ngx_conf_set_flag_slot,
  186.       NGX_STREAM_SRV_CONF_OFFSET,
  187.       offsetof(ngx_stream_ssl_srv_conf_t, prefer_server_ciphers),
  188.       NULL },

  190.     { ngx_string("ssl_session_cache"),
  191.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE12,
  192.       ngx_stream_ssl_session_cache,
  193.       NGX_STREAM_SRV_CONF_OFFSET,
  194.       0,
  195.       NULL },

  197.     { ngx_string("ssl_session_tickets"),
  198.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  199.       ngx_conf_set_flag_slot,
  200.       NGX_STREAM_SRV_CONF_OFFSET,
  201.       offsetof(ngx_stream_ssl_srv_conf_t, session_tickets),
  202.       NULL },

  204.     { ngx_string("ssl_session_ticket_key"),
  205.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  206.       ngx_conf_set_str_array_slot,
  207.       NGX_STREAM_SRV_CONF_OFFSET,
  208.       offsetof(ngx_stream_ssl_srv_conf_t, session_ticket_keys),
  209.       NULL },

  211.     { ngx_string("ssl_session_timeout"),
  212.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  213.       ngx_conf_set_sec_slot,
  214.       NGX_STREAM_SRV_CONF_OFFSET,
  215.       offsetof(ngx_stream_ssl_srv_conf_t, session_timeout),
  216.       NULL },

  218.     { ngx_string("ssl_crl"),
  219.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  220.       ngx_conf_set_str_slot,
  221.       NGX_STREAM_SRV_CONF_OFFSET,
  222.       offsetof(ngx_stream_ssl_srv_conf_t, crl),
  223.       NULL },

  225.     { ngx_string("ssl_ocsp"),
  226.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  227.       ngx_conf_set_enum_slot,
  228.       NGX_STREAM_SRV_CONF_OFFSET,
  229.       offsetof(ngx_stream_ssl_srv_conf_t, ocsp),
  230.       &ngx_stream_ssl_ocsp },

  232.     { ngx_string("ssl_ocsp_responder"),
  233.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  234.       ngx_conf_set_str_slot,
  235.       NGX_STREAM_SRV_CONF_OFFSET,
  236.       offsetof(ngx_stream_ssl_srv_conf_t, ocsp_responder),
  237.       NULL },

  239.     { ngx_string("ssl_ocsp_cache"),
  240.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  241.       ngx_stream_ssl_ocsp_cache,
  242.       NGX_STREAM_SRV_CONF_OFFSET,
  243.       0,
  244.       NULL },

  246.     { ngx_string("ssl_stapling"),
  247.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  248.       ngx_conf_set_flag_slot,
  249.       NGX_STREAM_SRV_CONF_OFFSET,
  250.       offsetof(ngx_stream_ssl_srv_conf_t, stapling),
  251.       NULL },

  253.     { ngx_string("ssl_stapling_file"),
  254.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  255.       ngx_conf_set_str_slot,
  256.       NGX_STREAM_SRV_CONF_OFFSET,
  257.       offsetof(ngx_stream_ssl_srv_conf_t, stapling_file),
  258.       NULL },

  260.     { ngx_string("ssl_stapling_responder"),
  261.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  262.       ngx_conf_set_str_slot,
  263.       NGX_STREAM_SRV_CONF_OFFSET,
  264.       offsetof(ngx_stream_ssl_srv_conf_t, stapling_responder),
  265.       NULL },

  267.     { ngx_string("ssl_stapling_verify"),
  268.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  269.       ngx_conf_set_flag_slot,
  270.       NGX_STREAM_SRV_CONF_OFFSET,
  271.       offsetof(ngx_stream_ssl_srv_conf_t, stapling_verify),
  272.       NULL },

  274.     { ngx_string("ssl_conf_command"),
  275.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE2,
  276.       ngx_conf_set_keyval_slot,
  277.       NGX_STREAM_SRV_CONF_OFFSET,
  278.       offsetof(ngx_stream_ssl_srv_conf_t, conf_commands),
  279.       &ngx_stream_ssl_conf_command_post },

  281.     { ngx_string("ssl_reject_handshake"),
  282.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  283.       ngx_conf_set_flag_slot,
  284.       NGX_STREAM_SRV_CONF_OFFSET,
  285.       offsetof(ngx_stream_ssl_srv_conf_t, reject_handshake),
  286.       NULL },

  288.     { ngx_string("ssl_alpn"),
  289.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_1MORE,
  290.       ngx_stream_ssl_alpn,
  291.       NGX_STREAM_SRV_CONF_OFFSET,
  292.       0,
  293.       NULL },

  295.       ngx_null_command
  296. };


  299. ‌static ngx_stream_module_t  ngx_stream_ssl_module_ctx = {
  300.     ngx_stream_ssl_add_variables,          /* preconfiguration */
  301.     ngx_stream_ssl_init,                   /* postconfiguration */

  303.     NULL,                                  /* create main configuration */
  304.     NULL,                                  /* init main configuration */

  306.     ngx_stream_ssl_create_srv_conf,        /* create server configuration */
  307.     ngx_stream_ssl_merge_srv_conf          /* merge server configuration */
  308. };


  311. ‌ngx_module_t  ngx_stream_ssl_module = {
  312.     NGX_MODULE_V1,
  313.     &ngx_stream_ssl_module_ctx,            /* module context */
  314.     ngx_stream_ssl_commands,               /* module directives */
  315.     NGX_STREAM_MODULE,                     /* module type */
  316.     NULL,                                  /* init master */
  317.     NULL,                                  /* init module */
  318.     NULL,                                  /* init process */
  319.     NULL,                                  /* init thread */
  320.     NULL,                                  /* exit thread */
  321.     NULL,                                  /* exit process */
  322.     NULL,                                  /* exit master */
  323.     NGX_MODULE_V1_PADDING
  324. };


  327. ‌static ngx_stream_variable_t  ngx_stream_ssl_vars[] = {

  329.     { ngx_string("ssl_protocol"), NULL, ngx_stream_ssl_static_variable,
  330.       (uintptr_t) ngx_ssl_get_protocol, NGX_STREAM_VAR_CHANGEABLE, 0 },

  332.     { ngx_string("ssl_cipher"), NULL, ngx_stream_ssl_static_variable,
  333.       (uintptr_t) ngx_ssl_get_cipher_name, NGX_STREAM_VAR_CHANGEABLE, 0 },

  335.     { ngx_string("ssl_ciphers"), NULL, ngx_stream_ssl_variable,
  336.       (uintptr_t) ngx_ssl_get_ciphers, NGX_STREAM_VAR_CHANGEABLE, 0 },

  338.     { ngx_string("ssl_curve"), NULL, ngx_stream_ssl_variable,
  339.       (uintptr_t) ngx_ssl_get_curve, NGX_STREAM_VAR_CHANGEABLE, 0 },

  341.     { ngx_string("ssl_curves"), NULL, ngx_stream_ssl_variable,
  342.       (uintptr_t) ngx_ssl_get_curves, NGX_STREAM_VAR_CHANGEABLE, 0 },

  344.     { ngx_string("ssl_session_id"), NULL, ngx_stream_ssl_variable,
  345.       (uintptr_t) ngx_ssl_get_session_id, NGX_STREAM_VAR_CHANGEABLE, 0 },

  347.     { ngx_string("ssl_session_reused"), NULL, ngx_stream_ssl_variable,
  348.       (uintptr_t) ngx_ssl_get_session_reused, NGX_STREAM_VAR_CHANGEABLE, 0 },

  350.     { ngx_string("ssl_server_name"), NULL, ngx_stream_ssl_variable,
  351.       (uintptr_t) ngx_ssl_get_server_name, NGX_STREAM_VAR_CHANGEABLE, 0 },

  353.     { ngx_string("ssl_alpn_protocol"), NULL, ngx_stream_ssl_variable,
  354.       (uintptr_t) ngx_ssl_get_alpn_protocol, NGX_STREAM_VAR_CHANGEABLE, 0 },

  356.     { ngx_string("ssl_client_cert"), NULL, ngx_stream_ssl_variable,
  357.       (uintptr_t) ngx_ssl_get_certificate, NGX_STREAM_VAR_CHANGEABLE, 0 },

  359.     { ngx_string("ssl_client_raw_cert"), NULL, ngx_stream_ssl_variable,
  360.       (uintptr_t) ngx_ssl_get_raw_certificate,
  361.       NGX_STREAM_VAR_CHANGEABLE, 0 },

  363.     { ngx_string("ssl_client_escaped_cert"), NULL, ngx_stream_ssl_variable,
  364.       (uintptr_t) ngx_ssl_get_escaped_certificate,
  365.       NGX_STREAM_VAR_CHANGEABLE, 0 },

  367.     { ngx_string("ssl_client_s_dn"), NULL, ngx_stream_ssl_variable,
  368.       (uintptr_t) ngx_ssl_get_subject_dn, NGX_STREAM_VAR_CHANGEABLE, 0 },

  370.     { ngx_string("ssl_client_i_dn"), NULL, ngx_stream_ssl_variable,
  371.       (uintptr_t) ngx_ssl_get_issuer_dn, NGX_STREAM_VAR_CHANGEABLE, 0 },

  373.     { ngx_string("ssl_client_serial"), NULL, ngx_stream_ssl_variable,
  374.       (uintptr_t) ngx_ssl_get_serial_number, NGX_STREAM_VAR_CHANGEABLE, 0 },

  376.     { ngx_string("ssl_client_fingerprint"), NULL, ngx_stream_ssl_variable,
  377.       (uintptr_t) ngx_ssl_get_fingerprint, NGX_STREAM_VAR_CHANGEABLE, 0 },

  379.     { ngx_string("ssl_client_verify"), NULL, ngx_stream_ssl_variable,
  380.       (uintptr_t) ngx_ssl_get_client_verify, NGX_STREAM_VAR_CHANGEABLE, 0 },

  382.     { ngx_string("ssl_client_v_start"), NULL, ngx_stream_ssl_variable,
  383.       (uintptr_t) ngx_ssl_get_client_v_start, NGX_STREAM_VAR_CHANGEABLE, 0 },

  385.     { ngx_string("ssl_client_v_end"), NULL, ngx_stream_ssl_variable,
  386.       (uintptr_t) ngx_ssl_get_client_v_end, NGX_STREAM_VAR_CHANGEABLE, 0 },

  388.     { ngx_string("ssl_client_v_remain"), NULL, ngx_stream_ssl_variable,
  389.       (uintptr_t) ngx_ssl_get_client_v_remain, NGX_STREAM_VAR_CHANGEABLE, 0 },

  391.       ngx_stream_null_variable
  392. };


  395. ‌static ngx_str_t ngx_stream_ssl_sess_id_ctx = ngx_string("STREAM");


  398. static ngx_int_t
  399. ‌ngx_stream_ssl_handler(ngx_stream_session_t *s)
  400. {
  401.     long                        rc;
  402.     X509                       *cert;
  403.     ngx_int_t                   rv;
  404.     ngx_connection_t           *c;
  405.     ngx_stream_ssl_srv_conf_t  *sscf;

  407.     if (!s->ssl) {
  408.         return NGX_OK;
  409.     }

  411.     c = s->connection;

  413.     sscf = ngx_stream_get_module_srv_conf(s, ngx_stream_ssl_module);

  415.     if (c->ssl == NULL) {
  416.         c->log->action = "SSL handshaking";

  418.         rv = ngx_stream_ssl_init_connection(&sscf->ssl, c);

  420.         if (rv != NGX_OK) {
  421.             return rv;
  422.         }
  423.     }

  425.     if (sscf->verify) {
  426.         rc = SSL_get_verify_result(c->ssl->connection);

  428.         if (rc != X509_V_OK
  429.             && (sscf->verify != 3 || !ngx_ssl_verify_error_optional(rc)))
  430.         {
  431.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  432.                           "client SSL certificate verify error: (%l:%s)",
  433.                           rc, X509_verify_cert_error_string(rc));

  435.             ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  436.                                        (SSL_get0_session(c->ssl->connection)));
  437.             return NGX_ERROR;
  438.         }

  440.         if (sscf->verify == 1) {
  441.             cert = SSL_get_peer_certificate(c->ssl->connection);

  443.             if (cert == NULL) {
  444.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  445.                               "client sent no required SSL certificate");

  447.                 ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  448.                                        (SSL_get0_session(c->ssl->connection)));
  449.                 return NGX_ERROR;
  450.             }

  452.             X509_free(cert);
  453.         }
  454.     }

  456.     return NGX_OK;
  457. }


  460. static ngx_int_t
  461. ‌ngx_stream_ssl_init_connection(ngx_ssl_t *ssl, ngx_connection_t *c)
  462. {
  463.     ngx_int_t                    rc;
  464.     ngx_stream_session_t        *s;
  465.     ngx_stream_ssl_srv_conf_t   *sscf;
  466.     ngx_stream_core_srv_conf_t  *cscf;

  468.     s = c->data;

  470.     cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);

  472.     if (cscf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  473.         return NGX_ERROR;
  474.     }

  476.     if (ngx_ssl_create_connection(ssl, c, 0) != NGX_OK) {
  477.         return NGX_ERROR;
  478.     }

  480.     rc = ngx_ssl_handshake(c);

  482.     if (rc == NGX_ERROR) {
  483.         return NGX_ERROR;
  484.     }

  486.     if (rc == NGX_AGAIN) {
  487.         sscf = ngx_stream_get_module_srv_conf(s, ngx_stream_ssl_module);

  489.         ngx_add_timer(c->read, sscf->handshake_timeout);

  491.         c->ssl->handler = ngx_stream_ssl_handshake_handler;

  493.         return NGX_AGAIN;
  494.     }

  496.     /* rc == NGX_OK */

  498.     return NGX_OK;
  499. }


  502. static void
  503. ‌ngx_stream_ssl_handshake_handler(ngx_connection_t *c)
  504. {
  505.     ngx_stream_session_t  *s;

  507.     s = c->data;

  509.     if (!c->ssl->handshaked) {
  510.         ngx_stream_finalize_session(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  511.         return;
  512.     }

  514.     if (c->read->timer_set) {
  515.         ngx_del_timer(c->read);
  516.     }

  518.     ngx_stream_core_run_phases(s);
  519. }


  522. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

  524. static int
  525. ‌ngx_stream_ssl_servername(ngx_ssl_conn_t *ssl_conn, int *ad, void *arg)
  526. {
  527.     ngx_int_t                    rc;
  528.     ngx_str_t                    host;
  529.     const char                  *servername;
  530.     ngx_connection_t            *c;
  531.     ngx_stream_session_t        *s;
  532.     ngx_stream_ssl_srv_conf_t   *sscf;
  533.     ngx_stream_core_srv_conf_t  *cscf;

  535.     c = ngx_ssl_get_connection(ssl_conn);

  537.     if (c->ssl->handshaked) {
  538.         *ad = SSL_AD_NO_RENEGOTIATION;
  539.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  540.     }

  542.     s = c->data;

  544.     servername = SSL_get_servername(ssl_conn, TLSEXT_NAMETYPE_host_name);

  546.     if (servername == NULL) {
  547.         ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,
  548.                        "SSL server name: null");
  549.         goto done;
  550.     }

  552.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
  553.                    "SSL server name: \"%s\"", servername);

  555.     host.len = ngx_strlen(servername);

  557.     if (host.len == 0) {
  558.         goto done;
  559.     }

  561.     host.data = (u_char *) servername;

  563.     rc = ngx_stream_validate_host(&host, c->pool, 1);

  565.     if (rc == NGX_ERROR) {
  566.         goto error;
  567.     }

  569.     if (rc == NGX_DECLINED) {
  570.         goto done;
  571.     }

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

  575.     if (rc == NGX_ERROR) {
  576.         goto error;
  577.     }

  579.     if (rc == NGX_DECLINED) {
  580.         goto done;
  581.     }

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

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

  587.     sscf = ngx_stream_get_module_srv_conf(s, ngx_stream_ssl_module);

  589.     if (sscf->ssl.ctx) {
  590.         if (SSL_set_SSL_CTX(ssl_conn, sscf->ssl.ctx) == NULL) {
  591.             goto error;
  592.         }

  594.         /*
  595.          * SSL_set_SSL_CTX() only changes certs as of 1.0.0d
  596.          * adjust other things we care about
  597.          */

  599.         SSL_set_verify(ssl_conn, SSL_CTX_get_verify_mode(sscf->ssl.ctx),
  600.                        SSL_CTX_get_verify_callback(sscf->ssl.ctx));

  602.         SSL_set_verify_depth(ssl_conn, SSL_CTX_get_verify_depth(sscf->ssl.ctx));

  604. #if OPENSSL_VERSION_NUMBER >= 0x009080dfL
  605.         /* only in 0.9.8m+ */
  606.         SSL_clear_options(ssl_conn, SSL_get_options(ssl_conn) &
  607.                                     ~SSL_CTX_get_options(sscf->ssl.ctx));
  608. #endif

  610.         SSL_set_options(ssl_conn, SSL_CTX_get_options(sscf->ssl.ctx));

  612. #ifdef SSL_OP_NO_RENEGOTIATION
  613.         SSL_set_options(ssl_conn, SSL_OP_NO_RENEGOTIATION);
  614. #endif
  615.     }

  617. done:

  619.     sscf = ngx_stream_get_module_srv_conf(s, ngx_stream_ssl_module);

  621.     if (sscf->reject_handshake) {
  622.         c->ssl->handshake_rejected = 1;
  623.         *ad = SSL_AD_UNRECOGNIZED_NAME;
  624.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  625.     }

  627.     return SSL_TLSEXT_ERR_OK;

  629. error:

  631.     *ad = SSL_AD_INTERNAL_ERROR;
  632.     return SSL_TLSEXT_ERR_ALERT_FATAL;
  633. }

  635. #endif


  638. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  640. static int
  641. ‌ngx_stream_ssl_alpn_select(ngx_ssl_conn_t *ssl_conn, const unsigned char **out,
  642.     unsigned char *outlen, const unsigned char *in, unsigned int inlen,
  643.     void *arg)
  644. {
  645.     ngx_str_t         *alpn;
  646. #if (NGX_DEBUG)
  647.     unsigned int       i;
  648.     ngx_connection_t  *c;

  650.     c = ngx_ssl_get_connection(ssl_conn);

  652.     for (i = 0; i < inlen; i += in[i] + 1) {
  653.         ngx_log_debug2(NGX_LOG_DEBUG_STREAM, c->log, 0,
  654.                        "SSL ALPN supported by client: %*s",
  655.                        (size_t) in[i], &in[i + 1]);
  656.     }

  658. #endif

  660.     alpn = arg;

  662.     if (SSL_select_next_proto((unsigned char **) out, outlen, alpn->data,
  663.                               alpn->len, in, inlen)
  664.         != OPENSSL_NPN_NEGOTIATED)
  665.     {
  666.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  667.     }

  669.     ngx_log_debug2(NGX_LOG_DEBUG_STREAM, c->log, 0,
  670.                    "SSL ALPN selected: %*s", (size_t) *outlen, *out);

  672.     return SSL_TLSEXT_ERR_OK;
  673. }

  675. #endif


  678. #ifdef SSL_R_CERT_CB_ERROR

  680. static int
  681. ‌ngx_stream_ssl_certificate(ngx_ssl_conn_t *ssl_conn, void *arg)
  682. {
  683.     ngx_str_t                    cert, key;
  684.     ngx_uint_t                   i, nelts;
  685.     ngx_connection_t            *c;
  686.     ngx_stream_session_t        *s;
  687.     ngx_stream_ssl_srv_conf_t   *sscf;
  688.     ngx_stream_complex_value_t  *certs, *keys;

  690.     c = ngx_ssl_get_connection(ssl_conn);

  692.     if (c->ssl->handshaked) {
  693.         return 0;
  694.     }

  696.     s = c->data;

  698.     sscf = arg;

  700.     nelts = sscf->certificate_values->nelts;
  701.     certs = sscf->certificate_values->elts;
  702.     keys = sscf->certificate_key_values->elts;

  704.     for (i = 0; i < nelts; i++) {

  706.         if (ngx_stream_complex_value(s, &certs[i], &cert) != NGX_OK) {
  707.             return 0;
  708.         }

  710.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
  711.                        "ssl cert: \"%s\"", cert.data);

  713.         if (ngx_stream_complex_value(s, &keys[i], &key) != NGX_OK) {
  714.             return 0;
  715.         }

  717.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
  718.                        "ssl key: \"%s\"", key.data);

  720.         if (ngx_ssl_connection_certificate(c, c->pool, &cert, &key,
  721.                                            sscf->passwords)
  722.             != NGX_OK)
  723.         {
  724.             return 0;
  725.         }
  726.     }

  728.     return 1;
  729. }

  731. #endif


  734. static ngx_int_t
  735. ‌ngx_stream_ssl_static_variable(ngx_stream_session_t *s,
  736.     ngx_stream_variable_value_t *v, uintptr_t data)
  737. {
  738.     ngx_ssl_variable_handler_pt  handler = (ngx_ssl_variable_handler_pt) data;

  740.     size_t     len;
  741.     ngx_str_t  str;

  743.     if (s->connection->ssl) {

  745.         (void) handler(s->connection, NULL, &str);

  747.         v->data = str.data;

  749.         for (len = 0; v->data[len]; len++) { /* void */ }

  751.         v->len = len;
  752.         v->valid = 1;
  753.         v->no_cacheable = 0;
  754.         v->not_found = 0;

  756.         return NGX_OK;
  757.     }

  759.     v->not_found = 1;

  761.     return NGX_OK;
  762. }


  765. static ngx_int_t
  766. ‌ngx_stream_ssl_variable(ngx_stream_session_t *s,
  767.     ngx_stream_variable_value_t *v, uintptr_t data)
  768. {
  769.     ngx_ssl_variable_handler_pt  handler = (ngx_ssl_variable_handler_pt) data;

  771.     ngx_str_t  str;

  773.     if (s->connection->ssl) {

  775.         if (handler(s->connection, s->connection->pool, &str) != NGX_OK) {
  776.             return NGX_ERROR;
  777.         }

  779.         v->len = str.len;
  780.         v->data = str.data;

  782.         if (v->len) {
  783.             v->valid = 1;
  784.             v->no_cacheable = 0;
  785.             v->not_found = 0;

  787.             return NGX_OK;
  788.         }
  789.     }

  791.     v->not_found = 1;

  793.     return NGX_OK;
  794. }


  797. static ngx_int_t
  798. ‌ngx_stream_ssl_add_variables(ngx_conf_t *cf)
  799. {
  800.     ngx_stream_variable_t  *var, *v;

  802.     for (v = ngx_stream_ssl_vars; v->name.len; v++) {
  803.         var = ngx_stream_add_variable(cf, &v->name, v->flags);
  804.         if (var == NULL) {
  805.             return NGX_ERROR;
  806.         }

  808.         var->get_handler = v->get_handler;
  809.         var->data = v->data;
  810.     }

  812.     return NGX_OK;
  813. }


  816. static void *
  817. ‌ngx_stream_ssl_create_srv_conf(ngx_conf_t *cf)
  818. {
  819.     ngx_stream_ssl_srv_conf_t  *sscf;

  821.     sscf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_ssl_srv_conf_t));
  822.     if (sscf == NULL) {
  823.         return NULL;
  824.     }

  826.     /*
  827.      * set by ngx_pcalloc():
  828.      *
  829.      *     sscf->protocols = 0;
  830.      *     sscf->certificate_values = NULL;
  831.      *     sscf->dhparam = { 0, NULL };
  832.      *     sscf->ecdh_curve = { 0, NULL };
  833.      *     sscf->client_certificate = { 0, NULL };
  834.      *     sscf->trusted_certificate = { 0, NULL };
  835.      *     sscf->crl = { 0, NULL };
  836.      *     sscf->alpn = { 0, NULL };
  837.      *     sscf->ciphers = { 0, NULL };
  838.      *     sscf->shm_zone = NULL;
  839.      *     sscf->ocsp_responder = { 0, NULL };
  840.      *     sscf->stapling_file = { 0, NULL };
  841.      *     sscf->stapling_responder = { 0, NULL };
  842.      */

  844.     sscf->handshake_timeout = NGX_CONF_UNSET_MSEC;
  845.     sscf->certificates = NGX_CONF_UNSET_PTR;
  846.     sscf->certificate_keys = NGX_CONF_UNSET_PTR;
  847.     sscf->passwords = NGX_CONF_UNSET_PTR;
  848.     sscf->conf_commands = NGX_CONF_UNSET_PTR;
  849.     sscf->prefer_server_ciphers = NGX_CONF_UNSET;
  850.     sscf->reject_handshake = NGX_CONF_UNSET;
  851.     sscf->verify = NGX_CONF_UNSET_UINT;
  852.     sscf->verify_depth = NGX_CONF_UNSET_UINT;
  853.     sscf->builtin_session_cache = NGX_CONF_UNSET;
  854.     sscf->session_timeout = NGX_CONF_UNSET;
  855.     sscf->session_tickets = NGX_CONF_UNSET;
  856.     sscf->session_ticket_keys = NGX_CONF_UNSET_PTR;
  857.     sscf->ocsp = NGX_CONF_UNSET_UINT;
  858.     sscf->ocsp_cache_zone = NGX_CONF_UNSET_PTR;
  859.     sscf->stapling = NGX_CONF_UNSET;
  860.     sscf->stapling_verify = NGX_CONF_UNSET;

  862.     return sscf;
  863. }


  866. static char *
  867. ‌ngx_stream_ssl_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  868. {
  869.     ngx_stream_ssl_srv_conf_t *prev = parent;
  870.     ngx_stream_ssl_srv_conf_t *conf = child;

  872.     ngx_pool_cleanup_t  *cln;

  874.     ngx_conf_merge_msec_value(conf->handshake_timeout,
  875.                          prev->handshake_timeout, 60000);

  877.     ngx_conf_merge_value(conf->session_timeout,
  878.                          prev->session_timeout, 300);

  880.     ngx_conf_merge_value(conf->prefer_server_ciphers,
  881.                          prev->prefer_server_ciphers, 0);

  883.     ngx_conf_merge_value(conf->reject_handshake, prev->reject_handshake, 0);

  885.     ngx_conf_merge_bitmask_value(conf->protocols, prev->protocols,
  886.                          (NGX_CONF_BITMASK_SET|NGX_SSL_DEFAULT_PROTOCOLS));

  888.     ngx_conf_merge_uint_value(conf->verify, prev->verify, 0);
  889.     ngx_conf_merge_uint_value(conf->verify_depth, prev->verify_depth, 1);

  891.     ngx_conf_merge_ptr_value(conf->certificates, prev->certificates, NULL);
  892.     ngx_conf_merge_ptr_value(conf->certificate_keys, prev->certificate_keys,
  893.                          NULL);

  895.     ngx_conf_merge_ptr_value(conf->passwords, prev->passwords, NULL);

  897.     ngx_conf_merge_str_value(conf->dhparam, prev->dhparam, "");

  899.     ngx_conf_merge_str_value(conf->client_certificate, prev->client_certificate,
  900.                          "");
  901.     ngx_conf_merge_str_value(conf->trusted_certificate,
  902.                          prev->trusted_certificate, "");
  903.     ngx_conf_merge_str_value(conf->crl, prev->crl, "");
  904.     ngx_conf_merge_str_value(conf->alpn, prev->alpn, "");

  906.     ngx_conf_merge_str_value(conf->ecdh_curve, prev->ecdh_curve,
  907.                          NGX_DEFAULT_ECDH_CURVE);

  909.     ngx_conf_merge_str_value(conf->ciphers, prev->ciphers, NGX_DEFAULT_CIPHERS);

  911.     ngx_conf_merge_ptr_value(conf->conf_commands, prev->conf_commands, NULL);

  913.     ngx_conf_merge_uint_value(conf->ocsp, prev->ocsp, 0);
  914.     ngx_conf_merge_str_value(conf->ocsp_responder, prev->ocsp_responder, "");
  915.     ngx_conf_merge_ptr_value(conf->ocsp_cache_zone,
  916.                          prev->ocsp_cache_zone, NULL);

  918.     ngx_conf_merge_value(conf->stapling, prev->stapling, 0);
  919.     ngx_conf_merge_value(conf->stapling_verify, prev->stapling_verify, 0);
  920.     ngx_conf_merge_str_value(conf->stapling_file, prev->stapling_file, "");
  921.     ngx_conf_merge_str_value(conf->stapling_responder,
  922.                          prev->stapling_responder, "");

  924.     conf->ssl.log = cf->log;

  926.     if (conf->certificates) {

  928.         if (conf->certificate_keys == NULL
  929.             || conf->certificate_keys->nelts < conf->certificates->nelts)
  930.         {
  931.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  932.                           "no \"ssl_certificate_key\" is defined "
  933.                           "for certificate \"%V\"",
  934.                           ((ngx_str_t *) conf->certificates->elts)
  935.                           + conf->certificates->nelts - 1);
  936.             return NGX_CONF_ERROR;
  937.         }

  939.     } else if (!conf->reject_handshake) {
  940.         return NGX_CONF_OK;
  941.     }

  943.     if (ngx_ssl_create(&conf->ssl, conf->protocols, NULL) != NGX_OK) {
  944.         return NGX_CONF_ERROR;
  945.     }

  947.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  948.     if (cln == NULL) {
  949.         ngx_ssl_cleanup_ctx(&conf->ssl);
  950.         return NGX_CONF_ERROR;
  951.     }

  953.     cln->handler = ngx_ssl_cleanup_ctx;
  954.     cln->data = &conf->ssl;

  956. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
  957.     SSL_CTX_set_tlsext_servername_callback(conf->ssl.ctx,
  958.                                            ngx_stream_ssl_servername);
  959. #endif

  961. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
  962.     if (conf->alpn.len) {
  963.         SSL_CTX_set_alpn_select_cb(conf->ssl.ctx, ngx_stream_ssl_alpn_select,
  964.                                    &conf->alpn);
  965.     }
  966. #endif

  968.     if (ngx_ssl_ciphers(cf, &conf->ssl, &conf->ciphers,
  969.                         conf->prefer_server_ciphers)
  970.         != NGX_OK)
  971.     {
  972.         return NGX_CONF_ERROR;
  973.     }

  975.     if (ngx_stream_ssl_compile_certificates(cf, conf) != NGX_OK) {
  976.         return NGX_CONF_ERROR;
  977.     }

  979.     if (conf->certificate_values) {

  981. #ifdef SSL_R_CERT_CB_ERROR

  983.         /* install callback to lookup certificates */

  985.         SSL_CTX_set_cert_cb(conf->ssl.ctx, ngx_stream_ssl_certificate, conf);

  987. #else
  988.         ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  989.                       "variables in "
  990.                       "\"ssl_certificate\" and \"ssl_certificate_key\" "
  991.                       "directives are not supported on this platform");
  992.         return NGX_CONF_ERROR;
  993. #endif

  995.     } else if (conf->certificates) {

  997.         /* configure certificates */

  999.         if (ngx_ssl_certificates(cf, &conf->ssl, conf->certificates,
  1000.                                  conf->certificate_keys, conf->passwords)
  1001.             != NGX_OK)
  1002.         {
  1003.             return NGX_CONF_ERROR;
  1004.         }
  1005.     }

  1007.     if (conf->verify) {

  1009.         if (conf->verify != 3
  1010.             && conf->client_certificate.len == 0
  1011.             && conf->trusted_certificate.len == 0)
  1012.         {
  1013.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1014.                           "no ssl_client_certificate or "
  1015.                           "ssl_trusted_certificate for ssl_verify_client");
  1016.             return NGX_CONF_ERROR;
  1017.         }

  1019.         if (ngx_ssl_client_certificate(cf, &conf->ssl,
  1020.                                        &conf->client_certificate,
  1021.                                        conf->verify_depth)
  1022.             != NGX_OK)
  1023.         {
  1024.             return NGX_CONF_ERROR;
  1025.         }
  1026.     }

  1028.     if (ngx_ssl_trusted_certificate(cf, &conf->ssl,
  1029.                                     &conf->trusted_certificate,
  1030.                                     conf->verify_depth)
  1031.         != NGX_OK)
  1032.     {
  1033.         return NGX_CONF_ERROR;
  1034.     }

  1036.     if (ngx_ssl_crl(cf, &conf->ssl, &conf->crl) != NGX_OK) {
  1037.         return NGX_CONF_ERROR;
  1038.     }

  1040.     if (conf->ocsp) {

  1042.         if (conf->verify == 3) {
  1043.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1044.                           "\"ssl_ocsp\" is incompatible with "
  1045.                           "\"ssl_verify_client optional_no_ca\"");
  1046.             return NGX_CONF_ERROR;
  1047.         }

  1049.         if (ngx_ssl_ocsp(cf, &conf->ssl, &conf->ocsp_responder, conf->ocsp,
  1050.                          conf->ocsp_cache_zone)
  1051.             != NGX_OK)
  1052.         {
  1053.             return NGX_CONF_ERROR;
  1054.         }
  1055.     }

  1057.     if (ngx_ssl_dhparam(cf, &conf->ssl, &conf->dhparam) != NGX_OK) {
  1058.         return NGX_CONF_ERROR;
  1059.     }

  1061.     if (ngx_ssl_ecdh_curve(cf, &conf->ssl, &conf->ecdh_curve) != NGX_OK) {
  1062.         return NGX_CONF_ERROR;
  1063.     }

  1065.     ngx_conf_merge_value(conf->builtin_session_cache,
  1066.                          prev->builtin_session_cache, NGX_SSL_NONE_SCACHE);

  1068.     if (conf->shm_zone == NULL) {
  1069.         conf->shm_zone = prev->shm_zone;
  1070.     }

  1072.     if (ngx_ssl_session_cache(&conf->ssl, &ngx_stream_ssl_sess_id_ctx,
  1073.                               conf->certificates, conf->builtin_session_cache,
  1074.                               conf->shm_zone, conf->session_timeout)
  1075.         != NGX_OK)
  1076.     {
  1077.         return NGX_CONF_ERROR;
  1078.     }

  1080.     ngx_conf_merge_value(conf->session_tickets,
  1081.                          prev->session_tickets, 1);

  1083. #ifdef SSL_OP_NO_TICKET
  1084.     if (!conf->session_tickets) {
  1085.         SSL_CTX_set_options(conf->ssl.ctx, SSL_OP_NO_TICKET);
  1086.     }
  1087. #endif

  1089.     ngx_conf_merge_ptr_value(conf->session_ticket_keys,
  1090.                          prev->session_ticket_keys, NULL);

  1092.     if (ngx_ssl_session_ticket_keys(cf, &conf->ssl, conf->session_ticket_keys)
  1093.         != NGX_OK)
  1094.     {
  1095.         return NGX_CONF_ERROR;
  1096.     }

  1098.     if (conf->stapling) {

  1100.         if (ngx_ssl_stapling(cf, &conf->ssl, &conf->stapling_file,
  1101.                              &conf->stapling_responder, conf->stapling_verify)
  1102.             != NGX_OK)
  1103.         {
  1104.             return NGX_CONF_ERROR;
  1105.         }

  1107.     }

  1109.     if (ngx_ssl_conf_commands(cf, &conf->ssl, conf->conf_commands) != NGX_OK) {
  1110.         return NGX_CONF_ERROR;
  1111.     }

  1113.     return NGX_CONF_OK;
  1114. }


  1117. static ngx_int_t
  1118. ‌ngx_stream_ssl_compile_certificates(ngx_conf_t *cf,
  1119.     ngx_stream_ssl_srv_conf_t *conf)
  1120. {
  1121.     ngx_str_t                           *cert, *key;
  1122.     ngx_uint_t                           i, nelts;
  1123.     ngx_stream_complex_value_t          *cv;
  1124.     ngx_stream_compile_complex_value_t   ccv;

  1126.     if (conf->certificates == NULL) {
  1127.         return NGX_OK;
  1128.     }

  1130.     cert = conf->certificates->elts;
  1131.     key = conf->certificate_keys->elts;
  1132.     nelts = conf->certificates->nelts;

  1134.     for (i = 0; i < nelts; i++) {

  1136.         if (ngx_stream_script_variables_count(&cert[i])) {
  1137.             goto found;
  1138.         }

  1140.         if (ngx_stream_script_variables_count(&key[i])) {
  1141.             goto found;
  1142.         }
  1143.     }

  1145.     return NGX_OK;

  1147. found:

  1149.     conf->certificate_values = ngx_array_create(cf->pool, nelts,
  1150.                                            sizeof(ngx_stream_complex_value_t));
  1151.     if (conf->certificate_values == NULL) {
  1152.         return NGX_ERROR;
  1153.     }

  1155.     conf->certificate_key_values = ngx_array_create(cf->pool, nelts,
  1156.                                            sizeof(ngx_stream_complex_value_t));
  1157.     if (conf->certificate_key_values == NULL) {
  1158.         return NGX_ERROR;
  1159.     }

  1161.     for (i = 0; i < nelts; i++) {

  1163.         cv = ngx_array_push(conf->certificate_values);
  1164.         if (cv == NULL) {
  1165.             return NGX_ERROR;
  1166.         }

  1168.         ngx_memzero(&ccv, sizeof(ngx_stream_compile_complex_value_t));

  1170.         ccv.cf = cf;
  1171.         ccv.value = &cert[i];
  1172.         ccv.complex_value = cv;
  1173.         ccv.zero = 1;

  1175.         if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  1176.             return NGX_ERROR;
  1177.         }

  1179.         cv = ngx_array_push(conf->certificate_key_values);
  1180.         if (cv == NULL) {
  1181.             return NGX_ERROR;
  1182.         }

  1184.         ngx_memzero(&ccv, sizeof(ngx_stream_compile_complex_value_t));

  1186.         ccv.cf = cf;
  1187.         ccv.value = &key[i];
  1188.         ccv.complex_value = cv;
  1189.         ccv.zero = 1;

  1191.         if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  1192.             return NGX_ERROR;
  1193.         }
  1194.     }

  1196.     conf->passwords = ngx_ssl_preserve_passwords(cf, conf->passwords);
  1197.     if (conf->passwords == NULL) {
  1198.         return NGX_ERROR;
  1199.     }

  1201.     return NGX_OK;
  1202. }


  1205. static char *
  1206. ‌ngx_stream_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1207. {
  1208.     ngx_stream_ssl_srv_conf_t  *sscf = conf;

  1210.     ngx_str_t  *value;

  1212.     if (sscf->passwords != NGX_CONF_UNSET_PTR) {
  1213.         return "is duplicate";
  1214.     }

  1216.     value = cf->args->elts;

  1218.     sscf->passwords = ngx_ssl_read_password_file(cf, &value[1]);

  1220.     if (sscf->passwords == NULL) {
  1221.         return NGX_CONF_ERROR;
  1222.     }

  1224.     return NGX_CONF_OK;
  1225. }


  1228. static char *
  1229. ‌ngx_stream_ssl_session_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1230. {
  1231.     ngx_stream_ssl_srv_conf_t  *sscf = conf;

  1233.     size_t       len;
  1234.     ngx_str_t   *value, name, size;
  1235.     ngx_int_t    n;
  1236.     ngx_uint_t   i, j;

  1238.     value = cf->args->elts;

  1240.     for (i = 1; i < cf->args->nelts; i++) {

  1242.         if (ngx_strcmp(value[i].data, "off") == 0) {
  1243.             sscf->builtin_session_cache = NGX_SSL_NO_SCACHE;
  1244.             continue;
  1245.         }

  1247.         if (ngx_strcmp(value[i].data, "none") == 0) {
  1248.             sscf->builtin_session_cache = NGX_SSL_NONE_SCACHE;
  1249.             continue;
  1250.         }

  1252.         if (ngx_strcmp(value[i].data, "builtin") == 0) {
  1253.             sscf->builtin_session_cache = NGX_SSL_DFLT_BUILTIN_SCACHE;
  1254.             continue;
  1255.         }

  1257.         if (value[i].len > sizeof("builtin:") - 1
  1258.             && ngx_strncmp(value[i].data, "builtin:", sizeof("builtin:") - 1)
  1259.                == 0)
  1260.         {
  1261.             n = ngx_atoi(value[i].data + sizeof("builtin:") - 1,
  1262.                          value[i].len - (sizeof("builtin:") - 1));

  1264.             if (n == NGX_ERROR) {
  1265.                 goto invalid;
  1266.             }

  1268.             sscf->builtin_session_cache = n;

  1270.             continue;
  1271.         }

  1273.         if (value[i].len > sizeof("shared:") - 1
  1274.             && ngx_strncmp(value[i].data, "shared:", sizeof("shared:") - 1)
  1275.                == 0)
  1276.         {
  1277.             len = 0;

  1279.             for (j = sizeof("shared:") - 1; j < value[i].len; j++) {
  1280.                 if (value[i].data[j] == ':') {
  1281.                     break;
  1282.                 }

  1284.                 len++;
  1285.             }

  1287.             if (len == 0 || j == value[i].len) {
  1288.                 goto invalid;
  1289.             }

  1291.             name.len = len;
  1292.             name.data = value[i].data + sizeof("shared:") - 1;

  1294.             size.len = value[i].len - j - 1;
  1295.             size.data = name.data + len + 1;

  1297.             n = ngx_parse_size(&size);

  1299.             if (n == NGX_ERROR) {
  1300.                 goto invalid;
  1301.             }

  1303.             if (n < (ngx_int_t) (8 * ngx_pagesize)) {
  1304.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1305.                                    "session cache \"%V\" is too small",
  1306.                                    &value[i]);

  1308.                 return NGX_CONF_ERROR;
  1309.             }

  1311.             sscf->shm_zone = ngx_shared_memory_add(cf, &name, n,
  1312.                                                    &ngx_stream_ssl_module);
  1313.             if (sscf->shm_zone == NULL) {
  1314.                 return NGX_CONF_ERROR;
  1315.             }

  1317.             sscf->shm_zone->init = ngx_ssl_session_cache_init;

  1319.             continue;
  1320.         }

  1322.         goto invalid;
  1323.     }

  1325.     if (sscf->shm_zone && sscf->builtin_session_cache == NGX_CONF_UNSET) {
  1326.         sscf->builtin_session_cache = NGX_SSL_NO_BUILTIN_SCACHE;
  1327.     }

  1329.     return NGX_CONF_OK;

  1331. invalid:

  1333.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1334.                        "invalid session cache \"%V\"", &value[i]);

  1336.     return NGX_CONF_ERROR;
  1337. }


  1340. static char *
  1341. ‌ngx_stream_ssl_ocsp_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1342. {
  1343.     ngx_stream_ssl_srv_conf_t *sscf = conf;

  1345.     size_t       len;
  1346.     ngx_int_t    n;
  1347.     ngx_str_t   *value, name, size;
  1348.     ngx_uint_t   j;

  1350.     if (sscf->ocsp_cache_zone != NGX_CONF_UNSET_PTR) {
  1351.         return "is duplicate";
  1352.     }

  1354.     value = cf->args->elts;

  1356.     if (ngx_strcmp(value[1].data, "off") == 0) {
  1357.         sscf->ocsp_cache_zone = NULL;
  1358.         return NGX_CONF_OK;
  1359.     }

  1361.     if (value[1].len <= sizeof("shared:") - 1
  1362.         || ngx_strncmp(value[1].data, "shared:", sizeof("shared:") - 1) != 0)
  1363.     {
  1364.         goto invalid;
  1365.     }

  1367.     len = 0;

  1369.     for (j = sizeof("shared:") - 1; j < value[1].len; j++) {
  1370.         if (value[1].data[j] == ':') {
  1371.             break;
  1372.         }

  1374.         len++;
  1375.     }

  1377.     if (len == 0 || j == value[1].len) {
  1378.         goto invalid;
  1379.     }

  1381.     name.len = len;
  1382.     name.data = value[1].data + sizeof("shared:") - 1;

  1384.     size.len = value[1].len - j - 1;
  1385.     size.data = name.data + len + 1;

  1387.     n = ngx_parse_size(&size);

  1389.     if (n == NGX_ERROR) {
  1390.         goto invalid;
  1391.     }

  1393.     if (n < (ngx_int_t) (8 * ngx_pagesize)) {
  1394.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1395.                            "OCSP cache \"%V\" is too small", &value[1]);

  1397.         return NGX_CONF_ERROR;
  1398.     }

  1400.     sscf->ocsp_cache_zone = ngx_shared_memory_add(cf, &name, n,
  1401.                                                   &ngx_stream_ssl_module_ctx);
  1402.     if (sscf->ocsp_cache_zone == NULL) {
  1403.         return NGX_CONF_ERROR;
  1404.     }

  1406.     sscf->ocsp_cache_zone->init = ngx_ssl_ocsp_cache_init;

  1408.     return NGX_CONF_OK;

  1410. invalid:

  1412.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1413.                        "invalid OCSP cache \"%V\"", &value[1]);

  1415.     return NGX_CONF_ERROR;
  1416. }


  1419. static char *
  1420. ‌ngx_stream_ssl_alpn(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1421. {
  1422. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  1424.     ngx_stream_ssl_srv_conf_t  *sscf = conf;

  1426.     u_char      *p;
  1427.     size_t       len;
  1428.     ngx_str_t   *value;
  1429.     ngx_uint_t   i;

  1431.     if (sscf->alpn.len) {
  1432.         return "is duplicate";
  1433.     }

  1435.     value = cf->args->elts;

  1437.     len = 0;

  1439.     for (i = 1; i < cf->args->nelts; i++) {

  1441.         if (value[i].len > 255) {
  1442.             return "protocol too long";
  1443.         }

  1445.         len += value[i].len + 1;
  1446.     }

  1448.     sscf->alpn.data = ngx_pnalloc(cf->pool, len);
  1449.     if (sscf->alpn.data == NULL) {
  1450.         return NGX_CONF_ERROR;
  1451.     }

  1453.     p = sscf->alpn.data;

  1455.     for (i = 1; i < cf->args->nelts; i++) {
  1456.         *p++ = value[i].len;
  1457.         p = ngx_cpymem(p, value[i].data, value[i].len);
  1458.     }

  1460.     sscf->alpn.len = len;

  1462.     return NGX_CONF_OK;

  1464. #else
  1465.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1466.                        "the \"ssl_alpn\" directive requires OpenSSL "
  1467.                        "with ALPN support");
  1468.     return NGX_CONF_ERROR;
  1469. #endif
  1470. }


  1473. static char *
  1474. ‌ngx_stream_ssl_conf_command_check(ngx_conf_t *cf, void *post, void *data)
  1475. {
  1476. #ifndef SSL_CONF_FLAG_FILE
  1477.     return "is not supported on this platform";
  1478. #else
  1479.     return NGX_CONF_OK;
  1480. #endif
  1481. }


  1484. static ngx_int_t
  1485. ‌ngx_stream_ssl_init(ngx_conf_t *cf)
  1486. {
  1487.     ngx_uint_t                     a, p, s;
  1488.     ngx_stream_handler_pt         *h;
  1489.     ngx_stream_conf_addr_t        *addr;
  1490.     ngx_stream_conf_port_t        *port;
  1491.     ngx_stream_ssl_srv_conf_t     *sscf;
  1492.     ngx_stream_core_srv_conf_t   **cscfp, *cscf;
  1493.     ngx_stream_core_main_conf_t   *cmcf;

  1495.     cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);
  1496.     cscfp = cmcf->servers.elts;

  1498.     for (s = 0; s < cmcf->servers.nelts; s++) {

  1500.         sscf = cscfp[s]->ctx->srv_conf[ngx_stream_ssl_module.ctx_index];

  1502.         if (sscf->ssl.ctx == NULL) {
  1503.             continue;
  1504.         }

  1506.         cscf = cscfp[s]->ctx->srv_conf[ngx_stream_core_module.ctx_index];

  1508.         if (sscf->stapling) {
  1509.             if (ngx_ssl_stapling_resolver(cf, &sscf->ssl, cscf->resolver,
  1510.                                           cscf->resolver_timeout)
  1511.                 != NGX_OK)
  1512.             {
  1513.                 return NGX_ERROR;
  1514.             }
  1515.         }

  1517.         if (sscf->ocsp) {
  1518.             if (ngx_ssl_ocsp_resolver(cf, &sscf->ssl, cscf->resolver,
  1519.                                       cscf->resolver_timeout)
  1520.                 != NGX_OK)
  1521.             {
  1522.                 return NGX_ERROR;
  1523.             }
  1524.         }
  1525.     }

  1527.     h = ngx_array_push(&cmcf->phases[NGX_STREAM_SSL_PHASE].handlers);
  1528.     if (h == NULL) {
  1529.         return NGX_ERROR;
  1530.     }

  1532.     *h = ngx_stream_ssl_handler;

  1534.     if (cmcf->ports == NULL) {
  1535.         return NGX_OK;
  1536.     }

  1538.     port = cmcf->ports->elts;
  1539.     for (p = 0; p < cmcf->ports->nelts; p++) {

  1541.         addr = port[p].addrs.elts;
  1542.         for (a = 0; a < port[p].addrs.nelts; a++) {

  1544.             if (!addr[a].opt.ssl) {
  1545.                 continue;
  1546.             }

  1548.             cscf = addr[a].default_server;
  1549.             sscf = cscf->ctx->srv_conf[ngx_stream_ssl_module.ctx_index];

  1551.             if (sscf->certificates) {
  1552.                 continue;
  1553.             }

  1555.             if (!sscf->reject_handshake) {
  1556.                 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1557.                               "no \"ssl_certificate\" is defined for "
  1558.                               "the \"listen ... ssl\" directive in %s:%ui",
  1559.                               cscf->file_name, cscf->line);
  1560.                 return NGX_ERROR;
  1561.             }

  1563.             /*
  1564.              * if no certificates are defined in the default server,
  1565.              * check all non-default server blocks
  1566.              */

  1568.             cscfp = addr[a].servers.elts;
  1569.             for (s = 0; s < addr[a].servers.nelts; s++) {

  1571.                 cscf = cscfp[s];
  1572.                 sscf = cscf->ctx->srv_conf[ngx_stream_ssl_module.ctx_index];

  1574.                 if (sscf->certificates || sscf->reject_handshake) {
  1575.                     continue;
  1576.                 }

  1578.                 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1579.                               "no \"ssl_certificate\" is defined for "
  1580.                               "the \"listen ... ssl\" directive in %s:%ui",
  1581.                               cscf->file_name, cscf->line);
  1582.                 return NGX_ERROR;
  1583.             }
  1584.         }
  1585.     }

  1587.     return NGX_OK;
  1588. }

One Level Up Top Level