One Level Up Top Level

src/event/quic/ngx_event_quic_ssl.c - nginx

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>
  10. #include <ngx_event_quic_connection.h>


  13. /*
  14. * RFC 9000, 7.5.  Cryptographic Message Buffering
  15. *
  16. * Implementations MUST support buffering at least 4096 bytes of data
  17. */
  18. ‌#define NGX_QUIC_MAX_BUFFERED    65535


  21. #if (NGX_QUIC_OPENSSL_API)

  23. static int ngx_quic_cbs_send(ngx_ssl_conn_t *ssl_conn,
  24.     const unsigned char *data, size_t len, size_t *consumed, void *arg);
  25. static int ngx_quic_cbs_recv_rcd(ngx_ssl_conn_t *ssl_conn,
  26.     const unsigned char **data, size_t *bytes_read, void *arg);
  27. static int ngx_quic_cbs_release_rcd(ngx_ssl_conn_t *ssl_conn,
  28.     size_t bytes_read, void *arg);
  29. static int ngx_quic_cbs_yield_secret(ngx_ssl_conn_t *ssl_conn, uint32_t level,
  30.     int direction, const unsigned char *secret, size_t secret_len, void *arg);
  31. static int ngx_quic_cbs_got_transport_params(ngx_ssl_conn_t *ssl_conn,
  32.     const unsigned char *params, size_t params_len, void *arg);
  33. static int ngx_quic_cbs_alert(ngx_ssl_conn_t *ssl_conn, unsigned char alert,
  34.     void *arg);

  36. #else /* NGX_QUIC_BORINGSSL_API || NGX_QUIC_QUICTLS_API */

  38. static ngx_inline ngx_uint_t ngx_quic_map_encryption_level(
  39.     enum ssl_encryption_level_t ssl_level);

  41. #if (NGX_QUIC_BORINGSSL_API)
  42. static int ngx_quic_set_read_secret(ngx_ssl_conn_t *ssl_conn,
  43.     enum ssl_encryption_level_t ssl_level, const SSL_CIPHER *cipher,
  44.     const uint8_t *secret, size_t secret_len);
  45. static int ngx_quic_set_write_secret(ngx_ssl_conn_t *ssl_conn,
  46.     enum ssl_encryption_level_t ssl_level, const SSL_CIPHER *cipher,
  47.     const uint8_t *secret, size_t secret_len);
  48. #else /* NGX_QUIC_QUICTLS_API */
  49. static int ngx_quic_set_encryption_secrets(ngx_ssl_conn_t *ssl_conn,
  50.     enum ssl_encryption_level_t ssl_level, const uint8_t *read_secret,
  51.     const uint8_t *write_secret, size_t secret_len);
  52. #endif

  54. static int ngx_quic_add_handshake_data(ngx_ssl_conn_t *ssl_conn,
  55.     enum ssl_encryption_level_t ssl_level, const uint8_t *data, size_t len);
  56. static int ngx_quic_flush_flight(ngx_ssl_conn_t *ssl_conn);
  57. static int ngx_quic_send_alert(ngx_ssl_conn_t *ssl_conn,
  58.     enum ssl_encryption_level_t ssl_level, uint8_t alert);

  60. #endif

  62. static ngx_int_t ngx_quic_handshake(ngx_connection_t *c);
  63. static ngx_int_t ngx_quic_crypto_provide(ngx_connection_t *c, ngx_uint_t level);


  66. #if (NGX_QUIC_OPENSSL_API)

  68. static int
  69. ‌ngx_quic_cbs_send(ngx_ssl_conn_t *ssl_conn,
  70.     const unsigned char *data, size_t len, size_t *consumed, void *arg)
  71. {
  72.     ngx_connection_t  *c = arg;

  74.     ngx_chain_t            *out;
  75.     unsigned int            alpn_len;
  76.     ngx_quic_frame_t       *frame;
  77.     const unsigned char    *alpn_data;
  78.     ngx_quic_send_ctx_t    *ctx;
  79.     ngx_quic_connection_t  *qc;

  81.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  82.                    "quic ngx_quic_cbs_send len:%uz", len);

  84.     qc = ngx_quic_get_connection(c);

  86.     *consumed = 0;

  88.     SSL_get0_alpn_selected(ssl_conn, &alpn_data, &alpn_len);

  90.     if (alpn_len == 0) {
  91.         qc->error = NGX_QUIC_ERR_CRYPTO(SSL_AD_NO_APPLICATION_PROTOCOL);
  92.         qc->error_reason = "missing ALPN extension";

  94.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  95.                       "quic missing ALPN extension");
  96.         return 1;
  97.     }

  99.     if (!qc->client_tp_done) {
  100.         /* RFC 9001, 8.2.  QUIC Transport Parameters Extension */
  101.         qc->error = NGX_QUIC_ERR_CRYPTO(SSL_AD_MISSING_EXTENSION);
  102.         qc->error_reason = "missing transport parameters";

  104.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  105.                       "missing transport parameters");
  106.         return 1;
  107.     }

  109.     ctx = ngx_quic_get_send_ctx(qc, qc->write_level);

  111.     out = ngx_quic_copy_buffer(c, (u_char *) data, len);
  112.     if (out == NGX_CHAIN_ERROR) {
  113.         qc->error = NGX_QUIC_ERR_INTERNAL_ERROR;
  114.         return 1;
  115.     }

  117.     frame = ngx_quic_alloc_frame(c);
  118.     if (frame == NULL) {
  119.         qc->error = NGX_QUIC_ERR_INTERNAL_ERROR;
  120.         return 1;
  121.     }

  123.     frame->data = out;
  124.     frame->level = qc->write_level;
  125.     frame->type = NGX_QUIC_FT_CRYPTO;
  126.     frame->u.crypto.offset = ctx->crypto_sent;
  127.     frame->u.crypto.length = len;

  129.     ctx->crypto_sent += len;
  130.     *consumed = len;

  132.     ngx_quic_queue_frame(qc, frame);

  134.     return 1;
  135. }


  138. static int
  139. ‌ngx_quic_cbs_recv_rcd(ngx_ssl_conn_t *ssl_conn,
  140.     const unsigned char **data, size_t *bytes_read, void *arg)
  141. {
  142.     ngx_connection_t  *c = arg;

  144.     ngx_buf_t              *b;
  145.     ngx_chain_t            *cl;
  146.     ngx_quic_send_ctx_t    *ctx;
  147.     ngx_quic_connection_t  *qc;

  149.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  150.                    "quic ngx_quic_cbs_recv_rcd");

  152.     qc = ngx_quic_get_connection(c);
  153.     ctx = ngx_quic_get_send_ctx(qc, qc->read_level);

  155.     cl = ctx->crypto.chain;

  157.     if (cl == NULL || cl->buf->sync) {
  158.         *data = NULL;
  159.         *bytes_read = 0;

  161.     } else {
  162.         b = cl->buf;

  164.         *data = b->pos;
  165.         *bytes_read = b->last - b->pos;
  166.     }

  168.     return 1;
  169. }


  172. static int
  173. ‌ngx_quic_cbs_release_rcd(ngx_ssl_conn_t *ssl_conn, size_t bytes_read, void *arg)
  174. {
  175.     ngx_connection_t  *c = arg;

  177.     ngx_chain_t            *cl;
  178.     ngx_quic_send_ctx_t    *ctx;
  179.     ngx_quic_connection_t  *qc;

  181.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  182.                    "quic ngx_quic_cbs_release_rcd len:%uz", bytes_read);

  184.     /* already closed on handshake failure */

  186.     qc = ngx_quic_get_connection(c);
  187.     if (qc == NULL) {
  188.         return 1;
  189.     }

  191.     ctx = ngx_quic_get_send_ctx(qc, qc->read_level);

  193.     cl = ngx_quic_read_buffer(c, &ctx->crypto, bytes_read);
  194.     if (cl == NGX_CHAIN_ERROR) {
  195.         qc->error = NGX_QUIC_ERR_INTERNAL_ERROR;
  196.         return 1;
  197.     }

  199.     ngx_quic_free_chain(c, cl);

  201.     return 1;
  202. }


  205. static int
  206. ‌ngx_quic_cbs_yield_secret(ngx_ssl_conn_t *ssl_conn, uint32_t ssl_level,
  207.     int direction, const unsigned char *secret, size_t secret_len, void *arg)
  208. {
  209.     ngx_connection_t  *c = arg;

  211.     ngx_uint_t              level;
  212.     const SSL_CIPHER       *cipher;
  213.     ngx_quic_connection_t  *qc;

  215.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  216.                    "quic ngx_quic_cbs_yield_secret() level:%uD", ssl_level);
  217. #ifdef NGX_QUIC_DEBUG_CRYPTO
  218.     ngx_log_debug4(NGX_LOG_DEBUG_EVENT, c->log, 0,
  219.                    "quic %s secret len:%uz %*xs",
  220.                    direction ? "write" : "read", secret_len,
  221.                    secret_len, secret);
  222. #endif

  224.     qc = ngx_quic_get_connection(c);
  225.     cipher = SSL_get_current_cipher(ssl_conn);

  227.     switch (ssl_level) {
  228.     case OSSL_RECORD_PROTECTION_LEVEL_NONE:
  229.         level = NGX_QUIC_ENCRYPTION_INITIAL;
  230.         break;
  231.     case OSSL_RECORD_PROTECTION_LEVEL_EARLY:
  232.         level = NGX_QUIC_ENCRYPTION_EARLY_DATA;
  233.         break;
  234.     case OSSL_RECORD_PROTECTION_LEVEL_HANDSHAKE:
  235.         level = NGX_QUIC_ENCRYPTION_HANDSHAKE;
  236.         break;
  237.     default: /* OSSL_RECORD_PROTECTION_LEVEL_APPLICATION */
  238.         level = NGX_QUIC_ENCRYPTION_APPLICATION;
  239.         break;
  240.     }

  242.     if (ngx_quic_keys_set_encryption_secret(c->log, direction, qc->keys, level,
  243.                                             cipher, secret, secret_len)
  244.         != NGX_OK)
  245.     {
  246.         qc->error = NGX_QUIC_ERR_INTERNAL_ERROR;
  247.         return 1;
  248.     }

  250.     if (direction) {
  251.         qc->write_level = level;

  253.     } else {
  254.         qc->read_level = level;
  255.     }

  257.     return 1;
  258. }


  261. static int
  262. ‌ngx_quic_cbs_got_transport_params(ngx_ssl_conn_t *ssl_conn,
  263.     const unsigned char *params, size_t params_len, void *arg)
  264. {
  265.     ngx_connection_t  *c = arg;

  267.     u_char                 *p, *end;
  268.     ngx_quic_tp_t           ctp;
  269.     ngx_quic_connection_t  *qc;

  271.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  272.                    "quic ngx_quic_cbs_got_transport_params() len:%uz",
  273.                    params_len);

  275.     qc = ngx_quic_get_connection(c);

  277.     /* defaults for parameters not sent by client */
  278.     ngx_memcpy(&ctp, &qc->ctp, sizeof(ngx_quic_tp_t));

  280.     p = (u_char *) params;
  281.     end = p + params_len;

  283.     if (ngx_quic_parse_transport_params(p, end, &ctp, c->log) != NGX_OK) {
  284.         qc->error = NGX_QUIC_ERR_TRANSPORT_PARAMETER_ERROR;
  285.         qc->error_reason = "failed to process transport parameters";

  287.         return 1;
  288.     }

  290.     if (ngx_quic_apply_transport_params(c, &ctp) != NGX_OK) {
  291.         return 1;
  292.     }

  294.     qc->client_tp_done = 1;

  296.     return 1;
  297. }


  300. static int
  301. ‌ngx_quic_cbs_alert(ngx_ssl_conn_t *ssl_conn, unsigned char alert, void *arg)
  302. {
  303.     ngx_connection_t  *c = arg;

  305.     ngx_quic_connection_t  *qc;

  307.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  308.                    "quic ngx_quic_cbs_alert() alert:%d", (int) alert);

  310.     /* already closed on regular shutdown */

  312.     qc = ngx_quic_get_connection(c);
  313.     if (qc == NULL) {
  314.         return 1;
  315.     }

  317.     qc->error = NGX_QUIC_ERR_CRYPTO(alert);
  318.     qc->error_reason = "handshake failed";

  320.     return 1;
  321. }


  324. #else /* NGX_QUIC_BORINGSSL_API || NGX_QUIC_QUICTLS_API */


  327. static ngx_inline ngx_uint_t
  328. ‌ngx_quic_map_encryption_level(enum ssl_encryption_level_t ssl_level)
  329. {
  330.     switch (ssl_level) {
  331.     case ssl_encryption_initial:
  332.         return NGX_QUIC_ENCRYPTION_INITIAL;
  333.     case ssl_encryption_early_data:
  334.         return NGX_QUIC_ENCRYPTION_EARLY_DATA;
  335.     case ssl_encryption_handshake:
  336.         return NGX_QUIC_ENCRYPTION_HANDSHAKE;
  337.     default: /* ssl_encryption_application */
  338.         return NGX_QUIC_ENCRYPTION_APPLICATION;
  339.     }
  340. }


  343. #if (NGX_QUIC_BORINGSSL_API)

  345. static int
  346. ‌ngx_quic_set_read_secret(ngx_ssl_conn_t *ssl_conn,
  347.     enum ssl_encryption_level_t ssl_level, const SSL_CIPHER *cipher,
  348.     const uint8_t *rsecret, size_t secret_len)
  349. {
  350.     ngx_uint_t              level;
  351.     ngx_connection_t       *c;
  352.     ngx_quic_connection_t  *qc;

  354.     c = ngx_ssl_get_connection(ssl_conn);
  355.     qc = ngx_quic_get_connection(c);
  356.     level = ngx_quic_map_encryption_level(ssl_level);

  358.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  359.                    "quic ngx_quic_set_read_secret() level:%d", ssl_level);
  360. #ifdef NGX_QUIC_DEBUG_CRYPTO
  361.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  362.                    "quic read secret len:%uz %*xs", secret_len,
  363.                    secret_len, rsecret);
  364. #endif

  366.     if (ngx_quic_keys_set_encryption_secret(c->log, 0, qc->keys, level,
  367.                                             cipher, rsecret, secret_len)
  368.         != NGX_OK)
  369.     {
  370.         qc->error = NGX_QUIC_ERR_INTERNAL_ERROR;
  371.     }

  373.     return 1;
  374. }


  377. static int
  378. ‌ngx_quic_set_write_secret(ngx_ssl_conn_t *ssl_conn,
  379.     enum ssl_encryption_level_t ssl_level, const SSL_CIPHER *cipher,
  380.     const uint8_t *wsecret, size_t secret_len)
  381. {
  382.     ngx_uint_t              level;
  383.     ngx_connection_t       *c;
  384.     ngx_quic_connection_t  *qc;

  386.     c = ngx_ssl_get_connection(ssl_conn);
  387.     qc = ngx_quic_get_connection(c);
  388.     level = ngx_quic_map_encryption_level(ssl_level);

  390.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  391.                    "quic ngx_quic_set_write_secret() level:%d", ssl_level);
  392. #ifdef NGX_QUIC_DEBUG_CRYPTO
  393.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  394.                    "quic write secret len:%uz %*xs", secret_len,
  395.                    secret_len, wsecret);
  396. #endif

  398.     if (ngx_quic_keys_set_encryption_secret(c->log, 1, qc->keys, level,
  399.                                             cipher, wsecret, secret_len)
  400.         != NGX_OK)
  401.     {
  402.         qc->error = NGX_QUIC_ERR_INTERNAL_ERROR;
  403.     }

  405.     return 1;
  406. }

  408. #else /* NGX_QUIC_QUICTLS_API */

  410. static int
  411. ‌ngx_quic_set_encryption_secrets(ngx_ssl_conn_t *ssl_conn,
  412.     enum ssl_encryption_level_t ssl_level, const uint8_t *rsecret,
  413.     const uint8_t *wsecret, size_t secret_len)
  414. {
  415.     ngx_uint_t              level;
  416.     ngx_connection_t       *c;
  417.     const SSL_CIPHER       *cipher;
  418.     ngx_quic_connection_t  *qc;

  420.     c = ngx_ssl_get_connection(ssl_conn);
  421.     qc = ngx_quic_get_connection(c);
  422.     level = ngx_quic_map_encryption_level(ssl_level);

  424.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  425.                    "quic ngx_quic_set_encryption_secrets() level:%d",
  426.                    ssl_level);
  427. #ifdef NGX_QUIC_DEBUG_CRYPTO
  428.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  429.                    "quic read secret len:%uz %*xs", secret_len,
  430.                    secret_len, rsecret);
  431. #endif

  433.     cipher = SSL_get_current_cipher(ssl_conn);

  435.     if (ngx_quic_keys_set_encryption_secret(c->log, 0, qc->keys, level,
  436.                                             cipher, rsecret, secret_len)
  437.         != NGX_OK)
  438.     {
  439.         qc->error = NGX_QUIC_ERR_INTERNAL_ERROR;
  440.         return 1;
  441.     }

  443.     if (level == NGX_QUIC_ENCRYPTION_EARLY_DATA) {
  444.         return 1;
  445.     }

  447. #ifdef NGX_QUIC_DEBUG_CRYPTO
  448.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  449.                    "quic write secret len:%uz %*xs", secret_len,
  450.                    secret_len, wsecret);
  451. #endif

  453.     if (ngx_quic_keys_set_encryption_secret(c->log, 1, qc->keys, level,
  454.                                             cipher, wsecret, secret_len)
  455.         != NGX_OK)
  456.     {
  457.         qc->error = NGX_QUIC_ERR_INTERNAL_ERROR;
  458.     }

  460.     return 1;
  461. }

  463. #endif


  466. static int
  467. ‌ngx_quic_add_handshake_data(ngx_ssl_conn_t *ssl_conn,
  468.     enum ssl_encryption_level_t ssl_level, const uint8_t *data, size_t len)
  469. {
  470.     u_char                 *p, *end;
  471.     size_t                  client_params_len;
  472.     ngx_uint_t              level;
  473.     ngx_chain_t            *out;
  474.     unsigned int            alpn_len;
  475.     const uint8_t          *client_params;
  476.     ngx_quic_tp_t           ctp;
  477.     ngx_quic_frame_t       *frame;
  478.     ngx_connection_t       *c;
  479.     const unsigned char    *alpn_data;
  480.     ngx_quic_send_ctx_t    *ctx;
  481.     ngx_quic_connection_t  *qc;

  483.     c = ngx_ssl_get_connection(ssl_conn);
  484.     qc = ngx_quic_get_connection(c);
  485.     level = ngx_quic_map_encryption_level(ssl_level);

  487.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  488.                    "quic ngx_quic_add_handshake_data");

  490.     if (!qc->client_tp_done) {
  491.         /*
  492.          * things to do once during handshake: check ALPN and transport
  493.          * parameters; we want to break handshake if something is wrong
  494.          * here;
  495.          */

  497.         SSL_get0_alpn_selected(ssl_conn, &alpn_data, &alpn_len);

  499.         if (alpn_len == 0) {
  500.             if (qc->error == 0) {
  501.                 qc->error = NGX_QUIC_ERR_CRYPTO(SSL_AD_NO_APPLICATION_PROTOCOL);
  502.                 qc->error_reason = "missing ALPN extension";

  504.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  505.                               "quic missing ALPN extension");
  506.             }

  508.             return 1;
  509.         }

  511.         SSL_get_peer_quic_transport_params(ssl_conn, &client_params,
  512.                                            &client_params_len);

  514.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  515.                        "quic SSL_get_peer_quic_transport_params():"
  516.                        " params_len:%ui", client_params_len);

  518.         if (client_params_len == 0) {
  519.             /* RFC 9001, 8.2.  QUIC Transport Parameters Extension */

  521.             if (qc->error == 0) {
  522.                 qc->error = NGX_QUIC_ERR_CRYPTO(SSL_AD_MISSING_EXTENSION);
  523.                 qc->error_reason = "missing transport parameters";

  525.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  526.                               "missing transport parameters");
  527.             }

  529.             return 1;
  530.         }

  532.         p = (u_char *) client_params;
  533.         end = p + client_params_len;

  535.         /* defaults for parameters not sent by client */
  536.         ngx_memcpy(&ctp, &qc->ctp, sizeof(ngx_quic_tp_t));

  538.         if (ngx_quic_parse_transport_params(p, end, &ctp, c->log)
  539.             != NGX_OK)
  540.         {
  541.             qc->error = NGX_QUIC_ERR_TRANSPORT_PARAMETER_ERROR;
  542.             qc->error_reason = "failed to process transport parameters";

  544.             return 1;
  545.         }

  547.         if (ngx_quic_apply_transport_params(c, &ctp) != NGX_OK) {
  548.             return 1;
  549.         }

  551.         qc->client_tp_done = 1;
  552.     }

  554.     ctx = ngx_quic_get_send_ctx(qc, level);

  556.     out = ngx_quic_copy_buffer(c, (u_char *) data, len);
  557.     if (out == NGX_CHAIN_ERROR) {
  558.         qc->error = NGX_QUIC_ERR_INTERNAL_ERROR;
  559.         return 1;
  560.     }

  562.     frame = ngx_quic_alloc_frame(c);
  563.     if (frame == NULL) {
  564.         qc->error = NGX_QUIC_ERR_INTERNAL_ERROR;
  565.         return 1;
  566.     }

  568.     frame->data = out;
  569.     frame->level = level;
  570.     frame->type = NGX_QUIC_FT_CRYPTO;
  571.     frame->u.crypto.offset = ctx->crypto_sent;
  572.     frame->u.crypto.length = len;

  574.     ctx->crypto_sent += len;

  576.     ngx_quic_queue_frame(qc, frame);

  578.     return 1;
  579. }


  582. static int
  583. ‌ngx_quic_flush_flight(ngx_ssl_conn_t *ssl_conn)
  584. {
  585. #if (NGX_DEBUG)
  586.     ngx_connection_t  *c;

  588.     c = ngx_ssl_get_connection(ssl_conn);

  590.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  591.                    "quic ngx_quic_flush_flight()");
  592. #endif
  593.     return 1;
  594. }


  597. static int
  598. ‌ngx_quic_send_alert(ngx_ssl_conn_t *ssl_conn,
  599.     enum ssl_encryption_level_t ssl_level, uint8_t alert)
  600. {
  601.     ngx_connection_t       *c;
  602.     ngx_quic_connection_t  *qc;

  604.     c = ngx_ssl_get_connection(ssl_conn);

  606.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  607.                    "quic ngx_quic_send_alert() level:%d alert:%d",
  608.                    ssl_level, (int) alert);

  610.     /* already closed on regular shutdown */

  612.     qc = ngx_quic_get_connection(c);
  613.     if (qc == NULL) {
  614.         return 1;
  615.     }

  617.     qc->error = NGX_QUIC_ERR_CRYPTO(alert);
  618.     qc->error_reason = "handshake failed";

  620.     return 1;
  621. }

  623. #endif


  626. ngx_int_t
  627. ‌ngx_quic_handle_crypto_frame(ngx_connection_t *c, ngx_quic_header_t *pkt,
  628.     ngx_quic_frame_t *frame)
  629. {
  630.     uint64_t                  last;
  631.     ngx_quic_send_ctx_t      *ctx;
  632.     ngx_quic_connection_t    *qc;
  633.     ngx_quic_crypto_frame_t  *f;

  635.     qc = ngx_quic_get_connection(c);

  637.     if (!ngx_quic_keys_available(qc->keys, pkt->level, 0)) {
  638.         return NGX_OK;
  639.     }

  641.     ctx = ngx_quic_get_send_ctx(qc, pkt->level);
  642.     f = &frame->u.crypto;

  644.     /* no overflow since both values are 62-bit */
  645.     last = f->offset + f->length;

  647.     if (last > ctx->crypto.offset + NGX_QUIC_MAX_BUFFERED) {
  648.         qc->error = NGX_QUIC_ERR_CRYPTO_BUFFER_EXCEEDED;
  649.         return NGX_ERROR;
  650.     }

  652.     if (last <= ctx->crypto.offset) {
  653.         if (pkt->level == NGX_QUIC_ENCRYPTION_INITIAL) {
  654.             /* speeding up handshake completion */

  656.             if (!ngx_queue_empty(&ctx->sent)) {
  657.                 ngx_quic_resend_frames(c, ctx);

  659.                 ctx = ngx_quic_get_send_ctx(qc, NGX_QUIC_ENCRYPTION_HANDSHAKE);
  660.                 while (!ngx_queue_empty(&ctx->sent)) {
  661.                     ngx_quic_resend_frames(c, ctx);
  662.                 }
  663.             }
  664.         }

  666.         return NGX_OK;
  667.     }

  669.     if (ngx_quic_write_buffer(c, &ctx->crypto, frame->data, f->length,
  670.                               f->offset)
  671.         == NGX_CHAIN_ERROR)
  672.     {
  673.         return NGX_ERROR;
  674.     }

  676.     if (ngx_quic_crypto_provide(c, pkt->level) != NGX_OK) {
  677.         return NGX_ERROR;
  678.     }

  680.     return ngx_quic_handshake(c);
  681. }


  684. static ngx_int_t
  685. ‌ngx_quic_handshake(ngx_connection_t *c)
  686. {
  687.     int                     n, sslerr;
  688.     ngx_ssl_conn_t         *ssl_conn;
  689.     ngx_quic_frame_t       *frame;
  690.     ngx_quic_connection_t  *qc;

  692.     qc = ngx_quic_get_connection(c);

  694.     ssl_conn = c->ssl->connection;

  696.     n = SSL_do_handshake(ssl_conn);

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

  700.     if (n <= 0) {
  701.         sslerr = SSL_get_error(ssl_conn, n);

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

  706.         if (c->ssl->handshake_rejected) {
  707.             ngx_connection_error(c, 0, "handshake rejected");
  708.             ERR_clear_error();
  709.             return NGX_ERROR;
  710.         }

  712.         if (qc->error) {
  713.             ngx_connection_error(c, 0, "SSL_do_handshake() failed");
  714.             ERR_clear_error();
  715.             return NGX_ERROR;
  716.         }

  718.         if (sslerr != SSL_ERROR_WANT_READ) {
  719.             ngx_ssl_connection_error(c, sslerr, 0, "SSL_do_handshake() failed");
  720.             return NGX_ERROR;
  721.         }
  722.     }

  724.     if (qc->error) {
  725.         ngx_connection_error(c, 0, "SSL_do_handshake() failed");
  726.         return NGX_ERROR;
  727.     }

  729.     if (!SSL_is_init_finished(ssl_conn)) {
  730.         if (ngx_quic_keys_available(qc->keys, NGX_QUIC_ENCRYPTION_EARLY_DATA, 0)
  731.             && qc->client_tp_done)
  732.         {
  733.             if (ngx_quic_init_streams(c) != NGX_OK) {
  734.                 return NGX_ERROR;
  735.             }
  736.         }

  738.         return NGX_OK;
  739.     }

  741. #if (NGX_DEBUG)
  742.     ngx_ssl_handshake_log(c);
  743. #endif

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

  747.     frame = ngx_quic_alloc_frame(c);
  748.     if (frame == NULL) {
  749.         return NGX_ERROR;
  750.     }

  752.     frame->level = NGX_QUIC_ENCRYPTION_APPLICATION;
  753.     frame->type = NGX_QUIC_FT_HANDSHAKE_DONE;
  754.     ngx_quic_queue_frame(qc, frame);

  756.     if (qc->conf->retry) {
  757.         if (ngx_quic_send_new_token(c, qc->path) != NGX_OK) {
  758.             return NGX_ERROR;
  759.         }
  760.     }

  762.     /*
  763.      * RFC 9001, 9.5.  Header Protection Timing Side Channels
  764.      *
  765.      * Generating next keys before a key update is received.
  766.      */

  768.     ngx_post_event(&qc->key_update, &ngx_posted_events);

  770.     /*
  771.      * RFC 9001, 4.9.2.  Discarding Handshake Keys
  772.      *
  773.      * An endpoint MUST discard its Handshake keys
  774.      * when the TLS handshake is confirmed.
  775.      */
  776.     ngx_quic_discard_ctx(c, NGX_QUIC_ENCRYPTION_HANDSHAKE);

  778.     ngx_quic_discover_path_mtu(c, qc->path);

  780.     /* start accepting clients on negotiated number of server ids */
  781.     if (ngx_quic_create_sockets(c) != NGX_OK) {
  782.         return NGX_ERROR;
  783.     }

  785.     if (ngx_quic_init_streams(c) != NGX_OK) {
  786.         return NGX_ERROR;
  787.     }

  789.     return NGX_OK;
  790. }


  793. static ngx_int_t
  794. ‌ngx_quic_crypto_provide(ngx_connection_t *c, ngx_uint_t level)
  795. {
  796. #if (NGX_QUIC_BORINGSSL_API || NGX_QUIC_QUICTLS_API)

  798.     ngx_buf_t                    *b;
  799.     ngx_chain_t                  *out, *cl;
  800.     ngx_quic_send_ctx_t          *ctx;
  801.     ngx_quic_connection_t        *qc;
  802.     enum ssl_encryption_level_t   ssl_level;

  804.     qc = ngx_quic_get_connection(c);
  805.     ctx = ngx_quic_get_send_ctx(qc, level);

  807.     out = ngx_quic_read_buffer(c, &ctx->crypto, (uint64_t) -1);
  808.     if (out == NGX_CHAIN_ERROR) {
  809.         return NGX_ERROR;
  810.     }

  812.     switch (level) {
  813.     case NGX_QUIC_ENCRYPTION_INITIAL:
  814.         ssl_level = ssl_encryption_initial;
  815.         break;
  816.     case NGX_QUIC_ENCRYPTION_EARLY_DATA:
  817.         ssl_level = ssl_encryption_early_data;
  818.         break;
  819.     case NGX_QUIC_ENCRYPTION_HANDSHAKE:
  820.         ssl_level = ssl_encryption_handshake;
  821.         break;
  822.     default: /* NGX_QUIC_ENCRYPTION_APPLICATION */
  823.         ssl_level = ssl_encryption_application;
  824.         break;
  825.     }

  827.     for (cl = out; cl; cl = cl->next) {
  828.         b = cl->buf;

  830.         if (!SSL_provide_quic_data(c->ssl->connection, ssl_level, b->pos,
  831.                                    b->last - b->pos))
  832.         {
  833.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  834.                           "SSL_provide_quic_data() failed");
  835.             return NGX_ERROR;
  836.         }
  837.     }

  839.     ngx_quic_free_chain(c, out);

  841. #endif

  843.     return NGX_OK;
  844. }


  847. ngx_int_t
  848. ‌ngx_quic_init_connection(ngx_connection_t *c)
  849. {
  850.     u_char                 *p;
  851.     size_t                  clen;
  852.     ssize_t                 len;
  853.     ngx_str_t               dcid;
  854.     ngx_ssl_conn_t         *ssl_conn;
  855.     ngx_quic_socket_t      *qsock;
  856.     ngx_quic_connection_t  *qc;

  858. #if (NGX_QUIC_OPENSSL_API)
  859.     static const OSSL_DISPATCH  qtdis[] = {

  861.         { OSSL_FUNC_SSL_QUIC_TLS_CRYPTO_SEND,
  862.           (void (*)(void)) ngx_quic_cbs_send },

  864.         { OSSL_FUNC_SSL_QUIC_TLS_CRYPTO_RECV_RCD,
  865.           (void (*)(void)) ngx_quic_cbs_recv_rcd },

  867.         { OSSL_FUNC_SSL_QUIC_TLS_CRYPTO_RELEASE_RCD,
  868.           (void (*)(void)) ngx_quic_cbs_release_rcd },

  870.         { OSSL_FUNC_SSL_QUIC_TLS_YIELD_SECRET,
  871.           (void (*)(void)) ngx_quic_cbs_yield_secret },

  873.         { OSSL_FUNC_SSL_QUIC_TLS_GOT_TRANSPORT_PARAMS,
  874.           (void (*)(void)) ngx_quic_cbs_got_transport_params },

  876.         { OSSL_FUNC_SSL_QUIC_TLS_ALERT,
  877.           (void (*)(void)) ngx_quic_cbs_alert },

  879.         { 0, NULL }
  880.     };
  881. #else /* NGX_QUIC_BORINGSSL_API || NGX_QUIC_QUICTLS_API */
  882.     static SSL_QUIC_METHOD  quic_method;
  883. #endif

  885.     qc = ngx_quic_get_connection(c);

  887.     if (ngx_ssl_create_connection(qc->conf->ssl, c, 0) != NGX_OK) {
  888.         return NGX_ERROR;
  889.     }

  891.     c->ssl->no_wait_shutdown = 1;

  893.     ssl_conn = c->ssl->connection;

  895. #if (NGX_QUIC_OPENSSL_API)

  897.     if (SSL_set_quic_tls_cbs(ssl_conn, qtdis, c) == 0) {
  898.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  899.                       "quic SSL_set_quic_tls_cbs() failed");
  900.         return NGX_ERROR;
  901.     }

  903.     if (SSL_CTX_get_max_early_data(qc->conf->ssl->ctx)) {
  904.         SSL_set_quic_tls_early_data_enabled(ssl_conn, 1);
  905.     }

  907. #else /* NGX_QUIC_BORINGSSL_API || NGX_QUIC_QUICTLS_API */

  909.     if (!quic_method.send_alert) {
  910. #if (NGX_QUIC_BORINGSSL_API)
  911.         quic_method.set_read_secret = ngx_quic_set_read_secret;
  912.         quic_method.set_write_secret = ngx_quic_set_write_secret;
  913. #else
  914.         quic_method.set_encryption_secrets = ngx_quic_set_encryption_secrets;
  915. #endif
  916.         quic_method.add_handshake_data = ngx_quic_add_handshake_data;
  917.         quic_method.flush_flight = ngx_quic_flush_flight;
  918.         quic_method.send_alert = ngx_quic_send_alert;
  919.     }

  921.     if (SSL_set_quic_method(ssl_conn, &quic_method) == 0) {
  922.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  923.                       "quic SSL_set_quic_method() failed");
  924.         return NGX_ERROR;
  925.     }

  927. #if (NGX_QUIC_QUICTLS_API)
  928.     if (SSL_CTX_get_max_early_data(qc->conf->ssl->ctx)) {
  929.         SSL_set_quic_early_data_enabled(ssl_conn, 1);
  930.     }
  931. #endif

  933. #endif

  935.     qsock = ngx_quic_get_socket(c);

  937.     dcid.data = qsock->sid.id;
  938.     dcid.len = qsock->sid.len;

  940.     if (ngx_quic_new_sr_token(c, &dcid, qc->conf->sr_token_key, qc->tp.sr_token)
  941.         != NGX_OK)
  942.     {
  943.         return NGX_ERROR;
  944.     }

  946.     len = ngx_quic_create_transport_params(NULL, NULL, &qc->tp, &clen);
  947.     /* always succeeds */

  949.     p = ngx_pnalloc(c->pool, len);
  950.     if (p == NULL) {
  951.         return NGX_ERROR;
  952.     }

  954.     len = ngx_quic_create_transport_params(p, p + len, &qc->tp, NULL);
  955.     if (len < 0) {
  956.         return NGX_ERROR;
  957.     }

  959. #ifdef NGX_QUIC_DEBUG_PACKETS
  960.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  961.                    "quic transport parameters len:%uz %*xs", len, len, p);
  962. #endif

  964. #if (NGX_QUIC_OPENSSL_API)
  965.     if (SSL_set_quic_tls_transport_params(ssl_conn, p, len) == 0) {
  966.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  967.                       "quic SSL_set_quic_tls_transport_params() failed");
  968.         return NGX_ERROR;
  969.     }
  970. #else
  971.     if (SSL_set_quic_transport_params(ssl_conn, p, len) == 0) {
  972.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  973.                       "quic SSL_set_quic_transport_params() failed");
  974.         return NGX_ERROR;
  975.     }
  976. #endif

  978. #if (defined OPENSSL_IS_BORINGSSL || defined OPENSSL_IS_AWSLC)
  979.     if (SSL_set_quic_early_data_context(ssl_conn, p, clen) == 0) {
  980.         ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  981.                       "quic SSL_set_quic_early_data_context() failed");
  982.         return NGX_ERROR;
  983.     }
  984. #endif

  986.     return NGX_OK;
  987. }

One Level Up Top Level