One Level Up Top Level

src/event/ngx_event_openssl.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

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 (defined BIO_get_ktls_recv && NGX_LINUX)

  3816.     /*
  3817.      * with kernel TLS, recv() fails with EIO on a record
  3818.      * other than application data, such as "close notify"
  3819.      */

  3821.     if (BIO_get_ktls_recv(SSL_get_rbio(c->ssl->connection)) == 1) {
  3822.         c->ktls_recv = 1;
  3823.     }

  3825. #endif

  3827.     if (c->ssl->shutdown_without_free) {
  3828.         c->ssl->shutdown_without_free = 0;
  3829.         c->recv = ngx_recv;
  3830.         return rc;
  3831.     }

  3833.     SSL_free(c->ssl->connection);
  3834.     c->ssl = NULL;
  3835.     c->recv = ngx_recv;

  3837.     return rc;
  3838. }


  3841. static void
  3842. ‌ngx_ssl_shutdown_handler(ngx_event_t *ev)
  3843. {
  3844.     ngx_connection_t           *c;
  3845.     ngx_connection_handler_pt   handler;

  3847.     c = ev->data;
  3848.     handler = c->ssl->handler;

  3850.     if (ev->timedout) {
  3851.         c->timedout = 1;
  3852.     }

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

  3856.     if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
  3857.         return;
  3858.     }

  3860.     handler(c);
  3861. }


  3864. void
  3865. ‌ngx_ssl_connection_error(ngx_connection_t *c, int sslerr, ngx_err_t err,
  3866.     char *text)
  3867. {
  3868.     int         n;
  3869.     ngx_uint_t  level;

  3871.     level = NGX_LOG_CRIT;

  3873.     if (sslerr == SSL_ERROR_SYSCALL) {

  3875.         if (err == NGX_ECONNRESET
  3876. #if (NGX_WIN32)
  3877.             || err == NGX_ECONNABORTED
  3878. #endif
  3879.             || err == NGX_EPIPE
  3880.             || err == NGX_ENOTCONN
  3881.             || err == NGX_ETIMEDOUT
  3882.             || err == NGX_ECONNREFUSED
  3883.             || err == NGX_ENETDOWN
  3884.             || err == NGX_ENETUNREACH
  3885.             || err == NGX_EHOSTDOWN
  3886.             || err == NGX_EHOSTUNREACH)
  3887.         {
  3888.             switch (c->log_error) {

  3890.             case NGX_ERROR_IGNORE_ECONNRESET:
  3891.             case NGX_ERROR_INFO:
  3892.                 level = NGX_LOG_INFO;
  3893.                 break;

  3895.             case NGX_ERROR_ERR:
  3896.                 level = NGX_LOG_ERR;
  3897.                 break;

  3899.             default:
  3900.                 break;
  3901.             }
  3902.         }

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

  3906.         n = ERR_GET_REASON(ERR_peek_last_error());

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

  4079.             case NGX_ERROR_IGNORE_ECONNRESET:
  4080.             case NGX_ERROR_INFO:
  4081.                 level = NGX_LOG_INFO;
  4082.                 break;

  4084.             case NGX_ERROR_ERR:
  4085.                 level = NGX_LOG_ERR;
  4086.                 break;

  4088.             default:
  4089.                 break;
  4090.             }
  4091.         }
  4092.     }

  4094.     ngx_ssl_error(level, c->log, err, text);
  4095. }


  4098. static void
  4099. ‌ngx_ssl_clear_error(ngx_log_t *log)
  4100. {
  4101.     while (ERR_peek_error()) {
  4102.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "ignoring stale global SSL error");
  4103.     }

  4105.     ERR_clear_error();
  4106. }


  4109. void ngx_cdecl
  4110. ‌ngx_ssl_error(ngx_uint_t level, ngx_log_t *log, ngx_err_t err, char *fmt, ...)
  4111. {
  4112.     int          flags;
  4113.     u_long       n;
  4114.     va_list      args;
  4115.     u_char      *p, *last;
  4116.     u_char       errstr[NGX_MAX_CONF_ERRSTR];
  4117.     const char  *data;

  4119.     last = errstr + NGX_MAX_CONF_ERRSTR;

  4121.     va_start(args, fmt);
  4122.     p = ngx_vslprintf(errstr, last - 1, fmt, args);
  4123.     va_end(args);

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

  4128.         for ( ;; ) {

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

  4132.             if (n == 0) {
  4133.                 break;
  4134.             }

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

  4138.             if (p >= last - 1) {
  4139.                 goto next;
  4140.             }

  4142.             *p++ = ' ';

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

  4146.             while (p < last && *p) {
  4147.                 p++;
  4148.             }

  4150.             if (p < last && *data && (flags & ERR_TXT_STRING)) {
  4151.                 *p++ = ':';
  4152.                 p = ngx_cpystrn(p, (u_char *) data, last - p);
  4153.             }

  4155.         next:

  4157.             (void) ERR_get_error();
  4158.         }

  4160.         if (p < last) {
  4161.             *p++ = ')';
  4162.         }
  4163.     }

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


  4169. ngx_int_t
  4170. ‌ngx_ssl_session_cache(ngx_ssl_t *ssl, ngx_str_t *sess_ctx,
  4171.     ngx_array_t *certificates, ssize_t builtin_session_cache,
  4172.     ngx_shm_zone_t *shm_zone, time_t timeout)
  4173. {
  4174.     long  cache_mode;

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

  4178.     if (ngx_ssl_session_id_context(ssl, sess_ctx, certificates) != NGX_OK) {
  4179.         return NGX_ERROR;
  4180.     }

  4182.     if (builtin_session_cache == NGX_SSL_NO_SCACHE) {
  4183.         SSL_CTX_set_session_cache_mode(ssl->ctx, SSL_SESS_CACHE_OFF);
  4184.         return NGX_OK;
  4185.     }

  4187.     if (builtin_session_cache == NGX_SSL_NONE_SCACHE) {

  4189.         /*
  4190.          * If the server explicitly says that it does not support
  4191.          * session reuse (see SSL_SESS_CACHE_OFF above), then
  4192.          * Outlook Express fails to upload a sent email to
  4193.          * the Sent Items folder on the IMAP server via a separate IMAP
  4194.          * connection in the background.  Therefore we have a special
  4195.          * mode (SSL_SESS_CACHE_SERVER|SSL_SESS_CACHE_NO_INTERNAL_STORE)
  4196.          * where the server pretends that it supports session reuse,
  4197.          * but it does not actually store any session.
  4198.          */

  4200.         SSL_CTX_set_session_cache_mode(ssl->ctx,
  4201.                                        SSL_SESS_CACHE_SERVER
  4202.                                        |SSL_SESS_CACHE_NO_AUTO_CLEAR
  4203.                                        |SSL_SESS_CACHE_NO_INTERNAL_STORE);

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

  4207.         return NGX_OK;
  4208.     }

  4210.     cache_mode = SSL_SESS_CACHE_SERVER;

  4212.     if (shm_zone && builtin_session_cache == NGX_SSL_NO_BUILTIN_SCACHE) {
  4213.         cache_mode |= SSL_SESS_CACHE_NO_INTERNAL;
  4214.     }

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

  4218.     if (builtin_session_cache != NGX_SSL_NO_BUILTIN_SCACHE) {

  4220.         if (builtin_session_cache != NGX_SSL_DFLT_BUILTIN_SCACHE) {
  4221.             SSL_CTX_sess_set_cache_size(ssl->ctx, builtin_session_cache);
  4222.         }
  4223.     }

  4225.     if (shm_zone) {
  4226.         SSL_CTX_sess_set_new_cb(ssl->ctx, ngx_ssl_new_session);
  4227.         SSL_CTX_sess_set_get_cb(ssl->ctx, ngx_ssl_get_cached_session);
  4228.         SSL_CTX_sess_set_remove_cb(ssl->ctx, ngx_ssl_remove_session);

  4230.         if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_session_cache_index, shm_zone)
  4231.             == 0)
  4232.         {
  4233.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4234.                           "SSL_CTX_set_ex_data() failed");
  4235.             return NGX_ERROR;
  4236.         }
  4237.     }

  4239.     return NGX_OK;
  4240. }


  4243. static ngx_int_t
  4244. ‌ngx_ssl_session_id_context(ngx_ssl_t *ssl, ngx_str_t *sess_ctx,
  4245.     ngx_array_t *certificates)
  4246. {
  4247.     int                   n, i;
  4248.     X509                 *cert;
  4249.     X509_NAME            *name;
  4250.     ngx_str_t            *certs;
  4251.     ngx_uint_t            k;
  4252.     EVP_MD_CTX           *md;
  4253.     unsigned int          len;
  4254.     STACK_OF(X509_NAME)  *list;
  4255.     u_char                buf[EVP_MAX_MD_SIZE];

  4257.     /*
  4258.      * Session ID context is set based on the string provided,
  4259.      * the server certificates, and the client CA list.
  4260.      */

  4262.     md = EVP_MD_CTX_create();
  4263.     if (md == NULL) {
  4264.         return NGX_ERROR;
  4265.     }

  4267.     if (EVP_DigestInit_ex(md, EVP_sha1(), NULL) == 0) {
  4268.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4269.                       "EVP_DigestInit_ex() failed");
  4270.         goto failed;
  4271.     }

  4273.     if (EVP_DigestUpdate(md, sess_ctx->data, sess_ctx->len) == 0) {
  4274.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4275.                       "EVP_DigestUpdate() failed");
  4276.         goto failed;
  4277.     }

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

  4282.         if (X509_digest(cert, EVP_sha1(), buf, &len) == 0) {
  4283.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4284.                           "X509_digest() failed");
  4285.             goto failed;
  4286.         }

  4288.         if (EVP_DigestUpdate(md, buf, len) == 0) {
  4289.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4290.                           "EVP_DigestUpdate() failed");
  4291.             goto failed;
  4292.         }
  4293.     }

  4295.     if (ssl->certs.nelts == 0 && certificates != NULL) {
  4296.         /*
  4297.          * If certificates are loaded dynamically, we use certificate
  4298.          * names as specified in the configuration (with variables).
  4299.          */

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

  4304.             if (EVP_DigestUpdate(md, certs[k].data, certs[k].len) == 0) {
  4305.                 ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4306.                               "EVP_DigestUpdate() failed");
  4307.                 goto failed;
  4308.             }
  4309.         }
  4310.     }

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

  4314.     if (list != NULL) {
  4315.         n = sk_X509_NAME_num(list);

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

  4320.             if (X509_NAME_digest(name, EVP_sha1(), buf, &len) == 0) {
  4321.                 ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4322.                               "X509_NAME_digest() failed");
  4323.                 goto failed;
  4324.             }

  4326.             if (EVP_DigestUpdate(md, buf, len) == 0) {
  4327.                 ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4328.                               "EVP_DigestUpdate() failed");
  4329.                 goto failed;
  4330.             }
  4331.         }
  4332.     }

  4334.     if (EVP_DigestFinal_ex(md, buf, &len) == 0) {
  4335.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4336.                       "EVP_DigestFinal_ex() failed");
  4337.         goto failed;
  4338.     }

  4340.     EVP_MD_CTX_destroy(md);

  4342.     if (SSL_CTX_set_session_id_context(ssl->ctx, buf, len) == 0) {
  4343.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4344.                       "SSL_CTX_set_session_id_context() failed");
  4345.         return NGX_ERROR;
  4346.     }

  4348.     return NGX_OK;

  4350. failed:

  4352.     EVP_MD_CTX_destroy(md);

  4354.     return NGX_ERROR;
  4355. }


  4358. ngx_int_t
  4359. ‌ngx_ssl_session_cache_init(ngx_shm_zone_t *shm_zone, void *data)
  4360. {
  4361.     size_t                    len;
  4362.     ngx_slab_pool_t          *shpool;
  4363.     ngx_ssl_session_cache_t  *cache;

  4365.     if (data) {
  4366.         shm_zone->data = data;
  4367.         return NGX_OK;
  4368.     }

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

  4372.     if (shm_zone->shm.exists) {
  4373.         shm_zone->data = shpool->data;
  4374.         return NGX_OK;
  4375.     }

  4377.     cache = ngx_slab_alloc(shpool, sizeof(ngx_ssl_session_cache_t));
  4378.     if (cache == NULL) {
  4379.         return NGX_ERROR;
  4380.     }

  4382.     shpool->data = cache;
  4383.     shm_zone->data = cache;

  4385.     ngx_rbtree_init(&cache->session_rbtree, &cache->sentinel,
  4386.                     ngx_ssl_session_rbtree_insert_value);

  4388.     ngx_queue_init(&cache->expire_queue);

  4390.     cache->ticket_keys[0].expire = 0;
  4391.     cache->ticket_keys[1].expire = 0;
  4392.     cache->ticket_keys[2].expire = 0;

  4394.     cache->fail_time = 0;

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

  4398.     shpool->log_ctx = ngx_slab_alloc(shpool, len);
  4399.     if (shpool->log_ctx == NULL) {
  4400.         return NGX_ERROR;
  4401.     }

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

  4406.     shpool->log_nomem = 0;

  4408.     return NGX_OK;
  4409. }


  4412. /*
  4413. * The length of the session id is 16 bytes for SSLv2 sessions and
  4414. * between 1 and 32 bytes for SSLv3 and TLS, typically 32 bytes.
  4415. * Typical length of the external ASN1 representation of a session
  4416. * is about 150 bytes plus SNI server name.
  4417. *
  4418. * On 32-bit platforms we allocate an rbtree node, a session id, and
  4419. * an ASN1 representation in a single allocation, it typically takes
  4420. * 256 bytes.
  4421. *
  4422. * On 64-bit platforms we allocate separately an rbtree node + session_id,
  4423. * and an ASN1 representation, they take accordingly 128 and 256 bytes.
  4424. *
  4425. * OpenSSL's i2d_SSL_SESSION() and d2i_SSL_SESSION are slow,
  4426. * so they are outside the code locked by shared pool mutex
  4427. */

  4429. static int
  4430. ‌ngx_ssl_new_session(ngx_ssl_conn_t *ssl_conn, ngx_ssl_session_t *sess)
  4431. {
  4432.     int                       len;
  4433.     u_char                   *p, *session_id;
  4434.     size_t                    n;
  4435.     uint32_t                  hash;
  4436.     SSL_CTX                  *ssl_ctx;
  4437.     unsigned int              session_id_length;
  4438.     ngx_shm_zone_t           *shm_zone;
  4439.     ngx_connection_t         *c;
  4440.     ngx_slab_pool_t          *shpool;
  4441.     ngx_ssl_sess_id_t        *sess_id;
  4442.     ngx_ssl_session_cache_t  *cache;

  4444. #ifdef TLS1_3_VERSION

  4446.     /*
  4447.      * OpenSSL tries to save TLSv1.3 sessions into session cache
  4448.      * even when using tickets for stateless session resumption,
  4449.      * "because some applications just want to know about the creation
  4450.      * of a session"; do not cache such sessions
  4451.      */

  4453.     if (SSL_version(ssl_conn) == TLS1_3_VERSION
  4454.         && (SSL_get_options(ssl_conn) & SSL_OP_NO_TICKET) == 0)
  4455.     {
  4456.         return 0;
  4457.     }

  4459. #endif

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

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

  4465.     if (session_id_length > 32) {
  4466.         return 0;
  4467.     }

  4469.     len = i2d_SSL_SESSION(sess, NULL);

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

  4473.     if (len <= 0 || len > NGX_SSL_MAX_SESSION_SIZE) {
  4474.         return 0;
  4475.     }

  4477.     p = ngx_ssl_session_buffer;
  4478.     i2d_SSL_SESSION(sess, &p);

  4480.     c = ngx_ssl_get_connection(ssl_conn);

  4482.     ssl_ctx = c->ssl->session_ctx;
  4483.     shm_zone = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_session_cache_index);

  4485.     cache = shm_zone->data;
  4486.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

  4488.     ngx_shmtx_lock(&shpool->mutex);

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

  4493. #if (NGX_PTR_SIZE == 8)
  4494.     n = sizeof(ngx_ssl_sess_id_t);
  4495. #else
  4496.     n = offsetof(ngx_ssl_sess_id_t, session) + len;
  4497. #endif

  4499.     sess_id = ngx_slab_alloc_locked(shpool, n);

  4501.     if (sess_id == NULL) {

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

  4505.         ngx_ssl_expire_sessions(cache, shpool, 0);

  4507.         sess_id = ngx_slab_alloc_locked(shpool, n);

  4509.         if (sess_id == NULL) {
  4510.             goto failed;
  4511.         }
  4512.     }

  4514. #if (NGX_PTR_SIZE == 8)

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

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

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

  4522.         ngx_ssl_expire_sessions(cache, shpool, 0);

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

  4526.         if (sess_id->session == NULL) {
  4527.             goto failed;
  4528.         }
  4529.     }

  4531. #endif

  4533.     ngx_memcpy(sess_id->session, ngx_ssl_session_buffer, len);
  4534.     ngx_memcpy(sess_id->id, session_id, session_id_length);

  4536.     hash = ngx_crc32_short(session_id, session_id_length);

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

  4542.     sess_id->node.key = hash;
  4543.     sess_id->node.data = (u_char) session_id_length;
  4544.     sess_id->len = len;

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

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

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

  4552.     ngx_shmtx_unlock(&shpool->mutex);

  4554.     ngx_explicit_memzero(ngx_ssl_session_buffer, len);

  4556.     return 0;

  4558. failed:

  4560.     if (sess_id) {
  4561.         ngx_slab_free_locked(shpool, sess_id);
  4562.     }

  4564.     ngx_shmtx_unlock(&shpool->mutex);

  4566.     ngx_explicit_memzero(ngx_ssl_session_buffer, len);

  4568.     if (cache->fail_time != ngx_time()) {
  4569.         cache->fail_time = ngx_time();
  4570.         ngx_log_error(NGX_LOG_WARN, c->log, 0,
  4571.                       "could not allocate new session%s", shpool->log_ctx);
  4572.     }

  4574.     return 0;
  4575. }


  4578. static ngx_ssl_session_t *
  4579. ‌ngx_ssl_get_cached_session(ngx_ssl_conn_t *ssl_conn,
  4580. #if OPENSSL_VERSION_NUMBER >= 0x10100003L
  4581.     const
  4582. #endif
  4583.     u_char *id, int len, int *copy)
  4584. {
  4585.     size_t                    slen;
  4586.     uint32_t                  hash;
  4587.     ngx_int_t                 rc;
  4588.     const u_char             *p;
  4589.     ngx_shm_zone_t           *shm_zone;
  4590.     ngx_slab_pool_t          *shpool;
  4591.     ngx_connection_t         *c;
  4592.     ngx_rbtree_node_t        *node, *sentinel;
  4593.     ngx_ssl_session_t        *sess;
  4594.     ngx_ssl_sess_id_t        *sess_id;
  4595.     ngx_ssl_session_cache_t  *cache;

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

  4600.     c = ngx_ssl_get_connection(ssl_conn);

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

  4605.     shm_zone = SSL_CTX_get_ex_data(c->ssl->session_ctx,
  4606.                                    ngx_ssl_session_cache_index);

  4608.     cache = shm_zone->data;

  4610.     sess = NULL;

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

  4614.     ngx_shmtx_lock(&shpool->mutex);

  4616.     node = cache->session_rbtree.root;
  4617.     sentinel = cache->session_rbtree.sentinel;

  4619.     while (node != sentinel) {

  4621.         if (hash < node->key) {
  4622.             node = node->left;
  4623.             continue;
  4624.         }

  4626.         if (hash > node->key) {
  4627.             node = node->right;
  4628.             continue;
  4629.         }

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

  4633.         sess_id = (ngx_ssl_sess_id_t *) node;

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

  4638.         if (rc == 0) {

  4640.             if (sess_id->expire > ngx_time()) {
  4641.                 slen = sess_id->len;

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

  4645.                 ngx_shmtx_unlock(&shpool->mutex);

  4647.                 p = ngx_ssl_session_buffer;
  4648.                 sess = d2i_SSL_SESSION(NULL, &p, slen);

  4650.                 ngx_explicit_memzero(ngx_ssl_session_buffer, slen);

  4652.                 return sess;
  4653.             }

  4655.             ngx_queue_remove(&sess_id->queue);

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

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

  4661. #if (NGX_PTR_SIZE == 8)
  4662.             ngx_slab_free_locked(shpool, sess_id->session);
  4663. #endif
  4664.             ngx_slab_free_locked(shpool, sess_id);

  4666.             sess = NULL;

  4668.             goto done;
  4669.         }

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

  4674. done:

  4676.     ngx_shmtx_unlock(&shpool->mutex);

  4678.     return sess;
  4679. }


  4682. void
  4683. ‌ngx_ssl_remove_cached_session(SSL_CTX *ssl, ngx_ssl_session_t *sess)
  4684. {
  4685.     SSL_CTX_remove_session(ssl, sess);

  4687.     ngx_ssl_remove_session(ssl, sess);
  4688. }


  4691. static void
  4692. ‌ngx_ssl_remove_session(SSL_CTX *ssl, ngx_ssl_session_t *sess)
  4693. {
  4694.     u_char                   *id;
  4695.     uint32_t                  hash;
  4696.     ngx_int_t                 rc;
  4697.     unsigned int              len;
  4698.     ngx_shm_zone_t           *shm_zone;
  4699.     ngx_slab_pool_t          *shpool;
  4700.     ngx_rbtree_node_t        *node, *sentinel;
  4701.     ngx_ssl_sess_id_t        *sess_id;
  4702.     ngx_ssl_session_cache_t  *cache;

  4704.     shm_zone = SSL_CTX_get_ex_data(ssl, ngx_ssl_session_cache_index);

  4706.     if (shm_zone == NULL) {
  4707.         return;
  4708.     }

  4710.     cache = shm_zone->data;

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

  4714.     hash = ngx_crc32_short(id, len);

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

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

  4721.     ngx_shmtx_lock(&shpool->mutex);

  4723.     node = cache->session_rbtree.root;
  4724.     sentinel = cache->session_rbtree.sentinel;

  4726.     while (node != sentinel) {

  4728.         if (hash < node->key) {
  4729.             node = node->left;
  4730.             continue;
  4731.         }

  4733.         if (hash > node->key) {
  4734.             node = node->right;
  4735.             continue;
  4736.         }

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

  4740.         sess_id = (ngx_ssl_sess_id_t *) node;

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

  4744.         if (rc == 0) {

  4746.             ngx_queue_remove(&sess_id->queue);

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

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

  4752. #if (NGX_PTR_SIZE == 8)
  4753.             ngx_slab_free_locked(shpool, sess_id->session);
  4754. #endif
  4755.             ngx_slab_free_locked(shpool, sess_id);

  4757.             goto done;
  4758.         }

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

  4763. done:

  4765.     ngx_shmtx_unlock(&shpool->mutex);
  4766. }


  4769. static void
  4770. ‌ngx_ssl_expire_sessions(ngx_ssl_session_cache_t *cache,
  4771.     ngx_slab_pool_t *shpool, ngx_uint_t n)
  4772. {
  4773.     time_t              now;
  4774.     ngx_queue_t        *q;
  4775.     ngx_ssl_sess_id_t  *sess_id;

  4777.     now = ngx_time();

  4779.     while (n < 3) {

  4781.         if (ngx_queue_empty(&cache->expire_queue)) {
  4782.             return;
  4783.         }

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

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

  4789.         if (n++ != 0 && sess_id->expire > now) {
  4790.             return;
  4791.         }

  4793.         ngx_queue_remove(q);

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

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

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

  4802. #if (NGX_PTR_SIZE == 8)
  4803.         ngx_slab_free_locked(shpool, sess_id->session);
  4804. #endif
  4805.         ngx_slab_free_locked(shpool, sess_id);
  4806.     }
  4807. }


  4810. static void
  4811. ‌ngx_ssl_session_rbtree_insert_value(ngx_rbtree_node_t *temp,
  4812.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  4813. {
  4814.     ngx_rbtree_node_t  **p;
  4815.     ngx_ssl_sess_id_t   *sess_id, *sess_id_temp;

  4817.     for ( ;; ) {

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

  4821.             p = &temp->left;

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

  4825.             p = &temp->right;

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

  4829.             sess_id = (ngx_ssl_sess_id_t *) node;
  4830.             sess_id_temp = (ngx_ssl_sess_id_t *) temp;

  4832.             p = (ngx_memn2cmp(sess_id->id, sess_id_temp->id,
  4833.                               (size_t) node->data, (size_t) temp->data)
  4834.                  < 0) ? &temp->left : &temp->right;
  4835.         }

  4837.         if (*p == sentinel) {
  4838.             break;
  4839.         }

  4841.         temp = *p;
  4842.     }

  4844.     *p = node;
  4845.     node->parent = temp;
  4846.     node->left = sentinel;
  4847.     node->right = sentinel;
  4848.     ngx_rbt_red(node);
  4849. }


  4852. #ifdef SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB

  4854. ngx_int_t
  4855. ‌ngx_ssl_session_ticket_keys(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_array_t *paths)
  4856. {
  4857.     u_char                 buf[80];
  4858.     size_t                 size;
  4859.     ssize_t                n;
  4860.     ngx_str_t             *path;
  4861.     ngx_file_t             file;
  4862.     ngx_uint_t             i;
  4863.     ngx_array_t           *keys;
  4864.     ngx_file_info_t        fi;
  4865.     ngx_pool_cleanup_t    *cln;
  4866.     ngx_ssl_ticket_key_t  *key;

  4868.     if (paths == NULL
  4869.         && SSL_CTX_get_ex_data(ssl->ctx, ngx_ssl_session_cache_index) == NULL)
  4870.     {
  4871.         return NGX_OK;
  4872.     }

  4874.     keys = ngx_array_create(cf->pool, paths ? paths->nelts : 3,
  4875.                             sizeof(ngx_ssl_ticket_key_t));
  4876.     if (keys == NULL) {
  4877.         return NGX_ERROR;
  4878.     }

  4880.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  4881.     if (cln == NULL) {
  4882.         return NGX_ERROR;
  4883.     }

  4885.     cln->handler = ngx_ssl_ticket_keys_cleanup;
  4886.     cln->data = keys;

  4888.     if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_ticket_keys_index, keys) == 0) {
  4889.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4890.                       "SSL_CTX_set_ex_data() failed");
  4891.         return NGX_ERROR;
  4892.     }

  4894.     if (SSL_CTX_set_tlsext_ticket_key_cb(ssl->ctx, ngx_ssl_ticket_key_callback)
  4895.         == 0)
  4896.     {
  4897.         ngx_log_error(NGX_LOG_WARN, cf->log, 0,
  4898.                       "nginx was built with Session Tickets support, however, "
  4899.                       "now it is linked dynamically to an OpenSSL library "
  4900.                       "which has no tlsext support, therefore Session Tickets "
  4901.                       "are not available");
  4902.         return NGX_OK;
  4903.     }

  4905.     if (paths == NULL) {

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

  4909.         key = ngx_array_push_n(keys, 3);
  4910.         key[0].shared = 1;
  4911.         key[0].expire = 0;
  4912.         key[1].shared = 1;
  4913.         key[1].expire = 0;
  4914.         key[2].shared = 1;
  4915.         key[2].expire = 0;

  4917.         return NGX_OK;
  4918.     }

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

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

  4927.         ngx_memzero(&file, sizeof(ngx_file_t));
  4928.         file.name = path[i];
  4929.         file.log = cf->log;

  4931.         file.fd = ngx_open_file(file.name.data, NGX_FILE_RDONLY,
  4932.                                 NGX_FILE_OPEN, 0);

  4934.         if (file.fd == NGX_INVALID_FILE) {
  4935.             ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  4936.                                ngx_open_file_n " \"%V\" failed", &file.name);
  4937.             return NGX_ERROR;
  4938.         }

  4940.         if (ngx_fd_info(file.fd, &fi) == NGX_FILE_ERROR) {
  4941.             ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  4942.                                ngx_fd_info_n " \"%V\" failed", &file.name);
  4943.             goto failed;
  4944.         }

  4946.         size = ngx_file_size(&fi);

  4948.         if (size != 48 && size != 80) {
  4949.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4950.                                "\"%V\" must be 48 or 80 bytes", &file.name);
  4951.             goto failed;
  4952.         }

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

  4956.         if (n == NGX_ERROR) {
  4957.             ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  4958.                                ngx_read_file_n " \"%V\" failed", &file.name);
  4959.             goto failed;
  4960.         }

  4962.         if ((size_t) n != size) {
  4963.             ngx_conf_log_error(NGX_LOG_CRIT, cf, 0,
  4964.                                ngx_read_file_n " \"%V\" returned only "
  4965.                                "%z bytes instead of %uz", &file.name, n, size);
  4966.             goto failed;
  4967.         }

  4969.         key = ngx_array_push(keys);
  4970.         if (key == NULL) {
  4971.             goto failed;
  4972.         }

  4974.         key->shared = 0;
  4975.         key->expire = 1;

  4977.         if (size == 48) {
  4978.             key->size = 48;
  4979.             ngx_memcpy(key->name, buf, 16);
  4980.             ngx_memcpy(key->aes_key, buf + 16, 16);
  4981.             ngx_memcpy(key->hmac_key, buf + 32, 16);

  4983.         } else {
  4984.             key->size = 80;
  4985.             ngx_memcpy(key->name, buf, 16);
  4986.             ngx_memcpy(key->hmac_key, buf + 16, 32);
  4987.             ngx_memcpy(key->aes_key, buf + 48, 32);
  4988.         }

  4990.         if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  4991.             ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  4992.                           ngx_close_file_n " \"%V\" failed", &file.name);
  4993.         }

  4995.         ngx_explicit_memzero(&buf, 80);
  4996.     }

  4998.     return NGX_OK;

  5000. failed:

  5002.     if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  5003.         ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  5004.                       ngx_close_file_n " \"%V\" failed", &file.name);
  5005.     }

  5007.     ngx_explicit_memzero(&buf, 80);

  5009.     return NGX_ERROR;
  5010. }


  5013. static int
  5014. ‌ngx_ssl_ticket_key_callback(ngx_ssl_conn_t *ssl_conn,
  5015.     unsigned char *name, unsigned char *iv, EVP_CIPHER_CTX *ectx,
  5016.     HMAC_CTX *hctx, int enc)
  5017. {
  5018.     size_t                 size;
  5019.     SSL_CTX               *ssl_ctx;
  5020.     ngx_uint_t             i;
  5021.     ngx_array_t           *keys;
  5022.     ngx_connection_t      *c;
  5023.     ngx_ssl_ticket_key_t  *key;
  5024.     const EVP_MD          *digest;
  5025.     const EVP_CIPHER      *cipher;

  5027.     c = ngx_ssl_get_connection(ssl_conn);
  5028.     ssl_ctx = c->ssl->session_ctx;

  5030.     if (ngx_ssl_rotate_ticket_keys(ssl_ctx, c->log) != NGX_OK) {
  5031.         return -1;
  5032.     }

  5034. #ifdef OPENSSL_NO_SHA256
  5035.     digest = EVP_sha1();
  5036. #else
  5037.     digest = EVP_sha256();
  5038. #endif

  5040.     keys = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_ticket_keys_index);
  5041.     if (keys == NULL) {
  5042.         return -1;
  5043.     }

  5045.     key = keys->elts;

  5047.     if (enc == 1) {
  5048.         /* encrypt session ticket */

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

  5055.         if (key[0].size == 48) {
  5056.             cipher = EVP_aes_128_cbc();
  5057.             size = 16;

  5059.         } else {
  5060.             cipher = EVP_aes_256_cbc();
  5061.             size = 32;
  5062.         }

  5064.         if (RAND_bytes(iv, EVP_CIPHER_iv_length(cipher)) != 1) {
  5065.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "RAND_bytes() failed");
  5066.             return -1;
  5067.         }

  5069.         if (EVP_EncryptInit_ex(ectx, cipher, NULL, key[0].aes_key, iv) != 1) {
  5070.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  5071.                           "EVP_EncryptInit_ex() failed");
  5072.             return -1;
  5073.         }

  5075. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  5076.         if (HMAC_Init_ex(hctx, key[0].hmac_key, size, digest, NULL) != 1) {
  5077.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "HMAC_Init_ex() failed");
  5078.             return -1;
  5079.         }
  5080. #else
  5081.         HMAC_Init_ex(hctx, key[0].hmac_key, size, digest, NULL);
  5082. #endif

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

  5086.         return 1;

  5088.     } else {
  5089.         /* decrypt session ticket */

  5091.         for (i = 0; i < keys->nelts; i++) {
  5092.             if (ngx_memcmp(name, key[i].name, 16) == 0) {
  5093.                 goto found;
  5094.             }
  5095.         }

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

  5101.         return 0;

  5103.     found:

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

  5109.         if (key[i].size == 48) {
  5110.             cipher = EVP_aes_128_cbc();
  5111.             size = 16;

  5113.         } else {
  5114.             cipher = EVP_aes_256_cbc();
  5115.             size = 32;
  5116.         }

  5118. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  5119.         if (HMAC_Init_ex(hctx, key[i].hmac_key, size, digest, NULL) != 1) {
  5120.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "HMAC_Init_ex() failed");
  5121.             return -1;
  5122.         }
  5123. #else
  5124.         HMAC_Init_ex(hctx, key[i].hmac_key, size, digest, NULL);
  5125. #endif

  5127.         if (EVP_DecryptInit_ex(ectx, cipher, NULL, key[i].aes_key, iv) != 1) {
  5128.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  5129.                           "EVP_DecryptInit_ex() failed");
  5130.             return -1;
  5131.         }

  5133.         /* renew if TLSv1.3 */

  5135. #ifdef TLS1_3_VERSION
  5136.         if (SSL_version(ssl_conn) == TLS1_3_VERSION) {
  5137.             return 2;
  5138.         }
  5139. #endif

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

  5143.         if (i != 0 && key[i].expire) {
  5144.             return 2;
  5145.         }

  5147.         return 1;
  5148.     }
  5149. }


  5152. static ngx_int_t
  5153. ‌ngx_ssl_rotate_ticket_keys(SSL_CTX *ssl_ctx, ngx_log_t *log)
  5154. {
  5155.     time_t                    now, expire;
  5156.     ngx_array_t              *keys;
  5157.     ngx_shm_zone_t           *shm_zone;
  5158.     ngx_slab_pool_t          *shpool;
  5159.     ngx_ssl_ticket_key_t     *key;
  5160.     ngx_ssl_session_cache_t  *cache;
  5161.     u_char                    buf[80];

  5163.     keys = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_ticket_keys_index);
  5164.     if (keys == NULL) {
  5165.         return NGX_OK;
  5166.     }

  5168.     key = keys->elts;

  5170.     if (!key[0].shared) {
  5171.         return NGX_OK;
  5172.     }

  5174.     /*
  5175.      * if we don't need to update expiration of the current key
  5176.      * and the previous key is still needed, don't sync with shared
  5177.      * memory to save some work; in the worst case other worker process
  5178.      * will switch to the next key, but this process will still be able
  5179.      * to decrypt tickets encrypted with it
  5180.      */

  5182.     now = ngx_time();
  5183.     expire = now + SSL_CTX_get_timeout(ssl_ctx);

  5185.     if (key[0].expire >= expire && key[1].expire >= now) {
  5186.         return NGX_OK;
  5187.     }

  5189.     shm_zone = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_session_cache_index);

  5191.     cache = shm_zone->data;
  5192.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

  5194.     ngx_shmtx_lock(&shpool->mutex);

  5196.     key = cache->ticket_keys;

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

  5200.         /* initialize the current key */

  5202.         if (RAND_bytes(buf, 80) != 1) {
  5203.             ngx_ssl_error(NGX_LOG_ALERT, log, 0, "RAND_bytes() failed");
  5204.             ngx_shmtx_unlock(&shpool->mutex);
  5205.             return NGX_ERROR;
  5206.         }

  5208.         key[0].shared = 1;
  5209.         key[0].expire = expire;
  5210.         key[0].size = 80;
  5211.         ngx_memcpy(key[0].name, buf, 16);
  5212.         ngx_memcpy(key[0].hmac_key, buf + 16, 32);
  5213.         ngx_memcpy(key[0].aes_key, buf + 48, 32);

  5215.         ngx_explicit_memzero(&buf, 80);

  5217.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0,
  5218.                        "ssl ticket key: \"%*xs\"",
  5219.                        (size_t) 16, key[0].name);

  5221.         /*
  5222.          * copy the current key to the next key, as initialization of
  5223.          * the previous key will replace the current key with the next
  5224.          * key
  5225.          */

  5227.         key[2] = key[0];
  5228.     }

  5230.     if (key[1].expire < now) {

  5232.         /*
  5233.          * if the previous key is no longer needed (or not initialized),
  5234.          * replace it with the current key, replace the current key with
  5235.          * the next key, and generate new next key
  5236.          */

  5238.         key[1] = key[0];
  5239.         key[0] = key[2];

  5241.         if (RAND_bytes(buf, 80) != 1) {
  5242.             ngx_ssl_error(NGX_LOG_ALERT, log, 0, "RAND_bytes() failed");
  5243.             ngx_shmtx_unlock(&shpool->mutex);
  5244.             return NGX_ERROR;
  5245.         }

  5247.         key[2].shared = 1;
  5248.         key[2].expire = 0;
  5249.         key[2].size = 80;
  5250.         ngx_memcpy(key[2].name, buf, 16);
  5251.         ngx_memcpy(key[2].hmac_key, buf + 16, 32);
  5252.         ngx_memcpy(key[2].aes_key, buf + 48, 32);

  5254.         ngx_explicit_memzero(&buf, 80);

  5256.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0,
  5257.                        "ssl ticket key: \"%*xs\"",
  5258.                        (size_t) 16, key[2].name);
  5259.     }

  5261.     /*
  5262.      * update expiration of the current key: it is going to be needed
  5263.      * at least till the session being created expires
  5264.      */

  5266.     if (expire > key[0].expire) {
  5267.         key[0].expire = expire;
  5268.     }

  5270.     /* sync keys to the worker process memory */

  5272.     ngx_memcpy(keys->elts, cache->ticket_keys,
  5273.                keys->nelts * sizeof(ngx_ssl_ticket_key_t));

  5275.     ngx_shmtx_unlock(&shpool->mutex);

  5277.     return NGX_OK;
  5278. }


  5281. static void
  5282. ‌ngx_ssl_ticket_keys_cleanup(void *data)
  5283. {
  5284.     ngx_array_t  *keys = data;

  5286.     ngx_explicit_memzero(keys->elts,
  5287.                          keys->nelts * sizeof(ngx_ssl_ticket_key_t));
  5288. }

  5290. #else

  5292. ngx_int_t
  5293. ‌ngx_ssl_session_ticket_keys(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_array_t *paths)
  5294. {
  5295.     if (paths) {
  5296.         ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  5297.                       "\"ssl_session_ticket_key\" ignored, not supported");
  5298.     }

  5300.     return NGX_OK;
  5301. }

  5303. #endif


  5306. void
  5307. ‌ngx_ssl_cleanup_ctx(void *data)
  5308. {
  5309.     ngx_ssl_t  *ssl = data;

  5311.     X509        *cert;
  5312.     u_char      *p;
  5313.     ngx_uint_t   i;

  5315.     for (i = 0; i < ssl->certs.nelts; i++) {
  5316.         cert = ((X509 **) ssl->certs.elts)[i];

  5318.         p = X509_get_ex_data(cert, ngx_ssl_certificate_comp_index);

  5320.         if (p) {
  5321.             ngx_free(p);
  5322.             X509_set_ex_data(cert, ngx_ssl_certificate_comp_index, NULL);
  5323.         }

  5325.         X509_free(cert);
  5326.     }

  5328.     SSL_CTX_free(ssl->ctx);
  5329. }


  5332. ngx_int_t
  5333. ‌ngx_ssl_check_host(ngx_connection_t *c, ngx_str_t *name)
  5334. {
  5335.     X509       *cert;
  5336.     u_char     *addr;
  5337.     size_t      alen;
  5338.     in_addr_t   addr4;
  5339. #if (NGX_HAVE_INET6)
  5340.     u_char      addr6[16];
  5341. #endif

  5343.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5344.     if (cert == NULL) {
  5345.         return NGX_ERROR;
  5346.     }

  5348.     if (name->len == 0) {
  5349.         goto failed;
  5350.     }

  5352.     addr4 = ngx_inet_addr(name->data, name->len);

  5354.     if (addr4 != INADDR_NONE) {
  5355.         addr = (u_char *) &addr4;
  5356.         alen = 4;

  5358. #if (NGX_HAVE_INET6)
  5359.     } else if (name->data[0] == '[') {

  5361.         if (name->data[name->len - 1] != ']') {
  5362.             goto failed;
  5363.         }

  5365.         if (ngx_inet6_addr(name->data + 1, name->len - 2, addr6) != NGX_OK) {
  5366.             goto failed;
  5367.         }

  5369.         addr = addr6;
  5370.         alen = 16;

  5372. #endif
  5373.     } else {
  5374.         addr = NULL;
  5375.         alen = 0;
  5376.     }

  5378. #ifdef X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT

  5380.     /* X509_check_host() is only available in OpenSSL 1.0.2+ */

  5382.     if (addr) {
  5383.         if (X509_check_ip(cert, addr, alen, 0) != 1) {
  5384.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5385.                            "X509_check_ip(): no match");
  5386.             goto failed;
  5387.         }

  5389.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5390.                        "X509_check_ip(): match");
  5391.         goto found;
  5392.     }

  5394.     if (X509_check_host(cert, (char *) name->data, name->len, 0, NULL) != 1) {
  5395.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5396.                        "X509_check_host(): no match");
  5397.         goto failed;
  5398.     }

  5400.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5401.                    "X509_check_host(): match");
  5402.     goto found;

  5404. #else
  5405.     {
  5406.     int                      n, i;
  5407.     size_t                   dlen;
  5408.     u_char                  *data;
  5409.     X509_NAME               *sname;
  5410.     ASN1_STRING             *str;
  5411.     X509_NAME_ENTRY         *entry;
  5412.     GENERAL_NAME            *altname;
  5413.     STACK_OF(GENERAL_NAME)  *altnames;

  5415.     /*
  5416.      * As per RFC6125 and RFC2818, we check subjectAltName extension,
  5417.      * and if it's not present - commonName in Subject is checked.
  5418.      */

  5420.     altnames = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);

  5422.     if (altnames) {
  5423.         n = sk_GENERAL_NAME_num(altnames);

  5425.         for (i = 0; i < n; i++) {
  5426.             altname = sk_GENERAL_NAME_value(altnames, i);

  5428.             if (altname->type == GEN_DNS) {

  5430.                 str = altname->d.dNSName;

  5432.                 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5433.                                "SSL subjectAltName: \"%*s\"",
  5434.                                (size_t) ASN1_STRING_length(str),
  5435.                                ASN1_STRING_data(str));

  5437.                 if (addr == NULL && ngx_ssl_check_name(name, str) == NGX_OK) {
  5438.                     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5439.                                    "SSL subjectAltName: match");
  5440.                     GENERAL_NAMES_free(altnames);
  5441.                     goto found;
  5442.                 }

  5444.             } else if (altname->type == GEN_IPADD) {

  5446.                 str = altname->d.iPAddress;
  5447.                 data = ASN1_STRING_data(str);
  5448.                 dlen = ASN1_STRING_length(str);

  5450. #if (NGX_DEBUG)
  5451.                 {
  5452.                 size_t  al;
  5453.                 u_char  at[NGX_INET6_ADDRSTRLEN];

  5455.                 if (dlen == 4) {
  5456.                     al = ngx_inet_ntop(AF_INET, data, at,
  5457.                                        NGX_INET6_ADDRSTRLEN);

  5459. #if (NGX_HAVE_INET6)
  5460.                 } else if (dlen == 16) {
  5461.                     al = ngx_inet_ntop(AF_INET6, data, at,
  5462.                                        NGX_INET6_ADDRSTRLEN);

  5464. #endif
  5465.                 } else {
  5466.                     al = ngx_cpymem(at, "<invalid>", sizeof("<invalid>") - 1)
  5467.                          - at;
  5468.                 }

  5470.                 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5471.                                "SSL subjectAltName: \"%*s\"",
  5472.                                al, at);
  5473.                 }
  5474. #endif

  5476.                 if (addr
  5477.                     && alen == dlen
  5478.                     && ngx_memcmp(addr, data, dlen) == 0)
  5479.                 {
  5480.                     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5481.                                    "SSL subjectAltName: match");
  5482.                     GENERAL_NAMES_free(altnames);
  5483.                     goto found;
  5484.                 }
  5485.             }
  5486.         }

  5488.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5489.                        "SSL subjectAltName: no match");

  5491.         GENERAL_NAMES_free(altnames);
  5492.         goto failed;
  5493.     }

  5495.     /*
  5496.      * If there is no subjectAltName extension, check commonName
  5497.      * in Subject.  While RFC2818 requires to only check "most specific"
  5498.      * CN, both Apache and OpenSSL check all CNs, and so do we.
  5499.      */

  5501.     if (addr) {
  5502.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5503.                        "SSL commonName: no match");
  5504.         goto failed;
  5505.     }

  5507.     sname = X509_get_subject_name(cert);

  5509.     if (sname == NULL) {
  5510.         goto failed;
  5511.     }

  5513.     i = -1;
  5514.     for ( ;; ) {
  5515.         i = X509_NAME_get_index_by_NID(sname, NID_commonName, i);

  5517.         if (i < 0) {
  5518.             break;
  5519.         }

  5521.         entry = X509_NAME_get_entry(sname, i);
  5522.         str = X509_NAME_ENTRY_get_data(entry);

  5524.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5525.                        "SSL commonName: \"%*s\"",
  5526.                        (size_t) ASN1_STRING_length(str),
  5527.                        ASN1_STRING_data(str));

  5529.         if (ngx_ssl_check_name(name, str) == NGX_OK) {
  5530.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5531.                            "SSL commonName: match");
  5532.             goto found;
  5533.         }
  5534.     }

  5536.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5537.                    "SSL commonName: no match");
  5538.     }
  5539. #endif

  5541. failed:

  5543.     X509_free(cert);
  5544.     return NGX_ERROR;

  5546. found:

  5548.     X509_free(cert);
  5549.     return NGX_OK;
  5550. }


  5553. #ifndef X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT

  5555. static ngx_int_t
  5556. ‌ngx_ssl_check_name(ngx_str_t *name, ASN1_STRING *pattern)
  5557. {
  5558.     u_char  *s, *p, *end;
  5559.     size_t   slen, plen;

  5561.     s = name->data;
  5562.     slen = name->len;

  5564.     p = ASN1_STRING_data(pattern);
  5565.     plen = ASN1_STRING_length(pattern);

  5567.     if (slen == plen && ngx_strncasecmp(s, p, plen) == 0) {
  5568.         return NGX_OK;
  5569.     }

  5571.     if (plen > 2 && p[0] == '*' && p[1] == '.') {
  5572.         plen -= 1;
  5573.         p += 1;

  5575.         end = s + slen;
  5576.         s = ngx_strlchr(s, end, '.');

  5578.         if (s == NULL) {
  5579.             return NGX_ERROR;
  5580.         }

  5582.         slen = end - s;

  5584.         if (plen == slen && ngx_strncasecmp(s, p, plen) == 0) {
  5585.             return NGX_OK;
  5586.         }
  5587.     }

  5589.     return NGX_ERROR;
  5590. }

  5592. #endif


  5595. ngx_int_t
  5596. ‌ngx_ssl_get_protocol(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5597. {
  5598.     s->data = (u_char *) SSL_get_version(c->ssl->connection);
  5599.     return NGX_OK;
  5600. }


  5603. ngx_int_t
  5604. ‌ngx_ssl_get_cipher_name(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5605. {
  5606.     s->data = (u_char *) SSL_get_cipher_name(c->ssl->connection);
  5607.     return NGX_OK;
  5608. }


  5611. ngx_int_t
  5612. ‌ngx_ssl_get_ciphers(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5613. {
  5614. #ifdef SSL_CTRL_GET_RAW_CIPHERLIST

  5616.     int                n, i, bytes;
  5617.     size_t             len;
  5618.     u_char            *ciphers, *p;
  5619.     const SSL_CIPHER  *cipher;

  5621.     bytes = SSL_get0_raw_cipherlist(c->ssl->connection, NULL);
  5622.     n = SSL_get0_raw_cipherlist(c->ssl->connection, &ciphers);

  5624.     if (n <= 0) {
  5625.         s->len = 0;
  5626.         return NGX_OK;
  5627.     }

  5629.     len = 0;
  5630.     n /= bytes;

  5632.     for (i = 0; i < n; i++) {
  5633.         cipher = SSL_CIPHER_find(c->ssl->connection, ciphers + i * bytes);

  5635.         if (cipher) {
  5636.             len += ngx_strlen(SSL_CIPHER_get_name(cipher));

  5638.         } else {
  5639.             len += sizeof("0x") - 1 + bytes * (sizeof("00") - 1);
  5640.         }

  5642.         len += sizeof(":") - 1;
  5643.     }

  5645.     s->data = ngx_pnalloc(pool, len);
  5646.     if (s->data == NULL) {
  5647.         return NGX_ERROR;
  5648.     }

  5650.     p = s->data;

  5652.     for (i = 0; i < n; i++) {
  5653.         cipher = SSL_CIPHER_find(c->ssl->connection, ciphers + i * bytes);

  5655.         if (cipher) {
  5656.             p = ngx_sprintf(p, "%s", SSL_CIPHER_get_name(cipher));

  5658.         } else {
  5659.             p = ngx_sprintf(p, "0x");
  5660.             p = ngx_hex_dump(p, ciphers + i * bytes, bytes);
  5661.         }

  5663.         *p++ = ':';
  5664.     }

  5666.     p--;

  5668.     s->len = p - s->data;

  5670. #else

  5672.     u_char  buf[4096];

  5674.     if (SSL_get_shared_ciphers(c->ssl->connection, (char *) buf, 4096)
  5675.         == NULL)
  5676.     {
  5677.         s->len = 0;
  5678.         return NGX_OK;
  5679.     }

  5681.     s->len = ngx_strlen(buf);
  5682.     s->data = ngx_pnalloc(pool, s->len);
  5683.     if (s->data == NULL) {
  5684.         return NGX_ERROR;
  5685.     }

  5687.     ngx_memcpy(s->data, buf, s->len);

  5689. #endif

  5691.     return NGX_OK;
  5692. }


  5695. ngx_int_t
  5696. ‌ngx_ssl_get_curve(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5697. {
  5698. #ifdef SSL_get_negotiated_group

  5700.     int          nid;
  5701.     const char  *name;

  5703.     nid = SSL_get_negotiated_group(c->ssl->connection);

  5705.     if (nid != NID_undef) {

  5707.         if ((nid & TLSEXT_nid_unknown) == 0) {
  5708.             s->len = ngx_strlen(OBJ_nid2sn(nid));
  5709.             s->data = (u_char *) OBJ_nid2sn(nid);
  5710.             return NGX_OK;
  5711.         }

  5713.         name = SSL_group_to_name(c->ssl->connection, nid);

  5715.         s->len = name ? ngx_strlen(name) : sizeof("0x0000") - 1;
  5716.         s->data = ngx_pnalloc(pool, s->len);
  5717.         if (s->data == NULL) {
  5718.             return NGX_ERROR;
  5719.         }

  5721.         if (name) {
  5722.             ngx_memcpy(s->data, name, s->len);

  5724.         } else {
  5725.             ngx_sprintf(s->data, "0x%04xd", nid & 0xffff);
  5726.         }

  5728.         return NGX_OK;
  5729.     }

  5731. #endif

  5733.     s->len = 0;
  5734.     return NGX_OK;
  5735. }


  5738. ngx_int_t
  5739. ‌ngx_ssl_get_curves(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5740. {
  5741. #ifdef SSL_CTRL_GET_CURVES

  5743.     int         *curves, n, i, nid;
  5744.     u_char      *p;
  5745.     size_t       len;
  5746.     const char  *name;

  5748.     n = SSL_get1_curves(c->ssl->connection, NULL);

  5750.     if (n <= 0) {
  5751.         s->len = 0;
  5752.         return NGX_OK;
  5753.     }

  5755.     curves = ngx_palloc(pool, n * sizeof(int));
  5756.     if (curves == NULL) {
  5757.         return NGX_ERROR;
  5758.     }

  5760.     n = SSL_get1_curves(c->ssl->connection, curves);
  5761.     len = 0;

  5763.     for (i = 0; i < n; i++) {
  5764.         nid = curves[i];

  5766.         if (nid & TLSEXT_nid_unknown) {
  5767.             name = SSL_group_to_name(c->ssl->connection, nid);

  5769.             len += name ? ngx_strlen(name) : sizeof("0x0000") - 1;

  5771.         } else {
  5772.             len += ngx_strlen(OBJ_nid2sn(nid));
  5773.         }

  5775.         len += sizeof(":") - 1;
  5776.     }

  5778.     s->data = ngx_pnalloc(pool, len);
  5779.     if (s->data == NULL) {
  5780.         return NGX_ERROR;
  5781.     }

  5783.     p = s->data;

  5785.     for (i = 0; i < n; i++) {
  5786.         nid = curves[i];

  5788.         if (nid & TLSEXT_nid_unknown) {
  5789.             name = SSL_group_to_name(c->ssl->connection, nid);

  5791.             p = name ? ngx_cpymem(p, name, ngx_strlen(name))
  5792.                      : ngx_sprintf(p, "0x%04xd", nid & 0xffff);

  5794.         } else {
  5795.             p = ngx_sprintf(p, "%s", OBJ_nid2sn(nid));
  5796.         }

  5798.         *p++ = ':';
  5799.     }

  5801.     p--;

  5803.     s->len = p - s->data;

  5805. #else

  5807.     s->len = 0;

  5809. #endif

  5811.     return NGX_OK;
  5812. }


  5815. ngx_int_t
  5816. ‌ngx_ssl_get_sigalg(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5817. {
  5818. #ifdef SSL_get0_signature_name

  5820.     const char  *name;

  5822.     if (SSL_get0_signature_name(c->ssl->connection, &name)) {
  5823.         s->len = ngx_strlen(name);
  5824.         s->data = ngx_pnalloc(pool, s->len);
  5825.         if (s->data == NULL) {
  5826.             return NGX_ERROR;
  5827.         }

  5829.         ngx_memcpy(s->data, name, s->len);

  5831.         return NGX_OK;
  5832.     }

  5834. #endif

  5836.     s->len = 0;
  5837.     return NGX_OK;
  5838. }


  5841. ngx_int_t
  5842. ‌ngx_ssl_get_sigalgs(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5843. {
  5844. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)

  5846.     int            n, i;
  5847.     size_t         len;
  5848.     u_char        *p;
  5849.     const char    *name;
  5850.     unsigned int   codepoint;

  5852.     n = SSL_get0_sigalg(c->ssl->connection, -1, NULL, NULL);

  5854.     if (n <= 0) {
  5855.         s->len = 0;
  5856.         return NGX_OK;
  5857.     }

  5859.     len = 0;

  5861.     for (i = 0; i < n; i++) {
  5862.         SSL_get0_sigalg(c->ssl->connection, i, &codepoint, &name);
  5863.         len += name ? ngx_strlen(name) : sizeof("0x0000") - 1;
  5864.         len += sizeof(":") - 1;
  5865.     }

  5867.     s->data = ngx_pnalloc(pool, len);
  5868.     if (s->data == NULL) {
  5869.         return NGX_ERROR;
  5870.     }

  5872.     p = s->data;

  5874.     for (i = 0; i < n; i++) {
  5875.         SSL_get0_sigalg(c->ssl->connection, i, &codepoint, &name);

  5877.         if (name) {
  5878.             p = ngx_cpymem(p, name, ngx_strlen(name));

  5880.         } else {
  5881.             p = ngx_sprintf(p, "0x%04xd", codepoint);
  5882.         }

  5884.         *p++ = ':';
  5885.     }

  5887.     p--;

  5889.     s->len = p - s->data;

  5891. #elif defined SSL_CTRL_SET_SIGALGS

  5893.     /*
  5894.      * SSL_get_sigalgs() is only available in OpenSSL 1.0.2+,
  5895.      * but uses a different naming, so emit raw codes
  5896.      */

  5898.     int             n, i;
  5899.     size_t          len;
  5900.     u_char         *p;
  5901.     unsigned char   rsig, rhash;

  5903.     n = SSL_get_sigalgs(c->ssl->connection, -1, NULL, NULL, NULL, NULL, NULL);

  5905.     if (n <= 0) {
  5906.         s->len = 0;
  5907.         return NGX_OK;
  5908.     }

  5910.     len = n * (sizeof("0x0000") - 1 + sizeof(":") - 1);

  5912.     s->data = ngx_pnalloc(pool, len);
  5913.     if (s->data == NULL) {
  5914.         return NGX_ERROR;
  5915.     }

  5917.     p = s->data;

  5919.     for (i = 0; i < n; i++) {
  5920.         SSL_get_sigalgs(c->ssl->connection, i, NULL, NULL, NULL, &rsig, &rhash);
  5921.         p = ngx_sprintf(p, "0x%04xd", rhash << 8 | rsig);
  5922.         *p++ = ':';
  5923.     }

  5925.     p--;

  5927.     s->len = p - s->data;

  5929. #else

  5931.     s->len = 0;

  5933. #endif

  5935.     return NGX_OK;
  5936. }


  5939. ngx_int_t
  5940. ‌ngx_ssl_get_session_id(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5941. {
  5942.     u_char        *buf;
  5943.     SSL_SESSION   *sess;
  5944.     unsigned int   len;

  5946.     sess = SSL_get0_session(c->ssl->connection);
  5947.     if (sess == NULL) {
  5948.         s->len = 0;
  5949.         return NGX_OK;
  5950.     }

  5952.     buf = (u_char *) SSL_SESSION_get_id(sess, &len);

  5954.     s->len = 2 * len;
  5955.     s->data = ngx_pnalloc(pool, 2 * len);
  5956.     if (s->data == NULL) {
  5957.         return NGX_ERROR;
  5958.     }

  5960.     ngx_hex_dump(s->data, buf, len);

  5962.     return NGX_OK;
  5963. }


  5966. ngx_int_t
  5967. ‌ngx_ssl_get_session_reused(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5968. {
  5969.     if (SSL_session_reused(c->ssl->connection)) {
  5970.         ngx_str_set(s, "r");

  5972.     } else {
  5973.         ngx_str_set(s, ".");
  5974.     }

  5976.     return NGX_OK;
  5977. }


  5980. ngx_int_t
  5981. ‌ngx_ssl_get_early_data(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5982. {
  5983.     s->len = 0;

  5985. #ifdef SSL_ERROR_EARLY_DATA_REJECTED

  5987.     /* BoringSSL */

  5989.     if (SSL_in_early_data(c->ssl->connection)) {
  5990.         ngx_str_set(s, "1");
  5991.     }

  5993. #elif defined SSL_READ_EARLY_DATA_SUCCESS

  5995.     /* OpenSSL */

  5997.     if (!SSL_is_init_finished(c->ssl->connection)) {
  5998.         ngx_str_set(s, "1");
  5999.     }

  6001. #endif

  6003.     return NGX_OK;
  6004. }


  6007. ngx_int_t
  6008. ‌ngx_ssl_get_server_name(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6009. {
  6010. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

  6012.     size_t       len;
  6013.     const char  *name;

  6015.     name = SSL_get_servername(c->ssl->connection, TLSEXT_NAMETYPE_host_name);

  6017.     if (name) {
  6018.         len = ngx_strlen(name);

  6020.         s->len = len;
  6021.         s->data = ngx_pnalloc(pool, len);
  6022.         if (s->data == NULL) {
  6023.             return NGX_ERROR;
  6024.         }

  6026.         ngx_memcpy(s->data, name, len);

  6028.         return NGX_OK;
  6029.     }

  6031. #endif

  6033.     s->len = 0;
  6034.     return NGX_OK;
  6035. }


  6038. ngx_int_t
  6039. ‌ngx_ssl_get_alpn_protocol(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6040. {
  6041. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  6043.     unsigned int          len;
  6044.     const unsigned char  *data;

  6046.     SSL_get0_alpn_selected(c->ssl->connection, &data, &len);

  6048.     if (len > 0) {

  6050.         s->data = ngx_pnalloc(pool, len);
  6051.         if (s->data == NULL) {
  6052.             return NGX_ERROR;
  6053.         }

  6055.         ngx_memcpy(s->data, data, len);
  6056.         s->len = len;

  6058.         return NGX_OK;
  6059.     }

  6061. #endif

  6063.     s->len = 0;
  6064.     return NGX_OK;
  6065. }


  6068. ngx_int_t
  6069. ‌ngx_ssl_get_ech_status(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6070. {
  6071. #ifdef SSL_OP_ECH_GREASE
  6072.     int    echrv;
  6073.     char  *inner_sni, *outer_sni;

  6075.     inner_sni = NULL;
  6076.     outer_sni = NULL;

  6078.     echrv = SSL_ech_get1_status(c->ssl->connection, &inner_sni, &outer_sni);

  6080.     switch (echrv) {
  6081.     case SSL_ECH_STATUS_NOT_TRIED:
  6082.         ngx_str_set(s, "NOT_TRIED");
  6083.         break;
  6084.     case SSL_ECH_STATUS_SUCCESS:
  6085.         ngx_str_set(s, "SUCCESS");
  6086.         break;
  6087.     case SSL_ECH_STATUS_GREASE:
  6088.         ngx_str_set(s, "GREASE");
  6089.         break;
  6090.     case SSL_ECH_STATUS_BACKEND:
  6091.         ngx_str_set(s, "BACKEND");
  6092.         break;
  6093.     default:
  6094.         ngx_str_set(s, "FAILED");
  6095.         break;
  6096.     }

  6098.     OPENSSL_free(inner_sni);
  6099.     OPENSSL_free(outer_sni);
  6100. #else
  6101.     s->len = 0;
  6102. #endif
  6103.     return NGX_OK;
  6104. }


  6107. ngx_int_t
  6108. ‌ngx_ssl_get_ech_outer_server_name(ngx_connection_t *c, ngx_pool_t *pool,
  6109.     ngx_str_t *s)
  6110. {
  6111. #if defined(SSL_OP_ECH_GREASE)
  6112.     int    echrv;
  6113.     char  *inner_sni, *outer_sni;

  6115.     inner_sni = NULL;
  6116.     outer_sni = NULL;

  6118.     echrv = SSL_ech_get1_status(c->ssl->connection, &inner_sni, &outer_sni);

  6120.     if (echrv == SSL_ECH_STATUS_SUCCESS && outer_sni) {
  6121.         s->len = ngx_strlen(outer_sni);

  6123.         s->data = ngx_pnalloc(pool, s->len);
  6124.         if (s->data == NULL) {
  6125.             OPENSSL_free(inner_sni);
  6126.             OPENSSL_free(outer_sni);
  6127.             return NGX_ERROR;
  6128.         }

  6130.         ngx_memcpy(s->data, outer_sni, s->len);

  6132.     } else {
  6133.         s->len = 0;
  6134.     }

  6136.     OPENSSL_free(inner_sni);
  6137.     OPENSSL_free(outer_sni);
  6138. #else
  6139.     s->len = 0;
  6140. #endif
  6141.     return NGX_OK;
  6142. }


  6145. ngx_int_t
  6146. ‌ngx_ssl_get_raw_certificate(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6147. {
  6148.     size_t   len;
  6149.     BIO     *bio;
  6150.     X509    *cert;

  6152.     s->len = 0;

  6154.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6155.     if (cert == NULL) {
  6156.         return NGX_OK;
  6157.     }

  6159.     bio = BIO_new(BIO_s_mem());
  6160.     if (bio == NULL) {
  6161.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6162.         X509_free(cert);
  6163.         return NGX_ERROR;
  6164.     }

  6166.     if (PEM_write_bio_X509(bio, cert) == 0) {
  6167.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "PEM_write_bio_X509() failed");
  6168.         goto failed;
  6169.     }

  6171.     len = BIO_pending(bio);
  6172.     s->len = len;

  6174.     s->data = ngx_pnalloc(pool, len);
  6175.     if (s->data == NULL) {
  6176.         goto failed;
  6177.     }

  6179.     BIO_read(bio, s->data, len);

  6181.     BIO_free(bio);
  6182.     X509_free(cert);

  6184.     return NGX_OK;

  6186. failed:

  6188.     BIO_free(bio);
  6189.     X509_free(cert);

  6191.     return NGX_ERROR;
  6192. }


  6195. ngx_int_t
  6196. ‌ngx_ssl_get_certificate(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6197. {
  6198.     u_char      *p;
  6199.     size_t       len;
  6200.     ngx_uint_t   i;
  6201.     ngx_str_t    cert;

  6203.     if (ngx_ssl_get_raw_certificate(c, pool, &cert) != NGX_OK) {
  6204.         return NGX_ERROR;
  6205.     }

  6207.     if (cert.len == 0) {
  6208.         s->len = 0;
  6209.         return NGX_OK;
  6210.     }

  6212.     len = cert.len - 1;

  6214.     for (i = 0; i < cert.len - 1; i++) {
  6215.         if (cert.data[i] == LF) {
  6216.             len++;
  6217.         }
  6218.     }

  6220.     s->len = len;
  6221.     s->data = ngx_pnalloc(pool, len);
  6222.     if (s->data == NULL) {
  6223.         return NGX_ERROR;
  6224.     }

  6226.     p = s->data;

  6228.     for (i = 0; i < cert.len - 1; i++) {
  6229.         *p++ = cert.data[i];
  6230.         if (cert.data[i] == LF) {
  6231.             *p++ = '\t';
  6232.         }
  6233.     }

  6235.     return NGX_OK;
  6236. }


  6239. ngx_int_t
  6240. ‌ngx_ssl_get_escaped_certificate(ngx_connection_t *c, ngx_pool_t *pool,
  6241.     ngx_str_t *s)
  6242. {
  6243.     ngx_str_t  cert;
  6244.     uintptr_t  n;

  6246.     if (ngx_ssl_get_raw_certificate(c, pool, &cert) != NGX_OK) {
  6247.         return NGX_ERROR;
  6248.     }

  6250.     if (cert.len == 0) {
  6251.         s->len = 0;
  6252.         return NGX_OK;
  6253.     }

  6255.     n = ngx_escape_uri(NULL, cert.data, cert.len, NGX_ESCAPE_URI_COMPONENT);

  6257.     s->len = cert.len + n * 2;
  6258.     s->data = ngx_pnalloc(pool, s->len);
  6259.     if (s->data == NULL) {
  6260.         return NGX_ERROR;
  6261.     }

  6263.     ngx_escape_uri(s->data, cert.data, cert.len, NGX_ESCAPE_URI_COMPONENT);

  6265.     return NGX_OK;
  6266. }


  6269. ngx_int_t
  6270. ‌ngx_ssl_get_subject_dn(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6271. {
  6272.     BIO        *bio;
  6273.     X509       *cert;
  6274. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  6275.     const
  6276. #endif
  6277.     X509_NAME  *name;

  6279.     s->len = 0;

  6281.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6282.     if (cert == NULL) {
  6283.         return NGX_OK;
  6284.     }

  6286.     name = X509_get_subject_name(cert);
  6287.     if (name == NULL) {
  6288.         X509_free(cert);
  6289.         return NGX_ERROR;
  6290.     }

  6292.     bio = BIO_new(BIO_s_mem());
  6293.     if (bio == NULL) {
  6294.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6295.         X509_free(cert);
  6296.         return NGX_ERROR;
  6297.     }

  6299.     if (X509_NAME_print_ex(bio, name, 0, XN_FLAG_RFC2253) < 0) {
  6300.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_print_ex() failed");
  6301.         goto failed;
  6302.     }

  6304.     s->len = BIO_pending(bio);
  6305.     s->data = ngx_pnalloc(pool, s->len);
  6306.     if (s->data == NULL) {
  6307.         goto failed;
  6308.     }

  6310.     BIO_read(bio, s->data, s->len);

  6312.     BIO_free(bio);
  6313.     X509_free(cert);

  6315.     return NGX_OK;

  6317. failed:

  6319.     BIO_free(bio);
  6320.     X509_free(cert);

  6322.     return NGX_ERROR;
  6323. }


  6326. ngx_int_t
  6327. ‌ngx_ssl_get_issuer_dn(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6328. {
  6329.     BIO        *bio;
  6330.     X509       *cert;
  6331. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  6332.     const
  6333. #endif
  6334.     X509_NAME  *name;

  6336.     s->len = 0;

  6338.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6339.     if (cert == NULL) {
  6340.         return NGX_OK;
  6341.     }

  6343.     name = X509_get_issuer_name(cert);
  6344.     if (name == NULL) {
  6345.         X509_free(cert);
  6346.         return NGX_ERROR;
  6347.     }

  6349.     bio = BIO_new(BIO_s_mem());
  6350.     if (bio == NULL) {
  6351.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6352.         X509_free(cert);
  6353.         return NGX_ERROR;
  6354.     }

  6356.     if (X509_NAME_print_ex(bio, name, 0, XN_FLAG_RFC2253) < 0) {
  6357.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_print_ex() failed");
  6358.         goto failed;
  6359.     }

  6361.     s->len = BIO_pending(bio);
  6362.     s->data = ngx_pnalloc(pool, s->len);
  6363.     if (s->data == NULL) {
  6364.         goto failed;
  6365.     }

  6367.     BIO_read(bio, s->data, s->len);

  6369.     BIO_free(bio);
  6370.     X509_free(cert);

  6372.     return NGX_OK;

  6374. failed:

  6376.     BIO_free(bio);
  6377.     X509_free(cert);

  6379.     return NGX_ERROR;
  6380. }


  6383. ngx_int_t
  6384. ‌ngx_ssl_get_subject_dn_legacy(ngx_connection_t *c, ngx_pool_t *pool,
  6385.     ngx_str_t *s)
  6386. {
  6387.     char       *p;
  6388.     size_t      len;
  6389.     X509       *cert;
  6390. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  6391.     const
  6392. #endif
  6393.     X509_NAME  *name;

  6395.     s->len = 0;

  6397.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6398.     if (cert == NULL) {
  6399.         return NGX_OK;
  6400.     }

  6402.     name = X509_get_subject_name(cert);
  6403.     if (name == NULL) {
  6404.         X509_free(cert);
  6405.         return NGX_ERROR;
  6406.     }

  6408.     p = X509_NAME_oneline(name, NULL, 0);
  6409.     if (p == NULL) {
  6410.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_oneline() failed");
  6411.         X509_free(cert);
  6412.         return NGX_ERROR;
  6413.     }

  6415.     for (len = 0; p[len]; len++) { /* void */ }

  6417.     s->len = len;
  6418.     s->data = ngx_pnalloc(pool, len);
  6419.     if (s->data == NULL) {
  6420.         OPENSSL_free(p);
  6421.         X509_free(cert);
  6422.         return NGX_ERROR;
  6423.     }

  6425.     ngx_memcpy(s->data, p, len);

  6427.     OPENSSL_free(p);
  6428.     X509_free(cert);

  6430.     return NGX_OK;
  6431. }


  6434. ngx_int_t
  6435. ‌ngx_ssl_get_issuer_dn_legacy(ngx_connection_t *c, ngx_pool_t *pool,
  6436.     ngx_str_t *s)
  6437. {
  6438.     char       *p;
  6439.     size_t      len;
  6440.     X509       *cert;
  6441. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  6442.     const
  6443. #endif
  6444.     X509_NAME  *name;

  6446.     s->len = 0;

  6448.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6449.     if (cert == NULL) {
  6450.         return NGX_OK;
  6451.     }

  6453.     name = X509_get_issuer_name(cert);
  6454.     if (name == NULL) {
  6455.         X509_free(cert);
  6456.         return NGX_ERROR;
  6457.     }

  6459.     p = X509_NAME_oneline(name, NULL, 0);
  6460.     if (p == NULL) {
  6461.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_oneline() failed");
  6462.         X509_free(cert);
  6463.         return NGX_ERROR;
  6464.     }

  6466.     for (len = 0; p[len]; len++) { /* void */ }

  6468.     s->len = len;
  6469.     s->data = ngx_pnalloc(pool, len);
  6470.     if (s->data == NULL) {
  6471.         OPENSSL_free(p);
  6472.         X509_free(cert);
  6473.         return NGX_ERROR;
  6474.     }

  6476.     ngx_memcpy(s->data, p, len);

  6478.     OPENSSL_free(p);
  6479.     X509_free(cert);

  6481.     return NGX_OK;
  6482. }


  6485. ngx_int_t
  6486. ‌ngx_ssl_get_serial_number(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6487. {
  6488.     size_t   len;
  6489.     X509    *cert;
  6490.     BIO     *bio;

  6492.     s->len = 0;

  6494.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6495.     if (cert == NULL) {
  6496.         return NGX_OK;
  6497.     }

  6499.     bio = BIO_new(BIO_s_mem());
  6500.     if (bio == NULL) {
  6501.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6502.         X509_free(cert);
  6503.         return NGX_ERROR;
  6504.     }

  6506.     i2a_ASN1_INTEGER(bio, X509_get_serialNumber(cert));
  6507.     len = BIO_pending(bio);

  6509.     s->len = len;
  6510.     s->data = ngx_pnalloc(pool, len);
  6511.     if (s->data == NULL) {
  6512.         BIO_free(bio);
  6513.         X509_free(cert);
  6514.         return NGX_ERROR;
  6515.     }

  6517.     BIO_read(bio, s->data, len);
  6518.     BIO_free(bio);
  6519.     X509_free(cert);

  6521.     return NGX_OK;
  6522. }


  6525. ngx_int_t
  6526. ‌ngx_ssl_get_fingerprint(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6527. {
  6528.     X509          *cert;
  6529.     unsigned int   len;
  6530.     u_char         buf[EVP_MAX_MD_SIZE];

  6532.     s->len = 0;

  6534.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6535.     if (cert == NULL) {
  6536.         return NGX_OK;
  6537.     }

  6539.     if (!X509_digest(cert, EVP_sha1(), buf, &len)) {
  6540.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_digest() failed");
  6541.         X509_free(cert);
  6542.         return NGX_ERROR;
  6543.     }

  6545.     s->len = 2 * len;
  6546.     s->data = ngx_pnalloc(pool, 2 * len);
  6547.     if (s->data == NULL) {
  6548.         X509_free(cert);
  6549.         return NGX_ERROR;
  6550.     }

  6552.     ngx_hex_dump(s->data, buf, len);

  6554.     X509_free(cert);

  6556.     return NGX_OK;
  6557. }


  6560. ngx_int_t
  6561. ‌ngx_ssl_get_client_verify(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6562. {
  6563.     X509        *cert;
  6564.     long         rc;
  6565.     const char  *str;

  6567.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6568.     if (cert == NULL) {
  6569.         ngx_str_set(s, "NONE");
  6570.         return NGX_OK;
  6571.     }

  6573.     X509_free(cert);

  6575.     rc = SSL_get_verify_result(c->ssl->connection);

  6577.     if (rc == X509_V_OK) {
  6578.         if (ngx_ssl_ocsp_get_status(c, &str) == NGX_OK) {
  6579.             ngx_str_set(s, "SUCCESS");
  6580.             return NGX_OK;
  6581.         }

  6583.     } else {
  6584.         str = X509_verify_cert_error_string(rc);
  6585.     }

  6587.     s->data = ngx_pnalloc(pool, sizeof("FAILED:") - 1 + ngx_strlen(str));
  6588.     if (s->data == NULL) {
  6589.         return NGX_ERROR;
  6590.     }

  6592.     s->len = ngx_sprintf(s->data, "FAILED:%s", str) - s->data;

  6594.     return NGX_OK;
  6595. }


  6598. ngx_int_t
  6599. ‌ngx_ssl_get_client_v_start(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6600. {
  6601.     BIO     *bio;
  6602.     X509    *cert;
  6603.     size_t   len;

  6605.     s->len = 0;

  6607.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6608.     if (cert == NULL) {
  6609.         return NGX_OK;
  6610.     }

  6612.     bio = BIO_new(BIO_s_mem());
  6613.     if (bio == NULL) {
  6614.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6615.         X509_free(cert);
  6616.         return NGX_ERROR;
  6617.     }

  6619. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  6620.     ASN1_TIME_print(bio, X509_get0_notBefore(cert));
  6621. #else
  6622.     ASN1_TIME_print(bio, X509_get_notBefore(cert));
  6623. #endif

  6625.     len = BIO_pending(bio);

  6627.     s->len = len;
  6628.     s->data = ngx_pnalloc(pool, len);
  6629.     if (s->data == NULL) {
  6630.         BIO_free(bio);
  6631.         X509_free(cert);
  6632.         return NGX_ERROR;
  6633.     }

  6635.     BIO_read(bio, s->data, len);
  6636.     BIO_free(bio);
  6637.     X509_free(cert);

  6639.     return NGX_OK;
  6640. }


  6643. ngx_int_t
  6644. ‌ngx_ssl_get_client_v_end(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6645. {
  6646.     BIO     *bio;
  6647.     X509    *cert;
  6648.     size_t   len;

  6650.     s->len = 0;

  6652.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6653.     if (cert == NULL) {
  6654.         return NGX_OK;
  6655.     }

  6657.     bio = BIO_new(BIO_s_mem());
  6658.     if (bio == NULL) {
  6659.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6660.         X509_free(cert);
  6661.         return NGX_ERROR;
  6662.     }

  6664. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  6665.     ASN1_TIME_print(bio, X509_get0_notAfter(cert));
  6666. #else
  6667.     ASN1_TIME_print(bio, X509_get_notAfter(cert));
  6668. #endif

  6670.     len = BIO_pending(bio);

  6672.     s->len = len;
  6673.     s->data = ngx_pnalloc(pool, len);
  6674.     if (s->data == NULL) {
  6675.         BIO_free(bio);
  6676.         X509_free(cert);
  6677.         return NGX_ERROR;
  6678.     }

  6680.     BIO_read(bio, s->data, len);
  6681.     BIO_free(bio);
  6682.     X509_free(cert);

  6684.     return NGX_OK;
  6685. }


  6688. ngx_int_t
  6689. ‌ngx_ssl_get_client_v_remain(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6690. {
  6691.     X509    *cert;
  6692.     time_t   now, end;

  6694.     s->len = 0;

  6696.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6697.     if (cert == NULL) {
  6698.         return NGX_OK;
  6699.     }

  6701. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  6702.     end = ngx_ssl_parse_time(X509_get0_notAfter(cert), c->log);
  6703. #else
  6704.     end = ngx_ssl_parse_time(X509_get_notAfter(cert), c->log);
  6705. #endif

  6707.     if (end == (time_t) NGX_ERROR) {
  6708.         X509_free(cert);
  6709.         return NGX_OK;
  6710.     }

  6712.     now = ngx_time();

  6714.     if (end < now + 86400) {
  6715.         ngx_str_set(s, "0");
  6716.         X509_free(cert);
  6717.         return NGX_OK;
  6718.     }

  6720.     s->data = ngx_pnalloc(pool, NGX_TIME_T_LEN);
  6721.     if (s->data == NULL) {
  6722.         X509_free(cert);
  6723.         return NGX_ERROR;
  6724.     }

  6726.     s->len = ngx_sprintf(s->data, "%T", (end - now) / 86400) - s->data;

  6728.     X509_free(cert);

  6730.     return NGX_OK;
  6731. }


  6734. static time_t
  6735. ‌ngx_ssl_parse_time(
  6736. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  6737.     const
  6738. #endif
  6739.     ASN1_TIME *asn1time, ngx_log_t *log)
  6740. {
  6741.     BIO     *bio;
  6742.     char    *value;
  6743.     size_t   len;
  6744.     time_t   time;

  6746.     /*
  6747.      * OpenSSL doesn't provide a way to convert ASN1_TIME
  6748.      * into time_t.  To do this, we use ASN1_TIME_print(),
  6749.      * which uses the "MMM DD HH:MM:SS YYYY [GMT]" format (e.g.,
  6750.      * "Feb  3 00:55:52 2015 GMT"), and parse the result.
  6751.      */

  6753.     bio = BIO_new(BIO_s_mem());
  6754.     if (bio == NULL) {
  6755.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "BIO_new() failed");
  6756.         return NGX_ERROR;
  6757.     }

  6759.     /* fake weekday prepended to match C asctime() format */

  6761.     BIO_write(bio, "Tue ", sizeof("Tue ") - 1);
  6762.     ASN1_TIME_print(bio, asn1time);
  6763.     len = BIO_get_mem_data(bio, &value);

  6765.     time = ngx_parse_http_time((u_char *) value, len);

  6767.     BIO_free(bio);

  6769.     return time;
  6770. }


  6773. ngx_int_t
  6774. ‌ngx_ssl_get_client_sigalg(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6775. {
  6776. #ifdef SSL_get0_peer_signature_name

  6778.     const char  *name;

  6780.     if (SSL_get0_peer_signature_name(c->ssl->connection, &name)) {
  6781.         s->len = ngx_strlen(name);
  6782.         s->data = ngx_pnalloc(pool, s->len);
  6783.         if (s->data == NULL) {
  6784.             return NGX_ERROR;
  6785.         }

  6787.         ngx_memcpy(s->data, name, s->len);

  6789.         return NGX_OK;
  6790.     }

  6792. #endif

  6794.     s->len = 0;
  6795.     return NGX_OK;
  6796. }


  6799. static void *
  6800. ‌ngx_openssl_create_conf(ngx_cycle_t *cycle)
  6801. {
  6802.     ngx_openssl_conf_t  *oscf;

  6804.     oscf = ngx_pcalloc(cycle->pool, sizeof(ngx_openssl_conf_t));
  6805.     if (oscf == NULL) {
  6806.         return NULL;
  6807.     }

  6809.     /*
  6810.      * set by ngx_pcalloc():
  6811.      *
  6812.      *     oscf->engine = 0;
  6813.      */

  6815.     return oscf;
  6816. }


  6819. static char *
  6820. ‌ngx_openssl_engine(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  6821. {
  6822. #ifndef OPENSSL_NO_ENGINE

  6824.     ngx_openssl_conf_t *oscf = conf;

  6826.     ENGINE     *engine;
  6827.     ngx_str_t  *value;

  6829.     if (oscf->engine) {
  6830.         return "is duplicate";
  6831.     }

  6833.     oscf->engine = 1;

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

  6837.     engine = ENGINE_by_id((char *) value[1].data);

  6839.     if (engine == NULL) {
  6840.         ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
  6841.                       "ENGINE_by_id(\"%V\") failed", &value[1]);
  6842.         return NGX_CONF_ERROR;
  6843.     }

  6845.     if (ENGINE_set_default(engine, ENGINE_METHOD_ALL) == 0) {
  6846.         ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
  6847.                       "ENGINE_set_default(\"%V\", ENGINE_METHOD_ALL) failed",
  6848.                       &value[1]);

  6850.         ENGINE_free(engine);

  6852.         return NGX_CONF_ERROR;
  6853.     }

  6855.     ENGINE_free(engine);

  6857.     return NGX_CONF_OK;

  6859. #else

  6861.     return "is not supported";

  6863. #endif
  6864. }


  6867. static void
  6868. ‌ngx_openssl_exit(ngx_cycle_t *cycle)
  6869. {
  6870. #if OPENSSL_VERSION_NUMBER < 0x10100003L

  6872.     EVP_cleanup();
  6873. #ifndef OPENSSL_NO_ENGINE
  6874.     ENGINE_cleanup();
  6875. #endif

  6877. #endif
  6878. }

One Level Up Top Level