One Level Up Top Level

src/stream/ngx_stream_ssl_module.c - nginx

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_certificate_cache(ngx_conf_t *cf,
  51.     ngx_command_t *cmd, void *conf);
  52. static char *ngx_stream_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd,
  53.     void *conf);
  54. static char *ngx_stream_ssl_session_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  55.     void *conf);
  56. static char *ngx_stream_ssl_ocsp_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  57.     void *conf);
  58. static char *ngx_stream_ssl_alpn(ngx_conf_t *cf, ngx_command_t *cmd,
  59.     void *conf);

  61. static char *ngx_stream_ssl_conf_command_check(ngx_conf_t *cf, void *post,
  62.     void *data);

  64. static ngx_int_t ngx_stream_ssl_init(ngx_conf_t *cf);


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


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


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


  95. ‌static ngx_conf_post_t  ngx_stream_ssl_conf_command_post =
  96.     { ngx_stream_ssl_conf_command_check };


  99. ‌static ngx_command_t  ngx_stream_ssl_commands[] = {

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

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

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

  122.     { ngx_string("ssl_certificate_cache"),
  123.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE123,
  124.       ngx_stream_ssl_certificate_cache,
  125.       NGX_STREAM_SRV_CONF_OFFSET,
  126.       0,
  127.       NULL },

  129.     { ngx_string("ssl_ech_file"),
  130.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  131.       ngx_conf_set_str_array_slot,
  132.       NGX_STREAM_SRV_CONF_OFFSET,
  133.       offsetof(ngx_stream_ssl_srv_conf_t, ech_files),
  134.       NULL },

  136.     { ngx_string("ssl_password_file"),
  137.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  138.       ngx_stream_ssl_password_file,
  139.       NGX_STREAM_SRV_CONF_OFFSET,
  140.       0,
  141.       NULL },

  143.     { ngx_string("ssl_certificate_compression"),
  144.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  145.       ngx_conf_set_flag_slot,
  146.       NGX_STREAM_SRV_CONF_OFFSET,
  147.       offsetof(ngx_stream_ssl_srv_conf_t, certificate_compression),
  148.       NULL },

  150.     { ngx_string("ssl_dhparam"),
  151.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  152.       ngx_conf_set_str_slot,
  153.       NGX_STREAM_SRV_CONF_OFFSET,
  154.       offsetof(ngx_stream_ssl_srv_conf_t, dhparam),
  155.       NULL },

  157.     { ngx_string("ssl_ecdh_curve"),
  158.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  159.       ngx_conf_set_str_slot,
  160.       NGX_STREAM_SRV_CONF_OFFSET,
  161.       offsetof(ngx_stream_ssl_srv_conf_t, ecdh_curve),
  162.       NULL },

  164.     { ngx_string("ssl_protocols"),
  165.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_1MORE,
  166.       ngx_conf_set_bitmask_slot,
  167.       NGX_STREAM_SRV_CONF_OFFSET,
  168.       offsetof(ngx_stream_ssl_srv_conf_t, protocols),
  169.       &ngx_stream_ssl_protocols },

  171.     { ngx_string("ssl_ciphers"),
  172.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  173.       ngx_conf_set_str_slot,
  174.       NGX_STREAM_SRV_CONF_OFFSET,
  175.       offsetof(ngx_stream_ssl_srv_conf_t, ciphers),
  176.       NULL },

  178.     { ngx_string("ssl_verify_client"),
  179.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  180.       ngx_conf_set_enum_slot,
  181.       NGX_STREAM_SRV_CONF_OFFSET,
  182.       offsetof(ngx_stream_ssl_srv_conf_t, verify),
  183.       &ngx_stream_ssl_verify },

  185.     { ngx_string("ssl_verify_depth"),
  186.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  187.       ngx_conf_set_num_slot,
  188.       NGX_STREAM_SRV_CONF_OFFSET,
  189.       offsetof(ngx_stream_ssl_srv_conf_t, verify_depth),
  190.       NULL },

  192.     { ngx_string("ssl_client_certificate"),
  193.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  194.       ngx_conf_set_str_slot,
  195.       NGX_STREAM_SRV_CONF_OFFSET,
  196.       offsetof(ngx_stream_ssl_srv_conf_t, client_certificate),
  197.       NULL },

  199.     { ngx_string("ssl_trusted_certificate"),
  200.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  201.       ngx_conf_set_str_slot,
  202.       NGX_STREAM_SRV_CONF_OFFSET,
  203.       offsetof(ngx_stream_ssl_srv_conf_t, trusted_certificate),
  204.       NULL },

  206.     { ngx_string("ssl_prefer_server_ciphers"),
  207.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  208.       ngx_conf_set_flag_slot,
  209.       NGX_STREAM_SRV_CONF_OFFSET,
  210.       offsetof(ngx_stream_ssl_srv_conf_t, prefer_server_ciphers),
  211.       NULL },

  213.     { ngx_string("ssl_session_cache"),
  214.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE12,
  215.       ngx_stream_ssl_session_cache,
  216.       NGX_STREAM_SRV_CONF_OFFSET,
  217.       0,
  218.       NULL },

  220.     { ngx_string("ssl_session_tickets"),
  221.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  222.       ngx_conf_set_flag_slot,
  223.       NGX_STREAM_SRV_CONF_OFFSET,
  224.       offsetof(ngx_stream_ssl_srv_conf_t, session_tickets),
  225.       NULL },

  227.     { ngx_string("ssl_session_ticket_key"),
  228.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  229.       ngx_conf_set_str_array_slot,
  230.       NGX_STREAM_SRV_CONF_OFFSET,
  231.       offsetof(ngx_stream_ssl_srv_conf_t, session_ticket_keys),
  232.       NULL },

  234.     { ngx_string("ssl_session_timeout"),
  235.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  236.       ngx_conf_set_sec_slot,
  237.       NGX_STREAM_SRV_CONF_OFFSET,
  238.       offsetof(ngx_stream_ssl_srv_conf_t, session_timeout),
  239.       NULL },

  241.     { ngx_string("ssl_crl"),
  242.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  243.       ngx_conf_set_str_slot,
  244.       NGX_STREAM_SRV_CONF_OFFSET,
  245.       offsetof(ngx_stream_ssl_srv_conf_t, crl),
  246.       NULL },

  248.     { ngx_string("ssl_ocsp"),
  249.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  250.       ngx_conf_set_enum_slot,
  251.       NGX_STREAM_SRV_CONF_OFFSET,
  252.       offsetof(ngx_stream_ssl_srv_conf_t, ocsp),
  253.       &ngx_stream_ssl_ocsp },

  255.     { ngx_string("ssl_ocsp_responder"),
  256.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  257.       ngx_conf_set_str_slot,
  258.       NGX_STREAM_SRV_CONF_OFFSET,
  259.       offsetof(ngx_stream_ssl_srv_conf_t, ocsp_responder),
  260.       NULL },

  262.     { ngx_string("ssl_ocsp_cache"),
  263.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  264.       ngx_stream_ssl_ocsp_cache,
  265.       NGX_STREAM_SRV_CONF_OFFSET,
  266.       0,
  267.       NULL },

  269.     { ngx_string("ssl_stapling"),
  270.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  271.       ngx_conf_set_flag_slot,
  272.       NGX_STREAM_SRV_CONF_OFFSET,
  273.       offsetof(ngx_stream_ssl_srv_conf_t, stapling),
  274.       NULL },

  276.     { ngx_string("ssl_stapling_file"),
  277.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  278.       ngx_conf_set_str_slot,
  279.       NGX_STREAM_SRV_CONF_OFFSET,
  280.       offsetof(ngx_stream_ssl_srv_conf_t, stapling_file),
  281.       NULL },

  283.     { ngx_string("ssl_stapling_responder"),
  284.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  285.       ngx_conf_set_str_slot,
  286.       NGX_STREAM_SRV_CONF_OFFSET,
  287.       offsetof(ngx_stream_ssl_srv_conf_t, stapling_responder),
  288.       NULL },

  290.     { ngx_string("ssl_stapling_verify"),
  291.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  292.       ngx_conf_set_flag_slot,
  293.       NGX_STREAM_SRV_CONF_OFFSET,
  294.       offsetof(ngx_stream_ssl_srv_conf_t, stapling_verify),
  295.       NULL },

  297.     { ngx_string("ssl_conf_command"),
  298.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE2,
  299.       ngx_conf_set_keyval_slot,
  300.       NGX_STREAM_SRV_CONF_OFFSET,
  301.       offsetof(ngx_stream_ssl_srv_conf_t, conf_commands),
  302.       &ngx_stream_ssl_conf_command_post },

  304.     { ngx_string("ssl_reject_handshake"),
  305.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  306.       ngx_conf_set_flag_slot,
  307.       NGX_STREAM_SRV_CONF_OFFSET,
  308.       offsetof(ngx_stream_ssl_srv_conf_t, reject_handshake),
  309.       NULL },

  311.     { ngx_string("ssl_alpn"),
  312.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_1MORE,
  313.       ngx_stream_ssl_alpn,
  314.       NGX_STREAM_SRV_CONF_OFFSET,
  315.       0,
  316.       NULL },

  318.       ngx_null_command
  319. };


  322. ‌static ngx_stream_module_t  ngx_stream_ssl_module_ctx = {
  323.     ngx_stream_ssl_add_variables,          /* preconfiguration */
  324.     ngx_stream_ssl_init,                   /* postconfiguration */

  326.     NULL,                                  /* create main configuration */
  327.     NULL,                                  /* init main configuration */

  329.     ngx_stream_ssl_create_srv_conf,        /* create server configuration */
  330.     ngx_stream_ssl_merge_srv_conf          /* merge server configuration */
  331. };


  334. ‌ngx_module_t  ngx_stream_ssl_module = {
  335.     NGX_MODULE_V1,
  336.     &ngx_stream_ssl_module_ctx,            /* module context */
  337.     ngx_stream_ssl_commands,               /* module directives */
  338.     NGX_STREAM_MODULE,                     /* module type */
  339.     NULL,                                  /* init master */
  340.     NULL,                                  /* init module */
  341.     NULL,                                  /* init process */
  342.     NULL,                                  /* init thread */
  343.     NULL,                                  /* exit thread */
  344.     NULL,                                  /* exit process */
  345.     NULL,                                  /* exit master */
  346.     NGX_MODULE_V1_PADDING
  347. };


  350. ‌static ngx_stream_variable_t  ngx_stream_ssl_vars[] = {

  352.     { ngx_string("ssl_protocol"), NULL, ngx_stream_ssl_static_variable,
  353.       (uintptr_t) ngx_ssl_get_protocol, NGX_STREAM_VAR_CHANGEABLE, 0 },

  355.     { ngx_string("ssl_cipher"), NULL, ngx_stream_ssl_static_variable,
  356.       (uintptr_t) ngx_ssl_get_cipher_name, NGX_STREAM_VAR_CHANGEABLE, 0 },

  358.     { ngx_string("ssl_ciphers"), NULL, ngx_stream_ssl_variable,
  359.       (uintptr_t) ngx_ssl_get_ciphers, NGX_STREAM_VAR_CHANGEABLE, 0 },

  361.     { ngx_string("ssl_curve"), NULL, ngx_stream_ssl_variable,
  362.       (uintptr_t) ngx_ssl_get_curve, NGX_STREAM_VAR_CHANGEABLE, 0 },

  364.     { ngx_string("ssl_curves"), NULL, ngx_stream_ssl_variable,
  365.       (uintptr_t) ngx_ssl_get_curves, NGX_STREAM_VAR_CHANGEABLE, 0 },

  367.     { ngx_string("ssl_sigalg"), NULL, ngx_stream_ssl_variable,
  368.       (uintptr_t) ngx_ssl_get_sigalg, NGX_STREAM_VAR_CHANGEABLE, 0 },

  370.     { ngx_string("ssl_session_id"), NULL, ngx_stream_ssl_variable,
  371.       (uintptr_t) ngx_ssl_get_session_id, NGX_STREAM_VAR_CHANGEABLE, 0 },

  373.     { ngx_string("ssl_session_reused"), NULL, ngx_stream_ssl_variable,
  374.       (uintptr_t) ngx_ssl_get_session_reused, NGX_STREAM_VAR_CHANGEABLE, 0 },

  376.     { ngx_string("ssl_server_name"), NULL, ngx_stream_ssl_variable,
  377.       (uintptr_t) ngx_ssl_get_server_name, NGX_STREAM_VAR_CHANGEABLE, 0 },

  379.     { ngx_string("ssl_alpn_protocol"), NULL, ngx_stream_ssl_variable,
  380.       (uintptr_t) ngx_ssl_get_alpn_protocol, NGX_STREAM_VAR_CHANGEABLE, 0 },

  382.     { ngx_string("ssl_ech_status"), NULL, ngx_stream_ssl_variable,
  383.       (uintptr_t) ngx_ssl_get_ech_status, NGX_STREAM_VAR_CHANGEABLE, 0 },

  385.     { ngx_string("ssl_ech_outer_server_name"), NULL, ngx_stream_ssl_variable,
  386.       (uintptr_t) ngx_ssl_get_ech_outer_server_name,
  387.       NGX_STREAM_VAR_CHANGEABLE, 0 },

  389.     { ngx_string("ssl_client_cert"), NULL, ngx_stream_ssl_variable,
  390.       (uintptr_t) ngx_ssl_get_certificate, NGX_STREAM_VAR_CHANGEABLE, 0 },

  392.     { ngx_string("ssl_client_raw_cert"), NULL, ngx_stream_ssl_variable,
  393.       (uintptr_t) ngx_ssl_get_raw_certificate,
  394.       NGX_STREAM_VAR_CHANGEABLE, 0 },

  396.     { ngx_string("ssl_client_escaped_cert"), NULL, ngx_stream_ssl_variable,
  397.       (uintptr_t) ngx_ssl_get_escaped_certificate,
  398.       NGX_STREAM_VAR_CHANGEABLE, 0 },

  400.     { ngx_string("ssl_client_s_dn"), NULL, ngx_stream_ssl_variable,
  401.       (uintptr_t) ngx_ssl_get_subject_dn, NGX_STREAM_VAR_CHANGEABLE, 0 },

  403.     { ngx_string("ssl_client_i_dn"), NULL, ngx_stream_ssl_variable,
  404.       (uintptr_t) ngx_ssl_get_issuer_dn, NGX_STREAM_VAR_CHANGEABLE, 0 },

  406.     { ngx_string("ssl_client_serial"), NULL, ngx_stream_ssl_variable,
  407.       (uintptr_t) ngx_ssl_get_serial_number, NGX_STREAM_VAR_CHANGEABLE, 0 },

  409.     { ngx_string("ssl_client_fingerprint"), NULL, ngx_stream_ssl_variable,
  410.       (uintptr_t) ngx_ssl_get_fingerprint, NGX_STREAM_VAR_CHANGEABLE, 0 },

  412.     { ngx_string("ssl_client_verify"), NULL, ngx_stream_ssl_variable,
  413.       (uintptr_t) ngx_ssl_get_client_verify, NGX_STREAM_VAR_CHANGEABLE, 0 },

  415.     { ngx_string("ssl_client_v_start"), NULL, ngx_stream_ssl_variable,
  416.       (uintptr_t) ngx_ssl_get_client_v_start, NGX_STREAM_VAR_CHANGEABLE, 0 },

  418.     { ngx_string("ssl_client_v_end"), NULL, ngx_stream_ssl_variable,
  419.       (uintptr_t) ngx_ssl_get_client_v_end, NGX_STREAM_VAR_CHANGEABLE, 0 },

  421.     { ngx_string("ssl_client_v_remain"), NULL, ngx_stream_ssl_variable,
  422.       (uintptr_t) ngx_ssl_get_client_v_remain, NGX_STREAM_VAR_CHANGEABLE, 0 },

  424.     { ngx_string("ssl_client_sigalg"), NULL, ngx_stream_ssl_variable,
  425.       (uintptr_t) ngx_ssl_get_client_sigalg, NGX_STREAM_VAR_CHANGEABLE, 0 },

  427.       ngx_stream_null_variable
  428. };


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


  434. static ngx_int_t
  435. ‌ngx_stream_ssl_handler(ngx_stream_session_t *s)
  436. {
  437.     long                        rc;
  438.     X509                       *cert;
  439.     ngx_int_t                   rv;
  440.     const char                 *str;
  441.     ngx_connection_t           *c;
  442.     ngx_stream_ssl_srv_conf_t  *sscf;

  444.     if (!s->ssl) {
  445.         return NGX_OK;
  446.     }

  448.     c = s->connection;

  450.     sscf = ngx_stream_get_module_srv_conf(s, ngx_stream_ssl_module);

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

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

  457.         if (rv != NGX_OK) {
  458.             return rv;
  459.         }
  460.     }

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

  465.         if (rc != X509_V_OK
  466.             && (sscf->verify != 3 || !ngx_ssl_verify_error_optional(rc)))
  467.         {
  468.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  469.                           "client SSL certificate verify error: (%l:%s)",
  470.                           rc, X509_verify_cert_error_string(rc));

  472.             ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  473.                                        (SSL_get0_session(c->ssl->connection)));
  474.             return NGX_ERROR;
  475.         }

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

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

  484.                 ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  485.                                        (SSL_get0_session(c->ssl->connection)));
  486.                 return NGX_ERROR;
  487.             }

  489.             X509_free(cert);
  490.         }

  492.         if (ngx_ssl_ocsp_get_status(c, &str) != NGX_OK) {
  493.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  494.                           "client SSL certificate verify error: %s", str);

  496.             ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  497.                                        (SSL_get0_session(c->ssl->connection)));
  498.             return NGX_ERROR;
  499.         }
  500.     }

  502.     return NGX_OK;
  503. }


  506. static ngx_int_t
  507. ‌ngx_stream_ssl_init_connection(ngx_ssl_t *ssl, ngx_connection_t *c)
  508. {
  509.     ngx_int_t                    rc;
  510.     ngx_stream_session_t        *s;
  511.     ngx_stream_ssl_srv_conf_t   *sscf;
  512.     ngx_stream_core_srv_conf_t  *cscf;

  514.     s = c->data;

  516.     cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);

  518.     if (cscf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  519.         return NGX_ERROR;
  520.     }

  522.     if (ngx_ssl_create_connection(ssl, c, 0) != NGX_OK) {
  523.         return NGX_ERROR;
  524.     }

  526.     rc = ngx_ssl_handshake(c);

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

  532.     if (rc == NGX_AGAIN) {
  533.         sscf = ngx_stream_get_module_srv_conf(s, ngx_stream_ssl_module);

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

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

  539.         return NGX_AGAIN;
  540.     }

  542.     /* rc == NGX_OK */

  544.     return NGX_OK;
  545. }


  548. static void
  549. ‌ngx_stream_ssl_handshake_handler(ngx_connection_t *c)
  550. {
  551.     ngx_stream_session_t  *s;

  553.     s = c->data;

  555.     if (!c->ssl->handshaked) {
  556.         ngx_stream_finalize_session(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  557.         return;
  558.     }

  560.     if (c->read->timer_set) {
  561.         ngx_del_timer(c->read);
  562.     }

  564.     ngx_stream_core_run_phases(s);
  565. }


  568. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

  570. static int
  571. ‌ngx_stream_ssl_servername(ngx_ssl_conn_t *ssl_conn, int *ad, void *arg)
  572. {
  573.     ngx_int_t                    rc;
  574.     ngx_str_t                    host;
  575.     const char                  *servername;
  576.     ngx_connection_t            *c;
  577.     ngx_stream_session_t        *s;
  578.     ngx_stream_ssl_srv_conf_t   *sscf;
  579.     ngx_stream_core_srv_conf_t  *cscf;

  581.     c = ngx_ssl_get_connection(ssl_conn);

  583.     if (c->ssl->handshaked) {
  584.         *ad = SSL_AD_NO_RENEGOTIATION;
  585.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  586.     }

  588.     if (c->ssl->sni_accepted) {
  589.         return SSL_TLSEXT_ERR_OK;
  590.     }

  592.     if (c->ssl->handshake_rejected) {
  593.         *ad = SSL_AD_UNRECOGNIZED_NAME;
  594.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  595.     }

  597.     s = c->data;

  599.     if (arg) {
  600.         host = *(ngx_str_t *) arg;

  602.         if (host.data == NULL) {
  603.             ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,
  604.                            "SSL server name: null");
  605.             goto done;
  606.         }

  608.     } else {
  609.         servername = SSL_get_servername(ssl_conn, TLSEXT_NAMETYPE_host_name);

  611.         if (servername == NULL) {
  612.             ngx_log_debug0(NGX_LOG_DEBUG_STREAM, c->log, 0,
  613.                            "SSL server name: null");
  614.             goto done;
  615.         }

  617.         host.len = ngx_strlen(servername);
  618.         host.data = (u_char *) servername;
  619.     }

  621.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, c->log, 0,
  622.                    "SSL server name: \"%V\"", &host);

  624.     if (host.len == 0) {
  625.         goto done;
  626.     }

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

  630.     if (rc == NGX_ERROR) {
  631.         goto error;
  632.     }

  634.     if (rc == NGX_DECLINED) {
  635.         goto done;
  636.     }

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

  640.     if (rc == NGX_ERROR) {
  641.         goto error;
  642.     }

  644.     if (rc == NGX_DECLINED) {
  645.         goto done;
  646.     }

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

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

  652.     sscf = ngx_stream_get_module_srv_conf(cscf->ctx, ngx_stream_ssl_module);

  654.     if (sscf->ssl.ctx) {
  655.         if (SSL_set_SSL_CTX(ssl_conn, sscf->ssl.ctx) == NULL) {
  656.             goto error;
  657.         }

  659.         /*
  660.          * SSL_set_SSL_CTX() only changes certs as of 1.0.0d
  661.          * adjust other things we care about
  662.          */

  664.         SSL_set_verify(ssl_conn, SSL_CTX_get_verify_mode(sscf->ssl.ctx),
  665.                        SSL_CTX_get_verify_callback(sscf->ssl.ctx));

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

  669. #if OPENSSL_VERSION_NUMBER >= 0x009080dfL
  670.         /* only in 0.9.8m+ */
  671.         SSL_clear_options(ssl_conn, SSL_get_options(ssl_conn) &
  672.                                     ~SSL_CTX_get_options(sscf->ssl.ctx));
  673. #endif

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

  677. #ifdef SSL_OP_NO_RENEGOTIATION
  678.         SSL_set_options(ssl_conn, SSL_OP_NO_RENEGOTIATION);
  679. #endif
  680.     }

  682. done:

  684.     sscf = ngx_stream_get_module_srv_conf(s, ngx_stream_ssl_module);

  686.     if (sscf->reject_handshake) {
  687.         c->ssl->handshake_rejected = 1;
  688.         *ad = SSL_AD_UNRECOGNIZED_NAME;
  689.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  690.     }

  692.     c->ssl->sni_accepted = 1;
  693.     return SSL_TLSEXT_ERR_OK;

  695. error:

  697.     *ad = SSL_AD_INTERNAL_ERROR;
  698.     return SSL_TLSEXT_ERR_ALERT_FATAL;
  699. }

  701. #endif


  704. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  706. static int
  707. ‌ngx_stream_ssl_alpn_select(ngx_ssl_conn_t *ssl_conn, const unsigned char **out,
  708.     unsigned char *outlen, const unsigned char *in, unsigned int inlen,
  709.     void *arg)
  710. {
  711.     ngx_str_t         *alpn;
  712. #if (NGX_DEBUG)
  713.     unsigned int       i;
  714.     ngx_connection_t  *c;

  716.     c = ngx_ssl_get_connection(ssl_conn);

  718.     for (i = 0; i < inlen; i += in[i] + 1) {
  719.         ngx_log_debug2(NGX_LOG_DEBUG_STREAM, c->log, 0,
  720.                        "SSL ALPN supported by client: %*s",
  721.                        (size_t) in[i], &in[i + 1]);
  722.     }

  724. #endif

  726.     alpn = arg;

  728.     if (SSL_select_next_proto((unsigned char **) out, outlen, alpn->data,
  729.                               alpn->len, in, inlen)
  730.         != OPENSSL_NPN_NEGOTIATED)
  731.     {
  732.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  733.     }

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

  738.     return SSL_TLSEXT_ERR_OK;
  739. }

  741. #endif


  744. #ifdef SSL_R_CERT_CB_ERROR

  746. static int
  747. ‌ngx_stream_ssl_certificate(ngx_ssl_conn_t *ssl_conn, void *arg)
  748. {
  749.     ngx_str_t                    cert, key;
  750.     ngx_uint_t                   i, nelts;
  751.     ngx_connection_t            *c;
  752.     ngx_stream_session_t        *s;
  753.     ngx_stream_ssl_srv_conf_t   *sscf;
  754.     ngx_stream_complex_value_t  *certs, *keys;

  756.     c = ngx_ssl_get_connection(ssl_conn);

  758.     if (c->ssl->handshaked) {
  759.         return 0;
  760.     }

  762.     s = c->data;

  764.     sscf = arg;

  766.     nelts = sscf->certificate_values->nelts;
  767.     certs = sscf->certificate_values->elts;
  768.     keys = sscf->certificate_key_values->elts;

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

  772.         if (ngx_stream_complex_value(s, &certs[i], &cert) != NGX_OK) {
  773.             return 0;
  774.         }

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

  779.         if (ngx_stream_complex_value(s, &keys[i], &key) != NGX_OK) {
  780.             return 0;
  781.         }

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

  786.         if (ngx_ssl_connection_certificate(c, c->pool, &cert, &key,
  787.                                            sscf->certificate_cache,
  788.                                            sscf->passwords)
  789.             != NGX_OK)
  790.         {
  791.             return 0;
  792.         }
  793.     }

  795.     return 1;
  796. }

  798. #endif


  801. static ngx_int_t
  802. ‌ngx_stream_ssl_static_variable(ngx_stream_session_t *s,
  803.     ngx_stream_variable_value_t *v, uintptr_t data)
  804. {
  805.     ngx_ssl_variable_handler_pt  handler = (ngx_ssl_variable_handler_pt) data;

  807.     size_t     len;
  808.     ngx_str_t  str;

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

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

  814.         v->data = str.data;

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

  818.         v->len = len;
  819.         v->valid = 1;
  820.         v->no_cacheable = 0;
  821.         v->not_found = 0;

  823.         return NGX_OK;
  824.     }

  826.     v->not_found = 1;

  828.     return NGX_OK;
  829. }


  832. static ngx_int_t
  833. ‌ngx_stream_ssl_variable(ngx_stream_session_t *s,
  834.     ngx_stream_variable_value_t *v, uintptr_t data)
  835. {
  836.     ngx_ssl_variable_handler_pt  handler = (ngx_ssl_variable_handler_pt) data;

  838.     ngx_str_t  str;

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

  842.         if (handler(s->connection, s->connection->pool, &str) != NGX_OK) {
  843.             return NGX_ERROR;
  844.         }

  846.         v->len = str.len;
  847.         v->data = str.data;

  849.         if (v->len) {
  850.             v->valid = 1;
  851.             v->no_cacheable = 0;
  852.             v->not_found = 0;

  854.             return NGX_OK;
  855.         }
  856.     }

  858.     v->not_found = 1;

  860.     return NGX_OK;
  861. }


  864. static ngx_int_t
  865. ‌ngx_stream_ssl_add_variables(ngx_conf_t *cf)
  866. {
  867.     ngx_stream_variable_t  *var, *v;

  869.     for (v = ngx_stream_ssl_vars; v->name.len; v++) {
  870.         var = ngx_stream_add_variable(cf, &v->name, v->flags);
  871.         if (var == NULL) {
  872.             return NGX_ERROR;
  873.         }

  875.         var->get_handler = v->get_handler;
  876.         var->data = v->data;
  877.     }

  879.     return NGX_OK;
  880. }


  883. static void *
  884. ‌ngx_stream_ssl_create_srv_conf(ngx_conf_t *cf)
  885. {
  886.     ngx_stream_ssl_srv_conf_t  *sscf;

  888.     sscf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_ssl_srv_conf_t));
  889.     if (sscf == NULL) {
  890.         return NULL;
  891.     }

  893.     /*
  894.      * set by ngx_pcalloc():
  895.      *
  896.      *     sscf->protocols = 0;
  897.      *     sscf->certificate_values = NULL;
  898.      *     sscf->dhparam = { 0, NULL };
  899.      *     sscf->ecdh_curve = { 0, NULL };
  900.      *     sscf->client_certificate = { 0, NULL };
  901.      *     sscf->trusted_certificate = { 0, NULL };
  902.      *     sscf->crl = { 0, NULL };
  903.      *     sscf->alpn = { 0, NULL };
  904.      *     sscf->ciphers = { 0, NULL };
  905.      *     sscf->shm_zone = NULL;
  906.      *     sscf->ocsp_responder = { 0, NULL };
  907.      *     sscf->stapling_file = { 0, NULL };
  908.      *     sscf->stapling_responder = { 0, NULL };
  909.      */

  911.     sscf->handshake_timeout = NGX_CONF_UNSET_MSEC;
  912.     sscf->certificates = NGX_CONF_UNSET_PTR;
  913.     sscf->certificate_keys = NGX_CONF_UNSET_PTR;
  914.     sscf->certificate_cache = NGX_CONF_UNSET_PTR;
  915.     sscf->ech_files = NGX_CONF_UNSET_PTR;
  916.     sscf->passwords = NGX_CONF_UNSET_PTR;
  917.     sscf->conf_commands = NGX_CONF_UNSET_PTR;
  918.     sscf->prefer_server_ciphers = NGX_CONF_UNSET;
  919.     sscf->certificate_compression = NGX_CONF_UNSET;
  920.     sscf->reject_handshake = NGX_CONF_UNSET;
  921.     sscf->verify = NGX_CONF_UNSET_UINT;
  922.     sscf->verify_depth = NGX_CONF_UNSET_UINT;
  923.     sscf->builtin_session_cache = NGX_CONF_UNSET;
  924.     sscf->session_timeout = NGX_CONF_UNSET;
  925.     sscf->session_tickets = NGX_CONF_UNSET;
  926.     sscf->session_ticket_keys = NGX_CONF_UNSET_PTR;
  927.     sscf->ocsp = NGX_CONF_UNSET_UINT;
  928.     sscf->ocsp_cache_zone = NGX_CONF_UNSET_PTR;
  929.     sscf->stapling = NGX_CONF_UNSET;
  930.     sscf->stapling_verify = NGX_CONF_UNSET;

  932.     return sscf;
  933. }


  936. static char *
  937. ‌ngx_stream_ssl_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  938. {
  939.     ngx_stream_ssl_srv_conf_t *prev = parent;
  940.     ngx_stream_ssl_srv_conf_t *conf = child;

  942.     ngx_pool_cleanup_t  *cln;

  944.     ngx_conf_merge_msec_value(conf->handshake_timeout,
  945.                          prev->handshake_timeout, 60000);

  947.     ngx_conf_merge_value(conf->session_timeout,
  948.                          prev->session_timeout, 300);

  950.     ngx_conf_merge_value(conf->prefer_server_ciphers,
  951.                          prev->prefer_server_ciphers, 0);

  953.     ngx_conf_merge_value(conf->certificate_compression,
  954.                          prev->certificate_compression, 0);

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

  958.     ngx_conf_merge_bitmask_value(conf->protocols, prev->protocols,
  959.                          (NGX_CONF_BITMASK_SET|NGX_SSL_DEFAULT_PROTOCOLS));

  961.     ngx_conf_merge_uint_value(conf->verify, prev->verify, 0);
  962.     ngx_conf_merge_uint_value(conf->verify_depth, prev->verify_depth, 1);

  964.     ngx_conf_merge_ptr_value(conf->certificates, prev->certificates, NULL);
  965.     ngx_conf_merge_ptr_value(conf->certificate_keys, prev->certificate_keys,
  966.                          NULL);

  968.     ngx_conf_merge_ptr_value(conf->certificate_cache, prev->certificate_cache,
  969.                          NULL);

  971.     ngx_conf_merge_ptr_value(conf->ech_files, prev->ech_files, NULL);

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

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

  977.     ngx_conf_merge_str_value(conf->client_certificate, prev->client_certificate,
  978.                          "");
  979.     ngx_conf_merge_str_value(conf->trusted_certificate,
  980.                          prev->trusted_certificate, "");
  981.     ngx_conf_merge_str_value(conf->crl, prev->crl, "");
  982.     ngx_conf_merge_str_value(conf->alpn, prev->alpn, "");

  984.     ngx_conf_merge_str_value(conf->ecdh_curve, prev->ecdh_curve,
  985.                          NGX_DEFAULT_ECDH_CURVE);

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

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

  991.     ngx_conf_merge_uint_value(conf->ocsp, prev->ocsp, 0);
  992.     ngx_conf_merge_str_value(conf->ocsp_responder, prev->ocsp_responder, "");
  993.     ngx_conf_merge_ptr_value(conf->ocsp_cache_zone,
  994.                          prev->ocsp_cache_zone, NULL);

  996.     ngx_conf_merge_value(conf->stapling, prev->stapling, 0);
  997.     ngx_conf_merge_value(conf->stapling_verify, prev->stapling_verify, 0);
  998.     ngx_conf_merge_str_value(conf->stapling_file, prev->stapling_file, "");
  999.     ngx_conf_merge_str_value(conf->stapling_responder,
  1000.                          prev->stapling_responder, "");

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

  1004.     if (conf->certificates) {

  1006.         if (conf->certificate_keys == NULL
  1007.             || conf->certificate_keys->nelts < conf->certificates->nelts)
  1008.         {
  1009.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1010.                           "no \"ssl_certificate_key\" is defined "
  1011.                           "for certificate \"%V\"",
  1012.                           ((ngx_str_t *) conf->certificates->elts)
  1013.                           + conf->certificates->nelts - 1);
  1014.             return NGX_CONF_ERROR;
  1015.         }

  1017.     } else if (!conf->reject_handshake) {
  1018.         return NGX_CONF_OK;
  1019.     }

  1021.     if (ngx_ssl_create(&conf->ssl, conf->protocols, NULL) != NGX_OK) {
  1022.         return NGX_CONF_ERROR;
  1023.     }

  1025.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  1026.     if (cln == NULL) {
  1027.         ngx_ssl_cleanup_ctx(&conf->ssl);
  1028.         return NGX_CONF_ERROR;
  1029.     }

  1031.     cln->handler = ngx_ssl_cleanup_ctx;
  1032.     cln->data = &conf->ssl;

  1034. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
  1035.     {
  1036.     static ngx_ssl_client_hello_arg cb = { ngx_stream_ssl_servername };

  1038.     if (ngx_ssl_set_client_hello_callback(&conf->ssl, &cb) != NGX_OK) {
  1039.         return NGX_CONF_ERROR;
  1040.     }

  1042.     SSL_CTX_set_tlsext_servername_callback(conf->ssl.ctx,
  1043.                                            ngx_stream_ssl_servername);
  1044.     }
  1045. #endif

  1047. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
  1048.     if (conf->alpn.len) {
  1049.         SSL_CTX_set_alpn_select_cb(conf->ssl.ctx, ngx_stream_ssl_alpn_select,
  1050.                                    &conf->alpn);
  1051.     }
  1052. #endif

  1054.     if (ngx_ssl_ciphers(cf, &conf->ssl, &conf->ciphers,
  1055.                         conf->prefer_server_ciphers)
  1056.         != NGX_OK)
  1057.     {
  1058.         return NGX_CONF_ERROR;
  1059.     }

  1061.     if (ngx_stream_ssl_compile_certificates(cf, conf) != NGX_OK) {
  1062.         return NGX_CONF_ERROR;
  1063.     }

  1065.     if (conf->certificate_values) {

  1067. #ifdef SSL_R_CERT_CB_ERROR

  1069.         /* install callback to lookup certificates */

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

  1073. #else
  1074.         ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1075.                       "variables in "
  1076.                       "\"ssl_certificate\" and \"ssl_certificate_key\" "
  1077.                       "directives are not supported on this platform");
  1078.         return NGX_CONF_ERROR;
  1079. #endif

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

  1083.         /* configure certificates */

  1085.         if (ngx_ssl_certificates(cf, &conf->ssl, conf->certificates,
  1086.                                  conf->certificate_keys, conf->passwords)
  1087.             != NGX_OK)
  1088.         {
  1089.             return NGX_CONF_ERROR;
  1090.         }

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

  1100.     if (conf->verify) {

  1102.         if (conf->verify != 3
  1103.             && conf->client_certificate.len == 0
  1104.             && conf->trusted_certificate.len == 0)
  1105.         {
  1106.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1107.                           "no ssl_client_certificate or "
  1108.                           "ssl_trusted_certificate for ssl_verify_client");
  1109.             return NGX_CONF_ERROR;
  1110.         }

  1112.         if (ngx_ssl_client_certificate(cf, &conf->ssl,
  1113.                                        &conf->client_certificate,
  1114.                                        conf->verify_depth)
  1115.             != NGX_OK)
  1116.         {
  1117.             return NGX_CONF_ERROR;
  1118.         }
  1119.     }

  1121.     if (ngx_ssl_trusted_certificate(cf, &conf->ssl,
  1122.                                     &conf->trusted_certificate,
  1123.                                     conf->verify_depth)
  1124.         != NGX_OK)
  1125.     {
  1126.         return NGX_CONF_ERROR;
  1127.     }

  1129.     if (ngx_ssl_crl(cf, &conf->ssl, &conf->crl) != NGX_OK) {
  1130.         return NGX_CONF_ERROR;
  1131.     }

  1133.     if (conf->ocsp) {

  1135.         if (conf->verify == 3) {
  1136.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1137.                           "\"ssl_ocsp\" is incompatible with "
  1138.                           "\"ssl_verify_client optional_no_ca\"");
  1139.             return NGX_CONF_ERROR;
  1140.         }

  1142.         if (ngx_ssl_ocsp(cf, &conf->ssl, &conf->ocsp_responder, conf->ocsp,
  1143.                          conf->ocsp_cache_zone)
  1144.             != NGX_OK)
  1145.         {
  1146.             return NGX_CONF_ERROR;
  1147.         }
  1148.     }

  1150.     if (ngx_ssl_dhparam(cf, &conf->ssl, &conf->dhparam) != NGX_OK) {
  1151.         return NGX_CONF_ERROR;
  1152.     }

  1154.     if (ngx_ssl_ech_files(cf, &conf->ssl, conf->ech_files) != NGX_OK) {
  1155.         return NGX_CONF_ERROR;
  1156.     }

  1158.     if (ngx_ssl_ecdh_curve(cf, &conf->ssl, &conf->ecdh_curve) != NGX_OK) {
  1159.         return NGX_CONF_ERROR;
  1160.     }

  1162.     ngx_conf_merge_value(conf->builtin_session_cache,
  1163.                          prev->builtin_session_cache, NGX_SSL_NONE_SCACHE);

  1165.     if (conf->shm_zone == NULL) {
  1166.         conf->shm_zone = prev->shm_zone;
  1167.     }

  1169.     if (ngx_ssl_session_cache(&conf->ssl, &ngx_stream_ssl_sess_id_ctx,
  1170.                               conf->certificates, conf->builtin_session_cache,
  1171.                               conf->shm_zone, conf->session_timeout)
  1172.         != NGX_OK)
  1173.     {
  1174.         return NGX_CONF_ERROR;
  1175.     }

  1177.     ngx_conf_merge_value(conf->session_tickets,
  1178.                          prev->session_tickets, 1);

  1180. #ifdef SSL_OP_NO_TICKET
  1181.     if (!conf->session_tickets) {
  1182.         SSL_CTX_set_options(conf->ssl.ctx, SSL_OP_NO_TICKET);
  1183.     }
  1184. #endif

  1186.     ngx_conf_merge_ptr_value(conf->session_ticket_keys,
  1187.                          prev->session_ticket_keys, NULL);

  1189.     if (ngx_ssl_session_ticket_keys(cf, &conf->ssl, conf->session_ticket_keys)
  1190.         != NGX_OK)
  1191.     {
  1192.         return NGX_CONF_ERROR;
  1193.     }

  1195.     if (conf->stapling) {

  1197.         if (conf->certificate_compression) {
  1198.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1199.                           "\"ssl_stapling\" is incompatible with "
  1200.                           "\"ssl_certificate_compression\"");
  1201.             return NGX_CONF_ERROR;
  1202.         }

  1204.         if (ngx_ssl_stapling(cf, &conf->ssl, &conf->stapling_file,
  1205.                              &conf->stapling_responder, conf->stapling_verify)
  1206.             != NGX_OK)
  1207.         {
  1208.             return NGX_CONF_ERROR;
  1209.         }
  1210.     }

  1212.     if (ngx_ssl_conf_commands(cf, &conf->ssl, conf->conf_commands) != NGX_OK) {
  1213.         return NGX_CONF_ERROR;
  1214.     }

  1216.     return NGX_CONF_OK;
  1217. }


  1220. static ngx_int_t
  1221. ‌ngx_stream_ssl_compile_certificates(ngx_conf_t *cf,
  1222.     ngx_stream_ssl_srv_conf_t *conf)
  1223. {
  1224.     ngx_str_t                           *cert, *key;
  1225.     ngx_uint_t                           i, nelts;
  1226.     ngx_stream_complex_value_t          *cv;
  1227.     ngx_stream_compile_complex_value_t   ccv;

  1229.     if (conf->certificates == NULL) {
  1230.         return NGX_OK;
  1231.     }

  1233.     cert = conf->certificates->elts;
  1234.     key = conf->certificate_keys->elts;
  1235.     nelts = conf->certificates->nelts;

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

  1239.         if (ngx_stream_script_variables_count(&cert[i])) {
  1240.             goto found;
  1241.         }

  1243.         if (ngx_stream_script_variables_count(&key[i])) {
  1244.             goto found;
  1245.         }
  1246.     }

  1248.     return NGX_OK;

  1250. found:

  1252.     conf->certificate_values = ngx_array_create(cf->pool, nelts,
  1253.                                            sizeof(ngx_stream_complex_value_t));
  1254.     if (conf->certificate_values == NULL) {
  1255.         return NGX_ERROR;
  1256.     }

  1258.     conf->certificate_key_values = ngx_array_create(cf->pool, nelts,
  1259.                                            sizeof(ngx_stream_complex_value_t));
  1260.     if (conf->certificate_key_values == NULL) {
  1261.         return NGX_ERROR;
  1262.     }

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

  1266.         cv = ngx_array_push(conf->certificate_values);
  1267.         if (cv == NULL) {
  1268.             return NGX_ERROR;
  1269.         }

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

  1273.         ccv.cf = cf;
  1274.         ccv.value = &cert[i];
  1275.         ccv.complex_value = cv;
  1276.         ccv.zero = 1;

  1278.         if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  1279.             return NGX_ERROR;
  1280.         }

  1282.         cv = ngx_array_push(conf->certificate_key_values);
  1283.         if (cv == NULL) {
  1284.             return NGX_ERROR;
  1285.         }

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

  1289.         ccv.cf = cf;
  1290.         ccv.value = &key[i];
  1291.         ccv.complex_value = cv;
  1292.         ccv.zero = 1;

  1294.         if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  1295.             return NGX_ERROR;
  1296.         }
  1297.     }

  1299.     conf->passwords = ngx_ssl_preserve_passwords(cf, conf->passwords);
  1300.     if (conf->passwords == NULL) {
  1301.         return NGX_ERROR;
  1302.     }

  1304.     return NGX_OK;
  1305. }


  1308. static char *
  1309. ‌ngx_stream_ssl_certificate_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1310. {
  1311.     ngx_stream_ssl_srv_conf_t *sscf = conf;

  1313.     time_t       inactive, valid;
  1314.     ngx_str_t   *value, s;
  1315.     ngx_int_t    max;
  1316.     ngx_uint_t   i;

  1318.     if (sscf->certificate_cache != NGX_CONF_UNSET_PTR) {
  1319.         return "is duplicate";
  1320.     }

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

  1324.     max = 0;
  1325.     inactive = 10;
  1326.     valid = 60;

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

  1330.         if (ngx_strncmp(value[i].data, "max=", 4) == 0) {

  1332.             max = ngx_atoi(value[i].data + 4, value[i].len - 4);
  1333.             if (max <= 0) {
  1334.                 goto failed;
  1335.             }

  1337.             continue;
  1338.         }

  1340.         if (ngx_strncmp(value[i].data, "inactive=", 9) == 0) {

  1342.             s.len = value[i].len - 9;
  1343.             s.data = value[i].data + 9;

  1345.             inactive = ngx_parse_time(&s, 1);
  1346.             if (inactive == (time_t) NGX_ERROR) {
  1347.                 goto failed;
  1348.             }

  1350.             continue;
  1351.         }

  1353.         if (ngx_strncmp(value[i].data, "valid=", 6) == 0) {

  1355.             s.len = value[i].len - 6;
  1356.             s.data = value[i].data + 6;

  1358.             valid = ngx_parse_time(&s, 1);
  1359.             if (valid == (time_t) NGX_ERROR) {
  1360.                 goto failed;
  1361.             }

  1363.             continue;
  1364.         }

  1366.         if (ngx_strcmp(value[i].data, "off") == 0) {

  1368.             sscf->certificate_cache = NULL;

  1370.             continue;
  1371.         }

  1373.     failed:

  1375.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1376.                            "invalid parameter \"%V\"", &value[i]);
  1377.         return NGX_CONF_ERROR;
  1378.     }

  1380.     if (sscf->certificate_cache == NULL) {
  1381.         return NGX_CONF_OK;
  1382.     }

  1384.     if (max == 0) {
  1385.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1386.                            "\"ssl_certificate_cache\" must have "
  1387.                            "the \"max\" parameter");
  1388.         return NGX_CONF_ERROR;
  1389.     }

  1391.     sscf->certificate_cache = ngx_ssl_cache_init(cf->pool, max, valid,
  1392.                                                  inactive);
  1393.     if (sscf->certificate_cache == NULL) {
  1394.         return NGX_CONF_ERROR;
  1395.     }

  1397.     return NGX_CONF_OK;
  1398. }


  1401. static char *
  1402. ‌ngx_stream_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1403. {
  1404.     ngx_stream_ssl_srv_conf_t  *sscf = conf;

  1406.     ngx_str_t  *value;

  1408.     if (sscf->passwords != NGX_CONF_UNSET_PTR) {
  1409.         return "is duplicate";
  1410.     }

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

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

  1416.     if (sscf->passwords == NULL) {
  1417.         return NGX_CONF_ERROR;
  1418.     }

  1420.     return NGX_CONF_OK;
  1421. }


  1424. static char *
  1425. ‌ngx_stream_ssl_session_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1426. {
  1427.     ngx_stream_ssl_srv_conf_t  *sscf = conf;

  1429.     size_t       len;
  1430.     ngx_str_t   *value, name, size;
  1431.     ngx_int_t    n;
  1432.     ngx_uint_t   i, j;

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

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

  1438.         if (ngx_strcmp(value[i].data, "off") == 0) {
  1439.             sscf->builtin_session_cache = NGX_SSL_NO_SCACHE;
  1440.             continue;
  1441.         }

  1443.         if (ngx_strcmp(value[i].data, "none") == 0) {
  1444.             sscf->builtin_session_cache = NGX_SSL_NONE_SCACHE;
  1445.             continue;
  1446.         }

  1448.         if (ngx_strcmp(value[i].data, "builtin") == 0) {
  1449.             sscf->builtin_session_cache = NGX_SSL_DFLT_BUILTIN_SCACHE;
  1450.             continue;
  1451.         }

  1453.         if (value[i].len > sizeof("builtin:") - 1
  1454.             && ngx_strncmp(value[i].data, "builtin:", sizeof("builtin:") - 1)
  1455.                == 0)
  1456.         {
  1457.             n = ngx_atoi(value[i].data + sizeof("builtin:") - 1,
  1458.                          value[i].len - (sizeof("builtin:") - 1));

  1460.             if (n == NGX_ERROR) {
  1461.                 goto invalid;
  1462.             }

  1464.             sscf->builtin_session_cache = n;

  1466.             continue;
  1467.         }

  1469.         if (value[i].len > sizeof("shared:") - 1
  1470.             && ngx_strncmp(value[i].data, "shared:", sizeof("shared:") - 1)
  1471.                == 0)
  1472.         {
  1473.             len = 0;

  1475.             for (j = sizeof("shared:") - 1; j < value[i].len; j++) {
  1476.                 if (value[i].data[j] == ':') {
  1477.                     break;
  1478.                 }

  1480.                 len++;
  1481.             }

  1483.             if (len == 0 || j == value[i].len) {
  1484.                 goto invalid;
  1485.             }

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

  1490.             size.len = value[i].len - j - 1;
  1491.             size.data = name.data + len + 1;

  1493.             n = ngx_parse_size(&size);

  1495.             if (n == NGX_ERROR) {
  1496.                 goto invalid;
  1497.             }

  1499.             if (n < (ngx_int_t) (8 * ngx_pagesize)) {
  1500.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1501.                                    "session cache \"%V\" is too small",
  1502.                                    &value[i]);

  1504.                 return NGX_CONF_ERROR;
  1505.             }

  1507.             sscf->shm_zone = ngx_shared_memory_add(cf, &name, n,
  1508.                                                    &ngx_stream_ssl_module);
  1509.             if (sscf->shm_zone == NULL) {
  1510.                 return NGX_CONF_ERROR;
  1511.             }

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

  1515.             continue;
  1516.         }

  1518.         goto invalid;
  1519.     }

  1521.     if (sscf->shm_zone && sscf->builtin_session_cache == NGX_CONF_UNSET) {
  1522.         sscf->builtin_session_cache = NGX_SSL_NO_BUILTIN_SCACHE;
  1523.     }

  1525.     return NGX_CONF_OK;

  1527. invalid:

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

  1532.     return NGX_CONF_ERROR;
  1533. }


  1536. static char *
  1537. ‌ngx_stream_ssl_ocsp_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1538. {
  1539.     ngx_stream_ssl_srv_conf_t *sscf = conf;

  1541.     size_t       len;
  1542.     ngx_int_t    n;
  1543.     ngx_str_t   *value, name, size;
  1544.     ngx_uint_t   j;

  1546.     if (sscf->ocsp_cache_zone != NGX_CONF_UNSET_PTR) {
  1547.         return "is duplicate";
  1548.     }

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

  1552.     if (ngx_strcmp(value[1].data, "off") == 0) {
  1553.         sscf->ocsp_cache_zone = NULL;
  1554.         return NGX_CONF_OK;
  1555.     }

  1557.     if (value[1].len <= sizeof("shared:") - 1
  1558.         || ngx_strncmp(value[1].data, "shared:", sizeof("shared:") - 1) != 0)
  1559.     {
  1560.         goto invalid;
  1561.     }

  1563.     len = 0;

  1565.     for (j = sizeof("shared:") - 1; j < value[1].len; j++) {
  1566.         if (value[1].data[j] == ':') {
  1567.             break;
  1568.         }

  1570.         len++;
  1571.     }

  1573.     if (len == 0 || j == value[1].len) {
  1574.         goto invalid;
  1575.     }

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

  1580.     size.len = value[1].len - j - 1;
  1581.     size.data = name.data + len + 1;

  1583.     n = ngx_parse_size(&size);

  1585.     if (n == NGX_ERROR) {
  1586.         goto invalid;
  1587.     }

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

  1593.         return NGX_CONF_ERROR;
  1594.     }

  1596.     sscf->ocsp_cache_zone = ngx_shared_memory_add(cf, &name, n,
  1597.                                                   &ngx_stream_ssl_module_ctx);
  1598.     if (sscf->ocsp_cache_zone == NULL) {
  1599.         return NGX_CONF_ERROR;
  1600.     }

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

  1604.     return NGX_CONF_OK;

  1606. invalid:

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

  1611.     return NGX_CONF_ERROR;
  1612. }


  1615. static char *
  1616. ‌ngx_stream_ssl_alpn(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1617. {
  1618. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  1620.     ngx_stream_ssl_srv_conf_t  *sscf = conf;

  1622.     u_char      *p;
  1623.     size_t       len;
  1624.     ngx_str_t   *value;
  1625.     ngx_uint_t   i;

  1627.     if (sscf->alpn.len) {
  1628.         return "is duplicate";
  1629.     }

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

  1633.     len = 0;

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

  1637.         if (value[i].len > 255) {
  1638.             return "protocol too long";
  1639.         }

  1641.         len += value[i].len + 1;
  1642.     }

  1644.     sscf->alpn.data = ngx_pnalloc(cf->pool, len);
  1645.     if (sscf->alpn.data == NULL) {
  1646.         return NGX_CONF_ERROR;
  1647.     }

  1649.     p = sscf->alpn.data;

  1651.     for (i = 1; i < cf->args->nelts; i++) {
  1652.         *p++ = value[i].len;
  1653.         p = ngx_cpymem(p, value[i].data, value[i].len);
  1654.     }

  1656.     sscf->alpn.len = len;

  1658.     return NGX_CONF_OK;

  1660. #else
  1661.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1662.                        "the \"ssl_alpn\" directive requires OpenSSL "
  1663.                        "with ALPN support");
  1664.     return NGX_CONF_ERROR;
  1665. #endif
  1666. }


  1669. static char *
  1670. ‌ngx_stream_ssl_conf_command_check(ngx_conf_t *cf, void *post, void *data)
  1671. {
  1672. #ifndef SSL_CONF_FLAG_FILE
  1673.     return "is not supported on this platform";
  1674. #else
  1675.     return NGX_CONF_OK;
  1676. #endif
  1677. }


  1680. static ngx_int_t
  1681. ‌ngx_stream_ssl_init(ngx_conf_t *cf)
  1682. {
  1683.     ngx_uint_t                     a, p, s;
  1684.     ngx_stream_handler_pt         *h;
  1685.     ngx_stream_conf_addr_t        *addr;
  1686.     ngx_stream_conf_port_t        *port;
  1687.     ngx_stream_ssl_srv_conf_t     *sscf;
  1688.     ngx_stream_core_srv_conf_t   **cscfp, *cscf;
  1689.     ngx_stream_core_main_conf_t   *cmcf;

  1691.     cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);
  1692.     cscfp = cmcf->servers.elts;

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

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

  1698.         if (sscf->ssl.ctx == NULL) {
  1699.             continue;
  1700.         }

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

  1704.         if (sscf->stapling) {
  1705.             if (ngx_ssl_stapling_resolver(cf, &sscf->ssl, cscf->resolver,
  1706.                                           cscf->resolver_timeout)
  1707.                 != NGX_OK)
  1708.             {
  1709.                 return NGX_ERROR;
  1710.             }
  1711.         }

  1713.         if (sscf->ocsp) {
  1714.             if (ngx_ssl_ocsp_resolver(cf, &sscf->ssl, cscf->resolver,
  1715.                                       cscf->resolver_timeout)
  1716.                 != NGX_OK)
  1717.             {
  1718.                 return NGX_ERROR;
  1719.             }
  1720.         }
  1721.     }

  1723.     h = ngx_array_push(&cmcf->phases[NGX_STREAM_SSL_PHASE].handlers);
  1724.     if (h == NULL) {
  1725.         return NGX_ERROR;
  1726.     }

  1728.     *h = ngx_stream_ssl_handler;

  1730.     if (cmcf->ports == NULL) {
  1731.         return NGX_OK;
  1732.     }

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

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

  1740.             if (!addr[a].opt.ssl) {
  1741.                 continue;
  1742.             }

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

  1747.             if (sscf->certificates) {
  1748.                 continue;
  1749.             }

  1751.             if (!sscf->reject_handshake) {
  1752.                 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1753.                               "no \"ssl_certificate\" is defined for "
  1754.                               "the \"listen ... ssl\" directive in %s:%ui",
  1755.                               cscf->file_name, cscf->line);
  1756.                 return NGX_ERROR;
  1757.             }

  1759.             /*
  1760.              * if no certificates are defined in the default server,
  1761.              * check all non-default server blocks
  1762.              */

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

  1767.                 cscf = cscfp[s];
  1768.                 sscf = cscf->ctx->srv_conf[ngx_stream_ssl_module.ctx_index];

  1770.                 if (sscf->certificates || sscf->reject_handshake) {
  1771.                     continue;
  1772.                 }

  1774.                 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1775.                               "no \"ssl_certificate\" is defined for "
  1776.                               "the \"listen ... ssl\" directive in %s:%ui",
  1777.                               cscf->file_name, cscf->line);
  1778.                 return NGX_ERROR;
  1779.             }
  1780.         }
  1781.     }

  1783.     return NGX_OK;
  1784. }

One Level Up Top Level