One Level Up Top Level

src/event/ngx_event_openssl_cache.c - nginx

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


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


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

  11. #ifdef ERR_R_OSSL_STORE_LIB
  12. #include <openssl/store.h>
  13. #include <openssl/ui.h>
  14. #endif


  17. ‌#define NGX_SSL_CACHE_PATH    0
  18. ‌#define NGX_SSL_CACHE_DATA    1
  19. ‌#define NGX_SSL_CACHE_ENGINE  2
  20. ‌#define NGX_SSL_CACHE_STORE   3

  22. ‌#define NGX_SSL_CACHE_DISABLED  (ngx_array_t *) (uintptr_t) -1


  25. ‌#define ngx_ssl_cache_get_conf(cycle)                                         \
  26.     (ngx_ssl_cache_t *) ngx_get_conf(cycle->conf_ctx, ngx_openssl_cache_module)

  28. ‌#define ngx_ssl_cache_get_old_conf(cycle)                                     \
  29.     cycle->old_cycle->conf_ctx ? ngx_ssl_cache_get_conf(cycle->old_cycle)     \
  30.                                : NULL


  33. ‌typedef struct {
  34.     unsigned                    type:2;
  35.     unsigned                    len:30;
  36.     u_char                     *data;
  37. ‌} ngx_ssl_cache_key_t;


  40. ‌typedef void *(*ngx_ssl_cache_create_pt)(ngx_ssl_cache_key_t *id, char **err,
  41.     void *data);
  42. ‌typedef void (*ngx_ssl_cache_free_pt)(void *data);
  43. ‌typedef void *(*ngx_ssl_cache_ref_pt)(char **err, void *data);


  46. ‌typedef struct {
  47.     ngx_ssl_cache_create_pt     create;
  48.     ngx_ssl_cache_free_pt       free;
  49.     ngx_ssl_cache_ref_pt        ref;
  50. ‌} ngx_ssl_cache_type_t;


  53. ‌typedef struct {
  54.     ngx_rbtree_node_t           node;
  55.     ngx_queue_t                 queue;
  56.     ngx_ssl_cache_key_t         id;
  57.     ngx_ssl_cache_type_t       *type;
  58.     void                       *value;

  60.     time_t                      created;
  61.     time_t                      accessed;

  63.     time_t                      mtime;
  64.     ngx_file_uniq_t             uniq;
  65. ‌} ngx_ssl_cache_node_t;


  68. ‌struct ngx_ssl_cache_s {
  69.     ngx_rbtree_t                rbtree;
  70.     ngx_rbtree_node_t           sentinel;
  71.     ngx_queue_t                 expire_queue;

  73.     ngx_flag_t                  inheritable;

  75.     ngx_uint_t                  current;
  76.     ngx_uint_t                  max;
  77.     time_t                      valid;
  78.     time_t                      inactive;
  79. };


  82. ‌typedef struct {
  83.     ngx_str_t                  *pwd;
  84.     unsigned                    encrypted:1;
  85. ‌} ngx_ssl_cache_pwd_t;


  88. static ngx_int_t ngx_ssl_cache_init_key(ngx_pool_t *pool, ngx_uint_t index,
  89.     ngx_str_t *path, ngx_ssl_cache_key_t *id);
  90. static ngx_ssl_cache_node_t *ngx_ssl_cache_lookup(ngx_ssl_cache_t *cache,
  91.     ngx_ssl_cache_type_t *type, ngx_ssl_cache_key_t *id, uint32_t hash);
  92. static void ngx_ssl_cache_expire(ngx_ssl_cache_t *cache, ngx_uint_t n,
  93.     ngx_log_t *log);

  95. static void *ngx_ssl_cache_cert_create(ngx_ssl_cache_key_t *id, char **err,
  96.     void *data);
  97. static void ngx_ssl_cache_cert_free(void *data);
  98. static void *ngx_ssl_cache_cert_ref(char **err, void *data);

  100. static void *ngx_ssl_cache_pkey_create(ngx_ssl_cache_key_t *id, char **err,
  101.     void *data);
  102. static int ngx_ssl_cache_pkey_password_callback(char *buf, int size, int rwflag,
  103.     void *userdata);
  104. static void ngx_ssl_cache_pkey_free(void *data);
  105. static void *ngx_ssl_cache_pkey_ref(char **err, void *data);

  107. static void *ngx_ssl_cache_crl_create(ngx_ssl_cache_key_t *id, char **err,
  108.     void *data);
  109. static void ngx_ssl_cache_crl_free(void *data);
  110. static void *ngx_ssl_cache_crl_ref(char **err, void *data);

  112. static void *ngx_ssl_cache_ca_create(ngx_ssl_cache_key_t *id, char **err,
  113.     void *data);

  115. static BIO *ngx_ssl_cache_create_bio(ngx_ssl_cache_key_t *id, char **err);

  117. static void *ngx_openssl_cache_create_conf(ngx_cycle_t *cycle);
  118. static char *ngx_openssl_cache_init_conf(ngx_cycle_t *cycle, void *conf);
  119. static void ngx_ssl_cache_cleanup(void *data);
  120. static void ngx_ssl_cache_node_insert(ngx_rbtree_node_t *temp,
  121.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);
  122. static void ngx_ssl_cache_node_free(ngx_rbtree_t *rbtree,
  123.     ngx_ssl_cache_node_t *cn);

  125. static ngx_int_t ngx_openssl_cache_init_worker(ngx_cycle_t *cycle);


  128. ‌static ngx_command_t  ngx_openssl_cache_commands[] = {

  130.     { ngx_string("ssl_object_cache_inheritable"),
  131.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_FLAG,
  132.       ngx_conf_set_flag_slot,
  133.       0,
  134.       offsetof(ngx_ssl_cache_t, inheritable),
  135.       NULL },

  137.       ngx_null_command
  138. };


  141. ‌static ngx_core_module_t  ngx_openssl_cache_module_ctx = {
  142.     ngx_string("openssl_cache"),
  143.     ngx_openssl_cache_create_conf,
  144.     ngx_openssl_cache_init_conf
  145. };


  148. ‌ngx_module_t  ngx_openssl_cache_module = {
  149.     NGX_MODULE_V1,
  150.     &ngx_openssl_cache_module_ctx,         /* module context */
  151.     ngx_openssl_cache_commands,            /* module directives */
  152.     NGX_CORE_MODULE,                       /* module type */
  153.     NULL,                                  /* init master */
  154.     NULL,                                  /* init module */
  155.     ngx_openssl_cache_init_worker,         /* init process */
  156.     NULL,                                  /* init thread */
  157.     NULL,                                  /* exit thread */
  158.     NULL,                                  /* exit process */
  159.     NULL,                                  /* exit master */
  160.     NGX_MODULE_V1_PADDING
  161. };


  164. ‌static ngx_ssl_cache_type_t  ngx_ssl_cache_types[] = {

  166.     /* NGX_SSL_CACHE_CERT */
  167.     { ngx_ssl_cache_cert_create,
  168.       ngx_ssl_cache_cert_free,
  169.       ngx_ssl_cache_cert_ref },

  171.     /* NGX_SSL_CACHE_PKEY */
  172.     { ngx_ssl_cache_pkey_create,
  173.       ngx_ssl_cache_pkey_free,
  174.       ngx_ssl_cache_pkey_ref },

  176.     /* NGX_SSL_CACHE_CRL */
  177.     { ngx_ssl_cache_crl_create,
  178.       ngx_ssl_cache_crl_free,
  179.       ngx_ssl_cache_crl_ref },

  181.     /* NGX_SSL_CACHE_CA */
  182.     { ngx_ssl_cache_ca_create,
  183.       ngx_ssl_cache_cert_free,
  184.       ngx_ssl_cache_cert_ref }
  185. };


  188. void *
  189. ‌ngx_ssl_cache_fetch(ngx_conf_t *cf, ngx_uint_t index, char **err,
  190.     ngx_str_t *path, void *data)
  191. {
  192.     void                  *value;
  193.     time_t                 mtime;
  194.     uint32_t               hash;
  195.     ngx_int_t              rc;
  196.     ngx_uint_t             invalidate;
  197.     ngx_file_uniq_t        uniq;
  198.     ngx_file_info_t        fi;
  199.     ngx_ssl_cache_t       *cache, *old_cache;
  200.     ngx_ssl_cache_key_t    id;
  201.     ngx_ssl_cache_type_t  *type;
  202.     ngx_ssl_cache_node_t  *cn;

  204.     *err = NULL;

  206.     invalidate = index & NGX_SSL_CACHE_INVALIDATE;
  207.     index &= ~NGX_SSL_CACHE_INVALIDATE;

  209.     if (ngx_ssl_cache_init_key(cf->pool, index, path, &id) != NGX_OK) {
  210.         return NULL;
  211.     }

  213.     if (id.type == NGX_SSL_CACHE_DATA) {
  214.         invalidate = 0;
  215.     }

  217.     cache = (ngx_ssl_cache_t *) ngx_get_conf(cf->cycle->conf_ctx,
  218.                                              ngx_openssl_cache_module);

  220.     type = &ngx_ssl_cache_types[index];
  221.     hash = ngx_murmur_hash2(id.data, id.len);

  223.     cn = ngx_ssl_cache_lookup(cache, type, &id, hash);

  225.     if (cn != NULL) {
  226.         if (!invalidate) {
  227.             return type->ref(err, cn->value);
  228.         }

  230.         type->free(cn->value);
  231.         ngx_rbtree_delete(&cache->rbtree, &cn->node);
  232.     }

  234.     value = NULL;

  236.     if (id.type == NGX_SSL_CACHE_PATH
  237.         && (rc = ngx_file_info(id.data, &fi)) != NGX_FILE_ERROR)
  238.     {
  239.         mtime = ngx_file_mtime(&fi);
  240.         uniq = ngx_file_uniq(&fi);

  242.     } else {
  243.         rc = NGX_FILE_ERROR;
  244.         mtime = 0;
  245.         uniq = 0;
  246.     }

  248.     /* try to use a reference from the old cycle */

  250.     old_cache = ngx_ssl_cache_get_old_conf(cf->cycle);

  252.     if (old_cache && old_cache->inheritable && !invalidate) {
  253.         cn = ngx_ssl_cache_lookup(old_cache, type, &id, hash);

  255.         if (cn != NULL) {
  256.             switch (id.type) {

  258.             case NGX_SSL_CACHE_DATA:
  259.                 value = type->ref(err, cn->value);
  260.                 break;

  262.             default:
  263.                 if (rc != NGX_FILE_ERROR
  264.                     && uniq == cn->uniq && mtime == cn->mtime)
  265.                 {
  266.                     value = type->ref(err, cn->value);
  267.                 }
  268.                 break;
  269.             }
  270.         }
  271.     }

  273.     if (value == NULL) {
  274.         value = type->create(&id, err, &data);

  276.         if (value == NULL || data == NGX_SSL_CACHE_DISABLED) {
  277.             return value;
  278.         }
  279.     }

  281.     cn = ngx_palloc(cf->pool, sizeof(ngx_ssl_cache_node_t) + id.len + 1);
  282.     if (cn == NULL) {
  283.         type->free(value);
  284.         return NULL;
  285.     }

  287.     cn->node.key = hash;
  288.     cn->id.data = (u_char *)(cn + 1);
  289.     cn->id.len = id.len;
  290.     cn->id.type = id.type;
  291.     cn->type = type;
  292.     cn->value = value;
  293.     cn->mtime = mtime;
  294.     cn->uniq = uniq;

  296.     ngx_cpystrn(cn->id.data, id.data, id.len + 1);

  298.     ngx_queue_init(&cn->queue);

  300.     ngx_rbtree_insert(&cache->rbtree, &cn->node);

  302.     return type->ref(err, cn->value);
  303. }


  306. void *
  307. ‌ngx_ssl_cache_connection_fetch(ngx_ssl_cache_t *cache, ngx_pool_t *pool,
  308.     ngx_uint_t index, char **err, ngx_str_t *path, void *data)
  309. {
  310.     void                  *value;
  311.     time_t                 now;
  312.     uint32_t               hash;
  313.     ngx_uint_t             invalidate;
  314.     ngx_file_info_t        fi;
  315.     ngx_ssl_cache_key_t    id;
  316.     ngx_ssl_cache_type_t  *type;
  317.     ngx_ssl_cache_node_t  *cn;

  319.     *err = NULL;

  321.     invalidate = index & NGX_SSL_CACHE_INVALIDATE;
  322.     index &= ~NGX_SSL_CACHE_INVALIDATE;

  324.     if (ngx_ssl_cache_init_key(pool, index, path, &id) != NGX_OK) {
  325.         return NULL;
  326.     }

  328.     type = &ngx_ssl_cache_types[index];

  330.     if (cache == NULL) {
  331.         return type->create(&id, err, &data);
  332.     }

  334.     now = ngx_time();

  336.     hash = ngx_murmur_hash2(id.data, id.len);

  338.     cn = ngx_ssl_cache_lookup(cache, type, &id, hash);

  340.     if (cn != NULL) {
  341.         ngx_queue_remove(&cn->queue);

  343.         if (id.type == NGX_SSL_CACHE_DATA) {
  344.             goto found;
  345.         }

  347.         if (!invalidate && now - cn->created <= cache->valid) {
  348.             goto found;
  349.         }

  351.         switch (id.type) {

  353.         case NGX_SSL_CACHE_PATH:

  355.             if (ngx_file_info(id.data, &fi) != NGX_FILE_ERROR) {

  357.                 if (!invalidate
  358.                     && ngx_file_uniq(&fi) == cn->uniq
  359.                     && ngx_file_mtime(&fi) == cn->mtime)
  360.                 {
  361.                     break;
  362.                 }

  364.                 cn->mtime = ngx_file_mtime(&fi);
  365.                 cn->uniq = ngx_file_uniq(&fi);

  367.             } else {
  368.                 cn->mtime = 0;
  369.                 cn->uniq = 0;
  370.             }

  372.             /* fall through */

  374.         default:
  375.             ngx_log_debug1(NGX_LOG_DEBUG_CORE, pool->log, 0,
  376.                            "update cached ssl object: %s", cn->id.data);

  378.             type->free(cn->value);

  380.             value = type->create(&id, err, &data);

  382.             if (value == NULL || data == NGX_SSL_CACHE_DISABLED) {
  383.                 ngx_rbtree_delete(&cache->rbtree, &cn->node);

  385.                 cache->current--;

  387.                 ngx_free(cn);

  389.                 return value;
  390.             }

  392.             cn->value = value;
  393.         }

  395.         cn->created = now;

  397.         goto found;
  398.     }

  400.     value = type->create(&id, err, &data);

  402.     if (value == NULL || data == NGX_SSL_CACHE_DISABLED) {
  403.         return value;
  404.     }

  406.     cn = ngx_alloc(sizeof(ngx_ssl_cache_node_t) + id.len + 1, pool->log);
  407.     if (cn == NULL) {
  408.         type->free(value);
  409.         return NULL;
  410.     }

  412.     cn->node.key = hash;
  413.     cn->id.data = (u_char *)(cn + 1);
  414.     cn->id.len = id.len;
  415.     cn->id.type = id.type;
  416.     cn->type = type;
  417.     cn->value = value;
  418.     cn->created = now;

  420.     ngx_cpystrn(cn->id.data, id.data, id.len + 1);

  422.     if (id.type == NGX_SSL_CACHE_PATH) {

  424.         if (ngx_file_info(id.data, &fi) != NGX_FILE_ERROR) {
  425.             cn->mtime = ngx_file_mtime(&fi);
  426.             cn->uniq = ngx_file_uniq(&fi);

  428.         } else {
  429.             cn->mtime = 0;
  430.             cn->uniq = 0;
  431.         }
  432.     }

  434.     ngx_ssl_cache_expire(cache, 1, pool->log);

  436.     if (cache->current >= cache->max) {
  437.         ngx_ssl_cache_expire(cache, 0, pool->log);
  438.     }

  440.     ngx_rbtree_insert(&cache->rbtree, &cn->node);

  442.     cache->current++;

  444. found:

  446.     cn->accessed = now;

  448.     ngx_queue_insert_head(&cache->expire_queue, &cn->queue);

  450.     return type->ref(err, cn->value);
  451. }


  454. static ngx_int_t
  455. ‌ngx_ssl_cache_init_key(ngx_pool_t *pool, ngx_uint_t index, ngx_str_t *path,
  456.     ngx_ssl_cache_key_t *id)
  457. {
  458.     if (index <= NGX_SSL_CACHE_PKEY
  459.         && ngx_strncmp(path->data, "data:", sizeof("data:") - 1) == 0)
  460.     {
  461.         id->type = NGX_SSL_CACHE_DATA;

  463.     } else if (index == NGX_SSL_CACHE_PKEY
  464.         && ngx_strncmp(path->data, "engine:", sizeof("engine:") - 1) == 0)
  465.     {
  466.         id->type = NGX_SSL_CACHE_ENGINE;

  468.     } else if (index == NGX_SSL_CACHE_PKEY
  469.         && ngx_strncmp(path->data, "store:", sizeof("store:") - 1) == 0)
  470.     {
  471.         id->type = NGX_SSL_CACHE_STORE;

  473.     } else {
  474.         if (ngx_get_full_name(pool, (ngx_str_t *) &ngx_cycle->conf_prefix, path)
  475.             != NGX_OK)
  476.         {
  477.             return NGX_ERROR;
  478.         }

  480.         id->type = NGX_SSL_CACHE_PATH;
  481.     }

  483.     id->len = path->len;
  484.     id->data = path->data;

  486.     return NGX_OK;
  487. }


  490. static ngx_ssl_cache_node_t *
  491. ‌ngx_ssl_cache_lookup(ngx_ssl_cache_t *cache, ngx_ssl_cache_type_t *type,
  492.     ngx_ssl_cache_key_t *id, uint32_t hash)
  493. {
  494.     ngx_int_t              rc;
  495.     ngx_rbtree_node_t     *node, *sentinel;
  496.     ngx_ssl_cache_node_t  *cn;

  498.     node = cache->rbtree.root;
  499.     sentinel = cache->rbtree.sentinel;

  501.     while (node != sentinel) {

  503.         if (hash < node->key) {
  504.             node = node->left;
  505.             continue;
  506.         }

  508.         if (hash > node->key) {
  509.             node = node->right;
  510.             continue;
  511.         }

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

  515.         cn = (ngx_ssl_cache_node_t *) node;

  517.         if (type < cn->type) {
  518.             node = node->left;
  519.             continue;
  520.         }

  522.         if (type > cn->type) {
  523.             node = node->right;
  524.             continue;
  525.         }

  527.         /* type == cn->type */

  529.         rc = ngx_memn2cmp(id->data, cn->id.data, id->len, cn->id.len);

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

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

  538.     return NULL;
  539. }


  542. static void
  543. ‌ngx_ssl_cache_expire(ngx_ssl_cache_t *cache, ngx_uint_t n,
  544.     ngx_log_t *log)
  545. {
  546.     time_t                 now;
  547.     ngx_queue_t           *q;
  548.     ngx_ssl_cache_node_t  *cn;

  550.     now = ngx_time();

  552.     while (n < 3) {

  554.         if (ngx_queue_empty(&cache->expire_queue)) {
  555.             return;
  556.         }

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

  560.         cn = ngx_queue_data(q, ngx_ssl_cache_node_t, queue);

  562.         if (n++ != 0 && now - cn->accessed <= cache->inactive) {
  563.             return;
  564.         }

  566.         ngx_ssl_cache_node_free(&cache->rbtree, cn);

  568.         cache->current--;
  569.     }
  570. }


  573. static void *
  574. ‌ngx_ssl_cache_cert_create(ngx_ssl_cache_key_t *id, char **err, void *data)
  575. {
  576.     BIO             *bio;
  577.     X509            *x509;
  578.     u_long           n;
  579.     STACK_OF(X509)  *chain;

  581.     chain = sk_X509_new_null();
  582.     if (chain == NULL) {
  583.         *err = "sk_X509_new_null() failed";
  584.         return NULL;
  585.     }

  587.     bio = ngx_ssl_cache_create_bio(id, err);
  588.     if (bio == NULL) {
  589.         sk_X509_pop_free(chain, X509_free);
  590.         return NULL;
  591.     }

  593.     /* certificate itself */

  595.     x509 = PEM_read_bio_X509_AUX(bio, NULL, NULL, NULL);
  596.     if (x509 == NULL) {
  597.         *err = "PEM_read_bio_X509_AUX() failed";
  598.         BIO_free(bio);
  599.         sk_X509_pop_free(chain, X509_free);
  600.         return NULL;
  601.     }

  603.     if (sk_X509_push(chain, x509) == 0) {
  604.         *err = "sk_X509_push() failed";
  605.         BIO_free(bio);
  606.         X509_free(x509);
  607.         sk_X509_pop_free(chain, X509_free);
  608.         return NULL;
  609.     }

  611.     /* rest of the chain */

  613.     for ( ;; ) {

  615.         x509 = PEM_read_bio_X509(bio, NULL, NULL, NULL);
  616.         if (x509 == NULL) {
  617.             n = ERR_peek_last_error();

  619.             if (ERR_GET_LIB(n) == ERR_LIB_PEM
  620.                 && ERR_GET_REASON(n) == PEM_R_NO_START_LINE)
  621.             {
  622.                 /* end of file */
  623.                 ERR_clear_error();
  624.                 break;
  625.             }

  627.             /* some real error */

  629.             *err = "PEM_read_bio_X509() failed";
  630.             BIO_free(bio);
  631.             sk_X509_pop_free(chain, X509_free);
  632.             return NULL;
  633.         }

  635.         if (sk_X509_push(chain, x509) == 0) {
  636.             *err = "sk_X509_push() failed";
  637.             BIO_free(bio);
  638.             X509_free(x509);
  639.             sk_X509_pop_free(chain, X509_free);
  640.             return NULL;
  641.         }
  642.     }

  644.     BIO_free(bio);

  646.     return chain;
  647. }


  650. static void
  651. ‌ngx_ssl_cache_cert_free(void *data)
  652. {
  653.     sk_X509_pop_free(data, X509_free);
  654. }


  657. static void *
  658. ‌ngx_ssl_cache_cert_ref(char **err, void *data)
  659. {
  660.     int              n, i;
  661.     X509            *x509;
  662.     STACK_OF(X509)  *chain;

  664.     chain = sk_X509_dup(data);
  665.     if (chain == NULL) {
  666.         *err = "sk_X509_dup() failed";
  667.         return NULL;
  668.     }

  670.     n = sk_X509_num(chain);

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

  675. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L)
  676.         X509_up_ref(x509);
  677. #else
  678.         CRYPTO_add(&x509->references, 1, CRYPTO_LOCK_X509);
  679. #endif
  680.     }

  682.     return chain;
  683. }


  686. static void *
  687. ‌ngx_ssl_cache_pkey_create(ngx_ssl_cache_key_t *id, char **err, void *data)
  688. {
  689.     ngx_array_t  **passwords = data;

  691.     BIO                  *bio;
  692.     EVP_PKEY             *pkey;
  693.     ngx_uint_t            tries;
  694.     pem_password_cb      *cb;
  695.     ngx_ssl_cache_pwd_t   cb_data, *pwd;

  697.     if (id->type == NGX_SSL_CACHE_ENGINE) {

  699. #ifndef OPENSSL_NO_ENGINE

  701.         u_char  *p, *last;
  702.         ENGINE  *engine;

  704.         p = id->data + sizeof("engine:") - 1;
  705.         last = (u_char *) ngx_strchr(p, ':');

  707.         if (last == NULL) {
  708.             *err = "invalid syntax";
  709.             return NULL;
  710.         }

  712.         *last = '\0';

  714.         engine = ENGINE_by_id((char *) p);

  716.         *last++ = ':';

  718.         if (engine == NULL) {
  719.             *err = "ENGINE_by_id() failed";
  720.             return NULL;
  721.         }

  723.         pkey = ENGINE_load_private_key(engine, (char *) last, NULL, NULL);

  725.         if (pkey == NULL) {
  726.             *err = "ENGINE_load_private_key() failed";
  727.             ENGINE_free(engine);
  728.             return NULL;
  729.         }

  731.         ENGINE_free(engine);

  733.         return pkey;

  735. #else

  737.         *err = "loading \"engine:...\" certificate keys is not supported";
  738.         return NULL;

  740. #endif
  741.     }

  743.     cb_data.encrypted = 0;

  745.     if (*passwords) {
  746.         cb_data.pwd = (*passwords)->elts;
  747.         tries = (*passwords)->nelts;
  748.         pwd = &cb_data;
  749.         cb = ngx_ssl_cache_pkey_password_callback;

  751.     } else {
  752.         cb_data.pwd = NULL;
  753.         tries = 1;
  754.         pwd = NULL;
  755.         cb = NULL;
  756.     }

  758.     if (id->type == NGX_SSL_CACHE_STORE) {

  760. #ifdef ERR_R_OSSL_STORE_LIB

  762.         u_char           *uri;
  763.         UI_METHOD        *method;
  764.         OSSL_STORE_CTX   *store;
  765.         OSSL_STORE_INFO  *info;

  767.         method = (cb != NULL) ? UI_UTIL_wrap_read_pem_callback(cb, 0) : NULL;
  768.         uri = id->data + sizeof("store:") - 1;

  770.         store = OSSL_STORE_open((char *) uri, method, pwd, NULL, NULL);

  772.         if (store == NULL) {
  773.             *err = "OSSL_STORE_open() failed";

  775.             if (method != NULL) {
  776.                 UI_destroy_method(method);
  777.             }

  779.             return NULL;
  780.         }

  782.         pkey = NULL;

  784.         while (pkey == NULL && !OSSL_STORE_eof(store)) {
  785.             info = OSSL_STORE_load(store);

  787.             if (info == NULL) {
  788.                 continue;
  789.             }

  791.             if (OSSL_STORE_INFO_get_type(info) == OSSL_STORE_INFO_PKEY) {
  792.                 pkey = OSSL_STORE_INFO_get1_PKEY(info);
  793.             }

  795.             OSSL_STORE_INFO_free(info);
  796.         }

  798.         OSSL_STORE_close(store);

  800.         if (method != NULL) {
  801.             UI_destroy_method(method);
  802.         }

  804.         if (pkey == NULL) {
  805.             *err = "OSSL_STORE_load() failed";
  806.             return NULL;
  807.         }

  809.         if (cb_data.encrypted) {
  810.             *passwords = NGX_SSL_CACHE_DISABLED;
  811.         }

  813.         return pkey;

  815. #else

  817.         *err = "loading \"store:...\" certificate keys is not supported";
  818.         return NULL;

  820. #endif
  821.     }

  823.     bio = ngx_ssl_cache_create_bio(id, err);
  824.     if (bio == NULL) {
  825.         return NULL;
  826.     }

  828.     for ( ;; ) {

  830.         pkey = PEM_read_bio_PrivateKey(bio, NULL, cb, pwd);
  831.         if (pkey != NULL) {
  832.             break;
  833.         }

  835.         if (tries-- > 1) {
  836.             ERR_clear_error();
  837.             (void) BIO_reset(bio);
  838.             cb_data.pwd++;
  839.             continue;
  840.         }

  842.         *err = "PEM_read_bio_PrivateKey() failed";
  843.         BIO_free(bio);
  844.         return NULL;
  845.     }

  847.     if (cb_data.encrypted) {
  848.         *passwords = NGX_SSL_CACHE_DISABLED;
  849.     }

  851.     BIO_free(bio);

  853.     return pkey;
  854. }


  857. static int
  858. ‌ngx_ssl_cache_pkey_password_callback(char *buf, int size, int rwflag,
  859.     void *userdata)
  860. {
  861.     ngx_ssl_cache_pwd_t  *data = userdata;

  863.     ngx_str_t  *pwd;

  865.     if (rwflag) {
  866.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  867.                       "ngx_ssl_cache_pkey_password_callback() is called "
  868.                       "for encryption");
  869.         return 0;
  870.     }

  872.     data->encrypted = 1;

  874.     pwd = data->pwd;

  876.     if (pwd == NULL) {
  877.         return 0;
  878.     }

  880.     if (pwd->len > (size_t) size) {
  881.         ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0,
  882.                       "password is truncated to %d bytes", size);
  883.     } else {
  884.         size = pwd->len;
  885.     }

  887.     ngx_memcpy(buf, pwd->data, size);

  889.     return size;
  890. }


  893. static void
  894. ‌ngx_ssl_cache_pkey_free(void *data)
  895. {
  896.     EVP_PKEY_free(data);
  897. }


  900. static void *
  901. ‌ngx_ssl_cache_pkey_ref(char **err, void *data)
  902. {
  903.     EVP_PKEY  *pkey = data;

  905. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L)
  906.     EVP_PKEY_up_ref(pkey);
  907. #else
  908.     CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
  909. #endif

  911.     return data;
  912. }


  915. static void *
  916. ‌ngx_ssl_cache_crl_create(ngx_ssl_cache_key_t *id, char **err, void *data)
  917. {
  918.     BIO                 *bio;
  919.     u_long               n;
  920.     X509_CRL            *x509;
  921.     STACK_OF(X509_CRL)  *chain;

  923.     chain = sk_X509_CRL_new_null();
  924.     if (chain == NULL) {
  925.         *err = "sk_X509_CRL_new_null() failed";
  926.         return NULL;
  927.     }

  929.     bio = ngx_ssl_cache_create_bio(id, err);
  930.     if (bio == NULL) {
  931.         sk_X509_CRL_pop_free(chain, X509_CRL_free);
  932.         return NULL;
  933.     }

  935.     for ( ;; ) {

  937.         x509 = PEM_read_bio_X509_CRL(bio, NULL, NULL, NULL);
  938.         if (x509 == NULL) {
  939.             n = ERR_peek_last_error();

  941.             if (ERR_GET_LIB(n) == ERR_LIB_PEM
  942.                 && ERR_GET_REASON(n) == PEM_R_NO_START_LINE
  943.                 && sk_X509_CRL_num(chain) > 0)
  944.             {
  945.                 /* end of file */
  946.                 ERR_clear_error();
  947.                 break;
  948.             }

  950.             /* some real error */

  952.             *err = "PEM_read_bio_X509_CRL() failed";
  953.             BIO_free(bio);
  954.             sk_X509_CRL_pop_free(chain, X509_CRL_free);
  955.             return NULL;
  956.         }

  958.         if (sk_X509_CRL_push(chain, x509) == 0) {
  959.             *err = "sk_X509_CRL_push() failed";
  960.             BIO_free(bio);
  961.             X509_CRL_free(x509);
  962.             sk_X509_CRL_pop_free(chain, X509_CRL_free);
  963.             return NULL;
  964.         }
  965.     }

  967.     BIO_free(bio);

  969.     return chain;
  970. }


  973. static void
  974. ‌ngx_ssl_cache_crl_free(void *data)
  975. {
  976.     sk_X509_CRL_pop_free(data, X509_CRL_free);
  977. }


  980. static void *
  981. ‌ngx_ssl_cache_crl_ref(char **err, void *data)
  982. {
  983.     int                  n, i;
  984.     X509_CRL            *x509;
  985.     STACK_OF(X509_CRL)  *chain;

  987.     chain = sk_X509_CRL_dup(data);
  988.     if (chain == NULL) {
  989.         *err = "sk_X509_CRL_dup() failed";
  990.         return NULL;
  991.     }

  993.     n = sk_X509_CRL_num(chain);

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

  998. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L)
  999.         X509_CRL_up_ref(x509);
  1000. #else
  1001.         CRYPTO_add(&x509->references, 1, CRYPTO_LOCK_X509_CRL);
  1002. #endif
  1003.     }

  1005.     return chain;
  1006. }


  1009. static void *
  1010. ‌ngx_ssl_cache_ca_create(ngx_ssl_cache_key_t *id, char **err, void *data)
  1011. {
  1012.     BIO             *bio;
  1013.     X509            *x509;
  1014.     u_long           n;
  1015.     STACK_OF(X509)  *chain;

  1017.     chain = sk_X509_new_null();
  1018.     if (chain == NULL) {
  1019.         *err = "sk_X509_new_null() failed";
  1020.         return NULL;
  1021.     }

  1023.     bio = ngx_ssl_cache_create_bio(id, err);
  1024.     if (bio == NULL) {
  1025.         sk_X509_pop_free(chain, X509_free);
  1026.         return NULL;
  1027.     }

  1029.     for ( ;; ) {

  1031.         x509 = PEM_read_bio_X509_AUX(bio, NULL, NULL, NULL);
  1032.         if (x509 == NULL) {
  1033.             n = ERR_peek_last_error();

  1035.             if (ERR_GET_LIB(n) == ERR_LIB_PEM
  1036.                 && ERR_GET_REASON(n) == PEM_R_NO_START_LINE
  1037.                 && sk_X509_num(chain) > 0)
  1038.             {
  1039.                 /* end of file */
  1040.                 ERR_clear_error();
  1041.                 break;
  1042.             }

  1044.             /* some real error */

  1046.             *err = "PEM_read_bio_X509_AUX() failed";
  1047.             BIO_free(bio);
  1048.             sk_X509_pop_free(chain, X509_free);
  1049.             return NULL;
  1050.         }

  1052.         if (sk_X509_push(chain, x509) == 0) {
  1053.             *err = "sk_X509_push() failed";
  1054.             BIO_free(bio);
  1055.             X509_free(x509);
  1056.             sk_X509_pop_free(chain, X509_free);
  1057.             return NULL;
  1058.         }
  1059.     }

  1061.     BIO_free(bio);

  1063.     return chain;
  1064. }


  1067. static BIO *
  1068. ‌ngx_ssl_cache_create_bio(ngx_ssl_cache_key_t *id, char **err)
  1069. {
  1070.     BIO  *bio;

  1072.     if (id->type == NGX_SSL_CACHE_DATA) {

  1074.         bio = BIO_new_mem_buf(id->data + sizeof("data:") - 1,
  1075.                               id->len - (sizeof("data:") - 1));
  1076.         if (bio == NULL) {
  1077.             *err = "BIO_new_mem_buf() failed";
  1078.         }

  1080.         return bio;
  1081.     }

  1083.     bio = BIO_new_file((char *) id->data, "r");
  1084.     if (bio == NULL) {
  1085.         *err = "BIO_new_file() failed";
  1086.     }

  1088.     return bio;
  1089. }


  1092. static void *
  1093. ‌ngx_openssl_cache_create_conf(ngx_cycle_t *cycle)
  1094. {
  1095.     ngx_ssl_cache_t  *cache;

  1097.     cache = ngx_ssl_cache_init(cycle->pool, 0, 0, 0);
  1098.     if (cache == NULL) {
  1099.         return NULL;
  1100.     }

  1102.     cache->inheritable = NGX_CONF_UNSET;

  1104.     return cache;
  1105. }


  1108. static char *
  1109. ‌ngx_openssl_cache_init_conf(ngx_cycle_t *cycle, void *conf)
  1110. {
  1111.     ngx_ssl_cache_t *cache = conf;

  1113.     ngx_conf_init_value(cache->inheritable, 1);

  1115.     return NGX_CONF_OK;
  1116. }


  1119. ngx_ssl_cache_t *
  1120. ‌ngx_ssl_cache_init(ngx_pool_t *pool, ngx_uint_t max, time_t valid,
  1121.     time_t inactive)
  1122. {
  1123.     ngx_ssl_cache_t     *cache;
  1124.     ngx_pool_cleanup_t  *cln;

  1126.     cache = ngx_pcalloc(pool, sizeof(ngx_ssl_cache_t));
  1127.     if (cache == NULL) {
  1128.         return NULL;
  1129.     }

  1131.     ngx_rbtree_init(&cache->rbtree, &cache->sentinel,
  1132.                     ngx_ssl_cache_node_insert);

  1134.     ngx_queue_init(&cache->expire_queue);

  1136.     cache->max = max;
  1137.     cache->valid = valid;
  1138.     cache->inactive = inactive;

  1140.     cln = ngx_pool_cleanup_add(pool, 0);
  1141.     if (cln == NULL) {
  1142.         return NULL;
  1143.     }

  1145.     cln->handler = ngx_ssl_cache_cleanup;
  1146.     cln->data = cache;

  1148.     return cache;
  1149. }


  1152. static void
  1153. ‌ngx_ssl_cache_cleanup(void *data)
  1154. {
  1155.     ngx_ssl_cache_t  *cache = data;

  1157.     ngx_rbtree_t          *tree;
  1158.     ngx_rbtree_node_t     *node;
  1159.     ngx_ssl_cache_node_t  *cn;

  1161.     tree = &cache->rbtree;

  1163.     if (tree->root == tree->sentinel) {
  1164.         return;
  1165.     }

  1167.     node = ngx_rbtree_min(tree->root, tree->sentinel);

  1169.     while (node != NULL) {
  1170.         cn = ngx_rbtree_data(node, ngx_ssl_cache_node_t, node);
  1171.         node = ngx_rbtree_next(tree, node);

  1173.         ngx_ssl_cache_node_free(tree, cn);

  1175.         if (cache->max) {
  1176.             cache->current--;
  1177.         }
  1178.     }

  1180.     if (cache->current) {
  1181.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  1182.                       "%ui items still left in ssl cache",
  1183.                       cache->current);
  1184.     }

  1186.     if (!ngx_queue_empty(&cache->expire_queue)) {
  1187.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  1188.                       "queue still is not empty in ssl cache");

  1190.     }
  1191. }


  1194. static void
  1195. ‌ngx_ssl_cache_node_free(ngx_rbtree_t *rbtree, ngx_ssl_cache_node_t *cn)
  1196. {
  1197.     cn->type->free(cn->value);

  1199.     ngx_rbtree_delete(rbtree, &cn->node);

  1201.     if (!ngx_queue_empty(&cn->queue)) {
  1202.         ngx_queue_remove(&cn->queue);

  1204.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0,
  1205.                        "delete cached ssl object: %s", cn->id.data);

  1207.         ngx_free(cn);
  1208.     }
  1209. }


  1212. static void
  1213. ‌ngx_ssl_cache_node_insert(ngx_rbtree_node_t *temp,
  1214.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  1215. {
  1216.     ngx_rbtree_node_t     **p;
  1217.     ngx_ssl_cache_node_t   *n, *t;

  1219.     for ( ;; ) {

  1221.         n = ngx_rbtree_data(node, ngx_ssl_cache_node_t, node);
  1222.         t = ngx_rbtree_data(temp, ngx_ssl_cache_node_t, node);

  1224.         if (node->key != temp->key) {

  1226.             p = (node->key < temp->key) ? &temp->left : &temp->right;

  1228.         } else if (n->type != t->type) {

  1230.             p = (n->type < t->type) ? &temp->left : &temp->right;

  1232.         } else {

  1234.             p = (ngx_memn2cmp(n->id.data, t->id.data, n->id.len, t->id.len)
  1235.                  < 0) ? &temp->left : &temp->right;
  1236.         }

  1238.         if (*p == sentinel) {
  1239.             break;
  1240.         }

  1242.         temp = *p;
  1243.     }

  1245.     *p = node;
  1246.     node->parent = temp;
  1247.     node->left = sentinel;
  1248.     node->right = sentinel;
  1249.     ngx_rbt_red(node);
  1250. }


  1253. static ngx_int_t
  1254. ‌ngx_openssl_cache_init_worker(ngx_cycle_t *cycle)
  1255. {
  1256. #ifdef ERR_R_OSSL_STORE_LIB

  1258.     if (ngx_process != NGX_PROCESS_WORKER) {
  1259.         return NGX_OK;
  1260.     }

  1262.     UI_set_default_method(UI_null());

  1264. #endif

  1266.     return NGX_OK;
  1267. }

One Level Up Top Level