One Level Up Top Level

src/event/ngx_event_openssl.c - nginx-1.31.7 nginx/ @ 939334eff

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>

  12. #if (NGX_ZLIB && defined TLSEXT_cert_compression_zlib)
  13. #include <zlib.h>
  14. #endif


  17. ‌#define NGX_SSL_PASSWORD_BUFFER_SIZE  4096


  20. ‌typedef struct {
  21.     ngx_uint_t  engine;   /* unsigned  engine:1; */
  22. ‌} ngx_openssl_conf_t;


  25. static ngx_inline ngx_int_t ngx_ssl_cert_already_in_hash(void);
  26. #if (NGX_ZLIB && defined TLSEXT_cert_compression_zlib)
  27. static int ngx_ssl_cert_compression_callback(ngx_ssl_conn_t *ssl_conn,
  28.     CBB *out, const uint8_t *in, size_t in_len);
  29. static void *ngx_ssl_cert_compression_alloc(void *opaque, u_int items,
  30.     u_int size);
  31. static void ngx_ssl_cert_compression_free(void *opaque, void *address);
  32. #endif
  33. static int ngx_ssl_verify_callback(int ok, X509_STORE_CTX *x509_store);
  34. static void ngx_ssl_info_callback(const ngx_ssl_conn_t *ssl_conn, int where,
  35.     int ret);
  36. static int ngx_ssl_cmp_x509_name(const X509_NAME *const *a,
  37.     const X509_NAME *const *b);
  38. static void ngx_ssl_passwords_cleanup(void *data);
  39. static int ngx_ssl_new_client_session(ngx_ssl_conn_t *ssl_conn,
  40.     ngx_ssl_session_t *sess);
  41. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  42. static ngx_int_t ngx_ssl_try_early_data(ngx_connection_t *c);
  43. #endif
  44. static void ngx_ssl_handshake_handler(ngx_event_t *ev);
  45. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  46. static ssize_t ngx_ssl_recv_early(ngx_connection_t *c, u_char *buf,
  47.     size_t size);
  48. #endif
  49. static ngx_int_t ngx_ssl_handle_recv(ngx_connection_t *c, int n);
  50. static void ngx_ssl_write_handler(ngx_event_t *wev);
  51. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  52. static ssize_t ngx_ssl_write_early(ngx_connection_t *c, u_char *data,
  53.     size_t size);
  54. #endif
  55. static ssize_t ngx_ssl_sendfile(ngx_connection_t *c, ngx_buf_t *file,
  56.     size_t size);
  57. static void ngx_ssl_read_handler(ngx_event_t *rev);
  58. static void ngx_ssl_shutdown_handler(ngx_event_t *ev);
  59. static void ngx_ssl_clear_error(ngx_log_t *log);

  61. static ngx_int_t ngx_ssl_session_id_context(ngx_ssl_t *ssl,
  62.     ngx_str_t *sess_ctx, ngx_array_t *certificates);
  63. static int ngx_ssl_new_session(ngx_ssl_conn_t *ssl_conn,
  64.     ngx_ssl_session_t *sess);
  65. static ngx_ssl_session_t *ngx_ssl_get_cached_session(ngx_ssl_conn_t *ssl_conn,
  66. #if OPENSSL_VERSION_NUMBER >= 0x10100003L
  67.     const
  68. #endif
  69.     u_char *id, int len, int *copy);
  70. static void ngx_ssl_remove_session(SSL_CTX *ssl, ngx_ssl_session_t *sess);
  71. static void ngx_ssl_expire_sessions(ngx_ssl_session_cache_t *cache,
  72.     ngx_slab_pool_t *shpool, ngx_uint_t n);
  73. static void ngx_ssl_session_rbtree_insert_value(ngx_rbtree_node_t *temp,
  74.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);

  76. #ifdef SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB
  77. static int ngx_ssl_ticket_key_callback(ngx_ssl_conn_t *ssl_conn,
  78.     unsigned char *name, unsigned char *iv, EVP_CIPHER_CTX *ectx,
  79.     HMAC_CTX *hctx, int enc);
  80. static ngx_int_t ngx_ssl_rotate_ticket_keys(SSL_CTX *ssl_ctx, ngx_log_t *log);
  81. static void ngx_ssl_ticket_keys_cleanup(void *data);
  82. #endif

  84. #ifndef X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT
  85. static ngx_int_t ngx_ssl_check_name(ngx_str_t *name, ASN1_STRING *str);
  86. #endif

  88. static time_t ngx_ssl_parse_time(
  89. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  90.     const
  91. #endif
  92.     ASN1_TIME *asn1time, ngx_log_t *log);

  94. static void *ngx_openssl_create_conf(ngx_cycle_t *cycle);
  95. static char *ngx_openssl_engine(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  96. static void ngx_openssl_exit(ngx_cycle_t *cycle);


  99. ‌static ngx_command_t  ngx_openssl_commands[] = {

  101.     { ngx_string("ssl_engine"),
  102.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  103.       ngx_openssl_engine,
  104.       0,
  105.       0,
  106.       NULL },

  108.       ngx_null_command
  109. };


  112. ‌static ngx_core_module_t  ngx_openssl_module_ctx = {
  113.     ngx_string("openssl"),
  114.     ngx_openssl_create_conf,
  115.     NULL
  116. };


  119. ‌ngx_module_t  ngx_openssl_module = {
  120.     NGX_MODULE_V1,
  121.     &ngx_openssl_module_ctx,               /* module context */
  122.     ngx_openssl_commands,                  /* module directives */
  123.     NGX_CORE_MODULE,                       /* module type */
  124.     NULL,                                  /* init master */
  125.     NULL,                                  /* init module */
  126.     NULL,                                  /* init process */
  127.     NULL,                                  /* init thread */
  128.     NULL,                                  /* exit thread */
  129.     NULL,                                  /* exit process */
  130.     ngx_openssl_exit,                      /* exit master */
  131.     NGX_MODULE_V1_PADDING
  132. };


  135. ‌int  ngx_ssl_connection_index;
  136. ‌int  ngx_ssl_server_conf_index;
  137. ‌int  ngx_ssl_session_cache_index;
  138. ‌int  ngx_ssl_ticket_keys_index;
  139. ‌int  ngx_ssl_ocsp_index;
  140. ‌int  ngx_ssl_index;
  141. ‌int  ngx_ssl_certificate_name_index;
  142. ‌int  ngx_ssl_certificate_comp_index;
  143. ‌int  ngx_ssl_client_hello_arg_index;


  146. ‌u_char  ngx_ssl_session_buffer[NGX_SSL_MAX_SESSION_SIZE];


  149. ngx_int_t
  150. ‌ngx_ssl_init(ngx_log_t *log)
  151. {
  152. #if (OPENSSL_INIT_LOAD_CONFIG && !defined LIBRESSL_VERSION_NUMBER)

  154.     uint64_t                opts;
  155.     OPENSSL_INIT_SETTINGS  *init;

  157.     opts = OPENSSL_INIT_LOAD_CONFIG;

  159. #if (NGX_OPENSSL_NO_CONFIG)

  161.     if (getenv("OPENSSL_CONF") == NULL) {
  162.         opts = OPENSSL_INIT_NO_LOAD_CONFIG;
  163.     }

  165. #endif

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

  173. #ifndef OPENSSL_NO_STDIO
  174.     if (OPENSSL_INIT_set_config_appname(init, "nginx") == 0) {
  175.         ngx_ssl_error(NGX_LOG_ALERT, log, 0,
  176.                       "OPENSSL_INIT_set_config_appname() failed");
  177.         return NGX_ERROR;
  178.     }
  179. #endif

  181.     if (OPENSSL_init_ssl(opts, init) == 0) {
  182.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "OPENSSL_init_ssl() failed");
  183.         return NGX_ERROR;
  184.     }

  186.     OPENSSL_INIT_free(init);

  188.     /*
  189.      * OPENSSL_init_ssl() may leave errors in the error queue
  190.      * while returning success
  191.      */

  193.     ERR_clear_error();

  195. #else

  197. #if (NGX_OPENSSL_NO_CONFIG)

  199.     if (getenv("OPENSSL_CONF") == NULL) {
  200.         OPENSSL_no_config();
  201.     }

  203. #endif

  205.     OPENSSL_config("nginx");

  207.     SSL_library_init();
  208.     SSL_load_error_strings();

  210.     OpenSSL_add_all_algorithms();

  212. #endif

  214. #ifndef SSL_OP_NO_COMPRESSION
  215.     {
  216.     /*
  217.      * Disable gzip compression in OpenSSL prior to 1.0.0 version,
  218.      * this saves about 522K per connection.
  219.      */
  220.     int                  n;
  221.     STACK_OF(SSL_COMP)  *ssl_comp_methods;

  223.     ssl_comp_methods = SSL_COMP_get_compression_methods();
  224.     n = sk_SSL_COMP_num(ssl_comp_methods);

  226.     while (n--) {
  227.         (void) sk_SSL_COMP_pop(ssl_comp_methods);
  228.     }
  229.     }
  230. #endif

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

  234.     if (ngx_ssl_connection_index == -1) {
  235.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "SSL_get_ex_new_index() failed");
  236.         return NGX_ERROR;
  237.     }

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

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

  255.     ngx_ssl_ticket_keys_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL,
  256.                                                          NULL);
  257.     if (ngx_ssl_ticket_keys_index == -1) {
  258.         ngx_ssl_error(NGX_LOG_ALERT, log, 0,
  259.                       "SSL_CTX_get_ex_new_index() failed");
  260.         return NGX_ERROR;
  261.     }

  263.     ngx_ssl_ocsp_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL, NULL);
  264.     if (ngx_ssl_ocsp_index == -1) {
  265.         ngx_ssl_error(NGX_LOG_ALERT, log, 0,
  266.                       "SSL_CTX_get_ex_new_index() failed");
  267.         return NGX_ERROR;
  268.     }

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

  272.     if (ngx_ssl_index == -1) {
  273.         ngx_ssl_error(NGX_LOG_ALERT, log, 0,
  274.                       "SSL_CTX_get_ex_new_index() failed");
  275.         return NGX_ERROR;
  276.     }

  278.     ngx_ssl_certificate_name_index = X509_get_ex_new_index(0, NULL, NULL, NULL,
  279.                                                            NULL);

  281.     if (ngx_ssl_certificate_name_index == -1) {
  282.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "X509_get_ex_new_index() failed");
  283.         return NGX_ERROR;
  284.     }

  286.     ngx_ssl_certificate_comp_index = X509_get_ex_new_index(0, NULL, NULL, NULL,
  287.                                                            NULL);
  288.     if (ngx_ssl_certificate_comp_index == -1) {
  289.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "X509_get_ex_new_index() failed");
  290.         return NGX_ERROR;
  291.     }

  293.     ngx_ssl_client_hello_arg_index = SSL_CTX_get_ex_new_index(0, NULL, NULL,
  294.                                                               NULL, NULL);
  295.     if (ngx_ssl_client_hello_arg_index == -1) {
  296.         ngx_ssl_error(NGX_LOG_ALERT, log, 0,
  297.                       "SSL_CTX_get_ex_new_index() failed");
  298.         return NGX_ERROR;
  299.     }

  301.     return NGX_OK;
  302. }


  305. ngx_int_t
  306. ‌ngx_ssl_create(ngx_ssl_t *ssl, ngx_uint_t protocols, void *data)
  307. {
  308.     ssl->ctx = SSL_CTX_new(SSLv23_method());

  310.     if (ssl->ctx == NULL) {
  311.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0, "SSL_CTX_new() failed");
  312.         return NGX_ERROR;
  313.     }

  315.     if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_server_conf_index, data) == 0) {
  316.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  317.                       "SSL_CTX_set_ex_data() failed");
  318.         return NGX_ERROR;
  319.     }

  321.     if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_index, ssl) == 0) {
  322.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  323.                       "SSL_CTX_set_ex_data() failed");
  324.         return NGX_ERROR;
  325.     }

  327.     ngx_rbtree_init(&ssl->staple_rbtree, &ssl->staple_sentinel,
  328.                     ngx_rbtree_insert_value);

  330.     ssl->buffer_size = NGX_SSL_BUFSIZE;

  332.     /* client side options */

  334. #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
  335.     SSL_CTX_set_options(ssl->ctx, SSL_OP_MICROSOFT_SESS_ID_BUG);
  336. #endif

  338. #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
  339.     SSL_CTX_set_options(ssl->ctx, SSL_OP_NETSCAPE_CHALLENGE_BUG);
  340. #endif

  342.     /* server side options */

  344. #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
  345.     SSL_CTX_set_options(ssl->ctx, SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG);
  346. #endif

  348. #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
  349.     SSL_CTX_set_options(ssl->ctx, SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER);
  350. #endif

  352. #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
  353.     SSL_CTX_set_options(ssl->ctx, SSL_OP_SSLEAY_080_CLIENT_DH_BUG);
  354. #endif

  356. #ifdef SSL_OP_TLS_D5_BUG
  357.     SSL_CTX_set_options(ssl->ctx, SSL_OP_TLS_D5_BUG);
  358. #endif

  360. #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
  361.     SSL_CTX_set_options(ssl->ctx, SSL_OP_TLS_BLOCK_PADDING_BUG);
  362. #endif

  364. #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
  365.     SSL_CTX_set_options(ssl->ctx, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);
  366. #endif

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

  370. #if OPENSSL_VERSION_NUMBER >= 0x009080dfL
  371.     /* only in 0.9.8m+ */
  372.     SSL_CTX_clear_options(ssl->ctx,
  373.                           SSL_OP_NO_SSLv2|SSL_OP_NO_SSLv3|SSL_OP_NO_TLSv1);
  374. #endif

  376.     if (!(protocols & NGX_SSL_SSLv2)) {
  377.         SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_SSLv2);
  378.     }
  379.     if (!(protocols & NGX_SSL_SSLv3)) {
  380.         SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_SSLv3);
  381.     }
  382.     if (!(protocols & NGX_SSL_TLSv1)) {
  383.         SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_TLSv1);
  384.     }
  385. #ifdef SSL_OP_NO_TLSv1_1
  386.     SSL_CTX_clear_options(ssl->ctx, SSL_OP_NO_TLSv1_1);
  387.     if (!(protocols & NGX_SSL_TLSv1_1)) {
  388.         SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_TLSv1_1);
  389.     }
  390. #endif
  391. #ifdef SSL_OP_NO_TLSv1_2
  392.     SSL_CTX_clear_options(ssl->ctx, SSL_OP_NO_TLSv1_2);
  393.     if (!(protocols & NGX_SSL_TLSv1_2)) {
  394.         SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_TLSv1_2);
  395.     }
  396. #endif
  397. #ifdef SSL_OP_NO_TLSv1_3
  398.     SSL_CTX_clear_options(ssl->ctx, SSL_OP_NO_TLSv1_3);
  399.     if (!(protocols & NGX_SSL_TLSv1_3)) {
  400.         SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_TLSv1_3);
  401.     }
  402. #endif

  404. #ifdef SSL_CTX_set_min_proto_version
  405.     SSL_CTX_set_min_proto_version(ssl->ctx, 0);
  406.     SSL_CTX_set_max_proto_version(ssl->ctx, TLS1_2_VERSION);
  407. #endif

  409. #ifdef TLS1_3_VERSION
  410.     SSL_CTX_set_min_proto_version(ssl->ctx, 0);
  411.     SSL_CTX_set_max_proto_version(ssl->ctx, TLS1_3_VERSION);
  412. #endif

  414. #ifdef SSL_OP_NO_COMPRESSION
  415.     SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_COMPRESSION);
  416. #endif

  418. #ifdef SSL_OP_NO_TX_CERTIFICATE_COMPRESSION
  419.     SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_TX_CERTIFICATE_COMPRESSION);
  420.     SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_RX_CERTIFICATE_COMPRESSION);
  421. #endif

  423. #ifdef SSL_OP_NO_ANTI_REPLAY
  424.     SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_ANTI_REPLAY);
  425. #endif

  427. #ifdef SSL_OP_NO_CLIENT_RENEGOTIATION
  428.     SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_CLIENT_RENEGOTIATION);
  429. #endif

  431. #ifdef SSL_OP_IGNORE_UNEXPECTED_EOF
  432.     SSL_CTX_set_options(ssl->ctx, SSL_OP_IGNORE_UNEXPECTED_EOF);
  433. #endif

  435. #ifdef SSL_MODE_RELEASE_BUFFERS
  436.     SSL_CTX_set_mode(ssl->ctx, SSL_MODE_RELEASE_BUFFERS);
  437. #endif

  439. #ifdef SSL_MODE_NO_AUTO_CHAIN
  440.     SSL_CTX_set_mode(ssl->ctx, SSL_MODE_NO_AUTO_CHAIN);
  441. #endif

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

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

  447.     return NGX_OK;
  448. }


  451. ngx_int_t
  452. ‌ngx_ssl_certificates(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_array_t *certs,
  453.     ngx_array_t *keys, ngx_array_t *passwords)
  454. {
  455.     ngx_str_t   *cert, *key;
  456.     ngx_uint_t   i;

  458.     cert = certs->elts;
  459.     key = keys->elts;

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

  463.         if (ngx_ssl_certificate(cf, ssl, &cert[i], &key[i], passwords)
  464.             != NGX_OK)
  465.         {
  466.             return NGX_ERROR;
  467.         }
  468.     }

  470.     return NGX_OK;
  471. }


  474. ngx_int_t
  475. ‌ngx_ssl_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *cert,
  476.     ngx_str_t *key, ngx_array_t *passwords)
  477. {
  478.     char            *err;
  479.     X509            *x509, **elm;
  480.     u_long           n;
  481.     EVP_PKEY        *pkey;
  482.     ngx_uint_t       mask;
  483.     STACK_OF(X509)  *chain;

  485.     mask = 0;
  486.     elm = NULL;

  488. retry:

  490.     chain = ngx_ssl_cache_fetch(cf, NGX_SSL_CACHE_CERT | mask,
  491.                                 &err, cert, NULL);
  492.     if (chain == NULL) {
  493.         if (err != NULL) {
  494.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  495.                           "cannot load certificate \"%s\": %s",
  496.                           cert->data, err);
  497.         }

  499.         return NGX_ERROR;
  500.     }

  502.     x509 = sk_X509_shift(chain);

  504.     if (SSL_CTX_use_certificate(ssl->ctx, x509) == 0) {
  505.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  506.                       "SSL_CTX_use_certificate(\"%s\") failed", cert->data);
  507.         X509_free(x509);
  508.         sk_X509_pop_free(chain, X509_free);
  509.         return NGX_ERROR;
  510.     }

  512.     if (X509_set_ex_data(x509, ngx_ssl_certificate_name_index, cert->data)
  513.         == 0)
  514.     {
  515.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0, "X509_set_ex_data() failed");
  516.         X509_free(x509);
  517.         sk_X509_pop_free(chain, X509_free);
  518.         return NGX_ERROR;
  519.     }

  521.     if (ssl->certs.elts == NULL) {
  522.         if (ngx_array_init(&ssl->certs, cf->pool, 1, sizeof(X509 *))
  523.             != NGX_OK)
  524.         {
  525.             X509_free(x509);
  526.             sk_X509_pop_free(chain, X509_free);
  527.             return NGX_ERROR;
  528.         }
  529.     }

  531.     if (elm == NULL) {
  532.         elm = ngx_array_push(&ssl->certs);
  533.         if (elm == NULL) {
  534.             X509_free(x509);
  535.             sk_X509_pop_free(chain, X509_free);
  536.             return NGX_ERROR;
  537.         }

  539.     } else {
  540.         X509_free(*elm);
  541.     }

  543.     *elm = x509;

  545.     /*
  546.      * Note that x509 is not freed here, but will be instead freed in
  547.      * ngx_ssl_cleanup_ctx().  This is because we need to preserve all
  548.      * certificates to be able to iterate all of them through ssl->certs,
  549.      * while OpenSSL can free a certificate if it is replaced with another
  550.      * certificate of the same type.
  551.      */

  553. #ifdef SSL_CTX_set0_chain

  555.     if (SSL_CTX_set0_chain(ssl->ctx, chain) == 0) {
  556.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  557.                       "SSL_CTX_set0_chain(\"%s\") failed", cert->data);
  558.         sk_X509_pop_free(chain, X509_free);
  559.         return NGX_ERROR;
  560.     }

  562. #else

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

  566. #ifdef SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS
  567.     /* OpenSSL 1.0.1+ */
  568.     SSL_CTX_clear_extra_chain_certs(ssl->ctx);
  569. #else

  571.     if (ssl->ctx->extra_certs) {
  572.         sk_X509_pop_free(ssl->ctx->extra_certs, X509_free);
  573.         ssl->ctx->extra_certs = NULL;
  574.     }

  576. #endif

  578.     n = sk_X509_num(chain);

  580.     while (n--) {
  581.         x509 = sk_X509_shift(chain);

  583.         if (SSL_CTX_add_extra_chain_cert(ssl->ctx, x509) == 0) {
  584.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  585.                           "SSL_CTX_add_extra_chain_cert(\"%s\") failed",
  586.                           cert->data);
  587.             sk_X509_pop_free(chain, X509_free);
  588.             return NGX_ERROR;
  589.         }
  590.     }

  592.     sk_X509_free(chain);

  594. #endif

  596.     pkey = ngx_ssl_cache_fetch(cf, NGX_SSL_CACHE_PKEY | mask,
  597.                                &err, key, passwords);
  598.     if (pkey == NULL) {
  599.         if (err != NULL) {
  600.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  601.                           "cannot load certificate key \"%s\": %s",
  602.                           key->data, err);
  603.         }

  605.         return NGX_ERROR;
  606.     }

  608.     if (SSL_CTX_use_PrivateKey(ssl->ctx, pkey) == 0) {
  609.         EVP_PKEY_free(pkey);

  611.         /* there can be mismatched pairs on uneven cache update */

  613.         n = ERR_peek_last_error();

  615.         if (ERR_GET_LIB(n) == ERR_LIB_X509
  616.             && ERR_GET_REASON(n) == X509_R_KEY_VALUES_MISMATCH
  617.             && mask == 0)
  618.         {
  619.             ERR_clear_error();
  620.             mask = NGX_SSL_CACHE_INVALIDATE;
  621.             goto retry;
  622.         }

  624.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  625.                       "SSL_CTX_use_PrivateKey(\"%s\") failed", key->data);
  626.         return NGX_ERROR;
  627.     }

  629.     EVP_PKEY_free(pkey);

  631.     return NGX_OK;
  632. }


  635. ngx_int_t
  636. ‌ngx_ssl_connection_certificate(ngx_connection_t *c, ngx_pool_t *pool,
  637.     ngx_str_t *cert, ngx_str_t *key, ngx_ssl_cache_t *cache,
  638.     ngx_array_t *passwords)
  639. {
  640.     char            *err;
  641.     X509            *x509;
  642.     u_long           n;
  643.     EVP_PKEY        *pkey;
  644.     ngx_uint_t       mask;
  645.     STACK_OF(X509)  *chain;

  647.     mask = 0;

  649. retry:

  651.     chain = ngx_ssl_cache_connection_fetch(cache, pool,
  652.                                            NGX_SSL_CACHE_CERT | mask,
  653.                                            &err, cert, NULL);
  654.     if (chain == NULL) {
  655.         if (err != NULL) {
  656.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  657.                           "cannot load certificate \"%s\": %s",
  658.                           cert->data, err);
  659.         }

  661.         return NGX_ERROR;
  662.     }

  664.     x509 = sk_X509_shift(chain);

  666.     if (SSL_use_certificate(c->ssl->connection, x509) == 0) {
  667.         ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  668.                       "SSL_use_certificate(\"%s\") failed", cert->data);
  669.         X509_free(x509);
  670.         sk_X509_pop_free(chain, X509_free);
  671.         return NGX_ERROR;
  672.     }

  674.     X509_free(x509);

  676. #ifdef SSL_set0_chain

  678.     /*
  679.      * SSL_set0_chain() is only available in OpenSSL 1.0.2+,
  680.      * but this function is only called via certificate callback,
  681.      * which is only available in OpenSSL 1.0.2+ as well
  682.      */

  684.     if (SSL_set0_chain(c->ssl->connection, chain) == 0) {
  685.         ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  686.                       "SSL_set0_chain(\"%s\") failed", cert->data);
  687.         sk_X509_pop_free(chain, X509_free);
  688.         return NGX_ERROR;
  689.     }

  691. #endif

  693.     pkey = ngx_ssl_cache_connection_fetch(cache, pool,
  694.                                           NGX_SSL_CACHE_PKEY | mask,
  695.                                           &err, key, passwords);
  696.     if (pkey == NULL) {
  697.         if (err != NULL) {
  698.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  699.                           "cannot load certificate key \"%s\": %s",
  700.                           key->data, err);
  701.         }

  703.         return NGX_ERROR;
  704.     }

  706.     if (SSL_use_PrivateKey(c->ssl->connection, pkey) == 0) {
  707.         EVP_PKEY_free(pkey);

  709.         /* there can be mismatched pairs on uneven cache update */

  711.         n = ERR_peek_last_error();

  713.         if (ERR_GET_LIB(n) == ERR_LIB_X509
  714.             && ERR_GET_REASON(n) == X509_R_KEY_VALUES_MISMATCH
  715.             && mask == 0)
  716.         {
  717.             ERR_clear_error();
  718.             mask = NGX_SSL_CACHE_INVALIDATE;
  719.             goto retry;
  720.         }

  722.         ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  723.                       "SSL_use_PrivateKey(\"%s\") failed", key->data);
  724.         return NGX_ERROR;
  725.     }

  727.     EVP_PKEY_free(pkey);

  729.     return NGX_OK;
  730. }


  733. ngx_int_t
  734. ‌ngx_ssl_certificate_compression(ngx_conf_t *cf, ngx_ssl_t *ssl,
  735.     ngx_uint_t enable)
  736. {
  737.     if (!enable) {
  738.         return NGX_OK;
  739.     }

  741. #ifdef SSL_OP_NO_TX_CERTIFICATE_COMPRESSION

  743.     if (SSL_CTX_compress_certs(ssl->ctx, 0) == 0) {
  744.         ngx_ssl_error(NGX_LOG_WARN, ssl->log, 0,
  745.                       "SSL_CTX_compress_certs() failed, ignored");
  746.         return NGX_OK;
  747.     }

  749.     SSL_CTX_clear_options(ssl->ctx, SSL_OP_NO_TX_CERTIFICATE_COMPRESSION);

  751. #elif (NGX_ZLIB && defined TLSEXT_cert_compression_zlib)

  753.     if (SSL_CTX_add_cert_compression_alg(ssl->ctx, TLSEXT_cert_compression_zlib,
  754.                                          ngx_ssl_cert_compression_callback,
  755.                                          NULL)
  756.         == 0)
  757.     {
  758.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  759.                       "SSL_CTX_add_cert_compression_alg() failed");
  760.         return NGX_ERROR;
  761.     }

  763. #else

  765.     ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  766.                   "\"ssl_certificate_compression\" is not supported "
  767.                   "on this platform, ignored");

  769. #endif

  771.     return NGX_OK;
  772. }


  775. #if (NGX_ZLIB && defined TLSEXT_cert_compression_zlib)

  777. static int
  778. ‌ngx_ssl_cert_compression_callback(ngx_ssl_conn_t *ssl_conn, CBB *out,
  779.     const uint8_t *in, size_t in_len)
  780. {
  781.     int                rc;
  782.     X509              *cert;
  783.     u_char            *p;
  784.     z_stream           zstream;
  785.     ngx_str_t         *comp, tmp;
  786.     ngx_pool_t        *pool;
  787.     ngx_connection_t  *c;

  789. #ifdef OPENSSL_IS_BORINGSSL
  790.     {
  791.     SSL_CTX    *ssl_ctx;
  792.     ngx_ssl_t  *ssl;

  794.     /* BoringSSL doesn't have certificate slots, we take the last set */

  796.     ssl_ctx = SSL_get_SSL_CTX(ssl_conn);
  797.     ssl = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_index);
  798.     cert = ((X509 **) ssl->certs.elts)[ssl->certs.nelts - 1];
  799.     }
  800. #else

  802.     /*
  803.      * AWS-LC saves leaf certificate in SSL to associate with SSL_CTX,
  804.      * see https://github.com/aws/aws-lc/commit/e1ba2b3e5
  805.      */

  807.     cert = SSL_get_certificate(ssl_conn);

  809. #endif

  811.     comp = X509_get_ex_data(cert, ngx_ssl_certificate_comp_index);

  813.     if (comp != NULL) {
  814.         return CBB_add_bytes(out, comp->data, comp->len);
  815.     }

  817.     c = ngx_ssl_get_connection(ssl_conn);

  819.     pool = ngx_create_pool(256, c->log);
  820.     if (pool == NULL) {
  821.         return 0;
  822.     }

  824.     pool->log = c->log;

  826.     ngx_memzero(&zstream, sizeof(z_stream));

  828.     zstream.zalloc = ngx_ssl_cert_compression_alloc;
  829.     zstream.zfree = ngx_ssl_cert_compression_free;
  830.     zstream.opaque = pool;

  832.     rc = deflateInit(&zstream, Z_DEFAULT_COMPRESSION);

  834.     if (rc != Z_OK) {
  835.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "deflateInit() failed: %d", rc);
  836.         goto error;
  837.     }

  839.     tmp.len = deflateBound(&zstream, in_len);
  840.     tmp.data = ngx_palloc(pool, tmp.len);
  841.     if (tmp.data == NULL) {
  842.         goto error;
  843.     }

  845.     zstream.next_in = (u_char *) in;
  846.     zstream.avail_in = in_len;
  847.     zstream.next_out = tmp.data;
  848.     zstream.avail_out = tmp.len;

  850.     rc = deflate(&zstream, Z_FINISH);

  852.     if (rc != Z_STREAM_END) {
  853.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  854.                       "deflate(Z_FINISH) failed: %d", rc);
  855.         goto error;
  856.     }

  858.     tmp.len -= zstream.avail_out;

  860.     rc = deflateEnd(&zstream);

  862.     if (rc != Z_OK) {
  863.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "deflateEnd() failed: %d", rc);
  864.         goto error;
  865.     }

  867.     p = ngx_alloc(sizeof(ngx_str_t) + tmp.len, c->log);
  868.     if (p == NULL) {
  869.         goto error;
  870.     }

  872.     comp = (ngx_str_t *) p;

  874.     comp->len = tmp.len;
  875.     comp->data = p + sizeof(ngx_str_t);

  877.     ngx_memcpy(comp->data, tmp.data, tmp.len);

  879.     if (X509_set_ex_data(cert, ngx_ssl_certificate_comp_index, p) == 0) {
  880.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_set_ex_data() failed");
  881.         ngx_free(p);
  882.     }

  884.     rc = CBB_add_bytes(out, tmp.data, tmp.len);

  886.     ngx_destroy_pool(pool);

  888.     return rc;

  890. error:

  892.     ngx_destroy_pool(pool);

  894.     return 0;
  895. }


  898. static void *
  899. ‌ngx_ssl_cert_compression_alloc(void *opaque, u_int items, u_int size)
  900. {
  901.     ngx_pool_t *pool = opaque;

  903.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, pool->log, 0,
  904.                    "cert compression alloc: n:%ud s:%ud", items, size);

  906.     return ngx_palloc(pool, items * size);
  907. }


  910. static void
  911. ‌ngx_ssl_cert_compression_free(void *opaque, void *address)
  912. {
  913. #if 0
  914.     ngx_pool_t *pool = opaque;

  916.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, pool->log, 0,
  917.                    "cert compression free: %p", address);
  918. #endif
  919. }

  921. #endif


  924. ngx_int_t
  925. ‌ngx_ssl_ciphers(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *ciphers,
  926.     ngx_uint_t prefer_server_ciphers)
  927. {
  928.     if (SSL_CTX_set_cipher_list(ssl->ctx, (char *) ciphers->data) == 0) {
  929.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  930.                       "SSL_CTX_set_cipher_list(\"%V\") failed",
  931.                       ciphers);
  932.         return NGX_ERROR;
  933.     }

  935.     if (prefer_server_ciphers) {
  936.         SSL_CTX_set_options(ssl->ctx, SSL_OP_CIPHER_SERVER_PREFERENCE);
  937.     }

  939.     return NGX_OK;
  940. }


  943. ngx_int_t
  944. ‌ngx_ssl_client_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *cert,
  945.     ngx_int_t depth)
  946. {
  947.     int                   n, i;
  948.     char                 *err;
  949.     X509                 *x509;
  950.     X509_NAME            *name;
  951. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  952.     const
  953. #endif
  954.     X509_NAME            *sname;
  955.     X509_STORE           *store;
  956.     STACK_OF(X509)       *chain;
  957.     STACK_OF(X509_NAME)  *list;

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

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

  963.     if (cert->len == 0) {
  964.         return NGX_OK;
  965.     }

  967.     list = sk_X509_NAME_new(ngx_ssl_cmp_x509_name);
  968.     if (list == NULL) {
  969.         return NGX_ERROR;
  970.     }

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

  974.     if (store == NULL) {
  975.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  976.                       "SSL_CTX_get_cert_store() failed");
  977.         return NGX_ERROR;
  978.     }

  980.     chain = ngx_ssl_cache_fetch(cf, NGX_SSL_CACHE_CA, &err, cert, NULL);
  981.     if (chain == NULL) {
  982.         if (err != NULL) {
  983.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  984.                           "cannot load certificate \"%s\": %s",
  985.                           cert->data, err);
  986.         }

  988.         sk_X509_NAME_pop_free(list, X509_NAME_free);
  989.         return NGX_ERROR;
  990.     }

  992.     n = sk_X509_num(chain);

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

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

  999.             if (ngx_ssl_cert_already_in_hash()) {
  1000.                 continue;
  1001.             }

  1003.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1004.                           "X509_STORE_add_cert(\"%s\") failed", cert->data);
  1005.             sk_X509_NAME_pop_free(list, X509_NAME_free);
  1006.             sk_X509_pop_free(chain, X509_free);
  1007.             return NGX_ERROR;
  1008.         }

  1010.         sname = X509_get_subject_name(x509);
  1011.         if (sname == NULL) {
  1012.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1013.                           "X509_get_subject_name(\"%s\") failed", cert->data);
  1014.             sk_X509_NAME_pop_free(list, X509_NAME_free);
  1015.             sk_X509_pop_free(chain, X509_free);
  1016.             return NGX_ERROR;
  1017.         }

  1019.         name = X509_NAME_dup(sname);
  1020.         if (name == NULL) {
  1021.             sk_X509_NAME_pop_free(list, X509_NAME_free);
  1022.             sk_X509_pop_free(chain, X509_free);
  1023.             return NGX_ERROR;
  1024.         }

  1026. #ifdef OPENSSL_IS_BORINGSSL
  1027.         if (sk_X509_NAME_find(list, NULL, name) > 0) {
  1028. #else
  1029.         if (sk_X509_NAME_find(list, name) >= 0) {
  1030. #endif
  1031.             X509_NAME_free(name);
  1032.             continue;
  1033.         }

  1035.         if (sk_X509_NAME_push(list, name) == 0) {
  1036.             sk_X509_NAME_pop_free(list, X509_NAME_free);
  1037.             sk_X509_pop_free(chain, X509_free);
  1038.             X509_NAME_free(name);
  1039.             return NGX_ERROR;
  1040.         }
  1041.     }

  1043.     sk_X509_pop_free(chain, X509_free);

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

  1047.     return NGX_OK;
  1048. }


  1051. ngx_int_t
  1052. ‌ngx_ssl_trusted_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *cert,
  1053.     ngx_int_t depth)
  1054. {
  1055.     int              i, n;
  1056.     char            *err;
  1057.     X509            *x509;
  1058.     X509_STORE      *store;
  1059.     STACK_OF(X509)  *chain;

  1061.     SSL_CTX_set_verify(ssl->ctx, SSL_CTX_get_verify_mode(ssl->ctx),
  1062.                        ngx_ssl_verify_callback);

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

  1066.     if (cert->len == 0) {
  1067.         return NGX_OK;
  1068.     }

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

  1072.     if (store == NULL) {
  1073.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1074.                       "SSL_CTX_get_cert_store() failed");
  1075.         return NGX_ERROR;
  1076.     }

  1078.     chain = ngx_ssl_cache_fetch(cf, NGX_SSL_CACHE_CA, &err, cert, NULL);
  1079.     if (chain == NULL) {
  1080.         if (err != NULL) {
  1081.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1082.                           "cannot load certificate \"%s\": %s",
  1083.                           cert->data, err);
  1084.         }

  1086.         return NGX_ERROR;
  1087.     }

  1089.     n = sk_X509_num(chain);

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

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

  1096.             if (ngx_ssl_cert_already_in_hash()) {
  1097.                 continue;
  1098.             }

  1100.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1101.                           "X509_STORE_add_cert(\"%s\") failed", cert->data);
  1102.             sk_X509_pop_free(chain, X509_free);
  1103.             return NGX_ERROR;
  1104.         }
  1105.     }

  1107.     sk_X509_pop_free(chain, X509_free);

  1109.     return NGX_OK;
  1110. }


  1113. ngx_int_t
  1114. ‌ngx_ssl_crl(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *crl)
  1115. {
  1116.     int                  n, i;
  1117.     char                *err;
  1118.     X509_CRL            *x509;
  1119.     X509_STORE          *store;
  1120.     STACK_OF(X509_CRL)  *chain;

  1122.     if (crl->len == 0) {
  1123.         return NGX_OK;
  1124.     }

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

  1128.     if (store == NULL) {
  1129.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1130.                       "SSL_CTX_get_cert_store() failed");
  1131.         return NGX_ERROR;
  1132.     }

  1134.     chain = ngx_ssl_cache_fetch(cf, NGX_SSL_CACHE_CRL, &err, crl, NULL);
  1135.     if (chain == NULL) {
  1136.         if (err != NULL) {
  1137.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1138.                           "cannot load CRL \"%s\": %s", crl->data, err);
  1139.         }

  1141.         return NGX_ERROR;
  1142.     }

  1144.     n = sk_X509_CRL_num(chain);

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

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

  1151.             if (ngx_ssl_cert_already_in_hash()) {
  1152.                 continue;
  1153.             }

  1155.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1156.                           "X509_STORE_add_crl(\"%s\") failed", crl->data);
  1157.             sk_X509_CRL_pop_free(chain, X509_CRL_free);
  1158.             return NGX_ERROR;
  1159.         }
  1160.     }

  1162.     sk_X509_CRL_pop_free(chain, X509_CRL_free);

  1164.     X509_STORE_set_flags(store,
  1165.                          X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);

  1167.     return NGX_OK;
  1168. }


  1171. static ngx_inline ngx_int_t
  1172. ‌ngx_ssl_cert_already_in_hash(void)
  1173. {
  1174. #if !(OPENSSL_VERSION_NUMBER >= 0x1010009fL                                   \
  1175.       || LIBRESSL_VERSION_NUMBER >= 0x3050000fL)
  1176.     u_long  error;

  1178.     /*
  1179.      * OpenSSL prior to 1.1.0i doesn't ignore duplicate certificate entries,
  1180.      * see https://github.com/openssl/openssl/commit/c0452248
  1181.      */

  1183.     error = ERR_peek_last_error();

  1185.     if (ERR_GET_LIB(error) == ERR_LIB_X509
  1186.         && ERR_GET_REASON(error) == X509_R_CERT_ALREADY_IN_HASH_TABLE)
  1187.     {
  1188.         ERR_clear_error();
  1189.         return 1;
  1190.     }
  1191. #endif

  1193.     return 0;
  1194. }


  1197. static int
  1198. ‌ngx_ssl_verify_callback(int ok, X509_STORE_CTX *x509_store)
  1199. {
  1200. #if (NGX_DEBUG)
  1201.     char              *subject, *issuer;
  1202.     int                err, depth;
  1203.     X509              *cert;
  1204. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  1205.     const
  1206. #endif
  1207.     X509_NAME         *sname, *iname;
  1208.     ngx_connection_t  *c;
  1209.     ngx_ssl_conn_t    *ssl_conn;

  1211.     ssl_conn = X509_STORE_CTX_get_ex_data(x509_store,
  1212.                                           SSL_get_ex_data_X509_STORE_CTX_idx());

  1214.     c = ngx_ssl_get_connection(ssl_conn);

  1216.     if (!(c->log->log_level & NGX_LOG_DEBUG_EVENT)) {
  1217.         return 1;
  1218.     }

  1220.     cert = X509_STORE_CTX_get_current_cert(x509_store);
  1221.     err = X509_STORE_CTX_get_error(x509_store);
  1222.     depth = X509_STORE_CTX_get_error_depth(x509_store);

  1224.     sname = X509_get_subject_name(cert);

  1226.     if (sname) {
  1227.         subject = X509_NAME_oneline(sname, NULL, 0);
  1228.         if (subject == NULL) {
  1229.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  1230.                           "X509_NAME_oneline() failed");
  1231.         }

  1233.     } else {
  1234.         subject = NULL;
  1235.     }

  1237.     iname = X509_get_issuer_name(cert);

  1239.     if (iname) {
  1240.         issuer = X509_NAME_oneline(iname, NULL, 0);
  1241.         if (issuer == NULL) {
  1242.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  1243.                           "X509_NAME_oneline() failed");
  1244.         }

  1246.     } else {
  1247.         issuer = NULL;
  1248.     }

  1250.     ngx_log_debug5(NGX_LOG_DEBUG_EVENT, c->log, 0,
  1251.                    "verify:%d, error:%d, depth:%d, "
  1252.                    "subject:\"%s\", issuer:\"%s\"",
  1253.                    ok, err, depth,
  1254.                    subject ? subject : "(none)",
  1255.                    issuer ? issuer : "(none)");

  1257.     if (subject) {
  1258.         OPENSSL_free(subject);
  1259.     }

  1261.     if (issuer) {
  1262.         OPENSSL_free(issuer);
  1263.     }
  1264. #endif

  1266.     return 1;
  1267. }


  1270. static void
  1271. ‌ngx_ssl_info_callback(const ngx_ssl_conn_t *ssl_conn, int where, int ret)
  1272. {
  1273.     BIO               *rbio, *wbio;
  1274.     ngx_connection_t  *c;

  1276. #if (!defined SSL_OP_NO_RENEGOTIATION                                         \
  1277.      && !defined SSL_OP_NO_CLIENT_RENEGOTIATION)

  1279.     if ((where & SSL_CB_HANDSHAKE_START)
  1280.         && SSL_is_server((ngx_ssl_conn_t *) ssl_conn))
  1281.     {
  1282.         c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn);

  1284.         if (c->ssl->handshaked) {
  1285.             c->ssl->renegotiation = 1;
  1286.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL renegotiation");
  1287.         }
  1288.     }

  1290. #endif

  1292. #ifdef TLS1_3_VERSION

  1294.     if ((where & SSL_CB_ACCEPT_LOOP) == SSL_CB_ACCEPT_LOOP
  1295.         && SSL_version(ssl_conn) == TLS1_3_VERSION)
  1296.     {
  1297.         time_t        now, time, timeout, conf_timeout;
  1298.         SSL_SESSION  *sess;

  1300.         /*
  1301.          * OpenSSL with TLSv1.3 updates the session creation time on
  1302.          * session resumption and keeps the session timeout unmodified,
  1303.          * making it possible to maintain the session forever, bypassing
  1304.          * client certificate expiration and revocation.  To make sure
  1305.          * session timeouts are actually used, we now update the session
  1306.          * creation time and reduce the session timeout accordingly.
  1307.          *
  1308.          * BoringSSL with TLSv1.3 ignores configured session timeouts
  1309.          * and uses a hardcoded timeout instead, 7 days.  So we update
  1310.          * session timeout to the configured value as soon as a session
  1311.          * is created.
  1312.          */

  1314.         c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn);
  1315.         sess = SSL_get0_session(ssl_conn);

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

  1320.             now = ngx_time();
  1321.             time = SSL_SESSION_get_time(sess);
  1322.             timeout = SSL_SESSION_get_timeout(sess);
  1323.             conf_timeout = SSL_CTX_get_timeout(c->ssl->session_ctx);

  1325.             timeout = ngx_min(timeout, conf_timeout);

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

  1330.             } else {
  1331.                 SSL_SESSION_set_time(sess, now);
  1332.                 SSL_SESSION_set_timeout(sess, timeout - (now - time));
  1333.             }
  1334.         }
  1335.     }

  1337. #endif

  1339.     if ((where & SSL_CB_ACCEPT_LOOP) == SSL_CB_ACCEPT_LOOP) {
  1340.         c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn);

  1342.         if (!c->ssl->handshake_buffer_set) {
  1343.             /*
  1344.              * By default OpenSSL uses 4k buffer during a handshake,
  1345.              * which is too low for long certificate chains and might
  1346.              * result in extra round-trips.
  1347.              *
  1348.              * To adjust a buffer size we detect that buffering was added
  1349.              * to write side of the connection by comparing rbio and wbio.
  1350.              * If they are different, we assume that it's due to buffering
  1351.              * added to wbio, and set buffer size.
  1352.              */

  1354.             rbio = SSL_get_rbio(ssl_conn);
  1355.             wbio = SSL_get_wbio(ssl_conn);

  1357.             if (rbio != wbio) {
  1358.                 (void) BIO_set_write_buffer_size(wbio, NGX_SSL_BUFSIZE);
  1359.                 c->ssl->handshake_buffer_set = 1;
  1360.             }
  1361.         }
  1362.     }
  1363. }


  1366. static int
  1367. ‌ngx_ssl_cmp_x509_name(const X509_NAME *const *a, const X509_NAME *const *b)
  1368. {
  1369.     return (X509_NAME_cmp(*a, *b));
  1370. }


  1373. ngx_array_t *
  1374. ‌ngx_ssl_read_password_file(ngx_conf_t *cf, ngx_str_t *file)
  1375. {
  1376.     u_char              *p, *last, *end;
  1377.     size_t               len;
  1378.     ssize_t              n;
  1379.     ngx_fd_t             fd;
  1380.     ngx_str_t           *pwd;
  1381.     ngx_array_t         *passwords;
  1382.     ngx_pool_cleanup_t  *cln;
  1383.     u_char               buf[NGX_SSL_PASSWORD_BUFFER_SIZE];

  1385.     if (ngx_conf_full_name(cf->cycle, file, 1) != NGX_OK) {
  1386.         return NULL;
  1387.     }

  1389.     passwords = ngx_array_create(cf->temp_pool, 4, sizeof(ngx_str_t));
  1390.     if (passwords == NULL) {
  1391.         return NULL;
  1392.     }

  1394.     cln = ngx_pool_cleanup_add(cf->temp_pool, 0);
  1395.     if (cln == NULL) {
  1396.         return NULL;
  1397.     }

  1399.     cln->handler = ngx_ssl_passwords_cleanup;
  1400.     cln->data = passwords;

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

  1404.     if (fd == NGX_INVALID_FILE) {
  1405.         ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  1406.                            ngx_open_file_n " \"%s\" failed", file->data);
  1407.         return NULL;
  1408.     }

  1410.     len = 0;
  1411.     last = buf;

  1413.     do {
  1414.         n = ngx_read_fd(fd, last, NGX_SSL_PASSWORD_BUFFER_SIZE - len);

  1416.         if (n == -1) {
  1417.             ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  1418.                                ngx_read_fd_n " \"%s\" failed", file->data);
  1419.             passwords = NULL;
  1420.             goto cleanup;
  1421.         }

  1423.         end = last + n;

  1425.         if (len && n == 0) {
  1426.             *end++ = LF;
  1427.         }

  1429.         p = buf;

  1431.         for ( ;; ) {
  1432.             last = ngx_strlchr(last, end, LF);

  1434.             if (last == NULL) {
  1435.                 break;
  1436.             }

  1438.             len = last++ - p;

  1440.             if (len && p[len - 1] == CR) {
  1441.                 len--;
  1442.             }

  1444.             if (len) {
  1445.                 pwd = ngx_array_push(passwords);
  1446.                 if (pwd == NULL) {
  1447.                     passwords = NULL;
  1448.                     goto cleanup;
  1449.                 }

  1451.                 pwd->len = len;
  1452.                 pwd->data = ngx_pnalloc(cf->temp_pool, len);

  1454.                 if (pwd->data == NULL) {
  1455.                     passwords->nelts--;
  1456.                     passwords = NULL;
  1457.                     goto cleanup;
  1458.                 }

  1460.                 ngx_memcpy(pwd->data, p, len);
  1461.             }

  1463.             p = last;
  1464.         }

  1466.         len = end - p;

  1468.         if (len == NGX_SSL_PASSWORD_BUFFER_SIZE) {
  1469.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1470.                                "too long line in \"%s\"", file->data);
  1471.             passwords = NULL;
  1472.             goto cleanup;
  1473.         }

  1475.         ngx_memmove(buf, p, len);
  1476.         last = buf + len;

  1478.     } while (n != 0);

  1480.     if (passwords->nelts == 0) {
  1481.         pwd = ngx_array_push(passwords);
  1482.         if (pwd == NULL) {
  1483.             passwords = NULL;
  1484.             goto cleanup;
  1485.         }

  1487.         ngx_memzero(pwd, sizeof(ngx_str_t));
  1488.     }

  1490. cleanup:

  1492.     if (ngx_close_file(fd) == NGX_FILE_ERROR) {
  1493.         ngx_conf_log_error(NGX_LOG_ALERT, cf, ngx_errno,
  1494.                            ngx_close_file_n " \"%s\" failed", file->data);
  1495.     }

  1497.     ngx_explicit_memzero(buf, NGX_SSL_PASSWORD_BUFFER_SIZE);

  1499.     return passwords;
  1500. }


  1503. ngx_array_t *
  1504. ‌ngx_ssl_preserve_passwords(ngx_conf_t *cf, ngx_array_t *passwords)
  1505. {
  1506.     ngx_str_t           *opwd, *pwd;
  1507.     ngx_uint_t           i;
  1508.     ngx_array_t         *pwds;
  1509.     ngx_pool_cleanup_t  *cln;
  1510.     static ngx_array_t   empty_passwords;

  1512.     if (passwords == NULL) {

  1514.         /*
  1515.          * If there are no passwords, an empty array is used
  1516.          * to make sure OpenSSL's default password callback
  1517.          * won't block on reading from stdin.
  1518.          */

  1520.         return &empty_passwords;
  1521.     }

  1523.     /*
  1524.      * Passwords are normally allocated from the temporary pool
  1525.      * and cleared after parsing configuration.  To be used at
  1526.      * runtime they have to be copied to the configuration pool.
  1527.      */

  1529.     pwds = ngx_array_create(cf->pool, passwords->nelts, sizeof(ngx_str_t));
  1530.     if (pwds == NULL) {
  1531.         return NULL;
  1532.     }

  1534.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  1535.     if (cln == NULL) {
  1536.         return NULL;
  1537.     }

  1539.     cln->handler = ngx_ssl_passwords_cleanup;
  1540.     cln->data = pwds;

  1542.     opwd = passwords->elts;

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

  1546.         pwd = ngx_array_push(pwds);
  1547.         if (pwd == NULL) {
  1548.             return NULL;
  1549.         }

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

  1554.         if (pwd->data == NULL) {
  1555.             pwds->nelts--;
  1556.             return NULL;
  1557.         }

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

  1562.     return pwds;
  1563. }


  1566. static void
  1567. ‌ngx_ssl_passwords_cleanup(void *data)
  1568. {
  1569.     ngx_array_t *passwords = data;

  1571.     ngx_str_t   *pwd;
  1572.     ngx_uint_t   i;

  1574.     pwd = passwords->elts;

  1576.     for (i = 0; i < passwords->nelts; i++) {
  1577.         ngx_explicit_memzero(pwd[i].data, pwd[i].len);
  1578.     }
  1579. }


  1582. ngx_int_t
  1583. ‌ngx_ssl_dhparam(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *file)
  1584. {
  1585. #ifndef OPENSSL_NO_DH

  1587.     BIO  *bio;

  1589.     if (file->len == 0) {
  1590.         return NGX_OK;
  1591.     }

  1593.     if (ngx_conf_full_name(cf->cycle, file, 1) != NGX_OK) {
  1594.         return NGX_ERROR;
  1595.     }

  1597.     bio = BIO_new_file((char *) file->data, "r");
  1598.     if (bio == NULL) {
  1599.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1600.                       "BIO_new_file(\"%s\") failed", file->data);
  1601.         return NGX_ERROR;
  1602.     }

  1604. #ifdef SSL_CTX_set_tmp_dh
  1605.     {
  1606.     DH  *dh;

  1608.     dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
  1609.     if (dh == NULL) {
  1610.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1611.                       "PEM_read_bio_DHparams(\"%s\") failed", file->data);
  1612.         BIO_free(bio);
  1613.         return NGX_ERROR;
  1614.     }

  1616.     if (SSL_CTX_set_tmp_dh(ssl->ctx, dh) != 1) {
  1617.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1618.                       "SSL_CTX_set_tmp_dh(\"%s\") failed", file->data);
  1619.         DH_free(dh);
  1620.         BIO_free(bio);
  1621.         return NGX_ERROR;
  1622.     }

  1624.     DH_free(dh);
  1625.     }
  1626. #else
  1627.     {
  1628.     EVP_PKEY  *dh;

  1630.     /*
  1631.      * PEM_read_bio_DHparams() and SSL_CTX_set_tmp_dh()
  1632.      * are deprecated in OpenSSL 3.0
  1633.      */

  1635.     dh = PEM_read_bio_Parameters(bio, NULL);
  1636.     if (dh == NULL) {
  1637.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1638.                       "PEM_read_bio_Parameters(\"%s\") failed", file->data);
  1639.         BIO_free(bio);
  1640.         return NGX_ERROR;
  1641.     }

  1643.     if (SSL_CTX_set0_tmp_dh_pkey(ssl->ctx, dh) != 1) {
  1644.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1645.                       "SSL_CTX_set0_tmp_dh_pkey(\"%s\") failed", file->data);
  1646. #if (OPENSSL_VERSION_NUMBER >= 0x30000010L)
  1647.         EVP_PKEY_free(dh);
  1648. #endif
  1649.         BIO_free(bio);
  1650.         return NGX_ERROR;
  1651.     }
  1652.     }
  1653. #endif

  1655.     BIO_free(bio);

  1657. #endif

  1659.     return NGX_OK;
  1660. }


  1663. ngx_int_t
  1664. ‌ngx_ssl_ech_files(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_array_t *filenames)
  1665. {
  1666. #ifdef SSL_OP_ECH_GREASE
  1667.     int             numkeys;
  1668.     BIO            *in;
  1669.     ngx_int_t       rc;
  1670.     ngx_str_t      *filename;
  1671.     ngx_uint_t      i;
  1672.     OSSL_ECHSTORE  *es;

  1674.     if (filenames == NULL) {
  1675.         return NGX_OK;
  1676.     }

  1678.     es = OSSL_ECHSTORE_new(NULL, NULL);
  1679.     if (es == NULL) {
  1680.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0, "OSSL_ECHSTORE_new() failed");
  1681.         return NGX_ERROR;
  1682.     }

  1684.     rc = NGX_ERROR;
  1685.     filename = filenames->elts;

  1687.     for (i = 0; i < filenames->nelts; i++) {

  1689.         if (ngx_conf_full_name(cf->cycle, &filename[i], 1) != NGX_OK) {
  1690.             goto cleanup;
  1691.         }

  1693.         in = BIO_new_file((char *) filename[i].data, "r");
  1694.         if (in == NULL) {
  1695.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1696.                           "BIO_new_file(\"%s\") failed", filename[i].data);
  1697.             goto cleanup;
  1698.         }

  1700.         /*
  1701.          * We only set the ECHConfigList from the first file read to use
  1702.          * in ECH retry-configs.
  1703.          *
  1704.          * That allows many sensible key rotation schemes so that the
  1705.          * values sent in ECH retry-configs are smaller and current.
  1706.          * For example, if the first file name has the current ECH
  1707.          * private key, and a second one has the previously used key
  1708.          * that some clients may still use due to DNS caching.
  1709.          */

  1711.          if (OSSL_ECHSTORE_read_pem(es, in, i ? OSSL_ECH_NO_RETRY
  1712.                                               : OSSL_ECH_FOR_RETRY)
  1713.              != 1)
  1714.          {
  1715.              ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1716.                            "OSSL_ECHSTORE_read_pem(%s) failed",
  1717.                            filename[i].data);
  1718.              BIO_free(in);
  1719.              goto cleanup;
  1720.          }

  1722.          BIO_free(in);
  1723.     }

  1725.     /*
  1726.      * load the ECH store after checking there's at least one ECH
  1727.      * private key in there (the PEM file spec allows zero or one
  1728.      * private key per file)
  1729.      */

  1731.     if (OSSL_ECHSTORE_num_keys(es, &numkeys) != 1) {
  1732.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1733.                       "OSSL_ECHSTORE_num_keys() failed");
  1734.         goto cleanup;
  1735.     }

  1737.     if (numkeys > 0 && SSL_CTX_set1_echstore(ssl->ctx, es) != 1) {
  1738.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1739.                       "SSL_CTX_set1_echstore() failed");
  1740.         goto cleanup;
  1741.     }

  1743.     rc = NGX_OK;

  1745. cleanup:

  1747.     OSSL_ECHSTORE_free(es);
  1748.     return rc;

  1750. #else
  1751.     if (filenames != NULL) {
  1752.         ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  1753.                       "\"ssl_ech_file\" is not supported on this platform, "
  1754.                       "ignored");
  1755.     }

  1757.     return NGX_OK;
  1758. #endif
  1759. }


  1762. ngx_int_t
  1763. ‌ngx_ssl_ecdh_curve(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *name)
  1764. {
  1765. #ifndef OPENSSL_NO_ECDH

  1767.     /*
  1768.      * Elliptic-Curve Diffie-Hellman parameters are either "named curves"
  1769.      * from RFC 4492 section 5.1.1, or explicitly described curves over
  1770.      * binary fields.  OpenSSL only supports the "named curves", which provide
  1771.      * maximum interoperability.
  1772.      */

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

  1776.     /*
  1777.      * OpenSSL 1.0.2+ allows configuring a curve list instead of a single
  1778.      * curve previously supported.  By default an internal list is used,
  1779.      * with prime256v1 being preferred by server in OpenSSL 1.0.2b+
  1780.      * and X25519 in OpenSSL 1.1.0+.
  1781.      *
  1782.      * By default a curve preferred by the client will be used for
  1783.      * key exchange.  The SSL_OP_CIPHER_SERVER_PREFERENCE option can
  1784.      * be used to prefer server curves instead, similar to what it
  1785.      * does for ciphers.
  1786.      */

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

  1790. #ifdef SSL_CTRL_SET_ECDH_AUTO
  1791.     /* not needed in OpenSSL 1.1.0+ */
  1792.     (void) SSL_CTX_set_ecdh_auto(ssl->ctx, 1);
  1793. #endif

  1795.     if (ngx_strcmp(name->data, "auto") == 0) {
  1796.         return NGX_OK;
  1797.     }

  1799.     if (SSL_CTX_set1_curves_list(ssl->ctx, (char *) name->data) == 0) {
  1800.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1801.                       "SSL_CTX_set1_curves_list(\"%s\") failed", name->data);
  1802.         return NGX_ERROR;
  1803.     }

  1805. #else

  1807.     int      nid;
  1808.     char    *curve;
  1809.     EC_KEY  *ecdh;

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

  1814.     } else {
  1815.         curve = (char *) name->data;
  1816.     }

  1818.     nid = OBJ_sn2nid(curve);
  1819.     if (nid == 0) {
  1820.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1821.                       "OBJ_sn2nid(\"%s\") failed: unknown curve", curve);
  1822.         return NGX_ERROR;
  1823.     }

  1825.     ecdh = EC_KEY_new_by_curve_name(nid);
  1826.     if (ecdh == NULL) {
  1827.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1828.                       "EC_KEY_new_by_curve_name(\"%s\") failed", curve);
  1829.         return NGX_ERROR;
  1830.     }

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

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

  1836.     EC_KEY_free(ecdh);
  1837. #endif
  1838. #endif

  1840.     return NGX_OK;
  1841. }


  1844. ngx_int_t
  1845. ‌ngx_ssl_early_data(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_uint_t enable)
  1846. {
  1847.     if (!enable) {
  1848.         return NGX_OK;
  1849.     }

  1851. #ifdef SSL_ERROR_EARLY_DATA_REJECTED

  1853.     /* BoringSSL */

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

  1857. #elif defined SSL_READ_EARLY_DATA_SUCCESS

  1859.     /* OpenSSL */

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

  1863. #else
  1864.     ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  1865.                   "\"ssl_early_data\" is not supported on this platform, "
  1866.                   "ignored");
  1867. #endif

  1869.     return NGX_OK;
  1870. }


  1873. ngx_int_t
  1874. ‌ngx_ssl_conf_commands(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_array_t *commands)
  1875. {
  1876.     if (commands == NULL) {
  1877.         return NGX_OK;
  1878.     }

  1880. #ifdef SSL_CONF_FLAG_FILE
  1881.     {
  1882.     int            type;
  1883.     u_char        *key, *value;
  1884.     ngx_uint_t     i;
  1885.     ngx_keyval_t  *cmd;
  1886.     SSL_CONF_CTX  *cctx;

  1888.     cctx = SSL_CONF_CTX_new();
  1889.     if (cctx == NULL) {
  1890.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1891.                       "SSL_CONF_CTX_new() failed");
  1892.         return NGX_ERROR;
  1893.     }

  1895.     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_FILE);
  1896.     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_SERVER);
  1897.     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CLIENT);
  1898.     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CERTIFICATE);
  1899.     SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_SHOW_ERRORS);

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

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

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

  1909.         if (type == SSL_CONF_TYPE_FILE || type == SSL_CONF_TYPE_DIR) {
  1910.             if (ngx_conf_full_name(cf->cycle, &cmd[i].value, 1) != NGX_OK) {
  1911.                 SSL_CONF_CTX_free(cctx);
  1912.                 return NGX_ERROR;
  1913.             }
  1914.         }

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

  1918.         if (SSL_CONF_cmd(cctx, (char *) key, (char *) value) <= 0) {
  1919.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1920.                           "SSL_CONF_cmd(\"%s\", \"%s\") failed", key, value);
  1921.             SSL_CONF_CTX_free(cctx);
  1922.             return NGX_ERROR;
  1923.         }
  1924.     }

  1926.     if (SSL_CONF_CTX_finish(cctx) != 1) {
  1927.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1928.                       "SSL_CONF_finish() failed");
  1929.         SSL_CONF_CTX_free(cctx);
  1930.         return NGX_ERROR;
  1931.     }

  1933.     SSL_CONF_CTX_free(cctx);

  1935.     return NGX_OK;
  1936.     }
  1937. #else
  1938.     ngx_log_error(NGX_LOG_EMERG, ssl->log, 0,
  1939.                   "SSL_CONF_cmd() is not available on this platform");
  1940.     return NGX_ERROR;
  1941. #endif
  1942. }


  1945. ngx_int_t
  1946. ‌ngx_ssl_client_session_cache(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_uint_t enable)
  1947. {
  1948.     if (!enable) {
  1949.         return NGX_OK;
  1950.     }

  1952.     SSL_CTX_set_session_cache_mode(ssl->ctx,
  1953.                                    SSL_SESS_CACHE_CLIENT
  1954.                                    |SSL_SESS_CACHE_NO_INTERNAL);

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

  1958.     return NGX_OK;
  1959. }


  1962. static int
  1963. ‌ngx_ssl_new_client_session(ngx_ssl_conn_t *ssl_conn, ngx_ssl_session_t *sess)
  1964. {
  1965.     ngx_connection_t  *c;

  1967.     c = ngx_ssl_get_connection(ssl_conn);

  1969.     if (c->ssl->save_session) {
  1970.         c->ssl->session = sess;

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

  1974.         c->ssl->session = NULL;
  1975.     }

  1977.     return 0;
  1978. }


  1981. ngx_int_t
  1982. ‌ngx_ssl_set_client_hello_callback(ngx_ssl_t *ssl, ngx_ssl_client_hello_arg *cb)
  1983. {
  1984. #ifdef SSL_CLIENT_HELLO_SUCCESS

  1986.     SSL_CTX_set_client_hello_cb(ssl->ctx, ngx_ssl_client_hello_callback, NULL);

  1988.     if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_client_hello_arg_index, cb) == 0)
  1989.     {
  1990.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  1991.                       "SSL_CTX_set_ex_data() failed");
  1992.         return NGX_ERROR;
  1993.     }

  1995. #elif defined OPENSSL_IS_BORINGSSL

  1997.     SSL_CTX_set_select_certificate_cb(ssl->ctx, ngx_ssl_select_certificate);

  1999.     if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_client_hello_arg_index, cb) == 0)
  2000.     {
  2001.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  2002.                       "SSL_CTX_set_ex_data() failed");
  2003.         return NGX_ERROR;
  2004.     }

  2006. #endif

  2008.     return NGX_OK;
  2009. }


  2012. #ifdef SSL_CLIENT_HELLO_SUCCESS

  2014. int
  2015. ‌ngx_ssl_client_hello_callback(ngx_ssl_conn_t *ssl_conn, int *ad, void *arg)
  2016. {
  2017.     u_char                    *p;
  2018.     size_t                     len;
  2019.     ngx_int_t                  rc;
  2020.     ngx_str_t                  host;
  2021.     ngx_connection_t          *c;
  2022.     ngx_ssl_client_hello_arg  *cb;

  2024.     c = ngx_ssl_get_connection(ssl_conn);
  2025.     cb = SSL_CTX_get_ex_data(c->ssl->session_ctx,
  2026.                              ngx_ssl_client_hello_arg_index);

  2028.     if (SSL_client_hello_get0_ext(ssl_conn, TLSEXT_TYPE_server_name,
  2029.                                   (const unsigned char **) &p, &len)
  2030.         == 0)
  2031.     {
  2032.         ngx_str_null(&host);
  2033.         goto done;
  2034.     }

  2036.     /*
  2037.      * RFC 6066 mandates non-zero HostName length, we follow OpenSSL.
  2038.      * No more than one ServerName is expected.
  2039.      */

  2041.     if (len < 5
  2042.         || (size_t) (p[0] << 8) + p[1] + 2 != len
  2043.         || p[2] != TLSEXT_NAMETYPE_host_name
  2044.         || (size_t) (p[3] << 8) + p[4] + 2 + 3 != len)
  2045.     {
  2046.         *ad = SSL_AD_DECODE_ERROR;
  2047.         return SSL_CLIENT_HELLO_ERROR;
  2048.     }

  2050.     len -= 5;
  2051.     p += 5;

  2053.     if (len > TLSEXT_MAXLEN_host_name || ngx_strlchr(p, p + len, '\0')) {
  2054.         *ad = SSL_AD_UNRECOGNIZED_NAME;
  2055.         return SSL_CLIENT_HELLO_ERROR;
  2056.     }

  2058.     host.len = len;
  2059.     host.data = p;

  2061. done:

  2063.     rc = cb->servername(ssl_conn, ad, &host);

  2065.     if (rc == SSL_TLSEXT_ERR_ALERT_FATAL) {
  2066.         return SSL_CLIENT_HELLO_ERROR;
  2067.     }

  2069.     return SSL_CLIENT_HELLO_SUCCESS;
  2070. }

  2072. #elif defined OPENSSL_IS_BORINGSSL

  2074. ‌enum ssl_select_cert_result_t ngx_ssl_select_certificate(
  2075.     const SSL_CLIENT_HELLO *client_hello)
  2076. {
  2077.     int                        ad;
  2078.     ngx_int_t                  rc;
  2079.     ngx_ssl_conn_t            *ssl_conn;
  2080.     ngx_connection_t          *c;
  2081.     ngx_ssl_client_hello_arg  *cb;

  2083.     ssl_conn = client_hello->ssl;
  2084.     c = ngx_ssl_get_connection(ssl_conn);
  2085.     cb = SSL_CTX_get_ex_data(c->ssl->session_ctx,
  2086.                              ngx_ssl_client_hello_arg_index);

  2088.     /*
  2089.      * BoringSSL sends a hardcoded "handshake_failure" alert on errors,
  2090.      * we use it to map SSL_AD_INTERNAL_ERROR.  To preserve other alert
  2091.      * values, error handling is postponed to the servername callback.
  2092.      */

  2094.     rc = cb->servername(ssl_conn, &ad, NULL);

  2096.     if (rc == SSL_TLSEXT_ERR_ALERT_FATAL && ad == SSL_AD_INTERNAL_ERROR) {
  2097.         return ssl_select_cert_error;
  2098.     }

  2100.     return ssl_select_cert_success;
  2101. }

  2103. #endif


  2106. ngx_int_t
  2107. ‌ngx_ssl_create_connection(ngx_ssl_t *ssl, ngx_connection_t *c, ngx_uint_t flags)
  2108. {
  2109.     ngx_ssl_connection_t  *sc;

  2111.     sc = ngx_pcalloc(c->pool, sizeof(ngx_ssl_connection_t));
  2112.     if (sc == NULL) {
  2113.         return NGX_ERROR;
  2114.     }

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

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

  2121. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  2122.     if (SSL_CTX_get_max_early_data(ssl->ctx)) {
  2123.         sc->try_early_data = 1;
  2124.     }
  2125. #endif

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

  2129.     if (sc->connection == NULL) {
  2130.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "SSL_new() failed");
  2131.         return NGX_ERROR;
  2132.     }

  2134.     if (SSL_set_fd(sc->connection, c->fd) == 0) {
  2135.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "SSL_set_fd() failed");
  2136.         return NGX_ERROR;
  2137.     }

  2139.     if (flags & NGX_SSL_CLIENT) {
  2140.         SSL_set_connect_state(sc->connection);

  2142.     } else {
  2143.         SSL_set_accept_state(sc->connection);

  2145. #ifdef SSL_OP_NO_RENEGOTIATION
  2146.         SSL_set_options(sc->connection, SSL_OP_NO_RENEGOTIATION);
  2147. #endif
  2148.     }

  2150.     if (SSL_set_ex_data(sc->connection, ngx_ssl_connection_index, c) == 0) {
  2151.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "SSL_set_ex_data() failed");
  2152.         return NGX_ERROR;
  2153.     }

  2155.     c->ssl = sc;

  2157.     return NGX_OK;
  2158. }


  2161. ngx_ssl_session_t *
  2162. ‌ngx_ssl_get_session(ngx_connection_t *c)
  2163. {
  2164. #ifdef TLS1_3_VERSION
  2165.     if (c->ssl->session) {
  2166.         SSL_SESSION_up_ref(c->ssl->session);
  2167.         return c->ssl->session;
  2168.     }
  2169. #endif

  2171.     return SSL_get1_session(c->ssl->connection);
  2172. }


  2175. ngx_ssl_session_t *
  2176. ‌ngx_ssl_get0_session(ngx_connection_t *c)
  2177. {
  2178.     if (c->ssl->session) {
  2179.         return c->ssl->session;
  2180.     }

  2182.     return SSL_get0_session(c->ssl->connection);
  2183. }


  2186. ngx_int_t
  2187. ‌ngx_ssl_set_session(ngx_connection_t *c, ngx_ssl_session_t *session)
  2188. {
  2189.     if (session) {
  2190.         if (SSL_set_session(c->ssl->connection, session) == 0) {
  2191.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "SSL_set_session() failed");
  2192.             return NGX_ERROR;
  2193.         }
  2194.     }

  2196.     return NGX_OK;
  2197. }


  2200. ngx_int_t
  2201. ‌ngx_ssl_handshake(ngx_connection_t *c)
  2202. {
  2203.     int        n, sslerr;
  2204.     ngx_err_t  err;
  2205.     ngx_int_t  rc;

  2207. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  2208.     if (c->ssl->try_early_data) {
  2209.         return ngx_ssl_try_early_data(c);
  2210.     }
  2211. #endif

  2213.     if (c->ssl->in_ocsp) {
  2214.         return ngx_ssl_ocsp_validate(c);
  2215.     }

  2217.     ngx_ssl_clear_error(c->log);

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

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

  2223.     if (n == 1) {

  2225.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2226.             return NGX_ERROR;
  2227.         }

  2229.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2230.             return NGX_ERROR;
  2231.         }

  2233. #if (NGX_DEBUG)
  2234.         ngx_ssl_handshake_log(c);
  2235. #endif

  2237.         c->recv = ngx_ssl_recv;
  2238.         c->send = ngx_ssl_write;
  2239.         c->recv_chain = ngx_ssl_recv_chain;
  2240.         c->send_chain = ngx_ssl_send_chain;

  2242.         c->read->ready = 1;
  2243.         c->write->ready = 1;

  2245. #if (!defined SSL_OP_NO_RENEGOTIATION                                         \
  2246.      && !defined SSL_OP_NO_CLIENT_RENEGOTIATION                               \
  2247.      && defined SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS                             \
  2248.      && OPENSSL_VERSION_NUMBER < 0x10100000L)

  2250.         /* initial handshake done, disable renegotiation (CVE-2009-3555) */
  2251.         if (c->ssl->connection->s3 && SSL_is_server(c->ssl->connection)) {
  2252.             c->ssl->connection->s3->flags |= SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS;
  2253.         }

  2255. #endif

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

  2259.         if (BIO_get_ktls_send(SSL_get_wbio(c->ssl->connection)) == 1) {
  2260.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2261.                            "BIO_get_ktls_send(): 1");
  2262.             c->ssl->sendfile = 1;
  2263.         }

  2265. #endif

  2267.         rc = ngx_ssl_ocsp_validate(c);

  2269.         if (rc == NGX_ERROR) {
  2270.             return NGX_ERROR;
  2271.         }

  2273.         if (rc == NGX_AGAIN) {
  2274.             c->read->handler = ngx_ssl_handshake_handler;
  2275.             c->write->handler = ngx_ssl_handshake_handler;
  2276.             return NGX_AGAIN;
  2277.         }

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

  2281.         return NGX_OK;
  2282.     }

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

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

  2288.     if (sslerr == SSL_ERROR_WANT_READ) {
  2289.         c->read->ready = 0;
  2290.         c->read->handler = ngx_ssl_handshake_handler;
  2291.         c->write->handler = ngx_ssl_handshake_handler;

  2293.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2294.             return NGX_ERROR;
  2295.         }

  2297.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2298.             return NGX_ERROR;
  2299.         }

  2301.         return NGX_AGAIN;
  2302.     }

  2304.     if (sslerr == SSL_ERROR_WANT_WRITE) {
  2305.         c->write->ready = 0;
  2306.         c->read->handler = ngx_ssl_handshake_handler;
  2307.         c->write->handler = ngx_ssl_handshake_handler;

  2309.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2310.             return NGX_ERROR;
  2311.         }

  2313.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2314.             return NGX_ERROR;
  2315.         }

  2317.         return NGX_AGAIN;
  2318.     }

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

  2322.     if (sslerr == SSL_ERROR_SYSCALL && ERR_peek_error() == 0 && err == 0) {

  2324.         /*
  2325.          * OpenSSL up to 3.0 returns SSL_ERROR_SYSCALL
  2326.          * without an error queue and with errno set to 0
  2327.          * if connection is closed cleanly
  2328.          */

  2330.         sslerr = SSL_ERROR_ZERO_RETURN;
  2331.     }

  2333.     c->ssl->no_wait_shutdown = 1;
  2334.     c->ssl->no_send_shutdown = 1;
  2335.     c->read->eof = 1;

  2337.     if (sslerr == SSL_ERROR_ZERO_RETURN) {
  2338.         ngx_connection_error(c, err,
  2339.                              "peer closed connection in SSL handshake");

  2341.         return NGX_ERROR;
  2342.     }

  2344.     if (c->ssl->handshake_rejected) {
  2345.         ngx_connection_error(c, err, "handshake rejected");
  2346.         ERR_clear_error();

  2348.         return NGX_ERROR;
  2349.     }

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

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

  2355.     return NGX_ERROR;
  2356. }


  2359. #ifdef SSL_READ_EARLY_DATA_SUCCESS

  2361. static ngx_int_t
  2362. ‌ngx_ssl_try_early_data(ngx_connection_t *c)
  2363. {
  2364.     int        n, sslerr;
  2365.     u_char     buf;
  2366.     size_t     readbytes;
  2367.     ngx_err_t  err;
  2368.     ngx_int_t  rc;

  2370.     ngx_ssl_clear_error(c->log);

  2372.     readbytes = 0;

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

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

  2379.     if (n == SSL_READ_EARLY_DATA_FINISH) {
  2380.         c->ssl->try_early_data = 0;
  2381.         return ngx_ssl_handshake(c);
  2382.     }

  2384.     if (n == SSL_READ_EARLY_DATA_SUCCESS) {

  2386.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2387.             return NGX_ERROR;
  2388.         }

  2390.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2391.             return NGX_ERROR;
  2392.         }

  2394. #if (NGX_DEBUG)
  2395.         ngx_ssl_handshake_log(c);
  2396. #endif

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

  2400.         c->ssl->early_buf = buf;
  2401.         c->ssl->early_preread = 1;

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

  2405.         c->recv = ngx_ssl_recv;
  2406.         c->send = ngx_ssl_write;
  2407.         c->recv_chain = ngx_ssl_recv_chain;
  2408.         c->send_chain = ngx_ssl_send_chain;

  2410.         c->read->ready = 1;
  2411.         c->write->ready = 1;

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

  2415.         if (BIO_get_ktls_send(SSL_get_wbio(c->ssl->connection)) == 1) {
  2416.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2417.                            "BIO_get_ktls_send(): 1");
  2418.             c->ssl->sendfile = 1;
  2419.         }

  2421. #endif

  2423.         rc = ngx_ssl_ocsp_validate(c);

  2425.         if (rc == NGX_ERROR) {
  2426.             return NGX_ERROR;
  2427.         }

  2429.         if (rc == NGX_AGAIN) {
  2430.             c->read->handler = ngx_ssl_handshake_handler;
  2431.             c->write->handler = ngx_ssl_handshake_handler;
  2432.             return NGX_AGAIN;
  2433.         }

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

  2437.         return NGX_OK;
  2438.     }

  2440.     /* SSL_READ_EARLY_DATA_ERROR */

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

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

  2446.     if (sslerr == SSL_ERROR_WANT_READ) {
  2447.         c->read->ready = 0;
  2448.         c->read->handler = ngx_ssl_handshake_handler;
  2449.         c->write->handler = ngx_ssl_handshake_handler;

  2451.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2452.             return NGX_ERROR;
  2453.         }

  2455.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2456.             return NGX_ERROR;
  2457.         }

  2459.         return NGX_AGAIN;
  2460.     }

  2462.     if (sslerr == SSL_ERROR_WANT_WRITE) {
  2463.         c->write->ready = 0;
  2464.         c->read->handler = ngx_ssl_handshake_handler;
  2465.         c->write->handler = ngx_ssl_handshake_handler;

  2467.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2468.             return NGX_ERROR;
  2469.         }

  2471.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2472.             return NGX_ERROR;
  2473.         }

  2475.         return NGX_AGAIN;
  2476.     }

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

  2480.     if (sslerr == SSL_ERROR_SYSCALL && ERR_peek_error() == 0 && err == 0) {

  2482.         /*
  2483.          * OpenSSL up to 3.0 returns SSL_ERROR_SYSCALL
  2484.          * without an error queue and with errno set to 0
  2485.          * if connection is closed cleanly
  2486.          */

  2488.         sslerr = SSL_ERROR_ZERO_RETURN;
  2489.     }

  2491.     c->ssl->no_wait_shutdown = 1;
  2492.     c->ssl->no_send_shutdown = 1;
  2493.     c->read->eof = 1;

  2495.     if (sslerr == SSL_ERROR_ZERO_RETURN) {
  2496.         ngx_connection_error(c, err,
  2497.                              "peer closed connection in SSL handshake");

  2499.         return NGX_ERROR;
  2500.     }

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

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

  2506.     return NGX_ERROR;
  2507. }

  2509. #endif


  2512. #if (NGX_DEBUG)

  2514. void
  2515. ‌ngx_ssl_handshake_log(ngx_connection_t *c)
  2516. {
  2517.     char         buf[129], *s, *d;
  2518. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  2519.     const
  2520. #endif
  2521.     SSL_CIPHER  *cipher;

  2523.     if (!(c->log->log_level & NGX_LOG_DEBUG_EVENT)) {
  2524.         return;
  2525.     }

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

  2529.     if (cipher) {
  2530.         SSL_CIPHER_description(cipher, &buf[1], 128);

  2532.         for (s = &buf[1], d = buf; *s; s++) {
  2533.             if (*s == ' ' && *d == ' ') {
  2534.                 continue;
  2535.             }

  2537.             if (*s == LF || *s == CR) {
  2538.                 continue;
  2539.             }

  2541.             *++d = *s;
  2542.         }

  2544.         if (*d != ' ') {
  2545.             d++;
  2546.         }

  2548.         *d = '\0';

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

  2554.         if (SSL_session_reused(c->ssl->connection)) {
  2555.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2556.                            "SSL reused session");
  2557.         }

  2559.     } else {
  2560.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2561.                        "SSL no shared ciphers");
  2562.     }
  2563. }

  2565. #endif


  2568. static void
  2569. ‌ngx_ssl_handshake_handler(ngx_event_t *ev)
  2570. {
  2571.     ngx_connection_t  *c;

  2573.     c = ev->data;

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

  2578.     if (ev->timedout) {
  2579.         c->ssl->handler(c);
  2580.         return;
  2581.     }

  2583.     if (ngx_ssl_handshake(c) == NGX_AGAIN) {
  2584.         return;
  2585.     }

  2587.     c->ssl->handler(c);
  2588. }


  2591. ssize_t
  2592. ‌ngx_ssl_recv_chain(ngx_connection_t *c, ngx_chain_t *cl, off_t limit)
  2593. {
  2594.     u_char     *last;
  2595.     ssize_t     n, bytes, size;
  2596.     ngx_buf_t  *b;

  2598.     bytes = 0;

  2600.     b = cl->buf;
  2601.     last = b->last;

  2603.     for ( ;; ) {
  2604.         size = b->end - last;

  2606.         if (limit) {
  2607.             if (bytes >= limit) {
  2608.                 return bytes;
  2609.             }

  2611.             if (bytes + size > limit) {
  2612.                 size = (ssize_t) (limit - bytes);
  2613.             }
  2614.         }

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

  2618.         if (n > 0) {
  2619.             last += n;
  2620.             bytes += n;

  2622.             if (!c->read->ready) {
  2623.                 return bytes;
  2624.             }

  2626.             if (last == b->end) {
  2627.                 cl = cl->next;

  2629.                 if (cl == NULL) {
  2630.                     return bytes;
  2631.                 }

  2633.                 b = cl->buf;
  2634.                 last = b->last;
  2635.             }

  2637.             continue;
  2638.         }

  2640.         if (bytes) {

  2642.             if (n == 0 || n == NGX_ERROR) {
  2643.                 c->read->ready = 1;
  2644.             }

  2646.             return bytes;
  2647.         }

  2649.         return n;
  2650.     }
  2651. }


  2654. ssize_t
  2655. ‌ngx_ssl_recv(ngx_connection_t *c, u_char *buf, size_t size)
  2656. {
  2657.     int  n, bytes;

  2659. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  2660.     if (c->ssl->in_early) {
  2661.         return ngx_ssl_recv_early(c, buf, size);
  2662.     }
  2663. #endif

  2665.     if (c->ssl->last == NGX_ERROR) {
  2666.         c->read->ready = 0;
  2667.         c->read->error = 1;
  2668.         return NGX_ERROR;
  2669.     }

  2671.     if (c->ssl->last == NGX_DONE) {
  2672.         c->read->ready = 0;
  2673.         c->read->eof = 1;
  2674.         return 0;
  2675.     }

  2677.     bytes = 0;

  2679.     ngx_ssl_clear_error(c->log);

  2681.     /*
  2682.      * SSL_read() may return data in parts, so try to read
  2683.      * until SSL_read() would return no data
  2684.      */

  2686.     for ( ;; ) {

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

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

  2692.         if (n > 0) {
  2693.             bytes += n;
  2694.         }

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

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

  2700.             size -= n;

  2702.             if (size == 0) {
  2703.                 c->read->ready = 1;

  2705.                 if (c->read->available >= 0) {
  2706.                     c->read->available -= bytes;

  2708.                     /*
  2709.                      * there can be data buffered at SSL layer,
  2710.                      * so we post an event to continue reading on the next
  2711.                      * iteration of the event loop
  2712.                      */

  2714.                     if (c->read->available < 0) {
  2715.                         c->read->available = 0;
  2716.                         c->read->ready = 0;

  2718.                         if (c->read->posted) {
  2719.                             ngx_delete_posted_event(c->read);
  2720.                         }

  2722.                         ngx_post_event(c->read, &ngx_posted_next_events);
  2723.                     }

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

  2728.                 } else {

  2730. #if (NGX_HAVE_FIONREAD)

  2732.                     if (ngx_socket_nread(c->fd, &c->read->available) == -1) {
  2733.                         c->read->ready = 0;
  2734.                         c->read->error = 1;
  2735.                         ngx_connection_error(c, ngx_socket_errno,
  2736.                                              ngx_socket_nread_n " failed");
  2737.                         return NGX_ERROR;
  2738.                     }

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

  2743. #endif
  2744.                 }

  2746.                 return bytes;
  2747.             }

  2749.             buf += n;

  2751.             continue;
  2752.         }

  2754.         if (bytes) {
  2755.             if (c->ssl->last != NGX_AGAIN) {
  2756.                 c->read->ready = 1;
  2757.             }

  2759.             return bytes;
  2760.         }

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

  2764.         case NGX_DONE:
  2765.             c->read->ready = 0;
  2766.             c->read->eof = 1;
  2767.             return 0;

  2769.         case NGX_ERROR:
  2770.             c->read->ready = 0;
  2771.             c->read->error = 1;

  2773.             /* fall through */

  2775.         case NGX_AGAIN:
  2776.             return c->ssl->last;
  2777.         }
  2778.     }
  2779. }


  2782. #ifdef SSL_READ_EARLY_DATA_SUCCESS

  2784. static ssize_t
  2785. ‌ngx_ssl_recv_early(ngx_connection_t *c, u_char *buf, size_t size)
  2786. {
  2787.     int        n, bytes;
  2788.     size_t     readbytes;

  2790.     if (c->ssl->last == NGX_ERROR) {
  2791.         c->read->ready = 0;
  2792.         c->read->error = 1;
  2793.         return NGX_ERROR;
  2794.     }

  2796.     if (c->ssl->last == NGX_DONE) {
  2797.         c->read->ready = 0;
  2798.         c->read->eof = 1;
  2799.         return 0;
  2800.     }

  2802.     bytes = 0;

  2804.     ngx_ssl_clear_error(c->log);

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

  2808.         if (size == 0) {
  2809.             c->read->ready = 0;
  2810.             c->read->eof = 1;
  2811.             return 0;
  2812.         }

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

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

  2818.         bytes = 1;
  2819.         size -= 1;
  2820.         buf += 1;
  2821.     }

  2823.     if (c->ssl->write_blocked) {
  2824.         return NGX_AGAIN;
  2825.     }

  2827.     /*
  2828.      * SSL_read_early_data() may return data in parts, so try to read
  2829.      * until SSL_read_early_data() would return no data
  2830.      */

  2832.     for ( ;; ) {

  2834.         readbytes = 0;

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

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

  2841.         if (n == SSL_READ_EARLY_DATA_SUCCESS) {

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

  2845.             bytes += readbytes;
  2846.             size -= readbytes;

  2848.             if (size == 0) {
  2849.                 c->read->ready = 1;
  2850.                 return bytes;
  2851.             }

  2853.             buf += readbytes;

  2855.             continue;
  2856.         }

  2858.         if (n == SSL_READ_EARLY_DATA_FINISH) {

  2860.             c->ssl->last = ngx_ssl_handle_recv(c, 1);
  2861.             c->ssl->in_early = 0;

  2863.             if (bytes) {
  2864.                 c->read->ready = 1;
  2865.                 return bytes;
  2866.             }

  2868.             return ngx_ssl_recv(c, buf, size);
  2869.         }

  2871.         /* SSL_READ_EARLY_DATA_ERROR */

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

  2875.         if (bytes) {
  2876.             if (c->ssl->last != NGX_AGAIN) {
  2877.                 c->read->ready = 1;
  2878.             }

  2880.             return bytes;
  2881.         }

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

  2885.         case NGX_DONE:
  2886.             c->read->ready = 0;
  2887.             c->read->eof = 1;
  2888.             return 0;

  2890.         case NGX_ERROR:
  2891.             c->read->ready = 0;
  2892.             c->read->error = 1;

  2894.             /* fall through */

  2896.         case NGX_AGAIN:
  2897.             return c->ssl->last;
  2898.         }
  2899.     }
  2900. }

  2902. #endif


  2905. static ngx_int_t
  2906. ‌ngx_ssl_handle_recv(ngx_connection_t *c, int n)
  2907. {
  2908.     int        sslerr;
  2909.     ngx_err_t  err;

  2911. #if (!defined SSL_OP_NO_RENEGOTIATION                                         \
  2912.      && !defined SSL_OP_NO_CLIENT_RENEGOTIATION)

  2914.     if (c->ssl->renegotiation) {
  2915.         /*
  2916.          * disable renegotiation (CVE-2009-3555):
  2917.          * OpenSSL (at least up to 0.9.8l) does not handle disabled
  2918.          * renegotiation gracefully, so drop connection here
  2919.          */

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

  2923.         while (ERR_peek_error()) {
  2924.             ngx_ssl_error(NGX_LOG_DEBUG, c->log, 0,
  2925.                           "ignoring stale global SSL error");
  2926.         }

  2928.         ERR_clear_error();

  2930.         c->ssl->no_wait_shutdown = 1;
  2931.         c->ssl->no_send_shutdown = 1;

  2933.         return NGX_ERROR;
  2934.     }

  2936. #endif

  2938.     if (n > 0) {

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

  2942.             c->write->handler = c->ssl->saved_write_handler;
  2943.             c->ssl->saved_write_handler = NULL;
  2944.             c->write->ready = 1;

  2946.             if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2947.                 return NGX_ERROR;
  2948.             }

  2950.             ngx_post_event(c->write, &ngx_posted_events);
  2951.         }

  2953.         return NGX_OK;
  2954.     }

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

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

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

  2962.     if (sslerr == SSL_ERROR_WANT_READ) {

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

  2966.             c->write->handler = c->ssl->saved_write_handler;
  2967.             c->ssl->saved_write_handler = NULL;
  2968.             c->write->ready = 1;

  2970.             if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2971.                 return NGX_ERROR;
  2972.             }

  2974.             ngx_post_event(c->write, &ngx_posted_events);
  2975.         }

  2977.         c->read->ready = 0;
  2978.         return NGX_AGAIN;
  2979.     }

  2981.     if (sslerr == SSL_ERROR_WANT_WRITE) {

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

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

  2988.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2989.             return NGX_ERROR;
  2990.         }

  2992.         /*
  2993.          * we do not set the timer because there is already the read event timer
  2994.          */

  2996.         if (c->ssl->saved_write_handler == NULL) {
  2997.             c->ssl->saved_write_handler = c->write->handler;
  2998.             c->write->handler = ngx_ssl_write_handler;
  2999.         }

  3001.         return NGX_AGAIN;
  3002.     }

  3004.     if (sslerr == SSL_ERROR_SYSCALL && ERR_peek_error() == 0 && err == 0) {

  3006.         /*
  3007.          * OpenSSL up to 3.0 returns SSL_ERROR_SYSCALL
  3008.          * without an error queue and with errno set to 0
  3009.          * if connection is closed cleanly
  3010.          */

  3012.         sslerr = SSL_ERROR_ZERO_RETURN;
  3013.     }

  3015.     c->ssl->no_wait_shutdown = 1;
  3016.     c->ssl->no_send_shutdown = 1;

  3018.     if (sslerr == SSL_ERROR_ZERO_RETURN) {
  3019.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  3020.                        "peer shutdown SSL cleanly");
  3021.         return NGX_DONE;
  3022.     }

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

  3026.     return NGX_ERROR;
  3027. }


  3030. static void
  3031. ‌ngx_ssl_write_handler(ngx_event_t *wev)
  3032. {
  3033.     ngx_connection_t  *c;

  3035.     c = wev->data;

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

  3039.     c->read->handler(c->read);
  3040. }


  3043. /*
  3044. * OpenSSL has no SSL_writev() so we copy several bufs into our 16K buffer
  3045. * before the SSL_write() call to decrease a SSL overhead.
  3046. *
  3047. * Besides for protocols such as HTTP it is possible to always buffer
  3048. * the output to decrease a SSL overhead some more.
  3049. */

  3051. ngx_chain_t *
  3052. ‌ngx_ssl_send_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
  3053. {
  3054.     int           n;
  3055.     ngx_uint_t    flush;
  3056.     ssize_t       send, size, file_size;
  3057.     ngx_buf_t    *buf;
  3058.     ngx_chain_t  *cl;

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

  3062.         while (in) {
  3063.             if (ngx_buf_special(in->buf)) {
  3064.                 in = in->next;
  3065.                 continue;
  3066.             }

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

  3070.             if (n == NGX_ERROR) {
  3071.                 return NGX_CHAIN_ERROR;
  3072.             }

  3074.             if (n == NGX_AGAIN) {
  3075.                 return in;
  3076.             }

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

  3080.             if (in->buf->pos == in->buf->last) {
  3081.                 in = in->next;
  3082.             }
  3083.         }

  3085.         return in;
  3086.     }


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

  3091.     if (limit == 0 || limit > (off_t) (NGX_MAX_INT32_VALUE - ngx_pagesize)) {
  3092.         limit = NGX_MAX_INT32_VALUE - ngx_pagesize;
  3093.     }

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

  3097.     if (buf == NULL) {
  3098.         buf = ngx_create_temp_buf(c->pool, c->ssl->buffer_size);
  3099.         if (buf == NULL) {
  3100.             return NGX_CHAIN_ERROR;
  3101.         }

  3103.         c->ssl->buf = buf;
  3104.     }

  3106.     if (buf->start == NULL) {
  3107.         buf->start = ngx_palloc(c->pool, c->ssl->buffer_size);
  3108.         if (buf->start == NULL) {
  3109.             return NGX_CHAIN_ERROR;
  3110.         }

  3112.         buf->pos = buf->start;
  3113.         buf->last = buf->start;
  3114.         buf->end = buf->start + c->ssl->buffer_size;
  3115.     }

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

  3120.     for ( ;; ) {

  3122.         while (in && buf->last < buf->end && send < limit) {
  3123.             if (in->buf->last_buf || in->buf->flush) {
  3124.                 flush = 1;
  3125.             }

  3127.             if (ngx_buf_special(in->buf)) {
  3128.                 in = in->next;
  3129.                 continue;
  3130.             }

  3132.             if (in->buf->in_file && c->ssl->sendfile) {
  3133.                 flush = 1;
  3134.                 break;
  3135.             }

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

  3139.             if (size > buf->end - buf->last) {
  3140.                 size = buf->end - buf->last;
  3141.             }

  3143.             if (send + size > limit) {
  3144.                 size = (ssize_t) (limit - send);
  3145.             }

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

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

  3152.             buf->last += size;
  3153.             in->buf->pos += size;
  3154.             send += size;

  3156.             if (in->buf->pos == in->buf->last) {
  3157.                 in = in->next;
  3158.             }
  3159.         }

  3161.         if (!flush && send < limit && buf->last < buf->end) {
  3162.             break;
  3163.         }

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

  3167.         if (size == 0) {

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

  3171.                 /* coalesce the neighbouring file bufs */

  3173.                 cl = in;
  3174.                 file_size = (size_t) ngx_chain_coalesce_file(&cl, limit - send);

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

  3178.                 if (n == NGX_ERROR) {
  3179.                     return NGX_CHAIN_ERROR;
  3180.                 }

  3182.                 if (n == NGX_AGAIN) {
  3183.                     break;
  3184.                 }

  3186.                 in = ngx_chain_update_sent(in, n);

  3188.                 send += n;
  3189.                 flush = 0;

  3191.                 continue;
  3192.             }

  3194.             buf->flush = 0;
  3195.             c->buffered &= ~NGX_SSL_BUFFERED;

  3197.             return in;
  3198.         }

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

  3202.         if (n == NGX_ERROR) {
  3203.             return NGX_CHAIN_ERROR;
  3204.         }

  3206.         if (n == NGX_AGAIN) {
  3207.             break;
  3208.         }

  3210.         buf->pos += n;

  3212.         if (n < size) {
  3213.             break;
  3214.         }

  3216.         flush = 0;

  3218.         buf->pos = buf->start;
  3219.         buf->last = buf->start;

  3221.         if (in == NULL || send >= limit) {
  3222.             break;
  3223.         }
  3224.     }

  3226.     buf->flush = flush;

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

  3231.     } else {
  3232.         c->buffered &= ~NGX_SSL_BUFFERED;
  3233.     }

  3235.     return in;
  3236. }


  3239. ssize_t
  3240. ‌ngx_ssl_write(ngx_connection_t *c, u_char *data, size_t size)
  3241. {
  3242.     int        n, sslerr;
  3243.     ngx_err_t  err;

  3245.     if (c->ssl->last == NGX_ERROR) {
  3246.         c->write->ready = 0;
  3247.         c->write->error = 1;
  3248.         return NGX_ERROR;
  3249.     }

  3251. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  3252.     if (c->ssl->in_early) {
  3253.         return ngx_ssl_write_early(c, data, size);
  3254.     }
  3255. #endif

  3257.     ngx_ssl_clear_error(c->log);

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

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

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

  3265.     if (n > 0) {

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

  3269.             c->read->handler = c->ssl->saved_read_handler;
  3270.             c->ssl->saved_read_handler = NULL;
  3271.             c->read->ready = 1;

  3273.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3274.                 return NGX_ERROR;
  3275.             }

  3277.             ngx_post_event(c->read, &ngx_posted_events);
  3278.         }

  3280.         c->sent += n;

  3282.         return n;
  3283.     }

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

  3287.     if (sslerr == SSL_ERROR_ZERO_RETURN) {

  3289.         /*
  3290.          * OpenSSL 1.1.1 fails to return SSL_ERROR_SYSCALL if an error
  3291.          * happens during SSL_write() after close_notify alert from the
  3292.          * peer, and returns SSL_ERROR_ZERO_RETURN instead,
  3293.          * see https://github.com/openssl/openssl/commit/8051ab2
  3294.          */

  3296.         sslerr = SSL_ERROR_SYSCALL;
  3297.     }

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

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

  3303.     if (sslerr == SSL_ERROR_WANT_WRITE) {

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

  3307.             c->read->handler = c->ssl->saved_read_handler;
  3308.             c->ssl->saved_read_handler = NULL;
  3309.             c->read->ready = 1;

  3311.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3312.                 return NGX_ERROR;
  3313.             }

  3315.             ngx_post_event(c->read, &ngx_posted_events);
  3316.         }

  3318.         c->write->ready = 0;
  3319.         return NGX_AGAIN;
  3320.     }

  3322.     if (sslerr == SSL_ERROR_WANT_READ) {

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

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

  3329.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3330.             return NGX_ERROR;
  3331.         }

  3333.         /*
  3334.          * we do not set the timer because there is already
  3335.          * the write event timer
  3336.          */

  3338.         if (c->ssl->saved_read_handler == NULL) {
  3339.             c->ssl->saved_read_handler = c->read->handler;
  3340.             c->read->handler = ngx_ssl_read_handler;
  3341.         }

  3343.         return NGX_AGAIN;
  3344.     }

  3346.     c->ssl->no_wait_shutdown = 1;
  3347.     c->ssl->no_send_shutdown = 1;
  3348.     c->write->error = 1;

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

  3352.     return NGX_ERROR;
  3353. }


  3356. #ifdef SSL_READ_EARLY_DATA_SUCCESS

  3358. static ssize_t
  3359. ‌ngx_ssl_write_early(ngx_connection_t *c, u_char *data, size_t size)
  3360. {
  3361.     int        n, sslerr;
  3362.     size_t     written;
  3363.     ngx_err_t  err;

  3365.     ngx_ssl_clear_error(c->log);

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

  3369.     written = 0;

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

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

  3376.     if (n > 0) {

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

  3380.             c->read->handler = c->ssl->saved_read_handler;
  3381.             c->ssl->saved_read_handler = NULL;
  3382.             c->read->ready = 1;

  3384.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3385.                 return NGX_ERROR;
  3386.             }

  3388.             ngx_post_event(c->read, &ngx_posted_events);
  3389.         }

  3391.         if (c->ssl->write_blocked) {
  3392.             c->ssl->write_blocked = 0;
  3393.             ngx_post_event(c->read, &ngx_posted_events);
  3394.         }

  3396.         c->sent += written;

  3398.         return written;
  3399.     }

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

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

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

  3407.     if (sslerr == SSL_ERROR_WANT_WRITE) {

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

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

  3414.             c->read->handler = c->ssl->saved_read_handler;
  3415.             c->ssl->saved_read_handler = NULL;
  3416.             c->read->ready = 1;

  3418.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3419.                 return NGX_ERROR;
  3420.             }

  3422.             ngx_post_event(c->read, &ngx_posted_events);
  3423.         }

  3425.         /*
  3426.          * OpenSSL 1.1.1a fails to handle SSL_read_early_data()
  3427.          * if an SSL_write_early_data() call blocked on writing,
  3428.          * see https://github.com/openssl/openssl/issues/7757
  3429.          */

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

  3433.         c->write->ready = 0;
  3434.         return NGX_AGAIN;
  3435.     }

  3437.     if (sslerr == SSL_ERROR_WANT_READ) {

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

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

  3444.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3445.             return NGX_ERROR;
  3446.         }

  3448.         /*
  3449.          * we do not set the timer because there is already
  3450.          * the write event timer
  3451.          */

  3453.         if (c->ssl->saved_read_handler == NULL) {
  3454.             c->ssl->saved_read_handler = c->read->handler;
  3455.             c->read->handler = ngx_ssl_read_handler;
  3456.         }

  3458.         return NGX_AGAIN;
  3459.     }

  3461.     c->ssl->no_wait_shutdown = 1;
  3462.     c->ssl->no_send_shutdown = 1;
  3463.     c->write->error = 1;

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

  3467.     return NGX_ERROR;
  3468. }

  3470. #endif


  3473. static ssize_t
  3474. ‌ngx_ssl_sendfile(ngx_connection_t *c, ngx_buf_t *file, size_t size)
  3475. {
  3476. #if (defined BIO_get_ktls_send && !NGX_WIN32)

  3478.     int        sslerr, flags;
  3479.     ssize_t    n;
  3480.     ngx_err_t  err;

  3482.     if (c->ssl->last == NGX_ERROR) {
  3483.         c->write->ready = 0;
  3484.         c->write->error = 1;
  3485.         return NGX_ERROR;
  3486.     }

  3488.     ngx_ssl_clear_error(c->log);

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

  3494.     ngx_set_errno(0);

  3496. #if (NGX_HAVE_SENDFILE_NODISKIO)

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

  3500.     if (file->file->directio) {
  3501.         flags |= SF_NOCACHE;
  3502.     }

  3504. #else
  3505.     flags = 0;
  3506. #endif

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

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

  3513.     if (n > 0) {

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

  3517.             c->read->handler = c->ssl->saved_read_handler;
  3518.             c->ssl->saved_read_handler = NULL;
  3519.             c->read->ready = 1;

  3521.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3522.                 return NGX_ERROR;
  3523.             }

  3525.             ngx_post_event(c->read, &ngx_posted_events);
  3526.         }

  3528. #if (NGX_HAVE_SENDFILE_NODISKIO)
  3529.         c->busy_count = 0;
  3530. #endif

  3532.         c->sent += n;

  3534.         return n;
  3535.     }

  3537.     if (n == 0) {

  3539.         /*
  3540.          * if sendfile returns zero, then someone has truncated the file,
  3541.          * so the offset became beyond the end of the file
  3542.          */

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

  3548.         return NGX_ERROR;
  3549.     }

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

  3553.     if (sslerr == SSL_ERROR_ZERO_RETURN) {

  3555.         /*
  3556.          * OpenSSL fails to return SSL_ERROR_SYSCALL if an error
  3557.          * happens during writing after close_notify alert from the
  3558.          * peer, and returns SSL_ERROR_ZERO_RETURN instead
  3559.          */

  3561.         sslerr = SSL_ERROR_SYSCALL;
  3562.     }

  3564.     if (sslerr == SSL_ERROR_SSL
  3565.         && ERR_GET_REASON(ERR_peek_error()) == SSL_R_UNINITIALIZED
  3566.         && ngx_errno != 0)
  3567.     {
  3568.         /*
  3569.          * OpenSSL fails to return SSL_ERROR_SYSCALL if an error
  3570.          * happens in sendfile(), and returns SSL_ERROR_SSL with
  3571.          * SSL_R_UNINITIALIZED reason instead
  3572.          */

  3574.         sslerr = SSL_ERROR_SYSCALL;
  3575.     }

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

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

  3581.     if (sslerr == SSL_ERROR_WANT_WRITE) {

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

  3585.             c->read->handler = c->ssl->saved_read_handler;
  3586.             c->ssl->saved_read_handler = NULL;
  3587.             c->read->ready = 1;

  3589.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3590.                 return NGX_ERROR;
  3591.             }

  3593.             ngx_post_event(c->read, &ngx_posted_events);
  3594.         }

  3596. #if (NGX_HAVE_SENDFILE_NODISKIO)

  3598.         if (ngx_errno == EBUSY) {
  3599.             c->busy_count++;

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

  3604.             if (c->write->posted) {
  3605.                 ngx_delete_posted_event(c->write);
  3606.             }

  3608.             ngx_post_event(c->write, &ngx_posted_next_events);
  3609.         }

  3611. #endif

  3613.         c->write->ready = 0;
  3614.         return NGX_AGAIN;
  3615.     }

  3617.     if (sslerr == SSL_ERROR_WANT_READ) {

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

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

  3624.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3625.             return NGX_ERROR;
  3626.         }

  3628.         /*
  3629.          * we do not set the timer because there is already
  3630.          * the write event timer
  3631.          */

  3633.         if (c->ssl->saved_read_handler == NULL) {
  3634.             c->ssl->saved_read_handler = c->read->handler;
  3635.             c->read->handler = ngx_ssl_read_handler;
  3636.         }

  3638.         return NGX_AGAIN;
  3639.     }

  3641.     c->ssl->no_wait_shutdown = 1;
  3642.     c->ssl->no_send_shutdown = 1;
  3643.     c->write->error = 1;

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

  3647. #else
  3648.     ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  3649.                   "SSL_sendfile() not available");
  3650. #endif

  3652.     return NGX_ERROR;
  3653. }


  3656. static void
  3657. ‌ngx_ssl_read_handler(ngx_event_t *rev)
  3658. {
  3659.     ngx_connection_t  *c;

  3661.     c = rev->data;

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

  3665.     c->write->handler(c->write);
  3666. }


  3669. void
  3670. ‌ngx_ssl_free_buffer(ngx_connection_t *c)
  3671. {
  3672.     if (c->ssl->buf && c->ssl->buf->start) {
  3673.         if (ngx_pfree(c->pool, c->ssl->buf->start) == NGX_OK) {
  3674.             c->ssl->buf->start = NULL;
  3675.         }
  3676.     }
  3677. }


  3680. ngx_int_t
  3681. ‌ngx_ssl_shutdown(ngx_connection_t *c)
  3682. {
  3683.     int         n, sslerr, mode;
  3684.     ngx_int_t   rc;
  3685.     ngx_err_t   err;
  3686.     ngx_uint_t  tries;

  3688. #if (NGX_QUIC)
  3689.     if (c->quic) {
  3690.         /* QUIC streams inherit SSL object */
  3691.         return NGX_OK;
  3692.     }
  3693. #endif

  3695.     rc = NGX_OK;

  3697.     ngx_ssl_ocsp_cleanup(c);

  3699.     if (SSL_in_init(c->ssl->connection)) {
  3700.         /*
  3701.          * OpenSSL 1.0.2f complains if SSL_shutdown() is called during
  3702.          * an SSL handshake, while previous versions always return 0.
  3703.          * Avoid calling SSL_shutdown() if handshake wasn't completed.
  3704.          */

  3706.         goto done;
  3707.     }

  3709.     if (c->timedout || c->error || c->buffered) {
  3710.         mode = SSL_RECEIVED_SHUTDOWN|SSL_SENT_SHUTDOWN;
  3711.         SSL_set_quiet_shutdown(c->ssl->connection, 1);

  3713.     } else {
  3714.         mode = SSL_get_shutdown(c->ssl->connection);

  3716.         if (c->ssl->no_wait_shutdown) {
  3717.             mode |= SSL_RECEIVED_SHUTDOWN;
  3718.         }

  3720.         if (c->ssl->no_send_shutdown) {
  3721.             mode |= SSL_SENT_SHUTDOWN;
  3722.         }

  3724.         if (c->ssl->no_wait_shutdown && c->ssl->no_send_shutdown) {
  3725.             SSL_set_quiet_shutdown(c->ssl->connection, 1);
  3726.         }
  3727.     }

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

  3731.     ngx_ssl_clear_error(c->log);

  3733.     tries = 2;

  3735.     for ( ;; ) {

  3737.         /*
  3738.          * For bidirectional shutdown, SSL_shutdown() needs to be called
  3739.          * twice: first call sends the "close notify" alert and returns 0,
  3740.          * second call waits for the peer's "close notify" alert.
  3741.          */

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

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

  3747.         if (n == 1) {
  3748.             goto done;
  3749.         }

  3751.         if (n == 0 && tries-- > 1) {
  3752.             continue;
  3753.         }

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

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

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

  3762.         if (sslerr == SSL_ERROR_WANT_READ || sslerr == SSL_ERROR_WANT_WRITE) {
  3763.             c->read->handler = ngx_ssl_shutdown_handler;
  3764.             c->write->handler = ngx_ssl_shutdown_handler;

  3766.             if (sslerr == SSL_ERROR_WANT_READ) {
  3767.                 c->read->ready = 0;

  3769.             } else {
  3770.                 c->write->ready = 0;
  3771.             }

  3773.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3774.                 goto failed;
  3775.             }

  3777.             if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  3778.                 goto failed;
  3779.             }

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

  3783.             return NGX_AGAIN;
  3784.         }

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

  3788.         if (sslerr == SSL_ERROR_SYSCALL && ERR_peek_error() == 0 && err == 0) {

  3790.             /*
  3791.              * OpenSSL up to 3.0 returns SSL_ERROR_SYSCALL
  3792.              * without an error queue and with errno set to 0
  3793.              * if connection is closed cleanly
  3794.              */

  3796.             sslerr = SSL_ERROR_ZERO_RETURN;
  3797.         }

  3799.         if (sslerr == SSL_ERROR_ZERO_RETURN) {
  3800.             goto done;
  3801.         }

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

  3805.         break;
  3806.     }

  3808. failed:

  3810.     rc = NGX_ERROR;

  3812. done:

  3814.     if (c->ssl->shutdown_without_free) {
  3815.         c->ssl->shutdown_without_free = 0;
  3816.         c->recv = ngx_recv;
  3817.         return rc;
  3818.     }

  3820.     SSL_free(c->ssl->connection);
  3821.     c->ssl = NULL;
  3822.     c->recv = ngx_recv;

  3824.     return rc;
  3825. }


  3828. static void
  3829. ‌ngx_ssl_shutdown_handler(ngx_event_t *ev)
  3830. {
  3831.     ngx_connection_t           *c;
  3832.     ngx_connection_handler_pt   handler;

  3834.     c = ev->data;
  3835.     handler = c->ssl->handler;

  3837.     if (ev->timedout) {
  3838.         c->timedout = 1;
  3839.     }

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

  3843.     if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
  3844.         return;
  3845.     }

  3847.     handler(c);
  3848. }


  3851. void
  3852. ‌ngx_ssl_connection_error(ngx_connection_t *c, int sslerr, ngx_err_t err,
  3853.     char *text)
  3854. {
  3855.     int         n;
  3856.     ngx_uint_t  level;

  3858.     level = NGX_LOG_CRIT;

  3860.     if (sslerr == SSL_ERROR_SYSCALL) {

  3862.         if (err == NGX_ECONNRESET
  3863. #if (NGX_WIN32)
  3864.             || err == NGX_ECONNABORTED
  3865. #endif
  3866.             || err == NGX_EPIPE
  3867.             || err == NGX_ENOTCONN
  3868.             || err == NGX_ETIMEDOUT
  3869.             || err == NGX_ECONNREFUSED
  3870.             || err == NGX_ENETDOWN
  3871.             || err == NGX_ENETUNREACH
  3872.             || err == NGX_EHOSTDOWN
  3873.             || err == NGX_EHOSTUNREACH)
  3874.         {
  3875.             switch (c->log_error) {

  3877.             case NGX_ERROR_IGNORE_ECONNRESET:
  3878.             case NGX_ERROR_INFO:
  3879.                 level = NGX_LOG_INFO;
  3880.                 break;

  3882.             case NGX_ERROR_ERR:
  3883.                 level = NGX_LOG_ERR;
  3884.                 break;

  3886.             default:
  3887.                 break;
  3888.             }
  3889.         }

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

  3893.         n = ERR_GET_REASON(ERR_peek_last_error());

  3895.             /* handshake failures */
  3896.         if (n == SSL_R_BAD_CHANGE_CIPHER_SPEC                        /*  103 */
  3897. #ifdef SSL_R_NO_SUITABLE_KEY_SHARE
  3898.             || n == SSL_R_NO_SUITABLE_KEY_SHARE                      /*  101 */
  3899. #endif
  3900. #ifdef SSL_R_BAD_ALERT
  3901.             || n == SSL_R_BAD_ALERT                                  /*  102 */
  3902. #endif
  3903. #ifdef SSL_R_BAD_KEY_SHARE
  3904.             || n == SSL_R_BAD_KEY_SHARE                              /*  108 */
  3905. #endif
  3906. #ifdef SSL_R_BAD_EXTENSION
  3907.             || n == SSL_R_BAD_EXTENSION                              /*  110 */
  3908. #endif
  3909.             || n == SSL_R_BAD_DIGEST_LENGTH                          /*  111 */
  3910. #ifdef SSL_R_MISSING_SIGALGS_EXTENSION
  3911.             || n == SSL_R_MISSING_SIGALGS_EXTENSION                  /*  112 */
  3912. #endif
  3913.             || n == SSL_R_BAD_PACKET_LENGTH                          /*  115 */
  3914. #ifdef SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM
  3915.             || n == SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM            /*  118 */
  3916. #endif
  3917. #ifdef SSL_R_BAD_KEY_UPDATE
  3918.             || n == SSL_R_BAD_KEY_UPDATE                             /*  122 */
  3919. #endif
  3920.             || n == SSL_R_BLOCK_CIPHER_PAD_IS_WRONG                  /*  129 */
  3921.             || n == SSL_R_CCS_RECEIVED_EARLY                         /*  133 */
  3922. #ifdef SSL_R_DECODE_ERROR
  3923.             || n == SSL_R_DECODE_ERROR                               /*  137 */
  3924. #endif
  3925. #ifdef SSL_R_DATA_BETWEEN_CCS_AND_FINISHED
  3926.             || n == SSL_R_DATA_BETWEEN_CCS_AND_FINISHED              /*  145 */
  3927. #endif
  3928.             || n == SSL_R_DATA_LENGTH_TOO_LONG                       /*  146 */
  3929.             || n == SSL_R_DIGEST_CHECK_FAILED                        /*  149 */
  3930.             || n == SSL_R_ENCRYPTED_LENGTH_TOO_LONG                  /*  150 */
  3931.             || n == SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST              /*  151 */
  3932.             || n == SSL_R_EXCESSIVE_MESSAGE_SIZE                     /*  152 */
  3933. #ifdef SSL_R_GOT_A_FIN_BEFORE_A_CCS
  3934.             || n == SSL_R_GOT_A_FIN_BEFORE_A_CCS                     /*  154 */
  3935. #endif
  3936.             || n == SSL_R_HTTPS_PROXY_REQUEST                        /*  155 */
  3937.             || n == SSL_R_HTTP_REQUEST                               /*  156 */
  3938.             || n == SSL_R_LENGTH_MISMATCH                            /*  159 */
  3939. #ifdef SSL_R_LENGTH_TOO_SHORT
  3940.             || n == SSL_R_LENGTH_TOO_SHORT                           /*  160 */
  3941. #endif
  3942. #ifdef SSL_R_NO_RENEGOTIATION
  3943.             || n == SSL_R_NO_RENEGOTIATION                           /*  182 */
  3944. #endif
  3945. #ifdef SSL_R_NO_CIPHERS_PASSED
  3946.             || n == SSL_R_NO_CIPHERS_PASSED                          /*  182 */
  3947. #endif
  3948.             || n == SSL_R_NO_CIPHERS_SPECIFIED                       /*  183 */
  3949. #ifdef SSL_R_BAD_CIPHER
  3950.             || n == SSL_R_BAD_CIPHER                                 /*  186 */
  3951. #endif
  3952.             || n == SSL_R_NO_COMPRESSION_SPECIFIED                   /*  187 */
  3953.             || n == SSL_R_NO_SHARED_CIPHER                           /*  193 */
  3954. #ifdef SSL_R_PACKET_LENGTH_TOO_LONG
  3955.             || n == SSL_R_PACKET_LENGTH_TOO_LONG                     /*  198 */
  3956. #endif
  3957. #ifdef SSL_R_INVALID_ALERT
  3958.             || n == SSL_R_INVALID_ALERT                              /*  205 */
  3959. #endif
  3960.             || n == SSL_R_RECORD_LENGTH_MISMATCH                     /*  213 */
  3961. #ifdef SSL_R_TOO_MANY_WARNING_ALERTS
  3962.             || n == SSL_R_TOO_MANY_WARNING_ALERTS                    /*  220 */
  3963. #endif
  3964. #ifdef SSL_R_CLIENTHELLO_TLSEXT
  3965.             || n == SSL_R_CLIENTHELLO_TLSEXT                         /*  226 */
  3966. #endif
  3967. #ifdef SSL_R_PARSE_TLSEXT
  3968.             || n == SSL_R_PARSE_TLSEXT                               /*  227 */
  3969. #endif
  3970. #ifdef SSL_R_CALLBACK_FAILED
  3971.             || n == SSL_R_CALLBACK_FAILED                            /*  234 */
  3972. #endif
  3973. #ifdef SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG
  3974.             || n == SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG    /*  234 */
  3975. #endif
  3976. #ifdef SSL_R_NO_APPLICATION_PROTOCOL
  3977.             || n == SSL_R_NO_APPLICATION_PROTOCOL                    /*  235 */
  3978. #endif
  3979.             || n == SSL_R_UNEXPECTED_MESSAGE                         /*  244 */
  3980.             || n == SSL_R_UNEXPECTED_RECORD                          /*  245 */
  3981.             || n == SSL_R_UNKNOWN_ALERT_TYPE                         /*  246 */
  3982.             || n == SSL_R_UNKNOWN_PROTOCOL                           /*  252 */
  3983. #ifdef SSL_R_NO_COMMON_SIGNATURE_ALGORITHMS
  3984.             || n == SSL_R_NO_COMMON_SIGNATURE_ALGORITHMS             /*  253 */
  3985. #endif
  3986. #ifdef SSL_R_INVALID_COMPRESSION_LIST
  3987.             || n == SSL_R_INVALID_COMPRESSION_LIST                   /*  256 */
  3988. #endif
  3989. #ifdef SSL_R_MISSING_KEY_SHARE
  3990.             || n == SSL_R_MISSING_KEY_SHARE                          /*  258 */
  3991. #endif
  3992.             || n == SSL_R_UNSUPPORTED_PROTOCOL                       /*  258 */
  3993. #ifdef SSL_R_NO_SHARED_GROUP
  3994.             || n == SSL_R_NO_SHARED_GROUP                            /*  266 */
  3995. #endif
  3996.             || n == SSL_R_WRONG_VERSION_NUMBER                       /*  267 */
  3997. #ifdef SSL_R_TOO_MUCH_SKIPPED_EARLY_DATA
  3998.             || n == SSL_R_TOO_MUCH_SKIPPED_EARLY_DATA                /*  270 */
  3999. #endif
  4000.             || n == SSL_R_BAD_LENGTH                                 /*  271 */
  4001.             || n == SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC        /*  281 */
  4002. #ifdef SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY
  4003.             || n == SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY        /*  291 */
  4004. #endif
  4005. #ifdef SSL_R_APPLICATION_DATA_ON_SHUTDOWN
  4006.             || n == SSL_R_APPLICATION_DATA_ON_SHUTDOWN               /*  291 */
  4007. #endif
  4008. #ifdef SSL_R_BAD_LEGACY_VERSION
  4009.             || n == SSL_R_BAD_LEGACY_VERSION                         /*  292 */
  4010. #endif
  4011. #ifdef SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA
  4012.             || n == SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA     /*  293 */
  4013. #endif
  4014. #ifdef SSL_R_RECORD_TOO_SMALL
  4015.             || n == SSL_R_RECORD_TOO_SMALL                           /*  298 */
  4016. #endif
  4017. #ifdef SSL_R_SSL3_SESSION_ID_TOO_LONG
  4018.             || n == SSL_R_SSL3_SESSION_ID_TOO_LONG                   /*  300 */
  4019. #elif (defined SSL_R_TLS_SESSION_ID_TOO_LONG)
  4020.             || n == SSL_R_TLS_SESSION_ID_TOO_LONG                    /*  300 */
  4021. #endif
  4022. #ifdef SSL_R_BAD_ECPOINT
  4023.             || n == SSL_R_BAD_ECPOINT                                /*  306 */
  4024. #endif
  4025. #ifdef SSL_R_RECORD_LAYER_FAILURE
  4026.             || n == SSL_R_RECORD_LAYER_FAILURE                       /*  313 */
  4027. #endif
  4028. #ifdef SSL_R_RENEGOTIATE_EXT_TOO_LONG
  4029.             || n == SSL_R_RENEGOTIATE_EXT_TOO_LONG                   /*  335 */
  4030.             || n == SSL_R_RENEGOTIATION_ENCODING_ERR                 /*  336 */
  4031.             || n == SSL_R_RENEGOTIATION_MISMATCH                     /*  337 */
  4032. #endif
  4033. #ifdef SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED
  4034.             || n == SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED       /*  338 */
  4035. #endif
  4036. #ifdef SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING
  4037.             || n == SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING           /*  345 */
  4038. #endif
  4039. #ifdef SSL_R_INAPPROPRIATE_FALLBACK
  4040.             || n == SSL_R_INAPPROPRIATE_FALLBACK                     /*  373 */
  4041. #endif
  4042. #ifdef SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS
  4043.             || n == SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS             /*  376 */
  4044. #endif
  4045. #ifdef SSL_R_NO_SHARED_SIGATURE_ALGORITHMS
  4046.             || n == SSL_R_NO_SHARED_SIGATURE_ALGORITHMS              /*  376 */
  4047. #endif
  4048. #ifdef SSL_R_CERT_CB_ERROR
  4049.             || n == SSL_R_CERT_CB_ERROR                              /*  377 */
  4050. #endif
  4051. #ifdef SSL_R_VERSION_TOO_LOW
  4052.             || n == SSL_R_VERSION_TOO_LOW                            /*  396 */
  4053. #endif
  4054. #ifdef SSL_R_TOO_MANY_WARN_ALERTS
  4055.             || n == SSL_R_TOO_MANY_WARN_ALERTS                       /*  409 */
  4056. #endif
  4057. #ifdef SSL_R_BAD_RECORD_TYPE
  4058.             || n == SSL_R_BAD_RECORD_TYPE                            /*  443 */
  4059. #endif
  4060.             || (n >= SSL_AD_REASON_OFFSET                            /* 1000 */
  4061.                 && n <= SSL_AD_REASON_OFFSET + 255)
  4062.             )
  4063.         {
  4064.             switch (c->log_error) {

  4066.             case NGX_ERROR_IGNORE_ECONNRESET:
  4067.             case NGX_ERROR_INFO:
  4068.                 level = NGX_LOG_INFO;
  4069.                 break;

  4071.             case NGX_ERROR_ERR:
  4072.                 level = NGX_LOG_ERR;
  4073.                 break;

  4075.             default:
  4076.                 break;
  4077.             }
  4078.         }
  4079.     }

  4081.     ngx_ssl_error(level, c->log, err, text);
  4082. }


  4085. static void
  4086. ‌ngx_ssl_clear_error(ngx_log_t *log)
  4087. {
  4088.     while (ERR_peek_error()) {
  4089.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "ignoring stale global SSL error");
  4090.     }

  4092.     ERR_clear_error();
  4093. }


  4096. void ngx_cdecl
  4097. ‌ngx_ssl_error(ngx_uint_t level, ngx_log_t *log, ngx_err_t err, char *fmt, ...)
  4098. {
  4099.     int          flags;
  4100.     u_long       n;
  4101.     va_list      args;
  4102.     u_char      *p, *last;
  4103.     u_char       errstr[NGX_MAX_CONF_ERRSTR];
  4104.     const char  *data;

  4106.     last = errstr + NGX_MAX_CONF_ERRSTR;

  4108.     va_start(args, fmt);
  4109.     p = ngx_vslprintf(errstr, last - 1, fmt, args);
  4110.     va_end(args);

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

  4115.         for ( ;; ) {

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

  4119.             if (n == 0) {
  4120.                 break;
  4121.             }

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

  4125.             if (p >= last - 1) {
  4126.                 goto next;
  4127.             }

  4129.             *p++ = ' ';

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

  4133.             while (p < last && *p) {
  4134.                 p++;
  4135.             }

  4137.             if (p < last && *data && (flags & ERR_TXT_STRING)) {
  4138.                 *p++ = ':';
  4139.                 p = ngx_cpystrn(p, (u_char *) data, last - p);
  4140.             }

  4142.         next:

  4144.             (void) ERR_get_error();
  4145.         }

  4147.         if (p < last) {
  4148.             *p++ = ')';
  4149.         }
  4150.     }

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


  4156. ngx_int_t
  4157. ‌ngx_ssl_session_cache(ngx_ssl_t *ssl, ngx_str_t *sess_ctx,
  4158.     ngx_array_t *certificates, ssize_t builtin_session_cache,
  4159.     ngx_shm_zone_t *shm_zone, time_t timeout)
  4160. {
  4161.     long  cache_mode;

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

  4165.     if (ngx_ssl_session_id_context(ssl, sess_ctx, certificates) != NGX_OK) {
  4166.         return NGX_ERROR;
  4167.     }

  4169.     if (builtin_session_cache == NGX_SSL_NO_SCACHE) {
  4170.         SSL_CTX_set_session_cache_mode(ssl->ctx, SSL_SESS_CACHE_OFF);
  4171.         return NGX_OK;
  4172.     }

  4174.     if (builtin_session_cache == NGX_SSL_NONE_SCACHE) {

  4176.         /*
  4177.          * If the server explicitly says that it does not support
  4178.          * session reuse (see SSL_SESS_CACHE_OFF above), then
  4179.          * Outlook Express fails to upload a sent email to
  4180.          * the Sent Items folder on the IMAP server via a separate IMAP
  4181.          * connection in the background.  Therefore we have a special
  4182.          * mode (SSL_SESS_CACHE_SERVER|SSL_SESS_CACHE_NO_INTERNAL_STORE)
  4183.          * where the server pretends that it supports session reuse,
  4184.          * but it does not actually store any session.
  4185.          */

  4187.         SSL_CTX_set_session_cache_mode(ssl->ctx,
  4188.                                        SSL_SESS_CACHE_SERVER
  4189.                                        |SSL_SESS_CACHE_NO_AUTO_CLEAR
  4190.                                        |SSL_SESS_CACHE_NO_INTERNAL_STORE);

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

  4194.         return NGX_OK;
  4195.     }

  4197.     cache_mode = SSL_SESS_CACHE_SERVER;

  4199.     if (shm_zone && builtin_session_cache == NGX_SSL_NO_BUILTIN_SCACHE) {
  4200.         cache_mode |= SSL_SESS_CACHE_NO_INTERNAL;
  4201.     }

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

  4205.     if (builtin_session_cache != NGX_SSL_NO_BUILTIN_SCACHE) {

  4207.         if (builtin_session_cache != NGX_SSL_DFLT_BUILTIN_SCACHE) {
  4208.             SSL_CTX_sess_set_cache_size(ssl->ctx, builtin_session_cache);
  4209.         }
  4210.     }

  4212.     if (shm_zone) {
  4213.         SSL_CTX_sess_set_new_cb(ssl->ctx, ngx_ssl_new_session);
  4214.         SSL_CTX_sess_set_get_cb(ssl->ctx, ngx_ssl_get_cached_session);
  4215.         SSL_CTX_sess_set_remove_cb(ssl->ctx, ngx_ssl_remove_session);

  4217.         if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_session_cache_index, shm_zone)
  4218.             == 0)
  4219.         {
  4220.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4221.                           "SSL_CTX_set_ex_data() failed");
  4222.             return NGX_ERROR;
  4223.         }
  4224.     }

  4226.     return NGX_OK;
  4227. }


  4230. static ngx_int_t
  4231. ‌ngx_ssl_session_id_context(ngx_ssl_t *ssl, ngx_str_t *sess_ctx,
  4232.     ngx_array_t *certificates)
  4233. {
  4234.     int                   n, i;
  4235.     X509                 *cert;
  4236.     X509_NAME            *name;
  4237.     ngx_str_t            *certs;
  4238.     ngx_uint_t            k;
  4239.     EVP_MD_CTX           *md;
  4240.     unsigned int          len;
  4241.     STACK_OF(X509_NAME)  *list;
  4242.     u_char                buf[EVP_MAX_MD_SIZE];

  4244.     /*
  4245.      * Session ID context is set based on the string provided,
  4246.      * the server certificates, and the client CA list.
  4247.      */

  4249.     md = EVP_MD_CTX_create();
  4250.     if (md == NULL) {
  4251.         return NGX_ERROR;
  4252.     }

  4254.     if (EVP_DigestInit_ex(md, EVP_sha1(), NULL) == 0) {
  4255.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4256.                       "EVP_DigestInit_ex() failed");
  4257.         goto failed;
  4258.     }

  4260.     if (EVP_DigestUpdate(md, sess_ctx->data, sess_ctx->len) == 0) {
  4261.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4262.                       "EVP_DigestUpdate() failed");
  4263.         goto failed;
  4264.     }

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

  4269.         if (X509_digest(cert, EVP_sha1(), buf, &len) == 0) {
  4270.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4271.                           "X509_digest() failed");
  4272.             goto failed;
  4273.         }

  4275.         if (EVP_DigestUpdate(md, buf, len) == 0) {
  4276.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4277.                           "EVP_DigestUpdate() failed");
  4278.             goto failed;
  4279.         }
  4280.     }

  4282.     if (ssl->certs.nelts == 0 && certificates != NULL) {
  4283.         /*
  4284.          * If certificates are loaded dynamically, we use certificate
  4285.          * names as specified in the configuration (with variables).
  4286.          */

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

  4291.             if (EVP_DigestUpdate(md, certs[k].data, certs[k].len) == 0) {
  4292.                 ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4293.                               "EVP_DigestUpdate() failed");
  4294.                 goto failed;
  4295.             }
  4296.         }
  4297.     }

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

  4301.     if (list != NULL) {
  4302.         n = sk_X509_NAME_num(list);

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

  4307.             if (X509_NAME_digest(name, EVP_sha1(), buf, &len) == 0) {
  4308.                 ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4309.                               "X509_NAME_digest() failed");
  4310.                 goto failed;
  4311.             }

  4313.             if (EVP_DigestUpdate(md, buf, len) == 0) {
  4314.                 ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4315.                               "EVP_DigestUpdate() failed");
  4316.                 goto failed;
  4317.             }
  4318.         }
  4319.     }

  4321.     if (EVP_DigestFinal_ex(md, buf, &len) == 0) {
  4322.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4323.                       "EVP_DigestFinal_ex() failed");
  4324.         goto failed;
  4325.     }

  4327.     EVP_MD_CTX_destroy(md);

  4329.     if (SSL_CTX_set_session_id_context(ssl->ctx, buf, len) == 0) {
  4330.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4331.                       "SSL_CTX_set_session_id_context() failed");
  4332.         return NGX_ERROR;
  4333.     }

  4335.     return NGX_OK;

  4337. failed:

  4339.     EVP_MD_CTX_destroy(md);

  4341.     return NGX_ERROR;
  4342. }


  4345. ngx_int_t
  4346. ‌ngx_ssl_session_cache_init(ngx_shm_zone_t *shm_zone, void *data)
  4347. {
  4348.     size_t                    len;
  4349.     ngx_slab_pool_t          *shpool;
  4350.     ngx_ssl_session_cache_t  *cache;

  4352.     if (data) {
  4353.         shm_zone->data = data;
  4354.         return NGX_OK;
  4355.     }

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

  4359.     if (shm_zone->shm.exists) {
  4360.         shm_zone->data = shpool->data;
  4361.         return NGX_OK;
  4362.     }

  4364.     cache = ngx_slab_alloc(shpool, sizeof(ngx_ssl_session_cache_t));
  4365.     if (cache == NULL) {
  4366.         return NGX_ERROR;
  4367.     }

  4369.     shpool->data = cache;
  4370.     shm_zone->data = cache;

  4372.     ngx_rbtree_init(&cache->session_rbtree, &cache->sentinel,
  4373.                     ngx_ssl_session_rbtree_insert_value);

  4375.     ngx_queue_init(&cache->expire_queue);

  4377.     cache->ticket_keys[0].expire = 0;
  4378.     cache->ticket_keys[1].expire = 0;
  4379.     cache->ticket_keys[2].expire = 0;

  4381.     cache->fail_time = 0;

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

  4385.     shpool->log_ctx = ngx_slab_alloc(shpool, len);
  4386.     if (shpool->log_ctx == NULL) {
  4387.         return NGX_ERROR;
  4388.     }

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

  4393.     shpool->log_nomem = 0;

  4395.     return NGX_OK;
  4396. }


  4399. /*
  4400. * The length of the session id is 16 bytes for SSLv2 sessions and
  4401. * between 1 and 32 bytes for SSLv3 and TLS, typically 32 bytes.
  4402. * Typical length of the external ASN1 representation of a session
  4403. * is about 150 bytes plus SNI server name.
  4404. *
  4405. * On 32-bit platforms we allocate an rbtree node, a session id, and
  4406. * an ASN1 representation in a single allocation, it typically takes
  4407. * 256 bytes.
  4408. *
  4409. * On 64-bit platforms we allocate separately an rbtree node + session_id,
  4410. * and an ASN1 representation, they take accordingly 128 and 256 bytes.
  4411. *
  4412. * OpenSSL's i2d_SSL_SESSION() and d2i_SSL_SESSION are slow,
  4413. * so they are outside the code locked by shared pool mutex
  4414. */

  4416. static int
  4417. ‌ngx_ssl_new_session(ngx_ssl_conn_t *ssl_conn, ngx_ssl_session_t *sess)
  4418. {
  4419.     int                       len;
  4420.     u_char                   *p, *session_id;
  4421.     size_t                    n;
  4422.     uint32_t                  hash;
  4423.     SSL_CTX                  *ssl_ctx;
  4424.     unsigned int              session_id_length;
  4425.     ngx_shm_zone_t           *shm_zone;
  4426.     ngx_connection_t         *c;
  4427.     ngx_slab_pool_t          *shpool;
  4428.     ngx_ssl_sess_id_t        *sess_id;
  4429.     ngx_ssl_session_cache_t  *cache;

  4431. #ifdef TLS1_3_VERSION

  4433.     /*
  4434.      * OpenSSL tries to save TLSv1.3 sessions into session cache
  4435.      * even when using tickets for stateless session resumption,
  4436.      * "because some applications just want to know about the creation
  4437.      * of a session"; do not cache such sessions
  4438.      */

  4440.     if (SSL_version(ssl_conn) == TLS1_3_VERSION
  4441.         && (SSL_get_options(ssl_conn) & SSL_OP_NO_TICKET) == 0)
  4442.     {
  4443.         return 0;
  4444.     }

  4446. #endif

  4448.     len = i2d_SSL_SESSION(sess, NULL);

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

  4452.     if (len > NGX_SSL_MAX_SESSION_SIZE) {
  4453.         return 0;
  4454.     }

  4456.     p = ngx_ssl_session_buffer;
  4457.     i2d_SSL_SESSION(sess, &p);

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

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

  4463.     if (session_id_length > 32) {
  4464.         return 0;
  4465.     }

  4467.     c = ngx_ssl_get_connection(ssl_conn);

  4469.     ssl_ctx = c->ssl->session_ctx;
  4470.     shm_zone = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_session_cache_index);

  4472.     cache = shm_zone->data;
  4473.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

  4475.     ngx_shmtx_lock(&shpool->mutex);

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

  4480. #if (NGX_PTR_SIZE == 8)
  4481.     n = sizeof(ngx_ssl_sess_id_t);
  4482. #else
  4483.     n = offsetof(ngx_ssl_sess_id_t, session) + len;
  4484. #endif

  4486.     sess_id = ngx_slab_alloc_locked(shpool, n);

  4488.     if (sess_id == NULL) {

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

  4492.         ngx_ssl_expire_sessions(cache, shpool, 0);

  4494.         sess_id = ngx_slab_alloc_locked(shpool, n);

  4496.         if (sess_id == NULL) {
  4497.             goto failed;
  4498.         }
  4499.     }

  4501. #if (NGX_PTR_SIZE == 8)

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

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

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

  4509.         ngx_ssl_expire_sessions(cache, shpool, 0);

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

  4513.         if (sess_id->session == NULL) {
  4514.             goto failed;
  4515.         }
  4516.     }

  4518. #endif

  4520.     ngx_memcpy(sess_id->session, ngx_ssl_session_buffer, len);
  4521.     ngx_memcpy(sess_id->id, session_id, session_id_length);

  4523.     hash = ngx_crc32_short(session_id, session_id_length);

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

  4529.     sess_id->node.key = hash;
  4530.     sess_id->node.data = (u_char) session_id_length;
  4531.     sess_id->len = len;

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

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

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

  4539.     ngx_shmtx_unlock(&shpool->mutex);

  4541.     return 0;

  4543. failed:

  4545.     if (sess_id) {
  4546.         ngx_slab_free_locked(shpool, sess_id);
  4547.     }

  4549.     ngx_shmtx_unlock(&shpool->mutex);

  4551.     if (cache->fail_time != ngx_time()) {
  4552.         cache->fail_time = ngx_time();
  4553.         ngx_log_error(NGX_LOG_WARN, c->log, 0,
  4554.                       "could not allocate new session%s", shpool->log_ctx);
  4555.     }

  4557.     return 0;
  4558. }


  4561. static ngx_ssl_session_t *
  4562. ‌ngx_ssl_get_cached_session(ngx_ssl_conn_t *ssl_conn,
  4563. #if OPENSSL_VERSION_NUMBER >= 0x10100003L
  4564.     const
  4565. #endif
  4566.     u_char *id, int len, int *copy)
  4567. {
  4568.     size_t                    slen;
  4569.     uint32_t                  hash;
  4570.     ngx_int_t                 rc;
  4571.     const u_char             *p;
  4572.     ngx_shm_zone_t           *shm_zone;
  4573.     ngx_slab_pool_t          *shpool;
  4574.     ngx_connection_t         *c;
  4575.     ngx_rbtree_node_t        *node, *sentinel;
  4576.     ngx_ssl_session_t        *sess;
  4577.     ngx_ssl_sess_id_t        *sess_id;
  4578.     ngx_ssl_session_cache_t  *cache;

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

  4583.     c = ngx_ssl_get_connection(ssl_conn);

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

  4588.     shm_zone = SSL_CTX_get_ex_data(c->ssl->session_ctx,
  4589.                                    ngx_ssl_session_cache_index);

  4591.     cache = shm_zone->data;

  4593.     sess = NULL;

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

  4597.     ngx_shmtx_lock(&shpool->mutex);

  4599.     node = cache->session_rbtree.root;
  4600.     sentinel = cache->session_rbtree.sentinel;

  4602.     while (node != sentinel) {

  4604.         if (hash < node->key) {
  4605.             node = node->left;
  4606.             continue;
  4607.         }

  4609.         if (hash > node->key) {
  4610.             node = node->right;
  4611.             continue;
  4612.         }

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

  4616.         sess_id = (ngx_ssl_sess_id_t *) node;

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

  4621.         if (rc == 0) {

  4623.             if (sess_id->expire > ngx_time()) {
  4624.                 slen = sess_id->len;

  4626.                 ngx_memcpy(ngx_ssl_session_buffer, sess_id->session, slen);

  4628.                 ngx_shmtx_unlock(&shpool->mutex);

  4630.                 p = ngx_ssl_session_buffer;
  4631.                 sess = d2i_SSL_SESSION(NULL, &p, slen);

  4633.                 return sess;
  4634.             }

  4636.             ngx_queue_remove(&sess_id->queue);

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

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

  4642. #if (NGX_PTR_SIZE == 8)
  4643.             ngx_slab_free_locked(shpool, sess_id->session);
  4644. #endif
  4645.             ngx_slab_free_locked(shpool, sess_id);

  4647.             sess = NULL;

  4649.             goto done;
  4650.         }

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

  4655. done:

  4657.     ngx_shmtx_unlock(&shpool->mutex);

  4659.     return sess;
  4660. }


  4663. void
  4664. ‌ngx_ssl_remove_cached_session(SSL_CTX *ssl, ngx_ssl_session_t *sess)
  4665. {
  4666.     SSL_CTX_remove_session(ssl, sess);

  4668.     ngx_ssl_remove_session(ssl, sess);
  4669. }


  4672. static void
  4673. ‌ngx_ssl_remove_session(SSL_CTX *ssl, ngx_ssl_session_t *sess)
  4674. {
  4675.     u_char                   *id;
  4676.     uint32_t                  hash;
  4677.     ngx_int_t                 rc;
  4678.     unsigned int              len;
  4679.     ngx_shm_zone_t           *shm_zone;
  4680.     ngx_slab_pool_t          *shpool;
  4681.     ngx_rbtree_node_t        *node, *sentinel;
  4682.     ngx_ssl_sess_id_t        *sess_id;
  4683.     ngx_ssl_session_cache_t  *cache;

  4685.     shm_zone = SSL_CTX_get_ex_data(ssl, ngx_ssl_session_cache_index);

  4687.     if (shm_zone == NULL) {
  4688.         return;
  4689.     }

  4691.     cache = shm_zone->data;

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

  4695.     hash = ngx_crc32_short(id, len);

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

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

  4702.     ngx_shmtx_lock(&shpool->mutex);

  4704.     node = cache->session_rbtree.root;
  4705.     sentinel = cache->session_rbtree.sentinel;

  4707.     while (node != sentinel) {

  4709.         if (hash < node->key) {
  4710.             node = node->left;
  4711.             continue;
  4712.         }

  4714.         if (hash > node->key) {
  4715.             node = node->right;
  4716.             continue;
  4717.         }

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

  4721.         sess_id = (ngx_ssl_sess_id_t *) node;

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

  4725.         if (rc == 0) {

  4727.             ngx_queue_remove(&sess_id->queue);

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

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

  4733. #if (NGX_PTR_SIZE == 8)
  4734.             ngx_slab_free_locked(shpool, sess_id->session);
  4735. #endif
  4736.             ngx_slab_free_locked(shpool, sess_id);

  4738.             goto done;
  4739.         }

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

  4744. done:

  4746.     ngx_shmtx_unlock(&shpool->mutex);
  4747. }


  4750. static void
  4751. ‌ngx_ssl_expire_sessions(ngx_ssl_session_cache_t *cache,
  4752.     ngx_slab_pool_t *shpool, ngx_uint_t n)
  4753. {
  4754.     time_t              now;
  4755.     ngx_queue_t        *q;
  4756.     ngx_ssl_sess_id_t  *sess_id;

  4758.     now = ngx_time();

  4760.     while (n < 3) {

  4762.         if (ngx_queue_empty(&cache->expire_queue)) {
  4763.             return;
  4764.         }

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

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

  4770.         if (n++ != 0 && sess_id->expire > now) {
  4771.             return;
  4772.         }

  4774.         ngx_queue_remove(q);

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

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

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

  4783. #if (NGX_PTR_SIZE == 8)
  4784.         ngx_slab_free_locked(shpool, sess_id->session);
  4785. #endif
  4786.         ngx_slab_free_locked(shpool, sess_id);
  4787.     }
  4788. }


  4791. static void
  4792. ‌ngx_ssl_session_rbtree_insert_value(ngx_rbtree_node_t *temp,
  4793.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  4794. {
  4795.     ngx_rbtree_node_t  **p;
  4796.     ngx_ssl_sess_id_t   *sess_id, *sess_id_temp;

  4798.     for ( ;; ) {

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

  4802.             p = &temp->left;

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

  4806.             p = &temp->right;

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

  4810.             sess_id = (ngx_ssl_sess_id_t *) node;
  4811.             sess_id_temp = (ngx_ssl_sess_id_t *) temp;

  4813.             p = (ngx_memn2cmp(sess_id->id, sess_id_temp->id,
  4814.                               (size_t) node->data, (size_t) temp->data)
  4815.                  < 0) ? &temp->left : &temp->right;
  4816.         }

  4818.         if (*p == sentinel) {
  4819.             break;
  4820.         }

  4822.         temp = *p;
  4823.     }

  4825.     *p = node;
  4826.     node->parent = temp;
  4827.     node->left = sentinel;
  4828.     node->right = sentinel;
  4829.     ngx_rbt_red(node);
  4830. }


  4833. #ifdef SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB

  4835. ngx_int_t
  4836. ‌ngx_ssl_session_ticket_keys(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_array_t *paths)
  4837. {
  4838.     u_char                 buf[80];
  4839.     size_t                 size;
  4840.     ssize_t                n;
  4841.     ngx_str_t             *path;
  4842.     ngx_file_t             file;
  4843.     ngx_uint_t             i;
  4844.     ngx_array_t           *keys;
  4845.     ngx_file_info_t        fi;
  4846.     ngx_pool_cleanup_t    *cln;
  4847.     ngx_ssl_ticket_key_t  *key;

  4849.     if (paths == NULL
  4850.         && SSL_CTX_get_ex_data(ssl->ctx, ngx_ssl_session_cache_index) == NULL)
  4851.     {
  4852.         return NGX_OK;
  4853.     }

  4855.     keys = ngx_array_create(cf->pool, paths ? paths->nelts : 3,
  4856.                             sizeof(ngx_ssl_ticket_key_t));
  4857.     if (keys == NULL) {
  4858.         return NGX_ERROR;
  4859.     }

  4861.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  4862.     if (cln == NULL) {
  4863.         return NGX_ERROR;
  4864.     }

  4866.     cln->handler = ngx_ssl_ticket_keys_cleanup;
  4867.     cln->data = keys;

  4869.     if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_ticket_keys_index, keys) == 0) {
  4870.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4871.                       "SSL_CTX_set_ex_data() failed");
  4872.         return NGX_ERROR;
  4873.     }

  4875.     if (SSL_CTX_set_tlsext_ticket_key_cb(ssl->ctx, ngx_ssl_ticket_key_callback)
  4876.         == 0)
  4877.     {
  4878.         ngx_log_error(NGX_LOG_WARN, cf->log, 0,
  4879.                       "nginx was built with Session Tickets support, however, "
  4880.                       "now it is linked dynamically to an OpenSSL library "
  4881.                       "which has no tlsext support, therefore Session Tickets "
  4882.                       "are not available");
  4883.         return NGX_OK;
  4884.     }

  4886.     if (paths == NULL) {

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

  4890.         key = ngx_array_push_n(keys, 3);
  4891.         key[0].shared = 1;
  4892.         key[0].expire = 0;
  4893.         key[1].shared = 1;
  4894.         key[1].expire = 0;
  4895.         key[2].shared = 1;
  4896.         key[2].expire = 0;

  4898.         return NGX_OK;
  4899.     }

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

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

  4908.         ngx_memzero(&file, sizeof(ngx_file_t));
  4909.         file.name = path[i];
  4910.         file.log = cf->log;

  4912.         file.fd = ngx_open_file(file.name.data, NGX_FILE_RDONLY,
  4913.                                 NGX_FILE_OPEN, 0);

  4915.         if (file.fd == NGX_INVALID_FILE) {
  4916.             ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  4917.                                ngx_open_file_n " \"%V\" failed", &file.name);
  4918.             return NGX_ERROR;
  4919.         }

  4921.         if (ngx_fd_info(file.fd, &fi) == NGX_FILE_ERROR) {
  4922.             ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  4923.                                ngx_fd_info_n " \"%V\" failed", &file.name);
  4924.             goto failed;
  4925.         }

  4927.         size = ngx_file_size(&fi);

  4929.         if (size != 48 && size != 80) {
  4930.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4931.                                "\"%V\" must be 48 or 80 bytes", &file.name);
  4932.             goto failed;
  4933.         }

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

  4937.         if (n == NGX_ERROR) {
  4938.             ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  4939.                                ngx_read_file_n " \"%V\" failed", &file.name);
  4940.             goto failed;
  4941.         }

  4943.         if ((size_t) n != size) {
  4944.             ngx_conf_log_error(NGX_LOG_CRIT, cf, 0,
  4945.                                ngx_read_file_n " \"%V\" returned only "
  4946.                                "%z bytes instead of %uz", &file.name, n, size);
  4947.             goto failed;
  4948.         }

  4950.         key = ngx_array_push(keys);
  4951.         if (key == NULL) {
  4952.             goto failed;
  4953.         }

  4955.         key->shared = 0;
  4956.         key->expire = 1;

  4958.         if (size == 48) {
  4959.             key->size = 48;
  4960.             ngx_memcpy(key->name, buf, 16);
  4961.             ngx_memcpy(key->aes_key, buf + 16, 16);
  4962.             ngx_memcpy(key->hmac_key, buf + 32, 16);

  4964.         } else {
  4965.             key->size = 80;
  4966.             ngx_memcpy(key->name, buf, 16);
  4967.             ngx_memcpy(key->hmac_key, buf + 16, 32);
  4968.             ngx_memcpy(key->aes_key, buf + 48, 32);
  4969.         }

  4971.         if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  4972.             ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  4973.                           ngx_close_file_n " \"%V\" failed", &file.name);
  4974.         }

  4976.         ngx_explicit_memzero(&buf, 80);
  4977.     }

  4979.     return NGX_OK;

  4981. failed:

  4983.     if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  4984.         ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  4985.                       ngx_close_file_n " \"%V\" failed", &file.name);
  4986.     }

  4988.     ngx_explicit_memzero(&buf, 80);

  4990.     return NGX_ERROR;
  4991. }


  4994. static int
  4995. ‌ngx_ssl_ticket_key_callback(ngx_ssl_conn_t *ssl_conn,
  4996.     unsigned char *name, unsigned char *iv, EVP_CIPHER_CTX *ectx,
  4997.     HMAC_CTX *hctx, int enc)
  4998. {
  4999.     size_t                 size;
  5000.     SSL_CTX               *ssl_ctx;
  5001.     ngx_uint_t             i;
  5002.     ngx_array_t           *keys;
  5003.     ngx_connection_t      *c;
  5004.     ngx_ssl_ticket_key_t  *key;
  5005.     const EVP_MD          *digest;
  5006.     const EVP_CIPHER      *cipher;

  5008.     c = ngx_ssl_get_connection(ssl_conn);
  5009.     ssl_ctx = c->ssl->session_ctx;

  5011.     if (ngx_ssl_rotate_ticket_keys(ssl_ctx, c->log) != NGX_OK) {
  5012.         return -1;
  5013.     }

  5015. #ifdef OPENSSL_NO_SHA256
  5016.     digest = EVP_sha1();
  5017. #else
  5018.     digest = EVP_sha256();
  5019. #endif

  5021.     keys = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_ticket_keys_index);
  5022.     if (keys == NULL) {
  5023.         return -1;
  5024.     }

  5026.     key = keys->elts;

  5028.     if (enc == 1) {
  5029.         /* encrypt session ticket */

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

  5036.         if (key[0].size == 48) {
  5037.             cipher = EVP_aes_128_cbc();
  5038.             size = 16;

  5040.         } else {
  5041.             cipher = EVP_aes_256_cbc();
  5042.             size = 32;
  5043.         }

  5045.         if (RAND_bytes(iv, EVP_CIPHER_iv_length(cipher)) != 1) {
  5046.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "RAND_bytes() failed");
  5047.             return -1;
  5048.         }

  5050.         if (EVP_EncryptInit_ex(ectx, cipher, NULL, key[0].aes_key, iv) != 1) {
  5051.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  5052.                           "EVP_EncryptInit_ex() failed");
  5053.             return -1;
  5054.         }

  5056. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  5057.         if (HMAC_Init_ex(hctx, key[0].hmac_key, size, digest, NULL) != 1) {
  5058.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "HMAC_Init_ex() failed");
  5059.             return -1;
  5060.         }
  5061. #else
  5062.         HMAC_Init_ex(hctx, key[0].hmac_key, size, digest, NULL);
  5063. #endif

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

  5067.         return 1;

  5069.     } else {
  5070.         /* decrypt session ticket */

  5072.         for (i = 0; i < keys->nelts; i++) {
  5073.             if (ngx_memcmp(name, key[i].name, 16) == 0) {
  5074.                 goto found;
  5075.             }
  5076.         }

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

  5082.         return 0;

  5084.     found:

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

  5090.         if (key[i].size == 48) {
  5091.             cipher = EVP_aes_128_cbc();
  5092.             size = 16;

  5094.         } else {
  5095.             cipher = EVP_aes_256_cbc();
  5096.             size = 32;
  5097.         }

  5099. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  5100.         if (HMAC_Init_ex(hctx, key[i].hmac_key, size, digest, NULL) != 1) {
  5101.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "HMAC_Init_ex() failed");
  5102.             return -1;
  5103.         }
  5104. #else
  5105.         HMAC_Init_ex(hctx, key[i].hmac_key, size, digest, NULL);
  5106. #endif

  5108.         if (EVP_DecryptInit_ex(ectx, cipher, NULL, key[i].aes_key, iv) != 1) {
  5109.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  5110.                           "EVP_DecryptInit_ex() failed");
  5111.             return -1;
  5112.         }

  5114.         /* renew if TLSv1.3 */

  5116. #ifdef TLS1_3_VERSION
  5117.         if (SSL_version(ssl_conn) == TLS1_3_VERSION) {
  5118.             return 2;
  5119.         }
  5120. #endif

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

  5124.         if (i != 0 && key[i].expire) {
  5125.             return 2;
  5126.         }

  5128.         return 1;
  5129.     }
  5130. }


  5133. static ngx_int_t
  5134. ‌ngx_ssl_rotate_ticket_keys(SSL_CTX *ssl_ctx, ngx_log_t *log)
  5135. {
  5136.     time_t                    now, expire;
  5137.     ngx_array_t              *keys;
  5138.     ngx_shm_zone_t           *shm_zone;
  5139.     ngx_slab_pool_t          *shpool;
  5140.     ngx_ssl_ticket_key_t     *key;
  5141.     ngx_ssl_session_cache_t  *cache;
  5142.     u_char                    buf[80];

  5144.     keys = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_ticket_keys_index);
  5145.     if (keys == NULL) {
  5146.         return NGX_OK;
  5147.     }

  5149.     key = keys->elts;

  5151.     if (!key[0].shared) {
  5152.         return NGX_OK;
  5153.     }

  5155.     /*
  5156.      * if we don't need to update expiration of the current key
  5157.      * and the previous key is still needed, don't sync with shared
  5158.      * memory to save some work; in the worst case other worker process
  5159.      * will switch to the next key, but this process will still be able
  5160.      * to decrypt tickets encrypted with it
  5161.      */

  5163.     now = ngx_time();
  5164.     expire = now + SSL_CTX_get_timeout(ssl_ctx);

  5166.     if (key[0].expire >= expire && key[1].expire >= now) {
  5167.         return NGX_OK;
  5168.     }

  5170.     shm_zone = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_session_cache_index);

  5172.     cache = shm_zone->data;
  5173.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

  5175.     ngx_shmtx_lock(&shpool->mutex);

  5177.     key = cache->ticket_keys;

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

  5181.         /* initialize the current key */

  5183.         if (RAND_bytes(buf, 80) != 1) {
  5184.             ngx_ssl_error(NGX_LOG_ALERT, log, 0, "RAND_bytes() failed");
  5185.             ngx_shmtx_unlock(&shpool->mutex);
  5186.             return NGX_ERROR;
  5187.         }

  5189.         key[0].shared = 1;
  5190.         key[0].expire = expire;
  5191.         key[0].size = 80;
  5192.         ngx_memcpy(key[0].name, buf, 16);
  5193.         ngx_memcpy(key[0].hmac_key, buf + 16, 32);
  5194.         ngx_memcpy(key[0].aes_key, buf + 48, 32);

  5196.         ngx_explicit_memzero(&buf, 80);

  5198.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0,
  5199.                        "ssl ticket key: \"%*xs\"",
  5200.                        (size_t) 16, key[0].name);

  5202.         /*
  5203.          * copy the current key to the next key, as initialization of
  5204.          * the previous key will replace the current key with the next
  5205.          * key
  5206.          */

  5208.         key[2] = key[0];
  5209.     }

  5211.     if (key[1].expire < now) {

  5213.         /*
  5214.          * if the previous key is no longer needed (or not initialized),
  5215.          * replace it with the current key, replace the current key with
  5216.          * the next key, and generate new next key
  5217.          */

  5219.         key[1] = key[0];
  5220.         key[0] = key[2];

  5222.         if (RAND_bytes(buf, 80) != 1) {
  5223.             ngx_ssl_error(NGX_LOG_ALERT, log, 0, "RAND_bytes() failed");
  5224.             ngx_shmtx_unlock(&shpool->mutex);
  5225.             return NGX_ERROR;
  5226.         }

  5228.         key[2].shared = 1;
  5229.         key[2].expire = 0;
  5230.         key[2].size = 80;
  5231.         ngx_memcpy(key[2].name, buf, 16);
  5232.         ngx_memcpy(key[2].hmac_key, buf + 16, 32);
  5233.         ngx_memcpy(key[2].aes_key, buf + 48, 32);

  5235.         ngx_explicit_memzero(&buf, 80);

  5237.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0,
  5238.                        "ssl ticket key: \"%*xs\"",
  5239.                        (size_t) 16, key[2].name);
  5240.     }

  5242.     /*
  5243.      * update expiration of the current key: it is going to be needed
  5244.      * at least till the session being created expires
  5245.      */

  5247.     if (expire > key[0].expire) {
  5248.         key[0].expire = expire;
  5249.     }

  5251.     /* sync keys to the worker process memory */

  5253.     ngx_memcpy(keys->elts, cache->ticket_keys,
  5254.                2 * sizeof(ngx_ssl_ticket_key_t));

  5256.     ngx_shmtx_unlock(&shpool->mutex);

  5258.     return NGX_OK;
  5259. }


  5262. static void
  5263. ‌ngx_ssl_ticket_keys_cleanup(void *data)
  5264. {
  5265.     ngx_array_t  *keys = data;

  5267.     ngx_explicit_memzero(keys->elts,
  5268.                          keys->nelts * sizeof(ngx_ssl_ticket_key_t));
  5269. }

  5271. #else

  5273. ngx_int_t
  5274. ‌ngx_ssl_session_ticket_keys(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_array_t *paths)
  5275. {
  5276.     if (paths) {
  5277.         ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  5278.                       "\"ssl_session_ticket_key\" ignored, not supported");
  5279.     }

  5281.     return NGX_OK;
  5282. }

  5284. #endif


  5287. void
  5288. ‌ngx_ssl_cleanup_ctx(void *data)
  5289. {
  5290.     ngx_ssl_t  *ssl = data;

  5292.     X509        *cert;
  5293.     u_char      *p;
  5294.     ngx_uint_t   i;

  5296.     for (i = 0; i < ssl->certs.nelts; i++) {
  5297.         cert = ((X509 **) ssl->certs.elts)[i];

  5299.         p = X509_get_ex_data(cert, ngx_ssl_certificate_comp_index);

  5301.         if (p) {
  5302.             ngx_free(p);
  5303.             X509_set_ex_data(cert, ngx_ssl_certificate_comp_index, NULL);
  5304.         }

  5306.         X509_free(cert);
  5307.     }

  5309.     SSL_CTX_free(ssl->ctx);
  5310. }


  5313. ngx_int_t
  5314. ‌ngx_ssl_check_host(ngx_connection_t *c, ngx_str_t *name)
  5315. {
  5316.     X509       *cert;
  5317.     u_char     *addr;
  5318.     size_t      alen;
  5319.     in_addr_t   addr4;
  5320. #if (NGX_HAVE_INET6)
  5321.     u_char      addr6[16];
  5322. #endif

  5324.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5325.     if (cert == NULL) {
  5326.         return NGX_ERROR;
  5327.     }

  5329.     if (name->len == 0) {
  5330.         goto failed;
  5331.     }

  5333.     addr4 = ngx_inet_addr(name->data, name->len);

  5335.     if (addr4 != INADDR_NONE) {
  5336.         addr = (u_char *) &addr4;
  5337.         alen = 4;

  5339. #if (NGX_HAVE_INET6)
  5340.     } else if (name->data[0] == '[') {

  5342.         if (name->data[name->len - 1] != ']') {
  5343.             goto failed;
  5344.         }

  5346.         if (ngx_inet6_addr(name->data + 1, name->len - 2, addr6) != NGX_OK) {
  5347.             goto failed;
  5348.         }

  5350.         addr = addr6;
  5351.         alen = 16;

  5353. #endif
  5354.     } else {
  5355.         addr = NULL;
  5356.         alen = 0;
  5357.     }

  5359. #ifdef X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT

  5361.     /* X509_check_host() is only available in OpenSSL 1.0.2+ */

  5363.     if (addr) {
  5364.         if (X509_check_ip(cert, addr, alen, 0) != 1) {
  5365.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5366.                            "X509_check_ip(): no match");
  5367.             goto failed;
  5368.         }

  5370.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5371.                        "X509_check_ip(): match");
  5372.         goto found;
  5373.     }

  5375.     if (X509_check_host(cert, (char *) name->data, name->len, 0, NULL) != 1) {
  5376.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5377.                        "X509_check_host(): no match");
  5378.         goto failed;
  5379.     }

  5381.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5382.                    "X509_check_host(): match");
  5383.     goto found;

  5385. #else
  5386.     {
  5387.     int                      n, i;
  5388.     size_t                   dlen;
  5389.     u_char                  *data;
  5390.     X509_NAME               *sname;
  5391.     ASN1_STRING             *str;
  5392.     X509_NAME_ENTRY         *entry;
  5393.     GENERAL_NAME            *altname;
  5394.     STACK_OF(GENERAL_NAME)  *altnames;

  5396.     /*
  5397.      * As per RFC6125 and RFC2818, we check subjectAltName extension,
  5398.      * and if it's not present - commonName in Subject is checked.
  5399.      */

  5401.     altnames = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);

  5403.     if (altnames) {
  5404.         n = sk_GENERAL_NAME_num(altnames);

  5406.         for (i = 0; i < n; i++) {
  5407.             altname = sk_GENERAL_NAME_value(altnames, i);

  5409.             if (altname->type == GEN_DNS) {

  5411.                 str = altname->d.dNSName;

  5413.                 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5414.                                "SSL subjectAltName: \"%*s\"",
  5415.                                (size_t) ASN1_STRING_length(str),
  5416.                                ASN1_STRING_data(str));

  5418.                 if (addr == NULL && ngx_ssl_check_name(name, str) == NGX_OK) {
  5419.                     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5420.                                    "SSL subjectAltName: match");
  5421.                     GENERAL_NAMES_free(altnames);
  5422.                     goto found;
  5423.                 }

  5425.             } else if (altname->type == GEN_IPADD) {

  5427.                 str = altname->d.iPAddress;
  5428.                 data = ASN1_STRING_data(str);
  5429.                 dlen = ASN1_STRING_length(str);

  5431. #if (NGX_DEBUG)
  5432.                 {
  5433.                 size_t  al;
  5434.                 u_char  at[NGX_INET6_ADDRSTRLEN];

  5436.                 if (dlen == 4) {
  5437.                     al = ngx_inet_ntop(AF_INET, data, at,
  5438.                                        NGX_INET6_ADDRSTRLEN);

  5440. #if (NGX_HAVE_INET6)
  5441.                 } else if (dlen == 16) {
  5442.                     al = ngx_inet_ntop(AF_INET6, data, at,
  5443.                                        NGX_INET6_ADDRSTRLEN);

  5445. #endif
  5446.                 } else {
  5447.                     al = ngx_cpymem(at, "<invalid>", sizeof("<invalid>") - 1)
  5448.                          - at;
  5449.                 }

  5451.                 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5452.                                "SSL subjectAltName: \"%*s\"",
  5453.                                al, at);
  5454.                 }
  5455. #endif

  5457.                 if (addr
  5458.                     && alen == dlen
  5459.                     && ngx_memcmp(addr, data, dlen) == 0)
  5460.                 {
  5461.                     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5462.                                    "SSL subjectAltName: match");
  5463.                     GENERAL_NAMES_free(altnames);
  5464.                     goto found;
  5465.                 }
  5466.             }
  5467.         }

  5469.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5470.                        "SSL subjectAltName: no match");

  5472.         GENERAL_NAMES_free(altnames);
  5473.         goto failed;
  5474.     }

  5476.     /*
  5477.      * If there is no subjectAltName extension, check commonName
  5478.      * in Subject.  While RFC2818 requires to only check "most specific"
  5479.      * CN, both Apache and OpenSSL check all CNs, and so do we.
  5480.      */

  5482.     if (addr) {
  5483.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5484.                        "SSL commonName: no match");
  5485.         goto failed;
  5486.     }

  5488.     sname = X509_get_subject_name(cert);

  5490.     if (sname == NULL) {
  5491.         goto failed;
  5492.     }

  5494.     i = -1;
  5495.     for ( ;; ) {
  5496.         i = X509_NAME_get_index_by_NID(sname, NID_commonName, i);

  5498.         if (i < 0) {
  5499.             break;
  5500.         }

  5502.         entry = X509_NAME_get_entry(sname, i);
  5503.         str = X509_NAME_ENTRY_get_data(entry);

  5505.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5506.                        "SSL commonName: \"%*s\"",
  5507.                        (size_t) ASN1_STRING_length(str),
  5508.                        ASN1_STRING_data(str));

  5510.         if (ngx_ssl_check_name(name, str) == NGX_OK) {
  5511.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5512.                            "SSL commonName: match");
  5513.             goto found;
  5514.         }
  5515.     }

  5517.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5518.                    "SSL commonName: no match");
  5519.     }
  5520. #endif

  5522. failed:

  5524.     X509_free(cert);
  5525.     return NGX_ERROR;

  5527. found:

  5529.     X509_free(cert);
  5530.     return NGX_OK;
  5531. }


  5534. #ifndef X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT

  5536. static ngx_int_t
  5537. ‌ngx_ssl_check_name(ngx_str_t *name, ASN1_STRING *pattern)
  5538. {
  5539.     u_char  *s, *p, *end;
  5540.     size_t   slen, plen;

  5542.     s = name->data;
  5543.     slen = name->len;

  5545.     p = ASN1_STRING_data(pattern);
  5546.     plen = ASN1_STRING_length(pattern);

  5548.     if (slen == plen && ngx_strncasecmp(s, p, plen) == 0) {
  5549.         return NGX_OK;
  5550.     }

  5552.     if (plen > 2 && p[0] == '*' && p[1] == '.') {
  5553.         plen -= 1;
  5554.         p += 1;

  5556.         end = s + slen;
  5557.         s = ngx_strlchr(s, end, '.');

  5559.         if (s == NULL) {
  5560.             return NGX_ERROR;
  5561.         }

  5563.         slen = end - s;

  5565.         if (plen == slen && ngx_strncasecmp(s, p, plen) == 0) {
  5566.             return NGX_OK;
  5567.         }
  5568.     }

  5570.     return NGX_ERROR;
  5571. }

  5573. #endif


  5576. ngx_int_t
  5577. ‌ngx_ssl_get_protocol(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5578. {
  5579.     s->data = (u_char *) SSL_get_version(c->ssl->connection);
  5580.     return NGX_OK;
  5581. }


  5584. ngx_int_t
  5585. ‌ngx_ssl_get_cipher_name(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5586. {
  5587.     s->data = (u_char *) SSL_get_cipher_name(c->ssl->connection);
  5588.     return NGX_OK;
  5589. }


  5592. ngx_int_t
  5593. ‌ngx_ssl_get_ciphers(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5594. {
  5595. #ifdef SSL_CTRL_GET_RAW_CIPHERLIST

  5597.     int                n, i, bytes;
  5598.     size_t             len;
  5599.     u_char            *ciphers, *p;
  5600.     const SSL_CIPHER  *cipher;

  5602.     bytes = SSL_get0_raw_cipherlist(c->ssl->connection, NULL);
  5603.     n = SSL_get0_raw_cipherlist(c->ssl->connection, &ciphers);

  5605.     if (n <= 0) {
  5606.         s->len = 0;
  5607.         return NGX_OK;
  5608.     }

  5610.     len = 0;
  5611.     n /= bytes;

  5613.     for (i = 0; i < n; i++) {
  5614.         cipher = SSL_CIPHER_find(c->ssl->connection, ciphers + i * bytes);

  5616.         if (cipher) {
  5617.             len += ngx_strlen(SSL_CIPHER_get_name(cipher));

  5619.         } else {
  5620.             len += sizeof("0x") - 1 + bytes * (sizeof("00") - 1);
  5621.         }

  5623.         len += sizeof(":") - 1;
  5624.     }

  5626.     s->data = ngx_pnalloc(pool, len);
  5627.     if (s->data == NULL) {
  5628.         return NGX_ERROR;
  5629.     }

  5631.     p = s->data;

  5633.     for (i = 0; i < n; i++) {
  5634.         cipher = SSL_CIPHER_find(c->ssl->connection, ciphers + i * bytes);

  5636.         if (cipher) {
  5637.             p = ngx_sprintf(p, "%s", SSL_CIPHER_get_name(cipher));

  5639.         } else {
  5640.             p = ngx_sprintf(p, "0x");
  5641.             p = ngx_hex_dump(p, ciphers + i * bytes, bytes);
  5642.         }

  5644.         *p++ = ':';
  5645.     }

  5647.     p--;

  5649.     s->len = p - s->data;

  5651. #else

  5653.     u_char  buf[4096];

  5655.     if (SSL_get_shared_ciphers(c->ssl->connection, (char *) buf, 4096)
  5656.         == NULL)
  5657.     {
  5658.         s->len = 0;
  5659.         return NGX_OK;
  5660.     }

  5662.     s->len = ngx_strlen(buf);
  5663.     s->data = ngx_pnalloc(pool, s->len);
  5664.     if (s->data == NULL) {
  5665.         return NGX_ERROR;
  5666.     }

  5668.     ngx_memcpy(s->data, buf, s->len);

  5670. #endif

  5672.     return NGX_OK;
  5673. }


  5676. ngx_int_t
  5677. ‌ngx_ssl_get_curve(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5678. {
  5679. #ifdef SSL_get_negotiated_group

  5681.     int          nid;
  5682.     const char  *name;

  5684.     nid = SSL_get_negotiated_group(c->ssl->connection);

  5686.     if (nid != NID_undef) {

  5688.         if ((nid & TLSEXT_nid_unknown) == 0) {
  5689.             s->len = ngx_strlen(OBJ_nid2sn(nid));
  5690.             s->data = (u_char *) OBJ_nid2sn(nid);
  5691.             return NGX_OK;
  5692.         }

  5694.         name = SSL_group_to_name(c->ssl->connection, nid);

  5696.         s->len = name ? ngx_strlen(name) : sizeof("0x0000") - 1;
  5697.         s->data = ngx_pnalloc(pool, s->len);
  5698.         if (s->data == NULL) {
  5699.             return NGX_ERROR;
  5700.         }

  5702.         if (name) {
  5703.             ngx_memcpy(s->data, name, s->len);

  5705.         } else {
  5706.             ngx_sprintf(s->data, "0x%04xd", nid & 0xffff);
  5707.         }

  5709.         return NGX_OK;
  5710.     }

  5712. #endif

  5714.     s->len = 0;
  5715.     return NGX_OK;
  5716. }


  5719. ngx_int_t
  5720. ‌ngx_ssl_get_curves(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5721. {
  5722. #ifdef SSL_CTRL_GET_CURVES

  5724.     int         *curves, n, i, nid;
  5725.     u_char      *p;
  5726.     size_t       len;
  5727.     const char  *name;

  5729.     n = SSL_get1_curves(c->ssl->connection, NULL);

  5731.     if (n <= 0) {
  5732.         s->len = 0;
  5733.         return NGX_OK;
  5734.     }

  5736.     curves = ngx_palloc(pool, n * sizeof(int));
  5737.     if (curves == NULL) {
  5738.         return NGX_ERROR;
  5739.     }

  5741.     n = SSL_get1_curves(c->ssl->connection, curves);
  5742.     len = 0;

  5744.     for (i = 0; i < n; i++) {
  5745.         nid = curves[i];

  5747.         if (nid & TLSEXT_nid_unknown) {
  5748.             name = SSL_group_to_name(c->ssl->connection, nid);

  5750.             len += name ? ngx_strlen(name) : sizeof("0x0000") - 1;

  5752.         } else {
  5753.             len += ngx_strlen(OBJ_nid2sn(nid));
  5754.         }

  5756.         len += sizeof(":") - 1;
  5757.     }

  5759.     s->data = ngx_pnalloc(pool, len);
  5760.     if (s->data == NULL) {
  5761.         return NGX_ERROR;
  5762.     }

  5764.     p = s->data;

  5766.     for (i = 0; i < n; i++) {
  5767.         nid = curves[i];

  5769.         if (nid & TLSEXT_nid_unknown) {
  5770.             name = SSL_group_to_name(c->ssl->connection, nid);

  5772.             p = name ? ngx_cpymem(p, name, ngx_strlen(name))
  5773.                      : ngx_sprintf(p, "0x%04xd", nid & 0xffff);

  5775.         } else {
  5776.             p = ngx_sprintf(p, "%s", OBJ_nid2sn(nid));
  5777.         }

  5779.         *p++ = ':';
  5780.     }

  5782.     p--;

  5784.     s->len = p - s->data;

  5786. #else

  5788.     s->len = 0;

  5790. #endif

  5792.     return NGX_OK;
  5793. }


  5796. ngx_int_t
  5797. ‌ngx_ssl_get_sigalg(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5798. {
  5799. #ifdef SSL_get0_signature_name

  5801.     const char  *name;

  5803.     if (SSL_get0_signature_name(c->ssl->connection, &name)) {
  5804.         s->len = ngx_strlen(name);
  5805.         s->data = ngx_pnalloc(pool, s->len);
  5806.         if (s->data == NULL) {
  5807.             return NGX_ERROR;
  5808.         }

  5810.         ngx_memcpy(s->data, name, s->len);

  5812.         return NGX_OK;
  5813.     }

  5815. #endif

  5817.     s->len = 0;
  5818.     return NGX_OK;
  5819. }


  5822. ngx_int_t
  5823. ‌ngx_ssl_get_sigalgs(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5824. {
  5825. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)

  5827.     int            n, i;
  5828.     size_t         len;
  5829.     u_char        *p;
  5830.     const char    *name;
  5831.     unsigned int   codepoint;

  5833.     n = SSL_get0_sigalg(c->ssl->connection, -1, NULL, NULL);

  5835.     if (n <= 0) {
  5836.         s->len = 0;
  5837.         return NGX_OK;
  5838.     }

  5840.     len = 0;

  5842.     for (i = 0; i < n; i++) {
  5843.         SSL_get0_sigalg(c->ssl->connection, i, &codepoint, &name);
  5844.         len += name ? ngx_strlen(name) : sizeof("0x0000") - 1;
  5845.         len += sizeof(":") - 1;
  5846.     }

  5848.     s->data = ngx_pnalloc(pool, len);
  5849.     if (s->data == NULL) {
  5850.         return NGX_ERROR;
  5851.     }

  5853.     p = s->data;

  5855.     for (i = 0; i < n; i++) {
  5856.         SSL_get0_sigalg(c->ssl->connection, i, &codepoint, &name);

  5858.         if (name) {
  5859.             p = ngx_cpymem(p, name, ngx_strlen(name));

  5861.         } else {
  5862.             p = ngx_sprintf(p, "0x%04xd", codepoint);
  5863.         }

  5865.         *p++ = ':';
  5866.     }

  5868.     p--;

  5870.     s->len = p - s->data;

  5872. #elif defined SSL_CTRL_SET_SIGALGS

  5874.     /*
  5875.      * SSL_get_sigalgs() is only available in OpenSSL 1.0.2+,
  5876.      * but uses a different naming, so emit raw codes
  5877.      */

  5879.     int             n, i;
  5880.     size_t          len;
  5881.     u_char         *p;
  5882.     unsigned char   rsig, rhash;

  5884.     n = SSL_get_sigalgs(c->ssl->connection, -1, NULL, NULL, NULL, NULL, NULL);

  5886.     if (n <= 0) {
  5887.         s->len = 0;
  5888.         return NGX_OK;
  5889.     }

  5891.     len = n * (sizeof("0x0000") - 1 + sizeof(":") - 1);

  5893.     s->data = ngx_pnalloc(pool, len);
  5894.     if (s->data == NULL) {
  5895.         return NGX_ERROR;
  5896.     }

  5898.     p = s->data;

  5900.     for (i = 0; i < n; i++) {
  5901.         SSL_get_sigalgs(c->ssl->connection, i, NULL, NULL, NULL, &rsig, &rhash);
  5902.         p = ngx_sprintf(p, "0x%04xd", rhash << 8 | rsig);
  5903.         *p++ = ':';
  5904.     }

  5906.     p--;

  5908.     s->len = p - s->data;

  5910. #else

  5912.     s->len = 0;

  5914. #endif

  5916.     return NGX_OK;
  5917. }


  5920. ngx_int_t
  5921. ‌ngx_ssl_get_session_id(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5922. {
  5923.     u_char        *buf;
  5924.     SSL_SESSION   *sess;
  5925.     unsigned int   len;

  5927.     sess = SSL_get0_session(c->ssl->connection);
  5928.     if (sess == NULL) {
  5929.         s->len = 0;
  5930.         return NGX_OK;
  5931.     }

  5933.     buf = (u_char *) SSL_SESSION_get_id(sess, &len);

  5935.     s->len = 2 * len;
  5936.     s->data = ngx_pnalloc(pool, 2 * len);
  5937.     if (s->data == NULL) {
  5938.         return NGX_ERROR;
  5939.     }

  5941.     ngx_hex_dump(s->data, buf, len);

  5943.     return NGX_OK;
  5944. }


  5947. ngx_int_t
  5948. ‌ngx_ssl_get_session_reused(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5949. {
  5950.     if (SSL_session_reused(c->ssl->connection)) {
  5951.         ngx_str_set(s, "r");

  5953.     } else {
  5954.         ngx_str_set(s, ".");
  5955.     }

  5957.     return NGX_OK;
  5958. }


  5961. ngx_int_t
  5962. ‌ngx_ssl_get_early_data(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5963. {
  5964.     s->len = 0;

  5966. #ifdef SSL_ERROR_EARLY_DATA_REJECTED

  5968.     /* BoringSSL */

  5970.     if (SSL_in_early_data(c->ssl->connection)) {
  5971.         ngx_str_set(s, "1");
  5972.     }

  5974. #elif defined SSL_READ_EARLY_DATA_SUCCESS

  5976.     /* OpenSSL */

  5978.     if (!SSL_is_init_finished(c->ssl->connection)) {
  5979.         ngx_str_set(s, "1");
  5980.     }

  5982. #endif

  5984.     return NGX_OK;
  5985. }


  5988. ngx_int_t
  5989. ‌ngx_ssl_get_server_name(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5990. {
  5991. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

  5993.     size_t       len;
  5994.     const char  *name;

  5996.     name = SSL_get_servername(c->ssl->connection, TLSEXT_NAMETYPE_host_name);

  5998.     if (name) {
  5999.         len = ngx_strlen(name);

  6001.         s->len = len;
  6002.         s->data = ngx_pnalloc(pool, len);
  6003.         if (s->data == NULL) {
  6004.             return NGX_ERROR;
  6005.         }

  6007.         ngx_memcpy(s->data, name, len);

  6009.         return NGX_OK;
  6010.     }

  6012. #endif

  6014.     s->len = 0;
  6015.     return NGX_OK;
  6016. }


  6019. ngx_int_t
  6020. ‌ngx_ssl_get_alpn_protocol(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6021. {
  6022. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  6024.     unsigned int          len;
  6025.     const unsigned char  *data;

  6027.     SSL_get0_alpn_selected(c->ssl->connection, &data, &len);

  6029.     if (len > 0) {

  6031.         s->data = ngx_pnalloc(pool, len);
  6032.         if (s->data == NULL) {
  6033.             return NGX_ERROR;
  6034.         }

  6036.         ngx_memcpy(s->data, data, len);
  6037.         s->len = len;

  6039.         return NGX_OK;
  6040.     }

  6042. #endif

  6044.     s->len = 0;
  6045.     return NGX_OK;
  6046. }


  6049. ngx_int_t
  6050. ‌ngx_ssl_get_ech_status(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6051. {
  6052. #ifdef SSL_OP_ECH_GREASE
  6053.     int    echrv;
  6054.     char  *inner_sni, *outer_sni;

  6056.     inner_sni = NULL;
  6057.     outer_sni = NULL;

  6059.     echrv = SSL_ech_get1_status(c->ssl->connection, &inner_sni, &outer_sni);

  6061.     switch (echrv) {
  6062.     case SSL_ECH_STATUS_NOT_TRIED:
  6063.         ngx_str_set(s, "NOT_TRIED");
  6064.         break;
  6065.     case SSL_ECH_STATUS_SUCCESS:
  6066.         ngx_str_set(s, "SUCCESS");
  6067.         break;
  6068.     case SSL_ECH_STATUS_GREASE:
  6069.         ngx_str_set(s, "GREASE");
  6070.         break;
  6071.     case SSL_ECH_STATUS_BACKEND:
  6072.         ngx_str_set(s, "BACKEND");
  6073.         break;
  6074.     default:
  6075.         ngx_str_set(s, "FAILED");
  6076.         break;
  6077.     }

  6079.     OPENSSL_free(inner_sni);
  6080.     OPENSSL_free(outer_sni);
  6081. #else
  6082.     s->len = 0;
  6083. #endif
  6084.     return NGX_OK;
  6085. }


  6088. ngx_int_t
  6089. ‌ngx_ssl_get_ech_outer_server_name(ngx_connection_t *c, ngx_pool_t *pool,
  6090.     ngx_str_t *s)
  6091. {
  6092. #if defined(SSL_OP_ECH_GREASE)
  6093.     int    echrv;
  6094.     char  *inner_sni, *outer_sni;

  6096.     inner_sni = NULL;
  6097.     outer_sni = NULL;

  6099.     echrv = SSL_ech_get1_status(c->ssl->connection, &inner_sni, &outer_sni);

  6101.     if (echrv == SSL_ECH_STATUS_SUCCESS && outer_sni) {
  6102.         s->len = ngx_strlen(outer_sni);

  6104.         s->data = ngx_pnalloc(pool, s->len);
  6105.         if (s->data == NULL) {
  6106.             OPENSSL_free(inner_sni);
  6107.             OPENSSL_free(outer_sni);
  6108.             return NGX_ERROR;
  6109.         }

  6111.         ngx_memcpy(s->data, outer_sni, s->len);

  6113.     } else {
  6114.         s->len = 0;
  6115.     }

  6117.     OPENSSL_free(inner_sni);
  6118.     OPENSSL_free(outer_sni);
  6119. #else
  6120.     s->len = 0;
  6121. #endif
  6122.     return NGX_OK;
  6123. }


  6126. ngx_int_t
  6127. ‌ngx_ssl_get_raw_certificate(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6128. {
  6129.     size_t   len;
  6130.     BIO     *bio;
  6131.     X509    *cert;

  6133.     s->len = 0;

  6135.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6136.     if (cert == NULL) {
  6137.         return NGX_OK;
  6138.     }

  6140.     bio = BIO_new(BIO_s_mem());
  6141.     if (bio == NULL) {
  6142.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6143.         X509_free(cert);
  6144.         return NGX_ERROR;
  6145.     }

  6147.     if (PEM_write_bio_X509(bio, cert) == 0) {
  6148.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "PEM_write_bio_X509() failed");
  6149.         goto failed;
  6150.     }

  6152.     len = BIO_pending(bio);
  6153.     s->len = len;

  6155.     s->data = ngx_pnalloc(pool, len);
  6156.     if (s->data == NULL) {
  6157.         goto failed;
  6158.     }

  6160.     BIO_read(bio, s->data, len);

  6162.     BIO_free(bio);
  6163.     X509_free(cert);

  6165.     return NGX_OK;

  6167. failed:

  6169.     BIO_free(bio);
  6170.     X509_free(cert);

  6172.     return NGX_ERROR;
  6173. }


  6176. ngx_int_t
  6177. ‌ngx_ssl_get_certificate(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6178. {
  6179.     u_char      *p;
  6180.     size_t       len;
  6181.     ngx_uint_t   i;
  6182.     ngx_str_t    cert;

  6184.     if (ngx_ssl_get_raw_certificate(c, pool, &cert) != NGX_OK) {
  6185.         return NGX_ERROR;
  6186.     }

  6188.     if (cert.len == 0) {
  6189.         s->len = 0;
  6190.         return NGX_OK;
  6191.     }

  6193.     len = cert.len - 1;

  6195.     for (i = 0; i < cert.len - 1; i++) {
  6196.         if (cert.data[i] == LF) {
  6197.             len++;
  6198.         }
  6199.     }

  6201.     s->len = len;
  6202.     s->data = ngx_pnalloc(pool, len);
  6203.     if (s->data == NULL) {
  6204.         return NGX_ERROR;
  6205.     }

  6207.     p = s->data;

  6209.     for (i = 0; i < cert.len - 1; i++) {
  6210.         *p++ = cert.data[i];
  6211.         if (cert.data[i] == LF) {
  6212.             *p++ = '\t';
  6213.         }
  6214.     }

  6216.     return NGX_OK;
  6217. }


  6220. ngx_int_t
  6221. ‌ngx_ssl_get_escaped_certificate(ngx_connection_t *c, ngx_pool_t *pool,
  6222.     ngx_str_t *s)
  6223. {
  6224.     ngx_str_t  cert;
  6225.     uintptr_t  n;

  6227.     if (ngx_ssl_get_raw_certificate(c, pool, &cert) != NGX_OK) {
  6228.         return NGX_ERROR;
  6229.     }

  6231.     if (cert.len == 0) {
  6232.         s->len = 0;
  6233.         return NGX_OK;
  6234.     }

  6236.     n = ngx_escape_uri(NULL, cert.data, cert.len, NGX_ESCAPE_URI_COMPONENT);

  6238.     s->len = cert.len + n * 2;
  6239.     s->data = ngx_pnalloc(pool, s->len);
  6240.     if (s->data == NULL) {
  6241.         return NGX_ERROR;
  6242.     }

  6244.     ngx_escape_uri(s->data, cert.data, cert.len, NGX_ESCAPE_URI_COMPONENT);

  6246.     return NGX_OK;
  6247. }


  6250. ngx_int_t
  6251. ‌ngx_ssl_get_subject_dn(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6252. {
  6253.     BIO        *bio;
  6254.     X509       *cert;
  6255. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  6256.     const
  6257. #endif
  6258.     X509_NAME  *name;

  6260.     s->len = 0;

  6262.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6263.     if (cert == NULL) {
  6264.         return NGX_OK;
  6265.     }

  6267.     name = X509_get_subject_name(cert);
  6268.     if (name == NULL) {
  6269.         X509_free(cert);
  6270.         return NGX_ERROR;
  6271.     }

  6273.     bio = BIO_new(BIO_s_mem());
  6274.     if (bio == NULL) {
  6275.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6276.         X509_free(cert);
  6277.         return NGX_ERROR;
  6278.     }

  6280.     if (X509_NAME_print_ex(bio, name, 0, XN_FLAG_RFC2253) < 0) {
  6281.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_print_ex() failed");
  6282.         goto failed;
  6283.     }

  6285.     s->len = BIO_pending(bio);
  6286.     s->data = ngx_pnalloc(pool, s->len);
  6287.     if (s->data == NULL) {
  6288.         goto failed;
  6289.     }

  6291.     BIO_read(bio, s->data, s->len);

  6293.     BIO_free(bio);
  6294.     X509_free(cert);

  6296.     return NGX_OK;

  6298. failed:

  6300.     BIO_free(bio);
  6301.     X509_free(cert);

  6303.     return NGX_ERROR;
  6304. }


  6307. ngx_int_t
  6308. ‌ngx_ssl_get_issuer_dn(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6309. {
  6310.     BIO        *bio;
  6311.     X509       *cert;
  6312. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  6313.     const
  6314. #endif
  6315.     X509_NAME  *name;

  6317.     s->len = 0;

  6319.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6320.     if (cert == NULL) {
  6321.         return NGX_OK;
  6322.     }

  6324.     name = X509_get_issuer_name(cert);
  6325.     if (name == NULL) {
  6326.         X509_free(cert);
  6327.         return NGX_ERROR;
  6328.     }

  6330.     bio = BIO_new(BIO_s_mem());
  6331.     if (bio == NULL) {
  6332.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6333.         X509_free(cert);
  6334.         return NGX_ERROR;
  6335.     }

  6337.     if (X509_NAME_print_ex(bio, name, 0, XN_FLAG_RFC2253) < 0) {
  6338.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_print_ex() failed");
  6339.         goto failed;
  6340.     }

  6342.     s->len = BIO_pending(bio);
  6343.     s->data = ngx_pnalloc(pool, s->len);
  6344.     if (s->data == NULL) {
  6345.         goto failed;
  6346.     }

  6348.     BIO_read(bio, s->data, s->len);

  6350.     BIO_free(bio);
  6351.     X509_free(cert);

  6353.     return NGX_OK;

  6355. failed:

  6357.     BIO_free(bio);
  6358.     X509_free(cert);

  6360.     return NGX_ERROR;
  6361. }


  6364. ngx_int_t
  6365. ‌ngx_ssl_get_subject_dn_legacy(ngx_connection_t *c, ngx_pool_t *pool,
  6366.     ngx_str_t *s)
  6367. {
  6368.     char       *p;
  6369.     size_t      len;
  6370.     X509       *cert;
  6371. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  6372.     const
  6373. #endif
  6374.     X509_NAME  *name;

  6376.     s->len = 0;

  6378.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6379.     if (cert == NULL) {
  6380.         return NGX_OK;
  6381.     }

  6383.     name = X509_get_subject_name(cert);
  6384.     if (name == NULL) {
  6385.         X509_free(cert);
  6386.         return NGX_ERROR;
  6387.     }

  6389.     p = X509_NAME_oneline(name, NULL, 0);
  6390.     if (p == NULL) {
  6391.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_oneline() failed");
  6392.         X509_free(cert);
  6393.         return NGX_ERROR;
  6394.     }

  6396.     for (len = 0; p[len]; len++) { /* void */ }

  6398.     s->len = len;
  6399.     s->data = ngx_pnalloc(pool, len);
  6400.     if (s->data == NULL) {
  6401.         OPENSSL_free(p);
  6402.         X509_free(cert);
  6403.         return NGX_ERROR;
  6404.     }

  6406.     ngx_memcpy(s->data, p, len);

  6408.     OPENSSL_free(p);
  6409.     X509_free(cert);

  6411.     return NGX_OK;
  6412. }


  6415. ngx_int_t
  6416. ‌ngx_ssl_get_issuer_dn_legacy(ngx_connection_t *c, ngx_pool_t *pool,
  6417.     ngx_str_t *s)
  6418. {
  6419.     char       *p;
  6420.     size_t      len;
  6421.     X509       *cert;
  6422. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  6423.     const
  6424. #endif
  6425.     X509_NAME  *name;

  6427.     s->len = 0;

  6429.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6430.     if (cert == NULL) {
  6431.         return NGX_OK;
  6432.     }

  6434.     name = X509_get_issuer_name(cert);
  6435.     if (name == NULL) {
  6436.         X509_free(cert);
  6437.         return NGX_ERROR;
  6438.     }

  6440.     p = X509_NAME_oneline(name, NULL, 0);
  6441.     if (p == NULL) {
  6442.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_oneline() failed");
  6443.         X509_free(cert);
  6444.         return NGX_ERROR;
  6445.     }

  6447.     for (len = 0; p[len]; len++) { /* void */ }

  6449.     s->len = len;
  6450.     s->data = ngx_pnalloc(pool, len);
  6451.     if (s->data == NULL) {
  6452.         OPENSSL_free(p);
  6453.         X509_free(cert);
  6454.         return NGX_ERROR;
  6455.     }

  6457.     ngx_memcpy(s->data, p, len);

  6459.     OPENSSL_free(p);
  6460.     X509_free(cert);

  6462.     return NGX_OK;
  6463. }


  6466. ngx_int_t
  6467. ‌ngx_ssl_get_serial_number(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6468. {
  6469.     size_t   len;
  6470.     X509    *cert;
  6471.     BIO     *bio;

  6473.     s->len = 0;

  6475.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6476.     if (cert == NULL) {
  6477.         return NGX_OK;
  6478.     }

  6480.     bio = BIO_new(BIO_s_mem());
  6481.     if (bio == NULL) {
  6482.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6483.         X509_free(cert);
  6484.         return NGX_ERROR;
  6485.     }

  6487.     i2a_ASN1_INTEGER(bio, X509_get_serialNumber(cert));
  6488.     len = BIO_pending(bio);

  6490.     s->len = len;
  6491.     s->data = ngx_pnalloc(pool, len);
  6492.     if (s->data == NULL) {
  6493.         BIO_free(bio);
  6494.         X509_free(cert);
  6495.         return NGX_ERROR;
  6496.     }

  6498.     BIO_read(bio, s->data, len);
  6499.     BIO_free(bio);
  6500.     X509_free(cert);

  6502.     return NGX_OK;
  6503. }


  6506. ngx_int_t
  6507. ‌ngx_ssl_get_fingerprint(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6508. {
  6509.     X509          *cert;
  6510.     unsigned int   len;
  6511.     u_char         buf[EVP_MAX_MD_SIZE];

  6513.     s->len = 0;

  6515.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6516.     if (cert == NULL) {
  6517.         return NGX_OK;
  6518.     }

  6520.     if (!X509_digest(cert, EVP_sha1(), buf, &len)) {
  6521.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_digest() failed");
  6522.         X509_free(cert);
  6523.         return NGX_ERROR;
  6524.     }

  6526.     s->len = 2 * len;
  6527.     s->data = ngx_pnalloc(pool, 2 * len);
  6528.     if (s->data == NULL) {
  6529.         X509_free(cert);
  6530.         return NGX_ERROR;
  6531.     }

  6533.     ngx_hex_dump(s->data, buf, len);

  6535.     X509_free(cert);

  6537.     return NGX_OK;
  6538. }


  6541. ngx_int_t
  6542. ‌ngx_ssl_get_client_verify(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6543. {
  6544.     X509        *cert;
  6545.     long         rc;
  6546.     const char  *str;

  6548.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6549.     if (cert == NULL) {
  6550.         ngx_str_set(s, "NONE");
  6551.         return NGX_OK;
  6552.     }

  6554.     X509_free(cert);

  6556.     rc = SSL_get_verify_result(c->ssl->connection);

  6558.     if (rc == X509_V_OK) {
  6559.         if (ngx_ssl_ocsp_get_status(c, &str) == NGX_OK) {
  6560.             ngx_str_set(s, "SUCCESS");
  6561.             return NGX_OK;
  6562.         }

  6564.     } else {
  6565.         str = X509_verify_cert_error_string(rc);
  6566.     }

  6568.     s->data = ngx_pnalloc(pool, sizeof("FAILED:") - 1 + ngx_strlen(str));
  6569.     if (s->data == NULL) {
  6570.         return NGX_ERROR;
  6571.     }

  6573.     s->len = ngx_sprintf(s->data, "FAILED:%s", str) - s->data;

  6575.     return NGX_OK;
  6576. }


  6579. ngx_int_t
  6580. ‌ngx_ssl_get_client_v_start(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6581. {
  6582.     BIO     *bio;
  6583.     X509    *cert;
  6584.     size_t   len;

  6586.     s->len = 0;

  6588.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6589.     if (cert == NULL) {
  6590.         return NGX_OK;
  6591.     }

  6593.     bio = BIO_new(BIO_s_mem());
  6594.     if (bio == NULL) {
  6595.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6596.         X509_free(cert);
  6597.         return NGX_ERROR;
  6598.     }

  6600. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  6601.     ASN1_TIME_print(bio, X509_get0_notBefore(cert));
  6602. #else
  6603.     ASN1_TIME_print(bio, X509_get_notBefore(cert));
  6604. #endif

  6606.     len = BIO_pending(bio);

  6608.     s->len = len;
  6609.     s->data = ngx_pnalloc(pool, len);
  6610.     if (s->data == NULL) {
  6611.         BIO_free(bio);
  6612.         X509_free(cert);
  6613.         return NGX_ERROR;
  6614.     }

  6616.     BIO_read(bio, s->data, len);
  6617.     BIO_free(bio);
  6618.     X509_free(cert);

  6620.     return NGX_OK;
  6621. }


  6624. ngx_int_t
  6625. ‌ngx_ssl_get_client_v_end(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6626. {
  6627.     BIO     *bio;
  6628.     X509    *cert;
  6629.     size_t   len;

  6631.     s->len = 0;

  6633.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6634.     if (cert == NULL) {
  6635.         return NGX_OK;
  6636.     }

  6638.     bio = BIO_new(BIO_s_mem());
  6639.     if (bio == NULL) {
  6640.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6641.         X509_free(cert);
  6642.         return NGX_ERROR;
  6643.     }

  6645. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  6646.     ASN1_TIME_print(bio, X509_get0_notAfter(cert));
  6647. #else
  6648.     ASN1_TIME_print(bio, X509_get_notAfter(cert));
  6649. #endif

  6651.     len = BIO_pending(bio);

  6653.     s->len = len;
  6654.     s->data = ngx_pnalloc(pool, len);
  6655.     if (s->data == NULL) {
  6656.         BIO_free(bio);
  6657.         X509_free(cert);
  6658.         return NGX_ERROR;
  6659.     }

  6661.     BIO_read(bio, s->data, len);
  6662.     BIO_free(bio);
  6663.     X509_free(cert);

  6665.     return NGX_OK;
  6666. }


  6669. ngx_int_t
  6670. ‌ngx_ssl_get_client_v_remain(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6671. {
  6672.     X509    *cert;
  6673.     time_t   now, end;

  6675.     s->len = 0;

  6677.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6678.     if (cert == NULL) {
  6679.         return NGX_OK;
  6680.     }

  6682. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  6683.     end = ngx_ssl_parse_time(X509_get0_notAfter(cert), c->log);
  6684. #else
  6685.     end = ngx_ssl_parse_time(X509_get_notAfter(cert), c->log);
  6686. #endif

  6688.     if (end == (time_t) NGX_ERROR) {
  6689.         X509_free(cert);
  6690.         return NGX_OK;
  6691.     }

  6693.     now = ngx_time();

  6695.     if (end < now + 86400) {
  6696.         ngx_str_set(s, "0");
  6697.         X509_free(cert);
  6698.         return NGX_OK;
  6699.     }

  6701.     s->data = ngx_pnalloc(pool, NGX_TIME_T_LEN);
  6702.     if (s->data == NULL) {
  6703.         X509_free(cert);
  6704.         return NGX_ERROR;
  6705.     }

  6707.     s->len = ngx_sprintf(s->data, "%T", (end - now) / 86400) - s->data;

  6709.     X509_free(cert);

  6711.     return NGX_OK;
  6712. }


  6715. static time_t
  6716. ‌ngx_ssl_parse_time(
  6717. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  6718.     const
  6719. #endif
  6720.     ASN1_TIME *asn1time, ngx_log_t *log)
  6721. {
  6722.     BIO     *bio;
  6723.     char    *value;
  6724.     size_t   len;
  6725.     time_t   time;

  6727.     /*
  6728.      * OpenSSL doesn't provide a way to convert ASN1_TIME
  6729.      * into time_t.  To do this, we use ASN1_TIME_print(),
  6730.      * which uses the "MMM DD HH:MM:SS YYYY [GMT]" format (e.g.,
  6731.      * "Feb  3 00:55:52 2015 GMT"), and parse the result.
  6732.      */

  6734.     bio = BIO_new(BIO_s_mem());
  6735.     if (bio == NULL) {
  6736.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "BIO_new() failed");
  6737.         return NGX_ERROR;
  6738.     }

  6740.     /* fake weekday prepended to match C asctime() format */

  6742.     BIO_write(bio, "Tue ", sizeof("Tue ") - 1);
  6743.     ASN1_TIME_print(bio, asn1time);
  6744.     len = BIO_get_mem_data(bio, &value);

  6746.     time = ngx_parse_http_time((u_char *) value, len);

  6748.     BIO_free(bio);

  6750.     return time;
  6751. }


  6754. ngx_int_t
  6755. ‌ngx_ssl_get_client_sigalg(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6756. {
  6757. #ifdef SSL_get0_peer_signature_name

  6759.     const char  *name;

  6761.     if (SSL_get0_peer_signature_name(c->ssl->connection, &name)) {
  6762.         s->len = ngx_strlen(name);
  6763.         s->data = ngx_pnalloc(pool, s->len);
  6764.         if (s->data == NULL) {
  6765.             return NGX_ERROR;
  6766.         }

  6768.         ngx_memcpy(s->data, name, s->len);

  6770.         return NGX_OK;
  6771.     }

  6773. #endif

  6775.     s->len = 0;
  6776.     return NGX_OK;
  6777. }


  6780. static void *
  6781. ‌ngx_openssl_create_conf(ngx_cycle_t *cycle)
  6782. {
  6783.     ngx_openssl_conf_t  *oscf;

  6785.     oscf = ngx_pcalloc(cycle->pool, sizeof(ngx_openssl_conf_t));
  6786.     if (oscf == NULL) {
  6787.         return NULL;
  6788.     }

  6790.     /*
  6791.      * set by ngx_pcalloc():
  6792.      *
  6793.      *     oscf->engine = 0;
  6794.      */

  6796.     return oscf;
  6797. }


  6800. static char *
  6801. ‌ngx_openssl_engine(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  6802. {
  6803. #ifndef OPENSSL_NO_ENGINE

  6805.     ngx_openssl_conf_t *oscf = conf;

  6807.     ENGINE     *engine;
  6808.     ngx_str_t  *value;

  6810.     if (oscf->engine) {
  6811.         return "is duplicate";
  6812.     }

  6814.     oscf->engine = 1;

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

  6818.     engine = ENGINE_by_id((char *) value[1].data);

  6820.     if (engine == NULL) {
  6821.         ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
  6822.                       "ENGINE_by_id(\"%V\") failed", &value[1]);
  6823.         return NGX_CONF_ERROR;
  6824.     }

  6826.     if (ENGINE_set_default(engine, ENGINE_METHOD_ALL) == 0) {
  6827.         ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
  6828.                       "ENGINE_set_default(\"%V\", ENGINE_METHOD_ALL) failed",
  6829.                       &value[1]);

  6831.         ENGINE_free(engine);

  6833.         return NGX_CONF_ERROR;
  6834.     }

  6836.     ENGINE_free(engine);

  6838.     return NGX_CONF_OK;

  6840. #else

  6842.     return "is not supported";

  6844. #endif
  6845. }


  6848. static void
  6849. ‌ngx_openssl_exit(ngx_cycle_t *cycle)
  6850. {
  6851. #if OPENSSL_VERSION_NUMBER < 0x10100003L

  6853.     EVP_cleanup();
  6854. #ifndef OPENSSL_NO_ENGINE
  6855.     ENGINE_cleanup();
  6856. #endif

  6858. #endif
  6859. }

One Level Up Top Level