One Level Up Top Level

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

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


  14. static void ngx_quic_address_hash(struct sockaddr *sockaddr, socklen_t socklen,
  15.     ngx_uint_t no_port, u_char buf[20]);


  18. ngx_int_t
  19. ‌ngx_quic_new_sr_token(ngx_connection_t *c, ngx_str_t *cid, u_char *secret,
  20.     u_char *token)
  21. {
  22.     ngx_str_t  tmp;

  24.     tmp.data = secret;
  25.     tmp.len = NGX_QUIC_SR_KEY_LEN;

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

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

  38.     return NGX_OK;
  39. }


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

  52.     u_char             in[NGX_QUIC_MAX_TOKEN_SIZE];

  54.     ngx_quic_address_hash(sockaddr, socklen, !is_retry, in);

  56.     p = in + 20;

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

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

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

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

  70.     len = p - in;

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

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

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

  85.     iv = token->data;

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

  94.     token->len = iv_len;

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

  101.     token->len += len;

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

  108.     token->len += len;

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

  119.     token->len += NGX_QUIC_AES_256_GCM_TAG_LEN;

  121.     EVP_CIPHER_CTX_free(ctx);

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

  128.     return NGX_OK;
  129. }


  132. static void
  133. ‌ngx_quic_address_hash(struct sockaddr *sockaddr, socklen_t socklen,
  134.     ngx_uint_t no_port, u_char buf[20])
  135. {
  136.     size_t                len;
  137.     u_char               *data;
  138.     ngx_sha1_t            sha1;
  139.     struct sockaddr_in   *sin;
  140. #if (NGX_HAVE_INET6)
  141.     struct sockaddr_in6  *sin6;
  142. #endif

  144.     len = (size_t) socklen;
  145.     data = (u_char *) sockaddr;

  147.     if (no_port) {
  148.         switch (sockaddr->sa_family) {

  150. #if (NGX_HAVE_INET6)
  151.         case AF_INET6:
  152.             sin6 = (struct sockaddr_in6 *) sockaddr;

  154.             len = sizeof(struct in6_addr);
  155.             data = sin6->sin6_addr.s6_addr;

  157.             break;
  158. #endif

  160.         case AF_INET:
  161.             sin = (struct sockaddr_in *) sockaddr;

  163.             len = sizeof(in_addr_t);
  164.             data = (u_char *) &sin->sin_addr;

  166.             break;
  167.         }
  168.     }

  170.     ngx_sha1_init(&sha1);
  171.     ngx_sha1_update(&sha1, data, len);
  172.     ngx_sha1_final(buf, &sha1);
  173. }


  176. ngx_int_t
  177. ‌ngx_quic_validate_token(ngx_connection_t *c, u_char *key,
  178.     ngx_quic_header_t *pkt)
  179. {
  180.     int                len, tlen, iv_len;
  181.     u_char            *iv, *p;
  182.     time_t             now, exp;
  183.     size_t             total;
  184.     ngx_str_t          odcid;
  185.     EVP_CIPHER_CTX    *ctx;
  186.     const EVP_CIPHER  *cipher;

  188.     u_char             addr_hash[20];
  189.     u_char             tdec[NGX_QUIC_MAX_TOKEN_SIZE];

  191. #if NGX_SUPPRESS_WARN
  192.     ngx_str_null(&odcid);
  193. #endif

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

  197.     cipher = EVP_aes_256_gcm();
  198.     iv = pkt->token.data;
  199.     iv_len = NGX_QUIC_AES_256_GCM_IV_LEN;

  201.     /* sanity checks */

  203.     if (pkt->token.len < (size_t) iv_len + NGX_QUIC_AES_256_GCM_TAG_LEN) {
  204.         goto garbage;
  205.     }

  207.     if (pkt->token.len > (size_t) iv_len + NGX_QUIC_MAX_TOKEN_SIZE
  208.                          + NGX_QUIC_AES_256_GCM_TAG_LEN)
  209.     {
  210.         goto garbage;
  211.     }

  213.     ctx = EVP_CIPHER_CTX_new();
  214.     if (ctx == NULL) {
  215.         return NGX_ERROR;
  216.     }

  218.     if (!EVP_DecryptInit_ex(ctx, cipher, NULL, key, iv)) {
  219.         EVP_CIPHER_CTX_free(ctx);
  220.         return NGX_ERROR;
  221.     }

  223.     p = pkt->token.data + iv_len;
  224.     len = pkt->token.len - iv_len - NGX_QUIC_AES_256_GCM_TAG_LEN;

  226.     if (EVP_DecryptUpdate(ctx, tdec, &tlen, p, len) != 1) {
  227.         EVP_CIPHER_CTX_free(ctx);
  228.         goto garbage;
  229.     }
  230.     total = tlen;

  232.     if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
  233.                             NGX_QUIC_AES_256_GCM_TAG_LEN, p + len)
  234.         == 0)
  235.     {
  236.         EVP_CIPHER_CTX_free(ctx);
  237.         goto garbage;
  238.     }

  240.     if (EVP_DecryptFinal_ex(ctx, tdec + tlen, &tlen) <= 0) {
  241.         EVP_CIPHER_CTX_free(ctx);
  242.         goto garbage;
  243.     }
  244.     total += tlen;

  246.     EVP_CIPHER_CTX_free(ctx);

  248.     if (total < (20 + sizeof(time_t) + 2)) {
  249.         goto garbage;
  250.     }

  252.     p = tdec + 20;

  254.     ngx_memcpy(&exp, p, sizeof(time_t));
  255.     p += sizeof(time_t);

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

  259.     ngx_quic_address_hash(c->sockaddr, c->socklen, !pkt->retried, addr_hash);

  261.     if (ngx_memcmp(tdec, addr_hash, 20) != 0) {
  262.         goto bad_token;
  263.     }

  265.     odcid.len = *p++;
  266.     if (odcid.len) {
  267.         if (odcid.len > NGX_QUIC_MAX_CID_LEN) {
  268.             goto bad_token;
  269.         }

  271.         if ((size_t)(tdec + total - p) < odcid.len) {
  272.             goto bad_token;
  273.         }

  275.         odcid.data = p;
  276.     }

  278.     now = ngx_time();

  280.     if (now > exp) {
  281.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "quic expired token");
  282.         return NGX_DECLINED;
  283.     }

  285.     if (odcid.len) {
  286.         pkt->odcid.len = odcid.len;
  287.         pkt->odcid.data = pkt->odcid_buf;
  288.         ngx_memcpy(pkt->odcid.data, odcid.data, odcid.len);

  290.     } else {
  291.         pkt->odcid = pkt->dcid;
  292.     }

  294.     pkt->validated = 1;

  296.     return NGX_OK;

  298. garbage:

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

  302.     return NGX_ABORT;

  304. bad_token:

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

  308.     return NGX_DECLINED;
  309. }

One Level Up Top Level