One Level Up Top Level

src/event/quic/ngx_event_quic_openssl_compat.c - nginx source code

Data types defined

Functions defined

Macros defined

Source code


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


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


  13. #if (NGX_QUIC_OPENSSL_COMPAT)

  15. ‌#define NGX_QUIC_COMPAT_RECORD_SIZE          1024

  17. ‌#define NGX_QUIC_COMPAT_SSL_TP_EXT           0x39

  19. ‌#define NGX_QUIC_COMPAT_CLIENT_HANDSHAKE     "CLIENT_HANDSHAKE_TRAFFIC_SECRET"
  20. ‌#define NGX_QUIC_COMPAT_SERVER_HANDSHAKE     "SERVER_HANDSHAKE_TRAFFIC_SECRET"
  21. ‌#define NGX_QUIC_COMPAT_CLIENT_APPLICATION   "CLIENT_TRAFFIC_SECRET_0"
  22. ‌#define NGX_QUIC_COMPAT_SERVER_APPLICATION   "SERVER_TRAFFIC_SECRET_0"


  25. ‌typedef struct {
  26.     ngx_quic_secret_t             secret;
  27.     ngx_uint_t                    cipher;
  28. ‌} ngx_quic_compat_keys_t;


  31. ‌typedef struct {
  32.     ngx_log_t                    *log;

  34.     u_char                        type;
  35.     ngx_str_t                     payload;
  36.     uint64_t                      number;
  37.     ngx_quic_compat_keys_t       *keys;

  39.     enum ssl_encryption_level_t   level;
  40. ‌} ngx_quic_compat_record_t;


  43. ‌struct ngx_quic_compat_s {
  44.     const SSL_QUIC_METHOD        *method;

  46.     enum ssl_encryption_level_t   write_level;

  48.     uint64_t                      read_record;
  49.     ngx_quic_compat_keys_t        keys;

  51.     ngx_str_t                     tp;
  52.     ngx_str_t                     ctp;
  53. };


  56. static void ngx_quic_compat_keylog_callback(const SSL *ssl, const char *line);
  57. static ngx_int_t ngx_quic_compat_set_encryption_secret(ngx_connection_t *c,
  58.     ngx_quic_compat_keys_t *keys, enum ssl_encryption_level_t level,
  59.     const SSL_CIPHER *cipher, const uint8_t *secret, size_t secret_len);
  60. static void ngx_quic_compat_cleanup_encryption_secret(void *data);
  61. static int ngx_quic_compat_add_transport_params_callback(SSL *ssl,
  62.     unsigned int ext_type, unsigned int context, const unsigned char **out,
  63.     size_t *outlen, X509 *x, size_t chainidx, int *al, void *add_arg);
  64. static int ngx_quic_compat_parse_transport_params_callback(SSL *ssl,
  65.     unsigned int ext_type, unsigned int context, const unsigned char *in,
  66.     size_t inlen, X509 *x, size_t chainidx, int *al, void *parse_arg);
  67. static void ngx_quic_compat_message_callback(int write_p, int version,
  68.     int content_type, const void *buf, size_t len, SSL *ssl, void *arg);
  69. static size_t ngx_quic_compat_create_header(ngx_quic_compat_record_t *rec,
  70.     u_char *out, ngx_uint_t plain);
  71. static ngx_int_t ngx_quic_compat_create_record(ngx_quic_compat_record_t *rec,
  72.     ngx_str_t *res);


  75. ngx_int_t
  76. ‌ngx_quic_compat_init(ngx_conf_t *cf, SSL_CTX *ctx)
  77. {
  78.     SSL_CTX_set_keylog_callback(ctx, ngx_quic_compat_keylog_callback);

  80.     if (SSL_CTX_has_client_custom_ext(ctx, NGX_QUIC_COMPAT_SSL_TP_EXT)) {
  81.         return NGX_OK;
  82.     }

  84.     if (SSL_CTX_add_custom_ext(ctx, NGX_QUIC_COMPAT_SSL_TP_EXT,
  85.                                SSL_EXT_CLIENT_HELLO
  86.                                |SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
  87.                                ngx_quic_compat_add_transport_params_callback,
  88.                                NULL,
  89.                                NULL,
  90.                                ngx_quic_compat_parse_transport_params_callback,
  91.                                NULL)
  92.         == 0)
  93.     {
  94.         ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  95.                       "SSL_CTX_add_custom_ext() failed");
  96.         return NGX_ERROR;
  97.     }

  99.     return NGX_OK;
  100. }


  103. static void
  104. ‌ngx_quic_compat_keylog_callback(const SSL *ssl, const char *line)
  105. {
  106.     u_char                        ch, *p, *start, value;
  107.     size_t                        n;
  108.     ngx_uint_t                    write;
  109.     const SSL_CIPHER             *cipher;
  110.     ngx_quic_compat_t            *com;
  111.     ngx_connection_t             *c;
  112.     ngx_quic_connection_t        *qc;
  113.     enum ssl_encryption_level_t   level;
  114.     u_char                        secret[EVP_MAX_MD_SIZE];

  116.     c = ngx_ssl_get_connection(ssl);
  117.     if (c->type != SOCK_DGRAM) {
  118.         return;
  119.     }

  121.     p = (u_char *) line;

  123.     for (start = p; *p && *p != ' '; p++);

  125.     n = p - start;

  127.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  128.                    "quic compat secret %*s", n, start);

  130.     if (n == sizeof(NGX_QUIC_COMPAT_CLIENT_HANDSHAKE) - 1
  131.         && ngx_strncmp(start, NGX_QUIC_COMPAT_CLIENT_HANDSHAKE, n) == 0)
  132.     {
  133.         level = ssl_encryption_handshake;
  134.         write = 0;

  136.     } else if (n == sizeof(NGX_QUIC_COMPAT_SERVER_HANDSHAKE) - 1
  137.                && ngx_strncmp(start, NGX_QUIC_COMPAT_SERVER_HANDSHAKE, n) == 0)
  138.     {
  139.         level = ssl_encryption_handshake;
  140.         write = 1;

  142.     } else if (n == sizeof(NGX_QUIC_COMPAT_CLIENT_APPLICATION) - 1
  143.                && ngx_strncmp(start, NGX_QUIC_COMPAT_CLIENT_APPLICATION, n)
  144.                   == 0)
  145.     {
  146.         level = ssl_encryption_application;
  147.         write = 0;

  149.     } else if (n == sizeof(NGX_QUIC_COMPAT_SERVER_APPLICATION) - 1
  150.                && ngx_strncmp(start, NGX_QUIC_COMPAT_SERVER_APPLICATION, n)
  151.                    == 0)
  152.     {
  153.         level = ssl_encryption_application;
  154.         write = 1;

  156.     } else {
  157.         return;
  158.     }

  160.     if (*p++ == '\0') {
  161.         return;
  162.     }

  164.     for ( /* void */ ; *p && *p != ' '; p++);

  166.     if (*p++ == '\0') {
  167.         return;
  168.     }

  170.     for (n = 0, start = p; *p; p++) {
  171.         ch = *p;

  173.         if (ch >= '0' && ch <= '9') {
  174.             value = ch - '0';
  175.             goto next;
  176.         }

  178.         ch = (u_char) (ch | 0x20);

  180.         if (ch >= 'a' && ch <= 'f') {
  181.             value = ch - 'a' + 10;
  182.             goto next;
  183.         }

  185.         ngx_log_error(NGX_LOG_EMERG, c->log, 0,
  186.                       "invalid OpenSSL QUIC secret format");

  188.         return;

  190.     next:

  192.         if ((p - start) % 2) {
  193.             secret[n++] += value;

  195.         } else {
  196.             if (n >= EVP_MAX_MD_SIZE) {
  197.                 ngx_log_error(NGX_LOG_EMERG, c->log, 0,
  198.                               "too big OpenSSL QUIC secret");
  199.                 return;
  200.             }

  202.             secret[n] = (value << 4);
  203.         }
  204.     }

  206.     qc = ngx_quic_get_connection(c);
  207.     com = qc->compat;
  208.     cipher = SSL_get_current_cipher(ssl);

  210.     if (write) {
  211.         com->method->set_write_secret((SSL *) ssl, level, cipher, secret, n);
  212.         com->write_level = level;

  214.     } else {
  215.         com->method->set_read_secret((SSL *) ssl, level, cipher, secret, n);
  216.         com->read_record = 0;

  218.         (void) ngx_quic_compat_set_encryption_secret(c, &com->keys, level,
  219.                                                      cipher, secret, n);
  220.     }

  222.     ngx_explicit_memzero(secret, n);
  223. }


  226. static ngx_int_t
  227. ‌ngx_quic_compat_set_encryption_secret(ngx_connection_t *c,
  228.     ngx_quic_compat_keys_t *keys, enum ssl_encryption_level_t level,
  229.     const SSL_CIPHER *cipher, const uint8_t *secret, size_t secret_len)
  230. {
  231.     ngx_int_t            key_len;
  232.     ngx_str_t            secret_str;
  233.     ngx_uint_t           i;
  234.     ngx_quic_md_t        key;
  235.     ngx_quic_hkdf_t      seq[2];
  236.     ngx_quic_secret_t   *peer_secret;
  237.     ngx_quic_ciphers_t   ciphers;
  238.     ngx_pool_cleanup_t  *cln;

  240.     peer_secret = &keys->secret;

  242.     keys->cipher = SSL_CIPHER_get_id(cipher);

  244.     key_len = ngx_quic_ciphers(keys->cipher, &ciphers);

  246.     if (key_len == NGX_ERROR) {
  247.         ngx_ssl_error(NGX_LOG_INFO, c->log, 0, "unexpected cipher");
  248.         return NGX_ERROR;
  249.     }

  251.     key.len = key_len;

  253.     peer_secret->iv.len = NGX_QUIC_IV_LEN;

  255.     secret_str.len = secret_len;
  256.     secret_str.data = (u_char *) secret;

  258.     ngx_quic_hkdf_set(&seq[0], "tls13 key", &key, &secret_str);
  259.     ngx_quic_hkdf_set(&seq[1], "tls13 iv", &peer_secret->iv, &secret_str);

  261.     for (i = 0; i < (sizeof(seq) / sizeof(seq[0])); i++) {
  262.         if (ngx_quic_hkdf_expand(&seq[i], ciphers.d, c->log) != NGX_OK) {
  263.             return NGX_ERROR;
  264.         }
  265.     }

  267.     /* register cleanup handler once */

  269.     if (peer_secret->ctx) {
  270.         ngx_quic_crypto_cleanup(peer_secret);

  272.     } else {
  273.         cln = ngx_pool_cleanup_add(c->pool, 0);
  274.         if (cln == NULL) {
  275.             return NGX_ERROR;
  276.         }

  278.         cln->handler = ngx_quic_compat_cleanup_encryption_secret;
  279.         cln->data = peer_secret;
  280.     }

  282.     if (ngx_quic_crypto_init(ciphers.c, peer_secret, &key, 1, c->log)
  283.         == NGX_ERROR)
  284.     {
  285.         return NGX_ERROR;
  286.     }

  288.     ngx_explicit_memzero(key.data, key.len);

  290.     return NGX_OK;
  291. }


  294. static void
  295. ‌ngx_quic_compat_cleanup_encryption_secret(void *data)
  296. {
  297.     ngx_quic_secret_t *secret = data;

  299.     ngx_quic_crypto_cleanup(secret);
  300. }


  303. static int
  304. ‌ngx_quic_compat_add_transport_params_callback(SSL *ssl, unsigned int ext_type,
  305.     unsigned int context, const unsigned char **out, size_t *outlen, X509 *x,
  306.     size_t chainidx, int *al, void *add_arg)
  307. {
  308.     ngx_connection_t       *c;
  309.     ngx_quic_compat_t      *com;
  310.     ngx_quic_connection_t  *qc;

  312.     c = ngx_ssl_get_connection(ssl);
  313.     if (c->type != SOCK_DGRAM) {
  314.         return 0;
  315.     }

  317.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  318.                    "quic compat add transport params");

  320.     qc = ngx_quic_get_connection(c);
  321.     com = qc->compat;

  323.     *out = com->tp.data;
  324.     *outlen = com->tp.len;

  326.     return 1;
  327. }


  330. static int
  331. ‌ngx_quic_compat_parse_transport_params_callback(SSL *ssl, unsigned int ext_type,
  332.     unsigned int context, const unsigned char *in, size_t inlen, X509 *x,
  333.     size_t chainidx, int *al, void *parse_arg)
  334. {
  335.     u_char                 *p;
  336.     ngx_connection_t       *c;
  337.     ngx_quic_compat_t      *com;
  338.     ngx_quic_connection_t  *qc;

  340.     c = ngx_ssl_get_connection(ssl);
  341.     if (c->type != SOCK_DGRAM) {
  342.         return 0;
  343.     }

  345.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  346.                    "quic compat parse transport params");

  348.     qc = ngx_quic_get_connection(c);
  349.     com = qc->compat;

  351.     p = ngx_pnalloc(c->pool, inlen);
  352.     if (p == NULL) {
  353.         return 0;
  354.     }

  356.     ngx_memcpy(p, in, inlen);

  358.     com->ctp.data = p;
  359.     com->ctp.len = inlen;

  361.     return 1;
  362. }


  365. int
  366. ‌SSL_set_quic_method(SSL *ssl, const SSL_QUIC_METHOD *quic_method)
  367. {
  368.     BIO                    *rbio, *wbio;
  369.     ngx_connection_t       *c;
  370.     ngx_quic_compat_t      *com;
  371.     ngx_quic_connection_t  *qc;

  373.     c = ngx_ssl_get_connection(ssl);

  375.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, "quic compat set method");

  377.     qc = ngx_quic_get_connection(c);

  379.     qc->compat = ngx_pcalloc(c->pool, sizeof(ngx_quic_compat_t));
  380.     if (qc->compat == NULL) {
  381.         return 0;
  382.     }

  384.     com = qc->compat;
  385.     com->method = quic_method;

  387.     rbio = BIO_new(BIO_s_mem());
  388.     if (rbio == NULL) {
  389.         return 0;
  390.     }

  392.     wbio = BIO_new(BIO_s_null());
  393.     if (wbio == NULL) {
  394.         BIO_free(rbio);
  395.         return 0;
  396.     }

  398.     SSL_set_bio(ssl, rbio, wbio);

  400.     SSL_set_msg_callback(ssl, ngx_quic_compat_message_callback);

  402.     /* early data is not supported */
  403.     SSL_set_max_early_data(ssl, 0);

  405.     return 1;
  406. }


  409. static void
  410. ‌ngx_quic_compat_message_callback(int write_p, int version, int content_type,
  411.     const void *buf, size_t len, SSL *ssl, void *arg)
  412. {
  413.     ngx_uint_t                    alert;
  414.     ngx_connection_t             *c;
  415.     ngx_quic_compat_t            *com;
  416.     ngx_quic_connection_t        *qc;
  417.     enum ssl_encryption_level_t   level;

  419.     if (!write_p) {
  420.         return;
  421.     }

  423.     c = ngx_ssl_get_connection(ssl);
  424.     qc = ngx_quic_get_connection(c);

  426.     if (qc == NULL) {
  427.         /* closing */
  428.         return;
  429.     }

  431.     com = qc->compat;
  432.     level = com->write_level;

  434.     switch (content_type) {

  436.     case SSL3_RT_HANDSHAKE:
  437.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  438.                        "quic compat tx %s len:%uz ",
  439.                        ngx_quic_level_name(level), len);

  441.         if (com->method->add_handshake_data(ssl, level, buf, len) != 1) {
  442.             goto failed;
  443.         }

  445.         break;

  447.     case SSL3_RT_ALERT:
  448.         if (len >= 2) {
  449.             alert = ((u_char *) buf)[1];

  451.             ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  452.                            "quic compat %s alert:%ui len:%uz ",
  453.                            ngx_quic_level_name(level), alert, len);

  455.             if (com->method->send_alert(ssl, level, alert) != 1) {
  456.                 goto failed;
  457.             }
  458.         }

  460.         break;
  461.     }

  463.     return;

  465. failed:

  467.     ngx_post_event(&qc->close, &ngx_posted_events);
  468. }


  471. int
  472. ‌SSL_provide_quic_data(SSL *ssl, enum ssl_encryption_level_t level,
  473.     const uint8_t *data, size_t len)
  474. {
  475.     BIO                       *rbio;
  476.     size_t                     n;
  477.     u_char                    *p;
  478.     ngx_str_t                  res;
  479.     ngx_connection_t          *c;
  480.     ngx_quic_compat_t         *com;
  481.     ngx_quic_connection_t     *qc;
  482.     ngx_quic_compat_record_t   rec;
  483.     u_char                     in[NGX_QUIC_COMPAT_RECORD_SIZE + 1];
  484.     u_char                     out[NGX_QUIC_COMPAT_RECORD_SIZE + 1
  485.                                    + SSL3_RT_HEADER_LENGTH
  486.                                    + NGX_QUIC_TAG_LEN];

  488.     c = ngx_ssl_get_connection(ssl);

  490.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0, "quic compat rx %s len:%uz",
  491.                    ngx_quic_level_name(level), len);

  493.     qc = ngx_quic_get_connection(c);
  494.     com = qc->compat;
  495.     rbio = SSL_get_rbio(ssl);

  497.     while (len) {
  498.         ngx_memzero(&rec, sizeof(ngx_quic_compat_record_t));

  500.         rec.type = SSL3_RT_HANDSHAKE;
  501.         rec.log = c->log;
  502.         rec.number = com->read_record++;
  503.         rec.keys = &com->keys;
  504.         rec.level = level;

  506.         if (level == ssl_encryption_initial) {
  507.             n = ngx_min(len, 65535);

  509.             rec.payload.len = n;
  510.             rec.payload.data = (u_char *) data;

  512.             ngx_quic_compat_create_header(&rec, out, 1);

  514.             BIO_write(rbio, out, SSL3_RT_HEADER_LENGTH);
  515.             BIO_write(rbio, data, n);

  517. #if defined(NGX_QUIC_DEBUG_CRYPTO) && defined(NGX_QUIC_DEBUG_PACKETS)
  518.             ngx_log_debug5(NGX_LOG_DEBUG_EVENT, c->log, 0,
  519.                            "quic compat record len:%uz %*xs%*xs",
  520.                            n + SSL3_RT_HEADER_LENGTH,
  521.                            (size_t) SSL3_RT_HEADER_LENGTH, out, n, data);
  522. #endif

  524.         } else {
  525.             n = ngx_min(len, NGX_QUIC_COMPAT_RECORD_SIZE);

  527.             p = ngx_cpymem(in, data, n);
  528.             *p++ = SSL3_RT_HANDSHAKE;

  530.             rec.payload.len = p - in;
  531.             rec.payload.data = in;

  533.             res.data = out;

  535.             if (ngx_quic_compat_create_record(&rec, &res) != NGX_OK) {
  536.                 return 0;
  537.             }

  539. #if defined(NGX_QUIC_DEBUG_CRYPTO) && defined(NGX_QUIC_DEBUG_PACKETS)
  540.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  541.                            "quic compat record len:%uz %xV", res.len, &res);
  542. #endif

  544.             BIO_write(rbio, res.data, res.len);
  545.         }

  547.         data += n;
  548.         len -= n;
  549.     }

  551.     return 1;
  552. }


  555. static size_t
  556. ‌ngx_quic_compat_create_header(ngx_quic_compat_record_t *rec, u_char *out,
  557.     ngx_uint_t plain)
  558. {
  559.     u_char  type;
  560.     size_t  len;

  562.     len = rec->payload.len;

  564.     if (plain) {
  565.         type = rec->type;

  567.     } else {
  568.         type = SSL3_RT_APPLICATION_DATA;
  569.         len += NGX_QUIC_TAG_LEN;
  570.     }

  572.     out[0] = type;
  573.     out[1] = 0x03;
  574.     out[2] = 0x03;
  575.     out[3] = (len >> 8);
  576.     out[4] = len;

  578.     return 5;
  579. }


  582. static ngx_int_t
  583. ‌ngx_quic_compat_create_record(ngx_quic_compat_record_t *rec, ngx_str_t *res)
  584. {
  585.     ngx_str_t           ad, out;
  586.     ngx_quic_secret_t  *secret;
  587.     u_char              nonce[NGX_QUIC_IV_LEN];

  589.     ad.data = res->data;
  590.     ad.len = ngx_quic_compat_create_header(rec, ad.data, 0);

  592.     out.len = rec->payload.len + NGX_QUIC_TAG_LEN;
  593.     out.data = res->data + ad.len;

  595. #ifdef NGX_QUIC_DEBUG_CRYPTO
  596.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, rec->log, 0,
  597.                    "quic compat ad len:%uz %xV", ad.len, &ad);
  598. #endif

  600.     secret = &rec->keys->secret;

  602.     ngx_memcpy(nonce, secret->iv.data, secret->iv.len);
  603.     ngx_quic_compute_nonce(nonce, sizeof(nonce), rec->number);

  605.     if (ngx_quic_crypto_seal(secret, &out, nonce, &rec->payload, &ad, rec->log)
  606.         != NGX_OK)
  607.     {
  608.         return NGX_ERROR;
  609.     }

  611.     res->len = ad.len + out.len;

  613.     return NGX_OK;
  614. }


  617. int
  618. ‌SSL_set_quic_transport_params(SSL *ssl, const uint8_t *params,
  619.     size_t params_len)
  620. {
  621.     ngx_connection_t       *c;
  622.     ngx_quic_compat_t      *com;
  623.     ngx_quic_connection_t  *qc;

  625.     c = ngx_ssl_get_connection(ssl);
  626.     qc = ngx_quic_get_connection(c);
  627.     com = qc->compat;

  629.     com->tp.len = params_len;
  630.     com->tp.data = (u_char *) params;

  632.     return 1;
  633. }


  636. void
  637. ‌SSL_get_peer_quic_transport_params(const SSL *ssl, const uint8_t **out_params,
  638.     size_t *out_params_len)
  639. {
  640.     ngx_connection_t       *c;
  641.     ngx_quic_compat_t      *com;
  642.     ngx_quic_connection_t  *qc;

  644.     c = ngx_ssl_get_connection(ssl);
  645.     qc = ngx_quic_get_connection(c);
  646.     com = qc->compat;

  648.     *out_params = com->ctp.data;
  649.     *out_params_len = com->ctp.len;
  650. }

  652. #endif /* NGX_QUIC_OPENSSL_COMPAT */

One Level Up Top Level