One Level Up Top Level

src/event/ngx_event_openssl.c - nginx source code

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


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


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


  13. ‌#define NGX_SSL_PASSWORD_BUFFER_SIZE  4096


  16. ‌typedef struct {
  17.     ngx_uint_t  engine;   /* unsigned  engine:1; */
  18. ‌} ngx_openssl_conf_t;


  21. static ngx_inline ngx_int_t ngx_ssl_cert_already_in_hash(void);
  22. static int ngx_ssl_verify_callback(int ok, X509_STORE_CTX *x509_store);
  23. static void ngx_ssl_info_callback(const ngx_ssl_conn_t *ssl_conn, int where,
  24.     int ret);
  25. static int ngx_ssl_cmp_x509_name(const X509_NAME *const *a,
  26.     const X509_NAME *const *b);
  27. static void ngx_ssl_passwords_cleanup(void *data);
  28. static int ngx_ssl_new_client_session(ngx_ssl_conn_t *ssl_conn,
  29.     ngx_ssl_session_t *sess);
  30. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  31. static ngx_int_t ngx_ssl_try_early_data(ngx_connection_t *c);
  32. #endif
  33. static void ngx_ssl_handshake_handler(ngx_event_t *ev);
  34. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  35. static ssize_t ngx_ssl_recv_early(ngx_connection_t *c, u_char *buf,
  36.     size_t size);
  37. #endif
  38. static ngx_int_t ngx_ssl_handle_recv(ngx_connection_t *c, int n);
  39. static void ngx_ssl_write_handler(ngx_event_t *wev);
  40. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  41. static ssize_t ngx_ssl_write_early(ngx_connection_t *c, u_char *data,
  42.     size_t size);
  43. #endif
  44. static ssize_t ngx_ssl_sendfile(ngx_connection_t *c, ngx_buf_t *file,
  45.     size_t size);
  46. static void ngx_ssl_read_handler(ngx_event_t *rev);
  47. static void ngx_ssl_shutdown_handler(ngx_event_t *ev);
  48. static void ngx_ssl_connection_error(ngx_connection_t *c, int sslerr,
  49.     ngx_err_t err, char *text);
  50. static void ngx_ssl_clear_error(ngx_log_t *log);

  52. static ngx_int_t ngx_ssl_session_id_context(ngx_ssl_t *ssl,
  53.     ngx_str_t *sess_ctx, ngx_array_t *certificates);
  54. static int ngx_ssl_new_session(ngx_ssl_conn_t *ssl_conn,
  55.     ngx_ssl_session_t *sess);
  56. static ngx_ssl_session_t *ngx_ssl_get_cached_session(ngx_ssl_conn_t *ssl_conn,
  57. #if OPENSSL_VERSION_NUMBER >= 0x10100003L
  58.     const
  59. #endif
  60.     u_char *id, int len, int *copy);
  61. static void ngx_ssl_remove_session(SSL_CTX *ssl, ngx_ssl_session_t *sess);
  62. static void ngx_ssl_expire_sessions(ngx_ssl_session_cache_t *cache,
  63.     ngx_slab_pool_t *shpool, ngx_uint_t n);
  64. static void ngx_ssl_session_rbtree_insert_value(ngx_rbtree_node_t *temp,
  65.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);

  67. #ifdef SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB
  68. static int ngx_ssl_ticket_key_callback(ngx_ssl_conn_t *ssl_conn,
  69.     unsigned char *name, unsigned char *iv, EVP_CIPHER_CTX *ectx,
  70.     HMAC_CTX *hctx, int enc);
  71. static ngx_int_t ngx_ssl_rotate_ticket_keys(SSL_CTX *ssl_ctx, ngx_log_t *log);
  72. static void ngx_ssl_ticket_keys_cleanup(void *data);
  73. #endif

  75. #ifndef X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT
  76. static ngx_int_t ngx_ssl_check_name(ngx_str_t *name, ASN1_STRING *str);
  77. #endif

  79. static time_t ngx_ssl_parse_time(
  80. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  81.     const
  82. #endif
  83.     ASN1_TIME *asn1time, ngx_log_t *log);

  85. static void *ngx_openssl_create_conf(ngx_cycle_t *cycle);
  86. static char *ngx_openssl_engine(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  87. static void ngx_openssl_exit(ngx_cycle_t *cycle);


  90. ‌static ngx_command_t  ngx_openssl_commands[] = {

  92.     { ngx_string("ssl_engine"),
  93.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  94.       ngx_openssl_engine,
  95.       0,
  96.       0,
  97.       NULL },

  99.       ngx_null_command
  100. };


  103. ‌static ngx_core_module_t  ngx_openssl_module_ctx = {
  104.     ngx_string("openssl"),
  105.     ngx_openssl_create_conf,
  106.     NULL
  107. };


  110. ‌ngx_module_t  ngx_openssl_module = {
  111.     NGX_MODULE_V1,
  112.     &ngx_openssl_module_ctx,               /* module context */
  113.     ngx_openssl_commands,                  /* module directives */
  114.     NGX_CORE_MODULE,                       /* module type */
  115.     NULL,                                  /* init master */
  116.     NULL,                                  /* init module */
  117.     NULL,                                  /* init process */
  118.     NULL,                                  /* init thread */
  119.     NULL,                                  /* exit thread */
  120.     NULL,                                  /* exit process */
  121.     ngx_openssl_exit,                      /* exit master */
  122.     NGX_MODULE_V1_PADDING
  123. };


  126. ‌int  ngx_ssl_connection_index;
  127. ‌int  ngx_ssl_server_conf_index;
  128. ‌int  ngx_ssl_session_cache_index;
  129. ‌int  ngx_ssl_ticket_keys_index;
  130. ‌int  ngx_ssl_ocsp_index;
  131. ‌int  ngx_ssl_index;
  132. ‌int  ngx_ssl_certificate_name_index;


  135. ngx_int_t
  136. ‌ngx_ssl_init(ngx_log_t *log)
  137. {
  138. #if (OPENSSL_INIT_LOAD_CONFIG && !defined LIBRESSL_VERSION_NUMBER)

  140.     uint64_t                opts;
  141.     OPENSSL_INIT_SETTINGS  *init;

  143.     opts = OPENSSL_INIT_LOAD_CONFIG;

  145. #if (NGX_OPENSSL_NO_CONFIG)

  147.     if (getenv("OPENSSL_CONF") == NULL) {
  148.         opts = OPENSSL_INIT_NO_LOAD_CONFIG;
  149.     }

  151. #endif

  153.     init = OPENSSL_INIT_new();
  154.     if (init == NULL) {
  155.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "OPENSSL_INIT_new() failed");
  156.         return NGX_ERROR;
  157.     }

  159. #ifndef OPENSSL_NO_STDIO
  160.     if (OPENSSL_INIT_set_config_appname(init, "nginx") == 0) {
  161.         ngx_ssl_error(NGX_LOG_ALERT, log, 0,
  162.                       "OPENSSL_INIT_set_config_appname() failed");
  163.         return NGX_ERROR;
  164.     }
  165. #endif

  167.     if (OPENSSL_init_ssl(opts, init) == 0) {
  168.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "OPENSSL_init_ssl() failed");
  169.         return NGX_ERROR;
  170.     }

  172.     OPENSSL_INIT_free(init);

  174.     /*
  175.      * OPENSSL_init_ssl() may leave errors in the error queue
  176.      * while returning success
  177.      */

  179.     ERR_clear_error();

  181. #else

  183. #if (NGX_OPENSSL_NO_CONFIG)

  185.     if (getenv("OPENSSL_CONF") == NULL) {
  186.         OPENSSL_no_config();
  187.     }

  189. #endif

  191.     OPENSSL_config("nginx");

  193.     SSL_library_init();
  194.     SSL_load_error_strings();

  196.     OpenSSL_add_all_algorithms();

  198. #endif

  200. #ifndef SSL_OP_NO_COMPRESSION
  201.     {
  202.     /*
  203.      * Disable gzip compression in OpenSSL prior to 1.0.0 version,
  204.      * this saves about 522K per connection.
  205.      */
  206.     int                  n;
  207.     STACK_OF(SSL_COMP)  *ssl_comp_methods;

  209.     ssl_comp_methods = SSL_COMP_get_compression_methods();
  210.     n = sk_SSL_COMP_num(ssl_comp_methods);

  212.     while (n--) {
  213.         (void) sk_SSL_COMP_pop(ssl_comp_methods);
  214.     }
  215.     }
  216. #endif

  218.     ngx_ssl_connection_index = SSL_get_ex_new_index(0, NULL, NULL, NULL, NULL);

  220.     if (ngx_ssl_connection_index == -1) {
  221.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "SSL_get_ex_new_index() failed");
  222.         return NGX_ERROR;
  223.     }

  225.     ngx_ssl_server_conf_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL,
  226.                                                          NULL);
  227.     if (ngx_ssl_server_conf_index == -1) {
  228.         ngx_ssl_error(NGX_LOG_ALERT, log, 0,
  229.                       "SSL_CTX_get_ex_new_index() failed");
  230.         return NGX_ERROR;
  231.     }

  233.     ngx_ssl_session_cache_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL,
  234.                                                            NULL);
  235.     if (ngx_ssl_session_cache_index == -1) {
  236.         ngx_ssl_error(NGX_LOG_ALERT, log, 0,
  237.                       "SSL_CTX_get_ex_new_index() failed");
  238.         return NGX_ERROR;
  239.     }

  241.     ngx_ssl_ticket_keys_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL,
  242.                                                          NULL);
  243.     if (ngx_ssl_ticket_keys_index == -1) {
  244.         ngx_ssl_error(NGX_LOG_ALERT, log, 0,
  245.                       "SSL_CTX_get_ex_new_index() failed");
  246.         return NGX_ERROR;
  247.     }

  249.     ngx_ssl_ocsp_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL, NULL);
  250.     if (ngx_ssl_ocsp_index == -1) {
  251.         ngx_ssl_error(NGX_LOG_ALERT, log, 0,
  252.                       "SSL_CTX_get_ex_new_index() failed");
  253.         return NGX_ERROR;
  254.     }

  256.     ngx_ssl_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL, NULL);

  258.     if (ngx_ssl_index == -1) {
  259.         ngx_ssl_error(NGX_LOG_ALERT, log, 0,
  260.                       "SSL_CTX_get_ex_new_index() failed");
  261.         return NGX_ERROR;
  262.     }

  264.     ngx_ssl_certificate_name_index = X509_get_ex_new_index(0, NULL, NULL, NULL,
  265.                                                            NULL);

  267.     if (ngx_ssl_certificate_name_index == -1) {
  268.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "X509_get_ex_new_index() failed");
  269.         return NGX_ERROR;
  270.     }

  272.     return NGX_OK;
  273. }


  276. ngx_int_t
  277. ‌ngx_ssl_create(ngx_ssl_t *ssl, ngx_uint_t protocols, void *data)
  278. {
  279.     ssl->ctx = SSL_CTX_new(SSLv23_method());

  281.     if (ssl->ctx == NULL) {
  282.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0, "SSL_CTX_new() failed");
  283.         return NGX_ERROR;
  284.     }

  286.     if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_server_conf_index, data) == 0) {
  287.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  288.                       "SSL_CTX_set_ex_data() failed");
  289.         return NGX_ERROR;
  290.     }

  292.     if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_index, ssl) == 0) {
  293.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  294.                       "SSL_CTX_set_ex_data() failed");
  295.         return NGX_ERROR;
  296.     }

  298.     ngx_rbtree_init(&ssl->staple_rbtree, &ssl->staple_sentinel,
  299.                     ngx_rbtree_insert_value);

  301.     ssl->buffer_size = NGX_SSL_BUFSIZE;

  303.     /* client side options */

  305. #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
  306.     SSL_CTX_set_options(ssl->ctx, SSL_OP_MICROSOFT_SESS_ID_BUG);
  307. #endif

  309. #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
  310.     SSL_CTX_set_options(ssl->ctx, SSL_OP_NETSCAPE_CHALLENGE_BUG);
  311. #endif

  313.     /* server side options */

  315. #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
  316.     SSL_CTX_set_options(ssl->ctx, SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG);
  317. #endif

  319. #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
  320.     SSL_CTX_set_options(ssl->ctx, SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER);
  321. #endif

  323. #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
  324.     SSL_CTX_set_options(ssl->ctx, SSL_OP_SSLEAY_080_CLIENT_DH_BUG);
  325. #endif

  327. #ifdef SSL_OP_TLS_D5_BUG
  328.     SSL_CTX_set_options(ssl->ctx, SSL_OP_TLS_D5_BUG);
  329. #endif

  331. #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
  332.     SSL_CTX_set_options(ssl->ctx, SSL_OP_TLS_BLOCK_PADDING_BUG);
  333. #endif

  335. #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
  336.     SSL_CTX_set_options(ssl->ctx, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);
  337. #endif

  339.     SSL_CTX_set_options(ssl->ctx, SSL_OP_SINGLE_DH_USE);

  341. #if OPENSSL_VERSION_NUMBER >= 0x009080dfL
  342.     /* only in 0.9.8m+ */
  343.     SSL_CTX_clear_options(ssl->ctx,
  344.                           SSL_OP_NO_SSLv2|SSL_OP_NO_SSLv3|SSL_OP_NO_TLSv1);
  345. #endif

  347.     if (!(protocols & NGX_SSL_SSLv2)) {
  348.         SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_SSLv2);
  349.     }
  350.     if (!(protocols & NGX_SSL_SSLv3)) {
  351.         SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_SSLv3);
  352.     }
  353.     if (!(protocols & NGX_SSL_TLSv1)) {
  354.         SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_TLSv1);
  355.     }
  356. #ifdef SSL_OP_NO_TLSv1_1
  357.     SSL_CTX_clear_options(ssl->ctx, SSL_OP_NO_TLSv1_1);
  358.     if (!(protocols & NGX_SSL_TLSv1_1)) {
  359.         SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_TLSv1_1);
  360.     }
  361. #endif
  362. #ifdef SSL_OP_NO_TLSv1_2
  363.     SSL_CTX_clear_options(ssl->ctx, SSL_OP_NO_TLSv1_2);
  364.     if (!(protocols & NGX_SSL_TLSv1_2)) {
  365.         SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_TLSv1_2);
  366.     }
  367. #endif
  368. #ifdef SSL_OP_NO_TLSv1_3
  369.     SSL_CTX_clear_options(ssl->ctx, SSL_OP_NO_TLSv1_3);
  370.     if (!(protocols & NGX_SSL_TLSv1_3)) {
  371.         SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_TLSv1_3);
  372.     }
  373. #endif

  375. #ifdef SSL_CTX_set_min_proto_version
  376.     SSL_CTX_set_min_proto_version(ssl->ctx, 0);
  377.     SSL_CTX_set_max_proto_version(ssl->ctx, TLS1_2_VERSION);
  378. #endif

  380. #ifdef TLS1_3_VERSION
  381.     SSL_CTX_set_min_proto_version(ssl->ctx, 0);
  382.     SSL_CTX_set_max_proto_version(ssl->ctx, TLS1_3_VERSION);
  383. #endif

  385. #ifdef SSL_OP_NO_COMPRESSION
  386.     SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_COMPRESSION);
  387. #endif

  389. #ifdef SSL_OP_NO_ANTI_REPLAY
  390.     SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_ANTI_REPLAY);
  391. #endif

  393. #ifdef SSL_OP_NO_CLIENT_RENEGOTIATION
  394.     SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_CLIENT_RENEGOTIATION);
  395. #endif

  397. #ifdef SSL_OP_IGNORE_UNEXPECTED_EOF
  398.     SSL_CTX_set_options(ssl->ctx, SSL_OP_IGNORE_UNEXPECTED_EOF);
  399. #endif

  401. #ifdef SSL_MODE_RELEASE_BUFFERS
  402.     SSL_CTX_set_mode(ssl->ctx, SSL_MODE_RELEASE_BUFFERS);
  403. #endif

  405. #ifdef SSL_MODE_NO_AUTO_CHAIN
  406.     SSL_CTX_set_mode(ssl->ctx, SSL_MODE_NO_AUTO_CHAIN);
  407. #endif

  409.     SSL_CTX_set_read_ahead(ssl->ctx, 1);

  411.     SSL_CTX_set_info_callback(ssl->ctx, ngx_ssl_info_callback);

  413.     return NGX_OK;
  414. }


  417. ngx_int_t
  418. ‌ngx_ssl_certificates(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_array_t *certs,
  419.     ngx_array_t *keys, ngx_array_t *passwords)
  420. {
  421.     ngx_str_t   *cert, *key;
  422.     ngx_uint_t   i;

  424.     cert = certs->elts;
  425.     key = keys->elts;

  427.     for (i = 0; i < certs->nelts; i++) {

  429.         if (ngx_ssl_certificate(cf, ssl, &cert[i], &key[i], passwords)
  430.             != NGX_OK)
  431.         {
  432.             return NGX_ERROR;
  433.         }
  434.     }

  436.     return NGX_OK;
  437. }


  440. ngx_int_t
  441. ‌ngx_ssl_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *cert,
  442.     ngx_str_t *key, ngx_array_t *passwords)
  443. {
  444.     char            *err;
  445.     X509            *x509, **elm;
  446.     EVP_PKEY        *pkey;
  447.     STACK_OF(X509)  *chain;

  449.     chain = ngx_ssl_cache_fetch(cf, NGX_SSL_CACHE_CERT, &err, cert, NULL);
  450.     if (chain == NULL) {
  451.         if (err != NULL) {
  452.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  453.                           "cannot load certificate \"%s\": %s",
  454.                           cert->data, err);
  455.         }

  457.         return NGX_ERROR;
  458.     }

  460.     x509 = sk_X509_shift(chain);

  462.     if (SSL_CTX_use_certificate(ssl->ctx, x509) == 0) {
  463.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  464.                       "SSL_CTX_use_certificate(\"%s\") failed", cert->data);
  465.         X509_free(x509);
  466.         sk_X509_pop_free(chain, X509_free);
  467.         return NGX_ERROR;
  468.     }

  470.     if (X509_set_ex_data(x509, ngx_ssl_certificate_name_index, cert->data)
  471.         == 0)
  472.     {
  473.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0, "X509_set_ex_data() failed");
  474.         X509_free(x509);
  475.         sk_X509_pop_free(chain, X509_free);
  476.         return NGX_ERROR;
  477.     }

  479.     if (ssl->certs.elts == NULL) {
  480.         if (ngx_array_init(&ssl->certs, cf->pool, 1, sizeof(X509 *))
  481.             != NGX_OK)
  482.         {
  483.             X509_free(x509);
  484.             sk_X509_pop_free(chain, X509_free);
  485.             return NGX_ERROR;
  486.         }
  487.     }

  489.     elm = ngx_array_push(&ssl->certs);
  490.     if (elm == NULL) {
  491.         X509_free(x509);
  492.         sk_X509_pop_free(chain, X509_free);
  493.         return NGX_ERROR;
  494.     }

  496.     *elm = x509;

  498.     /*
  499.      * Note that x509 is not freed here, but will be instead freed in
  500.      * ngx_ssl_cleanup_ctx().  This is because we need to preserve all
  501.      * certificates to be able to iterate all of them through ssl->certs,
  502.      * while OpenSSL can free a certificate if it is replaced with another
  503.      * certificate of the same type.
  504.      */

  506. #ifdef SSL_CTX_set0_chain

  508.     if (SSL_CTX_set0_chain(ssl->ctx, chain) == 0) {
  509.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  510.                       "SSL_CTX_set0_chain(\"%s\") failed", cert->data);
  511.         sk_X509_pop_free(chain, X509_free);
  512.         return NGX_ERROR;
  513.     }

  515. #else
  516.     {
  517.     int  n;

  519.     /* SSL_CTX_set0_chain() is only available in OpenSSL 1.0.2+ */

  521.     n = sk_X509_num(chain);

  523.     while (n--) {
  524.         x509 = sk_X509_shift(chain);

  526.         if (SSL_CTX_add_extra_chain_cert(ssl->ctx, x509) == 0) {
  527.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  528.                           "SSL_CTX_add_extra_chain_cert(\"%s\") failed",
  529.                           cert->data);
  530.             sk_X509_pop_free(chain, X509_free);
  531.             return NGX_ERROR;
  532.         }
  533.     }

  535.     sk_X509_free(chain);
  536.     }
  537. #endif

  539.     pkey = ngx_ssl_cache_fetch(cf, NGX_SSL_CACHE_PKEY, &err, key, passwords);
  540.     if (pkey == NULL) {
  541.         if (err != NULL) {
  542.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  543.                           "cannot load certificate key \"%s\": %s",
  544.                           key->data, err);
  545.         }

  547.         return NGX_ERROR;
  548.     }

  550.     if (SSL_CTX_use_PrivateKey(ssl->ctx, pkey) == 0) {
  551.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  552.                       "SSL_CTX_use_PrivateKey(\"%s\") failed", key->data);
  553.         EVP_PKEY_free(pkey);
  554.         return NGX_ERROR;
  555.     }

  557.     EVP_PKEY_free(pkey);

  559.     return NGX_OK;
  560. }


  563. ngx_int_t
  564. ‌ngx_ssl_connection_certificate(ngx_connection_t *c, ngx_pool_t *pool,
  565.     ngx_str_t *cert, ngx_str_t *key, ngx_array_t *passwords)
  566. {
  567.     char            *err;
  568.     X509            *x509;
  569.     EVP_PKEY        *pkey;
  570.     STACK_OF(X509)  *chain;

  572.     chain = ngx_ssl_cache_connection_fetch(pool, NGX_SSL_CACHE_CERT, &err,
  573.                                            cert, NULL);
  574.     if (chain == NULL) {
  575.         if (err != NULL) {
  576.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  577.                           "cannot load certificate \"%s\": %s",
  578.                           cert->data, err);
  579.         }

  581.         return NGX_ERROR;
  582.     }

  584.     x509 = sk_X509_shift(chain);

  586.     if (SSL_use_certificate(c->ssl->connection, x509) == 0) {
  587.         ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  588.                       "SSL_use_certificate(\"%s\") failed", cert->data);
  589.         X509_free(x509);
  590.         sk_X509_pop_free(chain, X509_free);
  591.         return NGX_ERROR;
  592.     }

  594.     X509_free(x509);

  596. #ifdef SSL_set0_chain

  598.     /*
  599.      * SSL_set0_chain() is only available in OpenSSL 1.0.2+,
  600.      * but this function is only called via certificate callback,
  601.      * which is only available in OpenSSL 1.0.2+ as well
  602.      */

  604.     if (SSL_set0_chain(c->ssl->connection, chain) == 0) {
  605.         ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  606.                       "SSL_set0_chain(\"%s\") failed", cert->data);
  607.         sk_X509_pop_free(chain, X509_free);
  608.         return NGX_ERROR;
  609.     }

  611. #endif

  613.     pkey = ngx_ssl_cache_connection_fetch(pool, NGX_SSL_CACHE_PKEY, &err,
  614.                                           key, passwords);
  615.     if (pkey == NULL) {
  616.         if (err != NULL) {
  617.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  618.                           "cannot load certificate key \"%s\": %s",
  619.                           key->data, err);
  620.         }

  622.         return NGX_ERROR;
  623.     }

  625.     if (SSL_use_PrivateKey(c->ssl->connection, pkey) == 0) {
  626.         ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  627.                       "SSL_use_PrivateKey(\"%s\") failed", key->data);
  628.         EVP_PKEY_free(pkey);
  629.         return NGX_ERROR;
  630.     }

  632.     EVP_PKEY_free(pkey);

  634.     return NGX_OK;
  635. }


  638. ngx_int_t
  639. ‌ngx_ssl_ciphers(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *ciphers,
  640.     ngx_uint_t prefer_server_ciphers)
  641. {
  642.     if (SSL_CTX_set_cipher_list(ssl->ctx, (char *) ciphers->data) == 0) {
  643.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  644.                       "SSL_CTX_set_cipher_list(\"%V\") failed",
  645.                       ciphers);
  646.         return NGX_ERROR;
  647.     }

  649.     if (prefer_server_ciphers) {
  650.         SSL_CTX_set_options(ssl->ctx, SSL_OP_CIPHER_SERVER_PREFERENCE);
  651.     }

  653.     return NGX_OK;
  654. }


  657. ngx_int_t
  658. ‌ngx_ssl_client_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *cert,
  659.     ngx_int_t depth)
  660. {
  661.     int                   n, i;
  662.     char                 *err;
  663.     X509                 *x509;
  664.     X509_NAME            *name;
  665.     X509_STORE           *store;
  666.     STACK_OF(X509)       *chain;
  667.     STACK_OF(X509_NAME)  *list;

  669.     SSL_CTX_set_verify(ssl->ctx, SSL_VERIFY_PEER, ngx_ssl_verify_callback);

  671.     SSL_CTX_set_verify_depth(ssl->ctx, depth);

  673.     if (cert->len == 0) {
  674.         return NGX_OK;
  675.     }

  677.     list = sk_X509_NAME_new(ngx_ssl_cmp_x509_name);
  678.     if (list == NULL) {
  679.         return NGX_ERROR;
  680.     }

  682.     store = SSL_CTX_get_cert_store(ssl->ctx);

  684.     if (store == NULL) {
  685.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  686.                       "SSL_CTX_get_cert_store() failed");
  687.         return NGX_ERROR;
  688.     }

  690.     chain = ngx_ssl_cache_fetch(cf, NGX_SSL_CACHE_CA, &err, cert, NULL);
  691.     if (chain == NULL) {
  692.         if (err != NULL) {
  693.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  694.                           "cannot load certificate \"%s\": %s",
  695.                           cert->data, err);
  696.         }

  698.         sk_X509_NAME_pop_free(list, X509_NAME_free);
  699.         return NGX_ERROR;
  700.     }

  702.     n = sk_X509_num(chain);

  704.     for (i = 0; i < n; i++) {
  705.         x509 = sk_X509_value(chain, i);

  707.         if (X509_STORE_add_cert(store, x509) != 1) {

  709.             if (ngx_ssl_cert_already_in_hash()) {
  710.                 continue;
  711.             }

  713.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  714.                           "X509_STORE_add_cert(\"%s\") failed", cert->data);
  715.             sk_X509_NAME_pop_free(list, X509_NAME_free);
  716.             sk_X509_pop_free(chain, X509_free);
  717.             return NGX_ERROR;
  718.         }

  720.         name = X509_get_subject_name(x509);
  721.         if (name == NULL) {
  722.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  723.                           "X509_get_subject_name(\"%s\") failed", cert->data);
  724.             sk_X509_NAME_pop_free(list, X509_NAME_free);
  725.             sk_X509_pop_free(chain, X509_free);
  726.             return NGX_ERROR;
  727.         }

  729.         name = X509_NAME_dup(name);
  730.         if (name == NULL) {
  731.             sk_X509_NAME_pop_free(list, X509_NAME_free);
  732.             sk_X509_pop_free(chain, X509_free);
  733.             return NGX_ERROR;
  734.         }

  736. #ifdef OPENSSL_IS_BORINGSSL
  737.         if (sk_X509_NAME_find(list, NULL, name) > 0) {
  738. #else
  739.         if (sk_X509_NAME_find(list, name) >= 0) {
  740. #endif
  741.             X509_NAME_free(name);
  742.             continue;
  743.         }

  745.         if (sk_X509_NAME_push(list, name) == 0) {
  746.             sk_X509_NAME_pop_free(list, X509_NAME_free);
  747.             sk_X509_pop_free(chain, X509_free);
  748.             X509_NAME_free(name);
  749.             return NGX_ERROR;
  750.         }
  751.     }

  753.     sk_X509_pop_free(chain, X509_free);

  755.     SSL_CTX_set_client_CA_list(ssl->ctx, list);

  757.     return NGX_OK;
  758. }


  761. ngx_int_t
  762. ‌ngx_ssl_trusted_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *cert,
  763.     ngx_int_t depth)
  764. {
  765.     int              i, n;
  766.     char            *err;
  767.     X509            *x509;
  768.     X509_STORE      *store;
  769.     STACK_OF(X509)  *chain;

  771.     SSL_CTX_set_verify(ssl->ctx, SSL_CTX_get_verify_mode(ssl->ctx),
  772.                        ngx_ssl_verify_callback);

  774.     SSL_CTX_set_verify_depth(ssl->ctx, depth);

  776.     if (cert->len == 0) {
  777.         return NGX_OK;
  778.     }

  780.     store = SSL_CTX_get_cert_store(ssl->ctx);

  782.     if (store == NULL) {
  783.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  784.                       "SSL_CTX_get_cert_store() failed");
  785.         return NGX_ERROR;
  786.     }

  788.     chain = ngx_ssl_cache_fetch(cf, NGX_SSL_CACHE_CA, &err, cert, NULL);
  789.     if (chain == NULL) {
  790.         if (err != NULL) {
  791.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  792.                           "cannot load certificate \"%s\": %s",
  793.                           cert->data, err);
  794.         }

  796.         return NGX_ERROR;
  797.     }

  799.     n = sk_X509_num(chain);

  801.     for (i = 0; i < n; i++) {
  802.         x509 = sk_X509_value(chain, i);

  804.         if (X509_STORE_add_cert(store, x509) != 1) {

  806.             if (ngx_ssl_cert_already_in_hash()) {
  807.                 continue;
  808.             }

  810.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  811.                           "X509_STORE_add_cert(\"%s\") failed", cert->data);
  812.             sk_X509_pop_free(chain, X509_free);
  813.             return NGX_ERROR;
  814.         }
  815.     }

  817.     sk_X509_pop_free(chain, X509_free);

  819.     return NGX_OK;
  820. }


  823. ngx_int_t
  824. ‌ngx_ssl_crl(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *crl)
  825. {
  826.     int                  n, i;
  827.     char                *err;
  828.     X509_CRL            *x509;
  829.     X509_STORE          *store;
  830.     STACK_OF(X509_CRL)  *chain;

  832.     if (crl->len == 0) {
  833.         return NGX_OK;
  834.     }

  836.     store = SSL_CTX_get_cert_store(ssl->ctx);

  838.     if (store == NULL) {
  839.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  840.                       "SSL_CTX_get_cert_store() failed");
  841.         return NGX_ERROR;
  842.     }

  844.     chain = ngx_ssl_cache_fetch(cf, NGX_SSL_CACHE_CRL, &err, crl, NULL);
  845.     if (chain == NULL) {
  846.         if (err != NULL) {
  847.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  848.                           "cannot load CRL \"%s\": %s", crl->data, err);
  849.         }

  851.         return NGX_ERROR;
  852.     }

  854.     n = sk_X509_CRL_num(chain);

  856.     for (i = 0; i < n; i++) {
  857.         x509 = sk_X509_CRL_value(chain, i);

  859.         if (X509_STORE_add_crl(store, x509) != 1) {

  861.             if (ngx_ssl_cert_already_in_hash()) {
  862.                 continue;
  863.             }

  865.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  866.                           "X509_STORE_add_crl(\"%s\") failed", crl->data);
  867.             sk_X509_CRL_pop_free(chain, X509_CRL_free);
  868.             return NGX_ERROR;
  869.         }
  870.     }

  872.     sk_X509_CRL_pop_free(chain, X509_CRL_free);

  874.     X509_STORE_set_flags(store,
  875.                          X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);

  877.     return NGX_OK;
  878. }


  881. static ngx_inline ngx_int_t
  882. ‌ngx_ssl_cert_already_in_hash(void)
  883. {
  884. #if !(OPENSSL_VERSION_NUMBER >= 0x1010009fL \
  885.       || LIBRESSL_VERSION_NUMBER >= 0x3050000fL)
  886.     u_long  error;

  888.     /*
  889.      * OpenSSL prior to 1.1.0i doesn't ignore duplicate certificate entries,
  890.      * see https://github.com/openssl/openssl/commit/c0452248
  891.      */

  893.     error = ERR_peek_last_error();

  895.     if (ERR_GET_LIB(error) == ERR_LIB_X509
  896.         && ERR_GET_REASON(error) == X509_R_CERT_ALREADY_IN_HASH_TABLE)
  897.     {
  898.         ERR_clear_error();
  899.         return 1;
  900.     }
  901. #endif

  903.     return 0;
  904. }


  907. static int
  908. ‌ngx_ssl_verify_callback(int ok, X509_STORE_CTX *x509_store)
  909. {
  910. #if (NGX_DEBUG)
  911.     char              *subject, *issuer;
  912.     int                err, depth;
  913.     X509              *cert;
  914.     X509_NAME         *sname, *iname;
  915.     ngx_connection_t  *c;
  916.     ngx_ssl_conn_t    *ssl_conn;

  918.     ssl_conn = X509_STORE_CTX_get_ex_data(x509_store,
  919.                                           SSL_get_ex_data_X509_STORE_CTX_idx());

  921.     c = ngx_ssl_get_connection(ssl_conn);

  923.     if (!(c->log->log_level & NGX_LOG_DEBUG_EVENT)) {
  924.         return 1;
  925.     }

  927.     cert = X509_STORE_CTX_get_current_cert(x509_store);
  928.     err = X509_STORE_CTX_get_error(x509_store);
  929.     depth = X509_STORE_CTX_get_error_depth(x509_store);

  931.     sname = X509_get_subject_name(cert);

  933.     if (sname) {
  934.         subject = X509_NAME_oneline(sname, NULL, 0);
  935.         if (subject == NULL) {
  936.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  937.                           "X509_NAME_oneline() failed");
  938.         }

  940.     } else {
  941.         subject = NULL;
  942.     }

  944.     iname = X509_get_issuer_name(cert);

  946.     if (iname) {
  947.         issuer = X509_NAME_oneline(iname, NULL, 0);
  948.         if (issuer == NULL) {
  949.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  950.                           "X509_NAME_oneline() failed");
  951.         }

  953.     } else {
  954.         issuer = NULL;
  955.     }

  957.     ngx_log_debug5(NGX_LOG_DEBUG_EVENT, c->log, 0,
  958.                    "verify:%d, error:%d, depth:%d, "
  959.                    "subject:\"%s\", issuer:\"%s\"",
  960.                    ok, err, depth,
  961.                    subject ? subject : "(none)",
  962.                    issuer ? issuer : "(none)");

  964.     if (subject) {
  965.         OPENSSL_free(subject);
  966.     }

  968.     if (issuer) {
  969.         OPENSSL_free(issuer);
  970.     }
  971. #endif

  973.     return 1;
  974. }


  977. static void
  978. ‌ngx_ssl_info_callback(const ngx_ssl_conn_t *ssl_conn, int where, int ret)
  979. {
  980.     BIO               *rbio, *wbio;
  981.     ngx_connection_t  *c;

  983. #if (!defined SSL_OP_NO_RENEGOTIATION                                         \
  984.      && !defined SSL_OP_NO_CLIENT_RENEGOTIATION)

  986.     if ((where & SSL_CB_HANDSHAKE_START)
  987.         && SSL_is_server((ngx_ssl_conn_t *) ssl_conn))
  988.     {
  989.         c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn);

  991.         if (c->ssl->handshaked) {
  992.             c->ssl->renegotiation = 1;
  993.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL renegotiation");
  994.         }
  995.     }

  997. #endif

  999. #ifdef TLS1_3_VERSION

  1001.     if ((where & SSL_CB_ACCEPT_LOOP) == SSL_CB_ACCEPT_LOOP
  1002.         && SSL_version(ssl_conn) == TLS1_3_VERSION)
  1003.     {
  1004.         time_t        now, time, timeout, conf_timeout;
  1005.         SSL_SESSION  *sess;

  1007.         /*
  1008.          * OpenSSL with TLSv1.3 updates the session creation time on
  1009.          * session resumption and keeps the session timeout unmodified,
  1010.          * making it possible to maintain the session forever, bypassing
  1011.          * client certificate expiration and revocation.  To make sure
  1012.          * session timeouts are actually used, we now update the session
  1013.          * creation time and reduce the session timeout accordingly.
  1014.          *
  1015.          * BoringSSL with TLSv1.3 ignores configured session timeouts
  1016.          * and uses a hardcoded timeout instead, 7 days.  So we update
  1017.          * session timeout to the configured value as soon as a session
  1018.          * is created.
  1019.          */

  1021.         c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn);
  1022.         sess = SSL_get0_session(ssl_conn);

  1024.         if (!c->ssl->session_timeout_set && sess) {
  1025.             c->ssl->session_timeout_set = 1;

  1027.             now = ngx_time();
  1028.             time = SSL_SESSION_get_time(sess);
  1029.             timeout = SSL_SESSION_get_timeout(sess);
  1030.             conf_timeout = SSL_CTX_get_timeout(c->ssl->session_ctx);

  1032.             timeout = ngx_min(timeout, conf_timeout);

  1034.             if (now - time >= timeout) {
  1035.                 SSL_SESSION_set1_id_context(sess, (unsigned char *) "", 0);

  1037.             } else {
  1038.                 SSL_SESSION_set_time(sess, now);
  1039.                 SSL_SESSION_set_timeout(sess, timeout - (now - time));
  1040.             }
  1041.         }
  1042.     }

  1044. #endif

  1046.     if ((where & SSL_CB_ACCEPT_LOOP) == SSL_CB_ACCEPT_LOOP) {
  1047.         c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn);

  1049.         if (!c->ssl->handshake_buffer_set) {
  1050.             /*
  1051.              * By default OpenSSL uses 4k buffer during a handshake,
  1052.              * which is too low for long certificate chains and might
  1053.              * result in extra round-trips.
  1054.              *
  1055.              * To adjust a buffer size we detect that buffering was added
  1056.              * to write side of the connection by comparing rbio and wbio.
  1057.              * If they are different, we assume that it's due to buffering
  1058.              * added to wbio, and set buffer size.
  1059.              */

  1061.             rbio = SSL_get_rbio(ssl_conn);
  1062.             wbio = SSL_get_wbio(ssl_conn);

  1064.             if (rbio != wbio) {
  1065.                 (void) BIO_set_write_buffer_size(wbio, NGX_SSL_BUFSIZE);
  1066.                 c->ssl->handshake_buffer_set = 1;
  1067.             }
  1068.         }
  1069.     }
  1070. }


  1073. static int
  1074. ‌ngx_ssl_cmp_x509_name(const X509_NAME *const *a, const X509_NAME *const *b)
  1075. {
  1076.     return (X509_NAME_cmp(*a, *b));
  1077. }


  1080. ngx_array_t *
  1081. ‌ngx_ssl_read_password_file(ngx_conf_t *cf, ngx_str_t *file)
  1082. {
  1083.     u_char              *p, *last, *end;
  1084.     size_t               len;
  1085.     ssize_t              n;
  1086.     ngx_fd_t             fd;
  1087.     ngx_str_t           *pwd;
  1088.     ngx_array_t         *passwords;
  1089.     ngx_pool_cleanup_t  *cln;
  1090.     u_char               buf[NGX_SSL_PASSWORD_BUFFER_SIZE];

  1092.     if (ngx_conf_full_name(cf->cycle, file, 1) != NGX_OK) {
  1093.         return NULL;
  1094.     }

  1096.     passwords = ngx_array_create(cf->temp_pool, 4, sizeof(ngx_str_t));
  1097.     if (passwords == NULL) {
  1098.         return NULL;
  1099.     }

  1101.     cln = ngx_pool_cleanup_add(cf->temp_pool, 0);
  1102.     if (cln == NULL) {
  1103.         return NULL;
  1104.     }

  1106.     cln->handler = ngx_ssl_passwords_cleanup;
  1107.     cln->data = passwords;

  1109.     fd = ngx_open_file(file->data, NGX_FILE_RDONLY, NGX_FILE_OPEN, 0);

  1111.     if (fd == NGX_INVALID_FILE) {
  1112.         ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  1113.                            ngx_open_file_n " \"%s\" failed", file->data);
  1114.         return NULL;
  1115.     }

  1117.     len = 0;
  1118.     last = buf;

  1120.     do {
  1121.         n = ngx_read_fd(fd, last, NGX_SSL_PASSWORD_BUFFER_SIZE - len);

  1123.         if (n == -1) {
  1124.             ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  1125.                                ngx_read_fd_n " \"%s\" failed", file->data);
  1126.             passwords = NULL;
  1127.             goto cleanup;
  1128.         }

  1130.         end = last + n;

  1132.         if (len && n == 0) {
  1133.             *end++ = LF;
  1134.         }

  1136.         p = buf;

  1138.         for ( ;; ) {
  1139.             last = ngx_strlchr(last, end, LF);

  1141.             if (last == NULL) {
  1142.                 break;
  1143.             }

  1145.             len = last++ - p;

  1147.             if (len && p[len - 1] == CR) {
  1148.                 len--;
  1149.             }

  1151.             if (len) {
  1152.                 pwd = ngx_array_push(passwords);
  1153.                 if (pwd == NULL) {
  1154.                     passwords = NULL;
  1155.                     goto cleanup;
  1156.                 }

  1158.                 pwd->len = len;
  1159.                 pwd->data = ngx_pnalloc(cf->temp_pool, len);

  1161.                 if (pwd->data == NULL) {
  1162.                     passwords->nelts--;
  1163.                     passwords = NULL;
  1164.                     goto cleanup;
  1165.                 }

  1167.                 ngx_memcpy(pwd->data, p, len);
  1168.             }

  1170.             p = last;
  1171.         }

  1173.         len = end - p;

  1175.         if (len == NGX_SSL_PASSWORD_BUFFER_SIZE) {
  1176.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1177.                                "too long line in \"%s\"", file->data);
  1178.             passwords = NULL;
  1179.             goto cleanup;
  1180.         }

  1182.         ngx_memmove(buf, p, len);
  1183.         last = buf + len;

  1185.     } while (n != 0);

  1187.     if (passwords->nelts == 0) {
  1188.         pwd = ngx_array_push(passwords);
  1189.         if (pwd == NULL) {
  1190.             passwords = NULL;
  1191.             goto cleanup;
  1192.         }

  1194.         ngx_memzero(pwd, sizeof(ngx_str_t));
  1195.     }

  1197. cleanup:

  1199.     if (ngx_close_file(fd) == NGX_FILE_ERROR) {
  1200.         ngx_conf_log_error(NGX_LOG_ALERT, cf, ngx_errno,
  1201.                            ngx_close_file_n " \"%s\" failed", file->data);
  1202.     }

  1204.     ngx_explicit_memzero(buf, NGX_SSL_PASSWORD_BUFFER_SIZE);

  1206.     return passwords;
  1207. }


  1210. ngx_array_t *
  1211. ‌ngx_ssl_preserve_passwords(ngx_conf_t *cf, ngx_array_t *passwords)
  1212. {
  1213.     ngx_str_t           *opwd, *pwd;
  1214.     ngx_uint_t           i;
  1215.     ngx_array_t         *pwds;
  1216.     ngx_pool_cleanup_t  *cln;
  1217.     static ngx_array_t   empty_passwords;

  1219.     if (passwords == NULL) {

  1221.         /*
  1222.          * If there are no passwords, an empty array is used
  1223.          * to make sure OpenSSL's default password callback
  1224.          * won't block on reading from stdin.
  1225.          */

  1227.         return &empty_passwords;
  1228.     }

  1230.     /*
  1231.      * Passwords are normally allocated from the temporary pool
  1232.      * and cleared after parsing configuration.  To be used at
  1233.      * runtime they have to be copied to the configuration pool.
  1234.      */

  1236.     pwds = ngx_array_create(cf->pool, passwords->nelts, sizeof(ngx_str_t));
  1237.     if (pwds == NULL) {
  1238.         return NULL;
  1239.     }

  1241.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  1242.     if (cln == NULL) {
  1243.         return NULL;
  1244.     }

  1246.     cln->handler = ngx_ssl_passwords_cleanup;
  1247.     cln->data = pwds;

  1249.     opwd = passwords->elts;

  1251.     for (i = 0; i < passwords->nelts; i++) {

  1253.         pwd = ngx_array_push(pwds);
  1254.         if (pwd == NULL) {
  1255.             return NULL;
  1256.         }

  1258.         pwd->len = opwd[i].len;
  1259.         pwd->data = ngx_pnalloc(cf->pool, pwd->len);

  1261.         if (pwd->data == NULL) {
  1262.             pwds->nelts--;
  1263.             return NULL;
  1264.         }

  1266.         ngx_memcpy(pwd->data, opwd[i].data, opwd[i].len);
  1267.     }

  1269.     return pwds;
  1270. }


  1273. static void
  1274. ‌ngx_ssl_passwords_cleanup(void *data)
  1275. {
  1276.     ngx_array_t *passwords = data;

  1278.     ngx_str_t   *pwd;
  1279.     ngx_uint_t   i;

  1281.     pwd = passwords->elts;

  1283.     for (i = 0; i < passwords->nelts; i++) {
  1284.         ngx_explicit_memzero(pwd[i].data, pwd[i].len);
  1285.     }
  1286. }


  1289. ngx_int_t
  1290. ‌ngx_ssl_dhparam(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *file)
  1291. {
  1292.     BIO  *bio;

  1294.     if (file->len == 0) {
  1295.         return NGX_OK;
  1296.     }

  1298.     if (ngx_conf_full_name(cf->cycle, file, 1) != NGX_OK) {
  1299.         return NGX_ERROR;
  1300.     }

  1302.     bio = BIO_new_file((char *) file->data, "r");
  1303.     if (bio == NULL) {
  1304.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1305.                       "BIO_new_file(\"%s\") failed", file->data);
  1306.         return NGX_ERROR;
  1307.     }

  1309. #ifdef SSL_CTX_set_tmp_dh
  1310.     {
  1311.     DH  *dh;

  1313.     dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
  1314.     if (dh == NULL) {
  1315.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1316.                       "PEM_read_bio_DHparams(\"%s\") failed", file->data);
  1317.         BIO_free(bio);
  1318.         return NGX_ERROR;
  1319.     }

  1321.     if (SSL_CTX_set_tmp_dh(ssl->ctx, dh) != 1) {
  1322.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1323.                       "SSL_CTX_set_tmp_dh(\"%s\") failed", file->data);
  1324.         DH_free(dh);
  1325.         BIO_free(bio);
  1326.         return NGX_ERROR;
  1327.     }

  1329.     DH_free(dh);
  1330.     }
  1331. #else
  1332.     {
  1333.     EVP_PKEY  *dh;

  1335.     /*
  1336.      * PEM_read_bio_DHparams() and SSL_CTX_set_tmp_dh()
  1337.      * are deprecated in OpenSSL 3.0
  1338.      */

  1340.     dh = PEM_read_bio_Parameters(bio, NULL);
  1341.     if (dh == NULL) {
  1342.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1343.                       "PEM_read_bio_Parameters(\"%s\") failed", file->data);
  1344.         BIO_free(bio);
  1345.         return NGX_ERROR;
  1346.     }

  1348.     if (SSL_CTX_set0_tmp_dh_pkey(ssl->ctx, dh) != 1) {
  1349.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1350.                       "SSL_CTX_set0_tmp_dh_pkey(\"%s\") failed", file->data);
  1351. #if (OPENSSL_VERSION_NUMBER >= 0x3000001fL)
  1352.         EVP_PKEY_free(dh);
  1353. #endif
  1354.         BIO_free(bio);
  1355.         return NGX_ERROR;
  1356.     }
  1357.     }
  1358. #endif

  1360.     BIO_free(bio);

  1362.     return NGX_OK;
  1363. }


  1366. ngx_int_t
  1367. ‌ngx_ssl_ecdh_curve(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *name)
  1368. {
  1369. #ifndef OPENSSL_NO_ECDH

  1371.     /*
  1372.      * Elliptic-Curve Diffie-Hellman parameters are either "named curves"
  1373.      * from RFC 4492 section 5.1.1, or explicitly described curves over
  1374.      * binary fields.  OpenSSL only supports the "named curves", which provide
  1375.      * maximum interoperability.
  1376.      */

  1378. #if (defined SSL_CTX_set1_curves_list || defined SSL_CTRL_SET_CURVES_LIST)

  1380.     /*
  1381.      * OpenSSL 1.0.2+ allows configuring a curve list instead of a single
  1382.      * curve previously supported.  By default an internal list is used,
  1383.      * with prime256v1 being preferred by server in OpenSSL 1.0.2b+
  1384.      * and X25519 in OpenSSL 1.1.0+.
  1385.      *
  1386.      * By default a curve preferred by the client will be used for
  1387.      * key exchange.  The SSL_OP_CIPHER_SERVER_PREFERENCE option can
  1388.      * be used to prefer server curves instead, similar to what it
  1389.      * does for ciphers.
  1390.      */

  1392.     SSL_CTX_set_options(ssl->ctx, SSL_OP_SINGLE_ECDH_USE);

  1394. #ifdef SSL_CTRL_SET_ECDH_AUTO
  1395.     /* not needed in OpenSSL 1.1.0+ */
  1396.     (void) SSL_CTX_set_ecdh_auto(ssl->ctx, 1);
  1397. #endif

  1399.     if (ngx_strcmp(name->data, "auto") == 0) {
  1400.         return NGX_OK;
  1401.     }

  1403.     if (SSL_CTX_set1_curves_list(ssl->ctx, (char *) name->data) == 0) {
  1404.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1405.                       "SSL_CTX_set1_curves_list(\"%s\") failed", name->data);
  1406.         return NGX_ERROR;
  1407.     }

  1409. #else

  1411.     int      nid;
  1412.     char    *curve;
  1413.     EC_KEY  *ecdh;

  1415.     if (ngx_strcmp(name->data, "auto") == 0) {
  1416.         curve = "prime256v1";

  1418.     } else {
  1419.         curve = (char *) name->data;
  1420.     }

  1422.     nid = OBJ_sn2nid(curve);
  1423.     if (nid == 0) {
  1424.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1425.                       "OBJ_sn2nid(\"%s\") failed: unknown curve", curve);
  1426.         return NGX_ERROR;
  1427.     }

  1429.     ecdh = EC_KEY_new_by_curve_name(nid);
  1430.     if (ecdh == NULL) {
  1431.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1432.                       "EC_KEY_new_by_curve_name(\"%s\") failed", curve);
  1433.         return NGX_ERROR;
  1434.     }

  1436.     SSL_CTX_set_options(ssl->ctx, SSL_OP_SINGLE_ECDH_USE);

  1438.     SSL_CTX_set_tmp_ecdh(ssl->ctx, ecdh);

  1440.     EC_KEY_free(ecdh);
  1441. #endif
  1442. #endif

  1444.     return NGX_OK;
  1445. }


  1448. ngx_int_t
  1449. ‌ngx_ssl_early_data(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_uint_t enable)
  1450. {
  1451.     if (!enable) {
  1452.         return NGX_OK;
  1453.     }

  1455. #ifdef SSL_ERROR_EARLY_DATA_REJECTED

  1457.     /* BoringSSL */

  1459.     SSL_CTX_set_early_data_enabled(ssl->ctx, 1);

  1461. #elif defined SSL_READ_EARLY_DATA_SUCCESS

  1463.     /* OpenSSL */

  1465.     SSL_CTX_set_max_early_data(ssl->ctx, NGX_SSL_BUFSIZE);

  1467. #else
  1468.     ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  1469.                   "\"ssl_early_data\" is not supported on this platform, "
  1470.                   "ignored");
  1471. #endif

  1473.     return NGX_OK;
  1474. }


  1477. ngx_int_t
  1478. ‌ngx_ssl_conf_commands(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_array_t *commands)
  1479. {
  1480.     if (commands == NULL) {
  1481.         return NGX_OK;
  1482.     }

  1484. #ifdef SSL_CONF_FLAG_FILE
  1485.     {
  1486.     int            type;
  1487.     u_char        *key, *value;
  1488.     ngx_uint_t     i;
  1489.     ngx_keyval_t  *cmd;
  1490.     SSL_CONF_CTX  *cctx;

  1492.     cctx = SSL_CONF_CTX_new();
  1493.     if (cctx == NULL) {
  1494.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1495.                       "SSL_CONF_CTX_new() failed");
  1496.         return NGX_ERROR;
  1497.     }

  1499.     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_FILE);
  1500.     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_SERVER);
  1501.     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CLIENT);
  1502.     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CERTIFICATE);
  1503.     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_SHOW_ERRORS);

  1505.     SSL_CONF_CTX_set_ssl_ctx(cctx, ssl->ctx);

  1507.     cmd = commands->elts;
  1508.     for (i = 0; i < commands->nelts; i++) {

  1510.         key = cmd[i].key.data;
  1511.         type = SSL_CONF_cmd_value_type(cctx, (char *) key);

  1513.         if (type == SSL_CONF_TYPE_FILE || type == SSL_CONF_TYPE_DIR) {
  1514.             if (ngx_conf_full_name(cf->cycle, &cmd[i].value, 1) != NGX_OK) {
  1515.                 SSL_CONF_CTX_free(cctx);
  1516.                 return NGX_ERROR;
  1517.             }
  1518.         }

  1520.         value = cmd[i].value.data;

  1522.         if (SSL_CONF_cmd(cctx, (char *) key, (char *) value) <= 0) {
  1523.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1524.                           "SSL_CONF_cmd(\"%s\", \"%s\") failed", key, value);
  1525.             SSL_CONF_CTX_free(cctx);
  1526.             return NGX_ERROR;
  1527.         }
  1528.     }

  1530.     if (SSL_CONF_CTX_finish(cctx) != 1) {
  1531.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1532.                       "SSL_CONF_finish() failed");
  1533.         SSL_CONF_CTX_free(cctx);
  1534.         return NGX_ERROR;
  1535.     }

  1537.     SSL_CONF_CTX_free(cctx);

  1539.     return NGX_OK;
  1540.     }
  1541. #else
  1542.     ngx_log_error(NGX_LOG_EMERG, ssl->log, 0,
  1543.                   "SSL_CONF_cmd() is not available on this platform");
  1544.     return NGX_ERROR;
  1545. #endif
  1546. }


  1549. ngx_int_t
  1550. ‌ngx_ssl_client_session_cache(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_uint_t enable)
  1551. {
  1552.     if (!enable) {
  1553.         return NGX_OK;
  1554.     }

  1556.     SSL_CTX_set_session_cache_mode(ssl->ctx,
  1557.                                    SSL_SESS_CACHE_CLIENT
  1558.                                    |SSL_SESS_CACHE_NO_INTERNAL);

  1560.     SSL_CTX_sess_set_new_cb(ssl->ctx, ngx_ssl_new_client_session);

  1562.     return NGX_OK;
  1563. }


  1566. static int
  1567. ‌ngx_ssl_new_client_session(ngx_ssl_conn_t *ssl_conn, ngx_ssl_session_t *sess)
  1568. {
  1569.     ngx_connection_t  *c;

  1571.     c = ngx_ssl_get_connection(ssl_conn);

  1573.     if (c->ssl->save_session) {
  1574.         c->ssl->session = sess;

  1576.         c->ssl->save_session(c);

  1578.         c->ssl->session = NULL;
  1579.     }

  1581.     return 0;
  1582. }


  1585. ngx_int_t
  1586. ‌ngx_ssl_create_connection(ngx_ssl_t *ssl, ngx_connection_t *c, ngx_uint_t flags)
  1587. {
  1588.     ngx_ssl_connection_t  *sc;

  1590.     sc = ngx_pcalloc(c->pool, sizeof(ngx_ssl_connection_t));
  1591.     if (sc == NULL) {
  1592.         return NGX_ERROR;
  1593.     }

  1595.     sc->buffer = ((flags & NGX_SSL_BUFFER) != 0);
  1596.     sc->buffer_size = ssl->buffer_size;

  1598.     sc->session_ctx = ssl->ctx;

  1600. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  1601.     if (SSL_CTX_get_max_early_data(ssl->ctx)) {
  1602.         sc->try_early_data = 1;
  1603.     }
  1604. #endif

  1606.     sc->connection = SSL_new(ssl->ctx);

  1608.     if (sc->connection == NULL) {
  1609.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "SSL_new() failed");
  1610.         return NGX_ERROR;
  1611.     }

  1613.     if (SSL_set_fd(sc->connection, c->fd) == 0) {
  1614.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "SSL_set_fd() failed");
  1615.         return NGX_ERROR;
  1616.     }

  1618.     if (flags & NGX_SSL_CLIENT) {
  1619.         SSL_set_connect_state(sc->connection);

  1621.     } else {
  1622.         SSL_set_accept_state(sc->connection);

  1624. #ifdef SSL_OP_NO_RENEGOTIATION
  1625.         SSL_set_options(sc->connection, SSL_OP_NO_RENEGOTIATION);
  1626. #endif
  1627.     }

  1629.     if (SSL_set_ex_data(sc->connection, ngx_ssl_connection_index, c) == 0) {
  1630.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "SSL_set_ex_data() failed");
  1631.         return NGX_ERROR;
  1632.     }

  1634.     c->ssl = sc;

  1636.     return NGX_OK;
  1637. }


  1640. ngx_ssl_session_t *
  1641. ‌ngx_ssl_get_session(ngx_connection_t *c)
  1642. {
  1643. #ifdef TLS1_3_VERSION
  1644.     if (c->ssl->session) {
  1645.         SSL_SESSION_up_ref(c->ssl->session);
  1646.         return c->ssl->session;
  1647.     }
  1648. #endif

  1650.     return SSL_get1_session(c->ssl->connection);
  1651. }


  1654. ngx_ssl_session_t *
  1655. ‌ngx_ssl_get0_session(ngx_connection_t *c)
  1656. {
  1657.     if (c->ssl->session) {
  1658.         return c->ssl->session;
  1659.     }

  1661.     return SSL_get0_session(c->ssl->connection);
  1662. }


  1665. ngx_int_t
  1666. ‌ngx_ssl_set_session(ngx_connection_t *c, ngx_ssl_session_t *session)
  1667. {
  1668.     if (session) {
  1669.         if (SSL_set_session(c->ssl->connection, session) == 0) {
  1670.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "SSL_set_session() failed");
  1671.             return NGX_ERROR;
  1672.         }
  1673.     }

  1675.     return NGX_OK;
  1676. }


  1679. ngx_int_t
  1680. ‌ngx_ssl_handshake(ngx_connection_t *c)
  1681. {
  1682.     int        n, sslerr;
  1683.     ngx_err_t  err;
  1684.     ngx_int_t  rc;

  1686. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  1687.     if (c->ssl->try_early_data) {
  1688.         return ngx_ssl_try_early_data(c);
  1689.     }
  1690. #endif

  1692.     if (c->ssl->in_ocsp) {
  1693.         return ngx_ssl_ocsp_validate(c);
  1694.     }

  1696.     ngx_ssl_clear_error(c->log);

  1698.     n = SSL_do_handshake(c->ssl->connection);

  1700.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_do_handshake: %d", n);

  1702.     if (n == 1) {

  1704.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  1705.             return NGX_ERROR;
  1706.         }

  1708.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  1709.             return NGX_ERROR;
  1710.         }

  1712. #if (NGX_DEBUG)
  1713.         ngx_ssl_handshake_log(c);
  1714. #endif

  1716.         c->recv = ngx_ssl_recv;
  1717.         c->send = ngx_ssl_write;
  1718.         c->recv_chain = ngx_ssl_recv_chain;
  1719.         c->send_chain = ngx_ssl_send_chain;

  1721.         c->read->ready = 1;
  1722.         c->write->ready = 1;

  1724. #if (!defined SSL_OP_NO_RENEGOTIATION                                         \
  1725.      && !defined SSL_OP_NO_CLIENT_RENEGOTIATION                               \
  1726.      && defined SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS                             \
  1727.      && OPENSSL_VERSION_NUMBER < 0x10100000L)

  1729.         /* initial handshake done, disable renegotiation (CVE-2009-3555) */
  1730.         if (c->ssl->connection->s3 && SSL_is_server(c->ssl->connection)) {
  1731.             c->ssl->connection->s3->flags |= SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS;
  1732.         }

  1734. #endif

  1736. #if (defined BIO_get_ktls_send && !NGX_WIN32)

  1738.         if (BIO_get_ktls_send(SSL_get_wbio(c->ssl->connection)) == 1) {
  1739.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  1740.                            "BIO_get_ktls_send(): 1");
  1741.             c->ssl->sendfile = 1;
  1742.         }

  1744. #endif

  1746.         rc = ngx_ssl_ocsp_validate(c);

  1748.         if (rc == NGX_ERROR) {
  1749.             return NGX_ERROR;
  1750.         }

  1752.         if (rc == NGX_AGAIN) {
  1753.             c->read->handler = ngx_ssl_handshake_handler;
  1754.             c->write->handler = ngx_ssl_handshake_handler;
  1755.             return NGX_AGAIN;
  1756.         }

  1758.         c->ssl->handshaked = 1;

  1760.         return NGX_OK;
  1761.     }

  1763.     sslerr = SSL_get_error(c->ssl->connection, n);

  1765.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_get_error: %d", sslerr);

  1767.     if (sslerr == SSL_ERROR_WANT_READ) {
  1768.         c->read->ready = 0;
  1769.         c->read->handler = ngx_ssl_handshake_handler;
  1770.         c->write->handler = ngx_ssl_handshake_handler;

  1772.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  1773.             return NGX_ERROR;
  1774.         }

  1776.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  1777.             return NGX_ERROR;
  1778.         }

  1780.         return NGX_AGAIN;
  1781.     }

  1783.     if (sslerr == SSL_ERROR_WANT_WRITE) {
  1784.         c->write->ready = 0;
  1785.         c->read->handler = ngx_ssl_handshake_handler;
  1786.         c->write->handler = ngx_ssl_handshake_handler;

  1788.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  1789.             return NGX_ERROR;
  1790.         }

  1792.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  1793.             return NGX_ERROR;
  1794.         }

  1796.         return NGX_AGAIN;
  1797.     }

  1799.     err = (sslerr == SSL_ERROR_SYSCALL) ? ngx_errno : 0;

  1801.     c->ssl->no_wait_shutdown = 1;
  1802.     c->ssl->no_send_shutdown = 1;
  1803.     c->read->eof = 1;

  1805.     if (sslerr == SSL_ERROR_ZERO_RETURN || ERR_peek_error() == 0) {
  1806.         ngx_connection_error(c, err,
  1807.                              "peer closed connection in SSL handshake");

  1809.         return NGX_ERROR;
  1810.     }

  1812.     if (c->ssl->handshake_rejected) {
  1813.         ngx_connection_error(c, err, "handshake rejected");
  1814.         ERR_clear_error();

  1816.         return NGX_ERROR;
  1817.     }

  1819.     c->read->error = 1;

  1821.     ngx_ssl_connection_error(c, sslerr, err, "SSL_do_handshake() failed");

  1823.     return NGX_ERROR;
  1824. }


  1827. #ifdef SSL_READ_EARLY_DATA_SUCCESS

  1829. static ngx_int_t
  1830. ‌ngx_ssl_try_early_data(ngx_connection_t *c)
  1831. {
  1832.     int        n, sslerr;
  1833.     u_char     buf;
  1834.     size_t     readbytes;
  1835.     ngx_err_t  err;
  1836.     ngx_int_t  rc;

  1838.     ngx_ssl_clear_error(c->log);

  1840.     readbytes = 0;

  1842.     n = SSL_read_early_data(c->ssl->connection, &buf, 1, &readbytes);

  1844.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  1845.                    "SSL_read_early_data: %d, %uz", n, readbytes);

  1847.     if (n == SSL_READ_EARLY_DATA_FINISH) {
  1848.         c->ssl->try_early_data = 0;
  1849.         return ngx_ssl_handshake(c);
  1850.     }

  1852.     if (n == SSL_READ_EARLY_DATA_SUCCESS) {

  1854.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  1855.             return NGX_ERROR;
  1856.         }

  1858.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  1859.             return NGX_ERROR;
  1860.         }

  1862. #if (NGX_DEBUG)
  1863.         ngx_ssl_handshake_log(c);
  1864. #endif

  1866.         c->ssl->try_early_data = 0;

  1868.         c->ssl->early_buf = buf;
  1869.         c->ssl->early_preread = 1;

  1871.         c->ssl->in_early = 1;

  1873.         c->recv = ngx_ssl_recv;
  1874.         c->send = ngx_ssl_write;
  1875.         c->recv_chain = ngx_ssl_recv_chain;
  1876.         c->send_chain = ngx_ssl_send_chain;

  1878.         c->read->ready = 1;
  1879.         c->write->ready = 1;

  1881. #if (defined BIO_get_ktls_send && !NGX_WIN32)

  1883.         if (BIO_get_ktls_send(SSL_get_wbio(c->ssl->connection)) == 1) {
  1884.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  1885.                            "BIO_get_ktls_send(): 1");
  1886.             c->ssl->sendfile = 1;
  1887.         }

  1889. #endif

  1891.         rc = ngx_ssl_ocsp_validate(c);

  1893.         if (rc == NGX_ERROR) {
  1894.             return NGX_ERROR;
  1895.         }

  1897.         if (rc == NGX_AGAIN) {
  1898.             c->read->handler = ngx_ssl_handshake_handler;
  1899.             c->write->handler = ngx_ssl_handshake_handler;
  1900.             return NGX_AGAIN;
  1901.         }

  1903.         c->ssl->handshaked = 1;

  1905.         return NGX_OK;
  1906.     }

  1908.     /* SSL_READ_EARLY_DATA_ERROR */

  1910.     sslerr = SSL_get_error(c->ssl->connection, n);

  1912.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_get_error: %d", sslerr);

  1914.     if (sslerr == SSL_ERROR_WANT_READ) {
  1915.         c->read->ready = 0;
  1916.         c->read->handler = ngx_ssl_handshake_handler;
  1917.         c->write->handler = ngx_ssl_handshake_handler;

  1919.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  1920.             return NGX_ERROR;
  1921.         }

  1923.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  1924.             return NGX_ERROR;
  1925.         }

  1927.         return NGX_AGAIN;
  1928.     }

  1930.     if (sslerr == SSL_ERROR_WANT_WRITE) {
  1931.         c->write->ready = 0;
  1932.         c->read->handler = ngx_ssl_handshake_handler;
  1933.         c->write->handler = ngx_ssl_handshake_handler;

  1935.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  1936.             return NGX_ERROR;
  1937.         }

  1939.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  1940.             return NGX_ERROR;
  1941.         }

  1943.         return NGX_AGAIN;
  1944.     }

  1946.     err = (sslerr == SSL_ERROR_SYSCALL) ? ngx_errno : 0;

  1948.     c->ssl->no_wait_shutdown = 1;
  1949.     c->ssl->no_send_shutdown = 1;
  1950.     c->read->eof = 1;

  1952.     if (sslerr == SSL_ERROR_ZERO_RETURN || ERR_peek_error() == 0) {
  1953.         ngx_connection_error(c, err,
  1954.                              "peer closed connection in SSL handshake");

  1956.         return NGX_ERROR;
  1957.     }

  1959.     c->read->error = 1;

  1961.     ngx_ssl_connection_error(c, sslerr, err, "SSL_read_early_data() failed");

  1963.     return NGX_ERROR;
  1964. }

  1966. #endif


  1969. #if (NGX_DEBUG)

  1971. void
  1972. ‌ngx_ssl_handshake_log(ngx_connection_t *c)
  1973. {
  1974.     char         buf[129], *s, *d;
  1975. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  1976.     const
  1977. #endif
  1978.     SSL_CIPHER  *cipher;

  1980.     if (!(c->log->log_level & NGX_LOG_DEBUG_EVENT)) {
  1981.         return;
  1982.     }

  1984.     cipher = SSL_get_current_cipher(c->ssl->connection);

  1986.     if (cipher) {
  1987.         SSL_CIPHER_description(cipher, &buf[1], 128);

  1989.         for (s = &buf[1], d = buf; *s; s++) {
  1990.             if (*s == ' ' && *d == ' ') {
  1991.                 continue;
  1992.             }

  1994.             if (*s == LF || *s == CR) {
  1995.                 continue;
  1996.             }

  1998.             *++d = *s;
  1999.         }

  2001.         if (*d != ' ') {
  2002.             d++;
  2003.         }

  2005.         *d = '\0';

  2007.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2008.                        "SSL: %s, cipher: \"%s\"",
  2009.                        SSL_get_version(c->ssl->connection), &buf[1]);

  2011.         if (SSL_session_reused(c->ssl->connection)) {
  2012.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2013.                            "SSL reused session");
  2014.         }

  2016.     } else {
  2017.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2018.                        "SSL no shared ciphers");
  2019.     }
  2020. }

  2022. #endif


  2025. static void
  2026. ‌ngx_ssl_handshake_handler(ngx_event_t *ev)
  2027. {
  2028.     ngx_connection_t  *c;

  2030.     c = ev->data;

  2032.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2033.                    "SSL handshake handler: %d", ev->write);

  2035.     if (ev->timedout) {
  2036.         c->ssl->handler(c);
  2037.         return;
  2038.     }

  2040.     if (ngx_ssl_handshake(c) == NGX_AGAIN) {
  2041.         return;
  2042.     }

  2044.     c->ssl->handler(c);
  2045. }


  2048. ssize_t
  2049. ‌ngx_ssl_recv_chain(ngx_connection_t *c, ngx_chain_t *cl, off_t limit)
  2050. {
  2051.     u_char     *last;
  2052.     ssize_t     n, bytes, size;
  2053.     ngx_buf_t  *b;

  2055.     bytes = 0;

  2057.     b = cl->buf;
  2058.     last = b->last;

  2060.     for ( ;; ) {
  2061.         size = b->end - last;

  2063.         if (limit) {
  2064.             if (bytes >= limit) {
  2065.                 return bytes;
  2066.             }

  2068.             if (bytes + size > limit) {
  2069.                 size = (ssize_t) (limit - bytes);
  2070.             }
  2071.         }

  2073.         n = ngx_ssl_recv(c, last, size);

  2075.         if (n > 0) {
  2076.             last += n;
  2077.             bytes += n;

  2079.             if (!c->read->ready) {
  2080.                 return bytes;
  2081.             }

  2083.             if (last == b->end) {
  2084.                 cl = cl->next;

  2086.                 if (cl == NULL) {
  2087.                     return bytes;
  2088.                 }

  2090.                 b = cl->buf;
  2091.                 last = b->last;
  2092.             }

  2094.             continue;
  2095.         }

  2097.         if (bytes) {

  2099.             if (n == 0 || n == NGX_ERROR) {
  2100.                 c->read->ready = 1;
  2101.             }

  2103.             return bytes;
  2104.         }

  2106.         return n;
  2107.     }
  2108. }


  2111. ssize_t
  2112. ‌ngx_ssl_recv(ngx_connection_t *c, u_char *buf, size_t size)
  2113. {
  2114.     int  n, bytes;

  2116. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  2117.     if (c->ssl->in_early) {
  2118.         return ngx_ssl_recv_early(c, buf, size);
  2119.     }
  2120. #endif

  2122.     if (c->ssl->last == NGX_ERROR) {
  2123.         c->read->ready = 0;
  2124.         c->read->error = 1;
  2125.         return NGX_ERROR;
  2126.     }

  2128.     if (c->ssl->last == NGX_DONE) {
  2129.         c->read->ready = 0;
  2130.         c->read->eof = 1;
  2131.         return 0;
  2132.     }

  2134.     bytes = 0;

  2136.     ngx_ssl_clear_error(c->log);

  2138.     /*
  2139.      * SSL_read() may return data in parts, so try to read
  2140.      * until SSL_read() would return no data
  2141.      */

  2143.     for ( ;; ) {

  2145.         n = SSL_read(c->ssl->connection, buf, size);

  2147.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_read: %d", n);

  2149.         if (n > 0) {
  2150.             bytes += n;
  2151.         }

  2153.         c->ssl->last = ngx_ssl_handle_recv(c, n);

  2155.         if (c->ssl->last == NGX_OK) {

  2157.             size -= n;

  2159.             if (size == 0) {
  2160.                 c->read->ready = 1;

  2162.                 if (c->read->available >= 0) {
  2163.                     c->read->available -= bytes;

  2165.                     /*
  2166.                      * there can be data buffered at SSL layer,
  2167.                      * so we post an event to continue reading on the next
  2168.                      * iteration of the event loop
  2169.                      */

  2171.                     if (c->read->available < 0) {
  2172.                         c->read->available = 0;
  2173.                         c->read->ready = 0;

  2175.                         if (c->read->posted) {
  2176.                             ngx_delete_posted_event(c->read);
  2177.                         }

  2179.                         ngx_post_event(c->read, &ngx_posted_next_events);
  2180.                     }

  2182.                     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2183.                                    "SSL_read: avail:%d", c->read->available);

  2185.                 } else {

  2187. #if (NGX_HAVE_FIONREAD)

  2189.                     if (ngx_socket_nread(c->fd, &c->read->available) == -1) {
  2190.                         c->read->ready = 0;
  2191.                         c->read->error = 1;
  2192.                         ngx_connection_error(c, ngx_socket_errno,
  2193.                                              ngx_socket_nread_n " failed");
  2194.                         return NGX_ERROR;
  2195.                     }

  2197.                     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2198.                                    "SSL_read: avail:%d", c->read->available);

  2200. #endif
  2201.                 }

  2203.                 return bytes;
  2204.             }

  2206.             buf += n;

  2208.             continue;
  2209.         }

  2211.         if (bytes) {
  2212.             if (c->ssl->last != NGX_AGAIN) {
  2213.                 c->read->ready = 1;
  2214.             }

  2216.             return bytes;
  2217.         }

  2219.         switch (c->ssl->last) {

  2221.         case NGX_DONE:
  2222.             c->read->ready = 0;
  2223.             c->read->eof = 1;
  2224.             return 0;

  2226.         case NGX_ERROR:
  2227.             c->read->ready = 0;
  2228.             c->read->error = 1;

  2230.             /* fall through */

  2232.         case NGX_AGAIN:
  2233.             return c->ssl->last;
  2234.         }
  2235.     }
  2236. }


  2239. #ifdef SSL_READ_EARLY_DATA_SUCCESS

  2241. static ssize_t
  2242. ‌ngx_ssl_recv_early(ngx_connection_t *c, u_char *buf, size_t size)
  2243. {
  2244.     int        n, bytes;
  2245.     size_t     readbytes;

  2247.     if (c->ssl->last == NGX_ERROR) {
  2248.         c->read->ready = 0;
  2249.         c->read->error = 1;
  2250.         return NGX_ERROR;
  2251.     }

  2253.     if (c->ssl->last == NGX_DONE) {
  2254.         c->read->ready = 0;
  2255.         c->read->eof = 1;
  2256.         return 0;
  2257.     }

  2259.     bytes = 0;

  2261.     ngx_ssl_clear_error(c->log);

  2263.     if (c->ssl->early_preread) {

  2265.         if (size == 0) {
  2266.             c->read->ready = 0;
  2267.             c->read->eof = 1;
  2268.             return 0;
  2269.         }

  2271.         *buf = c->ssl->early_buf;

  2273.         c->ssl->early_preread = 0;

  2275.         bytes = 1;
  2276.         size -= 1;
  2277.         buf += 1;
  2278.     }

  2280.     if (c->ssl->write_blocked) {
  2281.         return NGX_AGAIN;
  2282.     }

  2284.     /*
  2285.      * SSL_read_early_data() may return data in parts, so try to read
  2286.      * until SSL_read_early_data() would return no data
  2287.      */

  2289.     for ( ;; ) {

  2291.         readbytes = 0;

  2293.         n = SSL_read_early_data(c->ssl->connection, buf, size, &readbytes);

  2295.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2296.                        "SSL_read_early_data: %d, %uz", n, readbytes);

  2298.         if (n == SSL_READ_EARLY_DATA_SUCCESS) {

  2300.             c->ssl->last = ngx_ssl_handle_recv(c, 1);

  2302.             bytes += readbytes;
  2303.             size -= readbytes;

  2305.             if (size == 0) {
  2306.                 c->read->ready = 1;
  2307.                 return bytes;
  2308.             }

  2310.             buf += readbytes;

  2312.             continue;
  2313.         }

  2315.         if (n == SSL_READ_EARLY_DATA_FINISH) {

  2317.             c->ssl->last = ngx_ssl_handle_recv(c, 1);
  2318.             c->ssl->in_early = 0;

  2320.             if (bytes) {
  2321.                 c->read->ready = 1;
  2322.                 return bytes;
  2323.             }

  2325.             return ngx_ssl_recv(c, buf, size);
  2326.         }

  2328.         /* SSL_READ_EARLY_DATA_ERROR */

  2330.         c->ssl->last = ngx_ssl_handle_recv(c, 0);

  2332.         if (bytes) {
  2333.             if (c->ssl->last != NGX_AGAIN) {
  2334.                 c->read->ready = 1;
  2335.             }

  2337.             return bytes;
  2338.         }

  2340.         switch (c->ssl->last) {

  2342.         case NGX_DONE:
  2343.             c->read->ready = 0;
  2344.             c->read->eof = 1;
  2345.             return 0;

  2347.         case NGX_ERROR:
  2348.             c->read->ready = 0;
  2349.             c->read->error = 1;

  2351.             /* fall through */

  2353.         case NGX_AGAIN:
  2354.             return c->ssl->last;
  2355.         }
  2356.     }
  2357. }

  2359. #endif


  2362. static ngx_int_t
  2363. ‌ngx_ssl_handle_recv(ngx_connection_t *c, int n)
  2364. {
  2365.     int        sslerr;
  2366.     ngx_err_t  err;

  2368. #if (!defined SSL_OP_NO_RENEGOTIATION                                         \
  2369.      && !defined SSL_OP_NO_CLIENT_RENEGOTIATION)

  2371.     if (c->ssl->renegotiation) {
  2372.         /*
  2373.          * disable renegotiation (CVE-2009-3555):
  2374.          * OpenSSL (at least up to 0.9.8l) does not handle disabled
  2375.          * renegotiation gracefully, so drop connection here
  2376.          */

  2378.         ngx_log_error(NGX_LOG_NOTICE, c->log, 0, "SSL renegotiation disabled");

  2380.         while (ERR_peek_error()) {
  2381.             ngx_ssl_error(NGX_LOG_DEBUG, c->log, 0,
  2382.                           "ignoring stale global SSL error");
  2383.         }

  2385.         ERR_clear_error();

  2387.         c->ssl->no_wait_shutdown = 1;
  2388.         c->ssl->no_send_shutdown = 1;

  2390.         return NGX_ERROR;
  2391.     }

  2393. #endif

  2395.     if (n > 0) {

  2397.         if (c->ssl->saved_write_handler) {

  2399.             c->write->handler = c->ssl->saved_write_handler;
  2400.             c->ssl->saved_write_handler = NULL;
  2401.             c->write->ready = 1;

  2403.             if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2404.                 return NGX_ERROR;
  2405.             }

  2407.             ngx_post_event(c->write, &ngx_posted_events);
  2408.         }

  2410.         return NGX_OK;
  2411.     }

  2413.     sslerr = SSL_get_error(c->ssl->connection, n);

  2415.     err = (sslerr == SSL_ERROR_SYSCALL) ? ngx_errno : 0;

  2417.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_get_error: %d", sslerr);

  2419.     if (sslerr == SSL_ERROR_WANT_READ) {

  2421.         if (c->ssl->saved_write_handler) {

  2423.             c->write->handler = c->ssl->saved_write_handler;
  2424.             c->ssl->saved_write_handler = NULL;
  2425.             c->write->ready = 1;

  2427.             if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2428.                 return NGX_ERROR;
  2429.             }

  2431.             ngx_post_event(c->write, &ngx_posted_events);
  2432.         }

  2434.         c->read->ready = 0;
  2435.         return NGX_AGAIN;
  2436.     }

  2438.     if (sslerr == SSL_ERROR_WANT_WRITE) {

  2440.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2441.                        "SSL_read: want write");

  2443.         c->write->ready = 0;

  2445.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2446.             return NGX_ERROR;
  2447.         }

  2449.         /*
  2450.          * we do not set the timer because there is already the read event timer
  2451.          */

  2453.         if (c->ssl->saved_write_handler == NULL) {
  2454.             c->ssl->saved_write_handler = c->write->handler;
  2455.             c->write->handler = ngx_ssl_write_handler;
  2456.         }

  2458.         return NGX_AGAIN;
  2459.     }

  2461.     c->ssl->no_wait_shutdown = 1;
  2462.     c->ssl->no_send_shutdown = 1;

  2464.     if (sslerr == SSL_ERROR_ZERO_RETURN || ERR_peek_error() == 0) {
  2465.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2466.                        "peer shutdown SSL cleanly");
  2467.         return NGX_DONE;
  2468.     }

  2470.     ngx_ssl_connection_error(c, sslerr, err, "SSL_read() failed");

  2472.     return NGX_ERROR;
  2473. }


  2476. static void
  2477. ‌ngx_ssl_write_handler(ngx_event_t *wev)
  2478. {
  2479.     ngx_connection_t  *c;

  2481.     c = wev->data;

  2483.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL write handler");

  2485.     c->read->handler(c->read);
  2486. }


  2489. /*
  2490. * OpenSSL has no SSL_writev() so we copy several bufs into our 16K buffer
  2491. * before the SSL_write() call to decrease a SSL overhead.
  2492. *
  2493. * Besides for protocols such as HTTP it is possible to always buffer
  2494. * the output to decrease a SSL overhead some more.
  2495. */

  2497. ngx_chain_t *
  2498. ‌ngx_ssl_send_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
  2499. {
  2500.     int           n;
  2501.     ngx_uint_t    flush;
  2502.     ssize_t       send, size, file_size;
  2503.     ngx_buf_t    *buf;
  2504.     ngx_chain_t  *cl;

  2506.     if (!c->ssl->buffer) {

  2508.         while (in) {
  2509.             if (ngx_buf_special(in->buf)) {
  2510.                 in = in->next;
  2511.                 continue;
  2512.             }

  2514.             n = ngx_ssl_write(c, in->buf->pos, in->buf->last - in->buf->pos);

  2516.             if (n == NGX_ERROR) {
  2517.                 return NGX_CHAIN_ERROR;
  2518.             }

  2520.             if (n == NGX_AGAIN) {
  2521.                 return in;
  2522.             }

  2524.             in->buf->pos += n;

  2526.             if (in->buf->pos == in->buf->last) {
  2527.                 in = in->next;
  2528.             }
  2529.         }

  2531.         return in;
  2532.     }


  2535.     /* the maximum limit size is the maximum int32_t value - the page size */

  2537.     if (limit == 0 || limit > (off_t) (NGX_MAX_INT32_VALUE - ngx_pagesize)) {
  2538.         limit = NGX_MAX_INT32_VALUE - ngx_pagesize;
  2539.     }

  2541.     buf = c->ssl->buf;

  2543.     if (buf == NULL) {
  2544.         buf = ngx_create_temp_buf(c->pool, c->ssl->buffer_size);
  2545.         if (buf == NULL) {
  2546.             return NGX_CHAIN_ERROR;
  2547.         }

  2549.         c->ssl->buf = buf;
  2550.     }

  2552.     if (buf->start == NULL) {
  2553.         buf->start = ngx_palloc(c->pool, c->ssl->buffer_size);
  2554.         if (buf->start == NULL) {
  2555.             return NGX_CHAIN_ERROR;
  2556.         }

  2558.         buf->pos = buf->start;
  2559.         buf->last = buf->start;
  2560.         buf->end = buf->start + c->ssl->buffer_size;
  2561.     }

  2563.     send = buf->last - buf->pos;
  2564.     flush = (in == NULL) ? 1 : buf->flush;

  2566.     for ( ;; ) {

  2568.         while (in && buf->last < buf->end && send < limit) {
  2569.             if (in->buf->last_buf || in->buf->flush) {
  2570.                 flush = 1;
  2571.             }

  2573.             if (ngx_buf_special(in->buf)) {
  2574.                 in = in->next;
  2575.                 continue;
  2576.             }

  2578.             if (in->buf->in_file && c->ssl->sendfile) {
  2579.                 flush = 1;
  2580.                 break;
  2581.             }

  2583.             size = in->buf->last - in->buf->pos;

  2585.             if (size > buf->end - buf->last) {
  2586.                 size = buf->end - buf->last;
  2587.             }

  2589.             if (send + size > limit) {
  2590.                 size = (ssize_t) (limit - send);
  2591.             }

  2593.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2594.                            "SSL buf copy: %z", size);

  2596.             ngx_memcpy(buf->last, in->buf->pos, size);

  2598.             buf->last += size;
  2599.             in->buf->pos += size;
  2600.             send += size;

  2602.             if (in->buf->pos == in->buf->last) {
  2603.                 in = in->next;
  2604.             }
  2605.         }

  2607.         if (!flush && send < limit && buf->last < buf->end) {
  2608.             break;
  2609.         }

  2611.         size = buf->last - buf->pos;

  2613.         if (size == 0) {

  2615.             if (in && in->buf->in_file && send < limit) {

  2617.                 /* coalesce the neighbouring file bufs */

  2619.                 cl = in;
  2620.                 file_size = (size_t) ngx_chain_coalesce_file(&cl, limit - send);

  2622.                 n = ngx_ssl_sendfile(c, in->buf, file_size);

  2624.                 if (n == NGX_ERROR) {
  2625.                     return NGX_CHAIN_ERROR;
  2626.                 }

  2628.                 if (n == NGX_AGAIN) {
  2629.                     break;
  2630.                 }

  2632.                 in = ngx_chain_update_sent(in, n);

  2634.                 send += n;
  2635.                 flush = 0;

  2637.                 continue;
  2638.             }

  2640.             buf->flush = 0;
  2641.             c->buffered &= ~NGX_SSL_BUFFERED;

  2643.             return in;
  2644.         }

  2646.         n = ngx_ssl_write(c, buf->pos, size);

  2648.         if (n == NGX_ERROR) {
  2649.             return NGX_CHAIN_ERROR;
  2650.         }

  2652.         if (n == NGX_AGAIN) {
  2653.             break;
  2654.         }

  2656.         buf->pos += n;

  2658.         if (n < size) {
  2659.             break;
  2660.         }

  2662.         flush = 0;

  2664.         buf->pos = buf->start;
  2665.         buf->last = buf->start;

  2667.         if (in == NULL || send >= limit) {
  2668.             break;
  2669.         }
  2670.     }

  2672.     buf->flush = flush;

  2674.     if (buf->pos < buf->last) {
  2675.         c->buffered |= NGX_SSL_BUFFERED;

  2677.     } else {
  2678.         c->buffered &= ~NGX_SSL_BUFFERED;
  2679.     }

  2681.     return in;
  2682. }


  2685. ssize_t
  2686. ‌ngx_ssl_write(ngx_connection_t *c, u_char *data, size_t size)
  2687. {
  2688.     int        n, sslerr;
  2689.     ngx_err_t  err;

  2691. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  2692.     if (c->ssl->in_early) {
  2693.         return ngx_ssl_write_early(c, data, size);
  2694.     }
  2695. #endif

  2697.     ngx_ssl_clear_error(c->log);

  2699.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL to write: %uz", size);

  2701.     n = SSL_write(c->ssl->connection, data, size);

  2703.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_write: %d", n);

  2705.     if (n > 0) {

  2707.         if (c->ssl->saved_read_handler) {

  2709.             c->read->handler = c->ssl->saved_read_handler;
  2710.             c->ssl->saved_read_handler = NULL;
  2711.             c->read->ready = 1;

  2713.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2714.                 return NGX_ERROR;
  2715.             }

  2717.             ngx_post_event(c->read, &ngx_posted_events);
  2718.         }

  2720.         c->sent += n;

  2722.         return n;
  2723.     }

  2725.     sslerr = SSL_get_error(c->ssl->connection, n);

  2727.     if (sslerr == SSL_ERROR_ZERO_RETURN) {

  2729.         /*
  2730.          * OpenSSL 1.1.1 fails to return SSL_ERROR_SYSCALL if an error
  2731.          * happens during SSL_write() after close_notify alert from the
  2732.          * peer, and returns SSL_ERROR_ZERO_RETURN instead,
  2733.          * https://git.openssl.org/?p=openssl.git;a=commitdiff;h=8051ab2
  2734.          */

  2736.         sslerr = SSL_ERROR_SYSCALL;
  2737.     }

  2739.     err = (sslerr == SSL_ERROR_SYSCALL) ? ngx_errno : 0;

  2741.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_get_error: %d", sslerr);

  2743.     if (sslerr == SSL_ERROR_WANT_WRITE) {

  2745.         if (c->ssl->saved_read_handler) {

  2747.             c->read->handler = c->ssl->saved_read_handler;
  2748.             c->ssl->saved_read_handler = NULL;
  2749.             c->read->ready = 1;

  2751.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2752.                 return NGX_ERROR;
  2753.             }

  2755.             ngx_post_event(c->read, &ngx_posted_events);
  2756.         }

  2758.         c->write->ready = 0;
  2759.         return NGX_AGAIN;
  2760.     }

  2762.     if (sslerr == SSL_ERROR_WANT_READ) {

  2764.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2765.                        "SSL_write: want read");

  2767.         c->read->ready = 0;

  2769.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2770.             return NGX_ERROR;
  2771.         }

  2773.         /*
  2774.          * we do not set the timer because there is already
  2775.          * the write event timer
  2776.          */

  2778.         if (c->ssl->saved_read_handler == NULL) {
  2779.             c->ssl->saved_read_handler = c->read->handler;
  2780.             c->read->handler = ngx_ssl_read_handler;
  2781.         }

  2783.         return NGX_AGAIN;
  2784.     }

  2786.     c->ssl->no_wait_shutdown = 1;
  2787.     c->ssl->no_send_shutdown = 1;
  2788.     c->write->error = 1;

  2790.     ngx_ssl_connection_error(c, sslerr, err, "SSL_write() failed");

  2792.     return NGX_ERROR;
  2793. }


  2796. #ifdef SSL_READ_EARLY_DATA_SUCCESS

  2798. static ssize_t
  2799. ‌ngx_ssl_write_early(ngx_connection_t *c, u_char *data, size_t size)
  2800. {
  2801.     int        n, sslerr;
  2802.     size_t     written;
  2803.     ngx_err_t  err;

  2805.     ngx_ssl_clear_error(c->log);

  2807.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL to write: %uz", size);

  2809.     written = 0;

  2811.     n = SSL_write_early_data(c->ssl->connection, data, size, &written);

  2813.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2814.                    "SSL_write_early_data: %d, %uz", n, written);

  2816.     if (n > 0) {

  2818.         if (c->ssl->saved_read_handler) {

  2820.             c->read->handler = c->ssl->saved_read_handler;
  2821.             c->ssl->saved_read_handler = NULL;
  2822.             c->read->ready = 1;

  2824.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2825.                 return NGX_ERROR;
  2826.             }

  2828.             ngx_post_event(c->read, &ngx_posted_events);
  2829.         }

  2831.         if (c->ssl->write_blocked) {
  2832.             c->ssl->write_blocked = 0;
  2833.             ngx_post_event(c->read, &ngx_posted_events);
  2834.         }

  2836.         c->sent += written;

  2838.         return written;
  2839.     }

  2841.     sslerr = SSL_get_error(c->ssl->connection, n);

  2843.     err = (sslerr == SSL_ERROR_SYSCALL) ? ngx_errno : 0;

  2845.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_get_error: %d", sslerr);

  2847.     if (sslerr == SSL_ERROR_WANT_WRITE) {

  2849.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2850.                        "SSL_write_early_data: want write");

  2852.         if (c->ssl->saved_read_handler) {

  2854.             c->read->handler = c->ssl->saved_read_handler;
  2855.             c->ssl->saved_read_handler = NULL;
  2856.             c->read->ready = 1;

  2858.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2859.                 return NGX_ERROR;
  2860.             }

  2862.             ngx_post_event(c->read, &ngx_posted_events);
  2863.         }

  2865.         /*
  2866.          * OpenSSL 1.1.1a fails to handle SSL_read_early_data()
  2867.          * if an SSL_write_early_data() call blocked on writing,
  2868.          * see https://github.com/openssl/openssl/issues/7757
  2869.          */

  2871.         c->ssl->write_blocked = 1;

  2873.         c->write->ready = 0;
  2874.         return NGX_AGAIN;
  2875.     }

  2877.     if (sslerr == SSL_ERROR_WANT_READ) {

  2879.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2880.                        "SSL_write_early_data: want read");

  2882.         c->read->ready = 0;

  2884.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2885.             return NGX_ERROR;
  2886.         }

  2888.         /*
  2889.          * we do not set the timer because there is already
  2890.          * the write event timer
  2891.          */

  2893.         if (c->ssl->saved_read_handler == NULL) {
  2894.             c->ssl->saved_read_handler = c->read->handler;
  2895.             c->read->handler = ngx_ssl_read_handler;
  2896.         }

  2898.         return NGX_AGAIN;
  2899.     }

  2901.     c->ssl->no_wait_shutdown = 1;
  2902.     c->ssl->no_send_shutdown = 1;
  2903.     c->write->error = 1;

  2905.     ngx_ssl_connection_error(c, sslerr, err, "SSL_write_early_data() failed");

  2907.     return NGX_ERROR;
  2908. }

  2910. #endif


  2913. static ssize_t
  2914. ‌ngx_ssl_sendfile(ngx_connection_t *c, ngx_buf_t *file, size_t size)
  2915. {
  2916. #if (defined BIO_get_ktls_send && !NGX_WIN32)

  2918.     int        sslerr, flags;
  2919.     ssize_t    n;
  2920.     ngx_err_t  err;

  2922.     ngx_ssl_clear_error(c->log);

  2924.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2925.                    "SSL to sendfile: @%O %uz",
  2926.                    file->file_pos, size);

  2928.     ngx_set_errno(0);

  2930. #if (NGX_HAVE_SENDFILE_NODISKIO)

  2932.     flags = (c->busy_count <= 2) ? SF_NODISKIO : 0;

  2934.     if (file->file->directio) {
  2935.         flags |= SF_NOCACHE;
  2936.     }

  2938. #else
  2939.     flags = 0;
  2940. #endif

  2942.     n = SSL_sendfile(c->ssl->connection, file->file->fd, file->file_pos,
  2943.                      size, flags);

  2945.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_sendfile: %z", n);

  2947.     if (n > 0) {

  2949.         if (c->ssl->saved_read_handler) {

  2951.             c->read->handler = c->ssl->saved_read_handler;
  2952.             c->ssl->saved_read_handler = NULL;
  2953.             c->read->ready = 1;

  2955.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2956.                 return NGX_ERROR;
  2957.             }

  2959.             ngx_post_event(c->read, &ngx_posted_events);
  2960.         }

  2962. #if (NGX_HAVE_SENDFILE_NODISKIO)
  2963.         c->busy_count = 0;
  2964. #endif

  2966.         c->sent += n;

  2968.         return n;
  2969.     }

  2971.     if (n == 0) {

  2973.         /*
  2974.          * if sendfile returns zero, then someone has truncated the file,
  2975.          * so the offset became beyond the end of the file
  2976.          */

  2978.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2979.                       "SSL_sendfile() reported that \"%s\" was truncated at %O",
  2980.                       file->file->name.data, file->file_pos);

  2982.         return NGX_ERROR;
  2983.     }

  2985.     sslerr = SSL_get_error(c->ssl->connection, n);

  2987.     if (sslerr == SSL_ERROR_ZERO_RETURN) {

  2989.         /*
  2990.          * OpenSSL fails to return SSL_ERROR_SYSCALL if an error
  2991.          * happens during writing after close_notify alert from the
  2992.          * peer, and returns SSL_ERROR_ZERO_RETURN instead
  2993.          */

  2995.         sslerr = SSL_ERROR_SYSCALL;
  2996.     }

  2998.     if (sslerr == SSL_ERROR_SSL
  2999.         && ERR_GET_REASON(ERR_peek_error()) == SSL_R_UNINITIALIZED
  3000.         && ngx_errno != 0)
  3001.     {
  3002.         /*
  3003.          * OpenSSL fails to return SSL_ERROR_SYSCALL if an error
  3004.          * happens in sendfile(), and returns SSL_ERROR_SSL with
  3005.          * SSL_R_UNINITIALIZED reason instead
  3006.          */

  3008.         sslerr = SSL_ERROR_SYSCALL;
  3009.     }

  3011.     err = (sslerr == SSL_ERROR_SYSCALL) ? ngx_errno : 0;

  3013.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_get_error: %d", sslerr);

  3015.     if (sslerr == SSL_ERROR_WANT_WRITE) {

  3017.         if (c->ssl->saved_read_handler) {

  3019.             c->read->handler = c->ssl->saved_read_handler;
  3020.             c->ssl->saved_read_handler = NULL;
  3021.             c->read->ready = 1;

  3023.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3024.                 return NGX_ERROR;
  3025.             }

  3027.             ngx_post_event(c->read, &ngx_posted_events);
  3028.         }

  3030. #if (NGX_HAVE_SENDFILE_NODISKIO)

  3032.         if (ngx_errno == EBUSY) {
  3033.             c->busy_count++;

  3035.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  3036.                            "SSL_sendfile() busy, count:%d", c->busy_count);

  3038.             if (c->write->posted) {
  3039.                 ngx_delete_posted_event(c->write);
  3040.             }

  3042.             ngx_post_event(c->write, &ngx_posted_next_events);
  3043.         }

  3045. #endif

  3047.         c->write->ready = 0;
  3048.         return NGX_AGAIN;
  3049.     }

  3051.     if (sslerr == SSL_ERROR_WANT_READ) {

  3053.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  3054.                        "SSL_sendfile: want read");

  3056.         c->read->ready = 0;

  3058.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3059.             return NGX_ERROR;
  3060.         }

  3062.         /*
  3063.          * we do not set the timer because there is already
  3064.          * the write event timer
  3065.          */

  3067.         if (c->ssl->saved_read_handler == NULL) {
  3068.             c->ssl->saved_read_handler = c->read->handler;
  3069.             c->read->handler = ngx_ssl_read_handler;
  3070.         }

  3072.         return NGX_AGAIN;
  3073.     }

  3075.     c->ssl->no_wait_shutdown = 1;
  3076.     c->ssl->no_send_shutdown = 1;
  3077.     c->write->error = 1;

  3079.     ngx_ssl_connection_error(c, sslerr, err, "SSL_sendfile() failed");

  3081. #else
  3082.     ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  3083.                   "SSL_sendfile() not available");
  3084. #endif

  3086.     return NGX_ERROR;
  3087. }


  3090. static void
  3091. ‌ngx_ssl_read_handler(ngx_event_t *rev)
  3092. {
  3093.     ngx_connection_t  *c;

  3095.     c = rev->data;

  3097.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL read handler");

  3099.     c->write->handler(c->write);
  3100. }


  3103. void
  3104. ‌ngx_ssl_free_buffer(ngx_connection_t *c)
  3105. {
  3106.     if (c->ssl->buf && c->ssl->buf->start) {
  3107.         if (ngx_pfree(c->pool, c->ssl->buf->start) == NGX_OK) {
  3108.             c->ssl->buf->start = NULL;
  3109.         }
  3110.     }
  3111. }


  3114. ngx_int_t
  3115. ‌ngx_ssl_shutdown(ngx_connection_t *c)
  3116. {
  3117.     int         n, sslerr, mode;
  3118.     ngx_int_t   rc;
  3119.     ngx_err_t   err;
  3120.     ngx_uint_t  tries;

  3122. #if (NGX_QUIC)
  3123.     if (c->quic) {
  3124.         /* QUIC streams inherit SSL object */
  3125.         return NGX_OK;
  3126.     }
  3127. #endif

  3129.     rc = NGX_OK;

  3131.     ngx_ssl_ocsp_cleanup(c);

  3133.     if (SSL_in_init(c->ssl->connection)) {
  3134.         /*
  3135.          * OpenSSL 1.0.2f complains if SSL_shutdown() is called during
  3136.          * an SSL handshake, while previous versions always return 0.
  3137.          * Avoid calling SSL_shutdown() if handshake wasn't completed.
  3138.          */

  3140.         goto done;
  3141.     }

  3143.     if (c->timedout || c->error || c->buffered) {
  3144.         mode = SSL_RECEIVED_SHUTDOWN|SSL_SENT_SHUTDOWN;
  3145.         SSL_set_quiet_shutdown(c->ssl->connection, 1);

  3147.     } else {
  3148.         mode = SSL_get_shutdown(c->ssl->connection);

  3150.         if (c->ssl->no_wait_shutdown) {
  3151.             mode |= SSL_RECEIVED_SHUTDOWN;
  3152.         }

  3154.         if (c->ssl->no_send_shutdown) {
  3155.             mode |= SSL_SENT_SHUTDOWN;
  3156.         }

  3158.         if (c->ssl->no_wait_shutdown && c->ssl->no_send_shutdown) {
  3159.             SSL_set_quiet_shutdown(c->ssl->connection, 1);
  3160.         }
  3161.     }

  3163.     SSL_set_shutdown(c->ssl->connection, mode);

  3165.     ngx_ssl_clear_error(c->log);

  3167.     tries = 2;

  3169.     for ( ;; ) {

  3171.         /*
  3172.          * For bidirectional shutdown, SSL_shutdown() needs to be called
  3173.          * twice: first call sends the "close notify" alert and returns 0,
  3174.          * second call waits for the peer's "close notify" alert.
  3175.          */

  3177.         n = SSL_shutdown(c->ssl->connection);

  3179.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_shutdown: %d", n);

  3181.         if (n == 1) {
  3182.             goto done;
  3183.         }

  3185.         if (n == 0 && tries-- > 1) {
  3186.             continue;
  3187.         }

  3189.         /* before 0.9.8m SSL_shutdown() returned 0 instead of -1 on errors */

  3191.         sslerr = SSL_get_error(c->ssl->connection, n);

  3193.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  3194.                        "SSL_get_error: %d", sslerr);

  3196.         if (sslerr == SSL_ERROR_WANT_READ || sslerr == SSL_ERROR_WANT_WRITE) {
  3197.             c->read->handler = ngx_ssl_shutdown_handler;
  3198.             c->write->handler = ngx_ssl_shutdown_handler;

  3200.             if (sslerr == SSL_ERROR_WANT_READ) {
  3201.                 c->read->ready = 0;

  3203.             } else {
  3204.                 c->write->ready = 0;
  3205.             }

  3207.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3208.                 goto failed;
  3209.             }

  3211.             if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  3212.                 goto failed;
  3213.             }

  3215.             ngx_add_timer(c->read, 3000);

  3217.             return NGX_AGAIN;
  3218.         }

  3220.         if (sslerr == SSL_ERROR_ZERO_RETURN || ERR_peek_error() == 0) {
  3221.             goto done;
  3222.         }

  3224.         err = (sslerr == SSL_ERROR_SYSCALL) ? ngx_errno : 0;

  3226.         ngx_ssl_connection_error(c, sslerr, err, "SSL_shutdown() failed");

  3228.         break;
  3229.     }

  3231. failed:

  3233.     rc = NGX_ERROR;

  3235. done:

  3237.     if (c->ssl->shutdown_without_free) {
  3238.         c->ssl->shutdown_without_free = 0;
  3239.         c->recv = ngx_recv;
  3240.         return rc;
  3241.     }

  3243.     SSL_free(c->ssl->connection);
  3244.     c->ssl = NULL;
  3245.     c->recv = ngx_recv;

  3247.     return rc;
  3248. }


  3251. static void
  3252. ‌ngx_ssl_shutdown_handler(ngx_event_t *ev)
  3253. {
  3254.     ngx_connection_t           *c;
  3255.     ngx_connection_handler_pt   handler;

  3257.     c = ev->data;
  3258.     handler = c->ssl->handler;

  3260.     if (ev->timedout) {
  3261.         c->timedout = 1;
  3262.     }

  3264.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, 0, "SSL shutdown handler");

  3266.     if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
  3267.         return;
  3268.     }

  3270.     handler(c);
  3271. }


  3274. static void
  3275. ‌ngx_ssl_connection_error(ngx_connection_t *c, int sslerr, ngx_err_t err,
  3276.     char *text)
  3277. {
  3278.     int         n;
  3279.     ngx_uint_t  level;

  3281.     level = NGX_LOG_CRIT;

  3283.     if (sslerr == SSL_ERROR_SYSCALL) {

  3285.         if (err == NGX_ECONNRESET
  3286. #if (NGX_WIN32)
  3287.             || err == NGX_ECONNABORTED
  3288. #endif
  3289.             || err == NGX_EPIPE
  3290.             || err == NGX_ENOTCONN
  3291.             || err == NGX_ETIMEDOUT
  3292.             || err == NGX_ECONNREFUSED
  3293.             || err == NGX_ENETDOWN
  3294.             || err == NGX_ENETUNREACH
  3295.             || err == NGX_EHOSTDOWN
  3296.             || err == NGX_EHOSTUNREACH)
  3297.         {
  3298.             switch (c->log_error) {

  3300.             case NGX_ERROR_IGNORE_ECONNRESET:
  3301.             case NGX_ERROR_INFO:
  3302.                 level = NGX_LOG_INFO;
  3303.                 break;

  3305.             case NGX_ERROR_ERR:
  3306.                 level = NGX_LOG_ERR;
  3307.                 break;

  3309.             default:
  3310.                 break;
  3311.             }
  3312.         }

  3314.     } else if (sslerr == SSL_ERROR_SSL) {

  3316.         n = ERR_GET_REASON(ERR_peek_last_error());

  3318.             /* handshake failures */
  3319.         if (n == SSL_R_BAD_CHANGE_CIPHER_SPEC                        /*  103 */
  3320. #ifdef SSL_R_NO_SUITABLE_KEY_SHARE
  3321.             || n == SSL_R_NO_SUITABLE_KEY_SHARE                      /*  101 */
  3322. #endif
  3323. #ifdef SSL_R_BAD_ALERT
  3324.             || n == SSL_R_BAD_ALERT                                  /*  102 */
  3325. #endif
  3326. #ifdef SSL_R_BAD_KEY_SHARE
  3327.             || n == SSL_R_BAD_KEY_SHARE                              /*  108 */
  3328. #endif
  3329. #ifdef SSL_R_BAD_EXTENSION
  3330.             || n == SSL_R_BAD_EXTENSION                              /*  110 */
  3331. #endif
  3332.             || n == SSL_R_BAD_DIGEST_LENGTH                          /*  111 */
  3333. #ifdef SSL_R_MISSING_SIGALGS_EXTENSION
  3334.             || n == SSL_R_MISSING_SIGALGS_EXTENSION                  /*  112 */
  3335. #endif
  3336.             || n == SSL_R_BAD_PACKET_LENGTH                          /*  115 */
  3337. #ifdef SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM
  3338.             || n == SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM            /*  118 */
  3339. #endif
  3340. #ifdef SSL_R_BAD_KEY_UPDATE
  3341.             || n == SSL_R_BAD_KEY_UPDATE                             /*  122 */
  3342. #endif
  3343.             || n == SSL_R_BLOCK_CIPHER_PAD_IS_WRONG                  /*  129 */
  3344.             || n == SSL_R_CCS_RECEIVED_EARLY                         /*  133 */
  3345. #ifdef SSL_R_DECODE_ERROR
  3346.             || n == SSL_R_DECODE_ERROR                               /*  137 */
  3347. #endif
  3348. #ifdef SSL_R_DATA_BETWEEN_CCS_AND_FINISHED
  3349.             || n == SSL_R_DATA_BETWEEN_CCS_AND_FINISHED              /*  145 */
  3350. #endif
  3351.             || n == SSL_R_DATA_LENGTH_TOO_LONG                       /*  146 */
  3352.             || n == SSL_R_DIGEST_CHECK_FAILED                        /*  149 */
  3353.             || n == SSL_R_ENCRYPTED_LENGTH_TOO_LONG                  /*  150 */
  3354.             || n == SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST              /*  151 */
  3355.             || n == SSL_R_EXCESSIVE_MESSAGE_SIZE                     /*  152 */
  3356. #ifdef SSL_R_GOT_A_FIN_BEFORE_A_CCS
  3357.             || n == SSL_R_GOT_A_FIN_BEFORE_A_CCS                     /*  154 */
  3358. #endif
  3359.             || n == SSL_R_HTTPS_PROXY_REQUEST                        /*  155 */
  3360.             || n == SSL_R_HTTP_REQUEST                               /*  156 */
  3361.             || n == SSL_R_LENGTH_MISMATCH                            /*  159 */
  3362. #ifdef SSL_R_LENGTH_TOO_SHORT
  3363.             || n == SSL_R_LENGTH_TOO_SHORT                           /*  160 */
  3364. #endif
  3365. #ifdef SSL_R_NO_RENEGOTIATION
  3366.             || n == SSL_R_NO_RENEGOTIATION                           /*  182 */
  3367. #endif
  3368. #ifdef SSL_R_NO_CIPHERS_PASSED
  3369.             || n == SSL_R_NO_CIPHERS_PASSED                          /*  182 */
  3370. #endif
  3371.             || n == SSL_R_NO_CIPHERS_SPECIFIED                       /*  183 */
  3372. #ifdef SSL_R_BAD_CIPHER
  3373.             || n == SSL_R_BAD_CIPHER                                 /*  186 */
  3374. #endif
  3375.             || n == SSL_R_NO_COMPRESSION_SPECIFIED                   /*  187 */
  3376.             || n == SSL_R_NO_SHARED_CIPHER                           /*  193 */
  3377. #ifdef SSL_R_PACKET_LENGTH_TOO_LONG
  3378.             || n == SSL_R_PACKET_LENGTH_TOO_LONG                     /*  198 */
  3379. #endif
  3380.             || n == SSL_R_RECORD_LENGTH_MISMATCH                     /*  213 */
  3381. #ifdef SSL_R_TOO_MANY_WARNING_ALERTS
  3382.             || n == SSL_R_TOO_MANY_WARNING_ALERTS                    /*  220 */
  3383. #endif
  3384. #ifdef SSL_R_CLIENTHELLO_TLSEXT
  3385.             || n == SSL_R_CLIENTHELLO_TLSEXT                         /*  226 */
  3386. #endif
  3387. #ifdef SSL_R_PARSE_TLSEXT
  3388.             || n == SSL_R_PARSE_TLSEXT                               /*  227 */
  3389. #endif
  3390. #ifdef SSL_R_CALLBACK_FAILED
  3391.             || n == SSL_R_CALLBACK_FAILED                            /*  234 */
  3392. #endif
  3393. #ifdef SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG
  3394.             || n == SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG    /*  234 */
  3395. #endif
  3396. #ifdef SSL_R_NO_APPLICATION_PROTOCOL
  3397.             || n == SSL_R_NO_APPLICATION_PROTOCOL                    /*  235 */
  3398. #endif
  3399.             || n == SSL_R_UNEXPECTED_MESSAGE                         /*  244 */
  3400.             || n == SSL_R_UNEXPECTED_RECORD                          /*  245 */
  3401.             || n == SSL_R_UNKNOWN_ALERT_TYPE                         /*  246 */
  3402.             || n == SSL_R_UNKNOWN_PROTOCOL                           /*  252 */
  3403. #ifdef SSL_R_NO_COMMON_SIGNATURE_ALGORITHMS
  3404.             || n == SSL_R_NO_COMMON_SIGNATURE_ALGORITHMS             /*  253 */
  3405. #endif
  3406. #ifdef SSL_R_INVALID_COMPRESSION_LIST
  3407.             || n == SSL_R_INVALID_COMPRESSION_LIST                   /*  256 */
  3408. #endif
  3409. #ifdef SSL_R_MISSING_KEY_SHARE
  3410.             || n == SSL_R_MISSING_KEY_SHARE                          /*  258 */
  3411. #endif
  3412.             || n == SSL_R_UNSUPPORTED_PROTOCOL                       /*  258 */
  3413. #ifdef SSL_R_NO_SHARED_GROUP
  3414.             || n == SSL_R_NO_SHARED_GROUP                            /*  266 */
  3415. #endif
  3416.             || n == SSL_R_WRONG_VERSION_NUMBER                       /*  267 */
  3417. #ifdef SSL_R_TOO_MUCH_SKIPPED_EARLY_DATA
  3418.             || n == SSL_R_TOO_MUCH_SKIPPED_EARLY_DATA                /*  270 */
  3419. #endif
  3420.             || n == SSL_R_BAD_LENGTH                                 /*  271 */
  3421.             || n == SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC        /*  281 */
  3422. #ifdef SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY
  3423.             || n == SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY        /*  291 */
  3424. #endif
  3425. #ifdef SSL_R_APPLICATION_DATA_ON_SHUTDOWN
  3426.             || n == SSL_R_APPLICATION_DATA_ON_SHUTDOWN               /*  291 */
  3427. #endif
  3428. #ifdef SSL_R_BAD_LEGACY_VERSION
  3429.             || n == SSL_R_BAD_LEGACY_VERSION                         /*  292 */
  3430. #endif
  3431. #ifdef SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA
  3432.             || n == SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA     /*  293 */
  3433. #endif
  3434. #ifdef SSL_R_RECORD_TOO_SMALL
  3435.             || n == SSL_R_RECORD_TOO_SMALL                           /*  298 */
  3436. #endif
  3437. #ifdef SSL_R_SSL3_SESSION_ID_TOO_LONG
  3438.             || n == SSL_R_SSL3_SESSION_ID_TOO_LONG                   /*  300 */
  3439. #endif
  3440. #ifdef SSL_R_BAD_ECPOINT
  3441.             || n == SSL_R_BAD_ECPOINT                                /*  306 */
  3442. #endif
  3443. #ifdef SSL_R_RENEGOTIATE_EXT_TOO_LONG
  3444.             || n == SSL_R_RENEGOTIATE_EXT_TOO_LONG                   /*  335 */
  3445.             || n == SSL_R_RENEGOTIATION_ENCODING_ERR                 /*  336 */
  3446.             || n == SSL_R_RENEGOTIATION_MISMATCH                     /*  337 */
  3447. #endif
  3448. #ifdef SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED
  3449.             || n == SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED       /*  338 */
  3450. #endif
  3451. #ifdef SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING
  3452.             || n == SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING           /*  345 */
  3453. #endif
  3454. #ifdef SSL_R_INAPPROPRIATE_FALLBACK
  3455.             || n == SSL_R_INAPPROPRIATE_FALLBACK                     /*  373 */
  3456. #endif
  3457. #ifdef SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS
  3458.             || n == SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS             /*  376 */
  3459. #endif
  3460. #ifdef SSL_R_NO_SHARED_SIGATURE_ALGORITHMS
  3461.             || n == SSL_R_NO_SHARED_SIGATURE_ALGORITHMS              /*  376 */
  3462. #endif
  3463. #ifdef SSL_R_CERT_CB_ERROR
  3464.             || n == SSL_R_CERT_CB_ERROR                              /*  377 */
  3465. #endif
  3466. #ifdef SSL_R_VERSION_TOO_LOW
  3467.             || n == SSL_R_VERSION_TOO_LOW                            /*  396 */
  3468. #endif
  3469. #ifdef SSL_R_TOO_MANY_WARN_ALERTS
  3470.             || n == SSL_R_TOO_MANY_WARN_ALERTS                       /*  409 */
  3471. #endif
  3472. #ifdef SSL_R_BAD_RECORD_TYPE
  3473.             || n == SSL_R_BAD_RECORD_TYPE                            /*  443 */
  3474. #endif
  3475.             || n == 1000 /* SSL_R_SSLV3_ALERT_CLOSE_NOTIFY */
  3476. #ifdef SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE
  3477.             || n == SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE             /* 1010 */
  3478.             || n == SSL_R_SSLV3_ALERT_BAD_RECORD_MAC                 /* 1020 */
  3479.             || n == SSL_R_TLSV1_ALERT_DECRYPTION_FAILED              /* 1021 */
  3480.             || n == SSL_R_TLSV1_ALERT_RECORD_OVERFLOW                /* 1022 */
  3481.             || n == SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE          /* 1030 */
  3482.             || n == SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE              /* 1040 */
  3483.             || n == SSL_R_SSLV3_ALERT_NO_CERTIFICATE                 /* 1041 */
  3484.             || n == SSL_R_SSLV3_ALERT_BAD_CERTIFICATE                /* 1042 */
  3485.             || n == SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE        /* 1043 */
  3486.             || n == SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED            /* 1044 */
  3487.             || n == SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED            /* 1045 */
  3488.             || n == SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN            /* 1046 */
  3489.             || n == SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER              /* 1047 */
  3490.             || n == SSL_R_TLSV1_ALERT_UNKNOWN_CA                     /* 1048 */
  3491.             || n == SSL_R_TLSV1_ALERT_ACCESS_DENIED                  /* 1049 */
  3492.             || n == SSL_R_TLSV1_ALERT_DECODE_ERROR                   /* 1050 */
  3493.             || n == SSL_R_TLSV1_ALERT_DECRYPT_ERROR                  /* 1051 */
  3494.             || n == SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION             /* 1060 */
  3495.             || n == SSL_R_TLSV1_ALERT_PROTOCOL_VERSION               /* 1070 */
  3496.             || n == SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY          /* 1071 */
  3497.             || n == SSL_R_TLSV1_ALERT_INTERNAL_ERROR                 /* 1080 */
  3498.             || n == SSL_R_TLSV1_ALERT_USER_CANCELLED                 /* 1090 */
  3499.             || n == SSL_R_TLSV1_ALERT_NO_RENEGOTIATION               /* 1100 */
  3500. #endif
  3501.             )
  3502.         {
  3503.             switch (c->log_error) {

  3505.             case NGX_ERROR_IGNORE_ECONNRESET:
  3506.             case NGX_ERROR_INFO:
  3507.                 level = NGX_LOG_INFO;
  3508.                 break;

  3510.             case NGX_ERROR_ERR:
  3511.                 level = NGX_LOG_ERR;
  3512.                 break;

  3514.             default:
  3515.                 break;
  3516.             }
  3517.         }
  3518.     }

  3520.     ngx_ssl_error(level, c->log, err, text);
  3521. }


  3524. static void
  3525. ‌ngx_ssl_clear_error(ngx_log_t *log)
  3526. {
  3527.     while (ERR_peek_error()) {
  3528.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "ignoring stale global SSL error");
  3529.     }

  3531.     ERR_clear_error();
  3532. }


  3535. void ngx_cdecl
  3536. ‌ngx_ssl_error(ngx_uint_t level, ngx_log_t *log, ngx_err_t err, char *fmt, ...)
  3537. {
  3538.     int          flags;
  3539.     u_long       n;
  3540.     va_list      args;
  3541.     u_char      *p, *last;
  3542.     u_char       errstr[NGX_MAX_CONF_ERRSTR];
  3543.     const char  *data;

  3545.     last = errstr + NGX_MAX_CONF_ERRSTR;

  3547.     va_start(args, fmt);
  3548.     p = ngx_vslprintf(errstr, last - 1, fmt, args);
  3549.     va_end(args);

  3551.     if (ERR_peek_error()) {
  3552.         p = ngx_cpystrn(p, (u_char *) " (SSL:", last - p);

  3554.         for ( ;; ) {

  3556.             n = ERR_peek_error_data(&data, &flags);

  3558.             if (n == 0) {
  3559.                 break;
  3560.             }

  3562.             /* ERR_error_string_n() requires at least one byte */

  3564.             if (p >= last - 1) {
  3565.                 goto next;
  3566.             }

  3568.             *p++ = ' ';

  3570.             ERR_error_string_n(n, (char *) p, last - p);

  3572.             while (p < last && *p) {
  3573.                 p++;
  3574.             }

  3576.             if (p < last && *data && (flags & ERR_TXT_STRING)) {
  3577.                 *p++ = ':';
  3578.                 p = ngx_cpystrn(p, (u_char *) data, last - p);
  3579.             }

  3581.         next:

  3583.             (void) ERR_get_error();
  3584.         }

  3586.         if (p < last) {
  3587.             *p++ = ')';
  3588.         }
  3589.     }

  3591.     ngx_log_error(level, log, err, "%*s", p - errstr, errstr);
  3592. }


  3595. ngx_int_t
  3596. ‌ngx_ssl_session_cache(ngx_ssl_t *ssl, ngx_str_t *sess_ctx,
  3597.     ngx_array_t *certificates, ssize_t builtin_session_cache,
  3598.     ngx_shm_zone_t *shm_zone, time_t timeout)
  3599. {
  3600.     long  cache_mode;

  3602.     SSL_CTX_set_timeout(ssl->ctx, (long) timeout);

  3604.     if (ngx_ssl_session_id_context(ssl, sess_ctx, certificates) != NGX_OK) {
  3605.         return NGX_ERROR;
  3606.     }

  3608.     if (builtin_session_cache == NGX_SSL_NO_SCACHE) {
  3609.         SSL_CTX_set_session_cache_mode(ssl->ctx, SSL_SESS_CACHE_OFF);
  3610.         return NGX_OK;
  3611.     }

  3613.     if (builtin_session_cache == NGX_SSL_NONE_SCACHE) {

  3615.         /*
  3616.          * If the server explicitly says that it does not support
  3617.          * session reuse (see SSL_SESS_CACHE_OFF above), then
  3618.          * Outlook Express fails to upload a sent email to
  3619.          * the Sent Items folder on the IMAP server via a separate IMAP
  3620.          * connection in the background.  Therefore we have a special
  3621.          * mode (SSL_SESS_CACHE_SERVER|SSL_SESS_CACHE_NO_INTERNAL_STORE)
  3622.          * where the server pretends that it supports session reuse,
  3623.          * but it does not actually store any session.
  3624.          */

  3626.         SSL_CTX_set_session_cache_mode(ssl->ctx,
  3627.                                        SSL_SESS_CACHE_SERVER
  3628.                                        |SSL_SESS_CACHE_NO_AUTO_CLEAR
  3629.                                        |SSL_SESS_CACHE_NO_INTERNAL_STORE);

  3631.         SSL_CTX_sess_set_cache_size(ssl->ctx, 1);

  3633.         return NGX_OK;
  3634.     }

  3636.     cache_mode = SSL_SESS_CACHE_SERVER;

  3638.     if (shm_zone && builtin_session_cache == NGX_SSL_NO_BUILTIN_SCACHE) {
  3639.         cache_mode |= SSL_SESS_CACHE_NO_INTERNAL;
  3640.     }

  3642.     SSL_CTX_set_session_cache_mode(ssl->ctx, cache_mode);

  3644.     if (builtin_session_cache != NGX_SSL_NO_BUILTIN_SCACHE) {

  3646.         if (builtin_session_cache != NGX_SSL_DFLT_BUILTIN_SCACHE) {
  3647.             SSL_CTX_sess_set_cache_size(ssl->ctx, builtin_session_cache);
  3648.         }
  3649.     }

  3651.     if (shm_zone) {
  3652.         SSL_CTX_sess_set_new_cb(ssl->ctx, ngx_ssl_new_session);
  3653.         SSL_CTX_sess_set_get_cb(ssl->ctx, ngx_ssl_get_cached_session);
  3654.         SSL_CTX_sess_set_remove_cb(ssl->ctx, ngx_ssl_remove_session);

  3656.         if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_session_cache_index, shm_zone)
  3657.             == 0)
  3658.         {
  3659.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  3660.                           "SSL_CTX_set_ex_data() failed");
  3661.             return NGX_ERROR;
  3662.         }
  3663.     }

  3665.     return NGX_OK;
  3666. }


  3669. static ngx_int_t
  3670. ‌ngx_ssl_session_id_context(ngx_ssl_t *ssl, ngx_str_t *sess_ctx,
  3671.     ngx_array_t *certificates)
  3672. {
  3673.     int                   n, i;
  3674.     X509                 *cert;
  3675.     X509_NAME            *name;
  3676.     ngx_str_t            *certs;
  3677.     ngx_uint_t            k;
  3678.     EVP_MD_CTX           *md;
  3679.     unsigned int          len;
  3680.     STACK_OF(X509_NAME)  *list;
  3681.     u_char                buf[EVP_MAX_MD_SIZE];

  3683.     /*
  3684.      * Session ID context is set based on the string provided,
  3685.      * the server certificates, and the client CA list.
  3686.      */

  3688.     md = EVP_MD_CTX_create();
  3689.     if (md == NULL) {
  3690.         return NGX_ERROR;
  3691.     }

  3693.     if (EVP_DigestInit_ex(md, EVP_sha1(), NULL) == 0) {
  3694.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  3695.                       "EVP_DigestInit_ex() failed");
  3696.         goto failed;
  3697.     }

  3699.     if (EVP_DigestUpdate(md, sess_ctx->data, sess_ctx->len) == 0) {
  3700.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  3701.                       "EVP_DigestUpdate() failed");
  3702.         goto failed;
  3703.     }

  3705.     for (k = 0; k < ssl->certs.nelts; k++) {
  3706.         cert = ((X509 **) ssl->certs.elts)[k];

  3708.         if (X509_digest(cert, EVP_sha1(), buf, &len) == 0) {
  3709.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  3710.                           "X509_digest() failed");
  3711.             goto failed;
  3712.         }

  3714.         if (EVP_DigestUpdate(md, buf, len) == 0) {
  3715.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  3716.                           "EVP_DigestUpdate() failed");
  3717.             goto failed;
  3718.         }
  3719.     }

  3721.     if (ssl->certs.nelts == 0 && certificates != NULL) {
  3722.         /*
  3723.          * If certificates are loaded dynamically, we use certificate
  3724.          * names as specified in the configuration (with variables).
  3725.          */

  3727.         certs = certificates->elts;
  3728.         for (k = 0; k < certificates->nelts; k++) {

  3730.             if (EVP_DigestUpdate(md, certs[k].data, certs[k].len) == 0) {
  3731.                 ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  3732.                               "EVP_DigestUpdate() failed");
  3733.                 goto failed;
  3734.             }
  3735.         }
  3736.     }

  3738.     list = SSL_CTX_get_client_CA_list(ssl->ctx);

  3740.     if (list != NULL) {
  3741.         n = sk_X509_NAME_num(list);

  3743.         for (i = 0; i < n; i++) {
  3744.             name = sk_X509_NAME_value(list, i);

  3746.             if (X509_NAME_digest(name, EVP_sha1(), buf, &len) == 0) {
  3747.                 ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  3748.                               "X509_NAME_digest() failed");
  3749.                 goto failed;
  3750.             }

  3752.             if (EVP_DigestUpdate(md, buf, len) == 0) {
  3753.                 ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  3754.                               "EVP_DigestUpdate() failed");
  3755.                 goto failed;
  3756.             }
  3757.         }
  3758.     }

  3760.     if (EVP_DigestFinal_ex(md, buf, &len) == 0) {
  3761.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  3762.                       "EVP_DigestFinal_ex() failed");
  3763.         goto failed;
  3764.     }

  3766.     EVP_MD_CTX_destroy(md);

  3768.     if (SSL_CTX_set_session_id_context(ssl->ctx, buf, len) == 0) {
  3769.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  3770.                       "SSL_CTX_set_session_id_context() failed");
  3771.         return NGX_ERROR;
  3772.     }

  3774.     return NGX_OK;

  3776. failed:

  3778.     EVP_MD_CTX_destroy(md);

  3780.     return NGX_ERROR;
  3781. }


  3784. ngx_int_t
  3785. ‌ngx_ssl_session_cache_init(ngx_shm_zone_t *shm_zone, void *data)
  3786. {
  3787.     size_t                    len;
  3788.     ngx_slab_pool_t          *shpool;
  3789.     ngx_ssl_session_cache_t  *cache;

  3791.     if (data) {
  3792.         shm_zone->data = data;
  3793.         return NGX_OK;
  3794.     }

  3796.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

  3798.     if (shm_zone->shm.exists) {
  3799.         shm_zone->data = shpool->data;
  3800.         return NGX_OK;
  3801.     }

  3803.     cache = ngx_slab_alloc(shpool, sizeof(ngx_ssl_session_cache_t));
  3804.     if (cache == NULL) {
  3805.         return NGX_ERROR;
  3806.     }

  3808.     shpool->data = cache;
  3809.     shm_zone->data = cache;

  3811.     ngx_rbtree_init(&cache->session_rbtree, &cache->sentinel,
  3812.                     ngx_ssl_session_rbtree_insert_value);

  3814.     ngx_queue_init(&cache->expire_queue);

  3816.     cache->ticket_keys[0].expire = 0;
  3817.     cache->ticket_keys[1].expire = 0;
  3818.     cache->ticket_keys[2].expire = 0;

  3820.     cache->fail_time = 0;

  3822.     len = sizeof(" in SSL session shared cache \"\"") + shm_zone->shm.name.len;

  3824.     shpool->log_ctx = ngx_slab_alloc(shpool, len);
  3825.     if (shpool->log_ctx == NULL) {
  3826.         return NGX_ERROR;
  3827.     }

  3829.     ngx_sprintf(shpool->log_ctx, " in SSL session shared cache \"%V\"%Z",
  3830.                 &shm_zone->shm.name);

  3832.     shpool->log_nomem = 0;

  3834.     return NGX_OK;
  3835. }


  3838. /*
  3839. * The length of the session id is 16 bytes for SSLv2 sessions and
  3840. * between 1 and 32 bytes for SSLv3 and TLS, typically 32 bytes.
  3841. * Typical length of the external ASN1 representation of a session
  3842. * is about 150 bytes plus SNI server name.
  3843. *
  3844. * On 32-bit platforms we allocate an rbtree node, a session id, and
  3845. * an ASN1 representation in a single allocation, it typically takes
  3846. * 256 bytes.
  3847. *
  3848. * On 64-bit platforms we allocate separately an rbtree node + session_id,
  3849. * and an ASN1 representation, they take accordingly 128 and 256 bytes.
  3850. *
  3851. * OpenSSL's i2d_SSL_SESSION() and d2i_SSL_SESSION are slow,
  3852. * so they are outside the code locked by shared pool mutex
  3853. */

  3855. static int
  3856. ‌ngx_ssl_new_session(ngx_ssl_conn_t *ssl_conn, ngx_ssl_session_t *sess)
  3857. {
  3858.     int                       len;
  3859.     u_char                   *p, *session_id;
  3860.     size_t                    n;
  3861.     uint32_t                  hash;
  3862.     SSL_CTX                  *ssl_ctx;
  3863.     unsigned int              session_id_length;
  3864.     ngx_shm_zone_t           *shm_zone;
  3865.     ngx_connection_t         *c;
  3866.     ngx_slab_pool_t          *shpool;
  3867.     ngx_ssl_sess_id_t        *sess_id;
  3868.     ngx_ssl_session_cache_t  *cache;
  3869.     u_char                    buf[NGX_SSL_MAX_SESSION_SIZE];

  3871. #ifdef TLS1_3_VERSION

  3873.     /*
  3874.      * OpenSSL tries to save TLSv1.3 sessions into session cache
  3875.      * even when using tickets for stateless session resumption,
  3876.      * "because some applications just want to know about the creation
  3877.      * of a session"; do not cache such sessions
  3878.      */

  3880.     if (SSL_version(ssl_conn) == TLS1_3_VERSION
  3881.         && (SSL_get_options(ssl_conn) & SSL_OP_NO_TICKET) == 0)
  3882.     {
  3883.         return 0;
  3884.     }

  3886. #endif

  3888.     len = i2d_SSL_SESSION(sess, NULL);

  3890.     /* do not cache too big session */

  3892.     if (len > NGX_SSL_MAX_SESSION_SIZE) {
  3893.         return 0;
  3894.     }

  3896.     p = buf;
  3897.     i2d_SSL_SESSION(sess, &p);

  3899.     session_id = (u_char *) SSL_SESSION_get_id(sess, &session_id_length);

  3901.     /* do not cache sessions with too long session id */

  3903.     if (session_id_length > 32) {
  3904.         return 0;
  3905.     }

  3907.     c = ngx_ssl_get_connection(ssl_conn);

  3909.     ssl_ctx = c->ssl->session_ctx;
  3910.     shm_zone = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_session_cache_index);

  3912.     cache = shm_zone->data;
  3913.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

  3915.     ngx_shmtx_lock(&shpool->mutex);

  3917.     /* drop one or two expired sessions */
  3918.     ngx_ssl_expire_sessions(cache, shpool, 1);

  3920. #if (NGX_PTR_SIZE == 8)
  3921.     n = sizeof(ngx_ssl_sess_id_t);
  3922. #else
  3923.     n = offsetof(ngx_ssl_sess_id_t, session) + len;
  3924. #endif

  3926.     sess_id = ngx_slab_alloc_locked(shpool, n);

  3928.     if (sess_id == NULL) {

  3930.         /* drop the oldest non-expired session and try once more */

  3932.         ngx_ssl_expire_sessions(cache, shpool, 0);

  3934.         sess_id = ngx_slab_alloc_locked(shpool, n);

  3936.         if (sess_id == NULL) {
  3937.             goto failed;
  3938.         }
  3939.     }

  3941. #if (NGX_PTR_SIZE == 8)

  3943.     sess_id->session = ngx_slab_alloc_locked(shpool, len);

  3945.     if (sess_id->session == NULL) {

  3947.         /* drop the oldest non-expired session and try once more */

  3949.         ngx_ssl_expire_sessions(cache, shpool, 0);

  3951.         sess_id->session = ngx_slab_alloc_locked(shpool, len);

  3953.         if (sess_id->session == NULL) {
  3954.             goto failed;
  3955.         }
  3956.     }

  3958. #endif

  3960.     ngx_memcpy(sess_id->session, buf, len);
  3961.     ngx_memcpy(sess_id->id, session_id, session_id_length);

  3963.     hash = ngx_crc32_short(session_id, session_id_length);

  3965.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  3966.                    "ssl new session: %08XD:%ud:%d",
  3967.                    hash, session_id_length, len);

  3969.     sess_id->node.key = hash;
  3970.     sess_id->node.data = (u_char) session_id_length;
  3971.     sess_id->len = len;

  3973.     sess_id->expire = ngx_time() + SSL_CTX_get_timeout(ssl_ctx);

  3975.     ngx_queue_insert_head(&cache->expire_queue, &sess_id->queue);

  3977.     ngx_rbtree_insert(&cache->session_rbtree, &sess_id->node);

  3979.     ngx_shmtx_unlock(&shpool->mutex);

  3981.     return 0;

  3983. failed:

  3985.     if (sess_id) {
  3986.         ngx_slab_free_locked(shpool, sess_id);
  3987.     }

  3989.     ngx_shmtx_unlock(&shpool->mutex);

  3991.     if (cache->fail_time != ngx_time()) {
  3992.         cache->fail_time = ngx_time();
  3993.         ngx_log_error(NGX_LOG_WARN, c->log, 0,
  3994.                       "could not allocate new session%s", shpool->log_ctx);
  3995.     }

  3997.     return 0;
  3998. }


  4001. static ngx_ssl_session_t *
  4002. ‌ngx_ssl_get_cached_session(ngx_ssl_conn_t *ssl_conn,
  4003. #if OPENSSL_VERSION_NUMBER >= 0x10100003L
  4004.     const
  4005. #endif
  4006.     u_char *id, int len, int *copy)
  4007. {
  4008.     size_t                    slen;
  4009.     uint32_t                  hash;
  4010.     ngx_int_t                 rc;
  4011.     const u_char             *p;
  4012.     ngx_shm_zone_t           *shm_zone;
  4013.     ngx_slab_pool_t          *shpool;
  4014.     ngx_rbtree_node_t        *node, *sentinel;
  4015.     ngx_ssl_session_t        *sess;
  4016.     ngx_ssl_sess_id_t        *sess_id;
  4017.     ngx_ssl_session_cache_t  *cache;
  4018.     u_char                    buf[NGX_SSL_MAX_SESSION_SIZE];
  4019.     ngx_connection_t         *c;

  4021.     hash = ngx_crc32_short((u_char *) (uintptr_t) id, (size_t) len);
  4022.     *copy = 0;

  4024.     c = ngx_ssl_get_connection(ssl_conn);

  4026.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  4027.                    "ssl get session: %08XD:%d", hash, len);

  4029.     shm_zone = SSL_CTX_get_ex_data(c->ssl->session_ctx,
  4030.                                    ngx_ssl_session_cache_index);

  4032.     cache = shm_zone->data;

  4034.     sess = NULL;

  4036.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

  4038.     ngx_shmtx_lock(&shpool->mutex);

  4040.     node = cache->session_rbtree.root;
  4041.     sentinel = cache->session_rbtree.sentinel;

  4043.     while (node != sentinel) {

  4045.         if (hash < node->key) {
  4046.             node = node->left;
  4047.             continue;
  4048.         }

  4050.         if (hash > node->key) {
  4051.             node = node->right;
  4052.             continue;
  4053.         }

  4055.         /* hash == node->key */

  4057.         sess_id = (ngx_ssl_sess_id_t *) node;

  4059.         rc = ngx_memn2cmp((u_char *) (uintptr_t) id, sess_id->id,
  4060.                           (size_t) len, (size_t) node->data);

  4062.         if (rc == 0) {

  4064.             if (sess_id->expire > ngx_time()) {
  4065.                 slen = sess_id->len;

  4067.                 ngx_memcpy(buf, sess_id->session, slen);

  4069.                 ngx_shmtx_unlock(&shpool->mutex);

  4071.                 p = buf;
  4072.                 sess = d2i_SSL_SESSION(NULL, &p, slen);

  4074.                 return sess;
  4075.             }

  4077.             ngx_queue_remove(&sess_id->queue);

  4079.             ngx_rbtree_delete(&cache->session_rbtree, node);

  4081.             ngx_explicit_memzero(sess_id->session, sess_id->len);

  4083. #if (NGX_PTR_SIZE == 8)
  4084.             ngx_slab_free_locked(shpool, sess_id->session);
  4085. #endif
  4086.             ngx_slab_free_locked(shpool, sess_id);

  4088.             sess = NULL;

  4090.             goto done;
  4091.         }

  4093.         node = (rc < 0) ? node->left : node->right;
  4094.     }

  4096. done:

  4098.     ngx_shmtx_unlock(&shpool->mutex);

  4100.     return sess;
  4101. }


  4104. void
  4105. ‌ngx_ssl_remove_cached_session(SSL_CTX *ssl, ngx_ssl_session_t *sess)
  4106. {
  4107.     SSL_CTX_remove_session(ssl, sess);

  4109.     ngx_ssl_remove_session(ssl, sess);
  4110. }


  4113. static void
  4114. ‌ngx_ssl_remove_session(SSL_CTX *ssl, ngx_ssl_session_t *sess)
  4115. {
  4116.     u_char                   *id;
  4117.     uint32_t                  hash;
  4118.     ngx_int_t                 rc;
  4119.     unsigned int              len;
  4120.     ngx_shm_zone_t           *shm_zone;
  4121.     ngx_slab_pool_t          *shpool;
  4122.     ngx_rbtree_node_t        *node, *sentinel;
  4123.     ngx_ssl_sess_id_t        *sess_id;
  4124.     ngx_ssl_session_cache_t  *cache;

  4126.     shm_zone = SSL_CTX_get_ex_data(ssl, ngx_ssl_session_cache_index);

  4128.     if (shm_zone == NULL) {
  4129.         return;
  4130.     }

  4132.     cache = shm_zone->data;

  4134.     id = (u_char *) SSL_SESSION_get_id(sess, &len);

  4136.     hash = ngx_crc32_short(id, len);

  4138.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0,
  4139.                    "ssl remove session: %08XD:%ud", hash, len);

  4141.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

  4143.     ngx_shmtx_lock(&shpool->mutex);

  4145.     node = cache->session_rbtree.root;
  4146.     sentinel = cache->session_rbtree.sentinel;

  4148.     while (node != sentinel) {

  4150.         if (hash < node->key) {
  4151.             node = node->left;
  4152.             continue;
  4153.         }

  4155.         if (hash > node->key) {
  4156.             node = node->right;
  4157.             continue;
  4158.         }

  4160.         /* hash == node->key */

  4162.         sess_id = (ngx_ssl_sess_id_t *) node;

  4164.         rc = ngx_memn2cmp(id, sess_id->id, len, (size_t) node->data);

  4166.         if (rc == 0) {

  4168.             ngx_queue_remove(&sess_id->queue);

  4170.             ngx_rbtree_delete(&cache->session_rbtree, node);

  4172.             ngx_explicit_memzero(sess_id->session, sess_id->len);

  4174. #if (NGX_PTR_SIZE == 8)
  4175.             ngx_slab_free_locked(shpool, sess_id->session);
  4176. #endif
  4177.             ngx_slab_free_locked(shpool, sess_id);

  4179.             goto done;
  4180.         }

  4182.         node = (rc < 0) ? node->left : node->right;
  4183.     }

  4185. done:

  4187.     ngx_shmtx_unlock(&shpool->mutex);
  4188. }


  4191. static void
  4192. ‌ngx_ssl_expire_sessions(ngx_ssl_session_cache_t *cache,
  4193.     ngx_slab_pool_t *shpool, ngx_uint_t n)
  4194. {
  4195.     time_t              now;
  4196.     ngx_queue_t        *q;
  4197.     ngx_ssl_sess_id_t  *sess_id;

  4199.     now = ngx_time();

  4201.     while (n < 3) {

  4203.         if (ngx_queue_empty(&cache->expire_queue)) {
  4204.             return;
  4205.         }

  4207.         q = ngx_queue_last(&cache->expire_queue);

  4209.         sess_id = ngx_queue_data(q, ngx_ssl_sess_id_t, queue);

  4211.         if (n++ != 0 && sess_id->expire > now) {
  4212.             return;
  4213.         }

  4215.         ngx_queue_remove(q);

  4217.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0,
  4218.                        "expire session: %08Xi", sess_id->node.key);

  4220.         ngx_rbtree_delete(&cache->session_rbtree, &sess_id->node);

  4222.         ngx_explicit_memzero(sess_id->session, sess_id->len);

  4224. #if (NGX_PTR_SIZE == 8)
  4225.         ngx_slab_free_locked(shpool, sess_id->session);
  4226. #endif
  4227.         ngx_slab_free_locked(shpool, sess_id);
  4228.     }
  4229. }


  4232. static void
  4233. ‌ngx_ssl_session_rbtree_insert_value(ngx_rbtree_node_t *temp,
  4234.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  4235. {
  4236.     ngx_rbtree_node_t  **p;
  4237.     ngx_ssl_sess_id_t   *sess_id, *sess_id_temp;

  4239.     for ( ;; ) {

  4241.         if (node->key < temp->key) {

  4243.             p = &temp->left;

  4245.         } else if (node->key > temp->key) {

  4247.             p = &temp->right;

  4249.         } else { /* node->key == temp->key */

  4251.             sess_id = (ngx_ssl_sess_id_t *) node;
  4252.             sess_id_temp = (ngx_ssl_sess_id_t *) temp;

  4254.             p = (ngx_memn2cmp(sess_id->id, sess_id_temp->id,
  4255.                               (size_t) node->data, (size_t) temp->data)
  4256.                  < 0) ? &temp->left : &temp->right;
  4257.         }

  4259.         if (*p == sentinel) {
  4260.             break;
  4261.         }

  4263.         temp = *p;
  4264.     }

  4266.     *p = node;
  4267.     node->parent = temp;
  4268.     node->left = sentinel;
  4269.     node->right = sentinel;
  4270.     ngx_rbt_red(node);
  4271. }


  4274. #ifdef SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB

  4276. ngx_int_t
  4277. ‌ngx_ssl_session_ticket_keys(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_array_t *paths)
  4278. {
  4279.     u_char                 buf[80];
  4280.     size_t                 size;
  4281.     ssize_t                n;
  4282.     ngx_str_t             *path;
  4283.     ngx_file_t             file;
  4284.     ngx_uint_t             i;
  4285.     ngx_array_t           *keys;
  4286.     ngx_file_info_t        fi;
  4287.     ngx_pool_cleanup_t    *cln;
  4288.     ngx_ssl_ticket_key_t  *key;

  4290.     if (paths == NULL
  4291.         && SSL_CTX_get_ex_data(ssl->ctx, ngx_ssl_session_cache_index) == NULL)
  4292.     {
  4293.         return NGX_OK;
  4294.     }

  4296.     keys = ngx_array_create(cf->pool, paths ? paths->nelts : 3,
  4297.                             sizeof(ngx_ssl_ticket_key_t));
  4298.     if (keys == NULL) {
  4299.         return NGX_ERROR;
  4300.     }

  4302.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  4303.     if (cln == NULL) {
  4304.         return NGX_ERROR;
  4305.     }

  4307.     cln->handler = ngx_ssl_ticket_keys_cleanup;
  4308.     cln->data = keys;

  4310.     if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_ticket_keys_index, keys) == 0) {
  4311.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4312.                       "SSL_CTX_set_ex_data() failed");
  4313.         return NGX_ERROR;
  4314.     }

  4316.     if (SSL_CTX_set_tlsext_ticket_key_cb(ssl->ctx, ngx_ssl_ticket_key_callback)
  4317.         == 0)
  4318.     {
  4319.         ngx_log_error(NGX_LOG_WARN, cf->log, 0,
  4320.                       "nginx was built with Session Tickets support, however, "
  4321.                       "now it is linked dynamically to an OpenSSL library "
  4322.                       "which has no tlsext support, therefore Session Tickets "
  4323.                       "are not available");
  4324.         return NGX_OK;
  4325.     }

  4327.     if (paths == NULL) {

  4329.         /* placeholder for keys in shared memory */

  4331.         key = ngx_array_push_n(keys, 3);
  4332.         key[0].shared = 1;
  4333.         key[0].expire = 0;
  4334.         key[1].shared = 1;
  4335.         key[1].expire = 0;
  4336.         key[2].shared = 1;
  4337.         key[2].expire = 0;

  4339.         return NGX_OK;
  4340.     }

  4342.     path = paths->elts;
  4343.     for (i = 0; i < paths->nelts; i++) {

  4345.         if (ngx_conf_full_name(cf->cycle, &path[i], 1) != NGX_OK) {
  4346.             return NGX_ERROR;
  4347.         }

  4349.         ngx_memzero(&file, sizeof(ngx_file_t));
  4350.         file.name = path[i];
  4351.         file.log = cf->log;

  4353.         file.fd = ngx_open_file(file.name.data, NGX_FILE_RDONLY,
  4354.                                 NGX_FILE_OPEN, 0);

  4356.         if (file.fd == NGX_INVALID_FILE) {
  4357.             ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  4358.                                ngx_open_file_n " \"%V\" failed", &file.name);
  4359.             return NGX_ERROR;
  4360.         }

  4362.         if (ngx_fd_info(file.fd, &fi) == NGX_FILE_ERROR) {
  4363.             ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  4364.                                ngx_fd_info_n " \"%V\" failed", &file.name);
  4365.             goto failed;
  4366.         }

  4368.         size = ngx_file_size(&fi);

  4370.         if (size != 48 && size != 80) {
  4371.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4372.                                "\"%V\" must be 48 or 80 bytes", &file.name);
  4373.             goto failed;
  4374.         }

  4376.         n = ngx_read_file(&file, buf, size, 0);

  4378.         if (n == NGX_ERROR) {
  4379.             ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  4380.                                ngx_read_file_n " \"%V\" failed", &file.name);
  4381.             goto failed;
  4382.         }

  4384.         if ((size_t) n != size) {
  4385.             ngx_conf_log_error(NGX_LOG_CRIT, cf, 0,
  4386.                                ngx_read_file_n " \"%V\" returned only "
  4387.                                "%z bytes instead of %uz", &file.name, n, size);
  4388.             goto failed;
  4389.         }

  4391.         key = ngx_array_push(keys);
  4392.         if (key == NULL) {
  4393.             goto failed;
  4394.         }

  4396.         key->shared = 0;
  4397.         key->expire = 1;

  4399.         if (size == 48) {
  4400.             key->size = 48;
  4401.             ngx_memcpy(key->name, buf, 16);
  4402.             ngx_memcpy(key->aes_key, buf + 16, 16);
  4403.             ngx_memcpy(key->hmac_key, buf + 32, 16);

  4405.         } else {
  4406.             key->size = 80;
  4407.             ngx_memcpy(key->name, buf, 16);
  4408.             ngx_memcpy(key->hmac_key, buf + 16, 32);
  4409.             ngx_memcpy(key->aes_key, buf + 48, 32);
  4410.         }

  4412.         if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  4413.             ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  4414.                           ngx_close_file_n " \"%V\" failed", &file.name);
  4415.         }

  4417.         ngx_explicit_memzero(&buf, 80);
  4418.     }

  4420.     return NGX_OK;

  4422. failed:

  4424.     if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  4425.         ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  4426.                       ngx_close_file_n " \"%V\" failed", &file.name);
  4427.     }

  4429.     ngx_explicit_memzero(&buf, 80);

  4431.     return NGX_ERROR;
  4432. }


  4435. static int
  4436. ‌ngx_ssl_ticket_key_callback(ngx_ssl_conn_t *ssl_conn,
  4437.     unsigned char *name, unsigned char *iv, EVP_CIPHER_CTX *ectx,
  4438.     HMAC_CTX *hctx, int enc)
  4439. {
  4440.     size_t                 size;
  4441.     SSL_CTX               *ssl_ctx;
  4442.     ngx_uint_t             i;
  4443.     ngx_array_t           *keys;
  4444.     ngx_connection_t      *c;
  4445.     ngx_ssl_ticket_key_t  *key;
  4446.     const EVP_MD          *digest;
  4447.     const EVP_CIPHER      *cipher;

  4449.     c = ngx_ssl_get_connection(ssl_conn);
  4450.     ssl_ctx = c->ssl->session_ctx;

  4452.     if (ngx_ssl_rotate_ticket_keys(ssl_ctx, c->log) != NGX_OK) {
  4453.         return -1;
  4454.     }

  4456. #ifdef OPENSSL_NO_SHA256
  4457.     digest = EVP_sha1();
  4458. #else
  4459.     digest = EVP_sha256();
  4460. #endif

  4462.     keys = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_ticket_keys_index);
  4463.     if (keys == NULL) {
  4464.         return -1;
  4465.     }

  4467.     key = keys->elts;

  4469.     if (enc == 1) {
  4470.         /* encrypt session ticket */

  4472.         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  4473.                        "ssl ticket encrypt, key: \"%*xs\" (%s session)",
  4474.                        (size_t) 16, key[0].name,
  4475.                        SSL_session_reused(ssl_conn) ? "reused" : "new");

  4477.         if (key[0].size == 48) {
  4478.             cipher = EVP_aes_128_cbc();
  4479.             size = 16;

  4481.         } else {
  4482.             cipher = EVP_aes_256_cbc();
  4483.             size = 32;
  4484.         }

  4486.         if (RAND_bytes(iv, EVP_CIPHER_iv_length(cipher)) != 1) {
  4487.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "RAND_bytes() failed");
  4488.             return -1;
  4489.         }

  4491.         if (EVP_EncryptInit_ex(ectx, cipher, NULL, key[0].aes_key, iv) != 1) {
  4492.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  4493.                           "EVP_EncryptInit_ex() failed");
  4494.             return -1;
  4495.         }

  4497. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  4498.         if (HMAC_Init_ex(hctx, key[0].hmac_key, size, digest, NULL) != 1) {
  4499.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "HMAC_Init_ex() failed");
  4500.             return -1;
  4501.         }
  4502. #else
  4503.         HMAC_Init_ex(hctx, key[0].hmac_key, size, digest, NULL);
  4504. #endif

  4506.         ngx_memcpy(name, key[0].name, 16);

  4508.         return 1;

  4510.     } else {
  4511.         /* decrypt session ticket */

  4513.         for (i = 0; i < keys->nelts; i++) {
  4514.             if (ngx_memcmp(name, key[i].name, 16) == 0) {
  4515.                 goto found;
  4516.             }
  4517.         }

  4519.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  4520.                        "ssl ticket decrypt, key: \"%*xs\" not found",
  4521.                        (size_t) 16, name);

  4523.         return 0;

  4525.     found:

  4527.         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  4528.                        "ssl ticket decrypt, key: \"%*xs\"%s",
  4529.                        (size_t) 16, key[i].name, (i == 0) ? " (default)" : "");

  4531.         if (key[i].size == 48) {
  4532.             cipher = EVP_aes_128_cbc();
  4533.             size = 16;

  4535.         } else {
  4536.             cipher = EVP_aes_256_cbc();
  4537.             size = 32;
  4538.         }

  4540. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  4541.         if (HMAC_Init_ex(hctx, key[i].hmac_key, size, digest, NULL) != 1) {
  4542.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "HMAC_Init_ex() failed");
  4543.             return -1;
  4544.         }
  4545. #else
  4546.         HMAC_Init_ex(hctx, key[i].hmac_key, size, digest, NULL);
  4547. #endif

  4549.         if (EVP_DecryptInit_ex(ectx, cipher, NULL, key[i].aes_key, iv) != 1) {
  4550.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  4551.                           "EVP_DecryptInit_ex() failed");
  4552.             return -1;
  4553.         }

  4555.         /* renew if TLSv1.3 */

  4557. #ifdef TLS1_3_VERSION
  4558.         if (SSL_version(ssl_conn) == TLS1_3_VERSION) {
  4559.             return 2;
  4560.         }
  4561. #endif

  4563.         /* renew if non-default key */

  4565.         if (i != 0 && key[i].expire) {
  4566.             return 2;
  4567.         }

  4569.         return 1;
  4570.     }
  4571. }


  4574. static ngx_int_t
  4575. ‌ngx_ssl_rotate_ticket_keys(SSL_CTX *ssl_ctx, ngx_log_t *log)
  4576. {
  4577.     time_t                    now, expire;
  4578.     ngx_array_t              *keys;
  4579.     ngx_shm_zone_t           *shm_zone;
  4580.     ngx_slab_pool_t          *shpool;
  4581.     ngx_ssl_ticket_key_t     *key;
  4582.     ngx_ssl_session_cache_t  *cache;
  4583.     u_char                    buf[80];

  4585.     keys = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_ticket_keys_index);
  4586.     if (keys == NULL) {
  4587.         return NGX_OK;
  4588.     }

  4590.     key = keys->elts;

  4592.     if (!key[0].shared) {
  4593.         return NGX_OK;
  4594.     }

  4596.     /*
  4597.      * if we don't need to update expiration of the current key
  4598.      * and the previous key is still needed, don't sync with shared
  4599.      * memory to save some work; in the worst case other worker process
  4600.      * will switch to the next key, but this process will still be able
  4601.      * to decrypt tickets encrypted with it
  4602.      */

  4604.     now = ngx_time();
  4605.     expire = now + SSL_CTX_get_timeout(ssl_ctx);

  4607.     if (key[0].expire >= expire && key[1].expire >= now) {
  4608.         return NGX_OK;
  4609.     }

  4611.     shm_zone = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_session_cache_index);

  4613.     cache = shm_zone->data;
  4614.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

  4616.     ngx_shmtx_lock(&shpool->mutex);

  4618.     key = cache->ticket_keys;

  4620.     if (key[0].expire == 0) {

  4622.         /* initialize the current key */

  4624.         if (RAND_bytes(buf, 80) != 1) {
  4625.             ngx_ssl_error(NGX_LOG_ALERT, log, 0, "RAND_bytes() failed");
  4626.             ngx_shmtx_unlock(&shpool->mutex);
  4627.             return NGX_ERROR;
  4628.         }

  4630.         key[0].shared = 1;
  4631.         key[0].expire = expire;
  4632.         key[0].size = 80;
  4633.         ngx_memcpy(key[0].name, buf, 16);
  4634.         ngx_memcpy(key[0].hmac_key, buf + 16, 32);
  4635.         ngx_memcpy(key[0].aes_key, buf + 48, 32);

  4637.         ngx_explicit_memzero(&buf, 80);

  4639.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0,
  4640.                        "ssl ticket key: \"%*xs\"",
  4641.                        (size_t) 16, key[0].name);

  4643.         /*
  4644.          * copy the current key to the next key, as initialization of
  4645.          * the previous key will replace the current key with the next
  4646.          * key
  4647.          */

  4649.         key[2] = key[0];
  4650.     }

  4652.     if (key[1].expire < now) {

  4654.         /*
  4655.          * if the previous key is no longer needed (or not initialized),
  4656.          * replace it with the current key, replace the current key with
  4657.          * the next key, and generate new next key
  4658.          */

  4660.         key[1] = key[0];
  4661.         key[0] = key[2];

  4663.         if (RAND_bytes(buf, 80) != 1) {
  4664.             ngx_ssl_error(NGX_LOG_ALERT, log, 0, "RAND_bytes() failed");
  4665.             ngx_shmtx_unlock(&shpool->mutex);
  4666.             return NGX_ERROR;
  4667.         }

  4669.         key[2].shared = 1;
  4670.         key[2].expire = 0;
  4671.         key[2].size = 80;
  4672.         ngx_memcpy(key[2].name, buf, 16);
  4673.         ngx_memcpy(key[2].hmac_key, buf + 16, 32);
  4674.         ngx_memcpy(key[2].aes_key, buf + 48, 32);

  4676.         ngx_explicit_memzero(&buf, 80);

  4678.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0,
  4679.                        "ssl ticket key: \"%*xs\"",
  4680.                        (size_t) 16, key[2].name);
  4681.     }

  4683.     /*
  4684.      * update expiration of the current key: it is going to be needed
  4685.      * at least till the session being created expires
  4686.      */

  4688.     if (expire > key[0].expire) {
  4689.         key[0].expire = expire;
  4690.     }

  4692.     /* sync keys to the worker process memory */

  4694.     ngx_memcpy(keys->elts, cache->ticket_keys,
  4695.                2 * sizeof(ngx_ssl_ticket_key_t));

  4697.     ngx_shmtx_unlock(&shpool->mutex);

  4699.     return NGX_OK;
  4700. }


  4703. static void
  4704. ‌ngx_ssl_ticket_keys_cleanup(void *data)
  4705. {
  4706.     ngx_array_t  *keys = data;

  4708.     ngx_explicit_memzero(keys->elts,
  4709.                          keys->nelts * sizeof(ngx_ssl_ticket_key_t));
  4710. }

  4712. #else

  4714. ngx_int_t
  4715. ‌ngx_ssl_session_ticket_keys(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_array_t *paths)
  4716. {
  4717.     if (paths) {
  4718.         ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  4719.                       "\"ssl_session_ticket_key\" ignored, not supported");
  4720.     }

  4722.     return NGX_OK;
  4723. }

  4725. #endif


  4728. void
  4729. ‌ngx_ssl_cleanup_ctx(void *data)
  4730. {
  4731.     ngx_ssl_t  *ssl = data;

  4733.     X509        *cert;
  4734.     ngx_uint_t   i;

  4736.     for (i = 0; i < ssl->certs.nelts; i++) {
  4737.         cert = ((X509 **) ssl->certs.elts)[i];
  4738.         X509_free(cert);
  4739.     }

  4741.     SSL_CTX_free(ssl->ctx);
  4742. }


  4745. ngx_int_t
  4746. ‌ngx_ssl_check_host(ngx_connection_t *c, ngx_str_t *name)
  4747. {
  4748.     X509   *cert;

  4750.     cert = SSL_get_peer_certificate(c->ssl->connection);
  4751.     if (cert == NULL) {
  4752.         return NGX_ERROR;
  4753.     }

  4755. #ifdef X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT

  4757.     /* X509_check_host() is only available in OpenSSL 1.0.2+ */

  4759.     if (name->len == 0) {
  4760.         goto failed;
  4761.     }

  4763.     if (X509_check_host(cert, (char *) name->data, name->len, 0, NULL) != 1) {
  4764.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  4765.                        "X509_check_host(): no match");
  4766.         goto failed;
  4767.     }

  4769.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  4770.                    "X509_check_host(): match");

  4772.     goto found;

  4774. #else
  4775.     {
  4776.     int                      n, i;
  4777.     X509_NAME               *sname;
  4778.     ASN1_STRING             *str;
  4779.     X509_NAME_ENTRY         *entry;
  4780.     GENERAL_NAME            *altname;
  4781.     STACK_OF(GENERAL_NAME)  *altnames;

  4783.     /*
  4784.      * As per RFC6125 and RFC2818, we check subjectAltName extension,
  4785.      * and if it's not present - commonName in Subject is checked.
  4786.      */

  4788.     altnames = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);

  4790.     if (altnames) {
  4791.         n = sk_GENERAL_NAME_num(altnames);

  4793.         for (i = 0; i < n; i++) {
  4794.             altname = sk_GENERAL_NAME_value(altnames, i);

  4796.             if (altname->type != GEN_DNS) {
  4797.                 continue;
  4798.             }

  4800.             str = altname->d.dNSName;

  4802.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  4803.                            "SSL subjectAltName: \"%*s\"",
  4804.                            ASN1_STRING_length(str), ASN1_STRING_data(str));

  4806.             if (ngx_ssl_check_name(name, str) == NGX_OK) {
  4807.                 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  4808.                                "SSL subjectAltName: match");
  4809.                 GENERAL_NAMES_free(altnames);
  4810.                 goto found;
  4811.             }
  4812.         }

  4814.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  4815.                        "SSL subjectAltName: no match");

  4817.         GENERAL_NAMES_free(altnames);
  4818.         goto failed;
  4819.     }

  4821.     /*
  4822.      * If there is no subjectAltName extension, check commonName
  4823.      * in Subject.  While RFC2818 requires to only check "most specific"
  4824.      * CN, both Apache and OpenSSL check all CNs, and so do we.
  4825.      */

  4827.     sname = X509_get_subject_name(cert);

  4829.     if (sname == NULL) {
  4830.         goto failed;
  4831.     }

  4833.     i = -1;
  4834.     for ( ;; ) {
  4835.         i = X509_NAME_get_index_by_NID(sname, NID_commonName, i);

  4837.         if (i < 0) {
  4838.             break;
  4839.         }

  4841.         entry = X509_NAME_get_entry(sname, i);
  4842.         str = X509_NAME_ENTRY_get_data(entry);

  4844.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  4845.                        "SSL commonName: \"%*s\"",
  4846.                        ASN1_STRING_length(str), ASN1_STRING_data(str));

  4848.         if (ngx_ssl_check_name(name, str) == NGX_OK) {
  4849.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  4850.                            "SSL commonName: match");
  4851.             goto found;
  4852.         }
  4853.     }

  4855.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  4856.                    "SSL commonName: no match");
  4857.     }
  4858. #endif

  4860. failed:

  4862.     X509_free(cert);
  4863.     return NGX_ERROR;

  4865. found:

  4867.     X509_free(cert);
  4868.     return NGX_OK;
  4869. }


  4872. #ifndef X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT

  4874. static ngx_int_t
  4875. ‌ngx_ssl_check_name(ngx_str_t *name, ASN1_STRING *pattern)
  4876. {
  4877.     u_char  *s, *p, *end;
  4878.     size_t   slen, plen;

  4880.     s = name->data;
  4881.     slen = name->len;

  4883.     p = ASN1_STRING_data(pattern);
  4884.     plen = ASN1_STRING_length(pattern);

  4886.     if (slen == plen && ngx_strncasecmp(s, p, plen) == 0) {
  4887.         return NGX_OK;
  4888.     }

  4890.     if (plen > 2 && p[0] == '*' && p[1] == '.') {
  4891.         plen -= 1;
  4892.         p += 1;

  4894.         end = s + slen;
  4895.         s = ngx_strlchr(s, end, '.');

  4897.         if (s == NULL) {
  4898.             return NGX_ERROR;
  4899.         }

  4901.         slen = end - s;

  4903.         if (plen == slen && ngx_strncasecmp(s, p, plen) == 0) {
  4904.             return NGX_OK;
  4905.         }
  4906.     }

  4908.     return NGX_ERROR;
  4909. }

  4911. #endif


  4914. ngx_int_t
  4915. ‌ngx_ssl_get_protocol(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  4916. {
  4917.     s->data = (u_char *) SSL_get_version(c->ssl->connection);
  4918.     return NGX_OK;
  4919. }


  4922. ngx_int_t
  4923. ‌ngx_ssl_get_cipher_name(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  4924. {
  4925.     s->data = (u_char *) SSL_get_cipher_name(c->ssl->connection);
  4926.     return NGX_OK;
  4927. }


  4930. ngx_int_t
  4931. ‌ngx_ssl_get_ciphers(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  4932. {
  4933. #ifdef SSL_CTRL_GET_RAW_CIPHERLIST

  4935.     int                n, i, bytes;
  4936.     size_t             len;
  4937.     u_char            *ciphers, *p;
  4938.     const SSL_CIPHER  *cipher;

  4940.     bytes = SSL_get0_raw_cipherlist(c->ssl->connection, NULL);
  4941.     n = SSL_get0_raw_cipherlist(c->ssl->connection, &ciphers);

  4943.     if (n <= 0) {
  4944.         s->len = 0;
  4945.         return NGX_OK;
  4946.     }

  4948.     len = 0;
  4949.     n /= bytes;

  4951.     for (i = 0; i < n; i++) {
  4952.         cipher = SSL_CIPHER_find(c->ssl->connection, ciphers + i * bytes);

  4954.         if (cipher) {
  4955.             len += ngx_strlen(SSL_CIPHER_get_name(cipher));

  4957.         } else {
  4958.             len += sizeof("0x") - 1 + bytes * (sizeof("00") - 1);
  4959.         }

  4961.         len += sizeof(":") - 1;
  4962.     }

  4964.     s->data = ngx_pnalloc(pool, len);
  4965.     if (s->data == NULL) {
  4966.         return NGX_ERROR;
  4967.     }

  4969.     p = s->data;

  4971.     for (i = 0; i < n; i++) {
  4972.         cipher = SSL_CIPHER_find(c->ssl->connection, ciphers + i * bytes);

  4974.         if (cipher) {
  4975.             p = ngx_sprintf(p, "%s", SSL_CIPHER_get_name(cipher));

  4977.         } else {
  4978.             p = ngx_sprintf(p, "0x");
  4979.             p = ngx_hex_dump(p, ciphers + i * bytes, bytes);
  4980.         }

  4982.         *p++ = ':';
  4983.     }

  4985.     p--;

  4987.     s->len = p - s->data;

  4989. #else

  4991.     u_char  buf[4096];

  4993.     if (SSL_get_shared_ciphers(c->ssl->connection, (char *) buf, 4096)
  4994.         == NULL)
  4995.     {
  4996.         s->len = 0;
  4997.         return NGX_OK;
  4998.     }

  5000.     s->len = ngx_strlen(buf);
  5001.     s->data = ngx_pnalloc(pool, s->len);
  5002.     if (s->data == NULL) {
  5003.         return NGX_ERROR;
  5004.     }

  5006.     ngx_memcpy(s->data, buf, s->len);

  5008. #endif

  5010.     return NGX_OK;
  5011. }


  5014. ngx_int_t
  5015. ‌ngx_ssl_get_curve(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5016. {
  5017. #ifdef SSL_get_negotiated_group

  5019.     int  nid;

  5021.     nid = SSL_get_negotiated_group(c->ssl->connection);

  5023.     if (nid != NID_undef) {

  5025.         if ((nid & TLSEXT_nid_unknown) == 0) {
  5026.             s->len = ngx_strlen(OBJ_nid2sn(nid));
  5027.             s->data = (u_char *) OBJ_nid2sn(nid);
  5028.             return NGX_OK;
  5029.         }

  5031.         s->len = sizeof("0x0000") - 1;

  5033.         s->data = ngx_pnalloc(pool, s->len);
  5034.         if (s->data == NULL) {
  5035.             return NGX_ERROR;
  5036.         }

  5038.         ngx_sprintf(s->data, "0x%04xd", nid & 0xffff);

  5040.         return NGX_OK;
  5041.     }

  5043. #endif

  5045.     s->len = 0;
  5046.     return NGX_OK;
  5047. }


  5050. ngx_int_t
  5051. ‌ngx_ssl_get_curves(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5052. {
  5053. #ifdef SSL_CTRL_GET_CURVES

  5055.     int         *curves, n, i, nid;
  5056.     u_char      *p;
  5057.     size_t       len;

  5059.     n = SSL_get1_curves(c->ssl->connection, NULL);

  5061.     if (n <= 0) {
  5062.         s->len = 0;
  5063.         return NGX_OK;
  5064.     }

  5066.     curves = ngx_palloc(pool, n * sizeof(int));
  5067.     if (curves == NULL) {
  5068.         return NGX_ERROR;
  5069.     }

  5071.     n = SSL_get1_curves(c->ssl->connection, curves);
  5072.     len = 0;

  5074.     for (i = 0; i < n; i++) {
  5075.         nid = curves[i];

  5077.         if (nid & TLSEXT_nid_unknown) {
  5078.             len += sizeof("0x0000") - 1;

  5080.         } else {
  5081.             len += ngx_strlen(OBJ_nid2sn(nid));
  5082.         }

  5084.         len += sizeof(":") - 1;
  5085.     }

  5087.     s->data = ngx_pnalloc(pool, len);
  5088.     if (s->data == NULL) {
  5089.         return NGX_ERROR;
  5090.     }

  5092.     p = s->data;

  5094.     for (i = 0; i < n; i++) {
  5095.         nid = curves[i];

  5097.         if (nid & TLSEXT_nid_unknown) {
  5098.             p = ngx_sprintf(p, "0x%04xd", nid & 0xffff);

  5100.         } else {
  5101.             p = ngx_sprintf(p, "%s", OBJ_nid2sn(nid));
  5102.         }

  5104.         *p++ = ':';
  5105.     }

  5107.     p--;

  5109.     s->len = p - s->data;

  5111. #else

  5113.     s->len = 0;

  5115. #endif

  5117.     return NGX_OK;
  5118. }


  5121. ngx_int_t
  5122. ‌ngx_ssl_get_session_id(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5123. {
  5124.     u_char        *buf;
  5125.     SSL_SESSION   *sess;
  5126.     unsigned int   len;

  5128.     sess = SSL_get0_session(c->ssl->connection);
  5129.     if (sess == NULL) {
  5130.         s->len = 0;
  5131.         return NGX_OK;
  5132.     }

  5134.     buf = (u_char *) SSL_SESSION_get_id(sess, &len);

  5136.     s->len = 2 * len;
  5137.     s->data = ngx_pnalloc(pool, 2 * len);
  5138.     if (s->data == NULL) {
  5139.         return NGX_ERROR;
  5140.     }

  5142.     ngx_hex_dump(s->data, buf, len);

  5144.     return NGX_OK;
  5145. }


  5148. ngx_int_t
  5149. ‌ngx_ssl_get_session_reused(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5150. {
  5151.     if (SSL_session_reused(c->ssl->connection)) {
  5152.         ngx_str_set(s, "r");

  5154.     } else {
  5155.         ngx_str_set(s, ".");
  5156.     }

  5158.     return NGX_OK;
  5159. }


  5162. ngx_int_t
  5163. ‌ngx_ssl_get_early_data(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5164. {
  5165.     s->len = 0;

  5167. #ifdef SSL_ERROR_EARLY_DATA_REJECTED

  5169.     /* BoringSSL */

  5171.     if (SSL_in_early_data(c->ssl->connection)) {
  5172.         ngx_str_set(s, "1");
  5173.     }

  5175. #elif defined SSL_READ_EARLY_DATA_SUCCESS

  5177.     /* OpenSSL */

  5179.     if (!SSL_is_init_finished(c->ssl->connection)) {
  5180.         ngx_str_set(s, "1");
  5181.     }

  5183. #endif

  5185.     return NGX_OK;
  5186. }


  5189. ngx_int_t
  5190. ‌ngx_ssl_get_server_name(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5191. {
  5192. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

  5194.     size_t       len;
  5195.     const char  *name;

  5197.     name = SSL_get_servername(c->ssl->connection, TLSEXT_NAMETYPE_host_name);

  5199.     if (name) {
  5200.         len = ngx_strlen(name);

  5202.         s->len = len;
  5203.         s->data = ngx_pnalloc(pool, len);
  5204.         if (s->data == NULL) {
  5205.             return NGX_ERROR;
  5206.         }

  5208.         ngx_memcpy(s->data, name, len);

  5210.         return NGX_OK;
  5211.     }

  5213. #endif

  5215.     s->len = 0;
  5216.     return NGX_OK;
  5217. }


  5220. ngx_int_t
  5221. ‌ngx_ssl_get_alpn_protocol(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5222. {
  5223. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  5225.     unsigned int          len;
  5226.     const unsigned char  *data;

  5228.     SSL_get0_alpn_selected(c->ssl->connection, &data, &len);

  5230.     if (len > 0) {

  5232.         s->data = ngx_pnalloc(pool, len);
  5233.         if (s->data == NULL) {
  5234.             return NGX_ERROR;
  5235.         }

  5237.         ngx_memcpy(s->data, data, len);
  5238.         s->len = len;

  5240.         return NGX_OK;
  5241.     }

  5243. #endif

  5245.     s->len = 0;
  5246.     return NGX_OK;
  5247. }


  5250. ngx_int_t
  5251. ‌ngx_ssl_get_raw_certificate(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5252. {
  5253.     size_t   len;
  5254.     BIO     *bio;
  5255.     X509    *cert;

  5257.     s->len = 0;

  5259.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5260.     if (cert == NULL) {
  5261.         return NGX_OK;
  5262.     }

  5264.     bio = BIO_new(BIO_s_mem());
  5265.     if (bio == NULL) {
  5266.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  5267.         X509_free(cert);
  5268.         return NGX_ERROR;
  5269.     }

  5271.     if (PEM_write_bio_X509(bio, cert) == 0) {
  5272.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "PEM_write_bio_X509() failed");
  5273.         goto failed;
  5274.     }

  5276.     len = BIO_pending(bio);
  5277.     s->len = len;

  5279.     s->data = ngx_pnalloc(pool, len);
  5280.     if (s->data == NULL) {
  5281.         goto failed;
  5282.     }

  5284.     BIO_read(bio, s->data, len);

  5286.     BIO_free(bio);
  5287.     X509_free(cert);

  5289.     return NGX_OK;

  5291. failed:

  5293.     BIO_free(bio);
  5294.     X509_free(cert);

  5296.     return NGX_ERROR;
  5297. }


  5300. ngx_int_t
  5301. ‌ngx_ssl_get_certificate(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5302. {
  5303.     u_char      *p;
  5304.     size_t       len;
  5305.     ngx_uint_t   i;
  5306.     ngx_str_t    cert;

  5308.     if (ngx_ssl_get_raw_certificate(c, pool, &cert) != NGX_OK) {
  5309.         return NGX_ERROR;
  5310.     }

  5312.     if (cert.len == 0) {
  5313.         s->len = 0;
  5314.         return NGX_OK;
  5315.     }

  5317.     len = cert.len - 1;

  5319.     for (i = 0; i < cert.len - 1; i++) {
  5320.         if (cert.data[i] == LF) {
  5321.             len++;
  5322.         }
  5323.     }

  5325.     s->len = len;
  5326.     s->data = ngx_pnalloc(pool, len);
  5327.     if (s->data == NULL) {
  5328.         return NGX_ERROR;
  5329.     }

  5331.     p = s->data;

  5333.     for (i = 0; i < cert.len - 1; i++) {
  5334.         *p++ = cert.data[i];
  5335.         if (cert.data[i] == LF) {
  5336.             *p++ = '\t';
  5337.         }
  5338.     }

  5340.     return NGX_OK;
  5341. }


  5344. ngx_int_t
  5345. ‌ngx_ssl_get_escaped_certificate(ngx_connection_t *c, ngx_pool_t *pool,
  5346.     ngx_str_t *s)
  5347. {
  5348.     ngx_str_t  cert;
  5349.     uintptr_t  n;

  5351.     if (ngx_ssl_get_raw_certificate(c, pool, &cert) != NGX_OK) {
  5352.         return NGX_ERROR;
  5353.     }

  5355.     if (cert.len == 0) {
  5356.         s->len = 0;
  5357.         return NGX_OK;
  5358.     }

  5360.     n = ngx_escape_uri(NULL, cert.data, cert.len, NGX_ESCAPE_URI_COMPONENT);

  5362.     s->len = cert.len + n * 2;
  5363.     s->data = ngx_pnalloc(pool, s->len);
  5364.     if (s->data == NULL) {
  5365.         return NGX_ERROR;
  5366.     }

  5368.     ngx_escape_uri(s->data, cert.data, cert.len, NGX_ESCAPE_URI_COMPONENT);

  5370.     return NGX_OK;
  5371. }


  5374. ngx_int_t
  5375. ‌ngx_ssl_get_subject_dn(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5376. {
  5377.     BIO        *bio;
  5378.     X509       *cert;
  5379.     X509_NAME  *name;

  5381.     s->len = 0;

  5383.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5384.     if (cert == NULL) {
  5385.         return NGX_OK;
  5386.     }

  5388.     name = X509_get_subject_name(cert);
  5389.     if (name == NULL) {
  5390.         X509_free(cert);
  5391.         return NGX_ERROR;
  5392.     }

  5394.     bio = BIO_new(BIO_s_mem());
  5395.     if (bio == NULL) {
  5396.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  5397.         X509_free(cert);
  5398.         return NGX_ERROR;
  5399.     }

  5401.     if (X509_NAME_print_ex(bio, name, 0, XN_FLAG_RFC2253) < 0) {
  5402.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_print_ex() failed");
  5403.         goto failed;
  5404.     }

  5406.     s->len = BIO_pending(bio);
  5407.     s->data = ngx_pnalloc(pool, s->len);
  5408.     if (s->data == NULL) {
  5409.         goto failed;
  5410.     }

  5412.     BIO_read(bio, s->data, s->len);

  5414.     BIO_free(bio);
  5415.     X509_free(cert);

  5417.     return NGX_OK;

  5419. failed:

  5421.     BIO_free(bio);
  5422.     X509_free(cert);

  5424.     return NGX_ERROR;
  5425. }


  5428. ngx_int_t
  5429. ‌ngx_ssl_get_issuer_dn(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5430. {
  5431.     BIO        *bio;
  5432.     X509       *cert;
  5433.     X509_NAME  *name;

  5435.     s->len = 0;

  5437.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5438.     if (cert == NULL) {
  5439.         return NGX_OK;
  5440.     }

  5442.     name = X509_get_issuer_name(cert);
  5443.     if (name == NULL) {
  5444.         X509_free(cert);
  5445.         return NGX_ERROR;
  5446.     }

  5448.     bio = BIO_new(BIO_s_mem());
  5449.     if (bio == NULL) {
  5450.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  5451.         X509_free(cert);
  5452.         return NGX_ERROR;
  5453.     }

  5455.     if (X509_NAME_print_ex(bio, name, 0, XN_FLAG_RFC2253) < 0) {
  5456.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_print_ex() failed");
  5457.         goto failed;
  5458.     }

  5460.     s->len = BIO_pending(bio);
  5461.     s->data = ngx_pnalloc(pool, s->len);
  5462.     if (s->data == NULL) {
  5463.         goto failed;
  5464.     }

  5466.     BIO_read(bio, s->data, s->len);

  5468.     BIO_free(bio);
  5469.     X509_free(cert);

  5471.     return NGX_OK;

  5473. failed:

  5475.     BIO_free(bio);
  5476.     X509_free(cert);

  5478.     return NGX_ERROR;
  5479. }


  5482. ngx_int_t
  5483. ‌ngx_ssl_get_subject_dn_legacy(ngx_connection_t *c, ngx_pool_t *pool,
  5484.     ngx_str_t *s)
  5485. {
  5486.     char       *p;
  5487.     size_t      len;
  5488.     X509       *cert;
  5489.     X509_NAME  *name;

  5491.     s->len = 0;

  5493.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5494.     if (cert == NULL) {
  5495.         return NGX_OK;
  5496.     }

  5498.     name = X509_get_subject_name(cert);
  5499.     if (name == NULL) {
  5500.         X509_free(cert);
  5501.         return NGX_ERROR;
  5502.     }

  5504.     p = X509_NAME_oneline(name, NULL, 0);
  5505.     if (p == NULL) {
  5506.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_oneline() failed");
  5507.         X509_free(cert);
  5508.         return NGX_ERROR;
  5509.     }

  5511.     for (len = 0; p[len]; len++) { /* void */ }

  5513.     s->len = len;
  5514.     s->data = ngx_pnalloc(pool, len);
  5515.     if (s->data == NULL) {
  5516.         OPENSSL_free(p);
  5517.         X509_free(cert);
  5518.         return NGX_ERROR;
  5519.     }

  5521.     ngx_memcpy(s->data, p, len);

  5523.     OPENSSL_free(p);
  5524.     X509_free(cert);

  5526.     return NGX_OK;
  5527. }


  5530. ngx_int_t
  5531. ‌ngx_ssl_get_issuer_dn_legacy(ngx_connection_t *c, ngx_pool_t *pool,
  5532.     ngx_str_t *s)
  5533. {
  5534.     char       *p;
  5535.     size_t      len;
  5536.     X509       *cert;
  5537.     X509_NAME  *name;

  5539.     s->len = 0;

  5541.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5542.     if (cert == NULL) {
  5543.         return NGX_OK;
  5544.     }

  5546.     name = X509_get_issuer_name(cert);
  5547.     if (name == NULL) {
  5548.         X509_free(cert);
  5549.         return NGX_ERROR;
  5550.     }

  5552.     p = X509_NAME_oneline(name, NULL, 0);
  5553.     if (p == NULL) {
  5554.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_oneline() failed");
  5555.         X509_free(cert);
  5556.         return NGX_ERROR;
  5557.     }

  5559.     for (len = 0; p[len]; len++) { /* void */ }

  5561.     s->len = len;
  5562.     s->data = ngx_pnalloc(pool, len);
  5563.     if (s->data == NULL) {
  5564.         OPENSSL_free(p);
  5565.         X509_free(cert);
  5566.         return NGX_ERROR;
  5567.     }

  5569.     ngx_memcpy(s->data, p, len);

  5571.     OPENSSL_free(p);
  5572.     X509_free(cert);

  5574.     return NGX_OK;
  5575. }


  5578. ngx_int_t
  5579. ‌ngx_ssl_get_serial_number(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5580. {
  5581.     size_t   len;
  5582.     X509    *cert;
  5583.     BIO     *bio;

  5585.     s->len = 0;

  5587.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5588.     if (cert == NULL) {
  5589.         return NGX_OK;
  5590.     }

  5592.     bio = BIO_new(BIO_s_mem());
  5593.     if (bio == NULL) {
  5594.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  5595.         X509_free(cert);
  5596.         return NGX_ERROR;
  5597.     }

  5599.     i2a_ASN1_INTEGER(bio, X509_get_serialNumber(cert));
  5600.     len = BIO_pending(bio);

  5602.     s->len = len;
  5603.     s->data = ngx_pnalloc(pool, len);
  5604.     if (s->data == NULL) {
  5605.         BIO_free(bio);
  5606.         X509_free(cert);
  5607.         return NGX_ERROR;
  5608.     }

  5610.     BIO_read(bio, s->data, len);
  5611.     BIO_free(bio);
  5612.     X509_free(cert);

  5614.     return NGX_OK;
  5615. }


  5618. ngx_int_t
  5619. ‌ngx_ssl_get_fingerprint(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5620. {
  5621.     X509          *cert;
  5622.     unsigned int   len;
  5623.     u_char         buf[EVP_MAX_MD_SIZE];

  5625.     s->len = 0;

  5627.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5628.     if (cert == NULL) {
  5629.         return NGX_OK;
  5630.     }

  5632.     if (!X509_digest(cert, EVP_sha1(), buf, &len)) {
  5633.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_digest() failed");
  5634.         X509_free(cert);
  5635.         return NGX_ERROR;
  5636.     }

  5638.     s->len = 2 * len;
  5639.     s->data = ngx_pnalloc(pool, 2 * len);
  5640.     if (s->data == NULL) {
  5641.         X509_free(cert);
  5642.         return NGX_ERROR;
  5643.     }

  5645.     ngx_hex_dump(s->data, buf, len);

  5647.     X509_free(cert);

  5649.     return NGX_OK;
  5650. }


  5653. ngx_int_t
  5654. ‌ngx_ssl_get_client_verify(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5655. {
  5656.     X509        *cert;
  5657.     long         rc;
  5658.     const char  *str;

  5660.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5661.     if (cert == NULL) {
  5662.         ngx_str_set(s, "NONE");
  5663.         return NGX_OK;
  5664.     }

  5666.     X509_free(cert);

  5668.     rc = SSL_get_verify_result(c->ssl->connection);

  5670.     if (rc == X509_V_OK) {
  5671.         if (ngx_ssl_ocsp_get_status(c, &str) == NGX_OK) {
  5672.             ngx_str_set(s, "SUCCESS");
  5673.             return NGX_OK;
  5674.         }

  5676.     } else {
  5677.         str = X509_verify_cert_error_string(rc);
  5678.     }

  5680.     s->data = ngx_pnalloc(pool, sizeof("FAILED:") - 1 + ngx_strlen(str));
  5681.     if (s->data == NULL) {
  5682.         return NGX_ERROR;
  5683.     }

  5685.     s->len = ngx_sprintf(s->data, "FAILED:%s", str) - s->data;

  5687.     return NGX_OK;
  5688. }


  5691. ngx_int_t
  5692. ‌ngx_ssl_get_client_v_start(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5693. {
  5694.     BIO     *bio;
  5695.     X509    *cert;
  5696.     size_t   len;

  5698.     s->len = 0;

  5700.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5701.     if (cert == NULL) {
  5702.         return NGX_OK;
  5703.     }

  5705.     bio = BIO_new(BIO_s_mem());
  5706.     if (bio == NULL) {
  5707.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  5708.         X509_free(cert);
  5709.         return NGX_ERROR;
  5710.     }

  5712. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  5713.     ASN1_TIME_print(bio, X509_get0_notBefore(cert));
  5714. #else
  5715.     ASN1_TIME_print(bio, X509_get_notBefore(cert));
  5716. #endif

  5718.     len = BIO_pending(bio);

  5720.     s->len = len;
  5721.     s->data = ngx_pnalloc(pool, len);
  5722.     if (s->data == NULL) {
  5723.         BIO_free(bio);
  5724.         X509_free(cert);
  5725.         return NGX_ERROR;
  5726.     }

  5728.     BIO_read(bio, s->data, len);
  5729.     BIO_free(bio);
  5730.     X509_free(cert);

  5732.     return NGX_OK;
  5733. }


  5736. ngx_int_t
  5737. ‌ngx_ssl_get_client_v_end(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5738. {
  5739.     BIO     *bio;
  5740.     X509    *cert;
  5741.     size_t   len;

  5743.     s->len = 0;

  5745.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5746.     if (cert == NULL) {
  5747.         return NGX_OK;
  5748.     }

  5750.     bio = BIO_new(BIO_s_mem());
  5751.     if (bio == NULL) {
  5752.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  5753.         X509_free(cert);
  5754.         return NGX_ERROR;
  5755.     }

  5757. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  5758.     ASN1_TIME_print(bio, X509_get0_notAfter(cert));
  5759. #else
  5760.     ASN1_TIME_print(bio, X509_get_notAfter(cert));
  5761. #endif

  5763.     len = BIO_pending(bio);

  5765.     s->len = len;
  5766.     s->data = ngx_pnalloc(pool, len);
  5767.     if (s->data == NULL) {
  5768.         BIO_free(bio);
  5769.         X509_free(cert);
  5770.         return NGX_ERROR;
  5771.     }

  5773.     BIO_read(bio, s->data, len);
  5774.     BIO_free(bio);
  5775.     X509_free(cert);

  5777.     return NGX_OK;
  5778. }


  5781. ngx_int_t
  5782. ‌ngx_ssl_get_client_v_remain(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5783. {
  5784.     X509    *cert;
  5785.     time_t   now, end;

  5787.     s->len = 0;

  5789.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5790.     if (cert == NULL) {
  5791.         return NGX_OK;
  5792.     }

  5794. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  5795.     end = ngx_ssl_parse_time(X509_get0_notAfter(cert), c->log);
  5796. #else
  5797.     end = ngx_ssl_parse_time(X509_get_notAfter(cert), c->log);
  5798. #endif

  5800.     if (end == (time_t) NGX_ERROR) {
  5801.         X509_free(cert);
  5802.         return NGX_OK;
  5803.     }

  5805.     now = ngx_time();

  5807.     if (end < now + 86400) {
  5808.         ngx_str_set(s, "0");
  5809.         X509_free(cert);
  5810.         return NGX_OK;
  5811.     }

  5813.     s->data = ngx_pnalloc(pool, NGX_TIME_T_LEN);
  5814.     if (s->data == NULL) {
  5815.         X509_free(cert);
  5816.         return NGX_ERROR;
  5817.     }

  5819.     s->len = ngx_sprintf(s->data, "%T", (end - now) / 86400) - s->data;

  5821.     X509_free(cert);

  5823.     return NGX_OK;
  5824. }


  5827. static time_t
  5828. ‌ngx_ssl_parse_time(
  5829. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  5830.     const
  5831. #endif
  5832.     ASN1_TIME *asn1time, ngx_log_t *log)
  5833. {
  5834.     BIO     *bio;
  5835.     char    *value;
  5836.     size_t   len;
  5837.     time_t   time;

  5839.     /*
  5840.      * OpenSSL doesn't provide a way to convert ASN1_TIME
  5841.      * into time_t.  To do this, we use ASN1_TIME_print(),
  5842.      * which uses the "MMM DD HH:MM:SS YYYY [GMT]" format (e.g.,
  5843.      * "Feb  3 00:55:52 2015 GMT"), and parse the result.
  5844.      */

  5846.     bio = BIO_new(BIO_s_mem());
  5847.     if (bio == NULL) {
  5848.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "BIO_new() failed");
  5849.         return NGX_ERROR;
  5850.     }

  5852.     /* fake weekday prepended to match C asctime() format */

  5854.     BIO_write(bio, "Tue ", sizeof("Tue ") - 1);
  5855.     ASN1_TIME_print(bio, asn1time);
  5856.     len = BIO_get_mem_data(bio, &value);

  5858.     time = ngx_parse_http_time((u_char *) value, len);

  5860.     BIO_free(bio);

  5862.     return time;
  5863. }


  5866. static void *
  5867. ‌ngx_openssl_create_conf(ngx_cycle_t *cycle)
  5868. {
  5869.     ngx_openssl_conf_t  *oscf;

  5871.     oscf = ngx_pcalloc(cycle->pool, sizeof(ngx_openssl_conf_t));
  5872.     if (oscf == NULL) {
  5873.         return NULL;
  5874.     }

  5876.     /*
  5877.      * set by ngx_pcalloc():
  5878.      *
  5879.      *     oscf->engine = 0;
  5880.      */

  5882.     return oscf;
  5883. }


  5886. static char *
  5887. ‌ngx_openssl_engine(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5888. {
  5889. #ifndef OPENSSL_NO_ENGINE

  5891.     ngx_openssl_conf_t *oscf = conf;

  5893.     ENGINE     *engine;
  5894.     ngx_str_t  *value;

  5896.     if (oscf->engine) {
  5897.         return "is duplicate";
  5898.     }

  5900.     oscf->engine = 1;

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

  5904.     engine = ENGINE_by_id((char *) value[1].data);

  5906.     if (engine == NULL) {
  5907.         ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
  5908.                       "ENGINE_by_id(\"%V\") failed", &value[1]);
  5909.         return NGX_CONF_ERROR;
  5910.     }

  5912.     if (ENGINE_set_default(engine, ENGINE_METHOD_ALL) == 0) {
  5913.         ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
  5914.                       "ENGINE_set_default(\"%V\", ENGINE_METHOD_ALL) failed",
  5915.                       &value[1]);

  5917.         ENGINE_free(engine);

  5919.         return NGX_CONF_ERROR;
  5920.     }

  5922.     ENGINE_free(engine);

  5924.     return NGX_CONF_OK;

  5926. #else

  5928.     return "is not supported";

  5930. #endif
  5931. }


  5934. static void
  5935. ‌ngx_openssl_exit(ngx_cycle_t *cycle)
  5936. {
  5937. #if OPENSSL_VERSION_NUMBER < 0x10100003L

  5939.     EVP_cleanup();
  5940. #ifndef OPENSSL_NO_ENGINE
  5941.     ENGINE_cleanup();
  5942. #endif

  5944. #endif
  5945. }

One Level Up Top Level