ssl/quic/quic_port.c

   1 /*
   2  * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include "internal/quic_port.h"
  11 #include "internal/quic_channel.h"
  12 #include "internal/quic_lcidm.h"
  13 #include "internal/quic_srtm.h"
  14 #include "quic_port_local.h"
  15 #include "quic_channel_local.h"
  16 #include "../ssl_local.h"
  17
  18 /*
  19  * QUIC Port Structure
  20  * ===================
  21  */
  22 #define INIT_DCID_LEN                   8
  23
  24 static int port_init(QUIC_PORT *port);
  25 static void port_cleanup(QUIC_PORT *port);
  26 static OSSL_TIME get_time(void *arg);
  27 static void port_tick(QUIC_TICK_RESULT *res, void *arg, uint32_t flags);
  28 static void port_default_packet_handler(QUIC_URXE *e, void *arg,
  29                                         const QUIC_CONN_ID *dcid);
  30 static void port_rx_pre(QUIC_PORT *port);
  31
  32 DEFINE_LIST_OF_IMPL(ch, QUIC_CHANNEL);
  33
  34 QUIC_PORT *ossl_quic_port_new(const QUIC_PORT_ARGS *args)
  35 {
  36     QUIC_PORT *port;
  37
  38     if ((port = OPENSSL_zalloc(sizeof(QUIC_PORT))) == NULL)
  39         return NULL;
  40
  41     port->libctx        = args->libctx;
  42     port->propq         = args->propq;
  43     port->mutex         = args->mutex;
  44     port->now_cb        = args->now_cb;
  45     port->now_cb_arg    = args->now_cb_arg;
  46     port->channel_ctx   = args->channel_ctx;
  47     port->is_multi_conn = args->is_multi_conn;
  48
  49     if (!port_init(port)) {
  50         OPENSSL_free(port);
  51         return NULL;
  52     }
  53
  54     return port;
  55 }
  56
  57 void ossl_quic_port_free(QUIC_PORT *port)
  58 {
  59     if (port == NULL)
  60         return;
  61
  62     port_cleanup(port);
  63     OPENSSL_free(port);
  64 }
  65
  66 static int port_init(QUIC_PORT *port)
  67 {
  68     size_t rx_short_dcid_len = (port->is_multi_conn ? INIT_DCID_LEN : 0);
  69
  70     if (port->channel_ctx == NULL)
  71         goto err;
  72
  73     if ((port->demux = ossl_quic_demux_new(/*BIO=*/NULL,
  74                                            /*Short CID Len=*/rx_short_dcid_len,
  75                                            get_time, port)) == NULL)
  76         goto err;
  77
  78     /*
  79      * If we are a server, setup our handler for packets not corresponding to
  80      * any known DCID on our end. This is for handling clients establishing new
  81      * connections.
  82      */
  83     // if (is_server)
  84     ossl_quic_demux_set_default_handler(port->demux,
  85                                         port_default_packet_handler,
  86                                         port);
  87
  88     if ((port->srtm = ossl_quic_srtm_new(port->libctx, port->propq)) == NULL)
  89         goto err;
  90
  91     if ((port->lcidm = ossl_quic_lcidm_new(port->libctx, rx_short_dcid_len)) == NULL)
  92         goto err;
  93
  94     ossl_quic_reactor_init(&port->rtor, port_tick, port, ossl_time_zero());
  95     port->rx_short_dcid_len = (unsigned char)rx_short_dcid_len;
  96     port->tx_init_dcid_len  = INIT_DCID_LEN;
  97     return 1;
  98
  99 err:
 100     port_cleanup(port);
 101     return 0;
 102 }
 103
 104 static void port_cleanup(QUIC_PORT *port)
 105 {
 106     assert(ossl_list_ch_num(&port->channel_list) == 0);
 107
 108     ossl_quic_demux_free(port->demux);
 109     port->demux = NULL;
 110
 111     ossl_quic_srtm_free(port->srtm);
 112     port->srtm = NULL;
 113
 114     ossl_quic_lcidm_free(port->lcidm);
 115     port->lcidm = NULL;
 116 }
 117
 118 QUIC_REACTOR *ossl_quic_port_get0_reactor(QUIC_PORT *port)
 119 {
 120     return &port->rtor;
 121 }
 122
 123 QUIC_DEMUX *ossl_quic_port_get0_demux(QUIC_PORT *port)
 124 {
 125     return port->demux;
 126 }
 127
 128 CRYPTO_MUTEX *ossl_quic_port_get0_mutex(QUIC_PORT *port)
 129 {
 130     return port->mutex;
 131 }
 132
 133 OSSL_TIME ossl_quic_port_get_time(QUIC_PORT *port)
 134 {
 135     if (port->now_cb == NULL)
 136         return ossl_time_now();
 137
 138     return port->now_cb(port->now_cb_arg);
 139 }
 140
 141 static OSSL_TIME get_time(void *port)
 142 {
 143     return ossl_quic_port_get_time(port);
 144 }
 145
 146 int ossl_quic_port_get_rx_short_dcid_len(const QUIC_PORT *port)
 147 {
 148     return port->rx_short_dcid_len;
 149 }
 150
 151 int ossl_quic_port_get_tx_init_dcid_len(const QUIC_PORT *port)
 152 {
 153     return port->tx_init_dcid_len;
 154 }
 155
 156 /*
 157  * QUIC Port: Network BIO Configuration
 158  * ====================================
 159  */
 160
 161 /* Determines whether we can support a given poll descriptor. */
 162 static int validate_poll_descriptor(const BIO_POLL_DESCRIPTOR *d)
 163 {
 164     if (d->type == BIO_POLL_DESCRIPTOR_TYPE_SOCK_FD && d->value.fd < 0) {
 165         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
 166         return 0;
 167     }
 168
 169     return 1;
 170 }
 171
 172 BIO *ossl_quic_port_get_net_rbio(QUIC_PORT *port)
 173 {
 174     return port->net_rbio;
 175 }
 176
 177 BIO *ossl_quic_port_get_net_wbio(QUIC_PORT *port)
 178 {
 179     return port->net_wbio;
 180 }
 181
 182 static int port_update_poll_desc(QUIC_PORT *port, BIO *net_bio, int for_write)
 183 {
 184     BIO_POLL_DESCRIPTOR d = {0};
 185
 186     if (net_bio == NULL
 187         || (!for_write && !BIO_get_rpoll_descriptor(net_bio, &d))
 188         || (for_write && !BIO_get_wpoll_descriptor(net_bio, &d)))
 189         /* Non-pollable BIO */
 190         d.type = BIO_POLL_DESCRIPTOR_TYPE_NONE;
 191
 192     if (!validate_poll_descriptor(&d))
 193         return 0;
 194
 195     if (for_write)
 196         ossl_quic_reactor_set_poll_w(&port->rtor, &d);
 197     else
 198         ossl_quic_reactor_set_poll_r(&port->rtor, &d);
 199
 200     return 1;
 201 }
 202
 203 int ossl_quic_port_update_poll_descriptors(QUIC_PORT *port)
 204 {
 205     int ok = 1;
 206
 207     if (!port_update_poll_desc(port, port->net_rbio, /*for_write=*/0))
 208         ok = 0;
 209
 210     if (!port_update_poll_desc(port, port->net_wbio, /*for_write=*/1))
 211         ok = 0;
 212
 213     return ok;
 214 }
 215
 216 /*
 217  * QUIC_PORT does not ref any BIO it is provided with, nor is any ref
 218  * transferred to it. The caller (e.g., QUIC_CONNECTION) is responsible for
 219  * ensuring the BIO lasts until the channel is freed or the BIO is switched out
 220  * for another BIO by a subsequent successful call to this function.
 221  */
 222 int ossl_quic_port_set_net_rbio(QUIC_PORT *port, BIO *net_rbio)
 223 {
 224     if (port->net_rbio == net_rbio)
 225         return 1;
 226
 227     if (!port_update_poll_desc(port, net_rbio, /*for_write=*/0))
 228         return 0;
 229
 230     ossl_quic_demux_set_bio(port->demux, net_rbio);
 231     port->net_rbio = net_rbio;
 232     return 1;
 233 }
 234
 235 int ossl_quic_port_set_net_wbio(QUIC_PORT *port, BIO *net_wbio)
 236 {
 237     QUIC_CHANNEL *ch;
 238
 239     if (port->net_wbio == net_wbio)
 240         return 1;
 241
 242     if (!port_update_poll_desc(port, net_wbio, /*for_write=*/1))
 243         return 0;
 244
 245     LIST_FOREACH(ch, ch, &port->channel_list)
 246         ossl_qtx_set_bio(ch->qtx, net_wbio);
 247
 248     port->net_wbio = net_wbio;
 249     return 1;
 250 }
 251
 252 /*
 253  * QUIC Port: Channel Lifecycle
 254  * ============================
 255  */
 256
 257 static SSL *port_new_handshake_layer(QUIC_PORT *port)
 258 {
 259     SSL *tls = NULL;
 260     SSL_CONNECTION *tls_conn = NULL;
 261
 262     tls = ossl_ssl_connection_new_int(port->channel_ctx, TLS_method());
 263     if (tls == NULL || (tls_conn = SSL_CONNECTION_FROM_SSL(tls)) == NULL)
 264         return NULL;
 265
 266     /* Override the user_ssl of the inner connection. */
 267     tls_conn->s3.flags      |= TLS1_FLAGS_QUIC;
 268
 269     /* Restrict options derived from the SSL_CTX. */
 270     tls_conn->options       &= OSSL_QUIC_PERMITTED_OPTIONS_CONN;
 271     tls_conn->pha_enabled   = 0;
 272     return tls;
 273 }
 274
 275 static QUIC_CHANNEL *port_make_channel(QUIC_PORT *port, SSL *tls, int is_server)
 276 {
 277     QUIC_CHANNEL_ARGS args = {0};
 278     QUIC_CHANNEL *ch;
 279
 280     args.port       = port;
 281     args.is_server  = is_server;
 282     args.tls        = (tls != NULL ? tls : port_new_handshake_layer(port));
 283     if (args.tls == NULL)
 284         return NULL;
 285
 286     ch = ossl_quic_channel_new(&args);
 287     if (ch == NULL) {
 288         if (tls == NULL)
 289             SSL_free(args.tls);
 290
 291         return NULL;
 292     }
 293
 294     return ch;
 295 }
 296
 297 QUIC_CHANNEL *ossl_quic_port_create_outgoing(QUIC_PORT *port, SSL *tls)
 298 {
 299     return port_make_channel(port, tls, /*is_server=*/0);
 300 }
 301
 302 QUIC_CHANNEL *ossl_quic_port_create_incoming(QUIC_PORT *port, SSL *tls)
 303 {
 304     QUIC_CHANNEL *ch;
 305
 306     assert(port->tserver_ch == NULL);
 307
 308     ch = port_make_channel(port, tls, /*is_server=*/1);
 309     port->tserver_ch = ch;
 310     return ch;
 311 }
 312
 313 /*
 314  * QUIC Port: Ticker-Mutator
 315  * =========================
 316  */
 317
 318 /*
 319  * The central ticker function called by the reactor. This does everything, or
 320  * at least everything network I/O related. Best effort - not allowed to fail
 321  * "loudly".
 322  */
 323 static void port_tick(QUIC_TICK_RESULT *res, void *arg, uint32_t flags)
 324 {
 325     QUIC_PORT *port = arg;
 326     QUIC_CHANNEL *ch;
 327
 328     res->net_read_desired   = 0;
 329     res->net_write_desired  = 0;
 330     res->tick_deadline      = ossl_time_infinite();
 331
 332     if (!port->inhibit_tick) {
 333         /* Handle any incoming data from network. */
 334         port_rx_pre(port);
 335
 336         /* Iterate through all channels and service them. */
 337         LIST_FOREACH(ch, ch, &port->channel_list) {
 338             QUIC_TICK_RESULT subr = {0};
 339
 340             ossl_quic_channel_subtick(ch, &subr, flags);
 341             ossl_quic_tick_result_merge_into(res, &subr);
 342         }
 343     }
 344 }
 345
 346 /* Process incoming datagrams, if any. */
 347 static void port_rx_pre(QUIC_PORT *port)
 348 {
 349     int ret;
 350
 351     // TODO !have_sent_any_pkt
 352
 353     /*
 354      * Get DEMUX to BIO_recvmmsg from the network and queue incoming datagrams
 355      * to the appropriate QRX instances.
 356      */
 357     ret = ossl_quic_demux_pump(port->demux);
 358     // TODO: handle ret, stateless reset
 359
 360     if (ret == QUIC_DEMUX_PUMP_RES_PERMANENT_FAIL)
 361         /*
 362          * We don't care about transient failure, but permanent failure means we
 363          * should tear down the port. All connections skip straight to the
 364          * Terminated state as there is no point trying to send CONNECTION_CLOSE
 365          * frames if the network BIO is not operating correctly.
 366          */
 367         ossl_quic_port_raise_net_error(port);
 368 }
 369
 370 /*
 371  * Handles an incoming connection request and potentially decides to make a
 372  * connection from it. If a new connection is made, the new channel is written
 373  * to *new_ch.
 374  */
 375 static void port_on_new_conn(QUIC_PORT *port, const BIO_ADDR *peer,
 376                              const QUIC_CONN_ID *scid,
 377                              const QUIC_CONN_ID *dcid,
 378                              QUIC_CHANNEL **new_ch)
 379 {
 380     if (port->tserver_ch != NULL) {
 381         /* Specially assign to existing channel */
 382         if (!ossl_quic_channel_on_new_conn(port->tserver_ch, peer, scid, dcid))
 383             return;
 384
 385         *new_ch = port->tserver_ch;
 386         port->tserver_ch = NULL;
 387         return;
 388     }
 389 }
 390
 391 static int port_try_handle_stateless_reset(QUIC_PORT *port, const QUIC_URXE *e)
 392 {
 393     size_t i;
 394     const unsigned char *data = ossl_quic_urxe_data(e);
 395     void *opaque = NULL;
 396
 397     /*
 398      * Perform some fast and cheap checks for a packet not being a stateless
 399      * reset token.  RFC 9000 s. 10.3 specifies this layout for stateless
 400      * reset packets:
 401      *
 402      *  Stateless Reset {
 403      *      Fixed Bits (2) = 1,
 404      *      Unpredictable Bits (38..),
 405      *      Stateless Reset Token (128),
 406      *  }
 407      *
 408      * It also specifies:
 409      *      However, endpoints MUST treat any packet ending in a valid
 410      *      stateless reset token as a Stateless Reset, as other QUIC
 411      *      versions might allow the use of a long header.
 412      *
 413      * We can rapidly check for the minimum length and that the first pair
 414      * of bits in the first byte are 01 or 11.
 415      *
 416      * The function returns 1 if it is a stateless reset packet, 0 if it isn't
 417      * and -1 if an error was encountered.
 418      */
 419     if (e->data_len < QUIC_STATELESS_RESET_TOKEN_LEN + 5
 420         || (0100 & *data) != 0100)
 421         return 0;
 422
 423     for (i = 0;; ++i) {
 424         if (!ossl_quic_srtm_lookup(port->srtm,
 425                                    (QUIC_STATELESS_RESET_TOKEN *)(data + e->data_len
 426                                        - sizeof(QUIC_STATELESS_RESET_TOKEN)),
 427                                    i, &opaque, NULL))
 428             break;
 429
 430         assert(opaque != NULL);
 431         ossl_quic_channel_on_stateless_reset((QUIC_CHANNEL *)opaque);
 432     }
 433
 434     return i > 0;
 435 }
 436
 437 /*
 438  * This is called by the demux when we get a packet not destined for any known
 439  * DCID.
 440  */
 441 static void port_default_packet_handler(QUIC_URXE *e, void *arg,
 442                                         const QUIC_CONN_ID *dcid)
 443 {
 444     QUIC_PORT *port = arg;
 445     PACKET pkt;
 446     QUIC_PKT_HDR hdr;
 447     QUIC_CHANNEL *ch = NULL, *new_ch = NULL;
 448
 449     if (dcid != NULL
 450         && ossl_quic_lcidm_lookup(port->lcidm, dcid, NULL,
 451                                   (void **)&ch)) {
 452         assert(ch != NULL);
 453         ossl_quic_channel_inject(ch, e);
 454         return;
 455     }
 456
 457     if (port_try_handle_stateless_reset(port, e))
 458         goto undesirable;
 459
 460     // TODO review this
 461     if (port->tserver_ch == NULL)
 462         goto undesirable;
 463
 464     // TODO allow_incoming
 465     //if (!ossl_assert(ch->is_server))
 466     //    goto undesirable;
 467
 468     //TODO if (ch->state != QUIC_CHANNEL_STATE_IDLE)
 469     //    goto undesirable;
 470
 471     /*
 472      * We have got a packet for an unknown DCID. This might be an attempt to
 473      * open a new connection.
 474      */
 475     if (e->data_len < QUIC_MIN_INITIAL_DGRAM_LEN)
 476         goto undesirable;
 477
 478     if (!PACKET_buf_init(&pkt, ossl_quic_urxe_data(e), e->data_len))
 479         goto undesirable;
 480
 481     /*
 482      * We set short_conn_id_len to SIZE_MAX here which will cause the decode
 483      * operation to fail if we get a 1-RTT packet. This is fine since we only
 484      * care about Initial packets.
 485      */
 486     if (!ossl_quic_wire_decode_pkt_hdr(&pkt, SIZE_MAX, 1, 0, &hdr, NULL))
 487         goto undesirable;
 488
 489     switch (hdr.version) {
 490         case QUIC_VERSION_1:
 491             break;
 492
 493         case QUIC_VERSION_NONE:
 494         default:
 495             /* Unknown version or proactive version negotiation request, bail. */
 496             /* TODO(QUIC SERVER): Handle version negotiation on server side */
 497             goto undesirable;
 498     }
 499
 500     /*
 501      * We only care about Initial packets which might be trying to establish a
 502      * connection.
 503      */
 504     if (hdr.type != QUIC_PKT_TYPE_INITIAL)
 505         goto undesirable;
 506
 507     /*
 508      * Try to process this as a valid attempt to initiate a connection.
 509      *
 510      * We do not register the DCID in the Initial packet we received as
 511      * that DCID is not actually used again, thus after provisioning
 512      * the new connection and associated Initial keys, we inject the
 513      * received packet directly to the new channel's QRX so that it can
 514      * process it as a one-time thing, instead of going through the usual
 515      * DEMUX DCID-based routing.
 516      */
 517     port_on_new_conn(port, &e->peer, &hdr.src_conn_id, &hdr.dst_conn_id,
 518                      &new_ch);
 519     if (new_ch != NULL)
 520         ossl_qrx_inject_urxe(new_ch->qrx, e);
 521
 522     return;
 523
 524 undesirable:
 525     ossl_quic_demux_release_urxe(port->demux, e);
 526 }
 527
 528 void ossl_quic_port_set_inhibit_tick(QUIC_PORT *port, int inhibit)
 529 {
 530     port->inhibit_tick = (inhibit != 0);
 531 }
 532
 533 void ossl_quic_port_raise_net_error(QUIC_PORT *port)
 534 {
 535     QUIC_CHANNEL *ch;
 536
 537     // TODO fsm
 538
 539     LIST_FOREACH(ch, ch, &port->channel_list)
 540         ossl_quic_channel_raise_net_error(ch);
 541 }