One Level Up Top Level

src/event/quic/ngx_event_quic_openssl_compat.c - nginx-1.31.7 nginx/ @ 939334eff

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. void
  74. ‌ngx_quic_compat_keylog_init(SSL_CTX *ctx)
  75. {
  76.     SSL_CTX_set_keylog_callback(ctx, ngx_quic_compat_keylog_callback);
  77. }


  80. ngx_int_t
  81. ‌ngx_quic_compat_ext_init(ngx_conf_t *cf, SSL_CTX *ctx)
  82. {
  83.     if (SSL_CTX_has_client_custom_ext(ctx, NGX_QUIC_COMPAT_SSL_TP_EXT)) {
  84.         return NGX_OK;
  85.     }

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

  102.     return NGX_OK;
  103. }


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

  119.     c = ngx_ssl_get_connection(ssl);
  120.     if (c->type != SOCK_DGRAM) {
  121.         return;
  122.     }

  124.     p = (u_char *) line;

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

  128.     n = p - start;

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

  133.     if (n == sizeof(NGX_QUIC_COMPAT_CLIENT_HANDSHAKE) - 1
  134.         && ngx_strncmp(start, NGX_QUIC_COMPAT_CLIENT_HANDSHAKE, n) == 0)
  135.     {
  136.         level = ssl_encryption_handshake;
  137.         write = 0;

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

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

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

  159.     } else {
  160.         return;
  161.     }

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

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

  169.     if (*p++ == '\0') {
  170.         return;
  171.     }

  173.     for (n = 0, start = p; *p; p++) {
  174.         ch = *p;

  176.         if (ch >= '0' && ch <= '9') {
  177.             value = ch - '0';
  178.             goto next;
  179.         }

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

  183.         if (ch >= 'a' && ch <= 'f') {
  184.             value = ch - 'a' + 10;
  185.             goto next;
  186.         }

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

  191.         return;

  193.     next:

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

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

  205.             secret[n] = (value << 4);
  206.         }
  207.     }

  209.     qc = ngx_quic_get_connection(c);
  210.     com = qc->compat;
  211.     cipher = SSL_get_current_cipher(ssl);

  213.     if (write) {
  214.         com->method->set_write_secret((SSL *) ssl, level, cipher, secret, n);
  215.         com->write_level = level;

  217.     } else {
  218.         com->method->set_read_secret((SSL *) ssl, level, cipher, secret, n);
  219.         com->read_record = 0;

  221.         if (ngx_quic_compat_set_encryption_secret(c, &com->keys, level,
  222.                                                   cipher, secret, n)
  223.             != NGX_OK)
  224.         {
  225.             qc->error = NGX_QUIC_ERR_INTERNAL_ERROR;
  226.         }
  227.     }

  229.     ngx_explicit_memzero(secret, n);
  230. }


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

  247.     peer_secret = &keys->secret;

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

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

  253.     if (key_len == NGX_ERROR) {
  254.         ngx_ssl_error(NGX_LOG_INFO, c->log, 0, "unexpected cipher");
  255.         return NGX_ERROR;
  256.     }

  258.     key.len = key_len;

  260.     peer_secret->iv.len = NGX_QUIC_IV_LEN;

  262.     secret_str.len = secret_len;
  263.     secret_str.data = (u_char *) secret;

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

  268.     for (i = 0; i < (sizeof(seq) / sizeof(seq[0])); i++) {
  269.         if (ngx_quic_hkdf_expand(&seq[i], ciphers.d, c->log) != NGX_OK) {
  270.             return NGX_ERROR;
  271.         }
  272.     }

  274.     /* register cleanup handler once */

  276.     if (peer_secret->ctx) {
  277.         ngx_quic_crypto_cleanup(peer_secret);

  279.     } else {
  280.         cln = ngx_pool_cleanup_add(c->pool, 0);
  281.         if (cln == NULL) {
  282.             return NGX_ERROR;
  283.         }

  285.         cln->handler = ngx_quic_compat_cleanup_encryption_secret;
  286.         cln->data = peer_secret;
  287.     }

  289.     if (ngx_quic_crypto_init(ciphers.c, peer_secret, &key, 1, c->log)
  290.         == NGX_ERROR)
  291.     {
  292.         return NGX_ERROR;
  293.     }

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

  297.     return NGX_OK;
  298. }


  301. static void
  302. ‌ngx_quic_compat_cleanup_encryption_secret(void *data)
  303. {
  304.     ngx_quic_secret_t *secret = data;

  306.     ngx_quic_crypto_cleanup(secret);
  307. }


  310. static int
  311. ‌ngx_quic_compat_add_transport_params_callback(SSL *ssl, unsigned int ext_type,
  312.     unsigned int context, const unsigned char **out, size_t *outlen, X509 *x,
  313.     size_t chainidx, int *al, void *add_arg)
  314. {
  315.     ngx_connection_t       *c;
  316.     ngx_quic_compat_t      *com;
  317.     ngx_quic_connection_t  *qc;

  319.     c = ngx_ssl_get_connection(ssl);
  320.     if (c->type != SOCK_DGRAM) {
  321.         return 0;
  322.     }

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

  327.     qc = ngx_quic_get_connection(c);
  328.     com = qc->compat;

  330.     *out = com->tp.data;
  331.     *outlen = com->tp.len;

  333.     return 1;
  334. }


  337. static int
  338. ‌ngx_quic_compat_parse_transport_params_callback(SSL *ssl, unsigned int ext_type,
  339.     unsigned int context, const unsigned char *in, size_t inlen, X509 *x,
  340.     size_t chainidx, int *al, void *parse_arg)
  341. {
  342.     u_char                 *p;
  343.     ngx_connection_t       *c;
  344.     ngx_quic_compat_t      *com;
  345.     ngx_quic_connection_t  *qc;

  347.     c = ngx_ssl_get_connection(ssl);
  348.     if (c->type != SOCK_DGRAM) {
  349.         return 1;
  350.     }

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

  355.     qc = ngx_quic_get_connection(c);
  356.     com = qc->compat;

  358.     p = ngx_pnalloc(c->pool, inlen);
  359.     if (p == NULL) {
  360.         return 0;
  361.     }

  363.     ngx_memcpy(p, in, inlen);

  365.     com->ctp.data = p;
  366.     com->ctp.len = inlen;

  368.     return 1;
  369. }


  372. int
  373. ‌SSL_set_quic_method(SSL *ssl, const SSL_QUIC_METHOD *quic_method)
  374. {
  375.     BIO                    *rbio, *wbio;
  376.     ngx_connection_t       *c;
  377.     ngx_quic_compat_t      *com;
  378.     ngx_quic_connection_t  *qc;

  380.     c = ngx_ssl_get_connection(ssl);

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

  384.     qc = ngx_quic_get_connection(c);

  386.     qc->compat = ngx_pcalloc(c->pool, sizeof(ngx_quic_compat_t));
  387.     if (qc->compat == NULL) {
  388.         return 0;
  389.     }

  391.     com = qc->compat;
  392.     com->method = quic_method;

  394.     rbio = BIO_new(BIO_s_mem());
  395.     if (rbio == NULL) {
  396.         return 0;
  397.     }

  399.     wbio = BIO_new(BIO_s_null());
  400.     if (wbio == NULL) {
  401.         BIO_free(rbio);
  402.         return 0;
  403.     }

  405.     SSL_set_bio(ssl, rbio, wbio);

  407.     SSL_set_msg_callback(ssl, ngx_quic_compat_message_callback);

  409.     /* early data is not supported */
  410.     SSL_set_max_early_data(ssl, 0);

  412.     return 1;
  413. }


  416. static void
  417. ‌ngx_quic_compat_message_callback(int write_p, int version, int content_type,
  418.     const void *buf, size_t len, SSL *ssl, void *arg)
  419. {
  420.     ngx_uint_t                    alert;
  421.     ngx_connection_t             *c;
  422.     ngx_quic_compat_t            *com;
  423.     ngx_quic_connection_t        *qc;
  424.     enum ssl_encryption_level_t   level;

  426.     if (!write_p) {
  427.         return;
  428.     }

  430.     c = ngx_ssl_get_connection(ssl);
  431.     qc = ngx_quic_get_connection(c);

  433.     if (qc == NULL) {
  434.         /* closing */
  435.         return;
  436.     }

  438.     com = qc->compat;
  439.     level = com->write_level;

  441.     switch (content_type) {

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

  447.         if (com->method->add_handshake_data(ssl, level, buf, len) != 1) {
  448.             return;
  449.         }

  451.         break;

  453.     case SSL3_RT_ALERT:
  454.         if (len >= 2) {
  455.             alert = ((u_char *) buf)[1];

  457.             ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  458.                            "quic compat level:%d alert:%ui len:%uz",
  459.                            level, alert, len);

  461.             if (com->method->send_alert(ssl, level, alert) != 1) {
  462.                 return;
  463.             }
  464.         }

  466.         break;
  467.     }

  469.     return;
  470. }


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

  490.     c = ngx_ssl_get_connection(ssl);

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

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

  499.     while (len) {
  500.         ngx_memzero(&rec, sizeof(ngx_quic_compat_record_t));

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

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

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

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

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

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

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

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

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

  534.             res.data = out;

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

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

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

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

  552.     return 1;
  553. }


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

  563.     len = rec->payload.len;

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

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

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

  579.     return 5;
  580. }


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

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

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

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

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

  603.     if (secret->ctx == NULL) {
  604.         return NGX_ERROR;
  605.     }

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

  610.     if (ngx_quic_crypto_seal(secret, &out, nonce, &rec->payload, &ad, rec->log)
  611.         != NGX_OK)
  612.     {
  613.         return NGX_ERROR;
  614.     }

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

  618.     return NGX_OK;
  619. }


  622. int
  623. ‌SSL_set_quic_transport_params(SSL *ssl, const uint8_t *params,
  624.     size_t params_len)
  625. {
  626.     ngx_connection_t       *c;
  627.     ngx_quic_compat_t      *com;
  628.     ngx_quic_connection_t  *qc;

  630.     c = ngx_ssl_get_connection(ssl);
  631.     qc = ngx_quic_get_connection(c);
  632.     com = qc->compat;

  634.     com->tp.len = params_len;
  635.     com->tp.data = (u_char *) params;

  637.     return 1;
  638. }


  641. void
  642. ‌SSL_get_peer_quic_transport_params(const SSL *ssl, const uint8_t **out_params,
  643.     size_t *out_params_len)
  644. {
  645.     ngx_connection_t       *c;
  646.     ngx_quic_compat_t      *com;
  647.     ngx_quic_connection_t  *qc;

  649.     c = ngx_ssl_get_connection(ssl);
  650.     qc = ngx_quic_get_connection(c);
  651.     com = qc->compat;

  653.     *out_params = com->ctp.data;
  654.     *out_params_len = com->ctp.len;
  655. }

  657. #endif /* NGX_QUIC_OPENSSL_COMPAT */

One Level Up Top Level