One Level Up Top Level

src/event/quic/ngx_event_quic_tokens.c - nginx-1.31.3 nginx/ @ 42f8df65b

Functions 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. ngx_int_t
  14. ‌ngx_quic_new_sr_token(ngx_connection_t *c, ngx_str_t *cid, u_char *secret,
  15.     u_char *token)
  16. {
  17.     ngx_str_t  tmp;
  18.     u_char     buf[NGX_QUIC_SR_KEY_LEN + sizeof(ngx_uint_t)];

  20.     ngx_memcpy(buf, secret, NGX_QUIC_SR_KEY_LEN);
  21.     ngx_memcpy(buf + NGX_QUIC_SR_KEY_LEN, &ngx_worker, sizeof(ngx_uint_t));

  23.     tmp.data = buf;
  24.     tmp.len = sizeof(buf);

  26.     if (ngx_quic_derive_key(c->log, "sr_token_key", &tmp, cid, token,
  27.                             NGX_QUIC_SR_TOKEN_LEN)
  28.         != NGX_OK)
  29.     {
  30.         return NGX_ERROR;
  31.     }

  33.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  34.                    "quic stateless reset token %*xs",
  35.                     (size_t) NGX_QUIC_SR_TOKEN_LEN, token);

  37.     return NGX_OK;
  38. }


  41. ngx_int_t
  42. ‌ngx_quic_new_token(ngx_log_t *log, struct sockaddr *sockaddr,
  43.     socklen_t socklen, u_char *key, ngx_str_t *token, ngx_str_t *odcid,
  44.     time_t exp, ngx_uint_t is_retry)
  45. {
  46.     int                len, iv_len;
  47.     u_char            *p, *iv;
  48.     EVP_CIPHER_CTX    *ctx;
  49.     const EVP_CIPHER  *cipher;

  51.     u_char             in[NGX_QUIC_MAX_TOKEN_SIZE];

  53.     ngx_quic_address_hash(sockaddr, socklen, !is_retry, NULL, 0, in);

  55.     p = in + 20;

  57.     p = ngx_cpymem(p, &exp, sizeof(time_t));

  59.     *p++ = is_retry ? 1 : 0;

  61.     if (odcid) {
  62.         *p++ = odcid->len;
  63.         p = ngx_cpymem(p, odcid->data, odcid->len);

  65.     } else {
  66.         *p++ = 0;
  67.     }

  69.     len = p - in;

  71.     cipher = EVP_aes_256_gcm();
  72.     iv_len = NGX_QUIC_AES_256_GCM_IV_LEN;

  74.     if ((size_t) (iv_len + len + NGX_QUIC_AES_256_GCM_TAG_LEN) > token->len) {
  75.         ngx_log_error(NGX_LOG_ALERT, log, 0, "quic token buffer is too small");
  76.         return NGX_ERROR;
  77.     }

  79.     ctx = EVP_CIPHER_CTX_new();
  80.     if (ctx == NULL) {
  81.         return NGX_ERROR;
  82.     }

  84.     iv = token->data;

  86.     if (RAND_bytes(iv, iv_len) <= 0
  87.         || !EVP_EncryptInit_ex(ctx, cipher, NULL, key, iv))
  88.     {
  89.         EVP_CIPHER_CTX_free(ctx);
  90.         return NGX_ERROR;
  91.     }

  93.     token->len = iv_len;

  95.     if (EVP_EncryptUpdate(ctx, token->data + token->len, &len, in, len) != 1) {
  96.         EVP_CIPHER_CTX_free(ctx);
  97.         return NGX_ERROR;
  98.     }

  100.     token->len += len;

  102.     if (EVP_EncryptFinal_ex(ctx, token->data + token->len, &len) <= 0) {
  103.         EVP_CIPHER_CTX_free(ctx);
  104.         return NGX_ERROR;
  105.     }

  107.     token->len += len;

  109.     if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
  110.                             NGX_QUIC_AES_256_GCM_TAG_LEN,
  111.                             token->data + token->len)
  112.         == 0)
  113.     {
  114.         EVP_CIPHER_CTX_free(ctx);
  115.         return NGX_ERROR;
  116.     }

  118.     token->len += NGX_QUIC_AES_256_GCM_TAG_LEN;

  120.     EVP_CIPHER_CTX_free(ctx);

  122. #ifdef NGX_QUIC_DEBUG_PACKETS
  123.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0,
  124.                    "quic new token len:%uz %xV", token->len, token);
  125. #endif

  127.     return NGX_OK;
  128. }


  131. ngx_int_t
  132. ‌ngx_quic_validate_token(ngx_connection_t *c, u_char *key,
  133.     ngx_quic_header_t *pkt)
  134. {
  135.     int                len, tlen, iv_len;
  136.     u_char            *iv, *p;
  137.     time_t             now, exp;
  138.     size_t             total;
  139.     ngx_str_t          odcid;
  140.     EVP_CIPHER_CTX    *ctx;
  141.     const EVP_CIPHER  *cipher;

  143.     u_char             addr_hash[20];
  144.     u_char             tdec[NGX_QUIC_MAX_TOKEN_SIZE];

  146. #if NGX_SUPPRESS_WARN
  147.     ngx_str_null(&odcid);
  148. #endif

  150.     /* Retry token or NEW_TOKEN in a previous connection */

  152.     cipher = EVP_aes_256_gcm();
  153.     iv = pkt->token.data;
  154.     iv_len = NGX_QUIC_AES_256_GCM_IV_LEN;

  156.     /* sanity checks */

  158.     if (pkt->token.len < (size_t) iv_len + NGX_QUIC_AES_256_GCM_TAG_LEN) {
  159.         goto garbage;
  160.     }

  162.     if (pkt->token.len > (size_t) iv_len + NGX_QUIC_MAX_TOKEN_SIZE
  163.                          + NGX_QUIC_AES_256_GCM_TAG_LEN)
  164.     {
  165.         goto garbage;
  166.     }

  168.     ctx = EVP_CIPHER_CTX_new();
  169.     if (ctx == NULL) {
  170.         return NGX_ERROR;
  171.     }

  173.     if (!EVP_DecryptInit_ex(ctx, cipher, NULL, key, iv)) {
  174.         EVP_CIPHER_CTX_free(ctx);
  175.         return NGX_ERROR;
  176.     }

  178.     p = pkt->token.data + iv_len;
  179.     len = pkt->token.len - iv_len - NGX_QUIC_AES_256_GCM_TAG_LEN;

  181.     if (EVP_DecryptUpdate(ctx, tdec, &tlen, p, len) != 1) {
  182.         EVP_CIPHER_CTX_free(ctx);
  183.         goto garbage;
  184.     }
  185.     total = tlen;

  187.     if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
  188.                             NGX_QUIC_AES_256_GCM_TAG_LEN, p + len)
  189.         == 0)
  190.     {
  191.         EVP_CIPHER_CTX_free(ctx);
  192.         goto garbage;
  193.     }

  195.     if (EVP_DecryptFinal_ex(ctx, tdec + tlen, &tlen) <= 0) {
  196.         EVP_CIPHER_CTX_free(ctx);
  197.         goto garbage;
  198.     }
  199.     total += tlen;

  201.     EVP_CIPHER_CTX_free(ctx);

  203.     if (total < (20 + sizeof(time_t) + 2)) {
  204.         goto garbage;
  205.     }

  207.     p = tdec + 20;

  209.     ngx_memcpy(&exp, p, sizeof(time_t));
  210.     p += sizeof(time_t);

  212.     pkt->retried = (*p++ == 1);

  214.     ngx_quic_address_hash(c->sockaddr, c->socklen, !pkt->retried, NULL, 0,
  215.                           addr_hash);

  217.     if (ngx_memcmp(tdec, addr_hash, 20) != 0) {
  218.         goto bad_token;
  219.     }

  221.     odcid.len = *p++;
  222.     if (odcid.len) {
  223.         if (odcid.len > NGX_QUIC_MAX_CID_LEN) {
  224.             goto bad_token;
  225.         }

  227.         if ((size_t)(tdec + total - p) < odcid.len) {
  228.             goto bad_token;
  229.         }

  231.         odcid.data = p;
  232.     }

  234.     now = ngx_time();

  236.     if (now > exp) {
  237.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "quic expired token");
  238.         return NGX_DECLINED;
  239.     }

  241.     if (odcid.len) {
  242.         pkt->odcid.len = odcid.len;
  243.         pkt->odcid.data = pkt->odcid_buf;
  244.         ngx_memcpy(pkt->odcid.data, odcid.data, odcid.len);

  246.     } else {
  247.         pkt->odcid = pkt->dcid;
  248.     }

  250.     pkt->validated = 1;

  252.     return NGX_OK;

  254. garbage:

  256.     ngx_log_error(NGX_LOG_INFO, c->log, 0, "quic garbage token");

  258.     return NGX_ABORT;

  260. bad_token:

  262.     ngx_log_error(NGX_LOG_INFO, c->log, 0, "quic invalid token");

  264.     return NGX_DECLINED;
  265. }

One Level Up Top Level