One Level Up Top Level

src/event/ngx_event_openssl_stapling.c - nginx

Data types defined

Functions defined

Source code


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


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


  14. #if (!defined OPENSSL_NO_OCSP && defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB)


  17. ‌typedef struct {
  18.     ngx_rbtree_node_t            node;

  20.     ngx_str_t                    staple;
  21.     ngx_msec_t                   timeout;

  23.     ngx_resolver_t              *resolver;
  24.     ngx_msec_t                   resolver_timeout;

  26.     ngx_addr_t                  *addrs;
  27.     ngx_uint_t                   naddrs;
  28.     ngx_str_t                    host;
  29.     ngx_str_t                    uri;
  30.     in_port_t                    port;

  32.     SSL_CTX                     *ssl_ctx;

  34.     X509                        *cert;
  35.     X509                        *issuer;
  36.     STACK_OF(X509)              *chain;

  38.     u_char                      *name;

  40.     time_t                       valid;
  41.     time_t                       refresh;

  43.     unsigned                     verify:1;
  44.     unsigned                     loading:1;
  45. ‌} ngx_ssl_stapling_t;


  48. ‌typedef struct {
  49.     ngx_addr_t                  *addrs;
  50.     ngx_uint_t                   naddrs;

  52.     ngx_str_t                    host;
  53.     ngx_str_t                    uri;
  54.     in_port_t                    port;
  55.     ngx_uint_t                   depth;

  57.     ngx_shm_zone_t              *shm_zone;

  59.     ngx_resolver_t              *resolver;
  60.     ngx_msec_t                   resolver_timeout;
  61. ‌} ngx_ssl_ocsp_conf_t;


  64. ‌typedef struct {
  65.     ngx_rbtree_t                 rbtree;
  66.     ngx_rbtree_node_t            sentinel;
  67.     ngx_queue_t                  expire_queue;
  68. ‌} ngx_ssl_ocsp_cache_t;


  71. ‌typedef struct {
  72.     ngx_str_node_t               node;
  73.     ngx_queue_t                  queue;
  74.     int                          status;
  75.     time_t                       valid;
  76. ‌} ngx_ssl_ocsp_cache_node_t;


  79. ‌typedef struct ngx_ssl_ocsp_ctx_s  ngx_ssl_ocsp_ctx_t;


  82. ‌struct ngx_ssl_ocsp_s {
  83.     STACK_OF(X509)              *certs;
  84.     ngx_uint_t                   ncert;

  86.     int                          cert_status;
  87.     ngx_int_t                    status;

  89.     ngx_ssl_ocsp_conf_t         *conf;
  90.     ngx_ssl_ocsp_ctx_t          *ctx;
  91. };


  94. ‌struct ngx_ssl_ocsp_ctx_s {
  95.     SSL_CTX                     *ssl_ctx;

  97.     X509                        *cert;
  98.     X509                        *issuer;
  99.     STACK_OF(X509)              *chain;

  101.     int                          status;
  102.     time_t                       valid;

  104.     u_char                      *name;

  106.     ngx_uint_t                   naddrs;
  107.     ngx_uint_t                   naddr;

  109.     ngx_addr_t                  *addrs;
  110.     ngx_str_t                    host;
  111.     ngx_str_t                    uri;
  112.     in_port_t                    port;

  114.     ngx_resolver_t              *resolver;
  115.     ngx_msec_t                   resolver_timeout;
  116.     ngx_resolver_ctx_t          *resolve;

  118.     ngx_msec_t                   timeout;

  120.     void                       (*handler)(ngx_ssl_ocsp_ctx_t *ctx);
  121.     void                        *data;

  123.     ngx_str_t                    key;
  124.     ngx_buf_t                   *request;
  125.     ngx_buf_t                   *response;
  126.     ngx_peer_connection_t        peer;

  128.     ngx_shm_zone_t              *shm_zone;

  130.     ngx_int_t                  (*process)(ngx_ssl_ocsp_ctx_t *ctx);

  132.     ngx_uint_t                   state;

  134.     ngx_uint_t                   code;
  135.     ngx_uint_t                   count;
  136.     ngx_uint_t                   flags;
  137.     ngx_uint_t                   done;

  139.     u_char                      *header_name_start;
  140.     u_char                      *header_name_end;
  141.     u_char                      *header_start;
  142.     u_char                      *header_end;

  144.     ngx_pool_t                  *pool;
  145.     ngx_log_t                   *log;
  146. };


  149. static ngx_int_t ngx_ssl_stapling_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl,
  150.     X509 *cert, ngx_str_t *file, ngx_str_t *responder, ngx_uint_t verify);
  151. static ngx_int_t ngx_ssl_stapling_file(ngx_conf_t *cf, ngx_ssl_t *ssl,
  152.     ngx_ssl_stapling_t *staple, ngx_str_t *file);
  153. static ngx_int_t ngx_ssl_stapling_issuer(ngx_conf_t *cf, ngx_ssl_t *ssl,
  154.     ngx_ssl_stapling_t *staple);
  155. static ngx_int_t ngx_ssl_stapling_responder(ngx_conf_t *cf, ngx_ssl_t *ssl,
  156.     ngx_ssl_stapling_t *staple, ngx_str_t *responder);

  158. static int ngx_ssl_certificate_status_callback(ngx_ssl_conn_t *ssl_conn,
  159.     void *data);
  160. static ngx_ssl_stapling_t *ngx_ssl_stapling_lookup(ngx_ssl_t *ssl, X509 *cert);
  161. static void ngx_ssl_stapling_update(ngx_ssl_stapling_t *staple);
  162. static void ngx_ssl_stapling_ocsp_handler(ngx_ssl_ocsp_ctx_t *ctx);

  164. static time_t ngx_ssl_stapling_time(ASN1_GENERALIZEDTIME *asn1time);

  166. static void ngx_ssl_stapling_cleanup(void *data);

  168. static void ngx_ssl_ocsp_validate_next(ngx_connection_t *c);
  169. static void ngx_ssl_ocsp_handler(ngx_ssl_ocsp_ctx_t *ctx);
  170. static ngx_int_t ngx_ssl_ocsp_responder(ngx_connection_t *c,
  171.     ngx_ssl_ocsp_ctx_t *ctx);

  173. static ngx_ssl_ocsp_ctx_t *ngx_ssl_ocsp_start(ngx_log_t *log);
  174. static void ngx_ssl_ocsp_done(ngx_ssl_ocsp_ctx_t *ctx);
  175. static void ngx_ssl_ocsp_next(ngx_ssl_ocsp_ctx_t *ctx);
  176. static void ngx_ssl_ocsp_request(ngx_ssl_ocsp_ctx_t *ctx);
  177. static void ngx_ssl_ocsp_resolve_handler(ngx_resolver_ctx_t *resolve);
  178. static void ngx_ssl_ocsp_connect(ngx_ssl_ocsp_ctx_t *ctx);
  179. static void ngx_ssl_ocsp_write_handler(ngx_event_t *wev);
  180. static void ngx_ssl_ocsp_read_handler(ngx_event_t *rev);
  181. static void ngx_ssl_ocsp_dummy_handler(ngx_event_t *ev);

  183. static ngx_int_t ngx_ssl_ocsp_create_request(ngx_ssl_ocsp_ctx_t *ctx);
  184. static ngx_int_t ngx_ssl_ocsp_process_status_line(ngx_ssl_ocsp_ctx_t *ctx);
  185. static ngx_int_t ngx_ssl_ocsp_parse_status_line(ngx_ssl_ocsp_ctx_t *ctx);
  186. static ngx_int_t ngx_ssl_ocsp_process_headers(ngx_ssl_ocsp_ctx_t *ctx);
  187. static ngx_int_t ngx_ssl_ocsp_parse_header_line(ngx_ssl_ocsp_ctx_t *ctx);
  188. static ngx_int_t ngx_ssl_ocsp_process_body(ngx_ssl_ocsp_ctx_t *ctx);
  189. static ngx_int_t ngx_ssl_ocsp_verify(ngx_ssl_ocsp_ctx_t *ctx);

  191. static ngx_int_t ngx_ssl_ocsp_cache_lookup(ngx_ssl_ocsp_ctx_t *ctx);
  192. static ngx_int_t ngx_ssl_ocsp_cache_store(ngx_ssl_ocsp_ctx_t *ctx);
  193. static ngx_int_t ngx_ssl_ocsp_create_key(ngx_ssl_ocsp_ctx_t *ctx);

  195. static u_char *ngx_ssl_ocsp_log_error(ngx_log_t *log, u_char *buf, size_t len);


  198. ngx_int_t
  199. ‌ngx_ssl_stapling(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *file,
  200.     ngx_str_t *responder, ngx_uint_t verify)
  201. {
  202.     X509        *cert;
  203.     ngx_uint_t   k;

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

  208.         if (ngx_ssl_stapling_certificate(cf, ssl, cert, file, responder, verify)
  209.             != NGX_OK)
  210.         {
  211.             return NGX_ERROR;
  212.         }
  213.     }

  215.     SSL_CTX_set_tlsext_status_cb(ssl->ctx, ngx_ssl_certificate_status_callback);

  217.     return NGX_OK;
  218. }


  221. static ngx_int_t
  222. ‌ngx_ssl_stapling_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl, X509 *cert,
  223.     ngx_str_t *file, ngx_str_t *responder, ngx_uint_t verify)
  224. {
  225.     ngx_int_t            rc;
  226.     ngx_pool_cleanup_t  *cln;
  227.     ngx_ssl_stapling_t  *staple;

  229.     staple = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_stapling_t));
  230.     if (staple == NULL) {
  231.         return NGX_ERROR;
  232.     }

  234.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  235.     if (cln == NULL) {
  236.         return NGX_ERROR;
  237.     }

  239.     cln->handler = ngx_ssl_stapling_cleanup;
  240.     cln->data = staple;

  242.     staple->node.key = (ngx_rbtree_key_t) cert;

  244.     ngx_rbtree_insert(&ssl->staple_rbtree, &staple->node);

  246. #ifdef SSL_CTRL_SELECT_CURRENT_CERT
  247.     /* OpenSSL 1.0.2+ */
  248.     SSL_CTX_select_current_cert(ssl->ctx, cert);
  249. #endif

  251. #ifdef SSL_CTRL_GET_EXTRA_CHAIN_CERTS
  252.     /* OpenSSL 1.0.1+ */
  253.     SSL_CTX_get_extra_chain_certs(ssl->ctx, &staple->chain);
  254. #else
  255.     staple->chain = ssl->ctx->extra_certs;
  256. #endif

  258.     staple->ssl_ctx = ssl->ctx;
  259.     staple->timeout = 60000;
  260.     staple->verify = verify;
  261.     staple->cert = cert;
  262.     staple->name = X509_get_ex_data(staple->cert,
  263.                                     ngx_ssl_certificate_name_index);

  265.     if (file->len) {
  266.         /* use OCSP response from the file */

  268.         if (ngx_ssl_stapling_file(cf, ssl, staple, file) != NGX_OK) {
  269.             return NGX_ERROR;
  270.         }

  272.         return NGX_OK;
  273.     }

  275.     rc = ngx_ssl_stapling_issuer(cf, ssl, staple);

  277.     if (rc == NGX_DECLINED) {
  278.         return NGX_OK;
  279.     }

  281.     if (rc != NGX_OK) {
  282.         return NGX_ERROR;
  283.     }

  285.     rc = ngx_ssl_stapling_responder(cf, ssl, staple, responder);

  287.     if (rc == NGX_DECLINED) {
  288.         return NGX_OK;
  289.     }

  291.     if (rc != NGX_OK) {
  292.         return NGX_ERROR;
  293.     }

  295.     return NGX_OK;
  296. }


  299. static ngx_int_t
  300. ‌ngx_ssl_stapling_file(ngx_conf_t *cf, ngx_ssl_t *ssl,
  301.     ngx_ssl_stapling_t *staple, ngx_str_t *file)
  302. {
  303.     BIO            *bio;
  304.     int             len;
  305.     u_char         *p, *buf;
  306.     OCSP_RESPONSE  *response;

  308.     if (ngx_conf_full_name(cf->cycle, file, 1) != NGX_OK) {
  309.         return NGX_ERROR;
  310.     }

  312.     bio = BIO_new_file((char *) file->data, "rb");
  313.     if (bio == NULL) {
  314.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  315.                       "BIO_new_file(\"%s\") failed", file->data);
  316.         return NGX_ERROR;
  317.     }

  319.     response = d2i_OCSP_RESPONSE_bio(bio, NULL);
  320.     if (response == NULL) {
  321.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  322.                       "d2i_OCSP_RESPONSE_bio(\"%s\") failed", file->data);
  323.         BIO_free(bio);
  324.         return NGX_ERROR;
  325.     }

  327.     len = i2d_OCSP_RESPONSE(response, NULL);
  328.     if (len <= 0) {
  329.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  330.                       "i2d_OCSP_RESPONSE(\"%s\") failed", file->data);
  331.         goto failed;
  332.     }

  334.     buf = ngx_alloc(len, ssl->log);
  335.     if (buf == NULL) {
  336.         goto failed;
  337.     }

  339.     p = buf;
  340.     len = i2d_OCSP_RESPONSE(response, &p);
  341.     if (len <= 0) {
  342.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  343.                       "i2d_OCSP_RESPONSE(\"%s\") failed", file->data);
  344.         ngx_free(buf);
  345.         goto failed;
  346.     }

  348.     OCSP_RESPONSE_free(response);
  349.     BIO_free(bio);

  351.     staple->staple.data = buf;
  352.     staple->staple.len = len;
  353.     staple->valid = NGX_MAX_TIME_T_VALUE;

  355.     return NGX_OK;

  357. failed:

  359.     OCSP_RESPONSE_free(response);
  360.     BIO_free(bio);

  362.     return NGX_ERROR;
  363. }


  366. static ngx_int_t
  367. ‌ngx_ssl_stapling_issuer(ngx_conf_t *cf, ngx_ssl_t *ssl,
  368.     ngx_ssl_stapling_t *staple)
  369. {
  370.     int              i, n, rc;
  371.     X509            *cert, *issuer;
  372.     X509_STORE      *store;
  373.     X509_STORE_CTX  *store_ctx;

  375.     cert = staple->cert;

  377.     n = sk_X509_num(staple->chain);

  379.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ssl->log, 0,
  380.                    "SSL get issuer: %d extra certs", n);

  382.     for (i = 0; i < n; i++) {
  383.         issuer = sk_X509_value(staple->chain, i);
  384.         if (X509_check_issued(issuer, cert) == X509_V_OK) {
  385. #if OPENSSL_VERSION_NUMBER >= 0x10100001L
  386.             X509_up_ref(issuer);
  387. #else
  388.             CRYPTO_add(&issuer->references, 1, CRYPTO_LOCK_X509);
  389. #endif

  391.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ssl->log, 0,
  392.                            "SSL get issuer: found %p in extra certs", issuer);

  394.             staple->issuer = issuer;

  396.             return NGX_OK;
  397.         }
  398.     }

  400.     store = SSL_CTX_get_cert_store(ssl->ctx);
  401.     if (store == NULL) {
  402.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  403.                       "SSL_CTX_get_cert_store() failed");
  404.         return NGX_ERROR;
  405.     }

  407.     store_ctx = X509_STORE_CTX_new();
  408.     if (store_ctx == NULL) {
  409.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  410.                       "X509_STORE_CTX_new() failed");
  411.         return NGX_ERROR;
  412.     }

  414.     if (X509_STORE_CTX_init(store_ctx, store, NULL, NULL) == 0) {
  415.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  416.                       "X509_STORE_CTX_init() failed");
  417.         X509_STORE_CTX_free(store_ctx);
  418.         return NGX_ERROR;
  419.     }

  421.     rc = X509_STORE_CTX_get1_issuer(&issuer, store_ctx, cert);

  423.     if (rc == -1) {
  424.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  425.                       "X509_STORE_CTX_get1_issuer() failed");
  426.         X509_STORE_CTX_free(store_ctx);
  427.         return NGX_ERROR;
  428.     }

  430.     if (rc == 0) {
  431.         ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  432.                       "\"ssl_stapling\" ignored, "
  433.                       "issuer certificate not found for certificate \"%s\"",
  434.                       staple->name);
  435.         X509_STORE_CTX_free(store_ctx);
  436.         return NGX_DECLINED;
  437.     }

  439.     X509_STORE_CTX_free(store_ctx);

  441.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ssl->log, 0,
  442.                    "SSL get issuer: found %p in cert store", issuer);

  444.     staple->issuer = issuer;

  446.     return NGX_OK;
  447. }


  450. static ngx_int_t
  451. ‌ngx_ssl_stapling_responder(ngx_conf_t *cf, ngx_ssl_t *ssl,
  452.     ngx_ssl_stapling_t *staple, ngx_str_t *responder)
  453. {
  454.     char                      *s;
  455.     ngx_str_t                  rsp;
  456.     ngx_url_t                  u;
  457.     STACK_OF(OPENSSL_STRING)  *aia;

  459.     if (responder->len == 0) {

  461.         /* extract OCSP responder URL from certificate */

  463.         aia = X509_get1_ocsp(staple->cert);
  464.         if (aia == NULL) {
  465.             ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  466.                           "\"ssl_stapling\" ignored, "
  467.                           "no OCSP responder URL in the certificate \"%s\"",
  468.                           staple->name);
  469.             return NGX_DECLINED;
  470.         }

  472. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  473.         s = sk_OPENSSL_STRING_value(aia, 0);
  474. #else
  475.         s = sk_value(aia, 0);
  476. #endif
  477.         if (s == NULL) {
  478.             ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  479.                           "\"ssl_stapling\" ignored, "
  480.                           "no OCSP responder URL in the certificate \"%s\"",
  481.                           staple->name);
  482.             X509_email_free(aia);
  483.             return NGX_DECLINED;
  484.         }

  486.         responder = &rsp;

  488.         responder->len = ngx_strlen(s);
  489.         responder->data = ngx_palloc(cf->pool, responder->len);
  490.         if (responder->data == NULL) {
  491.             X509_email_free(aia);
  492.             return NGX_ERROR;
  493.         }

  495.         ngx_memcpy(responder->data, s, responder->len);
  496.         X509_email_free(aia);
  497.     }

  499.     ngx_memzero(&u, sizeof(ngx_url_t));

  501.     u.url = *responder;
  502.     u.default_port = 80;
  503.     u.uri_part = 1;

  505.     if (u.url.len > 7
  506.         && ngx_strncasecmp(u.url.data, (u_char *) "http://", 7) == 0)
  507.     {
  508.         u.url.len -= 7;
  509.         u.url.data += 7;

  511.     } else {
  512.         ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  513.                       "\"ssl_stapling\" ignored, "
  514.                       "invalid URL prefix in OCSP responder \"%V\" "
  515.                       "in the certificate \"%s\"",
  516.                       &u.url, staple->name);
  517.         return NGX_DECLINED;
  518.     }

  520.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  521.         if (u.err) {
  522.             ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  523.                           "\"ssl_stapling\" ignored, "
  524.                           "%s in OCSP responder \"%V\" "
  525.                           "in the certificate \"%s\"",
  526.                           u.err, &u.url, staple->name);
  527.             return NGX_DECLINED;
  528.         }

  530.         return NGX_ERROR;
  531.     }

  533.     staple->addrs = u.addrs;
  534.     staple->naddrs = u.naddrs;
  535.     staple->host = u.host;
  536.     staple->uri = u.uri;
  537.     staple->port = u.port;

  539.     if (staple->uri.len == 0) {
  540.         ngx_str_set(&staple->uri, "/");
  541.     }

  543.     return NGX_OK;
  544. }


  547. ngx_int_t
  548. ‌ngx_ssl_stapling_resolver(ngx_conf_t *cf, ngx_ssl_t *ssl,
  549.     ngx_resolver_t *resolver, ngx_msec_t resolver_timeout)
  550. {
  551.     ngx_rbtree_t        *tree;
  552.     ngx_rbtree_node_t   *node;
  553.     ngx_ssl_stapling_t  *staple;

  555.     tree = &ssl->staple_rbtree;

  557.     if (tree->root == tree->sentinel) {
  558.         return NGX_OK;
  559.     }

  561.     for (node = ngx_rbtree_min(tree->root, tree->sentinel);
  562.          node;
  563.          node = ngx_rbtree_next(tree, node))
  564.     {
  565.         staple = ngx_rbtree_data(node, ngx_ssl_stapling_t, node);
  566.         staple->resolver = resolver;
  567.         staple->resolver_timeout = resolver_timeout;
  568.     }

  570.     return NGX_OK;
  571. }


  574. static int
  575. ‌ngx_ssl_certificate_status_callback(ngx_ssl_conn_t *ssl_conn, void *data)
  576. {
  577.     int                  rc;
  578.     X509                *cert;
  579.     u_char              *p;
  580.     SSL_CTX             *ssl_ctx;
  581.     ngx_ssl_t           *ssl;
  582.     ngx_connection_t    *c;
  583.     ngx_ssl_stapling_t  *staple;

  585.     c = ngx_ssl_get_connection(ssl_conn);

  587.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  588.                    "SSL certificate status callback");

  590.     rc = SSL_TLSEXT_ERR_NOACK;

  592.     cert = SSL_get_certificate(ssl_conn);

  594.     if (cert == NULL) {
  595.         return rc;
  596.     }

  598.     ssl_ctx = SSL_get_SSL_CTX(ssl_conn);
  599.     ssl = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_index);

  601.     staple = ngx_ssl_stapling_lookup(ssl, cert);

  603.     if (staple == NULL) {
  604.         return rc;
  605.     }

  607.     if (staple->staple.len
  608.         && staple->valid >= ngx_time())
  609.     {
  610.         /* we have to copy ocsp response as OpenSSL will free it by itself */

  612.         p = OPENSSL_malloc(staple->staple.len);
  613.         if (p == NULL) {
  614.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "OPENSSL_malloc() failed");
  615.             return SSL_TLSEXT_ERR_NOACK;
  616.         }

  618.         ngx_memcpy(p, staple->staple.data, staple->staple.len);

  620.         SSL_set_tlsext_status_ocsp_resp(ssl_conn, p, staple->staple.len);

  622.         rc = SSL_TLSEXT_ERR_OK;
  623.     }

  625.     ngx_ssl_stapling_update(staple);

  627.     return rc;
  628. }


  631. static ngx_ssl_stapling_t *
  632. ‌ngx_ssl_stapling_lookup(ngx_ssl_t *ssl, X509 *cert)
  633. {
  634.     ngx_rbtree_key_t    key;
  635.     ngx_rbtree_node_t  *node, *sentinel;

  637.     node = ssl->staple_rbtree.root;
  638.     sentinel = ssl->staple_rbtree.sentinel;
  639.     key = (ngx_rbtree_key_t) cert;

  641.     while (node != sentinel) {

  643.         if (key != node->key) {
  644.             node = (key < node->key) ? node->left : node->right;
  645.             continue;
  646.         }

  648.         return ngx_rbtree_data(node, ngx_ssl_stapling_t, node);
  649.     }

  651.     return NULL;
  652. }


  655. static void
  656. ‌ngx_ssl_stapling_update(ngx_ssl_stapling_t *staple)
  657. {
  658.     ngx_ssl_ocsp_ctx_t  *ctx;

  660.     if (staple->host.len == 0
  661.         || staple->loading || staple->refresh >= ngx_time())
  662.     {
  663.         return;
  664.     }

  666.     staple->loading = 1;

  668.     ctx = ngx_ssl_ocsp_start(ngx_cycle->log);
  669.     if (ctx == NULL) {
  670.         return;
  671.     }

  673.     ctx->ssl_ctx = staple->ssl_ctx;
  674.     ctx->cert = staple->cert;
  675.     ctx->issuer = staple->issuer;
  676.     ctx->chain = staple->chain;
  677.     ctx->name = staple->name;
  678.     ctx->flags = (staple->verify ? OCSP_TRUSTOTHER : OCSP_NOVERIFY);

  680.     ctx->addrs = staple->addrs;
  681.     ctx->naddrs = staple->naddrs;
  682.     ctx->host = staple->host;
  683.     ctx->uri = staple->uri;
  684.     ctx->port = staple->port;
  685.     ctx->timeout = staple->timeout;

  687.     ctx->resolver = staple->resolver;
  688.     ctx->resolver_timeout = staple->resolver_timeout;

  690.     ctx->handler = ngx_ssl_stapling_ocsp_handler;
  691.     ctx->data = staple;

  693.     ngx_ssl_ocsp_request(ctx);

  695.     return;
  696. }


  699. static void
  700. ‌ngx_ssl_stapling_ocsp_handler(ngx_ssl_ocsp_ctx_t *ctx)
  701. {
  702.     time_t               now;
  703.     ngx_str_t            response;
  704.     ngx_ssl_stapling_t  *staple;

  706.     staple = ctx->data;
  707.     now = ngx_time();

  709.     if (ngx_ssl_ocsp_verify(ctx) != NGX_OK) {
  710.         goto error;
  711.     }

  713.     if (ctx->status != V_OCSP_CERTSTATUS_GOOD) {
  714.         ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  715.                       "certificate status \"%s\" in the OCSP response",
  716.                       OCSP_cert_status_str(ctx->status));
  717.         goto error;
  718.     }

  720.     /* copy the response to memory not in ctx->pool */

  722.     response.len = ctx->response->last - ctx->response->pos;
  723.     response.data = ngx_alloc(response.len, ctx->log);

  725.     if (response.data == NULL) {
  726.         goto error;
  727.     }

  729.     ngx_memcpy(response.data, ctx->response->pos, response.len);

  731.     if (staple->staple.data) {
  732.         ngx_free(staple->staple.data);
  733.     }

  735.     staple->staple = response;
  736.     staple->valid = ctx->valid;

  738.     /*
  739.      * refresh before the response expires,
  740.      * but not earlier than in 5 minutes, and at least in an hour
  741.      */

  743.     staple->loading = 0;
  744.     staple->refresh = ngx_max(ngx_min(ctx->valid - 300, now + 3600), now + 300);

  746.     ngx_ssl_ocsp_done(ctx);
  747.     return;

  749. error:

  751.     staple->loading = 0;
  752.     staple->refresh = now + 300;

  754.     ngx_ssl_ocsp_done(ctx);
  755. }


  758. static time_t
  759. ‌ngx_ssl_stapling_time(ASN1_GENERALIZEDTIME *asn1time)
  760. {
  761.     BIO     *bio;
  762.     char    *value;
  763.     size_t   len;
  764.     time_t   time;

  766.     /*
  767.      * OpenSSL doesn't provide a way to convert ASN1_GENERALIZEDTIME
  768.      * into time_t.  To do this, we use ASN1_GENERALIZEDTIME_print(),
  769.      * which uses the "MMM DD HH:MM:SS YYYY [GMT]" format (e.g.,
  770.      * "Feb  3 00:55:52 2015 GMT"), and parse the result.
  771.      */

  773.     bio = BIO_new(BIO_s_mem());
  774.     if (bio == NULL) {
  775.         return NGX_ERROR;
  776.     }

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

  780.     BIO_write(bio, "Tue ", sizeof("Tue ") - 1);
  781.     ASN1_GENERALIZEDTIME_print(bio, asn1time);
  782.     len = BIO_get_mem_data(bio, &value);

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

  786.     BIO_free(bio);

  788.     return time;
  789. }


  792. static void
  793. ‌ngx_ssl_stapling_cleanup(void *data)
  794. {
  795.     ngx_ssl_stapling_t  *staple = data;

  797.     if (staple->issuer) {
  798.         X509_free(staple->issuer);
  799.     }

  801.     if (staple->staple.data) {
  802.         ngx_free(staple->staple.data);
  803.     }
  804. }


  807. ngx_int_t
  808. ‌ngx_ssl_ocsp(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *responder,
  809.     ngx_uint_t depth, ngx_shm_zone_t *shm_zone)
  810. {
  811.     ngx_url_t             u;
  812.     ngx_ssl_ocsp_conf_t  *ocf;

  814.     ocf = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_ocsp_conf_t));
  815.     if (ocf == NULL) {
  816.         return NGX_ERROR;
  817.     }

  819.     ocf->depth = depth;
  820.     ocf->shm_zone = shm_zone;

  822.     if (responder->len) {
  823.         ngx_memzero(&u, sizeof(ngx_url_t));

  825.         u.url = *responder;
  826.         u.default_port = 80;
  827.         u.uri_part = 1;

  829.         if (u.url.len > 7
  830.             && ngx_strncasecmp(u.url.data, (u_char *) "http://", 7) == 0)
  831.         {
  832.             u.url.len -= 7;
  833.             u.url.data += 7;

  835.         } else {
  836.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  837.                           "invalid URL prefix in OCSP responder \"%V\" "
  838.                           "in \"ssl_ocsp_responder\"", &u.url);
  839.             return NGX_ERROR;
  840.         }

  842.         if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  843.             if (u.err) {
  844.                 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  845.                               "%s in OCSP responder \"%V\" "
  846.                               "in \"ssl_ocsp_responder\"", u.err, &u.url);
  847.             }

  849.             return NGX_ERROR;
  850.         }

  852.         ocf->addrs = u.addrs;
  853.         ocf->naddrs = u.naddrs;
  854.         ocf->host = u.host;
  855.         ocf->uri = u.uri;
  856.         ocf->port = u.port;
  857.     }

  859.     if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_ocsp_index, ocf) == 0) {
  860.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  861.                       "SSL_CTX_set_ex_data() failed");
  862.         return NGX_ERROR;
  863.     }

  865.     return NGX_OK;
  866. }


  869. ngx_int_t
  870. ‌ngx_ssl_ocsp_resolver(ngx_conf_t *cf, ngx_ssl_t *ssl,
  871.     ngx_resolver_t *resolver, ngx_msec_t resolver_timeout)
  872. {
  873.     ngx_ssl_ocsp_conf_t  *ocf;

  875.     ocf = SSL_CTX_get_ex_data(ssl->ctx, ngx_ssl_ocsp_index);
  876.     ocf->resolver = resolver;
  877.     ocf->resolver_timeout = resolver_timeout;

  879.     return NGX_OK;
  880. }


  883. ngx_int_t
  884. ‌ngx_ssl_ocsp_validate(ngx_connection_t *c)
  885. {
  886.     X509                 *cert;
  887.     SSL_CTX              *ssl_ctx;
  888.     ngx_int_t             rc;
  889.     X509_STORE           *store;
  890.     X509_STORE_CTX       *store_ctx;
  891.     STACK_OF(X509)       *chain;
  892.     ngx_ssl_ocsp_t       *ocsp;
  893.     ngx_ssl_ocsp_conf_t  *ocf;

  895.     if (c->ssl->in_ocsp) {
  896.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  897.             return NGX_ERROR;
  898.         }

  900.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  901.             return NGX_ERROR;
  902.         }

  904.         return NGX_AGAIN;
  905.     }

  907.     ssl_ctx = SSL_get_SSL_CTX(c->ssl->connection);

  909.     ocf = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_ocsp_index);
  910.     if (ocf == NULL) {
  911.         return NGX_OK;
  912.     }

  914.     if (SSL_get_verify_result(c->ssl->connection) != X509_V_OK) {
  915.         return NGX_OK;
  916.     }

  918.     cert = SSL_get_peer_certificate(c->ssl->connection);
  919.     if (cert == NULL) {
  920.         return NGX_OK;
  921.     }

  923.     ocsp = ngx_pcalloc(c->pool, sizeof(ngx_ssl_ocsp_t));
  924.     if (ocsp == NULL) {
  925.         X509_free(cert);
  926.         return NGX_ERROR;
  927.     }

  929.     c->ssl->ocsp = ocsp;

  931.     ocsp->status = NGX_AGAIN;
  932.     ocsp->cert_status = V_OCSP_CERTSTATUS_GOOD;
  933.     ocsp->conf = ocf;

  935. #if OPENSSL_VERSION_NUMBER >= 0x10100000L

  937.     ocsp->certs = SSL_get0_verified_chain(c->ssl->connection);

  939.     if (ocsp->certs) {
  940.         ocsp->certs = X509_chain_up_ref(ocsp->certs);
  941.         if (ocsp->certs == NULL) {
  942.             X509_free(cert);
  943.             return NGX_ERROR;
  944.         }
  945.     }

  947. #endif

  949.     if (ocsp->certs == NULL) {
  950.         store = SSL_CTX_get_cert_store(ssl_ctx);
  951.         if (store == NULL) {
  952.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  953.                           "SSL_CTX_get_cert_store() failed");
  954.             X509_free(cert);
  955.             return NGX_ERROR;
  956.         }

  958.         store_ctx = X509_STORE_CTX_new();
  959.         if (store_ctx == NULL) {
  960.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  961.                           "X509_STORE_CTX_new() failed");
  962.             X509_free(cert);
  963.             return NGX_ERROR;
  964.         }

  966.         chain = SSL_get_peer_cert_chain(c->ssl->connection);

  968.         if (X509_STORE_CTX_init(store_ctx, store, cert, chain) == 0) {
  969.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  970.                           "X509_STORE_CTX_init() failed");
  971.             X509_STORE_CTX_free(store_ctx);
  972.             X509_free(cert);
  973.             return NGX_ERROR;
  974.         }

  976.         rc = X509_verify_cert(store_ctx);
  977.         if (rc <= 0) {
  978.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0, "X509_verify_cert() failed");
  979.             X509_STORE_CTX_free(store_ctx);
  980.             X509_free(cert);
  981.             return NGX_ERROR;
  982.         }

  984.         ocsp->certs = X509_STORE_CTX_get1_chain(store_ctx);
  985.         if (ocsp->certs == NULL) {
  986.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  987.                           "X509_STORE_CTX_get1_chain() failed");
  988.             X509_STORE_CTX_free(store_ctx);
  989.             X509_free(cert);
  990.             return NGX_ERROR;
  991.         }

  993.         X509_STORE_CTX_free(store_ctx);
  994.     }

  996.     X509_free(cert);

  998.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  999.                    "ssl ocsp validate, certs:%d", sk_X509_num(ocsp->certs));

  1001.     ngx_ssl_ocsp_validate_next(c);

  1003.     if (ocsp->status == NGX_AGAIN) {
  1004.         c->ssl->in_ocsp = 1;
  1005.         return NGX_AGAIN;
  1006.     }

  1008.     return NGX_OK;
  1009. }


  1012. static void
  1013. ‌ngx_ssl_ocsp_validate_next(ngx_connection_t *c)
  1014. {
  1015.     ngx_int_t             rc;
  1016.     ngx_uint_t            n;
  1017.     ngx_ssl_ocsp_t       *ocsp;
  1018.     ngx_ssl_ocsp_ctx_t   *ctx;
  1019.     ngx_ssl_ocsp_conf_t  *ocf;

  1021.     ocsp = c->ssl->ocsp;
  1022.     ocf = ocsp->conf;

  1024.     n = sk_X509_num(ocsp->certs);

  1026.     for ( ;; ) {

  1028.         if (ocsp->ncert == n - 1 || (ocf->depth == 2 && ocsp->ncert == 1)) {
  1029.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  1030.                            "ssl ocsp validated, certs:%ui", ocsp->ncert);
  1031.             rc = NGX_OK;
  1032.             goto done;
  1033.         }

  1035.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  1036.                        "ssl ocsp validate cert:%ui", ocsp->ncert);

  1038.         ctx = ngx_ssl_ocsp_start(c->log);
  1039.         if (ctx == NULL) {
  1040.             rc = NGX_ERROR;
  1041.             goto done;
  1042.         }

  1044.         ocsp->ctx = ctx;

  1046.         ctx->ssl_ctx = SSL_get_SSL_CTX(c->ssl->connection);
  1047.         ctx->cert = sk_X509_value(ocsp->certs, ocsp->ncert);
  1048.         ctx->issuer = sk_X509_value(ocsp->certs, ocsp->ncert + 1);
  1049.         ctx->chain = ocsp->certs;

  1051.         ctx->resolver = ocf->resolver;
  1052.         ctx->resolver_timeout = ocf->resolver_timeout;

  1054.         ctx->handler = ngx_ssl_ocsp_handler;
  1055.         ctx->data = c;

  1057.         ctx->shm_zone = ocf->shm_zone;

  1059.         ctx->addrs = ocf->addrs;
  1060.         ctx->naddrs = ocf->naddrs;
  1061.         ctx->host = ocf->host;
  1062.         ctx->uri = ocf->uri;
  1063.         ctx->port = ocf->port;

  1065.         rc = ngx_ssl_ocsp_responder(c, ctx);
  1066.         if (rc != NGX_OK) {
  1067.             goto done;
  1068.         }

  1070.         if (ctx->uri.len == 0) {
  1071.             ngx_str_set(&ctx->uri, "/");
  1072.         }

  1074.         ocsp->ncert++;

  1076.         rc = ngx_ssl_ocsp_cache_lookup(ctx);

  1078.         if (rc == NGX_ERROR) {
  1079.             goto done;
  1080.         }

  1082.         if (rc == NGX_DECLINED) {
  1083.             break;
  1084.         }

  1086.         /* rc == NGX_OK */

  1088.         if (ctx->status != V_OCSP_CERTSTATUS_GOOD) {
  1089.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1090.                            "ssl ocsp cached status \"%s\"",
  1091.                            OCSP_cert_status_str(ctx->status));
  1092.             ocsp->cert_status = ctx->status;
  1093.             goto done;
  1094.         }

  1096.         ocsp->ctx = NULL;
  1097.         ngx_ssl_ocsp_done(ctx);
  1098.     }

  1100.     ngx_ssl_ocsp_request(ctx);
  1101.     return;

  1103. done:

  1105.     ocsp->status = rc;

  1107.     if (c->ssl->in_ocsp) {
  1108.         c->ssl->handshaked = 1;
  1109.         c->ssl->handler(c);
  1110.     }
  1111. }


  1114. static void
  1115. ‌ngx_ssl_ocsp_handler(ngx_ssl_ocsp_ctx_t *ctx)
  1116. {
  1117.     ngx_int_t          rc;
  1118.     ngx_ssl_ocsp_t    *ocsp;
  1119.     ngx_connection_t  *c;

  1121.     c = ctx->data;
  1122.     ocsp = c->ssl->ocsp;
  1123.     ocsp->ctx = NULL;

  1125.     rc = ngx_ssl_ocsp_verify(ctx);
  1126.     if (rc != NGX_OK) {
  1127.         goto done;
  1128.     }

  1130.     rc = ngx_ssl_ocsp_cache_store(ctx);
  1131.     if (rc != NGX_OK) {
  1132.         goto done;
  1133.     }

  1135.     if (ctx->status != V_OCSP_CERTSTATUS_GOOD) {
  1136.         ocsp->cert_status = ctx->status;
  1137.         goto done;
  1138.     }

  1140.     ngx_ssl_ocsp_done(ctx);

  1142.     ngx_ssl_ocsp_validate_next(c);

  1144.     return;

  1146. done:

  1148.     ocsp->status = rc;
  1149.     ngx_ssl_ocsp_done(ctx);

  1151.     if (c->ssl->in_ocsp) {
  1152.         c->ssl->handshaked = 1;
  1153.         c->ssl->handler(c);
  1154.     }
  1155. }


  1158. static ngx_int_t
  1159. ‌ngx_ssl_ocsp_responder(ngx_connection_t *c, ngx_ssl_ocsp_ctx_t *ctx)
  1160. {
  1161.     char                      *s;
  1162.     ngx_str_t                  responder;
  1163.     ngx_url_t                  u;
  1164.     STACK_OF(OPENSSL_STRING)  *aia;

  1166.     if (ctx->host.len) {
  1167.         return NGX_OK;
  1168.     }

  1170.     /* extract OCSP responder URL from certificate */

  1172.     aia = X509_get1_ocsp(ctx->cert);
  1173.     if (aia == NULL) {
  1174.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1175.                       "no OCSP responder URL in certificate");
  1176.         return NGX_ERROR;
  1177.     }

  1179. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  1180.     s = sk_OPENSSL_STRING_value(aia, 0);
  1181. #else
  1182.     s = sk_value(aia, 0);
  1183. #endif
  1184.     if (s == NULL) {
  1185.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1186.                       "no OCSP responder URL in certificate");
  1187.         X509_email_free(aia);
  1188.         return NGX_ERROR;
  1189.     }

  1191.     responder.len = ngx_strlen(s);
  1192.     responder.data = ngx_palloc(ctx->pool, responder.len);
  1193.     if (responder.data == NULL) {
  1194.         X509_email_free(aia);
  1195.         return NGX_ERROR;
  1196.     }

  1198.     ngx_memcpy(responder.data, s, responder.len);
  1199.     X509_email_free(aia);

  1201.     ngx_memzero(&u, sizeof(ngx_url_t));

  1203.     u.url = responder;
  1204.     u.default_port = 80;
  1205.     u.uri_part = 1;
  1206.     u.no_resolve = 1;

  1208.     if (u.url.len > 7
  1209.         && ngx_strncasecmp(u.url.data, (u_char *) "http://", 7) == 0)
  1210.     {
  1211.         u.url.len -= 7;
  1212.         u.url.data += 7;

  1214.     } else {
  1215.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1216.                       "invalid URL prefix in OCSP responder \"%V\" "
  1217.                       "in certificate", &u.url);
  1218.         return NGX_ERROR;
  1219.     }

  1221.     if (ngx_parse_url(ctx->pool, &u) != NGX_OK) {
  1222.         if (u.err) {
  1223.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1224.                           "%s in OCSP responder \"%V\" in certificate",
  1225.                           u.err, &u.url);
  1226.         }

  1228.         return NGX_ERROR;
  1229.     }

  1231.     if (u.host.len == 0) {
  1232.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1233.                       "empty host in OCSP responder in certificate");
  1234.         return NGX_ERROR;
  1235.     }

  1237.     ctx->addrs = u.addrs;
  1238.     ctx->naddrs = u.naddrs;
  1239.     ctx->host = u.host;
  1240.     ctx->uri = u.uri;
  1241.     ctx->port = u.port;

  1243.     return NGX_OK;
  1244. }


  1247. ngx_int_t
  1248. ‌ngx_ssl_ocsp_get_status(ngx_connection_t *c, const char **s)
  1249. {
  1250.     ngx_ssl_ocsp_t  *ocsp;

  1252.     ocsp = c->ssl->ocsp;
  1253.     if (ocsp == NULL) {
  1254.         return NGX_OK;
  1255.     }

  1257.     if (ocsp->status == NGX_ERROR) {
  1258.         *s = "certificate status request failed";
  1259.         return NGX_DECLINED;
  1260.     }

  1262.     switch (ocsp->cert_status) {

  1264.     case V_OCSP_CERTSTATUS_GOOD:
  1265.         return NGX_OK;

  1267.     case V_OCSP_CERTSTATUS_REVOKED:
  1268.         *s = "certificate revoked";
  1269.         break;

  1271.     default: /* V_OCSP_CERTSTATUS_UNKNOWN */
  1272.         *s = "certificate status unknown";
  1273.     }

  1275.     return NGX_DECLINED;
  1276. }


  1279. void
  1280. ‌ngx_ssl_ocsp_cleanup(ngx_connection_t *c)
  1281. {
  1282.     ngx_ssl_ocsp_t  *ocsp;

  1284.     ocsp = c->ssl->ocsp;
  1285.     if (ocsp == NULL) {
  1286.         return;
  1287.     }

  1289.     if (ocsp->ctx) {
  1290.         ngx_ssl_ocsp_done(ocsp->ctx);
  1291.         ocsp->ctx = NULL;
  1292.     }

  1294.     if (ocsp->certs) {
  1295.         sk_X509_pop_free(ocsp->certs, X509_free);
  1296.         ocsp->certs = NULL;
  1297.     }
  1298. }


  1301. static ngx_ssl_ocsp_ctx_t *
  1302. ‌ngx_ssl_ocsp_start(ngx_log_t *log)
  1303. {
  1304.     ngx_pool_t          *pool;
  1305.     ngx_ssl_ocsp_ctx_t  *ctx;

  1307.     pool = ngx_create_pool(2048, log);
  1308.     if (pool == NULL) {
  1309.         return NULL;
  1310.     }

  1312.     ctx = ngx_pcalloc(pool, sizeof(ngx_ssl_ocsp_ctx_t));
  1313.     if (ctx == NULL) {
  1314.         ngx_destroy_pool(pool);
  1315.         return NULL;
  1316.     }

  1318.     log = ngx_palloc(pool, sizeof(ngx_log_t));
  1319.     if (log == NULL) {
  1320.         ngx_destroy_pool(pool);
  1321.         return NULL;
  1322.     }

  1324.     ctx->pool = pool;

  1326.     *log = *ctx->pool->log;

  1328.     ctx->pool->log = log;
  1329.     ctx->log = log;

  1331.     log->handler = ngx_ssl_ocsp_log_error;
  1332.     log->data = ctx;
  1333.     log->action = "requesting certificate status";

  1335.     return ctx;
  1336. }


  1339. static void
  1340. ‌ngx_ssl_ocsp_done(ngx_ssl_ocsp_ctx_t *ctx)
  1341. {
  1342.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1343.                    "ssl ocsp done");

  1345.     if (ctx->resolve) {
  1346.         ngx_resolve_name_done(ctx->resolve);
  1347.     }

  1349.     if (ctx->peer.connection) {
  1350.         ngx_close_connection(ctx->peer.connection);
  1351.     }

  1353.     ngx_destroy_pool(ctx->pool);
  1354. }


  1357. static void
  1358. ‌ngx_ssl_ocsp_error(ngx_ssl_ocsp_ctx_t *ctx)
  1359. {
  1360.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1361.                    "ssl ocsp error");

  1363.     ctx->code = 0;
  1364.     ctx->handler(ctx);
  1365. }


  1368. static void
  1369. ‌ngx_ssl_ocsp_next(ngx_ssl_ocsp_ctx_t *ctx)
  1370. {
  1371.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1372.                    "ssl ocsp next");

  1374.     if (++ctx->naddr >= ctx->naddrs) {
  1375.         ngx_ssl_ocsp_error(ctx);
  1376.         return;
  1377.     }

  1379.     ctx->request->pos = ctx->request->start;

  1381.     if (ctx->response) {
  1382.         ctx->response->last = ctx->response->pos;
  1383.     }

  1385.     if (ctx->peer.connection) {
  1386.         ngx_close_connection(ctx->peer.connection);
  1387.         ctx->peer.connection = NULL;
  1388.     }

  1390.     ctx->state = 0;
  1391.     ctx->count = 0;
  1392.     ctx->done = 0;

  1394.     ngx_ssl_ocsp_connect(ctx);
  1395. }


  1398. static void
  1399. ‌ngx_ssl_ocsp_request(ngx_ssl_ocsp_ctx_t *ctx)
  1400. {
  1401.     ngx_resolver_ctx_t  *resolve, temp;

  1403.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1404.                    "ssl ocsp request");

  1406.     if (ngx_ssl_ocsp_create_request(ctx) != NGX_OK) {
  1407.         ngx_ssl_ocsp_error(ctx);
  1408.         return;
  1409.     }

  1411.     if (ctx->resolver) {
  1412.         /* resolve OCSP responder hostname */

  1414.         temp.name = ctx->host;

  1416.         resolve = ngx_resolve_start(ctx->resolver, &temp);
  1417.         if (resolve == NULL) {
  1418.             ngx_ssl_ocsp_error(ctx);
  1419.             return;
  1420.         }

  1422.         if (resolve == NGX_NO_RESOLVER) {
  1423.             if (ctx->naddrs == 0) {
  1424.                 ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  1425.                               "no resolver defined to resolve %V", &ctx->host);

  1427.                 ngx_ssl_ocsp_error(ctx);
  1428.                 return;
  1429.             }

  1431.             ngx_log_error(NGX_LOG_WARN, ctx->log, 0,
  1432.                           "no resolver defined to resolve %V", &ctx->host);
  1433.             goto connect;
  1434.         }

  1436.         resolve->name = ctx->host;
  1437.         resolve->handler = ngx_ssl_ocsp_resolve_handler;
  1438.         resolve->data = ctx;
  1439.         resolve->timeout = ctx->resolver_timeout;

  1441.         ctx->resolve = resolve;

  1443.         if (ngx_resolve_name(resolve) != NGX_OK) {
  1444.             ctx->resolve = NULL;
  1445.             ngx_ssl_ocsp_error(ctx);
  1446.             return;
  1447.         }

  1449.         return;
  1450.     }

  1452. connect:

  1454.     ngx_ssl_ocsp_connect(ctx);
  1455. }


  1458. static void
  1459. ‌ngx_ssl_ocsp_resolve_handler(ngx_resolver_ctx_t *resolve)
  1460. {
  1461.     ngx_ssl_ocsp_ctx_t *ctx = resolve->data;

  1463.     u_char           *p;
  1464.     size_t            len;
  1465.     socklen_t         socklen;
  1466.     ngx_uint_t        i;
  1467.     struct sockaddr  *sockaddr;

  1469.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1470.                    "ssl ocsp resolve handler");

  1472.     if (resolve->state) {
  1473.         ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  1474.                       "%V could not be resolved (%i: %s)",
  1475.                       &resolve->name, resolve->state,
  1476.                       ngx_resolver_strerror(resolve->state));
  1477.         goto failed;
  1478.     }

  1480. #if (NGX_DEBUG)
  1481.     {
  1482.     u_char     text[NGX_SOCKADDR_STRLEN];
  1483.     ngx_str_t  addr;

  1485.     addr.data = text;

  1487.     for (i = 0; i < resolve->naddrs; i++) {
  1488.         addr.len = ngx_sock_ntop(resolve->addrs[i].sockaddr,
  1489.                                  resolve->addrs[i].socklen,
  1490.                                  text, NGX_SOCKADDR_STRLEN, 0);

  1492.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1493.                        "name was resolved to %V", &addr);

  1495.     }
  1496.     }
  1497. #endif

  1499.     ctx->naddrs = resolve->naddrs;
  1500.     ctx->addrs = ngx_pcalloc(ctx->pool, ctx->naddrs * sizeof(ngx_addr_t));

  1502.     if (ctx->addrs == NULL) {
  1503.         goto failed;
  1504.     }

  1506.     for (i = 0; i < resolve->naddrs; i++) {

  1508.         socklen = resolve->addrs[i].socklen;

  1510.         sockaddr = ngx_palloc(ctx->pool, socklen);
  1511.         if (sockaddr == NULL) {
  1512.             goto failed;
  1513.         }

  1515.         ngx_memcpy(sockaddr, resolve->addrs[i].sockaddr, socklen);
  1516.         ngx_inet_set_port(sockaddr, ctx->port);

  1518.         ctx->addrs[i].sockaddr = sockaddr;
  1519.         ctx->addrs[i].socklen = socklen;

  1521.         p = ngx_pnalloc(ctx->pool, NGX_SOCKADDR_STRLEN);
  1522.         if (p == NULL) {
  1523.             goto failed;
  1524.         }

  1526.         len = ngx_sock_ntop(sockaddr, socklen, p, NGX_SOCKADDR_STRLEN, 1);

  1528.         ctx->addrs[i].name.len = len;
  1529.         ctx->addrs[i].name.data = p;
  1530.     }

  1532.     ngx_resolve_name_done(resolve);
  1533.     ctx->resolve = NULL;

  1535.     ngx_ssl_ocsp_connect(ctx);
  1536.     return;

  1538. failed:

  1540.     ngx_resolve_name_done(resolve);
  1541.     ctx->resolve = NULL;

  1543.     ngx_ssl_ocsp_error(ctx);
  1544. }


  1547. static void
  1548. ‌ngx_ssl_ocsp_connect(ngx_ssl_ocsp_ctx_t *ctx)
  1549. {
  1550.     ngx_int_t    rc;
  1551.     ngx_addr_t  *addr;

  1553.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1554.                    "ssl ocsp connect %ui/%ui", ctx->naddr, ctx->naddrs);

  1556.     addr = &ctx->addrs[ctx->naddr];

  1558.     ctx->peer.sockaddr = addr->sockaddr;
  1559.     ctx->peer.socklen = addr->socklen;
  1560.     ctx->peer.name = &addr->name;
  1561.     ctx->peer.get = ngx_event_get_peer;
  1562.     ctx->peer.log = ctx->log;
  1563.     ctx->peer.log_error = NGX_ERROR_ERR;

  1565.     rc = ngx_event_connect_peer(&ctx->peer);

  1567.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1568.                    "ssl ocsp connect peer done");

  1570.     if (rc == NGX_ERROR) {
  1571.         ngx_ssl_ocsp_error(ctx);
  1572.         return;
  1573.     }

  1575.     if (rc == NGX_BUSY || rc == NGX_DECLINED) {
  1576.         ngx_ssl_ocsp_next(ctx);
  1577.         return;
  1578.     }

  1580.     ctx->peer.connection->data = ctx;
  1581.     ctx->peer.connection->pool = ctx->pool;

  1583.     ctx->peer.connection->read->handler = ngx_ssl_ocsp_read_handler;
  1584.     ctx->peer.connection->write->handler = ngx_ssl_ocsp_write_handler;

  1586.     ctx->process = ngx_ssl_ocsp_process_status_line;

  1588.     if (ctx->timeout) {
  1589.         ngx_add_timer(ctx->peer.connection->read, ctx->timeout);
  1590.         ngx_add_timer(ctx->peer.connection->write, ctx->timeout);
  1591.     }

  1593.     if (rc == NGX_OK) {
  1594.         ngx_ssl_ocsp_write_handler(ctx->peer.connection->write);
  1595.         return;
  1596.     }
  1597. }


  1600. static void
  1601. ‌ngx_ssl_ocsp_write_handler(ngx_event_t *wev)
  1602. {
  1603.     ssize_t              n, size;
  1604.     ngx_connection_t    *c;
  1605.     ngx_ssl_ocsp_ctx_t  *ctx;

  1607.     c = wev->data;
  1608.     ctx = c->data;

  1610.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, wev->log, 0,
  1611.                    "ssl ocsp write handler");

  1613.     if (wev->timedout) {
  1614.         ngx_log_error(NGX_LOG_ERR, wev->log, NGX_ETIMEDOUT,
  1615.                       "OCSP responder timed out");
  1616.         ngx_ssl_ocsp_next(ctx);
  1617.         return;
  1618.     }

  1620.     size = ctx->request->last - ctx->request->pos;

  1622.     n = ngx_send(c, ctx->request->pos, size);

  1624.     if (n == NGX_ERROR) {
  1625.         ngx_ssl_ocsp_next(ctx);
  1626.         return;
  1627.     }

  1629.     if (n > 0) {
  1630.         ctx->request->pos += n;

  1632.         if (n == size) {
  1633.             wev->handler = ngx_ssl_ocsp_dummy_handler;

  1635.             if (wev->timer_set) {
  1636.                 ngx_del_timer(wev);
  1637.             }

  1639.             if (ngx_handle_write_event(wev, 0) != NGX_OK) {
  1640.                 ngx_ssl_ocsp_error(ctx);
  1641.             }

  1643.             return;
  1644.         }
  1645.     }

  1647.     if (!wev->timer_set && ctx->timeout) {
  1648.         ngx_add_timer(wev, ctx->timeout);
  1649.     }
  1650. }


  1653. static void
  1654. ‌ngx_ssl_ocsp_read_handler(ngx_event_t *rev)
  1655. {
  1656.     ssize_t              n, size;
  1657.     ngx_int_t            rc;
  1658.     ngx_connection_t    *c;
  1659.     ngx_ssl_ocsp_ctx_t  *ctx;

  1661.     c = rev->data;
  1662.     ctx = c->data;

  1664.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, rev->log, 0,
  1665.                    "ssl ocsp read handler");

  1667.     if (rev->timedout) {
  1668.         ngx_log_error(NGX_LOG_ERR, rev->log, NGX_ETIMEDOUT,
  1669.                       "OCSP responder timed out");
  1670.         ngx_ssl_ocsp_next(ctx);
  1671.         return;
  1672.     }

  1674.     if (ctx->response == NULL) {
  1675.         ctx->response = ngx_create_temp_buf(ctx->pool, 16384);
  1676.         if (ctx->response == NULL) {
  1677.             ngx_ssl_ocsp_error(ctx);
  1678.             return;
  1679.         }
  1680.     }

  1682.     for ( ;; ) {

  1684.         size = ctx->response->end - ctx->response->last;

  1686.         n = ngx_recv(c, ctx->response->last, size);

  1688.         if (n > 0) {
  1689.             ctx->response->last += n;

  1691.             rc = ctx->process(ctx);

  1693.             if (rc == NGX_ERROR) {
  1694.                 ngx_ssl_ocsp_next(ctx);
  1695.                 return;
  1696.             }

  1698.             continue;
  1699.         }

  1701.         if (n == NGX_AGAIN) {

  1703.             if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  1704.                 ngx_ssl_ocsp_error(ctx);
  1705.             }

  1707.             return;
  1708.         }

  1710.         break;
  1711.     }

  1713.     ctx->done = 1;

  1715.     rc = ctx->process(ctx);

  1717.     if (rc == NGX_DONE) {
  1718.         /* ctx->handler() was called */
  1719.         return;
  1720.     }

  1722.     ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  1723.                   "OCSP responder prematurely closed connection");

  1725.     ngx_ssl_ocsp_next(ctx);
  1726. }


  1729. static void
  1730. ‌ngx_ssl_ocsp_dummy_handler(ngx_event_t *ev)
  1731. {
  1732.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  1733.                    "ssl ocsp dummy handler");
  1734. }


  1737. static ngx_int_t
  1738. ‌ngx_ssl_ocsp_create_request(ngx_ssl_ocsp_ctx_t *ctx)
  1739. {
  1740.     int            len;
  1741.     u_char        *p;
  1742.     uintptr_t      escape;
  1743.     ngx_str_t      binary, base64;
  1744.     ngx_buf_t     *b;
  1745.     OCSP_CERTID   *id;
  1746.     OCSP_REQUEST  *ocsp;

  1748.     ocsp = OCSP_REQUEST_new();
  1749.     if (ocsp == NULL) {
  1750.         ngx_ssl_error(NGX_LOG_CRIT, ctx->log, 0,
  1751.                       "OCSP_REQUEST_new() failed");
  1752.         return NGX_ERROR;
  1753.     }

  1755.     id = OCSP_cert_to_id(NULL, ctx->cert, ctx->issuer);
  1756.     if (id == NULL) {
  1757.         ngx_ssl_error(NGX_LOG_CRIT, ctx->log, 0,
  1758.                       "OCSP_cert_to_id() failed");
  1759.         goto failed;
  1760.     }

  1762.     if (OCSP_request_add0_id(ocsp, id) == NULL) {
  1763.         ngx_ssl_error(NGX_LOG_CRIT, ctx->log, 0,
  1764.                       "OCSP_request_add0_id() failed");
  1765.         OCSP_CERTID_free(id);
  1766.         goto failed;
  1767.     }

  1769.     len = i2d_OCSP_REQUEST(ocsp, NULL);
  1770.     if (len <= 0) {
  1771.         ngx_ssl_error(NGX_LOG_CRIT, ctx->log, 0,
  1772.                       "i2d_OCSP_REQUEST() failed");
  1773.         goto failed;
  1774.     }

  1776.     binary.len = len;
  1777.     binary.data = ngx_palloc(ctx->pool, len);
  1778.     if (binary.data == NULL) {
  1779.         goto failed;
  1780.     }

  1782.     p = binary.data;
  1783.     len = i2d_OCSP_REQUEST(ocsp, &p);
  1784.     if (len <= 0) {
  1785.         ngx_ssl_error(NGX_LOG_EMERG, ctx->log, 0,
  1786.                       "i2d_OCSP_REQUEST() failed");
  1787.         goto failed;
  1788.     }

  1790.     base64.len = ngx_base64_encoded_length(binary.len);
  1791.     base64.data = ngx_palloc(ctx->pool, base64.len);
  1792.     if (base64.data == NULL) {
  1793.         goto failed;
  1794.     }

  1796.     ngx_encode_base64(&base64, &binary);

  1798.     escape = ngx_escape_uri(NULL, base64.data, base64.len,
  1799.                             NGX_ESCAPE_URI_COMPONENT);

  1801.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1802.                    "ssl ocsp request length %z, escape %d",
  1803.                    base64.len, (int) escape);

  1805.     len = sizeof("GET ") - 1 + ctx->uri.len + sizeof("/") - 1
  1806.           + base64.len + 2 * escape + sizeof(" HTTP/1.0" CRLF) - 1
  1807.           + sizeof("Host: ") - 1 + ctx->host.len + sizeof(CRLF) - 1
  1808.           + sizeof(CRLF) - 1;

  1810.     b = ngx_create_temp_buf(ctx->pool, len);
  1811.     if (b == NULL) {
  1812.         goto failed;
  1813.     }

  1815.     p = b->last;

  1817.     p = ngx_cpymem(p, "GET ", sizeof("GET ") - 1);
  1818.     p = ngx_cpymem(p, ctx->uri.data, ctx->uri.len);

  1820.     if (ctx->uri.data[ctx->uri.len - 1] != '/') {
  1821.         *p++ = '/';
  1822.     }

  1824.     if (escape == 0) {
  1825.         p = ngx_cpymem(p, base64.data, base64.len);

  1827.     } else {
  1828.         p = (u_char *) ngx_escape_uri(p, base64.data, base64.len,
  1829.                                       NGX_ESCAPE_URI_COMPONENT);
  1830.     }

  1832.     p = ngx_cpymem(p, " HTTP/1.0" CRLF, sizeof(" HTTP/1.0" CRLF) - 1);
  1833.     p = ngx_cpymem(p, "Host: ", sizeof("Host: ") - 1);
  1834.     p = ngx_cpymem(p, ctx->host.data, ctx->host.len);
  1835.     *p++ = CR; *p++ = LF;

  1837.     /* add "\r\n" at the header end */
  1838.     *p++ = CR; *p++ = LF;

  1840.     b->last = p;
  1841.     ctx->request = b;

  1843.     OCSP_REQUEST_free(ocsp);

  1845.     return NGX_OK;

  1847. failed:

  1849.     OCSP_REQUEST_free(ocsp);

  1851.     return NGX_ERROR;
  1852. }


  1855. static ngx_int_t
  1856. ‌ngx_ssl_ocsp_process_status_line(ngx_ssl_ocsp_ctx_t *ctx)
  1857. {
  1858.     ngx_int_t  rc;

  1860.     rc = ngx_ssl_ocsp_parse_status_line(ctx);

  1862.     if (rc == NGX_OK) {
  1863.         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1864.                        "ssl ocsp status %ui \"%*s\"",
  1865.                        ctx->code,
  1866.                        ctx->header_end - ctx->header_start,
  1867.                        ctx->header_start);

  1869.         ctx->process = ngx_ssl_ocsp_process_headers;
  1870.         return ctx->process(ctx);
  1871.     }

  1873.     if (rc == NGX_AGAIN) {
  1874.         return NGX_AGAIN;
  1875.     }

  1877.     /* rc == NGX_ERROR */

  1879.     ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  1880.                   "OCSP responder sent invalid response");

  1882.     return NGX_ERROR;
  1883. }


  1886. static ngx_int_t
  1887. ‌ngx_ssl_ocsp_parse_status_line(ngx_ssl_ocsp_ctx_t *ctx)
  1888. {
  1889.     u_char      ch;
  1890.     u_char     *p;
  1891.     ngx_buf_t  *b;
  1892. ‌    enum {
  1893.         sw_start = 0,
  1894.         sw_H,
  1895.         sw_HT,
  1896.         sw_HTT,
  1897.         sw_HTTP,
  1898.         sw_first_major_digit,
  1899.         sw_major_digit,
  1900.         sw_first_minor_digit,
  1901.         sw_minor_digit,
  1902.         sw_status,
  1903.         sw_space_after_status,
  1904.         sw_status_text,
  1905.         sw_almost_done
  1906.     } state;

  1908.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1909.                    "ssl ocsp process status line");

  1911.     state = ctx->state;
  1912.     b = ctx->response;

  1914.     for (p = b->pos; p < b->last; p++) {
  1915.         ch = *p;

  1917.         switch (state) {

  1919.         /* "HTTP/" */
  1920.         case sw_start:
  1921.             switch (ch) {
  1922.             case 'H':
  1923.                 state = sw_H;
  1924.                 break;
  1925.             default:
  1926.                 return NGX_ERROR;
  1927.             }
  1928.             break;

  1930.         case sw_H:
  1931.             switch (ch) {
  1932.             case 'T':
  1933.                 state = sw_HT;
  1934.                 break;
  1935.             default:
  1936.                 return NGX_ERROR;
  1937.             }
  1938.             break;

  1940.         case sw_HT:
  1941.             switch (ch) {
  1942.             case 'T':
  1943.                 state = sw_HTT;
  1944.                 break;
  1945.             default:
  1946.                 return NGX_ERROR;
  1947.             }
  1948.             break;

  1950.         case sw_HTT:
  1951.             switch (ch) {
  1952.             case 'P':
  1953.                 state = sw_HTTP;
  1954.                 break;
  1955.             default:
  1956.                 return NGX_ERROR;
  1957.             }
  1958.             break;

  1960.         case sw_HTTP:
  1961.             switch (ch) {
  1962.             case '/':
  1963.                 state = sw_first_major_digit;
  1964.                 break;
  1965.             default:
  1966.                 return NGX_ERROR;
  1967.             }
  1968.             break;

  1970.         /* the first digit of major HTTP version */
  1971.         case sw_first_major_digit:
  1972.             if (ch < '1' || ch > '9') {
  1973.                 return NGX_ERROR;
  1974.             }

  1976.             state = sw_major_digit;
  1977.             break;

  1979.         /* the major HTTP version or dot */
  1980.         case sw_major_digit:
  1981.             if (ch == '.') {
  1982.                 state = sw_first_minor_digit;
  1983.                 break;
  1984.             }

  1986.             if (ch < '0' || ch > '9') {
  1987.                 return NGX_ERROR;
  1988.             }

  1990.             break;

  1992.         /* the first digit of minor HTTP version */
  1993.         case sw_first_minor_digit:
  1994.             if (ch < '0' || ch > '9') {
  1995.                 return NGX_ERROR;
  1996.             }

  1998.             state = sw_minor_digit;
  1999.             break;

  2001.         /* the minor HTTP version or the end of the request line */
  2002.         case sw_minor_digit:
  2003.             if (ch == ' ') {
  2004.                 state = sw_status;
  2005.                 break;
  2006.             }

  2008.             if (ch < '0' || ch > '9') {
  2009.                 return NGX_ERROR;
  2010.             }

  2012.             break;

  2014.         /* HTTP status code */
  2015.         case sw_status:
  2016.             if (ch == ' ') {
  2017.                 break;
  2018.             }

  2020.             if (ch < '0' || ch > '9') {
  2021.                 return NGX_ERROR;
  2022.             }

  2024.             ctx->code = ctx->code * 10 + (ch - '0');

  2026.             if (++ctx->count == 3) {
  2027.                 state = sw_space_after_status;
  2028.                 ctx->header_start = p - 2;
  2029.             }

  2031.             break;

  2033.         /* space or end of line */
  2034.         case sw_space_after_status:
  2035.             switch (ch) {
  2036.             case ' ':
  2037.                 state = sw_status_text;
  2038.                 break;
  2039.             case '.':                    /* IIS may send 403.1, 403.2, etc */
  2040.                 state = sw_status_text;
  2041.                 break;
  2042.             case CR:
  2043.                 state = sw_almost_done;
  2044.                 break;
  2045.             case LF:
  2046.                 ctx->header_end = p;
  2047.                 goto done;
  2048.             default:
  2049.                 return NGX_ERROR;
  2050.             }
  2051.             break;

  2053.         /* any text until end of line */
  2054.         case sw_status_text:
  2055.             switch (ch) {
  2056.             case CR:
  2057.                 state = sw_almost_done;
  2058.                 break;
  2059.             case LF:
  2060.                 ctx->header_end = p;
  2061.                 goto done;
  2062.             }
  2063.             break;

  2065.         /* end of status line */
  2066.         case sw_almost_done:
  2067.             switch (ch) {
  2068.             case LF:
  2069.                 ctx->header_end = p - 1;
  2070.                 goto done;
  2071.             default:
  2072.                 return NGX_ERROR;
  2073.             }
  2074.         }
  2075.     }

  2077.     b->pos = p;
  2078.     ctx->state = state;

  2080.     return NGX_AGAIN;

  2082. done:

  2084.     b->pos = p + 1;
  2085.     ctx->state = sw_start;

  2087.     return NGX_OK;
  2088. }


  2091. static ngx_int_t
  2092. ‌ngx_ssl_ocsp_process_headers(ngx_ssl_ocsp_ctx_t *ctx)
  2093. {
  2094.     size_t     len;
  2095.     ngx_int_t  rc;

  2097.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2098.                    "ssl ocsp process headers");

  2100.     for ( ;; ) {
  2101.         rc = ngx_ssl_ocsp_parse_header_line(ctx);

  2103.         if (rc == NGX_OK) {

  2105.             ngx_log_debug4(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2106.                            "ssl ocsp header \"%*s: %*s\"",
  2107.                            ctx->header_name_end - ctx->header_name_start,
  2108.                            ctx->header_name_start,
  2109.                            ctx->header_end - ctx->header_start,
  2110.                            ctx->header_start);

  2112.             len = ctx->header_name_end - ctx->header_name_start;

  2114.             if (len == sizeof("Content-Type") - 1
  2115.                 && ngx_strncasecmp(ctx->header_name_start,
  2116.                                    (u_char *) "Content-Type",
  2117.                                    sizeof("Content-Type") - 1)
  2118.                    == 0)
  2119.             {
  2120.                 len = ctx->header_end - ctx->header_start;

  2122.                 if (len != sizeof("application/ocsp-response") - 1
  2123.                     || ngx_strncasecmp(ctx->header_start,
  2124.                                        (u_char *) "application/ocsp-response",
  2125.                                        sizeof("application/ocsp-response") - 1)
  2126.                        != 0)
  2127.                 {
  2128.                     ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  2129.                                   "OCSP responder sent invalid "
  2130.                                   "\"Content-Type\" header: \"%*s\"",
  2131.                                   ctx->header_end - ctx->header_start,
  2132.                                   ctx->header_start);
  2133.                     return NGX_ERROR;
  2134.                 }

  2136.                 continue;
  2137.             }

  2139.             /* TODO: honor Content-Length */

  2141.             continue;
  2142.         }

  2144.         if (rc == NGX_DONE) {
  2145.             break;
  2146.         }

  2148.         if (rc == NGX_AGAIN) {
  2149.             return NGX_AGAIN;
  2150.         }

  2152.         /* rc == NGX_ERROR */

  2154.         ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  2155.                       "OCSP responder sent invalid response");

  2157.         return NGX_ERROR;
  2158.     }

  2160.     ctx->process = ngx_ssl_ocsp_process_body;
  2161.     return ctx->process(ctx);
  2162. }


  2165. static ngx_int_t
  2166. ‌ngx_ssl_ocsp_parse_header_line(ngx_ssl_ocsp_ctx_t *ctx)
  2167. {
  2168.     u_char  c, ch, *p;
  2169. ‌    enum {
  2170.         sw_start = 0,
  2171.         sw_name,
  2172.         sw_space_before_value,
  2173.         sw_value,
  2174.         sw_space_after_value,
  2175.         sw_almost_done,
  2176.         sw_header_almost_done
  2177.     } state;

  2179.     state = ctx->state;

  2181.     for (p = ctx->response->pos; p < ctx->response->last; p++) {
  2182.         ch = *p;

  2184. #if 0
  2185.         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2186.                        "s:%d in:'%02Xd:%c'", state, ch, ch);
  2187. #endif

  2189.         switch (state) {

  2191.         /* first char */
  2192.         case sw_start:

  2194.             switch (ch) {
  2195.             case CR:
  2196.                 ctx->header_end = p;
  2197.                 state = sw_header_almost_done;
  2198.                 break;
  2199.             case LF:
  2200.                 ctx->header_end = p;
  2201.                 goto header_done;
  2202.             default:
  2203.                 state = sw_name;
  2204.                 ctx->header_name_start = p;

  2206.                 c = (u_char) (ch | 0x20);
  2207.                 if (c >= 'a' && c <= 'z') {
  2208.                     break;
  2209.                 }

  2211.                 if (ch >= '0' && ch <= '9') {
  2212.                     break;
  2213.                 }

  2215.                 return NGX_ERROR;
  2216.             }
  2217.             break;

  2219.         /* header name */
  2220.         case sw_name:
  2221.             c = (u_char) (ch | 0x20);
  2222.             if (c >= 'a' && c <= 'z') {
  2223.                 break;
  2224.             }

  2226.             if (ch == ':') {
  2227.                 ctx->header_name_end = p;
  2228.                 state = sw_space_before_value;
  2229.                 break;
  2230.             }

  2232.             if (ch == '-') {
  2233.                 break;
  2234.             }

  2236.             if (ch >= '0' && ch <= '9') {
  2237.                 break;
  2238.             }

  2240.             if (ch == CR) {
  2241.                 ctx->header_name_end = p;
  2242.                 ctx->header_start = p;
  2243.                 ctx->header_end = p;
  2244.                 state = sw_almost_done;
  2245.                 break;
  2246.             }

  2248.             if (ch == LF) {
  2249.                 ctx->header_name_end = p;
  2250.                 ctx->header_start = p;
  2251.                 ctx->header_end = p;
  2252.                 goto done;
  2253.             }

  2255.             return NGX_ERROR;

  2257.         /* space* before header value */
  2258.         case sw_space_before_value:
  2259.             switch (ch) {
  2260.             case ' ':
  2261.                 break;
  2262.             case CR:
  2263.                 ctx->header_start = p;
  2264.                 ctx->header_end = p;
  2265.                 state = sw_almost_done;
  2266.                 break;
  2267.             case LF:
  2268.                 ctx->header_start = p;
  2269.                 ctx->header_end = p;
  2270.                 goto done;
  2271.             default:
  2272.                 ctx->header_start = p;
  2273.                 state = sw_value;
  2274.                 break;
  2275.             }
  2276.             break;

  2278.         /* header value */
  2279.         case sw_value:
  2280.             switch (ch) {
  2281.             case ' ':
  2282.                 ctx->header_end = p;
  2283.                 state = sw_space_after_value;
  2284.                 break;
  2285.             case CR:
  2286.                 ctx->header_end = p;
  2287.                 state = sw_almost_done;
  2288.                 break;
  2289.             case LF:
  2290.                 ctx->header_end = p;
  2291.                 goto done;
  2292.             }
  2293.             break;

  2295.         /* space* before end of header line */
  2296.         case sw_space_after_value:
  2297.             switch (ch) {
  2298.             case ' ':
  2299.                 break;
  2300.             case CR:
  2301.                 state = sw_almost_done;
  2302.                 break;
  2303.             case LF:
  2304.                 goto done;
  2305.             default:
  2306.                 state = sw_value;
  2307.                 break;
  2308.             }
  2309.             break;

  2311.         /* end of header line */
  2312.         case sw_almost_done:
  2313.             switch (ch) {
  2314.             case LF:
  2315.                 goto done;
  2316.             default:
  2317.                 return NGX_ERROR;
  2318.             }

  2320.         /* end of header */
  2321.         case sw_header_almost_done:
  2322.             switch (ch) {
  2323.             case LF:
  2324.                 goto header_done;
  2325.             default:
  2326.                 return NGX_ERROR;
  2327.             }
  2328.         }
  2329.     }

  2331.     ctx->response->pos = p;
  2332.     ctx->state = state;

  2334.     return NGX_AGAIN;

  2336. done:

  2338.     ctx->response->pos = p + 1;
  2339.     ctx->state = sw_start;

  2341.     return NGX_OK;

  2343. header_done:

  2345.     ctx->response->pos = p + 1;
  2346.     ctx->state = sw_start;

  2348.     return NGX_DONE;
  2349. }


  2352. static ngx_int_t
  2353. ‌ngx_ssl_ocsp_process_body(ngx_ssl_ocsp_ctx_t *ctx)
  2354. {
  2355.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2356.                    "ssl ocsp process body");

  2358.     if (ctx->done) {
  2359.         ctx->handler(ctx);
  2360.         return NGX_DONE;
  2361.     }

  2363.     return NGX_AGAIN;
  2364. }


  2367. static ngx_int_t
  2368. ‌ngx_ssl_ocsp_verify(ngx_ssl_ocsp_ctx_t *ctx)
  2369. {
  2370.     int                    n;
  2371.     size_t                 len;
  2372.     X509_STORE            *store;
  2373.     const u_char          *p;
  2374.     OCSP_CERTID           *id;
  2375.     OCSP_RESPONSE         *ocsp;
  2376.     OCSP_BASICRESP        *basic;
  2377.     ASN1_GENERALIZEDTIME  *thisupdate, *nextupdate;

  2379.     ocsp = NULL;
  2380.     basic = NULL;
  2381.     id = NULL;

  2383.     if (ctx->code != 200) {
  2384.         goto error;
  2385.     }

  2387.     /* check the response */

  2389.     len = ctx->response->last - ctx->response->pos;
  2390.     p = ctx->response->pos;

  2392.     ocsp = d2i_OCSP_RESPONSE(NULL, &p, len);
  2393.     if (ocsp == NULL) {
  2394.         ngx_ssl_error(NGX_LOG_ERR, ctx->log, 0,
  2395.                       "d2i_OCSP_RESPONSE() failed");
  2396.         goto error;
  2397.     }

  2399.     n = OCSP_response_status(ocsp);

  2401.     if (n != OCSP_RESPONSE_STATUS_SUCCESSFUL) {
  2402.         ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  2403.                       "OCSP response not successful (%d: %s)",
  2404.                       n, OCSP_response_status_str(n));
  2405.         goto error;
  2406.     }

  2408.     basic = OCSP_response_get1_basic(ocsp);
  2409.     if (basic == NULL) {
  2410.         ngx_ssl_error(NGX_LOG_ERR, ctx->log, 0,
  2411.                       "OCSP_response_get1_basic() failed");
  2412.         goto error;
  2413.     }

  2415.     store = SSL_CTX_get_cert_store(ctx->ssl_ctx);
  2416.     if (store == NULL) {
  2417.         ngx_ssl_error(NGX_LOG_CRIT, ctx->log, 0,
  2418.                       "SSL_CTX_get_cert_store() failed");
  2419.         goto error;
  2420.     }

  2422.     if (OCSP_basic_verify(basic, ctx->chain, store, ctx->flags) != 1) {
  2423.         ngx_ssl_error(NGX_LOG_ERR, ctx->log, 0,
  2424.                       "OCSP_basic_verify() failed");
  2425.         goto error;
  2426.     }

  2428.     id = OCSP_cert_to_id(NULL, ctx->cert, ctx->issuer);
  2429.     if (id == NULL) {
  2430.         ngx_ssl_error(NGX_LOG_CRIT, ctx->log, 0,
  2431.                       "OCSP_cert_to_id() failed");
  2432.         goto error;
  2433.     }

  2435.     if (OCSP_resp_find_status(basic, id, &ctx->status, NULL, NULL,
  2436.                               &thisupdate, &nextupdate)
  2437.         != 1)
  2438.     {
  2439.         ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  2440.                       "certificate status not found in the OCSP response");
  2441.         goto error;
  2442.     }

  2444.     if (OCSP_check_validity(thisupdate, nextupdate, 300, -1) != 1) {
  2445.         ngx_ssl_error(NGX_LOG_ERR, ctx->log, 0,
  2446.                       "OCSP_check_validity() failed");
  2447.         goto error;
  2448.     }

  2450.     if (nextupdate) {
  2451.         ctx->valid = ngx_ssl_stapling_time(nextupdate);
  2452.         if (ctx->valid == (time_t) NGX_ERROR) {
  2453.             ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  2454.                           "invalid nextUpdate time in certificate status");
  2455.             goto error;
  2456.         }

  2458.     } else {
  2459.         ctx->valid = NGX_MAX_TIME_T_VALUE;
  2460.     }

  2462.     OCSP_CERTID_free(id);
  2463.     OCSP_BASICRESP_free(basic);
  2464.     OCSP_RESPONSE_free(ocsp);

  2466.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2467.                    "ssl ocsp response, %s, %uz",
  2468.                    OCSP_cert_status_str(ctx->status), len);

  2470.     return NGX_OK;

  2472. error:

  2474.     if (id) {
  2475.         OCSP_CERTID_free(id);
  2476.     }

  2478.     if (basic) {
  2479.         OCSP_BASICRESP_free(basic);
  2480.     }

  2482.     if (ocsp) {
  2483.         OCSP_RESPONSE_free(ocsp);
  2484.     }

  2486.     return NGX_ERROR;
  2487. }


  2490. ngx_int_t
  2491. ‌ngx_ssl_ocsp_cache_init(ngx_shm_zone_t *shm_zone, void *data)
  2492. {
  2493.     size_t                 len;
  2494.     ngx_slab_pool_t       *shpool;
  2495.     ngx_ssl_ocsp_cache_t  *cache;

  2497.     if (data) {
  2498.         shm_zone->data = data;
  2499.         return NGX_OK;
  2500.     }

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

  2504.     if (shm_zone->shm.exists) {
  2505.         shm_zone->data = shpool->data;
  2506.         return NGX_OK;
  2507.     }

  2509.     cache = ngx_slab_alloc(shpool, sizeof(ngx_ssl_ocsp_cache_t));
  2510.     if (cache == NULL) {
  2511.         return NGX_ERROR;
  2512.     }

  2514.     shpool->data = cache;
  2515.     shm_zone->data = cache;

  2517.     ngx_rbtree_init(&cache->rbtree, &cache->sentinel,
  2518.                     ngx_str_rbtree_insert_value);

  2520.     ngx_queue_init(&cache->expire_queue);

  2522.     len = sizeof(" in OCSP cache \"\"") + shm_zone->shm.name.len;

  2524.     shpool->log_ctx = ngx_slab_alloc(shpool, len);
  2525.     if (shpool->log_ctx == NULL) {
  2526.         return NGX_ERROR;
  2527.     }

  2529.     ngx_sprintf(shpool->log_ctx, " in OCSP cache \"%V\"%Z",
  2530.                 &shm_zone->shm.name);

  2532.     shpool->log_nomem = 0;

  2534.     return NGX_OK;
  2535. }


  2538. static ngx_int_t
  2539. ‌ngx_ssl_ocsp_cache_lookup(ngx_ssl_ocsp_ctx_t *ctx)
  2540. {
  2541.     uint32_t                    hash;
  2542.     ngx_shm_zone_t             *shm_zone;
  2543.     ngx_slab_pool_t            *shpool;
  2544.     ngx_ssl_ocsp_cache_t       *cache;
  2545.     ngx_ssl_ocsp_cache_node_t  *node;

  2547.     shm_zone = ctx->shm_zone;

  2549.     if (shm_zone == NULL) {
  2550.         return NGX_DECLINED;
  2551.     }

  2553.     if (ngx_ssl_ocsp_create_key(ctx) != NGX_OK) {
  2554.         return NGX_ERROR;
  2555.     }

  2557.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0, "ssl ocsp cache lookup");

  2559.     cache = shm_zone->data;
  2560.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;
  2561.     hash = ngx_hash_key(ctx->key.data, ctx->key.len);

  2563.     ngx_shmtx_lock(&shpool->mutex);

  2565.     node = (ngx_ssl_ocsp_cache_node_t *)
  2566.                ngx_str_rbtree_lookup(&cache->rbtree, &ctx->key, hash);

  2568.     if (node) {
  2569.         if (node->valid > ngx_time()) {
  2570.             ctx->status = node->status;
  2571.             ngx_shmtx_unlock(&shpool->mutex);

  2573.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2574.                            "ssl ocsp cache hit, %s",
  2575.                            OCSP_cert_status_str(ctx->status));

  2577.             return NGX_OK;
  2578.         }

  2580.         ngx_queue_remove(&node->queue);
  2581.         ngx_rbtree_delete(&cache->rbtree, &node->node.node);
  2582.         ngx_slab_free_locked(shpool, node);

  2584.         ngx_shmtx_unlock(&shpool->mutex);

  2586.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2587.                        "ssl ocsp cache expired");

  2589.         return NGX_DECLINED;
  2590.     }

  2592.     ngx_shmtx_unlock(&shpool->mutex);

  2594.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0, "ssl ocsp cache miss");

  2596.     return NGX_DECLINED;
  2597. }


  2600. static ngx_int_t
  2601. ‌ngx_ssl_ocsp_cache_store(ngx_ssl_ocsp_ctx_t *ctx)
  2602. {
  2603.     time_t                      now, valid;
  2604.     uint32_t                    hash;
  2605.     ngx_queue_t                *q;
  2606.     ngx_shm_zone_t             *shm_zone;
  2607.     ngx_slab_pool_t            *shpool;
  2608.     ngx_ssl_ocsp_cache_t       *cache;
  2609.     ngx_ssl_ocsp_cache_node_t  *node;

  2611.     shm_zone = ctx->shm_zone;

  2613.     if (shm_zone == NULL) {
  2614.         return NGX_OK;
  2615.     }

  2617.     valid = ctx->valid;

  2619.     now = ngx_time();

  2621.     if (valid < now) {
  2622.         return NGX_OK;
  2623.     }

  2625.     if (valid == NGX_MAX_TIME_T_VALUE) {
  2626.         valid = now + 3600;
  2627.     }

  2629.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2630.                    "ssl ocsp cache store, valid:%T", valid - now);

  2632.     cache = shm_zone->data;
  2633.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;
  2634.     hash = ngx_hash_key(ctx->key.data, ctx->key.len);

  2636.     ngx_shmtx_lock(&shpool->mutex);

  2638.     node = ngx_slab_calloc_locked(shpool,
  2639.                              sizeof(ngx_ssl_ocsp_cache_node_t) + ctx->key.len);
  2640.     if (node == NULL) {

  2642.         if (!ngx_queue_empty(&cache->expire_queue)) {
  2643.             q = ngx_queue_last(&cache->expire_queue);
  2644.             node = ngx_queue_data(q, ngx_ssl_ocsp_cache_node_t, queue);

  2646.             ngx_rbtree_delete(&cache->rbtree, &node->node.node);
  2647.             ngx_queue_remove(q);
  2648.             ngx_slab_free_locked(shpool, node);

  2650.             node = ngx_slab_alloc_locked(shpool,
  2651.                              sizeof(ngx_ssl_ocsp_cache_node_t) + ctx->key.len);
  2652.         }

  2654.         if (node == NULL) {
  2655.             ngx_shmtx_unlock(&shpool->mutex);
  2656.             ngx_log_error(NGX_LOG_ALERT, ctx->log, 0,
  2657.                           "could not allocate new entry%s", shpool->log_ctx);
  2658.             return NGX_ERROR;
  2659.         }
  2660.     }

  2662.     node->node.str.len = ctx->key.len;
  2663.     node->node.str.data = (u_char *) node + sizeof(ngx_ssl_ocsp_cache_node_t);
  2664.     ngx_memcpy(node->node.str.data, ctx->key.data, ctx->key.len);
  2665.     node->node.node.key = hash;
  2666.     node->status = ctx->status;
  2667.     node->valid = valid;

  2669.     ngx_rbtree_insert(&cache->rbtree, &node->node.node);
  2670.     ngx_queue_insert_head(&cache->expire_queue, &node->queue);

  2672.     ngx_shmtx_unlock(&shpool->mutex);

  2674.     return NGX_OK;
  2675. }


  2678. static ngx_int_t
  2679. ‌ngx_ssl_ocsp_create_key(ngx_ssl_ocsp_ctx_t *ctx)
  2680. {
  2681.     u_char           *p;
  2682.     ngx_int_t         length;
  2683.     ASN1_INTEGER     *serial;
  2684.     const X509_NAME  *name;

  2686.     p = ngx_pnalloc(ctx->pool, 60);
  2687.     if (p == NULL) {
  2688.         return NGX_ERROR;
  2689.     }

  2691.     ctx->key.data = p;
  2692.     ctx->key.len = 60;

  2694.     name = X509_get_subject_name(ctx->issuer);
  2695.     if (X509_NAME_digest(name, EVP_sha1(), p, NULL) == 0) {
  2696.         return NGX_ERROR;
  2697.     }

  2699.     p += 20;

  2701.     if (X509_pubkey_digest(ctx->issuer, EVP_sha1(), p, NULL) == 0) {
  2702.         return NGX_ERROR;
  2703.     }

  2705.     p += 20;

  2707.     serial = X509_get_serialNumber(ctx->cert);
  2708.     length = ASN1_STRING_length(serial);

  2710.     if (length > 20) {
  2711.         return NGX_ERROR;
  2712.     }

  2714.     p = ngx_cpymem(p, ASN1_STRING_get0_data(serial), length);
  2715.     ngx_memzero(p, 20 - length);

  2717.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2718.                    "ssl ocsp key %xV", &ctx->key);

  2720.     return NGX_OK;
  2721. }


  2724. static u_char *
  2725. ‌ngx_ssl_ocsp_log_error(ngx_log_t *log, u_char *buf, size_t len)
  2726. {
  2727.     u_char              *p;
  2728.     ngx_ssl_ocsp_ctx_t  *ctx;

  2730.     p = buf;

  2732.     if (log->action) {
  2733.         p = ngx_snprintf(buf, len, " while %s", log->action);
  2734.         len -= p - buf;
  2735.         buf = p;
  2736.     }

  2738.     ctx = log->data;

  2740.     if (ctx) {
  2741.         p = ngx_snprintf(buf, len, ", responder: %V", &ctx->host);
  2742.         len -= p - buf;
  2743.         buf = p;
  2744.     }

  2746.     if (ctx && ctx->peer.name) {
  2747.         p = ngx_snprintf(buf, len, ", peer: %V", ctx->peer.name);
  2748.         len -= p - buf;
  2749.         buf = p;
  2750.     }

  2752.     if (ctx && ctx->name) {
  2753.         p = ngx_snprintf(buf, len, ", certificate: \"%s\"", ctx->name);
  2754.         len -= p - buf;
  2755.         buf = p;
  2756.     }

  2758.     return p;
  2759. }


  2762. #else


  2765. ngx_int_t
  2766. ‌ngx_ssl_stapling(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *file,
  2767.     ngx_str_t *responder, ngx_uint_t verify)
  2768. {
  2769.     ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  2770.                   "\"ssl_stapling\" ignored, not supported");

  2772.     return NGX_OK;
  2773. }


  2776. ngx_int_t
  2777. ‌ngx_ssl_stapling_resolver(ngx_conf_t *cf, ngx_ssl_t *ssl,
  2778.     ngx_resolver_t *resolver, ngx_msec_t resolver_timeout)
  2779. {
  2780.     return NGX_OK;
  2781. }


  2784. ngx_int_t
  2785. ‌ngx_ssl_ocsp(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *responder,
  2786.     ngx_uint_t depth, ngx_shm_zone_t *shm_zone)
  2787. {
  2788.     ngx_log_error(NGX_LOG_EMERG, ssl->log, 0,
  2789.                   "\"ssl_ocsp\" is not supported on this platform");

  2791.     return NGX_ERROR;
  2792. }


  2795. ngx_int_t
  2796. ‌ngx_ssl_ocsp_resolver(ngx_conf_t *cf, ngx_ssl_t *ssl,
  2797.     ngx_resolver_t *resolver, ngx_msec_t resolver_timeout)
  2798. {
  2799.     return NGX_OK;
  2800. }


  2803. ngx_int_t
  2804. ‌ngx_ssl_ocsp_validate(ngx_connection_t *c)
  2805. {
  2806.     return NGX_OK;
  2807. }


  2810. ngx_int_t
  2811. ‌ngx_ssl_ocsp_get_status(ngx_connection_t *c, const char **s)
  2812. {
  2813.     return NGX_OK;
  2814. }


  2817. void
  2818. ‌ngx_ssl_ocsp_cleanup(ngx_connection_t *c)
  2819. {
  2820. }


  2823. ngx_int_t
  2824. ‌ngx_ssl_ocsp_cache_init(ngx_shm_zone_t *shm_zone, void *data)
  2825. {
  2826.     return NGX_OK;
  2827. }


  2830. #endif

One Level Up Top Level