One Level Up Top Level

src/event/quic/ngx_event_quic_openssl_compat.c - nginx

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;
  38. ‌} ngx_quic_compat_record_t;


  41. ‌struct ngx_quic_compat_s {
  42.     const SSL_QUIC_METHOD        *method;

  44.     enum ssl_encryption_level_t   write_level;

  46.     uint64_t                      read_record;
  47.     ngx_quic_compat_keys_t        keys;

  49.     ngx_str_t                     tp;
  50.     ngx_str_t                     ctp;
  51. };


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


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

  78.     if (SSL_CTX_has_client_custom_ext(ctx, NGX_QUIC_COMPAT_SSL_TP_EXT)) {
  79.         return NGX_OK;
  80.     }

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

  97.     return NGX_OK;
  98. }


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

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

  119.     p = (u_char *) line;

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

  123.     n = p - start;

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

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

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

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

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

  154.     } else {
  155.         return;
  156.     }

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

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

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

  168.     for (n = 0, start = p; *p; p++) {
  169.         ch = *p;

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

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

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

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

  186.         return;

  188.     next:

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

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

  200.             secret[n] = (value << 4);
  201.         }
  202.     }

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

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

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

  216.         if (ngx_quic_compat_set_encryption_secret(c, &com->keys, level,
  217.                                                   cipher, secret, n)
  218.             != NGX_OK)
  219.         {
  220.             qc->error = NGX_QUIC_ERR_INTERNAL_ERROR;
  221.         }
  222.     }

  224.     ngx_explicit_memzero(secret, n);
  225. }


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

  242.     peer_secret = &keys->secret;

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

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

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

  253.     key.len = key_len;

  255.     peer_secret->iv.len = NGX_QUIC_IV_LEN;

  257.     secret_str.len = secret_len;
  258.     secret_str.data = (u_char *) secret;

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

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

  269.     /* register cleanup handler once */

  271.     if (peer_secret->ctx) {
  272.         ngx_quic_crypto_cleanup(peer_secret);

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

  280.         cln->handler = ngx_quic_compat_cleanup_encryption_secret;
  281.         cln->data = peer_secret;
  282.     }

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

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

  292.     return NGX_OK;
  293. }


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

  301.     ngx_quic_crypto_cleanup(secret);
  302. }


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

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

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

  322.     qc = ngx_quic_get_connection(c);
  323.     com = qc->compat;

  325.     *out = com->tp.data;
  326.     *outlen = com->tp.len;

  328.     return 1;
  329. }


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

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

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

  350.     qc = ngx_quic_get_connection(c);
  351.     com = qc->compat;

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

  358.     ngx_memcpy(p, in, inlen);

  360.     com->ctp.data = p;
  361.     com->ctp.len = inlen;

  363.     return 1;
  364. }


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

  375.     c = ngx_ssl_get_connection(ssl);

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

  379.     qc = ngx_quic_get_connection(c);

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

  386.     com = qc->compat;
  387.     com->method = quic_method;

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

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

  400.     SSL_set_bio(ssl, rbio, wbio);

  402.     SSL_set_msg_callback(ssl, ngx_quic_compat_message_callback);

  404.     /* early data is not supported */
  405.     SSL_set_max_early_data(ssl, 0);

  407.     return 1;
  408. }


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

  421.     if (!write_p) {
  422.         return;
  423.     }

  425.     c = ngx_ssl_get_connection(ssl);
  426.     qc = ngx_quic_get_connection(c);

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

  433.     com = qc->compat;
  434.     level = com->write_level;

  436.     switch (content_type) {

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

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

  446.         break;

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

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

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

  461.         break;
  462.     }

  464.     return;
  465. }


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

  485.     c = ngx_ssl_get_connection(ssl);

  487.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  488.                    "quic compat rx level:%d len:%uz", level, len);

  490.     qc = ngx_quic_get_connection(c);
  491.     com = qc->compat;
  492.     rbio = SSL_get_rbio(ssl);

  494.     while (len) {
  495.         ngx_memzero(&rec, sizeof(ngx_quic_compat_record_t));

  497.         rec.type = SSL3_RT_HANDSHAKE;
  498.         rec.log = c->log;
  499.         rec.number = com->read_record++;
  500.         rec.keys = &com->keys;

  502.         if (level == ssl_encryption_initial) {
  503.             n = ngx_min(len, 65535);

  505.             rec.payload.len = n;
  506.             rec.payload.data = (u_char *) data;

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

  510.             BIO_write(rbio, out, SSL3_RT_HEADER_LENGTH);
  511.             BIO_write(rbio, data, n);

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

  520.         } else {
  521.             n = ngx_min(len, NGX_QUIC_COMPAT_RECORD_SIZE);

  523.             p = ngx_cpymem(in, data, n);
  524.             *p++ = SSL3_RT_HANDSHAKE;

  526.             rec.payload.len = p - in;
  527.             rec.payload.data = in;

  529.             res.data = out;

  531.             if (ngx_quic_compat_create_record(&rec, &res) != NGX_OK) {
  532.                 return 0;
  533.             }

  535. #if defined(NGX_QUIC_DEBUG_CRYPTO) && defined(NGX_QUIC_DEBUG_PACKETS)
  536.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  537.                            "quic compat record len:%uz %xV", res.len, &res);
  538. #endif

  540.             BIO_write(rbio, res.data, res.len);
  541.         }

  543.         data += n;
  544.         len -= n;
  545.     }

  547.     return 1;
  548. }


  551. static size_t
  552. ‌ngx_quic_compat_create_header(ngx_quic_compat_record_t *rec, u_char *out,
  553.     ngx_uint_t plain)
  554. {
  555.     u_char  type;
  556.     size_t  len;

  558.     len = rec->payload.len;

  560.     if (plain) {
  561.         type = rec->type;

  563.     } else {
  564.         type = SSL3_RT_APPLICATION_DATA;
  565.         len += NGX_QUIC_TAG_LEN;
  566.     }

  568.     out[0] = type;
  569.     out[1] = 0x03;
  570.     out[2] = 0x03;
  571.     out[3] = (len >> 8);
  572.     out[4] = len;

  574.     return 5;
  575. }


  578. static ngx_int_t
  579. ‌ngx_quic_compat_create_record(ngx_quic_compat_record_t *rec, ngx_str_t *res)
  580. {
  581.     ngx_str_t           ad, out;
  582.     ngx_quic_secret_t  *secret;
  583.     u_char              nonce[NGX_QUIC_IV_LEN];

  585.     ad.data = res->data;
  586.     ad.len = ngx_quic_compat_create_header(rec, ad.data, 0);

  588.     out.len = rec->payload.len + NGX_QUIC_TAG_LEN;
  589.     out.data = res->data + ad.len;

  591. #ifdef NGX_QUIC_DEBUG_CRYPTO
  592.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, rec->log, 0,
  593.                    "quic compat ad len:%uz %xV", ad.len, &ad);
  594. #endif

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

  598.     if (secret->ctx == NULL) {
  599.         return NGX_ERROR;
  600.     }

  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