One Level Up Top Level

src/event/ngx_event_openssl.c - nginx-1.31.3 nginx/ @ 42f8df65b

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


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


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_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(%s) 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.     c->ssl->no_wait_shutdown = 1;
  2323.     c->ssl->no_send_shutdown = 1;
  2324.     c->read->eof = 1;

  2326.     if (sslerr == SSL_ERROR_ZERO_RETURN || ERR_peek_error() == 0) {
  2327.         ngx_connection_error(c, err,
  2328.                              "peer closed connection in SSL handshake");

  2330.         return NGX_ERROR;
  2331.     }

  2333.     if (c->ssl->handshake_rejected) {
  2334.         ngx_connection_error(c, err, "handshake rejected");
  2335.         ERR_clear_error();

  2337.         return NGX_ERROR;
  2338.     }

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

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

  2344.     return NGX_ERROR;
  2345. }


  2348. #ifdef SSL_READ_EARLY_DATA_SUCCESS

  2350. static ngx_int_t
  2351. ‌ngx_ssl_try_early_data(ngx_connection_t *c)
  2352. {
  2353.     int        n, sslerr;
  2354.     u_char     buf;
  2355.     size_t     readbytes;
  2356.     ngx_err_t  err;
  2357.     ngx_int_t  rc;

  2359.     ngx_ssl_clear_error(c->log);

  2361.     readbytes = 0;

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

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

  2368.     if (n == SSL_READ_EARLY_DATA_FINISH) {
  2369.         c->ssl->try_early_data = 0;
  2370.         return ngx_ssl_handshake(c);
  2371.     }

  2373.     if (n == SSL_READ_EARLY_DATA_SUCCESS) {

  2375.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2376.             return NGX_ERROR;
  2377.         }

  2379.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2380.             return NGX_ERROR;
  2381.         }

  2383. #if (NGX_DEBUG)
  2384.         ngx_ssl_handshake_log(c);
  2385. #endif

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

  2389.         c->ssl->early_buf = buf;
  2390.         c->ssl->early_preread = 1;

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

  2394.         c->recv = ngx_ssl_recv;
  2395.         c->send = ngx_ssl_write;
  2396.         c->recv_chain = ngx_ssl_recv_chain;
  2397.         c->send_chain = ngx_ssl_send_chain;

  2399.         c->read->ready = 1;
  2400.         c->write->ready = 1;

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

  2404.         if (BIO_get_ktls_send(SSL_get_wbio(c->ssl->connection)) == 1) {
  2405.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2406.                            "BIO_get_ktls_send(): 1");
  2407.             c->ssl->sendfile = 1;
  2408.         }

  2410. #endif

  2412.         rc = ngx_ssl_ocsp_validate(c);

  2414.         if (rc == NGX_ERROR) {
  2415.             return NGX_ERROR;
  2416.         }

  2418.         if (rc == NGX_AGAIN) {
  2419.             c->read->handler = ngx_ssl_handshake_handler;
  2420.             c->write->handler = ngx_ssl_handshake_handler;
  2421.             return NGX_AGAIN;
  2422.         }

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

  2426.         return NGX_OK;
  2427.     }

  2429.     /* SSL_READ_EARLY_DATA_ERROR */

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

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

  2435.     if (sslerr == SSL_ERROR_WANT_READ) {
  2436.         c->read->ready = 0;
  2437.         c->read->handler = ngx_ssl_handshake_handler;
  2438.         c->write->handler = ngx_ssl_handshake_handler;

  2440.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2441.             return NGX_ERROR;
  2442.         }

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

  2448.         return NGX_AGAIN;
  2449.     }

  2451.     if (sslerr == SSL_ERROR_WANT_WRITE) {
  2452.         c->write->ready = 0;
  2453.         c->read->handler = ngx_ssl_handshake_handler;
  2454.         c->write->handler = ngx_ssl_handshake_handler;

  2456.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2457.             return NGX_ERROR;
  2458.         }

  2460.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2461.             return NGX_ERROR;
  2462.         }

  2464.         return NGX_AGAIN;
  2465.     }

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

  2469.     c->ssl->no_wait_shutdown = 1;
  2470.     c->ssl->no_send_shutdown = 1;
  2471.     c->read->eof = 1;

  2473.     if (sslerr == SSL_ERROR_ZERO_RETURN || ERR_peek_error() == 0) {
  2474.         ngx_connection_error(c, err,
  2475.                              "peer closed connection in SSL handshake");

  2477.         return NGX_ERROR;
  2478.     }

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

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

  2484.     return NGX_ERROR;
  2485. }

  2487. #endif


  2490. #if (NGX_DEBUG)

  2492. void
  2493. ‌ngx_ssl_handshake_log(ngx_connection_t *c)
  2494. {
  2495.     char         buf[129], *s, *d;
  2496. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  2497.     const
  2498. #endif
  2499.     SSL_CIPHER  *cipher;

  2501.     if (!(c->log->log_level & NGX_LOG_DEBUG_EVENT)) {
  2502.         return;
  2503.     }

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

  2507.     if (cipher) {
  2508.         SSL_CIPHER_description(cipher, &buf[1], 128);

  2510.         for (s = &buf[1], d = buf; *s; s++) {
  2511.             if (*s == ' ' && *d == ' ') {
  2512.                 continue;
  2513.             }

  2515.             if (*s == LF || *s == CR) {
  2516.                 continue;
  2517.             }

  2519.             *++d = *s;
  2520.         }

  2522.         if (*d != ' ') {
  2523.             d++;
  2524.         }

  2526.         *d = '\0';

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

  2532.         if (SSL_session_reused(c->ssl->connection)) {
  2533.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2534.                            "SSL reused session");
  2535.         }

  2537.     } else {
  2538.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2539.                        "SSL no shared ciphers");
  2540.     }
  2541. }

  2543. #endif


  2546. static void
  2547. ‌ngx_ssl_handshake_handler(ngx_event_t *ev)
  2548. {
  2549.     ngx_connection_t  *c;

  2551.     c = ev->data;

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

  2556.     if (ev->timedout) {
  2557.         c->ssl->handler(c);
  2558.         return;
  2559.     }

  2561.     if (ngx_ssl_handshake(c) == NGX_AGAIN) {
  2562.         return;
  2563.     }

  2565.     c->ssl->handler(c);
  2566. }


  2569. ssize_t
  2570. ‌ngx_ssl_recv_chain(ngx_connection_t *c, ngx_chain_t *cl, off_t limit)
  2571. {
  2572.     u_char     *last;
  2573.     ssize_t     n, bytes, size;
  2574.     ngx_buf_t  *b;

  2576.     bytes = 0;

  2578.     b = cl->buf;
  2579.     last = b->last;

  2581.     for ( ;; ) {
  2582.         size = b->end - last;

  2584.         if (limit) {
  2585.             if (bytes >= limit) {
  2586.                 return bytes;
  2587.             }

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

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

  2596.         if (n > 0) {
  2597.             last += n;
  2598.             bytes += n;

  2600.             if (!c->read->ready) {
  2601.                 return bytes;
  2602.             }

  2604.             if (last == b->end) {
  2605.                 cl = cl->next;

  2607.                 if (cl == NULL) {
  2608.                     return bytes;
  2609.                 }

  2611.                 b = cl->buf;
  2612.                 last = b->last;
  2613.             }

  2615.             continue;
  2616.         }

  2618.         if (bytes) {

  2620.             if (n == 0 || n == NGX_ERROR) {
  2621.                 c->read->ready = 1;
  2622.             }

  2624.             return bytes;
  2625.         }

  2627.         return n;
  2628.     }
  2629. }


  2632. ssize_t
  2633. ‌ngx_ssl_recv(ngx_connection_t *c, u_char *buf, size_t size)
  2634. {
  2635.     int  n, bytes;

  2637. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  2638.     if (c->ssl->in_early) {
  2639.         return ngx_ssl_recv_early(c, buf, size);
  2640.     }
  2641. #endif

  2643.     if (c->ssl->last == NGX_ERROR) {
  2644.         c->read->ready = 0;
  2645.         c->read->error = 1;
  2646.         return NGX_ERROR;
  2647.     }

  2649.     if (c->ssl->last == NGX_DONE) {
  2650.         c->read->ready = 0;
  2651.         c->read->eof = 1;
  2652.         return 0;
  2653.     }

  2655.     bytes = 0;

  2657.     ngx_ssl_clear_error(c->log);

  2659.     /*
  2660.      * SSL_read() may return data in parts, so try to read
  2661.      * until SSL_read() would return no data
  2662.      */

  2664.     for ( ;; ) {

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

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

  2670.         if (n > 0) {
  2671.             bytes += n;
  2672.         }

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

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

  2678.             size -= n;

  2680.             if (size == 0) {
  2681.                 c->read->ready = 1;

  2683.                 if (c->read->available >= 0) {
  2684.                     c->read->available -= bytes;

  2686.                     /*
  2687.                      * there can be data buffered at SSL layer,
  2688.                      * so we post an event to continue reading on the next
  2689.                      * iteration of the event loop
  2690.                      */

  2692.                     if (c->read->available < 0) {
  2693.                         c->read->available = 0;
  2694.                         c->read->ready = 0;

  2696.                         if (c->read->posted) {
  2697.                             ngx_delete_posted_event(c->read);
  2698.                         }

  2700.                         ngx_post_event(c->read, &ngx_posted_next_events);
  2701.                     }

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

  2706.                 } else {

  2708. #if (NGX_HAVE_FIONREAD)

  2710.                     if (ngx_socket_nread(c->fd, &c->read->available) == -1) {
  2711.                         c->read->ready = 0;
  2712.                         c->read->error = 1;
  2713.                         ngx_connection_error(c, ngx_socket_errno,
  2714.                                              ngx_socket_nread_n " failed");
  2715.                         return NGX_ERROR;
  2716.                     }

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

  2721. #endif
  2722.                 }

  2724.                 return bytes;
  2725.             }

  2727.             buf += n;

  2729.             continue;
  2730.         }

  2732.         if (bytes) {
  2733.             if (c->ssl->last != NGX_AGAIN) {
  2734.                 c->read->ready = 1;
  2735.             }

  2737.             return bytes;
  2738.         }

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

  2742.         case NGX_DONE:
  2743.             c->read->ready = 0;
  2744.             c->read->eof = 1;
  2745.             return 0;

  2747.         case NGX_ERROR:
  2748.             c->read->ready = 0;
  2749.             c->read->error = 1;

  2751.             /* fall through */

  2753.         case NGX_AGAIN:
  2754.             return c->ssl->last;
  2755.         }
  2756.     }
  2757. }


  2760. #ifdef SSL_READ_EARLY_DATA_SUCCESS

  2762. static ssize_t
  2763. ‌ngx_ssl_recv_early(ngx_connection_t *c, u_char *buf, size_t size)
  2764. {
  2765.     int        n, bytes;
  2766.     size_t     readbytes;

  2768.     if (c->ssl->last == NGX_ERROR) {
  2769.         c->read->ready = 0;
  2770.         c->read->error = 1;
  2771.         return NGX_ERROR;
  2772.     }

  2774.     if (c->ssl->last == NGX_DONE) {
  2775.         c->read->ready = 0;
  2776.         c->read->eof = 1;
  2777.         return 0;
  2778.     }

  2780.     bytes = 0;

  2782.     ngx_ssl_clear_error(c->log);

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

  2786.         if (size == 0) {
  2787.             c->read->ready = 0;
  2788.             c->read->eof = 1;
  2789.             return 0;
  2790.         }

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

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

  2796.         bytes = 1;
  2797.         size -= 1;
  2798.         buf += 1;
  2799.     }

  2801.     if (c->ssl->write_blocked) {
  2802.         return NGX_AGAIN;
  2803.     }

  2805.     /*
  2806.      * SSL_read_early_data() may return data in parts, so try to read
  2807.      * until SSL_read_early_data() would return no data
  2808.      */

  2810.     for ( ;; ) {

  2812.         readbytes = 0;

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

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

  2819.         if (n == SSL_READ_EARLY_DATA_SUCCESS) {

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

  2823.             bytes += readbytes;
  2824.             size -= readbytes;

  2826.             if (size == 0) {
  2827.                 c->read->ready = 1;
  2828.                 return bytes;
  2829.             }

  2831.             buf += readbytes;

  2833.             continue;
  2834.         }

  2836.         if (n == SSL_READ_EARLY_DATA_FINISH) {

  2838.             c->ssl->last = ngx_ssl_handle_recv(c, 1);
  2839.             c->ssl->in_early = 0;

  2841.             if (bytes) {
  2842.                 c->read->ready = 1;
  2843.                 return bytes;
  2844.             }

  2846.             return ngx_ssl_recv(c, buf, size);
  2847.         }

  2849.         /* SSL_READ_EARLY_DATA_ERROR */

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

  2853.         if (bytes) {
  2854.             if (c->ssl->last != NGX_AGAIN) {
  2855.                 c->read->ready = 1;
  2856.             }

  2858.             return bytes;
  2859.         }

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

  2863.         case NGX_DONE:
  2864.             c->read->ready = 0;
  2865.             c->read->eof = 1;
  2866.             return 0;

  2868.         case NGX_ERROR:
  2869.             c->read->ready = 0;
  2870.             c->read->error = 1;

  2872.             /* fall through */

  2874.         case NGX_AGAIN:
  2875.             return c->ssl->last;
  2876.         }
  2877.     }
  2878. }

  2880. #endif


  2883. static ngx_int_t
  2884. ‌ngx_ssl_handle_recv(ngx_connection_t *c, int n)
  2885. {
  2886.     int        sslerr;
  2887.     ngx_err_t  err;

  2889. #if (!defined SSL_OP_NO_RENEGOTIATION                                         \
  2890.      && !defined SSL_OP_NO_CLIENT_RENEGOTIATION)

  2892.     if (c->ssl->renegotiation) {
  2893.         /*
  2894.          * disable renegotiation (CVE-2009-3555):
  2895.          * OpenSSL (at least up to 0.9.8l) does not handle disabled
  2896.          * renegotiation gracefully, so drop connection here
  2897.          */

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

  2901.         while (ERR_peek_error()) {
  2902.             ngx_ssl_error(NGX_LOG_DEBUG, c->log, 0,
  2903.                           "ignoring stale global SSL error");
  2904.         }

  2906.         ERR_clear_error();

  2908.         c->ssl->no_wait_shutdown = 1;
  2909.         c->ssl->no_send_shutdown = 1;

  2911.         return NGX_ERROR;
  2912.     }

  2914. #endif

  2916.     if (n > 0) {

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

  2920.             c->write->handler = c->ssl->saved_write_handler;
  2921.             c->ssl->saved_write_handler = NULL;
  2922.             c->write->ready = 1;

  2924.             if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2925.                 return NGX_ERROR;
  2926.             }

  2928.             ngx_post_event(c->write, &ngx_posted_events);
  2929.         }

  2931.         return NGX_OK;
  2932.     }

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

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

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

  2940.     if (sslerr == SSL_ERROR_WANT_READ) {

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

  2944.             c->write->handler = c->ssl->saved_write_handler;
  2945.             c->ssl->saved_write_handler = NULL;
  2946.             c->write->ready = 1;

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

  2952.             ngx_post_event(c->write, &ngx_posted_events);
  2953.         }

  2955.         c->read->ready = 0;
  2956.         return NGX_AGAIN;
  2957.     }

  2959.     if (sslerr == SSL_ERROR_WANT_WRITE) {

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

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

  2966.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2967.             return NGX_ERROR;
  2968.         }

  2970.         /*
  2971.          * we do not set the timer because there is already the read event timer
  2972.          */

  2974.         if (c->ssl->saved_write_handler == NULL) {
  2975.             c->ssl->saved_write_handler = c->write->handler;
  2976.             c->write->handler = ngx_ssl_write_handler;
  2977.         }

  2979.         return NGX_AGAIN;
  2980.     }

  2982.     c->ssl->no_wait_shutdown = 1;
  2983.     c->ssl->no_send_shutdown = 1;

  2985.     if (sslerr == SSL_ERROR_ZERO_RETURN || ERR_peek_error() == 0) {
  2986.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  2987.                        "peer shutdown SSL cleanly");
  2988.         return NGX_DONE;
  2989.     }

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

  2993.     return NGX_ERROR;
  2994. }


  2997. static void
  2998. ‌ngx_ssl_write_handler(ngx_event_t *wev)
  2999. {
  3000.     ngx_connection_t  *c;

  3002.     c = wev->data;

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

  3006.     c->read->handler(c->read);
  3007. }


  3010. /*
  3011. * OpenSSL has no SSL_writev() so we copy several bufs into our 16K buffer
  3012. * before the SSL_write() call to decrease a SSL overhead.
  3013. *
  3014. * Besides for protocols such as HTTP it is possible to always buffer
  3015. * the output to decrease a SSL overhead some more.
  3016. */

  3018. ngx_chain_t *
  3019. ‌ngx_ssl_send_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
  3020. {
  3021.     int           n;
  3022.     ngx_uint_t    flush;
  3023.     ssize_t       send, size, file_size;
  3024.     ngx_buf_t    *buf;
  3025.     ngx_chain_t  *cl;

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

  3029.         while (in) {
  3030.             if (ngx_buf_special(in->buf)) {
  3031.                 in = in->next;
  3032.                 continue;
  3033.             }

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

  3037.             if (n == NGX_ERROR) {
  3038.                 return NGX_CHAIN_ERROR;
  3039.             }

  3041.             if (n == NGX_AGAIN) {
  3042.                 return in;
  3043.             }

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

  3047.             if (in->buf->pos == in->buf->last) {
  3048.                 in = in->next;
  3049.             }
  3050.         }

  3052.         return in;
  3053.     }


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

  3058.     if (limit == 0 || limit > (off_t) (NGX_MAX_INT32_VALUE - ngx_pagesize)) {
  3059.         limit = NGX_MAX_INT32_VALUE - ngx_pagesize;
  3060.     }

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

  3064.     if (buf == NULL) {
  3065.         buf = ngx_create_temp_buf(c->pool, c->ssl->buffer_size);
  3066.         if (buf == NULL) {
  3067.             return NGX_CHAIN_ERROR;
  3068.         }

  3070.         c->ssl->buf = buf;
  3071.     }

  3073.     if (buf->start == NULL) {
  3074.         buf->start = ngx_palloc(c->pool, c->ssl->buffer_size);
  3075.         if (buf->start == NULL) {
  3076.             return NGX_CHAIN_ERROR;
  3077.         }

  3079.         buf->pos = buf->start;
  3080.         buf->last = buf->start;
  3081.         buf->end = buf->start + c->ssl->buffer_size;
  3082.     }

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

  3087.     for ( ;; ) {

  3089.         while (in && buf->last < buf->end && send < limit) {
  3090.             if (in->buf->last_buf || in->buf->flush) {
  3091.                 flush = 1;
  3092.             }

  3094.             if (ngx_buf_special(in->buf)) {
  3095.                 in = in->next;
  3096.                 continue;
  3097.             }

  3099.             if (in->buf->in_file && c->ssl->sendfile) {
  3100.                 flush = 1;
  3101.                 break;
  3102.             }

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

  3106.             if (size > buf->end - buf->last) {
  3107.                 size = buf->end - buf->last;
  3108.             }

  3110.             if (send + size > limit) {
  3111.                 size = (ssize_t) (limit - send);
  3112.             }

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

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

  3119.             buf->last += size;
  3120.             in->buf->pos += size;
  3121.             send += size;

  3123.             if (in->buf->pos == in->buf->last) {
  3124.                 in = in->next;
  3125.             }
  3126.         }

  3128.         if (!flush && send < limit && buf->last < buf->end) {
  3129.             break;
  3130.         }

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

  3134.         if (size == 0) {

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

  3138.                 /* coalesce the neighbouring file bufs */

  3140.                 cl = in;
  3141.                 file_size = (size_t) ngx_chain_coalesce_file(&cl, limit - send);

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

  3145.                 if (n == NGX_ERROR) {
  3146.                     return NGX_CHAIN_ERROR;
  3147.                 }

  3149.                 if (n == NGX_AGAIN) {
  3150.                     break;
  3151.                 }

  3153.                 in = ngx_chain_update_sent(in, n);

  3155.                 send += n;
  3156.                 flush = 0;

  3158.                 continue;
  3159.             }

  3161.             buf->flush = 0;
  3162.             c->buffered &= ~NGX_SSL_BUFFERED;

  3164.             return in;
  3165.         }

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

  3169.         if (n == NGX_ERROR) {
  3170.             return NGX_CHAIN_ERROR;
  3171.         }

  3173.         if (n == NGX_AGAIN) {
  3174.             break;
  3175.         }

  3177.         buf->pos += n;

  3179.         if (n < size) {
  3180.             break;
  3181.         }

  3183.         flush = 0;

  3185.         buf->pos = buf->start;
  3186.         buf->last = buf->start;

  3188.         if (in == NULL || send >= limit) {
  3189.             break;
  3190.         }
  3191.     }

  3193.     buf->flush = flush;

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

  3198.     } else {
  3199.         c->buffered &= ~NGX_SSL_BUFFERED;
  3200.     }

  3202.     return in;
  3203. }


  3206. ssize_t
  3207. ‌ngx_ssl_write(ngx_connection_t *c, u_char *data, size_t size)
  3208. {
  3209.     int        n, sslerr;
  3210.     ngx_err_t  err;

  3212. #ifdef SSL_READ_EARLY_DATA_SUCCESS
  3213.     if (c->ssl->in_early) {
  3214.         return ngx_ssl_write_early(c, data, size);
  3215.     }
  3216. #endif

  3218.     ngx_ssl_clear_error(c->log);

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

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

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

  3226.     if (n > 0) {

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

  3230.             c->read->handler = c->ssl->saved_read_handler;
  3231.             c->ssl->saved_read_handler = NULL;
  3232.             c->read->ready = 1;

  3234.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3235.                 return NGX_ERROR;
  3236.             }

  3238.             ngx_post_event(c->read, &ngx_posted_events);
  3239.         }

  3241.         c->sent += n;

  3243.         return n;
  3244.     }

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

  3248.     if (sslerr == SSL_ERROR_ZERO_RETURN) {

  3250.         /*
  3251.          * OpenSSL 1.1.1 fails to return SSL_ERROR_SYSCALL if an error
  3252.          * happens during SSL_write() after close_notify alert from the
  3253.          * peer, and returns SSL_ERROR_ZERO_RETURN instead,
  3254.          * see https://github.com/openssl/openssl/commit/8051ab2
  3255.          */

  3257.         sslerr = SSL_ERROR_SYSCALL;
  3258.     }

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

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

  3264.     if (sslerr == SSL_ERROR_WANT_WRITE) {

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

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

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

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

  3279.         c->write->ready = 0;
  3280.         return NGX_AGAIN;
  3281.     }

  3283.     if (sslerr == SSL_ERROR_WANT_READ) {

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

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

  3290.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3291.             return NGX_ERROR;
  3292.         }

  3294.         /*
  3295.          * we do not set the timer because there is already
  3296.          * the write event timer
  3297.          */

  3299.         if (c->ssl->saved_read_handler == NULL) {
  3300.             c->ssl->saved_read_handler = c->read->handler;
  3301.             c->read->handler = ngx_ssl_read_handler;
  3302.         }

  3304.         return NGX_AGAIN;
  3305.     }

  3307.     c->ssl->no_wait_shutdown = 1;
  3308.     c->ssl->no_send_shutdown = 1;
  3309.     c->write->error = 1;

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

  3313.     return NGX_ERROR;
  3314. }


  3317. #ifdef SSL_READ_EARLY_DATA_SUCCESS

  3319. static ssize_t
  3320. ‌ngx_ssl_write_early(ngx_connection_t *c, u_char *data, size_t size)
  3321. {
  3322.     int        n, sslerr;
  3323.     size_t     written;
  3324.     ngx_err_t  err;

  3326.     ngx_ssl_clear_error(c->log);

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

  3330.     written = 0;

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

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

  3337.     if (n > 0) {

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

  3341.             c->read->handler = c->ssl->saved_read_handler;
  3342.             c->ssl->saved_read_handler = NULL;
  3343.             c->read->ready = 1;

  3345.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3346.                 return NGX_ERROR;
  3347.             }

  3349.             ngx_post_event(c->read, &ngx_posted_events);
  3350.         }

  3352.         if (c->ssl->write_blocked) {
  3353.             c->ssl->write_blocked = 0;
  3354.             ngx_post_event(c->read, &ngx_posted_events);
  3355.         }

  3357.         c->sent += written;

  3359.         return written;
  3360.     }

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

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

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

  3368.     if (sslerr == SSL_ERROR_WANT_WRITE) {

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

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

  3375.             c->read->handler = c->ssl->saved_read_handler;
  3376.             c->ssl->saved_read_handler = NULL;
  3377.             c->read->ready = 1;

  3379.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3380.                 return NGX_ERROR;
  3381.             }

  3383.             ngx_post_event(c->read, &ngx_posted_events);
  3384.         }

  3386.         /*
  3387.          * OpenSSL 1.1.1a fails to handle SSL_read_early_data()
  3388.          * if an SSL_write_early_data() call blocked on writing,
  3389.          * see https://github.com/openssl/openssl/issues/7757
  3390.          */

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

  3394.         c->write->ready = 0;
  3395.         return NGX_AGAIN;
  3396.     }

  3398.     if (sslerr == SSL_ERROR_WANT_READ) {

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

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

  3405.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3406.             return NGX_ERROR;
  3407.         }

  3409.         /*
  3410.          * we do not set the timer because there is already
  3411.          * the write event timer
  3412.          */

  3414.         if (c->ssl->saved_read_handler == NULL) {
  3415.             c->ssl->saved_read_handler = c->read->handler;
  3416.             c->read->handler = ngx_ssl_read_handler;
  3417.         }

  3419.         return NGX_AGAIN;
  3420.     }

  3422.     c->ssl->no_wait_shutdown = 1;
  3423.     c->ssl->no_send_shutdown = 1;
  3424.     c->write->error = 1;

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

  3428.     return NGX_ERROR;
  3429. }

  3431. #endif


  3434. static ssize_t
  3435. ‌ngx_ssl_sendfile(ngx_connection_t *c, ngx_buf_t *file, size_t size)
  3436. {
  3437. #if (defined BIO_get_ktls_send && !NGX_WIN32)

  3439.     int        sslerr, flags;
  3440.     ssize_t    n;
  3441.     ngx_err_t  err;

  3443.     ngx_ssl_clear_error(c->log);

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

  3449.     ngx_set_errno(0);

  3451. #if (NGX_HAVE_SENDFILE_NODISKIO)

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

  3455.     if (file->file->directio) {
  3456.         flags |= SF_NOCACHE;
  3457.     }

  3459. #else
  3460.     flags = 0;
  3461. #endif

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

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

  3468.     if (n > 0) {

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

  3472.             c->read->handler = c->ssl->saved_read_handler;
  3473.             c->ssl->saved_read_handler = NULL;
  3474.             c->read->ready = 1;

  3476.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3477.                 return NGX_ERROR;
  3478.             }

  3480.             ngx_post_event(c->read, &ngx_posted_events);
  3481.         }

  3483. #if (NGX_HAVE_SENDFILE_NODISKIO)
  3484.         c->busy_count = 0;
  3485. #endif

  3487.         c->sent += n;

  3489.         return n;
  3490.     }

  3492.     if (n == 0) {

  3494.         /*
  3495.          * if sendfile returns zero, then someone has truncated the file,
  3496.          * so the offset became beyond the end of the file
  3497.          */

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

  3503.         return NGX_ERROR;
  3504.     }

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

  3508.     if (sslerr == SSL_ERROR_ZERO_RETURN) {

  3510.         /*
  3511.          * OpenSSL fails to return SSL_ERROR_SYSCALL if an error
  3512.          * happens during writing after close_notify alert from the
  3513.          * peer, and returns SSL_ERROR_ZERO_RETURN instead
  3514.          */

  3516.         sslerr = SSL_ERROR_SYSCALL;
  3517.     }

  3519.     if (sslerr == SSL_ERROR_SSL
  3520.         && ERR_GET_REASON(ERR_peek_error()) == SSL_R_UNINITIALIZED
  3521.         && ngx_errno != 0)
  3522.     {
  3523.         /*
  3524.          * OpenSSL fails to return SSL_ERROR_SYSCALL if an error
  3525.          * happens in sendfile(), and returns SSL_ERROR_SSL with
  3526.          * SSL_R_UNINITIALIZED reason instead
  3527.          */

  3529.         sslerr = SSL_ERROR_SYSCALL;
  3530.     }

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

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

  3536.     if (sslerr == SSL_ERROR_WANT_WRITE) {

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

  3540.             c->read->handler = c->ssl->saved_read_handler;
  3541.             c->ssl->saved_read_handler = NULL;
  3542.             c->read->ready = 1;

  3544.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3545.                 return NGX_ERROR;
  3546.             }

  3548.             ngx_post_event(c->read, &ngx_posted_events);
  3549.         }

  3551. #if (NGX_HAVE_SENDFILE_NODISKIO)

  3553.         if (ngx_errno == EBUSY) {
  3554.             c->busy_count++;

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

  3559.             if (c->write->posted) {
  3560.                 ngx_delete_posted_event(c->write);
  3561.             }

  3563.             ngx_post_event(c->write, &ngx_posted_next_events);
  3564.         }

  3566. #endif

  3568.         c->write->ready = 0;
  3569.         return NGX_AGAIN;
  3570.     }

  3572.     if (sslerr == SSL_ERROR_WANT_READ) {

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

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

  3579.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3580.             return NGX_ERROR;
  3581.         }

  3583.         /*
  3584.          * we do not set the timer because there is already
  3585.          * the write event timer
  3586.          */

  3588.         if (c->ssl->saved_read_handler == NULL) {
  3589.             c->ssl->saved_read_handler = c->read->handler;
  3590.             c->read->handler = ngx_ssl_read_handler;
  3591.         }

  3593.         return NGX_AGAIN;
  3594.     }

  3596.     c->ssl->no_wait_shutdown = 1;
  3597.     c->ssl->no_send_shutdown = 1;
  3598.     c->write->error = 1;

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

  3602. #else
  3603.     ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  3604.                   "SSL_sendfile() not available");
  3605. #endif

  3607.     return NGX_ERROR;
  3608. }


  3611. static void
  3612. ‌ngx_ssl_read_handler(ngx_event_t *rev)
  3613. {
  3614.     ngx_connection_t  *c;

  3616.     c = rev->data;

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

  3620.     c->write->handler(c->write);
  3621. }


  3624. void
  3625. ‌ngx_ssl_free_buffer(ngx_connection_t *c)
  3626. {
  3627.     if (c->ssl->buf && c->ssl->buf->start) {
  3628.         if (ngx_pfree(c->pool, c->ssl->buf->start) == NGX_OK) {
  3629.             c->ssl->buf->start = NULL;
  3630.         }
  3631.     }
  3632. }


  3635. ngx_int_t
  3636. ‌ngx_ssl_shutdown(ngx_connection_t *c)
  3637. {
  3638.     int         n, sslerr, mode;
  3639.     ngx_int_t   rc;
  3640.     ngx_err_t   err;
  3641.     ngx_uint_t  tries;

  3643. #if (NGX_QUIC)
  3644.     if (c->quic) {
  3645.         /* QUIC streams inherit SSL object */
  3646.         return NGX_OK;
  3647.     }
  3648. #endif

  3650.     rc = NGX_OK;

  3652.     ngx_ssl_ocsp_cleanup(c);

  3654.     if (SSL_in_init(c->ssl->connection)) {
  3655.         /*
  3656.          * OpenSSL 1.0.2f complains if SSL_shutdown() is called during
  3657.          * an SSL handshake, while previous versions always return 0.
  3658.          * Avoid calling SSL_shutdown() if handshake wasn't completed.
  3659.          */

  3661.         goto done;
  3662.     }

  3664.     if (c->timedout || c->error || c->buffered) {
  3665.         mode = SSL_RECEIVED_SHUTDOWN|SSL_SENT_SHUTDOWN;
  3666.         SSL_set_quiet_shutdown(c->ssl->connection, 1);

  3668.     } else {
  3669.         mode = SSL_get_shutdown(c->ssl->connection);

  3671.         if (c->ssl->no_wait_shutdown) {
  3672.             mode |= SSL_RECEIVED_SHUTDOWN;
  3673.         }

  3675.         if (c->ssl->no_send_shutdown) {
  3676.             mode |= SSL_SENT_SHUTDOWN;
  3677.         }

  3679.         if (c->ssl->no_wait_shutdown && c->ssl->no_send_shutdown) {
  3680.             SSL_set_quiet_shutdown(c->ssl->connection, 1);
  3681.         }
  3682.     }

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

  3686.     ngx_ssl_clear_error(c->log);

  3688.     tries = 2;

  3690.     for ( ;; ) {

  3692.         /*
  3693.          * For bidirectional shutdown, SSL_shutdown() needs to be called
  3694.          * twice: first call sends the "close notify" alert and returns 0,
  3695.          * second call waits for the peer's "close notify" alert.
  3696.          */

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

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

  3702.         if (n == 1) {
  3703.             goto done;
  3704.         }

  3706.         if (n == 0 && tries-- > 1) {
  3707.             continue;
  3708.         }

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

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

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

  3717.         if (sslerr == SSL_ERROR_WANT_READ || sslerr == SSL_ERROR_WANT_WRITE) {
  3718.             c->read->handler = ngx_ssl_shutdown_handler;
  3719.             c->write->handler = ngx_ssl_shutdown_handler;

  3721.             if (sslerr == SSL_ERROR_WANT_READ) {
  3722.                 c->read->ready = 0;

  3724.             } else {
  3725.                 c->write->ready = 0;
  3726.             }

  3728.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  3729.                 goto failed;
  3730.             }

  3732.             if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  3733.                 goto failed;
  3734.             }

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

  3738.             return NGX_AGAIN;
  3739.         }

  3741.         if (sslerr == SSL_ERROR_ZERO_RETURN || ERR_peek_error() == 0) {
  3742.             goto done;
  3743.         }

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

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

  3749.         break;
  3750.     }

  3752. failed:

  3754.     rc = NGX_ERROR;

  3756. done:

  3758.     if (c->ssl->shutdown_without_free) {
  3759.         c->ssl->shutdown_without_free = 0;
  3760.         c->recv = ngx_recv;
  3761.         return rc;
  3762.     }

  3764.     SSL_free(c->ssl->connection);
  3765.     c->ssl = NULL;
  3766.     c->recv = ngx_recv;

  3768.     return rc;
  3769. }


  3772. static void
  3773. ‌ngx_ssl_shutdown_handler(ngx_event_t *ev)
  3774. {
  3775.     ngx_connection_t           *c;
  3776.     ngx_connection_handler_pt   handler;

  3778.     c = ev->data;
  3779.     handler = c->ssl->handler;

  3781.     if (ev->timedout) {
  3782.         c->timedout = 1;
  3783.     }

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

  3787.     if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
  3788.         return;
  3789.     }

  3791.     handler(c);
  3792. }


  3795. void
  3796. ‌ngx_ssl_connection_error(ngx_connection_t *c, int sslerr, ngx_err_t err,
  3797.     char *text)
  3798. {
  3799.     int         n;
  3800.     ngx_uint_t  level;

  3802.     level = NGX_LOG_CRIT;

  3804.     if (sslerr == SSL_ERROR_SYSCALL) {

  3806.         if (err == NGX_ECONNRESET
  3807. #if (NGX_WIN32)
  3808.             || err == NGX_ECONNABORTED
  3809. #endif
  3810.             || err == NGX_EPIPE
  3811.             || err == NGX_ENOTCONN
  3812.             || err == NGX_ETIMEDOUT
  3813.             || err == NGX_ECONNREFUSED
  3814.             || err == NGX_ENETDOWN
  3815.             || err == NGX_ENETUNREACH
  3816.             || err == NGX_EHOSTDOWN
  3817.             || err == NGX_EHOSTUNREACH)
  3818.         {
  3819.             switch (c->log_error) {

  3821.             case NGX_ERROR_IGNORE_ECONNRESET:
  3822.             case NGX_ERROR_INFO:
  3823.                 level = NGX_LOG_INFO;
  3824.                 break;

  3826.             case NGX_ERROR_ERR:
  3827.                 level = NGX_LOG_ERR;
  3828.                 break;

  3830.             default:
  3831.                 break;
  3832.             }
  3833.         }

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

  3837.         n = ERR_GET_REASON(ERR_peek_last_error());

  3839.             /* handshake failures */
  3840.         if (n == SSL_R_BAD_CHANGE_CIPHER_SPEC                        /*  103 */
  3841. #ifdef SSL_R_NO_SUITABLE_KEY_SHARE
  3842.             || n == SSL_R_NO_SUITABLE_KEY_SHARE                      /*  101 */
  3843. #endif
  3844. #ifdef SSL_R_BAD_ALERT
  3845.             || n == SSL_R_BAD_ALERT                                  /*  102 */
  3846. #endif
  3847. #ifdef SSL_R_BAD_KEY_SHARE
  3848.             || n == SSL_R_BAD_KEY_SHARE                              /*  108 */
  3849. #endif
  3850. #ifdef SSL_R_BAD_EXTENSION
  3851.             || n == SSL_R_BAD_EXTENSION                              /*  110 */
  3852. #endif
  3853.             || n == SSL_R_BAD_DIGEST_LENGTH                          /*  111 */
  3854. #ifdef SSL_R_MISSING_SIGALGS_EXTENSION
  3855.             || n == SSL_R_MISSING_SIGALGS_EXTENSION                  /*  112 */
  3856. #endif
  3857.             || n == SSL_R_BAD_PACKET_LENGTH                          /*  115 */
  3858. #ifdef SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM
  3859.             || n == SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM            /*  118 */
  3860. #endif
  3861. #ifdef SSL_R_BAD_KEY_UPDATE
  3862.             || n == SSL_R_BAD_KEY_UPDATE                             /*  122 */
  3863. #endif
  3864.             || n == SSL_R_BLOCK_CIPHER_PAD_IS_WRONG                  /*  129 */
  3865.             || n == SSL_R_CCS_RECEIVED_EARLY                         /*  133 */
  3866. #ifdef SSL_R_DECODE_ERROR
  3867.             || n == SSL_R_DECODE_ERROR                               /*  137 */
  3868. #endif
  3869. #ifdef SSL_R_DATA_BETWEEN_CCS_AND_FINISHED
  3870.             || n == SSL_R_DATA_BETWEEN_CCS_AND_FINISHED              /*  145 */
  3871. #endif
  3872.             || n == SSL_R_DATA_LENGTH_TOO_LONG                       /*  146 */
  3873.             || n == SSL_R_DIGEST_CHECK_FAILED                        /*  149 */
  3874.             || n == SSL_R_ENCRYPTED_LENGTH_TOO_LONG                  /*  150 */
  3875.             || n == SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST              /*  151 */
  3876.             || n == SSL_R_EXCESSIVE_MESSAGE_SIZE                     /*  152 */
  3877. #ifdef SSL_R_GOT_A_FIN_BEFORE_A_CCS
  3878.             || n == SSL_R_GOT_A_FIN_BEFORE_A_CCS                     /*  154 */
  3879. #endif
  3880.             || n == SSL_R_HTTPS_PROXY_REQUEST                        /*  155 */
  3881.             || n == SSL_R_HTTP_REQUEST                               /*  156 */
  3882.             || n == SSL_R_LENGTH_MISMATCH                            /*  159 */
  3883. #ifdef SSL_R_LENGTH_TOO_SHORT
  3884.             || n == SSL_R_LENGTH_TOO_SHORT                           /*  160 */
  3885. #endif
  3886. #ifdef SSL_R_NO_RENEGOTIATION
  3887.             || n == SSL_R_NO_RENEGOTIATION                           /*  182 */
  3888. #endif
  3889. #ifdef SSL_R_NO_CIPHERS_PASSED
  3890.             || n == SSL_R_NO_CIPHERS_PASSED                          /*  182 */
  3891. #endif
  3892.             || n == SSL_R_NO_CIPHERS_SPECIFIED                       /*  183 */
  3893. #ifdef SSL_R_BAD_CIPHER
  3894.             || n == SSL_R_BAD_CIPHER                                 /*  186 */
  3895. #endif
  3896.             || n == SSL_R_NO_COMPRESSION_SPECIFIED                   /*  187 */
  3897.             || n == SSL_R_NO_SHARED_CIPHER                           /*  193 */
  3898. #ifdef SSL_R_PACKET_LENGTH_TOO_LONG
  3899.             || n == SSL_R_PACKET_LENGTH_TOO_LONG                     /*  198 */
  3900. #endif
  3901. #ifdef SSL_R_INVALID_ALERT
  3902.             || n == SSL_R_INVALID_ALERT                              /*  205 */
  3903. #endif
  3904.             || n == SSL_R_RECORD_LENGTH_MISMATCH                     /*  213 */
  3905. #ifdef SSL_R_TOO_MANY_WARNING_ALERTS
  3906.             || n == SSL_R_TOO_MANY_WARNING_ALERTS                    /*  220 */
  3907. #endif
  3908. #ifdef SSL_R_CLIENTHELLO_TLSEXT
  3909.             || n == SSL_R_CLIENTHELLO_TLSEXT                         /*  226 */
  3910. #endif
  3911. #ifdef SSL_R_PARSE_TLSEXT
  3912.             || n == SSL_R_PARSE_TLSEXT                               /*  227 */
  3913. #endif
  3914. #ifdef SSL_R_CALLBACK_FAILED
  3915.             || n == SSL_R_CALLBACK_FAILED                            /*  234 */
  3916. #endif
  3917. #ifdef SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG
  3918.             || n == SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG    /*  234 */
  3919. #endif
  3920. #ifdef SSL_R_NO_APPLICATION_PROTOCOL
  3921.             || n == SSL_R_NO_APPLICATION_PROTOCOL                    /*  235 */
  3922. #endif
  3923.             || n == SSL_R_UNEXPECTED_MESSAGE                         /*  244 */
  3924.             || n == SSL_R_UNEXPECTED_RECORD                          /*  245 */
  3925.             || n == SSL_R_UNKNOWN_ALERT_TYPE                         /*  246 */
  3926.             || n == SSL_R_UNKNOWN_PROTOCOL                           /*  252 */
  3927. #ifdef SSL_R_NO_COMMON_SIGNATURE_ALGORITHMS
  3928.             || n == SSL_R_NO_COMMON_SIGNATURE_ALGORITHMS             /*  253 */
  3929. #endif
  3930. #ifdef SSL_R_INVALID_COMPRESSION_LIST
  3931.             || n == SSL_R_INVALID_COMPRESSION_LIST                   /*  256 */
  3932. #endif
  3933. #ifdef SSL_R_MISSING_KEY_SHARE
  3934.             || n == SSL_R_MISSING_KEY_SHARE                          /*  258 */
  3935. #endif
  3936.             || n == SSL_R_UNSUPPORTED_PROTOCOL                       /*  258 */
  3937. #ifdef SSL_R_NO_SHARED_GROUP
  3938.             || n == SSL_R_NO_SHARED_GROUP                            /*  266 */
  3939. #endif
  3940.             || n == SSL_R_WRONG_VERSION_NUMBER                       /*  267 */
  3941. #ifdef SSL_R_TOO_MUCH_SKIPPED_EARLY_DATA
  3942.             || n == SSL_R_TOO_MUCH_SKIPPED_EARLY_DATA                /*  270 */
  3943. #endif
  3944.             || n == SSL_R_BAD_LENGTH                                 /*  271 */
  3945.             || n == SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC        /*  281 */
  3946. #ifdef SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY
  3947.             || n == SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY        /*  291 */
  3948. #endif
  3949. #ifdef SSL_R_APPLICATION_DATA_ON_SHUTDOWN
  3950.             || n == SSL_R_APPLICATION_DATA_ON_SHUTDOWN               /*  291 */
  3951. #endif
  3952. #ifdef SSL_R_BAD_LEGACY_VERSION
  3953.             || n == SSL_R_BAD_LEGACY_VERSION                         /*  292 */
  3954. #endif
  3955. #ifdef SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA
  3956.             || n == SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA     /*  293 */
  3957. #endif
  3958. #ifdef SSL_R_RECORD_TOO_SMALL
  3959.             || n == SSL_R_RECORD_TOO_SMALL                           /*  298 */
  3960. #endif
  3961. #ifdef SSL_R_SSL3_SESSION_ID_TOO_LONG
  3962.             || n == SSL_R_SSL3_SESSION_ID_TOO_LONG                   /*  300 */
  3963. #elif (defined SSL_R_TLS_SESSION_ID_TOO_LONG)
  3964.             || n == SSL_R_TLS_SESSION_ID_TOO_LONG                    /*  300 */
  3965. #endif
  3966. #ifdef SSL_R_BAD_ECPOINT
  3967.             || n == SSL_R_BAD_ECPOINT                                /*  306 */
  3968. #endif
  3969. #ifdef SSL_R_RECORD_LAYER_FAILURE
  3970.             || n == SSL_R_RECORD_LAYER_FAILURE                       /*  313 */
  3971. #endif
  3972. #ifdef SSL_R_RENEGOTIATE_EXT_TOO_LONG
  3973.             || n == SSL_R_RENEGOTIATE_EXT_TOO_LONG                   /*  335 */
  3974.             || n == SSL_R_RENEGOTIATION_ENCODING_ERR                 /*  336 */
  3975.             || n == SSL_R_RENEGOTIATION_MISMATCH                     /*  337 */
  3976. #endif
  3977. #ifdef SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED
  3978.             || n == SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED       /*  338 */
  3979. #endif
  3980. #ifdef SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING
  3981.             || n == SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING           /*  345 */
  3982. #endif
  3983. #ifdef SSL_R_INAPPROPRIATE_FALLBACK
  3984.             || n == SSL_R_INAPPROPRIATE_FALLBACK                     /*  373 */
  3985. #endif
  3986. #ifdef SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS
  3987.             || n == SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS             /*  376 */
  3988. #endif
  3989. #ifdef SSL_R_NO_SHARED_SIGATURE_ALGORITHMS
  3990.             || n == SSL_R_NO_SHARED_SIGATURE_ALGORITHMS              /*  376 */
  3991. #endif
  3992. #ifdef SSL_R_CERT_CB_ERROR
  3993.             || n == SSL_R_CERT_CB_ERROR                              /*  377 */
  3994. #endif
  3995. #ifdef SSL_R_VERSION_TOO_LOW
  3996.             || n == SSL_R_VERSION_TOO_LOW                            /*  396 */
  3997. #endif
  3998. #ifdef SSL_R_TOO_MANY_WARN_ALERTS
  3999.             || n == SSL_R_TOO_MANY_WARN_ALERTS                       /*  409 */
  4000. #endif
  4001. #ifdef SSL_R_BAD_RECORD_TYPE
  4002.             || n == SSL_R_BAD_RECORD_TYPE                            /*  443 */
  4003. #endif
  4004.             || (n >= SSL_AD_REASON_OFFSET                            /* 1000 */
  4005.                 && n <= SSL_AD_REASON_OFFSET + 255)
  4006.             )
  4007.         {
  4008.             switch (c->log_error) {

  4010.             case NGX_ERROR_IGNORE_ECONNRESET:
  4011.             case NGX_ERROR_INFO:
  4012.                 level = NGX_LOG_INFO;
  4013.                 break;

  4015.             case NGX_ERROR_ERR:
  4016.                 level = NGX_LOG_ERR;
  4017.                 break;

  4019.             default:
  4020.                 break;
  4021.             }
  4022.         }
  4023.     }

  4025.     ngx_ssl_error(level, c->log, err, text);
  4026. }


  4029. static void
  4030. ‌ngx_ssl_clear_error(ngx_log_t *log)
  4031. {
  4032.     while (ERR_peek_error()) {
  4033.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "ignoring stale global SSL error");
  4034.     }

  4036.     ERR_clear_error();
  4037. }


  4040. void ngx_cdecl
  4041. ‌ngx_ssl_error(ngx_uint_t level, ngx_log_t *log, ngx_err_t err, char *fmt, ...)
  4042. {
  4043.     int          flags;
  4044.     u_long       n;
  4045.     va_list      args;
  4046.     u_char      *p, *last;
  4047.     u_char       errstr[NGX_MAX_CONF_ERRSTR];
  4048.     const char  *data;

  4050.     last = errstr + NGX_MAX_CONF_ERRSTR;

  4052.     va_start(args, fmt);
  4053.     p = ngx_vslprintf(errstr, last - 1, fmt, args);
  4054.     va_end(args);

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

  4059.         for ( ;; ) {

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

  4063.             if (n == 0) {
  4064.                 break;
  4065.             }

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

  4069.             if (p >= last - 1) {
  4070.                 goto next;
  4071.             }

  4073.             *p++ = ' ';

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

  4077.             while (p < last && *p) {
  4078.                 p++;
  4079.             }

  4081.             if (p < last && *data && (flags & ERR_TXT_STRING)) {
  4082.                 *p++ = ':';
  4083.                 p = ngx_cpystrn(p, (u_char *) data, last - p);
  4084.             }

  4086.         next:

  4088.             (void) ERR_get_error();
  4089.         }

  4091.         if (p < last) {
  4092.             *p++ = ')';
  4093.         }
  4094.     }

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


  4100. ngx_int_t
  4101. ‌ngx_ssl_session_cache(ngx_ssl_t *ssl, ngx_str_t *sess_ctx,
  4102.     ngx_array_t *certificates, ssize_t builtin_session_cache,
  4103.     ngx_shm_zone_t *shm_zone, time_t timeout)
  4104. {
  4105.     long  cache_mode;

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

  4109.     if (ngx_ssl_session_id_context(ssl, sess_ctx, certificates) != NGX_OK) {
  4110.         return NGX_ERROR;
  4111.     }

  4113.     if (builtin_session_cache == NGX_SSL_NO_SCACHE) {
  4114.         SSL_CTX_set_session_cache_mode(ssl->ctx, SSL_SESS_CACHE_OFF);
  4115.         return NGX_OK;
  4116.     }

  4118.     if (builtin_session_cache == NGX_SSL_NONE_SCACHE) {

  4120.         /*
  4121.          * If the server explicitly says that it does not support
  4122.          * session reuse (see SSL_SESS_CACHE_OFF above), then
  4123.          * Outlook Express fails to upload a sent email to
  4124.          * the Sent Items folder on the IMAP server via a separate IMAP
  4125.          * connection in the background.  Therefore we have a special
  4126.          * mode (SSL_SESS_CACHE_SERVER|SSL_SESS_CACHE_NO_INTERNAL_STORE)
  4127.          * where the server pretends that it supports session reuse,
  4128.          * but it does not actually store any session.
  4129.          */

  4131.         SSL_CTX_set_session_cache_mode(ssl->ctx,
  4132.                                        SSL_SESS_CACHE_SERVER
  4133.                                        |SSL_SESS_CACHE_NO_AUTO_CLEAR
  4134.                                        |SSL_SESS_CACHE_NO_INTERNAL_STORE);

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

  4138.         return NGX_OK;
  4139.     }

  4141.     cache_mode = SSL_SESS_CACHE_SERVER;

  4143.     if (shm_zone && builtin_session_cache == NGX_SSL_NO_BUILTIN_SCACHE) {
  4144.         cache_mode |= SSL_SESS_CACHE_NO_INTERNAL;
  4145.     }

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

  4149.     if (builtin_session_cache != NGX_SSL_NO_BUILTIN_SCACHE) {

  4151.         if (builtin_session_cache != NGX_SSL_DFLT_BUILTIN_SCACHE) {
  4152.             SSL_CTX_sess_set_cache_size(ssl->ctx, builtin_session_cache);
  4153.         }
  4154.     }

  4156.     if (shm_zone) {
  4157.         SSL_CTX_sess_set_new_cb(ssl->ctx, ngx_ssl_new_session);
  4158.         SSL_CTX_sess_set_get_cb(ssl->ctx, ngx_ssl_get_cached_session);
  4159.         SSL_CTX_sess_set_remove_cb(ssl->ctx, ngx_ssl_remove_session);

  4161.         if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_session_cache_index, shm_zone)
  4162.             == 0)
  4163.         {
  4164.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4165.                           "SSL_CTX_set_ex_data() failed");
  4166.             return NGX_ERROR;
  4167.         }
  4168.     }

  4170.     return NGX_OK;
  4171. }


  4174. static ngx_int_t
  4175. ‌ngx_ssl_session_id_context(ngx_ssl_t *ssl, ngx_str_t *sess_ctx,
  4176.     ngx_array_t *certificates)
  4177. {
  4178.     int                   n, i;
  4179.     X509                 *cert;
  4180.     X509_NAME            *name;
  4181.     ngx_str_t            *certs;
  4182.     ngx_uint_t            k;
  4183.     EVP_MD_CTX           *md;
  4184.     unsigned int          len;
  4185.     STACK_OF(X509_NAME)  *list;
  4186.     u_char                buf[EVP_MAX_MD_SIZE];

  4188.     /*
  4189.      * Session ID context is set based on the string provided,
  4190.      * the server certificates, and the client CA list.
  4191.      */

  4193.     md = EVP_MD_CTX_create();
  4194.     if (md == NULL) {
  4195.         return NGX_ERROR;
  4196.     }

  4198.     if (EVP_DigestInit_ex(md, EVP_sha1(), NULL) == 0) {
  4199.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4200.                       "EVP_DigestInit_ex() failed");
  4201.         goto failed;
  4202.     }

  4204.     if (EVP_DigestUpdate(md, sess_ctx->data, sess_ctx->len) == 0) {
  4205.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4206.                       "EVP_DigestUpdate() failed");
  4207.         goto failed;
  4208.     }

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

  4213.         if (X509_digest(cert, EVP_sha1(), buf, &len) == 0) {
  4214.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4215.                           "X509_digest() failed");
  4216.             goto failed;
  4217.         }

  4219.         if (EVP_DigestUpdate(md, buf, len) == 0) {
  4220.             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4221.                           "EVP_DigestUpdate() failed");
  4222.             goto failed;
  4223.         }
  4224.     }

  4226.     if (ssl->certs.nelts == 0 && certificates != NULL) {
  4227.         /*
  4228.          * If certificates are loaded dynamically, we use certificate
  4229.          * names as specified in the configuration (with variables).
  4230.          */

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

  4235.             if (EVP_DigestUpdate(md, certs[k].data, certs[k].len) == 0) {
  4236.                 ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4237.                               "EVP_DigestUpdate() failed");
  4238.                 goto failed;
  4239.             }
  4240.         }
  4241.     }

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

  4245.     if (list != NULL) {
  4246.         n = sk_X509_NAME_num(list);

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

  4251.             if (X509_NAME_digest(name, EVP_sha1(), buf, &len) == 0) {
  4252.                 ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4253.                               "X509_NAME_digest() failed");
  4254.                 goto failed;
  4255.             }

  4257.             if (EVP_DigestUpdate(md, buf, len) == 0) {
  4258.                 ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4259.                               "EVP_DigestUpdate() failed");
  4260.                 goto failed;
  4261.             }
  4262.         }
  4263.     }

  4265.     if (EVP_DigestFinal_ex(md, buf, &len) == 0) {
  4266.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4267.                       "EVP_DigestFinal_ex() failed");
  4268.         goto failed;
  4269.     }

  4271.     EVP_MD_CTX_destroy(md);

  4273.     if (SSL_CTX_set_session_id_context(ssl->ctx, buf, len) == 0) {
  4274.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4275.                       "SSL_CTX_set_session_id_context() failed");
  4276.         return NGX_ERROR;
  4277.     }

  4279.     return NGX_OK;

  4281. failed:

  4283.     EVP_MD_CTX_destroy(md);

  4285.     return NGX_ERROR;
  4286. }


  4289. ngx_int_t
  4290. ‌ngx_ssl_session_cache_init(ngx_shm_zone_t *shm_zone, void *data)
  4291. {
  4292.     size_t                    len;
  4293.     ngx_slab_pool_t          *shpool;
  4294.     ngx_ssl_session_cache_t  *cache;

  4296.     if (data) {
  4297.         shm_zone->data = data;
  4298.         return NGX_OK;
  4299.     }

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

  4303.     if (shm_zone->shm.exists) {
  4304.         shm_zone->data = shpool->data;
  4305.         return NGX_OK;
  4306.     }

  4308.     cache = ngx_slab_alloc(shpool, sizeof(ngx_ssl_session_cache_t));
  4309.     if (cache == NULL) {
  4310.         return NGX_ERROR;
  4311.     }

  4313.     shpool->data = cache;
  4314.     shm_zone->data = cache;

  4316.     ngx_rbtree_init(&cache->session_rbtree, &cache->sentinel,
  4317.                     ngx_ssl_session_rbtree_insert_value);

  4319.     ngx_queue_init(&cache->expire_queue);

  4321.     cache->ticket_keys[0].expire = 0;
  4322.     cache->ticket_keys[1].expire = 0;
  4323.     cache->ticket_keys[2].expire = 0;

  4325.     cache->fail_time = 0;

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

  4329.     shpool->log_ctx = ngx_slab_alloc(shpool, len);
  4330.     if (shpool->log_ctx == NULL) {
  4331.         return NGX_ERROR;
  4332.     }

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

  4337.     shpool->log_nomem = 0;

  4339.     return NGX_OK;
  4340. }


  4343. /*
  4344. * The length of the session id is 16 bytes for SSLv2 sessions and
  4345. * between 1 and 32 bytes for SSLv3 and TLS, typically 32 bytes.
  4346. * Typical length of the external ASN1 representation of a session
  4347. * is about 150 bytes plus SNI server name.
  4348. *
  4349. * On 32-bit platforms we allocate an rbtree node, a session id, and
  4350. * an ASN1 representation in a single allocation, it typically takes
  4351. * 256 bytes.
  4352. *
  4353. * On 64-bit platforms we allocate separately an rbtree node + session_id,
  4354. * and an ASN1 representation, they take accordingly 128 and 256 bytes.
  4355. *
  4356. * OpenSSL's i2d_SSL_SESSION() and d2i_SSL_SESSION are slow,
  4357. * so they are outside the code locked by shared pool mutex
  4358. */

  4360. static int
  4361. ‌ngx_ssl_new_session(ngx_ssl_conn_t *ssl_conn, ngx_ssl_session_t *sess)
  4362. {
  4363.     int                       len;
  4364.     u_char                   *p, *session_id;
  4365.     size_t                    n;
  4366.     uint32_t                  hash;
  4367.     SSL_CTX                  *ssl_ctx;
  4368.     unsigned int              session_id_length;
  4369.     ngx_shm_zone_t           *shm_zone;
  4370.     ngx_connection_t         *c;
  4371.     ngx_slab_pool_t          *shpool;
  4372.     ngx_ssl_sess_id_t        *sess_id;
  4373.     ngx_ssl_session_cache_t  *cache;

  4375. #ifdef TLS1_3_VERSION

  4377.     /*
  4378.      * OpenSSL tries to save TLSv1.3 sessions into session cache
  4379.      * even when using tickets for stateless session resumption,
  4380.      * "because some applications just want to know about the creation
  4381.      * of a session"; do not cache such sessions
  4382.      */

  4384.     if (SSL_version(ssl_conn) == TLS1_3_VERSION
  4385.         && (SSL_get_options(ssl_conn) & SSL_OP_NO_TICKET) == 0)
  4386.     {
  4387.         return 0;
  4388.     }

  4390. #endif

  4392.     len = i2d_SSL_SESSION(sess, NULL);

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

  4396.     if (len > NGX_SSL_MAX_SESSION_SIZE) {
  4397.         return 0;
  4398.     }

  4400.     p = ngx_ssl_session_buffer;
  4401.     i2d_SSL_SESSION(sess, &p);

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

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

  4407.     if (session_id_length > 32) {
  4408.         return 0;
  4409.     }

  4411.     c = ngx_ssl_get_connection(ssl_conn);

  4413.     ssl_ctx = c->ssl->session_ctx;
  4414.     shm_zone = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_session_cache_index);

  4416.     cache = shm_zone->data;
  4417.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

  4419.     ngx_shmtx_lock(&shpool->mutex);

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

  4424. #if (NGX_PTR_SIZE == 8)
  4425.     n = sizeof(ngx_ssl_sess_id_t);
  4426. #else
  4427.     n = offsetof(ngx_ssl_sess_id_t, session) + len;
  4428. #endif

  4430.     sess_id = ngx_slab_alloc_locked(shpool, n);

  4432.     if (sess_id == NULL) {

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

  4436.         ngx_ssl_expire_sessions(cache, shpool, 0);

  4438.         sess_id = ngx_slab_alloc_locked(shpool, n);

  4440.         if (sess_id == NULL) {
  4441.             goto failed;
  4442.         }
  4443.     }

  4445. #if (NGX_PTR_SIZE == 8)

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

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

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

  4453.         ngx_ssl_expire_sessions(cache, shpool, 0);

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

  4457.         if (sess_id->session == NULL) {
  4458.             goto failed;
  4459.         }
  4460.     }

  4462. #endif

  4464.     ngx_memcpy(sess_id->session, ngx_ssl_session_buffer, len);
  4465.     ngx_memcpy(sess_id->id, session_id, session_id_length);

  4467.     hash = ngx_crc32_short(session_id, session_id_length);

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

  4473.     sess_id->node.key = hash;
  4474.     sess_id->node.data = (u_char) session_id_length;
  4475.     sess_id->len = len;

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

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

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

  4483.     ngx_shmtx_unlock(&shpool->mutex);

  4485.     return 0;

  4487. failed:

  4489.     if (sess_id) {
  4490.         ngx_slab_free_locked(shpool, sess_id);
  4491.     }

  4493.     ngx_shmtx_unlock(&shpool->mutex);

  4495.     if (cache->fail_time != ngx_time()) {
  4496.         cache->fail_time = ngx_time();
  4497.         ngx_log_error(NGX_LOG_WARN, c->log, 0,
  4498.                       "could not allocate new session%s", shpool->log_ctx);
  4499.     }

  4501.     return 0;
  4502. }


  4505. static ngx_ssl_session_t *
  4506. ‌ngx_ssl_get_cached_session(ngx_ssl_conn_t *ssl_conn,
  4507. #if OPENSSL_VERSION_NUMBER >= 0x10100003L
  4508.     const
  4509. #endif
  4510.     u_char *id, int len, int *copy)
  4511. {
  4512.     size_t                    slen;
  4513.     uint32_t                  hash;
  4514.     ngx_int_t                 rc;
  4515.     const u_char             *p;
  4516.     ngx_shm_zone_t           *shm_zone;
  4517.     ngx_slab_pool_t          *shpool;
  4518.     ngx_connection_t         *c;
  4519.     ngx_rbtree_node_t        *node, *sentinel;
  4520.     ngx_ssl_session_t        *sess;
  4521.     ngx_ssl_sess_id_t        *sess_id;
  4522.     ngx_ssl_session_cache_t  *cache;

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

  4527.     c = ngx_ssl_get_connection(ssl_conn);

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

  4532.     shm_zone = SSL_CTX_get_ex_data(c->ssl->session_ctx,
  4533.                                    ngx_ssl_session_cache_index);

  4535.     cache = shm_zone->data;

  4537.     sess = NULL;

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

  4541.     ngx_shmtx_lock(&shpool->mutex);

  4543.     node = cache->session_rbtree.root;
  4544.     sentinel = cache->session_rbtree.sentinel;

  4546.     while (node != sentinel) {

  4548.         if (hash < node->key) {
  4549.             node = node->left;
  4550.             continue;
  4551.         }

  4553.         if (hash > node->key) {
  4554.             node = node->right;
  4555.             continue;
  4556.         }

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

  4560.         sess_id = (ngx_ssl_sess_id_t *) node;

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

  4565.         if (rc == 0) {

  4567.             if (sess_id->expire > ngx_time()) {
  4568.                 slen = sess_id->len;

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

  4572.                 ngx_shmtx_unlock(&shpool->mutex);

  4574.                 p = ngx_ssl_session_buffer;
  4575.                 sess = d2i_SSL_SESSION(NULL, &p, slen);

  4577.                 return sess;
  4578.             }

  4580.             ngx_queue_remove(&sess_id->queue);

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

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

  4586. #if (NGX_PTR_SIZE == 8)
  4587.             ngx_slab_free_locked(shpool, sess_id->session);
  4588. #endif
  4589.             ngx_slab_free_locked(shpool, sess_id);

  4591.             sess = NULL;

  4593.             goto done;
  4594.         }

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

  4599. done:

  4601.     ngx_shmtx_unlock(&shpool->mutex);

  4603.     return sess;
  4604. }


  4607. void
  4608. ‌ngx_ssl_remove_cached_session(SSL_CTX *ssl, ngx_ssl_session_t *sess)
  4609. {
  4610.     SSL_CTX_remove_session(ssl, sess);

  4612.     ngx_ssl_remove_session(ssl, sess);
  4613. }


  4616. static void
  4617. ‌ngx_ssl_remove_session(SSL_CTX *ssl, ngx_ssl_session_t *sess)
  4618. {
  4619.     u_char                   *id;
  4620.     uint32_t                  hash;
  4621.     ngx_int_t                 rc;
  4622.     unsigned int              len;
  4623.     ngx_shm_zone_t           *shm_zone;
  4624.     ngx_slab_pool_t          *shpool;
  4625.     ngx_rbtree_node_t        *node, *sentinel;
  4626.     ngx_ssl_sess_id_t        *sess_id;
  4627.     ngx_ssl_session_cache_t  *cache;

  4629.     shm_zone = SSL_CTX_get_ex_data(ssl, ngx_ssl_session_cache_index);

  4631.     if (shm_zone == NULL) {
  4632.         return;
  4633.     }

  4635.     cache = shm_zone->data;

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

  4639.     hash = ngx_crc32_short(id, len);

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

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

  4646.     ngx_shmtx_lock(&shpool->mutex);

  4648.     node = cache->session_rbtree.root;
  4649.     sentinel = cache->session_rbtree.sentinel;

  4651.     while (node != sentinel) {

  4653.         if (hash < node->key) {
  4654.             node = node->left;
  4655.             continue;
  4656.         }

  4658.         if (hash > node->key) {
  4659.             node = node->right;
  4660.             continue;
  4661.         }

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

  4665.         sess_id = (ngx_ssl_sess_id_t *) node;

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

  4669.         if (rc == 0) {

  4671.             ngx_queue_remove(&sess_id->queue);

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

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

  4677. #if (NGX_PTR_SIZE == 8)
  4678.             ngx_slab_free_locked(shpool, sess_id->session);
  4679. #endif
  4680.             ngx_slab_free_locked(shpool, sess_id);

  4682.             goto done;
  4683.         }

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

  4688. done:

  4690.     ngx_shmtx_unlock(&shpool->mutex);
  4691. }


  4694. static void
  4695. ‌ngx_ssl_expire_sessions(ngx_ssl_session_cache_t *cache,
  4696.     ngx_slab_pool_t *shpool, ngx_uint_t n)
  4697. {
  4698.     time_t              now;
  4699.     ngx_queue_t        *q;
  4700.     ngx_ssl_sess_id_t  *sess_id;

  4702.     now = ngx_time();

  4704.     while (n < 3) {

  4706.         if (ngx_queue_empty(&cache->expire_queue)) {
  4707.             return;
  4708.         }

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

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

  4714.         if (n++ != 0 && sess_id->expire > now) {
  4715.             return;
  4716.         }

  4718.         ngx_queue_remove(q);

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

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

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

  4727. #if (NGX_PTR_SIZE == 8)
  4728.         ngx_slab_free_locked(shpool, sess_id->session);
  4729. #endif
  4730.         ngx_slab_free_locked(shpool, sess_id);
  4731.     }
  4732. }


  4735. static void
  4736. ‌ngx_ssl_session_rbtree_insert_value(ngx_rbtree_node_t *temp,
  4737.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  4738. {
  4739.     ngx_rbtree_node_t  **p;
  4740.     ngx_ssl_sess_id_t   *sess_id, *sess_id_temp;

  4742.     for ( ;; ) {

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

  4746.             p = &temp->left;

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

  4750.             p = &temp->right;

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

  4754.             sess_id = (ngx_ssl_sess_id_t *) node;
  4755.             sess_id_temp = (ngx_ssl_sess_id_t *) temp;

  4757.             p = (ngx_memn2cmp(sess_id->id, sess_id_temp->id,
  4758.                               (size_t) node->data, (size_t) temp->data)
  4759.                  < 0) ? &temp->left : &temp->right;
  4760.         }

  4762.         if (*p == sentinel) {
  4763.             break;
  4764.         }

  4766.         temp = *p;
  4767.     }

  4769.     *p = node;
  4770.     node->parent = temp;
  4771.     node->left = sentinel;
  4772.     node->right = sentinel;
  4773.     ngx_rbt_red(node);
  4774. }


  4777. #ifdef SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB

  4779. ngx_int_t
  4780. ‌ngx_ssl_session_ticket_keys(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_array_t *paths)
  4781. {
  4782.     u_char                 buf[80];
  4783.     size_t                 size;
  4784.     ssize_t                n;
  4785.     ngx_str_t             *path;
  4786.     ngx_file_t             file;
  4787.     ngx_uint_t             i;
  4788.     ngx_array_t           *keys;
  4789.     ngx_file_info_t        fi;
  4790.     ngx_pool_cleanup_t    *cln;
  4791.     ngx_ssl_ticket_key_t  *key;

  4793.     if (paths == NULL
  4794.         && SSL_CTX_get_ex_data(ssl->ctx, ngx_ssl_session_cache_index) == NULL)
  4795.     {
  4796.         return NGX_OK;
  4797.     }

  4799.     keys = ngx_array_create(cf->pool, paths ? paths->nelts : 3,
  4800.                             sizeof(ngx_ssl_ticket_key_t));
  4801.     if (keys == NULL) {
  4802.         return NGX_ERROR;
  4803.     }

  4805.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  4806.     if (cln == NULL) {
  4807.         return NGX_ERROR;
  4808.     }

  4810.     cln->handler = ngx_ssl_ticket_keys_cleanup;
  4811.     cln->data = keys;

  4813.     if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_ticket_keys_index, keys) == 0) {
  4814.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  4815.                       "SSL_CTX_set_ex_data() failed");
  4816.         return NGX_ERROR;
  4817.     }

  4819.     if (SSL_CTX_set_tlsext_ticket_key_cb(ssl->ctx, ngx_ssl_ticket_key_callback)
  4820.         == 0)
  4821.     {
  4822.         ngx_log_error(NGX_LOG_WARN, cf->log, 0,
  4823.                       "nginx was built with Session Tickets support, however, "
  4824.                       "now it is linked dynamically to an OpenSSL library "
  4825.                       "which has no tlsext support, therefore Session Tickets "
  4826.                       "are not available");
  4827.         return NGX_OK;
  4828.     }

  4830.     if (paths == NULL) {

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

  4834.         key = ngx_array_push_n(keys, 3);
  4835.         key[0].shared = 1;
  4836.         key[0].expire = 0;
  4837.         key[1].shared = 1;
  4838.         key[1].expire = 0;
  4839.         key[2].shared = 1;
  4840.         key[2].expire = 0;

  4842.         return NGX_OK;
  4843.     }

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

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

  4852.         ngx_memzero(&file, sizeof(ngx_file_t));
  4853.         file.name = path[i];
  4854.         file.log = cf->log;

  4856.         file.fd = ngx_open_file(file.name.data, NGX_FILE_RDONLY,
  4857.                                 NGX_FILE_OPEN, 0);

  4859.         if (file.fd == NGX_INVALID_FILE) {
  4860.             ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  4861.                                ngx_open_file_n " \"%V\" failed", &file.name);
  4862.             return NGX_ERROR;
  4863.         }

  4865.         if (ngx_fd_info(file.fd, &fi) == NGX_FILE_ERROR) {
  4866.             ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  4867.                                ngx_fd_info_n " \"%V\" failed", &file.name);
  4868.             goto failed;
  4869.         }

  4871.         size = ngx_file_size(&fi);

  4873.         if (size != 48 && size != 80) {
  4874.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  4875.                                "\"%V\" must be 48 or 80 bytes", &file.name);
  4876.             goto failed;
  4877.         }

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

  4881.         if (n == NGX_ERROR) {
  4882.             ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  4883.                                ngx_read_file_n " \"%V\" failed", &file.name);
  4884.             goto failed;
  4885.         }

  4887.         if ((size_t) n != size) {
  4888.             ngx_conf_log_error(NGX_LOG_CRIT, cf, 0,
  4889.                                ngx_read_file_n " \"%V\" returned only "
  4890.                                "%z bytes instead of %uz", &file.name, n, size);
  4891.             goto failed;
  4892.         }

  4894.         key = ngx_array_push(keys);
  4895.         if (key == NULL) {
  4896.             goto failed;
  4897.         }

  4899.         key->shared = 0;
  4900.         key->expire = 1;

  4902.         if (size == 48) {
  4903.             key->size = 48;
  4904.             ngx_memcpy(key->name, buf, 16);
  4905.             ngx_memcpy(key->aes_key, buf + 16, 16);
  4906.             ngx_memcpy(key->hmac_key, buf + 32, 16);

  4908.         } else {
  4909.             key->size = 80;
  4910.             ngx_memcpy(key->name, buf, 16);
  4911.             ngx_memcpy(key->hmac_key, buf + 16, 32);
  4912.             ngx_memcpy(key->aes_key, buf + 48, 32);
  4913.         }

  4915.         if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  4916.             ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  4917.                           ngx_close_file_n " \"%V\" failed", &file.name);
  4918.         }

  4920.         ngx_explicit_memzero(&buf, 80);
  4921.     }

  4923.     return NGX_OK;

  4925. failed:

  4927.     if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  4928.         ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  4929.                       ngx_close_file_n " \"%V\" failed", &file.name);
  4930.     }

  4932.     ngx_explicit_memzero(&buf, 80);

  4934.     return NGX_ERROR;
  4935. }


  4938. static int
  4939. ‌ngx_ssl_ticket_key_callback(ngx_ssl_conn_t *ssl_conn,
  4940.     unsigned char *name, unsigned char *iv, EVP_CIPHER_CTX *ectx,
  4941.     HMAC_CTX *hctx, int enc)
  4942. {
  4943.     size_t                 size;
  4944.     SSL_CTX               *ssl_ctx;
  4945.     ngx_uint_t             i;
  4946.     ngx_array_t           *keys;
  4947.     ngx_connection_t      *c;
  4948.     ngx_ssl_ticket_key_t  *key;
  4949.     const EVP_MD          *digest;
  4950.     const EVP_CIPHER      *cipher;

  4952.     c = ngx_ssl_get_connection(ssl_conn);
  4953.     ssl_ctx = c->ssl->session_ctx;

  4955.     if (ngx_ssl_rotate_ticket_keys(ssl_ctx, c->log) != NGX_OK) {
  4956.         return -1;
  4957.     }

  4959. #ifdef OPENSSL_NO_SHA256
  4960.     digest = EVP_sha1();
  4961. #else
  4962.     digest = EVP_sha256();
  4963. #endif

  4965.     keys = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_ticket_keys_index);
  4966.     if (keys == NULL) {
  4967.         return -1;
  4968.     }

  4970.     key = keys->elts;

  4972.     if (enc == 1) {
  4973.         /* encrypt session ticket */

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

  4980.         if (key[0].size == 48) {
  4981.             cipher = EVP_aes_128_cbc();
  4982.             size = 16;

  4984.         } else {
  4985.             cipher = EVP_aes_256_cbc();
  4986.             size = 32;
  4987.         }

  4989.         if (RAND_bytes(iv, EVP_CIPHER_iv_length(cipher)) != 1) {
  4990.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "RAND_bytes() failed");
  4991.             return -1;
  4992.         }

  4994.         if (EVP_EncryptInit_ex(ectx, cipher, NULL, key[0].aes_key, iv) != 1) {
  4995.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  4996.                           "EVP_EncryptInit_ex() failed");
  4997.             return -1;
  4998.         }

  5000. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  5001.         if (HMAC_Init_ex(hctx, key[0].hmac_key, size, digest, NULL) != 1) {
  5002.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "HMAC_Init_ex() failed");
  5003.             return -1;
  5004.         }
  5005. #else
  5006.         HMAC_Init_ex(hctx, key[0].hmac_key, size, digest, NULL);
  5007. #endif

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

  5011.         return 1;

  5013.     } else {
  5014.         /* decrypt session ticket */

  5016.         for (i = 0; i < keys->nelts; i++) {
  5017.             if (ngx_memcmp(name, key[i].name, 16) == 0) {
  5018.                 goto found;
  5019.             }
  5020.         }

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

  5026.         return 0;

  5028.     found:

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

  5034.         if (key[i].size == 48) {
  5035.             cipher = EVP_aes_128_cbc();
  5036.             size = 16;

  5038.         } else {
  5039.             cipher = EVP_aes_256_cbc();
  5040.             size = 32;
  5041.         }

  5043. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  5044.         if (HMAC_Init_ex(hctx, key[i].hmac_key, size, digest, NULL) != 1) {
  5045.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "HMAC_Init_ex() failed");
  5046.             return -1;
  5047.         }
  5048. #else
  5049.         HMAC_Init_ex(hctx, key[i].hmac_key, size, digest, NULL);
  5050. #endif

  5052.         if (EVP_DecryptInit_ex(ectx, cipher, NULL, key[i].aes_key, iv) != 1) {
  5053.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  5054.                           "EVP_DecryptInit_ex() failed");
  5055.             return -1;
  5056.         }

  5058.         /* renew if TLSv1.3 */

  5060. #ifdef TLS1_3_VERSION
  5061.         if (SSL_version(ssl_conn) == TLS1_3_VERSION) {
  5062.             return 2;
  5063.         }
  5064. #endif

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

  5068.         if (i != 0 && key[i].expire) {
  5069.             return 2;
  5070.         }

  5072.         return 1;
  5073.     }
  5074. }


  5077. static ngx_int_t
  5078. ‌ngx_ssl_rotate_ticket_keys(SSL_CTX *ssl_ctx, ngx_log_t *log)
  5079. {
  5080.     time_t                    now, expire;
  5081.     ngx_array_t              *keys;
  5082.     ngx_shm_zone_t           *shm_zone;
  5083.     ngx_slab_pool_t          *shpool;
  5084.     ngx_ssl_ticket_key_t     *key;
  5085.     ngx_ssl_session_cache_t  *cache;
  5086.     u_char                    buf[80];

  5088.     keys = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_ticket_keys_index);
  5089.     if (keys == NULL) {
  5090.         return NGX_OK;
  5091.     }

  5093.     key = keys->elts;

  5095.     if (!key[0].shared) {
  5096.         return NGX_OK;
  5097.     }

  5099.     /*
  5100.      * if we don't need to update expiration of the current key
  5101.      * and the previous key is still needed, don't sync with shared
  5102.      * memory to save some work; in the worst case other worker process
  5103.      * will switch to the next key, but this process will still be able
  5104.      * to decrypt tickets encrypted with it
  5105.      */

  5107.     now = ngx_time();
  5108.     expire = now + SSL_CTX_get_timeout(ssl_ctx);

  5110.     if (key[0].expire >= expire && key[1].expire >= now) {
  5111.         return NGX_OK;
  5112.     }

  5114.     shm_zone = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_session_cache_index);

  5116.     cache = shm_zone->data;
  5117.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

  5119.     ngx_shmtx_lock(&shpool->mutex);

  5121.     key = cache->ticket_keys;

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

  5125.         /* initialize the current key */

  5127.         if (RAND_bytes(buf, 80) != 1) {
  5128.             ngx_ssl_error(NGX_LOG_ALERT, log, 0, "RAND_bytes() failed");
  5129.             ngx_shmtx_unlock(&shpool->mutex);
  5130.             return NGX_ERROR;
  5131.         }

  5133.         key[0].shared = 1;
  5134.         key[0].expire = expire;
  5135.         key[0].size = 80;
  5136.         ngx_memcpy(key[0].name, buf, 16);
  5137.         ngx_memcpy(key[0].hmac_key, buf + 16, 32);
  5138.         ngx_memcpy(key[0].aes_key, buf + 48, 32);

  5140.         ngx_explicit_memzero(&buf, 80);

  5142.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0,
  5143.                        "ssl ticket key: \"%*xs\"",
  5144.                        (size_t) 16, key[0].name);

  5146.         /*
  5147.          * copy the current key to the next key, as initialization of
  5148.          * the previous key will replace the current key with the next
  5149.          * key
  5150.          */

  5152.         key[2] = key[0];
  5153.     }

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

  5157.         /*
  5158.          * if the previous key is no longer needed (or not initialized),
  5159.          * replace it with the current key, replace the current key with
  5160.          * the next key, and generate new next key
  5161.          */

  5163.         key[1] = key[0];
  5164.         key[0] = key[2];

  5166.         if (RAND_bytes(buf, 80) != 1) {
  5167.             ngx_ssl_error(NGX_LOG_ALERT, log, 0, "RAND_bytes() failed");
  5168.             ngx_shmtx_unlock(&shpool->mutex);
  5169.             return NGX_ERROR;
  5170.         }

  5172.         key[2].shared = 1;
  5173.         key[2].expire = 0;
  5174.         key[2].size = 80;
  5175.         ngx_memcpy(key[2].name, buf, 16);
  5176.         ngx_memcpy(key[2].hmac_key, buf + 16, 32);
  5177.         ngx_memcpy(key[2].aes_key, buf + 48, 32);

  5179.         ngx_explicit_memzero(&buf, 80);

  5181.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0,
  5182.                        "ssl ticket key: \"%*xs\"",
  5183.                        (size_t) 16, key[2].name);
  5184.     }

  5186.     /*
  5187.      * update expiration of the current key: it is going to be needed
  5188.      * at least till the session being created expires
  5189.      */

  5191.     if (expire > key[0].expire) {
  5192.         key[0].expire = expire;
  5193.     }

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

  5197.     ngx_memcpy(keys->elts, cache->ticket_keys,
  5198.                2 * sizeof(ngx_ssl_ticket_key_t));

  5200.     ngx_shmtx_unlock(&shpool->mutex);

  5202.     return NGX_OK;
  5203. }


  5206. static void
  5207. ‌ngx_ssl_ticket_keys_cleanup(void *data)
  5208. {
  5209.     ngx_array_t  *keys = data;

  5211.     ngx_explicit_memzero(keys->elts,
  5212.                          keys->nelts * sizeof(ngx_ssl_ticket_key_t));
  5213. }

  5215. #else

  5217. ngx_int_t
  5218. ‌ngx_ssl_session_ticket_keys(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_array_t *paths)
  5219. {
  5220.     if (paths) {
  5221.         ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  5222.                       "\"ssl_session_ticket_key\" ignored, not supported");
  5223.     }

  5225.     return NGX_OK;
  5226. }

  5228. #endif


  5231. void
  5232. ‌ngx_ssl_cleanup_ctx(void *data)
  5233. {
  5234.     ngx_ssl_t  *ssl = data;

  5236.     X509        *cert;
  5237.     u_char      *p;
  5238.     ngx_uint_t   i;

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

  5243.         p = X509_get_ex_data(cert, ngx_ssl_certificate_comp_index);

  5245.         if (p) {
  5246.             ngx_free(p);
  5247.             X509_set_ex_data(cert, ngx_ssl_certificate_comp_index, NULL);
  5248.         }

  5250.         X509_free(cert);
  5251.     }

  5253.     SSL_CTX_free(ssl->ctx);
  5254. }


  5257. ngx_int_t
  5258. ‌ngx_ssl_check_host(ngx_connection_t *c, ngx_str_t *name)
  5259. {
  5260.     X509   *cert;

  5262.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5263.     if (cert == NULL) {
  5264.         return NGX_ERROR;
  5265.     }

  5267. #ifdef X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT

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

  5271.     if (name->len == 0) {
  5272.         goto failed;
  5273.     }

  5275.     if (X509_check_host(cert, (char *) name->data, name->len, 0, NULL) != 1) {
  5276.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5277.                        "X509_check_host(): no match");
  5278.         goto failed;
  5279.     }

  5281.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5282.                    "X509_check_host(): match");

  5284.     goto found;

  5286. #else
  5287.     {
  5288.     int                      n, i;
  5289.     X509_NAME               *sname;
  5290.     ASN1_STRING             *str;
  5291.     X509_NAME_ENTRY         *entry;
  5292.     GENERAL_NAME            *altname;
  5293.     STACK_OF(GENERAL_NAME)  *altnames;

  5295.     /*
  5296.      * As per RFC6125 and RFC2818, we check subjectAltName extension,
  5297.      * and if it's not present - commonName in Subject is checked.
  5298.      */

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

  5302.     if (altnames) {
  5303.         n = sk_GENERAL_NAME_num(altnames);

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

  5308.             if (altname->type != GEN_DNS) {
  5309.                 continue;
  5310.             }

  5312.             str = altname->d.dNSName;

  5314.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5315.                            "SSL subjectAltName: \"%*s\"",
  5316.                            ASN1_STRING_length(str), ASN1_STRING_data(str));

  5318.             if (ngx_ssl_check_name(name, str) == NGX_OK) {
  5319.                 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5320.                                "SSL subjectAltName: match");
  5321.                 GENERAL_NAMES_free(altnames);
  5322.                 goto found;
  5323.             }
  5324.         }

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

  5329.         GENERAL_NAMES_free(altnames);
  5330.         goto failed;
  5331.     }

  5333.     /*
  5334.      * If there is no subjectAltName extension, check commonName
  5335.      * in Subject.  While RFC2818 requires to only check "most specific"
  5336.      * CN, both Apache and OpenSSL check all CNs, and so do we.
  5337.      */

  5339.     sname = X509_get_subject_name(cert);

  5341.     if (sname == NULL) {
  5342.         goto failed;
  5343.     }

  5345.     i = -1;
  5346.     for ( ;; ) {
  5347.         i = X509_NAME_get_index_by_NID(sname, NID_commonName, i);

  5349.         if (i < 0) {
  5350.             break;
  5351.         }

  5353.         entry = X509_NAME_get_entry(sname, i);
  5354.         str = X509_NAME_ENTRY_get_data(entry);

  5356.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5357.                        "SSL commonName: \"%*s\"",
  5358.                        ASN1_STRING_length(str), ASN1_STRING_data(str));

  5360.         if (ngx_ssl_check_name(name, str) == NGX_OK) {
  5361.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5362.                            "SSL commonName: match");
  5363.             goto found;
  5364.         }
  5365.     }

  5367.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  5368.                    "SSL commonName: no match");
  5369.     }
  5370. #endif

  5372. failed:

  5374.     X509_free(cert);
  5375.     return NGX_ERROR;

  5377. found:

  5379.     X509_free(cert);
  5380.     return NGX_OK;
  5381. }


  5384. #ifndef X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT

  5386. static ngx_int_t
  5387. ‌ngx_ssl_check_name(ngx_str_t *name, ASN1_STRING *pattern)
  5388. {
  5389.     u_char  *s, *p, *end;
  5390.     size_t   slen, plen;

  5392.     s = name->data;
  5393.     slen = name->len;

  5395.     p = ASN1_STRING_data(pattern);
  5396.     plen = ASN1_STRING_length(pattern);

  5398.     if (slen == plen && ngx_strncasecmp(s, p, plen) == 0) {
  5399.         return NGX_OK;
  5400.     }

  5402.     if (plen > 2 && p[0] == '*' && p[1] == '.') {
  5403.         plen -= 1;
  5404.         p += 1;

  5406.         end = s + slen;
  5407.         s = ngx_strlchr(s, end, '.');

  5409.         if (s == NULL) {
  5410.             return NGX_ERROR;
  5411.         }

  5413.         slen = end - s;

  5415.         if (plen == slen && ngx_strncasecmp(s, p, plen) == 0) {
  5416.             return NGX_OK;
  5417.         }
  5418.     }

  5420.     return NGX_ERROR;
  5421. }

  5423. #endif


  5426. ngx_int_t
  5427. ‌ngx_ssl_get_protocol(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5428. {
  5429.     s->data = (u_char *) SSL_get_version(c->ssl->connection);
  5430.     return NGX_OK;
  5431. }


  5434. ngx_int_t
  5435. ‌ngx_ssl_get_cipher_name(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5436. {
  5437.     s->data = (u_char *) SSL_get_cipher_name(c->ssl->connection);
  5438.     return NGX_OK;
  5439. }


  5442. ngx_int_t
  5443. ‌ngx_ssl_get_ciphers(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5444. {
  5445. #ifdef SSL_CTRL_GET_RAW_CIPHERLIST

  5447.     int                n, i, bytes;
  5448.     size_t             len;
  5449.     u_char            *ciphers, *p;
  5450.     const SSL_CIPHER  *cipher;

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

  5455.     if (n <= 0) {
  5456.         s->len = 0;
  5457.         return NGX_OK;
  5458.     }

  5460.     len = 0;
  5461.     n /= bytes;

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

  5466.         if (cipher) {
  5467.             len += ngx_strlen(SSL_CIPHER_get_name(cipher));

  5469.         } else {
  5470.             len += sizeof("0x") - 1 + bytes * (sizeof("00") - 1);
  5471.         }

  5473.         len += sizeof(":") - 1;
  5474.     }

  5476.     s->data = ngx_pnalloc(pool, len);
  5477.     if (s->data == NULL) {
  5478.         return NGX_ERROR;
  5479.     }

  5481.     p = s->data;

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

  5486.         if (cipher) {
  5487.             p = ngx_sprintf(p, "%s", SSL_CIPHER_get_name(cipher));

  5489.         } else {
  5490.             p = ngx_sprintf(p, "0x");
  5491.             p = ngx_hex_dump(p, ciphers + i * bytes, bytes);
  5492.         }

  5494.         *p++ = ':';
  5495.     }

  5497.     p--;

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

  5501. #else

  5503.     u_char  buf[4096];

  5505.     if (SSL_get_shared_ciphers(c->ssl->connection, (char *) buf, 4096)
  5506.         == NULL)
  5507.     {
  5508.         s->len = 0;
  5509.         return NGX_OK;
  5510.     }

  5512.     s->len = ngx_strlen(buf);
  5513.     s->data = ngx_pnalloc(pool, s->len);
  5514.     if (s->data == NULL) {
  5515.         return NGX_ERROR;
  5516.     }

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

  5520. #endif

  5522.     return NGX_OK;
  5523. }


  5526. ngx_int_t
  5527. ‌ngx_ssl_get_curve(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5528. {
  5529. #ifdef SSL_get_negotiated_group

  5531.     int          nid;
  5532.     const char  *name;

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

  5536.     if (nid != NID_undef) {

  5538.         if ((nid & TLSEXT_nid_unknown) == 0) {
  5539.             s->len = ngx_strlen(OBJ_nid2sn(nid));
  5540.             s->data = (u_char *) OBJ_nid2sn(nid);
  5541.             return NGX_OK;
  5542.         }

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

  5546.         s->len = name ? ngx_strlen(name) : sizeof("0x0000") - 1;
  5547.         s->data = ngx_pnalloc(pool, s->len);
  5548.         if (s->data == NULL) {
  5549.             return NGX_ERROR;
  5550.         }

  5552.         if (name) {
  5553.             ngx_memcpy(s->data, name, s->len);

  5555.         } else {
  5556.             ngx_sprintf(s->data, "0x%04xd", nid & 0xffff);
  5557.         }

  5559.         return NGX_OK;
  5560.     }

  5562. #endif

  5564.     s->len = 0;
  5565.     return NGX_OK;
  5566. }


  5569. ngx_int_t
  5570. ‌ngx_ssl_get_curves(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5571. {
  5572. #ifdef SSL_CTRL_GET_CURVES

  5574.     int         *curves, n, i, nid;
  5575.     u_char      *p;
  5576.     size_t       len;
  5577.     const char  *name;

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

  5581.     if (n <= 0) {
  5582.         s->len = 0;
  5583.         return NGX_OK;
  5584.     }

  5586.     curves = ngx_palloc(pool, n * sizeof(int));
  5587.     if (curves == NULL) {
  5588.         return NGX_ERROR;
  5589.     }

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

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

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

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

  5602.         } else {
  5603.             len += ngx_strlen(OBJ_nid2sn(nid));
  5604.         }

  5606.         len += sizeof(":") - 1;
  5607.     }

  5609.     s->data = ngx_pnalloc(pool, len);
  5610.     if (s->data == NULL) {
  5611.         return NGX_ERROR;
  5612.     }

  5614.     p = s->data;

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

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

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

  5625.         } else {
  5626.             p = ngx_sprintf(p, "%s", OBJ_nid2sn(nid));
  5627.         }

  5629.         *p++ = ':';
  5630.     }

  5632.     p--;

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

  5636. #else

  5638.     s->len = 0;

  5640. #endif

  5642.     return NGX_OK;
  5643. }


  5646. ngx_int_t
  5647. ‌ngx_ssl_get_sigalg(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5648. {
  5649. #ifdef SSL_get0_signature_name

  5651.     const char  *name;

  5653.     if (SSL_get0_signature_name(c->ssl->connection, &name)) {
  5654.         s->len = ngx_strlen(name);
  5655.         s->data = ngx_pnalloc(pool, s->len);
  5656.         if (s->data == NULL) {
  5657.             return NGX_ERROR;
  5658.         }

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

  5662.         return NGX_OK;
  5663.     }

  5665. #endif

  5667.     s->len = 0;
  5668.     return NGX_OK;
  5669. }


  5672. ngx_int_t
  5673. ‌ngx_ssl_get_sigalgs(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5674. {
  5675. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)

  5677.     int            n, i;
  5678.     size_t         len;
  5679.     u_char        *p;
  5680.     const char    *name;
  5681.     unsigned int   codepoint;

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

  5685.     if (n <= 0) {
  5686.         s->len = 0;
  5687.         return NGX_OK;
  5688.     }

  5690.     len = 0;

  5692.     for (i = 0; i < n; i++) {
  5693.         SSL_get0_sigalg(c->ssl->connection, i, &codepoint, &name);
  5694.         len += name ? ngx_strlen(name) : sizeof("0x0000") - 1;
  5695.         len += sizeof(":") - 1;
  5696.     }

  5698.     s->data = ngx_pnalloc(pool, len);
  5699.     if (s->data == NULL) {
  5700.         return NGX_ERROR;
  5701.     }

  5703.     p = s->data;

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

  5708.         if (name) {
  5709.             p = ngx_cpymem(p, name, ngx_strlen(name));

  5711.         } else {
  5712.             p = ngx_sprintf(p, "0x%04xd", codepoint);
  5713.         }

  5715.         *p++ = ':';
  5716.     }

  5718.     p--;

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

  5722. #elif defined SSL_CTRL_SET_SIGALGS

  5724.     /*
  5725.      * SSL_get_sigalgs() is only available in OpenSSL 1.0.2+,
  5726.      * but uses a different naming, so emit raw codes
  5727.      */

  5729.     int             n, i;
  5730.     size_t          len;
  5731.     u_char         *p;
  5732.     unsigned char   rsig, rhash;

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

  5736.     if (n <= 0) {
  5737.         s->len = 0;
  5738.         return NGX_OK;
  5739.     }

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

  5743.     s->data = ngx_pnalloc(pool, len);
  5744.     if (s->data == NULL) {
  5745.         return NGX_ERROR;
  5746.     }

  5748.     p = s->data;

  5750.     for (i = 0; i < n; i++) {
  5751.         SSL_get_sigalgs(c->ssl->connection, i, NULL, NULL, NULL, &rsig, &rhash);
  5752.         p = ngx_sprintf(p, "0x%04xd", rhash << 8 | rsig);
  5753.         *p++ = ':';
  5754.     }

  5756.     p--;

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

  5760. #else

  5762.     s->len = 0;

  5764. #endif

  5766.     return NGX_OK;
  5767. }


  5770. ngx_int_t
  5771. ‌ngx_ssl_get_session_id(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5772. {
  5773.     u_char        *buf;
  5774.     SSL_SESSION   *sess;
  5775.     unsigned int   len;

  5777.     sess = SSL_get0_session(c->ssl->connection);
  5778.     if (sess == NULL) {
  5779.         s->len = 0;
  5780.         return NGX_OK;
  5781.     }

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

  5785.     s->len = 2 * len;
  5786.     s->data = ngx_pnalloc(pool, 2 * len);
  5787.     if (s->data == NULL) {
  5788.         return NGX_ERROR;
  5789.     }

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

  5793.     return NGX_OK;
  5794. }


  5797. ngx_int_t
  5798. ‌ngx_ssl_get_session_reused(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5799. {
  5800.     if (SSL_session_reused(c->ssl->connection)) {
  5801.         ngx_str_set(s, "r");

  5803.     } else {
  5804.         ngx_str_set(s, ".");
  5805.     }

  5807.     return NGX_OK;
  5808. }


  5811. ngx_int_t
  5812. ‌ngx_ssl_get_early_data(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5813. {
  5814.     s->len = 0;

  5816. #ifdef SSL_ERROR_EARLY_DATA_REJECTED

  5818.     /* BoringSSL */

  5820.     if (SSL_in_early_data(c->ssl->connection)) {
  5821.         ngx_str_set(s, "1");
  5822.     }

  5824. #elif defined SSL_READ_EARLY_DATA_SUCCESS

  5826.     /* OpenSSL */

  5828.     if (!SSL_is_init_finished(c->ssl->connection)) {
  5829.         ngx_str_set(s, "1");
  5830.     }

  5832. #endif

  5834.     return NGX_OK;
  5835. }


  5838. ngx_int_t
  5839. ‌ngx_ssl_get_server_name(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5840. {
  5841. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

  5843.     size_t       len;
  5844.     const char  *name;

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

  5848.     if (name) {
  5849.         len = ngx_strlen(name);

  5851.         s->len = len;
  5852.         s->data = ngx_pnalloc(pool, len);
  5853.         if (s->data == NULL) {
  5854.             return NGX_ERROR;
  5855.         }

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

  5859.         return NGX_OK;
  5860.     }

  5862. #endif

  5864.     s->len = 0;
  5865.     return NGX_OK;
  5866. }


  5869. ngx_int_t
  5870. ‌ngx_ssl_get_alpn_protocol(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5871. {
  5872. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  5874.     unsigned int          len;
  5875.     const unsigned char  *data;

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

  5879.     if (len > 0) {

  5881.         s->data = ngx_pnalloc(pool, len);
  5882.         if (s->data == NULL) {
  5883.             return NGX_ERROR;
  5884.         }

  5886.         ngx_memcpy(s->data, data, len);
  5887.         s->len = len;

  5889.         return NGX_OK;
  5890.     }

  5892. #endif

  5894.     s->len = 0;
  5895.     return NGX_OK;
  5896. }


  5899. ngx_int_t
  5900. ‌ngx_ssl_get_ech_status(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5901. {
  5902. #ifdef SSL_OP_ECH_GREASE
  5903.     int    echrv;
  5904.     char  *inner_sni, *outer_sni;

  5906.     inner_sni = NULL;
  5907.     outer_sni = NULL;

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

  5911.     switch (echrv) {
  5912.     case SSL_ECH_STATUS_NOT_TRIED:
  5913.         ngx_str_set(s, "NOT_TRIED");
  5914.         break;
  5915.     case SSL_ECH_STATUS_SUCCESS:
  5916.         ngx_str_set(s, "SUCCESS");
  5917.         break;
  5918.     case SSL_ECH_STATUS_GREASE:
  5919.         ngx_str_set(s, "GREASE");
  5920.         break;
  5921.     case SSL_ECH_STATUS_BACKEND:
  5922.         ngx_str_set(s, "BACKEND");
  5923.         break;
  5924.     default:
  5925.         ngx_str_set(s, "FAILED");
  5926.         break;
  5927.     }

  5929.     OPENSSL_free(inner_sni);
  5930.     OPENSSL_free(outer_sni);
  5931. #else
  5932.     s->len = 0;
  5933. #endif
  5934.     return NGX_OK;
  5935. }


  5938. ngx_int_t
  5939. ‌ngx_ssl_get_ech_outer_server_name(ngx_connection_t *c, ngx_pool_t *pool,
  5940.     ngx_str_t *s)
  5941. {
  5942. #if defined(SSL_OP_ECH_GREASE)
  5943.     int    echrv;
  5944.     char  *inner_sni, *outer_sni;

  5946.     inner_sni = NULL;
  5947.     outer_sni = NULL;

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

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

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

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

  5961.     } else {
  5962.         s->len = 0;
  5963.     }

  5965.     OPENSSL_free(inner_sni);
  5966.     OPENSSL_free(outer_sni);
  5967. #else
  5968.     s->len = 0;
  5969. #endif
  5970.     return NGX_OK;
  5971. }


  5974. ngx_int_t
  5975. ‌ngx_ssl_get_raw_certificate(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  5976. {
  5977.     size_t   len;
  5978.     BIO     *bio;
  5979.     X509    *cert;

  5981.     s->len = 0;

  5983.     cert = SSL_get_peer_certificate(c->ssl->connection);
  5984.     if (cert == NULL) {
  5985.         return NGX_OK;
  5986.     }

  5988.     bio = BIO_new(BIO_s_mem());
  5989.     if (bio == NULL) {
  5990.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  5991.         X509_free(cert);
  5992.         return NGX_ERROR;
  5993.     }

  5995.     if (PEM_write_bio_X509(bio, cert) == 0) {
  5996.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "PEM_write_bio_X509() failed");
  5997.         goto failed;
  5998.     }

  6000.     len = BIO_pending(bio);
  6001.     s->len = len;

  6003.     s->data = ngx_pnalloc(pool, len);
  6004.     if (s->data == NULL) {
  6005.         goto failed;
  6006.     }

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

  6010.     BIO_free(bio);
  6011.     X509_free(cert);

  6013.     return NGX_OK;

  6015. failed:

  6017.     BIO_free(bio);
  6018.     X509_free(cert);

  6020.     return NGX_ERROR;
  6021. }


  6024. ngx_int_t
  6025. ‌ngx_ssl_get_certificate(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6026. {
  6027.     u_char      *p;
  6028.     size_t       len;
  6029.     ngx_uint_t   i;
  6030.     ngx_str_t    cert;

  6032.     if (ngx_ssl_get_raw_certificate(c, pool, &cert) != NGX_OK) {
  6033.         return NGX_ERROR;
  6034.     }

  6036.     if (cert.len == 0) {
  6037.         s->len = 0;
  6038.         return NGX_OK;
  6039.     }

  6041.     len = cert.len - 1;

  6043.     for (i = 0; i < cert.len - 1; i++) {
  6044.         if (cert.data[i] == LF) {
  6045.             len++;
  6046.         }
  6047.     }

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

  6055.     p = s->data;

  6057.     for (i = 0; i < cert.len - 1; i++) {
  6058.         *p++ = cert.data[i];
  6059.         if (cert.data[i] == LF) {
  6060.             *p++ = '\t';
  6061.         }
  6062.     }

  6064.     return NGX_OK;
  6065. }


  6068. ngx_int_t
  6069. ‌ngx_ssl_get_escaped_certificate(ngx_connection_t *c, ngx_pool_t *pool,
  6070.     ngx_str_t *s)
  6071. {
  6072.     ngx_str_t  cert;
  6073.     uintptr_t  n;

  6075.     if (ngx_ssl_get_raw_certificate(c, pool, &cert) != NGX_OK) {
  6076.         return NGX_ERROR;
  6077.     }

  6079.     if (cert.len == 0) {
  6080.         s->len = 0;
  6081.         return NGX_OK;
  6082.     }

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

  6086.     s->len = cert.len + n * 2;
  6087.     s->data = ngx_pnalloc(pool, s->len);
  6088.     if (s->data == NULL) {
  6089.         return NGX_ERROR;
  6090.     }

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

  6094.     return NGX_OK;
  6095. }


  6098. ngx_int_t
  6099. ‌ngx_ssl_get_subject_dn(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6100. {
  6101.     BIO        *bio;
  6102.     X509       *cert;
  6103. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  6104.     const
  6105. #endif
  6106.     X509_NAME  *name;

  6108.     s->len = 0;

  6110.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6111.     if (cert == NULL) {
  6112.         return NGX_OK;
  6113.     }

  6115.     name = X509_get_subject_name(cert);
  6116.     if (name == NULL) {
  6117.         X509_free(cert);
  6118.         return NGX_ERROR;
  6119.     }

  6121.     bio = BIO_new(BIO_s_mem());
  6122.     if (bio == NULL) {
  6123.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6124.         X509_free(cert);
  6125.         return NGX_ERROR;
  6126.     }

  6128.     if (X509_NAME_print_ex(bio, name, 0, XN_FLAG_RFC2253) < 0) {
  6129.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_print_ex() failed");
  6130.         goto failed;
  6131.     }

  6133.     s->len = BIO_pending(bio);
  6134.     s->data = ngx_pnalloc(pool, s->len);
  6135.     if (s->data == NULL) {
  6136.         goto failed;
  6137.     }

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

  6141.     BIO_free(bio);
  6142.     X509_free(cert);

  6144.     return NGX_OK;

  6146. failed:

  6148.     BIO_free(bio);
  6149.     X509_free(cert);

  6151.     return NGX_ERROR;
  6152. }


  6155. ngx_int_t
  6156. ‌ngx_ssl_get_issuer_dn(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6157. {
  6158.     BIO        *bio;
  6159.     X509       *cert;
  6160. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  6161.     const
  6162. #endif
  6163.     X509_NAME  *name;

  6165.     s->len = 0;

  6167.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6168.     if (cert == NULL) {
  6169.         return NGX_OK;
  6170.     }

  6172.     name = X509_get_issuer_name(cert);
  6173.     if (name == NULL) {
  6174.         X509_free(cert);
  6175.         return NGX_ERROR;
  6176.     }

  6178.     bio = BIO_new(BIO_s_mem());
  6179.     if (bio == NULL) {
  6180.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6181.         X509_free(cert);
  6182.         return NGX_ERROR;
  6183.     }

  6185.     if (X509_NAME_print_ex(bio, name, 0, XN_FLAG_RFC2253) < 0) {
  6186.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_print_ex() failed");
  6187.         goto failed;
  6188.     }

  6190.     s->len = BIO_pending(bio);
  6191.     s->data = ngx_pnalloc(pool, s->len);
  6192.     if (s->data == NULL) {
  6193.         goto failed;
  6194.     }

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

  6198.     BIO_free(bio);
  6199.     X509_free(cert);

  6201.     return NGX_OK;

  6203. failed:

  6205.     BIO_free(bio);
  6206.     X509_free(cert);

  6208.     return NGX_ERROR;
  6209. }


  6212. ngx_int_t
  6213. ‌ngx_ssl_get_subject_dn_legacy(ngx_connection_t *c, ngx_pool_t *pool,
  6214.     ngx_str_t *s)
  6215. {
  6216.     char       *p;
  6217.     size_t      len;
  6218.     X509       *cert;
  6219. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  6220.     const
  6221. #endif
  6222.     X509_NAME  *name;

  6224.     s->len = 0;

  6226.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6227.     if (cert == NULL) {
  6228.         return NGX_OK;
  6229.     }

  6231.     name = X509_get_subject_name(cert);
  6232.     if (name == NULL) {
  6233.         X509_free(cert);
  6234.         return NGX_ERROR;
  6235.     }

  6237.     p = X509_NAME_oneline(name, NULL, 0);
  6238.     if (p == NULL) {
  6239.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_oneline() failed");
  6240.         X509_free(cert);
  6241.         return NGX_ERROR;
  6242.     }

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

  6246.     s->len = len;
  6247.     s->data = ngx_pnalloc(pool, len);
  6248.     if (s->data == NULL) {
  6249.         OPENSSL_free(p);
  6250.         X509_free(cert);
  6251.         return NGX_ERROR;
  6252.     }

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

  6256.     OPENSSL_free(p);
  6257.     X509_free(cert);

  6259.     return NGX_OK;
  6260. }


  6263. ngx_int_t
  6264. ‌ngx_ssl_get_issuer_dn_legacy(ngx_connection_t *c, ngx_pool_t *pool,
  6265.     ngx_str_t *s)
  6266. {
  6267.     char       *p;
  6268.     size_t      len;
  6269.     X509       *cert;
  6270. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  6271.     const
  6272. #endif
  6273.     X509_NAME  *name;

  6275.     s->len = 0;

  6277.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6278.     if (cert == NULL) {
  6279.         return NGX_OK;
  6280.     }

  6282.     name = X509_get_issuer_name(cert);
  6283.     if (name == NULL) {
  6284.         X509_free(cert);
  6285.         return NGX_ERROR;
  6286.     }

  6288.     p = X509_NAME_oneline(name, NULL, 0);
  6289.     if (p == NULL) {
  6290.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_NAME_oneline() failed");
  6291.         X509_free(cert);
  6292.         return NGX_ERROR;
  6293.     }

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

  6297.     s->len = len;
  6298.     s->data = ngx_pnalloc(pool, len);
  6299.     if (s->data == NULL) {
  6300.         OPENSSL_free(p);
  6301.         X509_free(cert);
  6302.         return NGX_ERROR;
  6303.     }

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

  6307.     OPENSSL_free(p);
  6308.     X509_free(cert);

  6310.     return NGX_OK;
  6311. }


  6314. ngx_int_t
  6315. ‌ngx_ssl_get_serial_number(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6316. {
  6317.     size_t   len;
  6318.     X509    *cert;
  6319.     BIO     *bio;

  6321.     s->len = 0;

  6323.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6324.     if (cert == NULL) {
  6325.         return NGX_OK;
  6326.     }

  6328.     bio = BIO_new(BIO_s_mem());
  6329.     if (bio == NULL) {
  6330.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6331.         X509_free(cert);
  6332.         return NGX_ERROR;
  6333.     }

  6335.     i2a_ASN1_INTEGER(bio, X509_get_serialNumber(cert));
  6336.     len = BIO_pending(bio);

  6338.     s->len = len;
  6339.     s->data = ngx_pnalloc(pool, len);
  6340.     if (s->data == NULL) {
  6341.         BIO_free(bio);
  6342.         X509_free(cert);
  6343.         return NGX_ERROR;
  6344.     }

  6346.     BIO_read(bio, s->data, len);
  6347.     BIO_free(bio);
  6348.     X509_free(cert);

  6350.     return NGX_OK;
  6351. }


  6354. ngx_int_t
  6355. ‌ngx_ssl_get_fingerprint(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6356. {
  6357.     X509          *cert;
  6358.     unsigned int   len;
  6359.     u_char         buf[EVP_MAX_MD_SIZE];

  6361.     s->len = 0;

  6363.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6364.     if (cert == NULL) {
  6365.         return NGX_OK;
  6366.     }

  6368.     if (!X509_digest(cert, EVP_sha1(), buf, &len)) {
  6369.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "X509_digest() failed");
  6370.         X509_free(cert);
  6371.         return NGX_ERROR;
  6372.     }

  6374.     s->len = 2 * len;
  6375.     s->data = ngx_pnalloc(pool, 2 * len);
  6376.     if (s->data == NULL) {
  6377.         X509_free(cert);
  6378.         return NGX_ERROR;
  6379.     }

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

  6383.     X509_free(cert);

  6385.     return NGX_OK;
  6386. }


  6389. ngx_int_t
  6390. ‌ngx_ssl_get_client_verify(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6391. {
  6392.     X509        *cert;
  6393.     long         rc;
  6394.     const char  *str;

  6396.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6397.     if (cert == NULL) {
  6398.         ngx_str_set(s, "NONE");
  6399.         return NGX_OK;
  6400.     }

  6402.     X509_free(cert);

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

  6406.     if (rc == X509_V_OK) {
  6407.         if (ngx_ssl_ocsp_get_status(c, &str) == NGX_OK) {
  6408.             ngx_str_set(s, "SUCCESS");
  6409.             return NGX_OK;
  6410.         }

  6412.     } else {
  6413.         str = X509_verify_cert_error_string(rc);
  6414.     }

  6416.     s->data = ngx_pnalloc(pool, sizeof("FAILED:") - 1 + ngx_strlen(str));
  6417.     if (s->data == NULL) {
  6418.         return NGX_ERROR;
  6419.     }

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

  6423.     return NGX_OK;
  6424. }


  6427. ngx_int_t
  6428. ‌ngx_ssl_get_client_v_start(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6429. {
  6430.     BIO     *bio;
  6431.     X509    *cert;
  6432.     size_t   len;

  6434.     s->len = 0;

  6436.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6437.     if (cert == NULL) {
  6438.         return NGX_OK;
  6439.     }

  6441.     bio = BIO_new(BIO_s_mem());
  6442.     if (bio == NULL) {
  6443.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6444.         X509_free(cert);
  6445.         return NGX_ERROR;
  6446.     }

  6448. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  6449.     ASN1_TIME_print(bio, X509_get0_notBefore(cert));
  6450. #else
  6451.     ASN1_TIME_print(bio, X509_get_notBefore(cert));
  6452. #endif

  6454.     len = BIO_pending(bio);

  6456.     s->len = len;
  6457.     s->data = ngx_pnalloc(pool, len);
  6458.     if (s->data == NULL) {
  6459.         BIO_free(bio);
  6460.         X509_free(cert);
  6461.         return NGX_ERROR;
  6462.     }

  6464.     BIO_read(bio, s->data, len);
  6465.     BIO_free(bio);
  6466.     X509_free(cert);

  6468.     return NGX_OK;
  6469. }


  6472. ngx_int_t
  6473. ‌ngx_ssl_get_client_v_end(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6474. {
  6475.     BIO     *bio;
  6476.     X509    *cert;
  6477.     size_t   len;

  6479.     s->len = 0;

  6481.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6482.     if (cert == NULL) {
  6483.         return NGX_OK;
  6484.     }

  6486.     bio = BIO_new(BIO_s_mem());
  6487.     if (bio == NULL) {
  6488.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "BIO_new() failed");
  6489.         X509_free(cert);
  6490.         return NGX_ERROR;
  6491.     }

  6493. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  6494.     ASN1_TIME_print(bio, X509_get0_notAfter(cert));
  6495. #else
  6496.     ASN1_TIME_print(bio, X509_get_notAfter(cert));
  6497. #endif

  6499.     len = BIO_pending(bio);

  6501.     s->len = len;
  6502.     s->data = ngx_pnalloc(pool, len);
  6503.     if (s->data == NULL) {
  6504.         BIO_free(bio);
  6505.         X509_free(cert);
  6506.         return NGX_ERROR;
  6507.     }

  6509.     BIO_read(bio, s->data, len);
  6510.     BIO_free(bio);
  6511.     X509_free(cert);

  6513.     return NGX_OK;
  6514. }


  6517. ngx_int_t
  6518. ‌ngx_ssl_get_client_v_remain(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6519. {
  6520.     X509    *cert;
  6521.     time_t   now, end;

  6523.     s->len = 0;

  6525.     cert = SSL_get_peer_certificate(c->ssl->connection);
  6526.     if (cert == NULL) {
  6527.         return NGX_OK;
  6528.     }

  6530. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  6531.     end = ngx_ssl_parse_time(X509_get0_notAfter(cert), c->log);
  6532. #else
  6533.     end = ngx_ssl_parse_time(X509_get_notAfter(cert), c->log);
  6534. #endif

  6536.     if (end == (time_t) NGX_ERROR) {
  6537.         X509_free(cert);
  6538.         return NGX_OK;
  6539.     }

  6541.     now = ngx_time();

  6543.     if (end < now + 86400) {
  6544.         ngx_str_set(s, "0");
  6545.         X509_free(cert);
  6546.         return NGX_OK;
  6547.     }

  6549.     s->data = ngx_pnalloc(pool, NGX_TIME_T_LEN);
  6550.     if (s->data == NULL) {
  6551.         X509_free(cert);
  6552.         return NGX_ERROR;
  6553.     }

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

  6557.     X509_free(cert);

  6559.     return NGX_OK;
  6560. }


  6563. static time_t
  6564. ‌ngx_ssl_parse_time(
  6565. #if OPENSSL_VERSION_NUMBER > 0x10100000L
  6566.     const
  6567. #endif
  6568.     ASN1_TIME *asn1time, ngx_log_t *log)
  6569. {
  6570.     BIO     *bio;
  6571.     char    *value;
  6572.     size_t   len;
  6573.     time_t   time;

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

  6582.     bio = BIO_new(BIO_s_mem());
  6583.     if (bio == NULL) {
  6584.         ngx_ssl_error(NGX_LOG_ALERT, log, 0, "BIO_new() failed");
  6585.         return NGX_ERROR;
  6586.     }

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

  6590.     BIO_write(bio, "Tue ", sizeof("Tue ") - 1);
  6591.     ASN1_TIME_print(bio, asn1time);
  6592.     len = BIO_get_mem_data(bio, &value);

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

  6596.     BIO_free(bio);

  6598.     return time;
  6599. }


  6602. ngx_int_t
  6603. ‌ngx_ssl_get_client_sigalg(ngx_connection_t *c, ngx_pool_t *pool, ngx_str_t *s)
  6604. {
  6605. #ifdef SSL_get0_peer_signature_name

  6607.     const char  *name;

  6609.     if (SSL_get0_peer_signature_name(c->ssl->connection, &name)) {
  6610.         s->len = ngx_strlen(name);
  6611.         s->data = ngx_pnalloc(pool, s->len);
  6612.         if (s->data == NULL) {
  6613.             return NGX_ERROR;
  6614.         }

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

  6618.         return NGX_OK;
  6619.     }

  6621. #endif

  6623.     s->len = 0;
  6624.     return NGX_OK;
  6625. }


  6628. static void *
  6629. ‌ngx_openssl_create_conf(ngx_cycle_t *cycle)
  6630. {
  6631.     ngx_openssl_conf_t  *oscf;

  6633.     oscf = ngx_pcalloc(cycle->pool, sizeof(ngx_openssl_conf_t));
  6634.     if (oscf == NULL) {
  6635.         return NULL;
  6636.     }

  6638.     /*
  6639.      * set by ngx_pcalloc():
  6640.      *
  6641.      *     oscf->engine = 0;
  6642.      */

  6644.     return oscf;
  6645. }


  6648. static char *
  6649. ‌ngx_openssl_engine(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  6650. {
  6651. #ifndef OPENSSL_NO_ENGINE

  6653.     ngx_openssl_conf_t *oscf = conf;

  6655.     ENGINE     *engine;
  6656.     ngx_str_t  *value;

  6658.     if (oscf->engine) {
  6659.         return "is duplicate";
  6660.     }

  6662.     oscf->engine = 1;

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

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

  6668.     if (engine == NULL) {
  6669.         ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
  6670.                       "ENGINE_by_id(\"%V\") failed", &value[1]);
  6671.         return NGX_CONF_ERROR;
  6672.     }

  6674.     if (ENGINE_set_default(engine, ENGINE_METHOD_ALL) == 0) {
  6675.         ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
  6676.                       "ENGINE_set_default(\"%V\", ENGINE_METHOD_ALL) failed",
  6677.                       &value[1]);

  6679.         ENGINE_free(engine);

  6681.         return NGX_CONF_ERROR;
  6682.     }

  6684.     ENGINE_free(engine);

  6686.     return NGX_CONF_OK;

  6688. #else

  6690.     return "is not supported";

  6692. #endif
  6693. }


  6696. static void
  6697. ‌ngx_openssl_exit(ngx_cycle_t *cycle)
  6698. {
  6699. #if OPENSSL_VERSION_NUMBER < 0x10100003L

  6701.     EVP_cleanup();
  6702. #ifndef OPENSSL_NO_ENGINE
  6703.     ENGINE_cleanup();
  6704. #endif

  6706. #endif
  6707. }

One Level Up Top Level