One Level Up Top Level

src/stream/ngx_stream_ssl_module.c - nginx-1.31.3 nginx/ @ 42f8df65b

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_sigalgs"), NULL, ngx_stream_ssl_variable,
  371.       (uintptr_t) ngx_ssl_get_sigalgs, NGX_STREAM_VAR_CHANGEABLE, 0 },

  373.     { ngx_string("ssl_session_id"), NULL, ngx_stream_ssl_variable,
  374.       (uintptr_t) ngx_ssl_get_session_id, NGX_STREAM_VAR_CHANGEABLE, 0 },

  376.     { ngx_string("ssl_session_reused"), NULL, ngx_stream_ssl_variable,
  377.       (uintptr_t) ngx_ssl_get_session_reused, NGX_STREAM_VAR_CHANGEABLE, 0 },

  379.     { ngx_string("ssl_server_name"), NULL, ngx_stream_ssl_variable,
  380.       (uintptr_t) ngx_ssl_get_server_name, NGX_STREAM_VAR_CHANGEABLE, 0 },

  382.     { ngx_string("ssl_alpn_protocol"), NULL, ngx_stream_ssl_variable,
  383.       (uintptr_t) ngx_ssl_get_alpn_protocol, NGX_STREAM_VAR_CHANGEABLE, 0 },

  385.     { ngx_string("ssl_ech_status"), NULL, ngx_stream_ssl_variable,
  386.       (uintptr_t) ngx_ssl_get_ech_status, NGX_STREAM_VAR_CHANGEABLE, 0 },

  388.     { ngx_string("ssl_ech_outer_server_name"), NULL, ngx_stream_ssl_variable,
  389.       (uintptr_t) ngx_ssl_get_ech_outer_server_name,
  390.       NGX_STREAM_VAR_CHANGEABLE, 0 },

  392.     { ngx_string("ssl_client_cert"), NULL, ngx_stream_ssl_variable,
  393.       (uintptr_t) ngx_ssl_get_certificate, NGX_STREAM_VAR_CHANGEABLE, 0 },

  395.     { ngx_string("ssl_client_raw_cert"), NULL, ngx_stream_ssl_variable,
  396.       (uintptr_t) ngx_ssl_get_raw_certificate,
  397.       NGX_STREAM_VAR_CHANGEABLE, 0 },

  399.     { ngx_string("ssl_client_escaped_cert"), NULL, ngx_stream_ssl_variable,
  400.       (uintptr_t) ngx_ssl_get_escaped_certificate,
  401.       NGX_STREAM_VAR_CHANGEABLE, 0 },

  403.     { ngx_string("ssl_client_s_dn"), NULL, ngx_stream_ssl_variable,
  404.       (uintptr_t) ngx_ssl_get_subject_dn, NGX_STREAM_VAR_CHANGEABLE, 0 },

  406.     { ngx_string("ssl_client_i_dn"), NULL, ngx_stream_ssl_variable,
  407.       (uintptr_t) ngx_ssl_get_issuer_dn, NGX_STREAM_VAR_CHANGEABLE, 0 },

  409.     { ngx_string("ssl_client_serial"), NULL, ngx_stream_ssl_variable,
  410.       (uintptr_t) ngx_ssl_get_serial_number, NGX_STREAM_VAR_CHANGEABLE, 0 },

  412.     { ngx_string("ssl_client_fingerprint"), NULL, ngx_stream_ssl_variable,
  413.       (uintptr_t) ngx_ssl_get_fingerprint, NGX_STREAM_VAR_CHANGEABLE, 0 },

  415.     { ngx_string("ssl_client_verify"), NULL, ngx_stream_ssl_variable,
  416.       (uintptr_t) ngx_ssl_get_client_verify, NGX_STREAM_VAR_CHANGEABLE, 0 },

  418.     { ngx_string("ssl_client_v_start"), NULL, ngx_stream_ssl_variable,
  419.       (uintptr_t) ngx_ssl_get_client_v_start, NGX_STREAM_VAR_CHANGEABLE, 0 },

  421.     { ngx_string("ssl_client_v_end"), NULL, ngx_stream_ssl_variable,
  422.       (uintptr_t) ngx_ssl_get_client_v_end, NGX_STREAM_VAR_CHANGEABLE, 0 },

  424.     { ngx_string("ssl_client_v_remain"), NULL, ngx_stream_ssl_variable,
  425.       (uintptr_t) ngx_ssl_get_client_v_remain, NGX_STREAM_VAR_CHANGEABLE, 0 },

  427.     { ngx_string("ssl_client_sigalg"), NULL, ngx_stream_ssl_variable,
  428.       (uintptr_t) ngx_ssl_get_client_sigalg, NGX_STREAM_VAR_CHANGEABLE, 0 },

  430.       ngx_stream_null_variable
  431. };


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


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

  447.     if (!s->ssl) {
  448.         return NGX_OK;
  449.     }

  451.     c = s->connection;

  453.     sscf = ngx_stream_get_module_srv_conf(s, ngx_stream_ssl_module);

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

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

  460.         if (rv != NGX_OK) {
  461.             return rv;
  462.         }
  463.     }

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

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

  475.             ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  476.                                        (SSL_get0_session(c->ssl->connection)));
  477.             return NGX_ERROR;
  478.         }

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

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

  487.                 ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  488.                                        (SSL_get0_session(c->ssl->connection)));
  489.                 return NGX_ERROR;
  490.             }

  492.             X509_free(cert);
  493.         }

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

  499.             ngx_ssl_remove_cached_session(c->ssl->session_ctx,
  500.                                        (SSL_get0_session(c->ssl->connection)));
  501.             return NGX_ERROR;
  502.         }
  503.     }

  505.     return NGX_OK;
  506. }


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

  517.     s = c->data;

  519.     cscf = ngx_stream_get_module_srv_conf(s, ngx_stream_core_module);

  521.     if (cscf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  522.         return NGX_ERROR;
  523.     }

  525.     if (ngx_ssl_create_connection(ssl, c, 0) != NGX_OK) {
  526.         return NGX_ERROR;
  527.     }

  529.     rc = ngx_ssl_handshake(c);

  531.     if (rc == NGX_ERROR) {
  532.         return NGX_ERROR;
  533.     }

  535.     if (rc == NGX_AGAIN) {
  536.         sscf = ngx_stream_get_module_srv_conf(s, ngx_stream_ssl_module);

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

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

  542.         return NGX_AGAIN;
  543.     }

  545.     /* rc == NGX_OK */

  547.     return NGX_OK;
  548. }


  551. static void
  552. ‌ngx_stream_ssl_handshake_handler(ngx_connection_t *c)
  553. {
  554.     ngx_stream_session_t  *s;

  556.     s = c->data;

  558.     if (!c->ssl->handshaked) {
  559.         ngx_stream_finalize_session(s, NGX_STREAM_INTERNAL_SERVER_ERROR);
  560.         return;
  561.     }

  563.     if (c->read->timer_set) {
  564.         ngx_del_timer(c->read);
  565.     }

  567.     ngx_stream_core_run_phases(s);
  568. }


  571. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

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

  584.     c = ngx_ssl_get_connection(ssl_conn);

  586.     if (c->ssl->handshaked) {
  587.         *ad = SSL_AD_NO_RENEGOTIATION;
  588.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  589.     }

  591.     if (c->ssl->sni_accepted) {
  592.         return SSL_TLSEXT_ERR_OK;
  593.     }

  595.     if (c->ssl->handshake_rejected) {
  596.         *ad = SSL_AD_UNRECOGNIZED_NAME;
  597.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  598.     }

  600.     s = c->data;

  602.     if (arg) {
  603.         host = *(ngx_str_t *) arg;

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

  611.     } else {
  612.         servername = SSL_get_servername(ssl_conn, TLSEXT_NAMETYPE_host_name);

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

  620.         host.len = ngx_strlen(servername);
  621.         host.data = (u_char *) servername;
  622.     }

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

  627.     if (host.len == 0) {
  628.         goto done;
  629.     }

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

  633.     if (rc == NGX_ERROR) {
  634.         goto error;
  635.     }

  637.     if (rc == NGX_DECLINED) {
  638.         goto done;
  639.     }

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

  643.     if (rc == NGX_ERROR) {
  644.         goto error;
  645.     }

  647.     if (rc == NGX_DECLINED) {
  648.         goto done;
  649.     }

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

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

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

  657.     if (sscf->ssl.ctx) {
  658.         if (SSL_set_SSL_CTX(ssl_conn, sscf->ssl.ctx) == NULL) {
  659.             goto error;
  660.         }

  662.         /*
  663.          * SSL_set_SSL_CTX() only changes certs as of 1.0.0d
  664.          * adjust other things we care about
  665.          */

  667.         SSL_set_verify(ssl_conn, SSL_CTX_get_verify_mode(sscf->ssl.ctx),
  668.                        SSL_CTX_get_verify_callback(sscf->ssl.ctx));

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

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

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

  680. #ifdef SSL_OP_NO_RENEGOTIATION
  681.         SSL_set_options(ssl_conn, SSL_OP_NO_RENEGOTIATION);
  682. #endif
  683.     }

  685. done:

  687.     sscf = ngx_stream_get_module_srv_conf(s, ngx_stream_ssl_module);

  689.     if (sscf->reject_handshake) {
  690.         c->ssl->handshake_rejected = 1;
  691.         *ad = SSL_AD_UNRECOGNIZED_NAME;
  692.         return SSL_TLSEXT_ERR_ALERT_FATAL;
  693.     }

  695.     c->ssl->sni_accepted = 1;
  696.     return SSL_TLSEXT_ERR_OK;

  698. error:

  700.     *ad = SSL_AD_INTERNAL_ERROR;
  701.     return SSL_TLSEXT_ERR_ALERT_FATAL;
  702. }

  704. #endif


  707. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

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

  719.     c = ngx_ssl_get_connection(ssl_conn);

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

  727. #endif

  729.     alpn = arg;

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

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

  741.     return SSL_TLSEXT_ERR_OK;
  742. }

  744. #endif


  747. #ifdef SSL_R_CERT_CB_ERROR

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

  759.     c = ngx_ssl_get_connection(ssl_conn);

  761.     if (c->ssl->handshaked) {
  762.         return 0;
  763.     }

  765.     s = c->data;

  767.     sscf = arg;

  769.     nelts = sscf->certificate_values->nelts;
  770.     certs = sscf->certificate_values->elts;
  771.     keys = sscf->certificate_key_values->elts;

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

  775.         if (ngx_stream_complex_value(s, &certs[i], &cert) != NGX_OK) {
  776.             return 0;
  777.         }

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

  782.         if (ngx_stream_complex_value(s, &keys[i], &key) != NGX_OK) {
  783.             return 0;
  784.         }

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

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

  798.     return 1;
  799. }

  801. #endif


  804. static ngx_int_t
  805. ‌ngx_stream_ssl_static_variable(ngx_stream_session_t *s,
  806.     ngx_stream_variable_value_t *v, uintptr_t data)
  807. {
  808.     ngx_ssl_variable_handler_pt  handler = (ngx_ssl_variable_handler_pt) data;

  810.     size_t     len;
  811.     ngx_str_t  str;

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

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

  817.         v->data = str.data;

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

  821.         v->len = len;
  822.         v->valid = 1;
  823.         v->no_cacheable = 0;
  824.         v->not_found = 0;

  826.         return NGX_OK;
  827.     }

  829.     v->not_found = 1;

  831.     return NGX_OK;
  832. }


  835. static ngx_int_t
  836. ‌ngx_stream_ssl_variable(ngx_stream_session_t *s,
  837.     ngx_stream_variable_value_t *v, uintptr_t data)
  838. {
  839.     ngx_ssl_variable_handler_pt  handler = (ngx_ssl_variable_handler_pt) data;

  841.     ngx_str_t  str;

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

  845.         if (handler(s->connection, s->connection->pool, &str) != NGX_OK) {
  846.             return NGX_ERROR;
  847.         }

  849.         v->len = str.len;
  850.         v->data = str.data;

  852.         if (v->len) {
  853.             v->valid = 1;
  854.             v->no_cacheable = 0;
  855.             v->not_found = 0;

  857.             return NGX_OK;
  858.         }
  859.     }

  861.     v->not_found = 1;

  863.     return NGX_OK;
  864. }


  867. static ngx_int_t
  868. ‌ngx_stream_ssl_add_variables(ngx_conf_t *cf)
  869. {
  870.     ngx_stream_variable_t  *var, *v;

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

  878.         var->get_handler = v->get_handler;
  879.         var->data = v->data;
  880.     }

  882.     return NGX_OK;
  883. }


  886. static void *
  887. ‌ngx_stream_ssl_create_srv_conf(ngx_conf_t *cf)
  888. {
  889.     ngx_stream_ssl_srv_conf_t  *sscf;

  891.     sscf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_ssl_srv_conf_t));
  892.     if (sscf == NULL) {
  893.         return NULL;
  894.     }

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

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

  935.     return sscf;
  936. }


  939. static char *
  940. ‌ngx_stream_ssl_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  941. {
  942.     ngx_stream_ssl_srv_conf_t *prev = parent;
  943.     ngx_stream_ssl_srv_conf_t *conf = child;

  945.     ngx_pool_cleanup_t  *cln;

  947.     ngx_conf_merge_msec_value(conf->handshake_timeout,
  948.                          prev->handshake_timeout, 60000);

  950.     ngx_conf_merge_value(conf->session_timeout,
  951.                          prev->session_timeout, 300);

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

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

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

  961.     ngx_conf_merge_bitmask_value(conf->protocols, prev->protocols,
  962.                          (NGX_CONF_BITMASK_SET|NGX_SSL_DEFAULT_PROTOCOLS));

  964.     ngx_conf_merge_uint_value(conf->verify, prev->verify, 0);
  965.     ngx_conf_merge_uint_value(conf->verify_depth, prev->verify_depth, 1);

  967.     ngx_conf_merge_ptr_value(conf->certificates, prev->certificates, NULL);
  968.     ngx_conf_merge_ptr_value(conf->certificate_keys, prev->certificate_keys,
  969.                          NULL);

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

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

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

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

  980.     ngx_conf_merge_str_value(conf->client_certificate, prev->client_certificate,
  981.                          "");
  982.     ngx_conf_merge_str_value(conf->trusted_certificate,
  983.                          prev->trusted_certificate, "");
  984.     ngx_conf_merge_str_value(conf->crl, prev->crl, "");
  985.     ngx_conf_merge_str_value(conf->alpn, prev->alpn, "");

  987.     ngx_conf_merge_str_value(conf->ecdh_curve, prev->ecdh_curve,
  988.                          NGX_DEFAULT_ECDH_CURVE);

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

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

  994.     ngx_conf_merge_uint_value(conf->ocsp, prev->ocsp, 0);
  995.     ngx_conf_merge_str_value(conf->ocsp_responder, prev->ocsp_responder, "");
  996.     ngx_conf_merge_ptr_value(conf->ocsp_cache_zone,
  997.                          prev->ocsp_cache_zone, NULL);

  999.     ngx_conf_merge_value(conf->stapling, prev->stapling, 0);
  1000.     ngx_conf_merge_value(conf->stapling_verify, prev->stapling_verify, 0);
  1001.     ngx_conf_merge_str_value(conf->stapling_file, prev->stapling_file, "");
  1002.     ngx_conf_merge_str_value(conf->stapling_responder,
  1003.                          prev->stapling_responder, "");

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

  1007.     if (conf->certificates) {

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

  1020.     } else if (!conf->reject_handshake) {
  1021.         return NGX_CONF_OK;
  1022.     }

  1024.     if (ngx_ssl_create(&conf->ssl, conf->protocols, NULL) != NGX_OK) {
  1025.         return NGX_CONF_ERROR;
  1026.     }

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

  1034.     cln->handler = ngx_ssl_cleanup_ctx;
  1035.     cln->data = &conf->ssl;

  1037. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
  1038.     {
  1039.     static ngx_ssl_client_hello_arg cb = { ngx_stream_ssl_servername };

  1041.     if (ngx_ssl_set_client_hello_callback(&conf->ssl, &cb) != NGX_OK) {
  1042.         return NGX_CONF_ERROR;
  1043.     }

  1045.     SSL_CTX_set_tlsext_servername_callback(conf->ssl.ctx,
  1046.                                            ngx_stream_ssl_servername);
  1047.     }
  1048. #endif

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

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

  1064.     if (ngx_stream_ssl_compile_certificates(cf, conf) != NGX_OK) {
  1065.         return NGX_CONF_ERROR;
  1066.     }

  1068.     if (conf->certificate_values) {

  1070. #ifdef SSL_R_CERT_CB_ERROR

  1072.         /* install callback to lookup certificates */

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

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

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

  1086.         /* configure certificates */

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

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

  1103.     if (conf->verify) {

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

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

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

  1132.     if (ngx_ssl_crl(cf, &conf->ssl, &conf->crl) != NGX_OK) {
  1133.         return NGX_CONF_ERROR;
  1134.     }

  1136.     if (conf->ocsp) {

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

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

  1153.     if (ngx_ssl_dhparam(cf, &conf->ssl, &conf->dhparam) != NGX_OK) {
  1154.         return NGX_CONF_ERROR;
  1155.     }

  1157.     if (ngx_ssl_ech_files(cf, &conf->ssl, conf->ech_files) != NGX_OK) {
  1158.         return NGX_CONF_ERROR;
  1159.     }

  1161.     if (ngx_ssl_ecdh_curve(cf, &conf->ssl, &conf->ecdh_curve) != NGX_OK) {
  1162.         return NGX_CONF_ERROR;
  1163.     }

  1165.     ngx_conf_merge_value(conf->builtin_session_cache,
  1166.                          prev->builtin_session_cache, NGX_SSL_NONE_SCACHE);

  1168.     if (conf->shm_zone == NULL) {
  1169.         conf->shm_zone = prev->shm_zone;
  1170.     }

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

  1180.     ngx_conf_merge_value(conf->session_tickets,
  1181.                          prev->session_tickets, 1);

  1183. #ifdef SSL_OP_NO_TICKET
  1184.     if (!conf->session_tickets) {
  1185.         SSL_CTX_set_options(conf->ssl.ctx, SSL_OP_NO_TICKET);
  1186.     }
  1187. #endif

  1189.     ngx_conf_merge_ptr_value(conf->session_ticket_keys,
  1190.                          prev->session_ticket_keys, NULL);

  1192.     if (ngx_ssl_session_ticket_keys(cf, &conf->ssl, conf->session_ticket_keys)
  1193.         != NGX_OK)
  1194.     {
  1195.         return NGX_CONF_ERROR;
  1196.     }

  1198.     if (conf->stapling) {

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

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

  1215.     if (ngx_ssl_conf_commands(cf, &conf->ssl, conf->conf_commands) != NGX_OK) {
  1216.         return NGX_CONF_ERROR;
  1217.     }

  1219.     return NGX_CONF_OK;
  1220. }


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

  1232.     if (conf->certificates == NULL) {
  1233.         return NGX_OK;
  1234.     }

  1236.     cert = conf->certificates->elts;
  1237.     key = conf->certificate_keys->elts;
  1238.     nelts = conf->certificates->nelts;

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

  1242.         if (ngx_stream_script_variables_count(&cert[i])) {
  1243.             goto found;
  1244.         }

  1246.         if (ngx_stream_script_variables_count(&key[i])) {
  1247.             goto found;
  1248.         }
  1249.     }

  1251.     return NGX_OK;

  1253. found:

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

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

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

  1269.         cv = ngx_array_push(conf->certificate_values);
  1270.         if (cv == NULL) {
  1271.             return NGX_ERROR;
  1272.         }

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

  1276.         ccv.cf = cf;
  1277.         ccv.value = &cert[i];
  1278.         ccv.complex_value = cv;
  1279.         ccv.zero = 1;

  1281.         if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  1282.             return NGX_ERROR;
  1283.         }

  1285.         cv = ngx_array_push(conf->certificate_key_values);
  1286.         if (cv == NULL) {
  1287.             return NGX_ERROR;
  1288.         }

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

  1292.         ccv.cf = cf;
  1293.         ccv.value = &key[i];
  1294.         ccv.complex_value = cv;
  1295.         ccv.zero = 1;

  1297.         if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  1298.             return NGX_ERROR;
  1299.         }
  1300.     }

  1302.     conf->passwords = ngx_ssl_preserve_passwords(cf, conf->passwords);
  1303.     if (conf->passwords == NULL) {
  1304.         return NGX_ERROR;
  1305.     }

  1307.     return NGX_OK;
  1308. }


  1311. static char *
  1312. ‌ngx_stream_ssl_certificate_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1313. {
  1314.     ngx_stream_ssl_srv_conf_t *sscf = conf;

  1316.     time_t       inactive, valid;
  1317.     ngx_str_t   *value, s;
  1318.     ngx_int_t    max;
  1319.     ngx_uint_t   i;

  1321.     if (sscf->certificate_cache != NGX_CONF_UNSET_PTR) {
  1322.         return "is duplicate";
  1323.     }

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

  1327.     max = 0;
  1328.     inactive = 10;
  1329.     valid = 60;

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

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

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

  1340.             continue;
  1341.         }

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

  1345.             s.len = value[i].len - 9;
  1346.             s.data = value[i].data + 9;

  1348.             inactive = ngx_parse_time(&s, 1);
  1349.             if (inactive == (time_t) NGX_ERROR) {
  1350.                 goto failed;
  1351.             }

  1353.             continue;
  1354.         }

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

  1358.             s.len = value[i].len - 6;
  1359.             s.data = value[i].data + 6;

  1361.             valid = ngx_parse_time(&s, 1);
  1362.             if (valid == (time_t) NGX_ERROR) {
  1363.                 goto failed;
  1364.             }

  1366.             continue;
  1367.         }

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

  1371.             sscf->certificate_cache = NULL;

  1373.             continue;
  1374.         }

  1376.     failed:

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

  1383.     if (sscf->certificate_cache == NULL) {
  1384.         return NGX_CONF_OK;
  1385.     }

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

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

  1400.     return NGX_CONF_OK;
  1401. }


  1404. static char *
  1405. ‌ngx_stream_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1406. {
  1407.     ngx_stream_ssl_srv_conf_t  *sscf = conf;

  1409.     ngx_str_t  *value;

  1411.     if (sscf->passwords != NGX_CONF_UNSET_PTR) {
  1412.         return "is duplicate";
  1413.     }

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

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

  1419.     if (sscf->passwords == NULL) {
  1420.         return NGX_CONF_ERROR;
  1421.     }

  1423.     return NGX_CONF_OK;
  1424. }


  1427. static char *
  1428. ‌ngx_stream_ssl_session_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1429. {
  1430.     ngx_stream_ssl_srv_conf_t  *sscf = conf;

  1432.     size_t       len;
  1433.     ngx_str_t   *value, name, size;
  1434.     ngx_int_t    n;
  1435.     ngx_uint_t   i, j;

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

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

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

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

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

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

  1463.             if (n == NGX_ERROR) {
  1464.                 goto invalid;
  1465.             }

  1467.             sscf->builtin_session_cache = n;

  1469.             continue;
  1470.         }

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

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

  1483.                 len++;
  1484.             }

  1486.             if (len == 0 || j == value[i].len) {
  1487.                 goto invalid;
  1488.             }

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

  1493.             size.len = value[i].len - j - 1;
  1494.             size.data = name.data + len + 1;

  1496.             n = ngx_parse_size(&size);

  1498.             if (n == NGX_ERROR) {
  1499.                 goto invalid;
  1500.             }

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

  1507.                 return NGX_CONF_ERROR;
  1508.             }

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

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

  1518.             continue;
  1519.         }

  1521.         goto invalid;
  1522.     }

  1524.     if (sscf->shm_zone && sscf->builtin_session_cache == NGX_CONF_UNSET) {
  1525.         sscf->builtin_session_cache = NGX_SSL_NO_BUILTIN_SCACHE;
  1526.     }

  1528.     return NGX_CONF_OK;

  1530. invalid:

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

  1535.     return NGX_CONF_ERROR;
  1536. }


  1539. static char *
  1540. ‌ngx_stream_ssl_ocsp_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1541. {
  1542.     ngx_stream_ssl_srv_conf_t *sscf = conf;

  1544.     size_t       len;
  1545.     ngx_int_t    n;
  1546.     ngx_str_t   *value, name, size;
  1547.     ngx_uint_t   j;

  1549.     if (sscf->ocsp_cache_zone != NGX_CONF_UNSET_PTR) {
  1550.         return "is duplicate";
  1551.     }

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

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

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

  1566.     len = 0;

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

  1573.         len++;
  1574.     }

  1576.     if (len == 0 || j == value[1].len) {
  1577.         goto invalid;
  1578.     }

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

  1583.     size.len = value[1].len - j - 1;
  1584.     size.data = name.data + len + 1;

  1586.     n = ngx_parse_size(&size);

  1588.     if (n == NGX_ERROR) {
  1589.         goto invalid;
  1590.     }

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

  1596.         return NGX_CONF_ERROR;
  1597.     }

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

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

  1607.     return NGX_CONF_OK;

  1609. invalid:

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

  1614.     return NGX_CONF_ERROR;
  1615. }


  1618. static char *
  1619. ‌ngx_stream_ssl_alpn(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1620. {
  1621. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  1623.     ngx_stream_ssl_srv_conf_t  *sscf = conf;

  1625.     u_char      *p;
  1626.     size_t       len;
  1627.     ngx_str_t   *value;
  1628.     ngx_uint_t   i;

  1630.     if (sscf->alpn.len) {
  1631.         return "is duplicate";
  1632.     }

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

  1636.     len = 0;

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

  1640.         if (value[i].len > 255) {
  1641.             return "protocol too long";
  1642.         }

  1644.         len += value[i].len + 1;
  1645.     }

  1647.     sscf->alpn.data = ngx_pnalloc(cf->pool, len);
  1648.     if (sscf->alpn.data == NULL) {
  1649.         return NGX_CONF_ERROR;
  1650.     }

  1652.     p = sscf->alpn.data;

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

  1659.     sscf->alpn.len = len;

  1661.     return NGX_CONF_OK;

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


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


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

  1694.     cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);
  1695.     cscfp = cmcf->servers.elts;

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

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

  1701.         if (sscf->ssl.ctx == NULL) {
  1702.             continue;
  1703.         }

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

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

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

  1726.     h = ngx_array_push(&cmcf->phases[NGX_STREAM_SSL_PHASE].handlers);
  1727.     if (h == NULL) {
  1728.         return NGX_ERROR;
  1729.     }

  1731.     *h = ngx_stream_ssl_handler;

  1733.     if (cmcf->ports == NULL) {
  1734.         return NGX_OK;
  1735.     }

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

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

  1743.             if (!addr[a].opt.ssl) {
  1744.                 continue;
  1745.             }

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

  1750.             if (sscf->certificates) {
  1751.                 continue;
  1752.             }

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

  1762.             /*
  1763.              * if no certificates are defined in the default server,
  1764.              * check all non-default server blocks
  1765.              */

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

  1770.                 cscf = cscfp[s];
  1771.                 sscf = cscf->ctx->srv_conf[ngx_stream_ssl_module.ctx_index];

  1773.                 if (sscf->certificates || sscf->reject_handshake) {
  1774.                     continue;
  1775.                 }

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

  1786.     return NGX_OK;
  1787. }

One Level Up Top Level